@@ -16,6 +16,7 @@ golang.org/x/net                                    0de0cce0169b09b364e001f108dc

 golang.org/x/sys                                    d5e6a3e2c0ae16fc7480523ebcb7fd4dd3215489

 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                                   342b2e1fbaa52c93f31447ad2c6abc048c63e475 # v0.3.2

 gotest.tools/v3                                     bb0d8a963040ea5048dcef1a14d8f8b58a33d4b3 # v3.0.2

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

new file mode 100644

@@ -0,0 +1,202 @@

+

+                                 Apache License

+                           Version 2.0, January 2004

+                        http://www.apache.org/licenses/

+

+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+

+   1. Definitions.

+

+      "License" shall mean the terms and conditions for use, reproduction,

+      and distribution as defined by Sections 1 through 9 of this document.

+

+      "Licensor" shall mean the copyright owner or entity authorized by

+      the copyright owner that is granting the License.

+

+      "Legal Entity" shall mean the union of the acting entity and all

+      other entities that control, are controlled by, or are under common

+      control with that entity. For the purposes of this definition,

+      "control" means (i) the power, direct or indirect, to cause the

+      direction or management of such entity, whether by contract or

+      otherwise, or (ii) ownership of fifty percent (50%) or more of the

+      outstanding shares, or (iii) beneficial ownership of such entity.

+

+      "You" (or "Your") shall mean an individual or Legal Entity

+      exercising permissions granted by this License.

+

+      "Source" form shall mean the preferred form for making modifications,

+      including but not limited to software source code, documentation

+      source, and configuration files.

+

+      "Object" form shall mean any form resulting from mechanical

+      transformation or translation of a Source form, including but

+      not limited to compiled object code, generated documentation,

+      and conversions to other media types.

+

+      "Work" shall mean the work of authorship, whether in Source or

+      Object form, made available under the License, as indicated by a

+      copyright notice that is included in or attached to the work

+      (an example is provided in the Appendix below).

+

+      "Derivative Works" shall mean any work, whether in Source or Object

+      form, that is based on (or derived from) the Work and for which the

+      editorial revisions, annotations, elaborations, or other modifications

+      represent, as a whole, an original work of authorship. For the purposes

+      of this License, Derivative Works shall not include works that remain

+      separable from, or merely link (or bind by name) to the interfaces of,

+      the Work and Derivative Works thereof.

+

+      "Contribution" shall mean any work of authorship, including

+      the original version of the Work and any modifications or additions

+      to that Work or Derivative Works thereof, that is intentionally

+      submitted to Licensor for inclusion in the Work by the copyright owner

+      or by an individual or Legal Entity authorized to submit on behalf of

+      the copyright owner. For the purposes of this definition, "submitted"

+      means any form of electronic, verbal, or written communication sent

+      to the Licensor or its representatives, including but not limited to

+      communication on electronic mailing lists, source code control systems,

+      and issue tracking systems that are managed by, or on behalf of, the

+      Licensor for the purpose of discussing and improving the Work, but

+      excluding communication that is conspicuously marked or otherwise

+      designated in writing by the copyright owner as "Not a Contribution."

+

+      "Contributor" shall mean Licensor and any individual or Legal Entity

+      on behalf of whom a Contribution has been received by Licensor and

+      subsequently incorporated within the Work.

+

+   2. Grant of Copyright License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      copyright license to reproduce, prepare Derivative Works of,

+      publicly display, publicly perform, sublicense, and distribute the

+      Work and such Derivative Works in Source or Object form.

+

+   3. Grant of Patent License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      (except as stated in this section) patent license to make, have made,

+      use, offer to sell, sell, import, and otherwise transfer the Work,

+      where such license applies only to those patent claims licensable

+      by such Contributor that are necessarily infringed by their

+      Contribution(s) alone or by combination of their Contribution(s)

+      with the Work to which such Contribution(s) was submitted. If You

+      institute patent litigation against any entity (including a

+      cross-claim or counterclaim in a lawsuit) alleging that the Work

+      or a Contribution incorporated within the Work constitutes direct

+      or contributory patent infringement, then any patent licenses

+      granted to You under this License for that Work shall terminate

+      as of the date such litigation is filed.

+

+   4. Redistribution. You may reproduce and distribute copies of the

+      Work or Derivative Works thereof in any medium, with or without

+      modifications, and in Source or Object form, provided that You

+      meet the following conditions:

+

+      (a) You must give any other recipients of the Work or

+          Derivative Works a copy of this License; and

+

+      (b) You must cause any modified files to carry prominent notices

+          stating that You changed the files; and

+

+      (c) You must retain, in the Source form of any Derivative Works

+          that You distribute, all copyright, patent, trademark, and

