@@ -159,7 +159,7 @@ func lookupZfsDataset(rootdir string) (string, error) {

 			continue // may fail on fuse file systems

 		}

-		if stat.Dev == wantedDev && m.Fstype == "zfs" {

+		if stat.Dev == wantedDev && m.FSType == "zfs" {

 			return m.Source, nil

 		}

 	}

@@ -69,5 +69,5 @@ var (

 	PrefixFilter      = mountinfo.PrefixFilter

 	SingleEntryFilter = mountinfo.SingleEntryFilter

 	ParentsFilter     = mountinfo.ParentsFilter

-	FstypeFilter      = mountinfo.FstypeFilter

+	FstypeFilter      = mountinfo.FSTypeFilter

 )

@@ -9,6 +9,13 @@ github.com/Microsoft/opengcs                        a10967154e143a36014584a6f664

 github.com/moby/locker                              281af2d563954745bea9d1487c965f24d30742fe # v1.0.1

 github.com/moby/term                                7f0af18e79f2784809e9cef63d0df5aa2c79d76e

+# Note that this dependency uses submodules, providing the github.com/moby/sys/mount

+# and github.com/moby/sys/mountinfo modules. Our vendoring tool (vndr) currently

+# does not support submodules / vendoring sub-paths, so we vendor the top-level

+# moby/sys repository (which contains both) and pick the most recent tag, which

+# could be either `mountinfo/vX.Y.Z` or `mount/vX.Y.Z`.

+github.com/moby/sys                                 9a75fe61baf4b9788826b48b0518abecffb79b16 # mountinfo v0.4.0

+

 github.com/creack/pty                               3a6a957789163cacdfe0e291617a1c8e80612c11 # v1.1.9

 github.com/sirupsen/logrus                          6699a89a232f3db797f2e280639854bbc4b89725 # v1.7.0

 github.com/tchap/go-patricia                        a7f0089c6f496e8e70402f61733606daa326cac5 # v2.3.0

@@ -16,7 +23,6 @@ golang.org/x/net                                    ab34263943818b32f575efc978a3

 golang.org/x/sys                                    aee5d888a86055dc6ab0342f9cdc7b53aaeaec62

 github.com/docker/go-units                          519db1ee28dcc9fd2474ae59fca29a810482bfb1 # v0.4.0

 github.com/docker/go-connections                    7395e3f8aa162843a74ed6d48e79627d9792ac55 # v0.4.0

-github.com/moby/sys                                 6154f11e6840c0d6b0dbb23f4125a6134b3013c9 # mountinfo/v0.1.3

 golang.org/x/text                                   23ae387dee1f90d29a23c0e87ee0b46038fbed0e # v0.3.3

 gotest.tools/v3                                     bb0d8a963040ea5048dcef1a14d8f8b58a33d4b3 # v3.0.2

 github.com/google/go-cmp                            3af367b6b30c263d47e8895973edcca9a49cf029 # v0.2.0

new file mode 100644

@@ -0,0 +1,4 @@

+// Package mount provides a set of functions to mount and unmount mounts.

+//

+// Currently it supports Linux. For historical reasons, there is also some support for FreeBSD.

+package mount

deleted file mode 100644

@@ -1,137 +0,0 @@

-package mount

-

-import (

-	"fmt"

-	"strings"

-)

-

-var flags = map[string]struct {

-	clear bool

-	flag  int

-}{

-	"defaults":      {false, 0},

-	"ro":            {false, RDONLY},

-	"rw":            {true, RDONLY},

-	"suid":          {true, NOSUID},

-	"nosuid":        {false, NOSUID},

-	"dev":           {true, NODEV},

-	"nodev":         {false, NODEV},

-	"exec":          {true, NOEXEC},

-	"noexec":        {false, NOEXEC},

-	"sync":          {false, SYNCHRONOUS},

-	"async":         {true, SYNCHRONOUS},

-	"dirsync":       {false, DIRSYNC},

-	"remount":       {false, REMOUNT},

-	"mand":          {false, MANDLOCK},

-	"nomand":        {true, MANDLOCK},

-	"atime":         {true, NOATIME},

-	"noatime":       {false, NOATIME},

-	"diratime":      {true, NODIRATIME},

-	"nodiratime":    {false, NODIRATIME},

-	"bind":          {false, BIND},

-	"rbind":         {false, RBIND},

-	"unbindable":    {false, UNBINDABLE},

-	"runbindable":   {false, RUNBINDABLE},

-	"private":       {false, PRIVATE},

-	"rprivate":      {false, RPRIVATE},

-	"shared":        {false, SHARED},

-	"rshared":       {false, RSHARED},

-	"slave":         {false, SLAVE},

-	"rslave":        {false, RSLAVE},

-	"relatime":      {false, RELATIME},

-	"norelatime":    {true, RELATIME},

-	"strictatime":   {false, STRICTATIME},

-	"nostrictatime": {true, STRICTATIME},

-}

