return n.innerNetns.Close()
}

func (n *NetnsWrapper) Fd() uintptr {
	return n.innerNetns.Fd()
}

func inodeForFd(n NetnsFd) (uint64, error) {
	stats := &unix.Stat_t{}
	err := unix.Fstat(int(n.Fd()), stats)
	return stats.Ino, err
}

func OpenNetns(nspath string) (NetnsCloser, error) {
	n, err := netns.GetNS(nspath)
	if err != nil {
		return nil, err
	}
	i, err := inodeForFd(n)

			fchown(fd, uid, gid, callback) { callback(enosys()); },
			fstat(fd, callback) { callback(enosys()); },
			fsync(fd, callback) { callback(null); },
			ftruncate(fd, length, callback) { callback(enosys()); },
			lchown(path, uid, gid, callback) { callback(enosys()); },
			link(path, link, callback) { callback(enosys()); },
			lstat(path, callback) { callback(enosys()); },
			mkdir(path, perm, callback) { callback(enosys()); },

pkg syscall (freebsd-386-cgo), func ForkExec(string, []string, *ProcAttr) (int, error)
pkg syscall (freebsd-386-cgo), func Fpathconf(int, int) (int, error)
pkg syscall (freebsd-386-cgo), func Fstat(int, *Stat_t) error
pkg syscall (freebsd-386-cgo), func Fstatfs(int, *Statfs_t) error
pkg syscall (freebsd-386-cgo), func Fsync(int) error
pkg syscall (freebsd-386-cgo), func Ftruncate(int, int64) error

				Failed:          fstats.toMetric(),
				FailStats:       fstats,
				ReplicatedSize:  stat.ReplicatedSize + oldst.ReplicatedSize,
				ReplicatedCount: stat.ReplicatedCount + oldst.ReplicatedCount,
				Latency:         stat.Latency.merge(oldst.Latency),
				XferRateLrg:     &lrg,
				XferRateSml:     &sml,
			}
			totReplicatedSize += stat.ReplicatedSize
			totReplicatedCount += stat.ReplicatedCount

	defer updateOSMetrics(osMetricOpenFileDirectIO, name)(err)
	return disk.OpenFileDirectIO(name, flag, perm)
}

// Lstat captures time taken to call os.Lstat
func Lstat(name string) (info os.FileInfo, err error) {
	defer updateOSMetrics(osMetricLstat, name)(err)
	return os.Lstat(name)
}

// Remove captures time taken to call os.Remove
func Remove(deletePath string) (err error) {

		if err == nil {
			devName := ""
			diskstats, _ := bfs.ProcDiskstats()
			for _, dstat := range diskstats {
				// ignore all loop devices
				if strings.HasPrefix(dstat.DeviceName, "loop") {
					continue
				}
				if dstat.MajorNumber == info.Major && dstat.MinorNumber == info.Minor {
					devName = dstat.DeviceName
					break
				}
			}
			if devName != "" {
				info.Name = devName

pkg net/http, type File interface { Close, Read, Readdir, Seek, Stat }
pkg net/http, type File interface, Close() error
pkg net/http, type File interface, Read([]uint8) (int, error)
pkg net/http, type File interface, Readdir(int) ([]os.FileInfo, error)
pkg net/http, type File interface, Seek(int64, int) (int64, error)
pkg net/http, type File interface, Stat() (os.FileInfo, error)
pkg net/http, type FileSystem interface { Open }

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"io"
	"os"
	"syscall"
)

func access(name string) error {
	_, err := os.Lstat(name)
	return err
}

func osMkdirAll(dirPath string, perm os.FileMode, _ string) error {
	// baseDir is not honored in plan9 and solaris platforms.
	return os.MkdirAll(dirPath, perm)
}

	"syscall"
)

const (
	// Number of fields per line in /proc/mounts as per the fstab man page.
	expectedNumFieldsPerLine = 6
	// Location of the mount file to use
	procMountsPath = "/proc/mounts"
)

// IsLikelyMountPoint determines if a directory is a mountpoint.
func IsLikelyMountPoint(path string) bool {
	s1, err := os.Lstat(path)
	if err != nil {
		return false
	}

	// A symlink can never be a mount point

		if err := checkPathLength(filePath); err != nil {
			return stat, err
		}
		st, _ := Lstat(filePath)
		if st == nil {
			if !skipAccessChecks(volume) {
				// Stat a volume entry.
				if verr := Access(volumeDir); verr != nil {
					return stat, convertAccessError(verr, errVolumeAccessDenied)
				}
			}
			return stat, errPathNotFound
		}
		name, err := filepath.Rel(volumeDir, filePath)