+          attribution notices from the Source form of the Work,

+          excluding those notices that do not pertain to any part of

+          the Derivative Works; and

+

+      (d) If the Work includes a "NOTICE" text file as part of its

+          distribution, then any Derivative Works that You distribute must

+          include a readable copy of the attribution notices contained

+          within such NOTICE file, excluding those notices that do not

+          pertain to any part of the Derivative Works, in at least one

+          of the following places: within a NOTICE text file distributed

+          as part of the Derivative Works; within the Source form or

+          documentation, if provided along with the Derivative Works; or,

+          within a display generated by the Derivative Works, if and

+          wherever such third-party notices normally appear. The contents

+          of the NOTICE file are for informational purposes only and

+          do not modify the License. You may add Your own attribution

+          notices within Derivative Works that You distribute, alongside

+          or as an addendum to the NOTICE text from the Work, provided

+          that such additional attribution notices cannot be construed

+          as modifying the License.

+

+      You may add Your own copyright statement to Your modifications and

+      may provide additional or different license terms and conditions

+      for use, reproduction, or distribution of Your modifications, or

+      for any such Derivative Works as a whole, provided Your use,

+      reproduction, and distribution of the Work otherwise complies with

+      the conditions stated in this License.

+

+   5. Submission of Contributions. Unless You explicitly state otherwise,

+      any Contribution intentionally submitted for inclusion in the Work

+      by You to the Licensor shall be under the terms and conditions of

+      this License, without any additional terms or conditions.

+      Notwithstanding the above, nothing herein shall supersede or modify

+      the terms of any separate license agreement you may have executed

+      with Licensor regarding such Contributions.

+

+   6. Trademarks. This License does not grant permission to use the trade

+      names, trademarks, service marks, or product names of the Licensor,

+      except as required for reasonable and customary use in describing the

+      origin of the Work and reproducing the content of the NOTICE file.

+

+   7. Disclaimer of Warranty. Unless required by applicable law or

+      agreed to in writing, Licensor provides the Work (and each

+      Contributor provides its Contributions) on an "AS IS" BASIS,

+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

+      implied, including, without limitation, any warranties or conditions

+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

+      PARTICULAR PURPOSE. You are solely responsible for determining the

+      appropriateness of using or redistributing the Work and assume any

+      risks associated with Your exercise of permissions under this License.

+

+   8. Limitation of Liability. In no event and under no legal theory,

+      whether in tort (including negligence), contract, or otherwise,

+      unless required by applicable law (such as deliberate and grossly

+      negligent acts) or agreed to in writing, shall any Contributor be

+      liable to You for damages, including any direct, indirect, special,

+      incidental, or consequential damages of any character arising as a

+      result of this License or out of the use or inability to use the

+      Work (including but not limited to damages for loss of goodwill,

+      work stoppage, computer failure or malfunction, or any and all

+      other commercial damages or losses), even if such Contributor

+      has been advised of the possibility of such damages.

+

+   9. Accepting Warranty or Additional Liability. While redistributing

+      the Work or Derivative Works thereof, You may choose to offer,

+      and charge a fee for, acceptance of support, warranty, indemnity,

+      or other liability obligations and/or rights consistent with this

+      License. However, in accepting such obligations, You may act only

+      on Your own behalf and on Your sole responsibility, not on behalf

+      of any other Contributor, and only if You agree to indemnify,

+      defend, and hold each Contributor harmless for any liability

+      incurred by, or claims asserted against, such Contributor by reason

+      of your accepting any such warranty or additional liability.

+

+   END OF TERMS AND CONDITIONS

+

+   APPENDIX: How to apply the Apache License to your work.

+

+      To apply the Apache License to your work, attach the following

+      boilerplate notice, with the fields enclosed by brackets "[]"

+      replaced with your own identifying information. (Don't include

+      the brackets!)  The text should be enclosed in the appropriate

+      comment syntax for the file format. We also recommend that a

+      file or class name and description of purpose be included on the

+      same "printed page" as the copyright notice for easier

+      identification within third-party archives.

+

+   Copyright [yyyy] [name of copyright owner]

+

+   Licensed under the Apache License, Version 2.0 (the "License");

+   you may not use this file except in compliance with the License.

+   You may obtain a copy of the License at

+

+       http://www.apache.org/licenses/LICENSE-2.0

+

+   Unless required by applicable law or agreed to in writing, software

+   distributed under the License is distributed on an "AS IS" BASIS,

+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+   See the License for the specific language governing permissions and

+   limitations under the License.

new file mode 100644

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

+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,48 @@

+// +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,87 @@

+package mount

+

+import (

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

+)

+