-

-var validFlags = map[string]bool{

-	"":          true,

-	"size":      true,

-	"mode":      true,

-	"uid":       true,

-	"gid":       true,

-	"nr_inodes": true,

-	"nr_blocks": true,

-	"mpol":      true,

-}

-

-var propagationFlags = map[string]bool{

-	"bind":        true,

-	"rbind":       true,

-	"unbindable":  true,

-	"runbindable": true,

-	"private":     true,

-	"rprivate":    true,

-	"shared":      true,

-	"rshared":     true,

-	"slave":       true,

-	"rslave":      true,

-}

-

-// MergeTmpfsOptions merge mount options to make sure there is no duplicate.

-func MergeTmpfsOptions(options []string) ([]string, error) {

-	// We use collisions maps to remove duplicates.

-	// For flag, the key is the flag value (the key for propagation flag is -1)

-	// For data=value, the key is the data

-	flagCollisions := map[int]bool{}

-	dataCollisions := map[string]bool{}

-

-	var newOptions []string

-	// We process in reverse order

-	for i := len(options) - 1; i >= 0; i-- {

-		option := options[i]

-		if option == "defaults" {

-			continue

-		}

-		if f, ok := flags[option]; ok && f.flag != 0 {

-			// There is only one propagation mode

-			key := f.flag

-			if propagationFlags[option] {

-				key = -1

-			}

-			// Check to see if there is collision for flag

-			if !flagCollisions[key] {

-				// We prepend the option and add to collision map

-				newOptions = append([]string{option}, newOptions...)

-				flagCollisions[key] = true

-			}

-			continue

-		}

-		opt := strings.SplitN(option, "=", 2)

-		if len(opt) != 2 || !validFlags[opt[0]] {

-			return nil, fmt.Errorf("Invalid tmpfs option %q", opt)

-		}

-		if !dataCollisions[opt[0]] {

-			// We prepend the option and add to collision map

-			newOptions = append([]string{option}, newOptions...)

-			dataCollisions[opt[0]] = true

-		}

-	}

-

-	return newOptions, nil

-}

-

-// Parse fstab type mount options into mount() flags

-// and device specific data

-func parseOptions(options string) (int, string) {

-	var (

-		flag int

-		data []string

-	)

-

-	for _, o := range strings.Split(options, ",") {

-		// If the option does not exist in the flags table or the flag

-		// is not supported on the platform,

-		// then it is a data value for a specific fs type

-		if f, exists := flags[o]; exists && f.flag != 0 {

-			if f.clear {

-				flag &= ^f.flag

-			} else {

-				flag |= f.flag

-			}

-		} else {

-			data = append(data, o)

-		}

-	}

-	return flag, strings.Join(data, ",")

-}

new file mode 100644

@@ -0,0 +1,45 @@

+// +build freebsd openbsd

+

+package mount

+

+import "golang.org/x/sys/unix"

+

+const (

+	// RDONLY will mount the filesystem as read-only.

+	RDONLY = unix.MNT_RDONLY

+

+	// NOSUID will not allow set-user-identifier or set-group-identifier bits to

+	// take effect.

+	NOSUID = unix.MNT_NOSUID

+

+	// NOEXEC will not allow execution of any binaries on the mounted file system.

+	NOEXEC = unix.MNT_NOEXEC

+

+	// SYNCHRONOUS will allow any I/O to the file system to be done synchronously.

+	SYNCHRONOUS = unix.MNT_SYNCHRONOUS

+

+	// NOATIME will not update the file access time when reading from a file.

+	NOATIME = unix.MNT_NOATIME

+)

+

+// These flags are unsupported.

+const (

+	BIND        = 0

+	DIRSYNC     = 0

+	MANDLOCK    = 0

+	NODEV       = 0

+	NODIRATIME  = 0

+	UNBINDABLE  = 0

+	RUNBINDABLE = 0

+	PRIVATE     = 0

+	RPRIVATE    = 0

+	SHARED      = 0

+	RSHARED     = 0

+	SLAVE       = 0

+	RSLAVE      = 0

+	RBIND       = 0

+	RELATIME    = 0

+	REMOUNT     = 0

+	STRICTATIME = 0

+	mntDetach   = 0

+)

deleted file mode 100644

@@ -1,48 +0,0 @@

-// +build freebsd,cgo

-

-package mount

-

-/*

-#include <sys/mount.h>

-*/

-import "C"

-

-const (

-	// RDONLY will mount the filesystem as read-only.

-	RDONLY = C.MNT_RDONLY

-

-	// NOSUID will not allow set-user-identifier or set-group-identifier bits to

-	// take effect.

-	NOSUID = C.MNT_NOSUID

-

-	// NOEXEC will not allow execution of any binaries on the mounted file system.

-	NOEXEC = C.MNT_NOEXEC

-

-	// SYNCHRONOUS will allow any I/O to the file system to be done synchronously.

-	SYNCHRONOUS = C.MNT_SYNCHRONOUS

-

-	// NOATIME will not update the file access time when reading from a file.

-	NOATIME = C.MNT_NOATIME

-)

-

-// These flags are unsupported.

-const (

-	BIND        = 0

-	DIRSYNC     = 0

-	MANDLOCK    = 0

-	NODEV       = 0

-	NODIRATIME  = 0

-	UNBINDABLE  = 0

-	RUNBINDABLE = 0

-	PRIVATE     = 0

-	RPRIVATE    = 0

-	SHARED      = 0

-	RSHARED     = 0

-	SLAVE       = 0

-	RSLAVE      = 0

-	RBIND       = 0

-	RELATIME    = 0

-	REMOUNT     = 0

-	STRICTATIME = 0

-	mntDetach   = 0

-)

new file mode 100644

@@ -0,0 +1,139 @@

+// +build !darwin,!windows

+

+package mount

+

+import (

+	"fmt"

+	"strings"

+)

+

+var flags = map[string]struct {

+	clear bool

+	flag  int

+}{

+	"defaults":      {false, 0},

+	"ro":            {false, RDONLY},

+	"rw":            {true, RDONLY},

+	"suid":          {true, NOSUID},

+	"nosuid":        {false, NOSUID},

+	"dev":           {true, NODEV},

+	"nodev":         {false, NODEV},

+	"exec":          {true, NOEXEC},

+	"noexec":        {false, NOEXEC},

+	"sync":          {false, SYNCHRONOUS},

+	"async":         {true, SYNCHRONOUS},

+	"dirsync":       {false, DIRSYNC},

+	"remount":       {false, REMOUNT},

+	"mand":          {false, MANDLOCK},

+	"nomand":        {true, MANDLOCK},

+	"atime":         {true, NOATIME},

+	"noatime":       {false, NOATIME},

+	"diratime":      {true, NODIRATIME},

+	"nodiratime":    {false, NODIRATIME},

+	"bind":          {false, BIND},

+	"rbind":         {false, RBIND},

+	"unbindable":    {false, UNBINDABLE},

+	"runbindable":   {false, RUNBINDABLE},

+	"private":       {false, PRIVATE},

+	"rprivate":      {false, RPRIVATE},

+	"shared":        {false, SHARED},

+	"rshared":       {false, RSHARED},

+	"slave":         {false, SLAVE},

+	"rslave":        {false, RSLAVE},

+	"relatime":      {false, RELATIME},

+	"norelatime":    {true, RELATIME},

+	"strictatime":   {false, STRICTATIME},

+	"nostrictatime": {true, STRICTATIME},

+}