+const (

+	// RDONLY will mount the file system read-only.

+	RDONLY = unix.MS_RDONLY

+

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

+	// take effect.

+	NOSUID = unix.MS_NOSUID

+

+	// NODEV will not interpret character or block special devices on the file

+	// system.

+	NODEV = unix.MS_NODEV

+

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

+	NOEXEC = unix.MS_NOEXEC

+

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

+	SYNCHRONOUS = unix.MS_SYNCHRONOUS

+

+	// DIRSYNC will force all directory updates within the file system to be done

+	// synchronously. This affects the following system calls: create, link,

+	// unlink, symlink, mkdir, rmdir, mknod and rename.

+	DIRSYNC = unix.MS_DIRSYNC

+

+	// REMOUNT will attempt to remount an already-mounted file system. This is

+	// commonly used to change the mount flags for a file system, especially to

+	// make a readonly file system writeable. It does not change device or mount

+	// point.

+	REMOUNT = unix.MS_REMOUNT

+

+	// MANDLOCK will force mandatory locks on a filesystem.

+	MANDLOCK = unix.MS_MANDLOCK

+

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

+	NOATIME = unix.MS_NOATIME

+

+	// NODIRATIME will not update the directory access time.

+	NODIRATIME = unix.MS_NODIRATIME

+

+	// BIND remounts a subtree somewhere else.

+	BIND = unix.MS_BIND

+

+	// RBIND remounts a subtree and all possible submounts somewhere else.

+	RBIND = unix.MS_BIND | unix.MS_REC

+

+	// UNBINDABLE creates a mount which cannot be cloned through a bind operation.

+	UNBINDABLE = unix.MS_UNBINDABLE

+

+	// RUNBINDABLE marks the entire mount tree as UNBINDABLE.

+	RUNBINDABLE = unix.MS_UNBINDABLE | unix.MS_REC

+

+	// PRIVATE creates a mount which carries no propagation abilities.

+	PRIVATE = unix.MS_PRIVATE

+

+	// RPRIVATE marks the entire mount tree as PRIVATE.

+	RPRIVATE = unix.MS_PRIVATE | unix.MS_REC

+

+	// SLAVE creates a mount which receives propagation from its master, but not

+	// vice versa.

+	SLAVE = unix.MS_SLAVE

+

+	// RSLAVE marks the entire mount tree as SLAVE.

+	RSLAVE = unix.MS_SLAVE | unix.MS_REC

+

+	// SHARED creates a mount which provides the ability to create mirrors of

+	// that mount such that mounts and unmounts within any of the mirrors

+	// propagate to the other mirrors.

+	SHARED = unix.MS_SHARED

+

+	// RSHARED marks the entire mount tree as SHARED.

+	RSHARED = unix.MS_SHARED | unix.MS_REC

+

+	// RELATIME updates inode access times relative to modify or change time.

+	RELATIME = unix.MS_RELATIME

+

+	// STRICTATIME allows to explicitly request full atime updates.  This makes

+	// it possible for the kernel to default to relatime or noatime but still

+	// allow userspace to override it.

+	STRICTATIME = unix.MS_STRICTATIME

+

+	mntDetach = unix.MNT_DETACH

+)

new file mode 100644

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

+// +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

+)

new file mode 100644

@@ -0,0 +1,8 @@

+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

+)

new file mode 100644

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

+// +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,46 @@

+// +build !windows

+

+package mount

+

+import "strconv"

+

+// mountError records an error from mount or unmount operation

+type mountError struct {

+	op             string

+	source, target string

+	flags          uintptr

+	data           string

+	err            error

+}

+

+func (e *mountError) Error() string {

+	out := e.op + " "

+

+	if e.source != "" {

+		out += e.source + ":" + e.target

+	} else {

+		out += e.target

+	}

+

+	if e.flags != uintptr(0) {

+		out += ", flags: 0x" + strconv.FormatUint(uint64(e.flags), 16)

+	}

+	if e.data != "" {

+		out += ", data: " + e.data

+	}

+

+	out += ": " + e.err.Error()

+	return out

+}

+

+// Cause returns the underlying cause of the error.

+// This is a convention used in github.com/pkg/errors

+func (e *mountError) Cause() error {

+	return e.err

+}

+

+// Unwrap returns the underlying error.

+// This is a convention used in golang 1.13+

+func (e *mountError) Unwrap() error {

+	return e.err

+}

new file mode 100644

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

+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

+}

new file mode 100644

@@ -0,0 +1,73 @@

+package mount

+

+import (

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

+)

+

+const (

+	// ptypes is the set propagation types.

+	ptypes = unix.MS_SHARED | unix.MS_PRIVATE | unix.MS_SLAVE | unix.MS_UNBINDABLE

+

+	// pflags is the full set valid flags for a change propagation call.

+	pflags = ptypes | unix.MS_REC | unix.MS_SILENT

+

+	// broflags is the combination of bind and read only

+	broflags = unix.MS_BIND | unix.MS_RDONLY

+)