+

+var validFlags = map[string]bool{

+	"":          true,

+	"size":      true,

+	"mode":      true,

+	"uid":       true,

+	"gid":       true,

+	"nr_inodes": true,

+	"nr_blocks": true,

+	"mpol":      true,

+}

+

+var propagationFlags = map[string]bool{

+	"bind":        true,

+	"rbind":       true,

+	"unbindable":  true,

+	"runbindable": true,

+	"private":     true,

+	"rprivate":    true,

+	"shared":      true,

+	"rshared":     true,

+	"slave":       true,

+	"rslave":      true,

+}

+

+// MergeTmpfsOptions merge mount options to make sure there is no duplicate.

+func MergeTmpfsOptions(options []string) ([]string, error) {

+	// We use collisions maps to remove duplicates.

+	// For flag, the key is the flag value (the key for propagation flag is -1)

+	// For data=value, the key is the data

+	flagCollisions := map[int]bool{}

+	dataCollisions := map[string]bool{}

+

+	var newOptions []string

+	// We process in reverse order

+	for i := len(options) - 1; i >= 0; i-- {

+		option := options[i]

+		if option == "defaults" {

+			continue

+		}

+		if f, ok := flags[option]; ok && f.flag != 0 {

+			// There is only one propagation mode

+			key := f.flag

+			if propagationFlags[option] {

+				key = -1

+			}

+			// Check to see if there is collision for flag

+			if !flagCollisions[key] {

+				// We prepend the option and add to collision map

+				newOptions = append([]string{option}, newOptions...)

+				flagCollisions[key] = true

+			}

+			continue

+		}

+		opt := strings.SplitN(option, "=", 2)

+		if len(opt) != 2 || !validFlags[opt[0]] {

+			return nil, fmt.Errorf("Invalid tmpfs option %q", opt)

+		}

+		if !dataCollisions[opt[0]] {

+			// We prepend the option and add to collision map

+			newOptions = append([]string{option}, newOptions...)

+			dataCollisions[opt[0]] = true

+		}

+	}

+

+	return newOptions, nil

+}

+

+// Parse fstab type mount options into mount() flags

+// and device specific data

+func parseOptions(options string) (int, string) {

+	var (

+		flag int

+		data []string

+	)

+

+	for _, o := range strings.Split(options, ",") {

+		// If the option does not exist in the flags table or the flag

+		// is not supported on the platform,

+		// then it is a data value for a specific fs type

+		if f, exists := flags[o]; exists && f.flag != 0 {

+			if f.clear {

+				flag &= ^f.flag

+			} else {

+				flag |= f.flag

+			}

+		} else {

+			data = append(data, o)

+		}

+	}

+	return flag, strings.Join(data, ",")

+}

deleted file mode 100644

@@ -1,30 +0,0 @@

-// +build !linux,!freebsd freebsd,!cgo

-

-package mount

-

-// These flags are unsupported.

-const (

-	BIND        = 0

-	DIRSYNC     = 0

-	MANDLOCK    = 0

-	NOATIME     = 0

-	NODEV       = 0

-	NODIRATIME  = 0

-	NOEXEC      = 0

-	NOSUID      = 0

-	UNBINDABLE  = 0

-	RUNBINDABLE = 0

-	PRIVATE     = 0

-	RPRIVATE    = 0

-	SHARED      = 0

-	RSHARED     = 0

-	SLAVE       = 0

-	RSLAVE      = 0

-	RBIND       = 0

-	RELATIME    = 0

-	REMOUNT     = 0

-	STRICTATIME = 0

-	SYNCHRONOUS = 0

-	RDONLY      = 0

-	mntDetach   = 0

-)

@@ -3,6 +3,6 @@ module github.com/moby/sys/mount

 go 1.14

 require (

-	github.com/moby/sys/mountinfo v0.1.0

-	golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae

+	github.com/moby/sys/mountinfo v0.3.1

+	golang.org/x/sys v0.0.0-20200922070232-aee5d888a860

 )

deleted file mode 100644

@@ -1,56 +0,0 @@

-// +build go1.13

-

-package mount

-

-import (

-	"fmt"

-	"sort"

-

-	"github.com/moby/sys/mountinfo"

-)

-

-// Mount will mount filesystem according to the specified configuration.

-// Options must be specified like the mount or fstab unix commands:

-// "opt1=val1,opt2=val2". See flags.go for supported option flags.

-func Mount(device, target, mType, options string) error {

-	flag, data := parseOptions(options)

-	return mount(device, target, mType, uintptr(flag), data)

-}

-

-// Unmount lazily unmounts a filesystem on supported platforms, otherwise

-// does a normal unmount.

-func Unmount(target string) error {

-	return unmount(target, mntDetach)

-}

-

-// RecursiveUnmount unmounts the target and all mounts underneath, starting with

-// the deepsest mount first.

-func RecursiveUnmount(target string) error {

-	mounts, err := mountinfo.GetMounts(mountinfo.PrefixFilter(target))

-	if err != nil {

-		return err

-	}

-

-	// Make the deepest mount be first

-	sort.Slice(mounts, func(i, j int) bool {

-		return len(mounts[i].Mountpoint) > len(mounts[j].Mountpoint)

-	})

-

-	var suberr error

-	for i, m := range mounts {

-		err = unmount(m.Mountpoint, mntDetach)

-		if err != nil {

-			if i == len(mounts)-1 { // last mount

-				return fmt.Errorf("%w (possible cause: %s)", err, suberr)

-			}

-			// This is a submount, we can ignore the error for now,

-			// the final unmount will fail if this is a real problem.

-			// With that in mind, the _first_ failed unmount error

-			// might be the real error cause, so let's keep it.

-			if suberr == nil {

-				suberr = err

-			}

-		}

-	}

-	return nil

-}

new file mode 100644

@@ -0,0 +1,87 @@

+// +build !darwin,!windows

+

+package mount

+

+import (

+	"fmt"

+	"sort"

+

+	"github.com/moby/sys/mountinfo"

+	"golang.org/x/sys/unix"

+)

+

+// Mount will mount filesystem according to the specified configuration.

+// Options must be specified like the mount or fstab unix commands:

+// "opt1=val1,opt2=val2". See flags.go for supported option flags.

+func Mount(device, target, mType, options string) error {

+	flag, data := parseOptions(options)

+	return mount(device, target, mType, uintptr(flag), data)

+}

+

+// Unmount lazily unmounts a filesystem on supported platforms, otherwise does

+// a normal unmount. If target is not a mount point, no error is returned.

+func Unmount(target string) error {

+	err := unix.Unmount(target, mntDetach)

+	if err == nil || err == unix.EINVAL {

+		// Ignore "not mounted" error here. Note the same error

+		// can be returned if flags are invalid, so this code

+		// assumes that the flags value is always correct.

+		return nil

+	}

+

+	return &mountError{

+		op:     "umount",

+		target: target,

+		flags:  uintptr(mntDetach),

+		err:    err,

+	}

+}

+

+// RecursiveUnmount unmounts the target and all mounts underneath, starting

+// with the deepest mount first. The argument does not have to be a mount

+// point itself.

+func RecursiveUnmount(target string) error {

+	// Fast path, works if target is a mount point that can be unmounted.

+	// On Linux, mntDetach flag ensures a recursive unmount.  For other

+	// platforms, if there are submounts, we'll get EBUSY (and fall back

+	// to the slow path). NOTE we do not ignore EINVAL here as target might

+	// not be a mount point itself (but there can be mounts underneath).

+	if err := unix.Unmount(target, mntDetach); err == nil {

+		return nil

+	}

+

+	// Slow path: get all submounts, sort, unmount one by one.

+	mounts, err := mountinfo.GetMounts(mountinfo.PrefixFilter(target))

+	if err != nil {

+		return err

+	}

+

+	// Make the deepest mount be first

+	sort.Slice(mounts, func(i, j int) bool {

+		return len(mounts[i].Mountpoint) > len(mounts[j].Mountpoint)

+	})

+

+	var (

+		suberr    error

+		lastMount = len(mounts) - 1

+	)

+	for i, m := range mounts {

+		err = Unmount(m.Mountpoint)

+		if err != nil {

+			if i == lastMount {

+				if suberr != nil {

+					return fmt.Errorf("%w (possible cause: %s)", err, suberr)

+				}

+				return err

+			}

+			// This is a submount, we can ignore the error for now,

+			// the final unmount will fail if this is a real problem.

+			// With that in mind, the _first_ failed unmount error

+			// might be the real error cause, so let's keep it.

+			if suberr == nil {

+				suberr = err

+			}

+		}

+	}

+	return nil

+}