+

+// isremount returns true if either device name or flags identify a remount request, false otherwise.

+func isremount(device string, flags uintptr) bool {

+	switch {

+	// We treat device "" and "none" as a remount request to provide compatibility with

+	// requests that don't explicitly set MS_REMOUNT such as those manipulating bind mounts.

+	case flags&unix.MS_REMOUNT != 0, device == "", device == "none":

+		return true

+	default:

+		return false

+	}

+}

+

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

+	oflags := flags &^ ptypes

+	if !isremount(device, flags) || data != "" {

+		// Initial call applying all non-propagation flags for mount

+		// or remount with changed data

+		if err := unix.Mount(device, target, mType, oflags, data); err != nil {

+			return &mountError{

+				op:     "mount",

+				source: device,

+				target: target,

+				flags:  oflags,

+				data:   data,

+				err:    err,

+			}

+		}

+	}

+

+	if flags&ptypes != 0 {

+		// Change the propagation type.

+		if err := unix.Mount("", target, "", flags&pflags, ""); err != nil {

+			return &mountError{

+				op:     "remount",

+				target: target,

+				flags:  flags & pflags,

+				err:    err,

+			}

+		}

+	}

+

+	if oflags&broflags == broflags {

+		// Remount the bind to apply read only.

+		if err := unix.Mount("", target, "", oflags|unix.MS_REMOUNT, ""); err != nil {

+			return &mountError{

+				op:     "remount-ro",

+				target: target,

+				flags:  oflags | unix.MS_REMOUNT,

+				err:    err,

+			}

+

+		}

+	}

+

+	return nil

+}

new file mode 100644

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

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

+

+package mount

+

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

+	panic("Not implemented")

+}

new file mode 100644

@@ -0,0 +1,73 @@

+package mount

+

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

+

+// MakeShared ensures a mounted filesystem has the SHARED mount option enabled.

+// See the supported options in flags.go for further reference.

+func MakeShared(mountPoint string) error {

+	return ensureMountedAs(mountPoint, SHARED)

+}

+

+// MakeRShared ensures a mounted filesystem has the RSHARED mount option enabled.

+// See the supported options in flags.go for further reference.

+func MakeRShared(mountPoint string) error {

+	return ensureMountedAs(mountPoint, RSHARED)

+}

+

+// MakePrivate ensures a mounted filesystem has the PRIVATE mount option enabled.

+// See the supported options in flags.go for further reference.

+func MakePrivate(mountPoint string) error {

+	return ensureMountedAs(mountPoint, PRIVATE)

+}

+

+// MakeRPrivate ensures a mounted filesystem has the RPRIVATE mount option

+// enabled. See the supported options in flags.go for further reference.

+func MakeRPrivate(mountPoint string) error {

+	return ensureMountedAs(mountPoint, RPRIVATE)

+}

+

+// MakeSlave ensures a mounted filesystem has the SLAVE mount option enabled.

+// See the supported options in flags.go for further reference.

+func MakeSlave(mountPoint string) error {

+	return ensureMountedAs(mountPoint, SLAVE)

+}

+

+// MakeRSlave ensures a mounted filesystem has the RSLAVE mount option enabled.

+// See the supported options in flags.go for further reference.

+func MakeRSlave(mountPoint string) error {

+	return ensureMountedAs(mountPoint, RSLAVE)

+}

+

+// MakeUnbindable ensures a mounted filesystem has the UNBINDABLE mount option

+// enabled. See the supported options in flags.go for further reference.

+func MakeUnbindable(mountPoint string) error {

+	return ensureMountedAs(mountPoint, UNBINDABLE)

+}

+

+// MakeRUnbindable ensures a mounted filesystem has the RUNBINDABLE mount

+// option enabled. See the supported options in flags.go for further reference.

+func MakeRUnbindable(mountPoint string) error {

+	return ensureMountedAs(mountPoint, RUNBINDABLE)

+}

+

+// MakeMount ensures that the file or directory given is a mount point,

+// bind mounting it to itself it case it is not.

+func MakeMount(mnt string) error {

+	mounted, err := mountinfo.Mounted(mnt)

+	if err != nil {

+		return err

+	}

+	if mounted {

+		return nil

+	}

+

+	return mount(mnt, mnt, "none", uintptr(BIND), "")

+}

+

+func ensureMountedAs(mnt string, flags int) error {

+	if err := MakeMount(mnt); err != nil {

+		return err

+	}

+

+	return mount("", mnt, "none", uintptr(flags), "")

+}

new file mode 100644

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