new file mode 100644

@@ -0,0 +1,61 @@

+// +build freebsd,cgo openbsd,cgo

+

+package mount

+

+/*

+#include <errno.h>

+#include <stdlib.h>

+#include <string.h>

+#include <sys/_iovec.h>

+#include <sys/mount.h>

+#include <sys/param.h>

+*/

+import "C"

+

+import (

+	"strings"

+	"syscall"

+	"unsafe"

+)

+

+func allocateIOVecs(options []string) []C.struct_iovec {

+	out := make([]C.struct_iovec, len(options))

+	for i, option := range options {

+		out[i].iov_base = unsafe.Pointer(C.CString(option))

+		out[i].iov_len = C.size_t(len(option) + 1)

+	}

+	return out

+}

+

+func mount(device, target, mType string, flag uintptr, data string) error {

+	isNullFS := false

+

+	xs := strings.Split(data, ",")

+	for _, x := range xs {

+		if x == "bind" {

+			isNullFS = true

+		}

+	}

+

+	options := []string{"fspath", target}

+	if isNullFS {

+		options = append(options, "fstype", "nullfs", "target", device)

+	} else {

+		options = append(options, "fstype", mType, "from", device)

+	}

+	rawOptions := allocateIOVecs(options)

+	for _, rawOption := range rawOptions {

+		defer C.free(rawOption.iov_base)

+	}

+

+	if errno := C.nmount(&rawOptions[0], C.uint(len(options)), C.int(flag)); errno != 0 {

+		return &mountError{

+			op:     "mount",

+			source: device,

+			target: target,

+			flags:  flag,

+			err:    syscall.Errno(errno),

+		}

+	}

+	return nil

+}

deleted file mode 100644

@@ -1,59 +0,0 @@

-package mount

-

-/*

-#include <errno.h>

-#include <stdlib.h>

-#include <string.h>

-#include <sys/_iovec.h>

-#include <sys/mount.h>

-#include <sys/param.h>

-*/

-import "C"

-

-import (

-	"strings"

-	"syscall"

-	"unsafe"

-)

-

-func allocateIOVecs(options []string) []C.struct_iovec {

-	out := make([]C.struct_iovec, len(options))

-	for i, option := range options {

-		out[i].iov_base = unsafe.Pointer(C.CString(option))

-		out[i].iov_len = C.size_t(len(option) + 1)

-	}

-	return out

-}

-

-func mount(device, target, mType string, flag uintptr, data string) error {

-	isNullFS := false

-

-	xs := strings.Split(data, ",")

-	for _, x := range xs {

-		if x == "bind" {

-			isNullFS = true

-		}

-	}

-

-	options := []string{"fspath", target}

-	if isNullFS {

-		options = append(options, "fstype", "nullfs", "target", device)

-	} else {

-		options = append(options, "fstype", mType, "from", device)

-	}

-	rawOptions := allocateIOVecs(options)

-	for _, rawOption := range rawOptions {

-		defer C.free(rawOption.iov_base)

-	}

-

-	if errno := C.nmount(&rawOptions[0], C.uint(len(options)), C.int(flag)); errno != 0 {

-		return &mountError{

-			op:     "mount",

-			source: device,

-			target: target,

-			flags:  flag,

-			err:    syscall.Errno(errno),

-		}

-	}

-	return nil

-}

@@ -1,7 +1,7 @@

-// +build !linux,!freebsd freebsd,!cgo

+// +build !linux,!freebsd,!openbsd,!windows freebsd,!cgo openbsd,!cgo

 package mount

 func mount(device, target, mType string, flag uintptr, data string) error {

-	panic("Not implemented")

+	panic("cgo required on freebsd and openbsd")

 }

deleted file mode 100644

@@ -1,22 +0,0 @@

-// +build !windows

-

-package mount

-

-import "golang.org/x/sys/unix"

-

-func unmount(target string, flags int) error {

-	err := unix.Unmount(target, flags)

-	if err == nil || err == unix.EINVAL {

-		// Ignore "not mounted" error here. Note the same error

-		// can be returned if flags are invalid, so this code

-		// assumes that the flags value is always correct.

-		return nil

-	}

-

-	return &mountError{

-		op:     "umount",

-		target: target,

-		flags:  uintptr(flags),

-		err:    err,

-	}

-}

deleted file mode 100644

@@ -1,7 +0,0 @@

-// +build windows

-

-package mount

-

-func unmount(target string, flag int) error {

-	panic("Not implemented")

-}

new file mode 100644

@@ -0,0 +1,44 @@

+// Package mountinfo provides a set of functions to retrieve information about OS mounts.

+//

+// Currently it supports Linux. For historical reasons, there is also some support for FreeBSD and OpenBSD,

+// and a shallow implementation for Windows, but in general this is Linux-only package, so

+// the rest of the document only applies to Linux, unless explicitly specified otherwise.

+//

+// In Linux, information about mounts seen by the current process is available from

+// /proc/self/mountinfo. Note that due to mount namespaces, different processes can

+// see different mounts. A per-process mountinfo table is available from /proc/<PID>/mountinfo,

+// where <PID> is a numerical process identifier.

+//

+// In general, /proc is not a very efficient interface, and mountinfo is not an exception.

+// For example, there is no way to get information about a specific mount point (i.e. it

+// is all-or-nothing). This package tries to hide the /proc ineffectiveness by using

+// parse filters while reading mountinfo. A filter can skip some entries, or stop

+// processing the rest of the file once the needed information is found.

+//

+// For mountinfo filters that accept path as an argument, the path must be absolute,

+// having all symlinks resolved, and being cleaned (i.e. no extra slashes or dots).

+// One way to achieve all of the above is to employ filepath.Abs followed by

+// filepath.EvalSymlinks (the latter calls filepath.Clean on the result so

+// there is no need to explicitly call filepath.Clean).

+//

+// NOTE that in many cases there is no need to consult mountinfo at all. Here are some

+// of the cases where mountinfo should not be parsed:

+//

+// 1. Before performing a mount. Usually, this is not needed, but if required (say to

+// prevent over-mounts), to check whether a directory is mounted, call os.Lstat

+// on it and its parent directory, and compare their st.Sys().(*syscall.Stat_t).Dev

+// fields -- if they differ, then the directory is the mount point. NOTE this does

+// not work for bind mounts. Optionally, the filesystem type can also be checked

+// by calling unix.Statfs and checking the Type field (i.e. filesystem type).

+//

+// 2. After performing a mount. If there is no error returned, the mount succeeded;

+// checking the mount table for a new mount is redundant and expensive.

+//

+// 3. Before performing an unmount. It is more efficient to do an unmount and ignore

+// a specific error (EINVAL) which tells the directory is not mounted.

+//

+// 4. After performing an unmount. If there is no error returned, the unmount succeeded.

+//

+// 5. To find the mount point root of a specific directory. You can perform os.Stat()

+// on the directory and traverse up until the Dev field of a parent directory differs.

+package mountinfo

@@ -1,3 +1,5 @@

 module github.com/moby/sys/mountinfo

 go 1.14

+

+require golang.org/x/sys v0.0.0-20200909081042-eff7692f9009

new file mode 100644

@@ -0,0 +1,58 @@

+package mountinfo

+

+import (

+	"os"

+	"path/filepath"

+

+	"golang.org/x/sys/unix"

+)

+

+// mountedByOpenat2 is a method of detecting a mount that works for all kinds

+// of mounts (incl. bind mounts), but requires a recent (v5.6+) linux kernel.

+func mountedByOpenat2(path string) (bool, error) {