Remove dependency on kubernetes

podman parse and attach were using a very small portion of the kubernetes code
but using it caused a signficant increase in binary size.

Signed-off-by: baude <bbaude@redhat.com>

Closes: #559
Approved by: rhatdan

11 files changed, 0 insertions, 2285 deletions

diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/doc.go b/vendor/k8s.io/kubernetes/pkg/util/mount/doc.go
deleted file mode 100644
index 15179e53f..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/doc.go
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-// Package mount defines an interface to mounting filesystems.
-package mount // import "k8s.io/kubernetes/pkg/util/mount"
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/exec.go b/vendor/k8s.io/kubernetes/pkg/util/mount/exec.go
deleted file mode 100644
index 716cda0a0..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/exec.go
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import "k8s.io/utils/exec"
-
-func NewOsExec() Exec {
-	return &osExec{}
-}
-
-// Real implementation of Exec interface that uses simple util.Exec
-type osExec struct{}
-
-var _ Exec = &osExec{}
-
-func (e *osExec) Run(cmd string, args ...string) ([]byte, error) {
-	exe := exec.New()
-	return exe.Command(cmd, args...).CombinedOutput()
-}
-
-func NewFakeExec(run runHook) *FakeExec {
-	return &FakeExec{runHook: run}
-}
-
-// Fake for testing.
-type FakeExec struct {
-	runHook runHook
-}
-type runHook func(cmd string, args ...string) ([]byte, error)
-
-func (f *FakeExec) Run(cmd string, args ...string) ([]byte, error) {
-	if f.runHook != nil {
-		return f.runHook(cmd, args...)
-	}
-	return nil, nil
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount.go b/vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount.go
deleted file mode 100644
index b12a2be38..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount.go
+++ /dev/null
@@ -1,140 +0,0 @@
-// +build linux
-
-/*
-Copyright 2017 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-)
-
-// ExecMounter is a mounter that uses provided Exec interface to mount and
-// unmount a filesystem. For all other calls it uses a wrapped mounter.
-type execMounter struct {
-	wrappedMounter Interface
-	exec           Exec
-}
-
-func NewExecMounter(exec Exec, wrapped Interface) Interface {
-	return &execMounter{
-		wrappedMounter: wrapped,
-		exec:           exec,
-	}
-}
-
-// execMounter implements mount.Interface
-var _ Interface = &execMounter{}
-
-// Mount runs mount(8) using given exec interface.
-func (m *execMounter) Mount(source string, target string, fstype string, options []string) error {
-	bind, bindRemountOpts := isBind(options)
-
-	if bind {
-		err := m.doExecMount(source, target, fstype, []string{"bind"})
-		if err != nil {
-			return err
-		}
-		return m.doExecMount(source, target, fstype, bindRemountOpts)
-	}
-
-	return m.doExecMount(source, target, fstype, options)
-}
-
-// doExecMount calls exec(mount <what> <where>) using given exec interface.
-func (m *execMounter) doExecMount(source, target, fstype string, options []string) error {
-	glog.V(5).Infof("Exec Mounting %s %s %s %v", source, target, fstype, options)
-	mountArgs := makeMountArgs(source, target, fstype, options)
-	output, err := m.exec.Run("mount", mountArgs...)
-	glog.V(5).Infof("Exec mounted %v: %v: %s", mountArgs, err, string(output))
-	if err != nil {
-		return fmt.Errorf("mount failed: %v\nMounting command: %s\nMounting arguments: %s %s %s %v\nOutput: %s\n",
-			err, "mount", source, target, fstype, options, string(output))
-	}
-
-	return err
-}
-
-// Unmount runs umount(8) using given exec interface.
-func (m *execMounter) Unmount(target string) error {
-	outputBytes, err := m.exec.Run("umount", target)
-	if err == nil {
-		glog.V(5).Infof("Exec unmounted %s: %s", target, string(outputBytes))
-	} else {
-		glog.V(5).Infof("Failed to exec unmount %s: err: %q, umount output: %s", target, err, string(outputBytes))
-	}
-
-	return err
-}
-
-// List returns a list of all mounted filesystems.
-func (m *execMounter) List() ([]MountPoint, error) {
-	return m.wrappedMounter.List()
-}
-
-// IsLikelyNotMountPoint determines whether a path is a mountpoint.
-func (m *execMounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	return m.wrappedMounter.IsLikelyNotMountPoint(file)
-}
-
-// DeviceOpened checks if block device in use by calling Open with O_EXCL flag.
-// Returns true if open returns errno EBUSY, and false if errno is nil.
-// Returns an error if errno is any error other than EBUSY.
-// Returns with error if pathname is not a device.
-func (m *execMounter) DeviceOpened(pathname string) (bool, error) {
-	return m.wrappedMounter.DeviceOpened(pathname)
-}
-
-// PathIsDevice uses FileInfo returned from os.Stat to check if path refers
-// to a device.
-func (m *execMounter) PathIsDevice(pathname string) (bool, error) {
-	return m.wrappedMounter.PathIsDevice(pathname)
-}
-
-//GetDeviceNameFromMount given a mount point, find the volume id from checking /proc/mounts
-func (m *execMounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return m.wrappedMounter.GetDeviceNameFromMount(mountPath, pluginDir)
-}
-
-func (m *execMounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return m.wrappedMounter.IsMountPointMatch(mp, dir)
-}
-
-func (m *execMounter) IsNotMountPoint(dir string) (bool, error) {
-	return m.wrappedMounter.IsNotMountPoint(dir)
-}
-
-func (m *execMounter) MakeRShared(path string) error {
-	return m.wrappedMounter.MakeRShared(path)
-}
-
-func (m *execMounter) GetFileType(pathname string) (FileType, error) {
-	return m.wrappedMounter.GetFileType(pathname)
-}
-
-func (m *execMounter) MakeFile(pathname string) error {
-	return m.wrappedMounter.MakeFile(pathname)
-}
-
-func (m *execMounter) MakeDir(pathname string) error {
-	return m.wrappedMounter.MakeDir(pathname)
-}
-
-func (m *execMounter) ExistsPath(pathname string) bool {
-	return m.wrappedMounter.ExistsPath(pathname)
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount_unsupported.go b/vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount_unsupported.go
deleted file mode 100644
index 136704b23..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/exec_mount_unsupported.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// +build !linux
-
-/*
-Copyright 2017 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"errors"
-)
-
-type execMounter struct{}
-
-// ExecMounter is a mounter that uses provided Exec interface to mount and
-// unmount a filesystem. For all other calls it uses a wrapped mounter.
-func NewExecMounter(exec Exec, wrapped Interface) Interface {
-	return &execMounter{}
-}
-
-func (mounter *execMounter) Mount(source string, target string, fstype string, options []string) error {
-	return nil
-}
-
-func (mounter *execMounter) Unmount(target string) error {
-	return nil
-}
-
-func (mounter *execMounter) List() ([]MountPoint, error) {
-	return []MountPoint{}, nil
-}
-
-func (mounter *execMounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return (mp.Path == dir)
-}
-
-func (mounter *execMounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(mounter, dir)
-}
-
-func (mounter *execMounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	return true, nil
-}
-
-func (mounter *execMounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return "", nil
-}
-
-func (mounter *execMounter) DeviceOpened(pathname string) (bool, error) {
-	return false, nil
-}
-
-func (mounter *execMounter) PathIsDevice(pathname string) (bool, error) {
-	return true, nil
-}
-
-func (mounter *execMounter) MakeRShared(path string) error {
-	return nil
-}
-
-func (mounter *execMounter) GetFileType(pathname string) (FileType, error) {
-	return FileType("fake"), errors.New("not implemented")
-}
-
-func (mounter *execMounter) MakeDir(pathname string) error {
-	return nil
-}
-
-func (mounter *execMounter) MakeFile(pathname string) error {
-	return nil
-}
-
-func (mounter *execMounter) ExistsPath(pathname string) bool {
-	return true
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/fake.go b/vendor/k8s.io/kubernetes/pkg/util/mount/fake.go
deleted file mode 100644
index f4e2e411d..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/fake.go
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/golang/glog"
-)
-
-// FakeMounter implements mount.Interface for tests.
-type FakeMounter struct {
-	MountPoints []MountPoint
-	Log         []FakeAction
-	// Some tests run things in parallel, make sure the mounter does not produce
-	// any golang's DATA RACE warnings.
-	mutex sync.Mutex
-}
-
-var _ Interface = &FakeMounter{}
-
-// Values for FakeAction.Action
-const FakeActionMount = "mount"
-const FakeActionUnmount = "unmount"
-
-// FakeAction objects are logged every time a fake mount or unmount is called.
-type FakeAction struct {
-	Action string // "mount" or "unmount"
-	Target string // applies to both mount and unmount actions
-	Source string // applies only to "mount" actions
-	FSType string // applies only to "mount" actions
-}
-
-func (f *FakeMounter) ResetLog() {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	f.Log = []FakeAction{}
-}
-
-func (f *FakeMounter) Mount(source string, target string, fstype string, options []string) error {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	// find 'bind' option
-	for _, option := range options {
-		if option == "bind" {
-			// This is a bind-mount. In order to mimic linux behaviour, we must
-			// use the original device of the bind-mount as the real source.
-			// E.g. when mounted /dev/sda like this:
-			//      $ mount /dev/sda /mnt/test
-			//      $ mount -o bind /mnt/test /mnt/bound
-			// then /proc/mount contains:
-			// /dev/sda /mnt/test
-			// /dev/sda /mnt/bound
-			// (and not /mnt/test /mnt/bound)
-			// I.e. we must use /dev/sda as source instead of /mnt/test in the
-			// bind mount.
-			for _, mnt := range f.MountPoints {
-				if source == mnt.Path {
-					source = mnt.Device
-					break
-				}
-			}
-			break
-		}
-	}
-
-	// If target is a symlink, get its absolute path
-	absTarget, err := filepath.EvalSymlinks(target)
-	if err != nil {
-		absTarget = target
-	}
-
-	f.MountPoints = append(f.MountPoints, MountPoint{Device: source, Path: absTarget, Type: fstype})
-	glog.V(5).Infof("Fake mounter: mounted %s to %s", source, absTarget)
-	f.Log = append(f.Log, FakeAction{Action: FakeActionMount, Target: absTarget, Source: source, FSType: fstype})
-	return nil
-}
-
-func (f *FakeMounter) Unmount(target string) error {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	// If target is a symlink, get its absolute path
-	absTarget, err := filepath.EvalSymlinks(target)
-	if err != nil {
-		absTarget = target
-	}
-
-	newMountpoints := []MountPoint{}
-	for _, mp := range f.MountPoints {
-		if mp.Path == absTarget {
-			glog.V(5).Infof("Fake mounter: unmounted %s from %s", mp.Device, absTarget)
-			// Don't copy it to newMountpoints
-			continue
-		}
-		newMountpoints = append(newMountpoints, MountPoint{Device: mp.Device, Path: mp.Path, Type: mp.Type})
-	}
-	f.MountPoints = newMountpoints
-	f.Log = append(f.Log, FakeAction{Action: FakeActionUnmount, Target: absTarget})
-	return nil
-}
-
-func (f *FakeMounter) List() ([]MountPoint, error) {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	return f.MountPoints, nil
-}
-
-func (f *FakeMounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return mp.Path == dir
-}
-
-func (f *FakeMounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(f, dir)
-}
-
-func (f *FakeMounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	_, err := os.Stat(file)
-	if err != nil {
-		return true, err
-	}
-
-	// If file is a symlink, get its absolute path
-	absFile, err := filepath.EvalSymlinks(file)
-	if err != nil {
-		absFile = file
-	}
-
-	for _, mp := range f.MountPoints {
-		if mp.Path == absFile {
-			glog.V(5).Infof("isLikelyNotMountPoint for %s: mounted %s, false", file, mp.Path)
-			return false, nil
-		}
-	}
-	glog.V(5).Infof("isLikelyNotMountPoint for %s: true", file)
-	return true, nil
-}
-
-func (f *FakeMounter) DeviceOpened(pathname string) (bool, error) {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	for _, mp := range f.MountPoints {
-		if mp.Device == pathname {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-func (f *FakeMounter) PathIsDevice(pathname string) (bool, error) {
-	return true, nil
-}
-
-func (f *FakeMounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return getDeviceNameFromMount(f, mountPath, pluginDir)
-}
-
-func (f *FakeMounter) MakeRShared(path string) error {
-	return nil
-}
-
-func (f *FakeMounter) GetFileType(pathname string) (FileType, error) {
-	return FileType("fake"), nil
-}
-
-func (f *FakeMounter) MakeDir(pathname string) error {
-	return nil
-}
-
-func (f *FakeMounter) MakeFile(pathname string) error {
-	return nil
-}
-
-func (f *FakeMounter) ExistsPath(pathname string) bool {
-	return false
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/mount.go b/vendor/k8s.io/kubernetes/pkg/util/mount/mount.go
deleted file mode 100644
index 0f9bac03f..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/mount.go
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-// TODO(thockin): This whole pkg is pretty linux-centric.  As soon as we have
-// an alternate platform, we will need to abstract further.
-package mount
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-type FileType string
-
-const (
-	// Default mount command if mounter path is not specified
-	defaultMountCommand           = "mount"
-	MountsInGlobalPDPath          = "mounts"
-	FileTypeDirectory    FileType = "Directory"
-	FileTypeFile         FileType = "File"
-	FileTypeSocket       FileType = "Socket"
-	FileTypeCharDev      FileType = "CharDevice"
-	FileTypeBlockDev     FileType = "BlockDevice"
-)
-
-type Interface interface {
-	// Mount mounts source to target as fstype with given options.
-	Mount(source string, target string, fstype string, options []string) error
-	// Unmount unmounts given target.
-	Unmount(target string) error
-	// List returns a list of all mounted filesystems.  This can be large.
-	// On some platforms, reading mounts is not guaranteed consistent (i.e.
-	// it could change between chunked reads). This is guaranteed to be
-	// consistent.
-	List() ([]MountPoint, error)
-	// IsMountPointMatch determines if the mountpoint matches the dir
-	IsMountPointMatch(mp MountPoint, dir string) bool
-	// IsNotMountPoint determines if a directory is a mountpoint.
-	// It should return ErrNotExist when the directory does not exist.
-	// IsNotMountPoint is more expensive than IsLikelyNotMountPoint.
-	// IsNotMountPoint detects bind mounts in linux.
-	// IsNotMountPoint enumerates all the mountpoints using List() and
-	// the list of mountpoints may be large, then it uses
-	// IsMountPointMatch to evaluate whether the directory is a mountpoint
-	IsNotMountPoint(file string) (bool, error)
-	// IsLikelyNotMountPoint uses heuristics to determine if a directory
-	// is a mountpoint.
-	// It should return ErrNotExist when the directory does not exist.
-	// IsLikelyNotMountPoint does NOT properly detect all mountpoint types
-	// most notably linux bind mounts.
-	IsLikelyNotMountPoint(file string) (bool, error)
-	// DeviceOpened determines if the device is in use elsewhere
-	// on the system, i.e. still mounted.
-	DeviceOpened(pathname string) (bool, error)
-	// PathIsDevice determines if a path is a device.
-	PathIsDevice(pathname string) (bool, error)
-	// GetDeviceNameFromMount finds the device name by checking the mount path
-	// to get the global mount path which matches its plugin directory
-	GetDeviceNameFromMount(mountPath, pluginDir string) (string, error)
-	// MakeRShared checks that given path is on a mount with 'rshared' mount
-	// propagation. If not, it bind-mounts the path as rshared.
-	MakeRShared(path string) error
-	// GetFileType checks for file/directory/socket/block/character devices.
-	// Will operate in the host mount namespace if kubelet is running in a container
-	GetFileType(pathname string) (FileType, error)
-	// MakeFile creates an empty file.
-	// Will operate in the host mount namespace if kubelet is running in a container
-	MakeFile(pathname string) error
-	// MakeDir creates a new directory.
-	// Will operate in the host mount namespace if kubelet is running in a container
-	MakeDir(pathname string) error
-	// ExistsPath checks whether the path exists.
-	// Will operate in the host mount namespace if kubelet is running in a container
-	ExistsPath(pathname string) bool
-}
-
-// Exec executes command where mount utilities are. This can be either the host,
-// container where kubelet runs or even a remote pod with mount utilities.
-// Usual pkg/util/exec interface is not used because kubelet.RunInContainer does
-// not provide stdin/stdout/stderr streams.
-type Exec interface {
-	// Run executes a command and returns its stdout + stderr combined in one
-	// stream.
-	Run(cmd string, args ...string) ([]byte, error)
-}
-
-// Compile-time check to ensure all Mounter implementations satisfy
-// the mount interface
-var _ Interface = &Mounter{}
-
-// This represents a single line in /proc/mounts or /etc/fstab.
-type MountPoint struct {
-	Device string
-	Path   string
-	Type   string
-	Opts   []string
-	Freq   int
-	Pass   int
-}
-
-// SafeFormatAndMount probes a device to see if it is formatted.
-// Namely it checks to see if a file system is present. If so it
-// mounts it otherwise the device is formatted first then mounted.
-type SafeFormatAndMount struct {
-	Interface
-	Exec
-}
-
-// FormatAndMount formats the given disk, if needed, and mounts it.
-// That is if the disk is not formatted and it is not being mounted as
-// read-only it will format it first then mount it. Otherwise, if the
-// disk is already formatted or it is being mounted as read-only, it
-// will be mounted without formatting.
-func (mounter *SafeFormatAndMount) FormatAndMount(source string, target string, fstype string, options []string) error {
-	return mounter.formatAndMount(source, target, fstype, options)
-}
-
-// GetMountRefsByDev finds all references to the device provided
-// by mountPath; returns a list of paths.
-func GetMountRefsByDev(mounter Interface, mountPath string) ([]string, error) {
-	mps, err := mounter.List()
-	if err != nil {
-		return nil, err
-	}
-	slTarget, err := filepath.EvalSymlinks(mountPath)
-	if err != nil {
-		slTarget = mountPath
-	}
-
-	// Finding the device mounted to mountPath
-	diskDev := ""
-	for i := range mps {
-		if slTarget == mps[i].Path {
-			diskDev = mps[i].Device
-			break
-		}
-	}
-
-	// Find all references to the device.
-	var refs []string
-	for i := range mps {
-		if mps[i].Device == diskDev || mps[i].Device == slTarget {
-			if mps[i].Path != slTarget {
-				refs = append(refs, mps[i].Path)
-			}
-		}
-	}
-	return refs, nil
-}
-
-// GetDeviceNameFromMount: given a mnt point, find the device from /proc/mounts
-// returns the device name, reference count, and error code
-func GetDeviceNameFromMount(mounter Interface, mountPath string) (string, int, error) {
-	mps, err := mounter.List()
-	if err != nil {
-		return "", 0, err
-	}
-
-	// Find the device name.
-	// FIXME if multiple devices mounted on the same mount path, only the first one is returned
-	device := ""
-	// If mountPath is symlink, need get its target path.
-	slTarget, err := filepath.EvalSymlinks(mountPath)
-	if err != nil {
-		slTarget = mountPath
-	}
-	for i := range mps {
-		if mps[i].Path == slTarget {
-			device = mps[i].Device
-			break
-		}
-	}
-
-	// Find all references to the device.
-	refCount := 0
-	for i := range mps {
-		if mps[i].Device == device {
-			refCount++
-		}
-	}
-	return device, refCount, nil
-}
-
-// IsNotMountPoint determines if a directory is a mountpoint.
-// It should return ErrNotExist when the directory does not exist.
-// This method uses the List() of all mountpoints
-// It is more extensive than IsLikelyNotMountPoint
-// and it detects bind mounts in linux
-func IsNotMountPoint(mounter Interface, file string) (bool, error) {
-	// IsLikelyNotMountPoint provides a quick check
-	// to determine whether file IS A mountpoint
-	notMnt, notMntErr := mounter.IsLikelyNotMountPoint(file)
-	if notMntErr != nil && os.IsPermission(notMntErr) {
-		// We were not allowed to do the simple stat() check, e.g. on NFS with
-		// root_squash. Fall back to /proc/mounts check below.
-		notMnt = true
-		notMntErr = nil
-	}
-	if notMntErr != nil {
-		return notMnt, notMntErr
-	}
-	// identified as mountpoint, so return this fact
-	if notMnt == false {
-		return notMnt, nil
-	}
-	// check all mountpoints since IsLikelyNotMountPoint
-	// is not reliable for some mountpoint types
-	mountPoints, mountPointsErr := mounter.List()
-	if mountPointsErr != nil {
-		return notMnt, mountPointsErr
-	}
-	for _, mp := range mountPoints {
-		if mounter.IsMountPointMatch(mp, file) {
-			notMnt = false
-			break
-		}
-	}
-	return notMnt, nil
-}
-
-// isBind detects whether a bind mount is being requested and makes the remount options to
-// use in case of bind mount, due to the fact that bind mount doesn't respect mount options.
-// The list equals:
-//   options - 'bind' + 'remount' (no duplicate)
-func isBind(options []string) (bool, []string) {
-	bindRemountOpts := []string{"remount"}
-	bind := false
-
-	if len(options) != 0 {
-		for _, option := range options {
-			switch option {
-			case "bind":
-				bind = true
-				break
-			case "remount":
-				break
-			default:
-				bindRemountOpts = append(bindRemountOpts, option)
-			}
-		}
-	}
-
-	return bind, bindRemountOpts
-}
-
-// TODO: this is a workaround for the unmount device issue caused by gci mounter.
-// In GCI cluster, if gci mounter is used for mounting, the container started by mounter
-// script will cause additional mounts created in the container. Since these mounts are
-// irrelevant to the original mounts, they should be not considered when checking the
-// mount references. Current solution is to filter out those mount paths that contain
-// the string of original mount path.
-// Plan to work on better approach to solve this issue.
-
-func HasMountRefs(mountPath string, mountRefs []string) bool {
-	count := 0
-	for _, ref := range mountRefs {
-		if !strings.Contains(ref, mountPath) {
-			count = count + 1
-		}
-	}
-	return count > 0
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/mount_linux.go b/vendor/k8s.io/kubernetes/pkg/util/mount/mount_linux.go
deleted file mode 100644
index 11835432d..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/mount_linux.go
+++ /dev/null
@@ -1,700 +0,0 @@
-// +build linux
-
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-
-	"github.com/golang/glog"
-	"golang.org/x/sys/unix"
-	"k8s.io/apimachinery/pkg/util/sets"
-	utilio "k8s.io/kubernetes/pkg/util/io"
-	utilexec "k8s.io/utils/exec"
-)
-
-const (
-	// How many times to retry for a consistent read of /proc/mounts.
-	maxListTries = 3
-	// 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"
-	// Location of the mountinfo file
-	procMountInfoPath = "/proc/self/mountinfo"
-	// 'fsck' found errors and corrected them
-	fsckErrorsCorrected = 1
-	// 'fsck' found errors but exited without correcting them
-	fsckErrorsUncorrected = 4
-)
-
-// Mounter provides the default implementation of mount.Interface
-// for the linux platform.  This implementation assumes that the
-// kubelet is running in the host's root mount namespace.
-type Mounter struct {
-	mounterPath string
-	withSystemd bool
-}
-
-// New returns a mount.Interface for the current system.
-// It provides options to override the default mounter behavior.
-// mounterPath allows using an alternative to `/bin/mount` for mounting.
-func New(mounterPath string) Interface {
-	return &Mounter{
-		mounterPath: mounterPath,
-		withSystemd: detectSystemd(),
-	}
-}
-
-// Mount mounts source to target as fstype with given options. 'source' and 'fstype' must
-// be an empty string in case it's not required, e.g. for remount, or for auto filesystem
-// type, where kernel handles fstype for you. The mount 'options' is a list of options,
-// currently come from mount(8), e.g. "ro", "remount", "bind", etc. If no more option is
-// required, call Mount with an empty string list or nil.
-func (mounter *Mounter) Mount(source string, target string, fstype string, options []string) error {
-	// Path to mounter binary if containerized mounter is needed. Otherwise, it is set to empty.
-	// All Linux distros are expected to be shipped with a mount utility that a support bind mounts.
-	mounterPath := ""
-	bind, bindRemountOpts := isBind(options)
-	if bind {
-		err := mounter.doMount(mounterPath, defaultMountCommand, source, target, fstype, []string{"bind"})
-		if err != nil {
-			return err
-		}
-		return mounter.doMount(mounterPath, defaultMountCommand, source, target, fstype, bindRemountOpts)
-	}
-	// The list of filesystems that require containerized mounter on GCI image cluster
-	fsTypesNeedMounter := sets.NewString("nfs", "glusterfs", "ceph", "cifs")
-	if fsTypesNeedMounter.Has(fstype) {
-		mounterPath = mounter.mounterPath
-	}
-	return mounter.doMount(mounterPath, defaultMountCommand, source, target, fstype, options)
-}
-
-// doMount runs the mount command. mounterPath is the path to mounter binary if containerized mounter is used.
-func (m *Mounter) doMount(mounterPath string, mountCmd string, source string, target string, fstype string, options []string) error {
-	mountArgs := makeMountArgs(source, target, fstype, options)
-	if len(mounterPath) > 0 {
-		mountArgs = append([]string{mountCmd}, mountArgs...)
-		mountCmd = mounterPath
-	}
-
-	if m.withSystemd {
-		// Try to run mount via systemd-run --scope. This will escape the
-		// service where kubelet runs and any fuse daemons will be started in a
-		// specific scope. kubelet service than can be restarted without killing
-		// these fuse daemons.
-		//
-		// Complete command line (when mounterPath is not used):
-		// systemd-run --description=... --scope -- mount -t <type> <what> <where>
-		//
-		// Expected flow:
-		// * systemd-run creates a transient scope (=~ cgroup) and executes its
-		//   argument (/bin/mount) there.
-		// * mount does its job, forks a fuse daemon if necessary and finishes.
-		//   (systemd-run --scope finishes at this point, returning mount's exit
-		//   code and stdout/stderr - thats one of --scope benefits).
-		// * systemd keeps the fuse daemon running in the scope (i.e. in its own
-		//   cgroup) until the fuse daemon dies (another --scope benefit).
-		//   Kubelet service can be restarted and the fuse daemon survives.
-		// * When the fuse daemon dies (e.g. during unmount) systemd removes the
-		//   scope automatically.
-		//
-		// systemd-mount is not used because it's too new for older distros
-		// (CentOS 7, Debian Jessie).
-		mountCmd, mountArgs = addSystemdScope("systemd-run", target, mountCmd, mountArgs)
-	} else {
-		// No systemd-run on the host (or we failed to check it), assume kubelet
-		// does not run as a systemd service.
-		// No code here, mountCmd and mountArgs are already populated.
-	}
-
-	glog.V(4).Infof("Mounting cmd (%s) with arguments (%s)", mountCmd, mountArgs)
-	command := exec.Command(mountCmd, mountArgs...)
-	output, err := command.CombinedOutput()
-	if err != nil {
-		args := strings.Join(mountArgs, " ")
-		glog.Errorf("Mount failed: %v\nMounting command: %s\nMounting arguments: %s\nOutput: %s\n", err, mountCmd, args, string(output))
-		return fmt.Errorf("mount failed: %v\nMounting command: %s\nMounting arguments: %s\nOutput: %s\n",
-			err, mountCmd, args, string(output))
-	}
-	return err
-}
-
-// GetMountRefs finds all other references to the device referenced
-// by mountPath; returns a list of paths.
-func GetMountRefs(mounter Interface, mountPath string) ([]string, error) {
-	mps, err := mounter.List()
-	if err != nil {
-		return nil, err
-	}
-	// Find the device name.
-	deviceName := ""
-	// If mountPath is symlink, need get its target path.
-	slTarget, err := filepath.EvalSymlinks(mountPath)
-	if err != nil {
-		slTarget = mountPath
-	}
-	for i := range mps {
-		if mps[i].Path == slTarget {
-			deviceName = mps[i].Device
-			break
-		}
-	}
-
-	// Find all references to the device.
-	var refs []string
-	if deviceName == "" {
-		glog.Warningf("could not determine device for path: %q", mountPath)
-	} else {
-		for i := range mps {
-			if mps[i].Device == deviceName && mps[i].Path != slTarget {
-				refs = append(refs, mps[i].Path)
-			}
-		}
-	}
-	return refs, nil
-}
-
-// detectSystemd returns true if OS runs with systemd as init. When not sure
-// (permission errors, ...), it returns false.
-// There may be different ways how to detect systemd, this one makes sure that
-// systemd-runs (needed by Mount()) works.
-func detectSystemd() bool {
-	if _, err := exec.LookPath("systemd-run"); err != nil {
-		glog.V(2).Infof("Detected OS without systemd")
-		return false
-	}
-	// Try to run systemd-run --scope /bin/true, that should be enough
-	// to make sure that systemd is really running and not just installed,
-	// which happens when running in a container with a systemd-based image
-	// but with different pid 1.
-	cmd := exec.Command("systemd-run", "--description=Kubernetes systemd probe", "--scope", "true")
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		glog.V(2).Infof("Cannot run systemd-run, assuming non-systemd OS")
-		glog.V(4).Infof("systemd-run failed with: %v", err)
-		glog.V(4).Infof("systemd-run output: %s", string(output))
-		return false
-	}
-	glog.V(2).Infof("Detected OS with systemd")
-	return true
-}
-
-// makeMountArgs makes the arguments to the mount(8) command.
-func makeMountArgs(source, target, fstype string, options []string) []string {
-	// Build mount command as follows:
-	//   mount [-t $fstype] [-o $options] [$source] $target
-	mountArgs := []string{}
-	if len(fstype) > 0 {
-		mountArgs = append(mountArgs, "-t", fstype)
-	}
-	if len(options) > 0 {
-		mountArgs = append(mountArgs, "-o", strings.Join(options, ","))
-	}
-	if len(source) > 0 {
-		mountArgs = append(mountArgs, source)
-	}
-	mountArgs = append(mountArgs, target)
-
-	return mountArgs
-}
-
-// addSystemdScope adds "system-run --scope" to given command line
-func addSystemdScope(systemdRunPath, mountName, command string, args []string) (string, []string) {
-	descriptionArg := fmt.Sprintf("--description=Kubernetes transient mount for %s", mountName)
-	systemdRunArgs := []string{descriptionArg, "--scope", "--", command}
-	return systemdRunPath, append(systemdRunArgs, args...)
-}
-
-// Unmount unmounts the target.
-func (mounter *Mounter) Unmount(target string) error {
-	glog.V(4).Infof("Unmounting %s", target)
-	command := exec.Command("umount", target)
-	output, err := command.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("Unmount failed: %v\nUnmounting arguments: %s\nOutput: %s\n", err, target, string(output))
-	}
-	return nil
-}
-
-// List returns a list of all mounted filesystems.
-func (*Mounter) List() ([]MountPoint, error) {
-	return listProcMounts(procMountsPath)
-}
-
-func (mounter *Mounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	deletedDir := fmt.Sprintf("%s\\040(deleted)", dir)
-	return ((mp.Path == dir) || (mp.Path == deletedDir))
-}
-
-func (mounter *Mounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(mounter, dir)
-}
-
-// IsLikelyNotMountPoint determines if a directory is not a mountpoint.
-// It is fast but not necessarily ALWAYS correct. If the path is in fact
-// a bind mount from one part of a mount to another it will not be detected.
-// mkdir /tmp/a /tmp/b; mount --bin /tmp/a /tmp/b; IsLikelyNotMountPoint("/tmp/b")
-// will return true. When in fact /tmp/b is a mount point. If this situation
-// if of interest to you, don't use this function...
-func (mounter *Mounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	stat, err := os.Stat(file)
-	if err != nil {
-		return true, err
-	}
-	rootStat, err := os.Lstat(filepath.Dir(strings.TrimSuffix(file, "/")))
-	if err != nil {
-		return true, err
-	}
-	// If the directory has a different device as parent, then it is a mountpoint.
-	if stat.Sys().(*syscall.Stat_t).Dev != rootStat.Sys().(*syscall.Stat_t).Dev {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-// DeviceOpened checks if block device in use by calling Open with O_EXCL flag.
-// If pathname is not a device, log and return false with nil error.
-// If open returns errno EBUSY, return true with nil error.
-// If open returns nil, return false with nil error.
-// Otherwise, return false with error
-func (mounter *Mounter) DeviceOpened(pathname string) (bool, error) {
-	return exclusiveOpenFailsOnDevice(pathname)
-}
-
-// PathIsDevice uses FileInfo returned from os.Stat to check if path refers
-// to a device.
-func (mounter *Mounter) PathIsDevice(pathname string) (bool, error) {
-	pathType, err := mounter.GetFileType(pathname)
-	isDevice := pathType == FileTypeCharDev || pathType == FileTypeBlockDev
-	return isDevice, err
-}
-
-func exclusiveOpenFailsOnDevice(pathname string) (bool, error) {
-	var isDevice bool
-	finfo, err := os.Stat(pathname)
-	if os.IsNotExist(err) {
-		isDevice = false
-	}
-	// err in call to os.Stat
-	if err != nil {
-		return false, fmt.Errorf(
-			"PathIsDevice failed for path %q: %v",
-			pathname,
-			err)
-	}
-	// path refers to a device
-	if finfo.Mode()&os.ModeDevice != 0 {
-		isDevice = true
-	}
-
-	if !isDevice {
-		glog.Errorf("Path %q is not referring to a device.", pathname)
-		return false, nil
-	}
-	fd, errno := unix.Open(pathname, unix.O_RDONLY|unix.O_EXCL, 0)
-	// If the device is in use, open will return an invalid fd.
-	// When this happens, it is expected that Close will fail and throw an error.
-	defer unix.Close(fd)
-	if errno == nil {
-		// device not in use
-		return false, nil
-	} else if errno == unix.EBUSY {
-		// device is in use
-		return true, nil
-	}
-	// error during call to Open
-	return false, errno
-}
-
-//GetDeviceNameFromMount: given a mount point, find the device name from its global mount point
-func (mounter *Mounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return getDeviceNameFromMount(mounter, mountPath, pluginDir)
-}
-
-// getDeviceNameFromMount find the device name from /proc/mounts in which
-// the mount path reference should match the given plugin directory. In case no mount path reference
-// matches, returns the volume name taken from its given mountPath
-func getDeviceNameFromMount(mounter Interface, mountPath, pluginDir string) (string, error) {
-	refs, err := GetMountRefs(mounter, mountPath)
-	if err != nil {
-		glog.V(4).Infof("GetMountRefs failed for mount path %q: %v", mountPath, err)
-		return "", err
-	}
-	if len(refs) == 0 {
-		glog.V(4).Infof("Directory %s is not mounted", mountPath)
-		return "", fmt.Errorf("directory %s is not mounted", mountPath)
-	}
-	basemountPath := path.Join(pluginDir, MountsInGlobalPDPath)
-	for _, ref := range refs {
-		if strings.HasPrefix(ref, basemountPath) {
-			volumeID, err := filepath.Rel(basemountPath, ref)
-			if err != nil {
-				glog.Errorf("Failed to get volume id from mount %s - %v", mountPath, err)
-				return "", err
-			}
-			return volumeID, nil
-		}
-	}
-
-	return path.Base(mountPath), nil
-}
-
-func listProcMounts(mountFilePath string) ([]MountPoint, error) {
-	content, err := utilio.ConsistentRead(mountFilePath, maxListTries)
-	if err != nil {
-		return nil, err
-	}
-	return parseProcMounts(content)
-}
-
-func parseProcMounts(content []byte) ([]MountPoint, error) {
-	out := []MountPoint{}
-	lines := strings.Split(string(content), "\n")
-	for _, line := range lines {
-		if line == "" {
-			// the last split() item is empty string following the last \n
-			continue
-		}
-		fields := strings.Fields(line)
-		if len(fields) != expectedNumFieldsPerLine {
-			return nil, fmt.Errorf("wrong number of fields (expected %d, got %d): %s", expectedNumFieldsPerLine, len(fields), line)
-		}
-
-		mp := MountPoint{
-			Device: fields[0],
-			Path:   fields[1],
-			Type:   fields[2],
-			Opts:   strings.Split(fields[3], ","),
-		}
-
-		freq, err := strconv.Atoi(fields[4])
-		if err != nil {
-			return nil, err
-		}
-		mp.Freq = freq
-
-		pass, err := strconv.Atoi(fields[5])
-		if err != nil {
-			return nil, err
-		}
-		mp.Pass = pass
-
-		out = append(out, mp)
-	}
-	return out, nil
-}
-
-func (mounter *Mounter) MakeRShared(path string) error {
-	return doMakeRShared(path, procMountInfoPath)
-}
-
-func (mounter *Mounter) GetFileType(pathname string) (FileType, error) {
-	var pathType FileType
-	finfo, err := os.Stat(pathname)
-	if os.IsNotExist(err) {
-		return pathType, fmt.Errorf("path %q does not exist", pathname)
-	}
-	// err in call to os.Stat
-	if err != nil {
-		return pathType, err
-	}
-
-	mode := finfo.Sys().(*syscall.Stat_t).Mode
-	switch mode & syscall.S_IFMT {
-	case syscall.S_IFSOCK:
-		return FileTypeSocket, nil
-	case syscall.S_IFBLK:
-		return FileTypeBlockDev, nil
-	case syscall.S_IFCHR:
-		return FileTypeCharDev, nil
-	case syscall.S_IFDIR:
-		return FileTypeDirectory, nil
-	case syscall.S_IFREG:
-		return FileTypeFile, nil
-	}
-
-	return pathType, fmt.Errorf("only recognise file, directory, socket, block device and character device")
-}
-
-func (mounter *Mounter) MakeDir(pathname string) error {
-	err := os.MkdirAll(pathname, os.FileMode(0755))
-	if err != nil {
-		if !os.IsExist(err) {
-			return err
-		}
-	}
-	return nil
-}
-
-func (mounter *Mounter) MakeFile(pathname string) error {
-	f, err := os.OpenFile(pathname, os.O_CREATE, os.FileMode(0644))
-	defer f.Close()
-	if err != nil {
-		if !os.IsExist(err) {
-			return err
-		}
-	}
-	return nil
-}
-
-func (mounter *Mounter) ExistsPath(pathname string) bool {
-	_, err := os.Stat(pathname)
-	if err != nil {
-		return false
-	}
-	return true
-}
-
-// formatAndMount uses unix utils to format and mount the given disk
-func (mounter *SafeFormatAndMount) formatAndMount(source string, target string, fstype string, options []string) error {
-	readOnly := false
-	for _, option := range options {
-		if option == "ro" {
-			readOnly = true
-			break
-		}
-	}
-
-	options = append(options, "defaults")
-
-	if !readOnly {
-		// Run fsck on the disk to fix repairable issues, only do this for volumes requested as rw.
-		glog.V(4).Infof("Checking for issues with fsck on disk: %s", source)
-		args := []string{"-a", source}
-		out, err := mounter.Exec.Run("fsck", args...)
-		if err != nil {
-			ee, isExitError := err.(utilexec.ExitError)
-			switch {
-			case err == utilexec.ErrExecutableNotFound:
-				glog.Warningf("'fsck' not found on system; continuing mount without running 'fsck'.")
-			case isExitError && ee.ExitStatus() == fsckErrorsCorrected:
-				glog.Infof("Device %s has errors which were corrected by fsck.", source)
-			case isExitError && ee.ExitStatus() == fsckErrorsUncorrected:
-				return fmt.Errorf("'fsck' found errors on device %s but could not correct them: %s.", source, string(out))
-			case isExitError && ee.ExitStatus() > fsckErrorsUncorrected:
-				glog.Infof("`fsck` error %s", string(out))
-			}
-		}
-	}
-
-	// Try to mount the disk
-	glog.V(4).Infof("Attempting to mount disk: %s %s %s", fstype, source, target)
-	mountErr := mounter.Interface.Mount(source, target, fstype, options)
-	if mountErr != nil {
-		// Mount failed. This indicates either that the disk is unformatted or
-		// it contains an unexpected filesystem.
-		existingFormat, err := mounter.GetDiskFormat(source)
-		if err != nil {
-			return err
-		}
-		if existingFormat == "" {
-			if readOnly {
-				// Don't attempt to format if mounting as readonly, return an error to reflect this.
-				return errors.New("failed to mount unformatted volume as read only")
-			}
-
-			// Disk is unformatted so format it.
-			args := []string{source}
-			// Use 'ext4' as the default
-			if len(fstype) == 0 {
-				fstype = "ext4"
-			}
-
-			if fstype == "ext4" || fstype == "ext3" {
-				args = []string{"-F", source}
-			}
-			glog.Infof("Disk %q appears to be unformatted, attempting to format as type: %q with options: %v", source, fstype, args)
-			_, err := mounter.Exec.Run("mkfs."+fstype, args...)
-			if err == nil {
-				// the disk has been formatted successfully try to mount it again.
-				glog.Infof("Disk successfully formatted (mkfs): %s - %s %s", fstype, source, target)
-				return mounter.Interface.Mount(source, target, fstype, options)
-			}
-			glog.Errorf("format of disk %q failed: type:(%q) target:(%q) options:(%q)error:(%v)", source, fstype, target, options, err)
-			return err
-		} else {
-			// Disk is already formatted and failed to mount
-			if len(fstype) == 0 || fstype == existingFormat {
-				// This is mount error
-				return mountErr
-			} else {
-				// Block device is formatted with unexpected filesystem, let the user know
-				return fmt.Errorf("failed to mount the volume as %q, it already contains %s. Mount error: %v", fstype, existingFormat, mountErr)
-			}
-		}
-	}
-	return mountErr
-}
-
-// GetDiskFormat uses 'blkid' to see if the given disk is unformated
-func (mounter *SafeFormatAndMount) GetDiskFormat(disk string) (string, error) {
-	args := []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", disk}
-	glog.V(4).Infof("Attempting to determine if disk %q is formatted using blkid with args: (%v)", disk, args)
-	dataOut, err := mounter.Exec.Run("blkid", args...)
-	output := string(dataOut)
-	glog.V(4).Infof("Output: %q, err: %v", output, err)
-
-	if err != nil {
-		if exit, ok := err.(utilexec.ExitError); ok {
-			if exit.ExitStatus() == 2 {
-				// Disk device is unformatted.
-				// For `blkid`, if the specified token (TYPE/PTTYPE, etc) was
-				// not found, or no (specified) devices could be identified, an
-				// exit code of 2 is returned.
-				return "", nil
-			}
-		}
-		glog.Errorf("Could not determine if disk %q is formatted (%v)", disk, err)
-		return "", err
-	}
-
-	var fstype, pttype string
-
-	lines := strings.Split(output, "\n")
-	for _, l := range lines {
-		if len(l) <= 0 {
-			// Ignore empty line.
-			continue
-		}
-		cs := strings.Split(l, "=")
-		if len(cs) != 2 {
-			return "", fmt.Errorf("blkid returns invalid output: %s", output)
-		}
-		// TYPE is filesystem type, and PTTYPE is partition table type, according
-		// to https://www.kernel.org/pub/linux/utils/util-linux/v2.21/libblkid-docs/.
-		if cs[0] == "TYPE" {
-			fstype = cs[1]
-		} else if cs[0] == "PTTYPE" {
-			pttype = cs[1]
-		}
-	}
-
-	if len(pttype) > 0 {
-		glog.V(4).Infof("Disk %s detected partition table type: %s", pttype)
-		// Returns a special non-empty string as filesystem type, then kubelet
-		// will not format it.
-		return "unknown data, probably partitions", nil
-	}
-
-	return fstype, nil
-}
-
-// isShared returns true, if given path is on a mount point that has shared
-// mount propagation.
-func isShared(path string, filename string) (bool, error) {
-	infos, err := parseMountInfo(filename)
-	if err != nil {
-		return false, err
-	}
-
-	// process /proc/xxx/mountinfo in backward order and find the first mount
-	// point that is prefix of 'path' - that's the mount where path resides
-	var info *mountInfo
-	for i := len(infos) - 1; i >= 0; i-- {
-		if strings.HasPrefix(path, infos[i].mountPoint) {
-			info = &infos[i]
-			break
-		}
-	}
-	if info == nil {
-		return false, fmt.Errorf("cannot find mount point for %q", path)
-	}
-
-	// parse optional parameters
-	for _, opt := range info.optional {
-		if strings.HasPrefix(opt, "shared:") {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-type mountInfo struct {
-	mountPoint string
-	// list of "optional parameters", mount propagation is one of them
-	optional []string
-}
-
-// parseMountInfo parses /proc/xxx/mountinfo.
-func parseMountInfo(filename string) ([]mountInfo, error) {
-	content, err := utilio.ConsistentRead(filename, maxListTries)
-	if err != nil {
-		return []mountInfo{}, err
-	}
-	contentStr := string(content)
-	infos := []mountInfo{}
-
-	for _, line := range strings.Split(contentStr, "\n") {
-		if line == "" {
-			// the last split() item is empty string following the last \n
-			continue
-		}
-		fields := strings.Fields(line)
-		if len(fields) < 7 {
-			return nil, fmt.Errorf("wrong number of fields in (expected %d, got %d): %s", 8, len(fields), line)
-		}
-		info := mountInfo{
-			mountPoint: fields[4],
-			optional:   []string{},
-		}
-		for i := 6; i < len(fields) && fields[i] != "-"; i++ {
-			info.optional = append(info.optional, fields[i])
-		}
-		infos = append(infos, info)
-	}
-	return infos, nil
-}
-
-// doMakeRShared is common implementation of MakeRShared on Linux. It checks if
-// path is shared and bind-mounts it as rshared if needed. mountCmd and
-// mountArgs are expected to contain mount-like command, doMakeRShared will add
-// '--bind <path> <path>' and '--make-rshared <path>' to mountArgs.
-func doMakeRShared(path string, mountInfoFilename string) error {
-	shared, err := isShared(path, mountInfoFilename)
-	if err != nil {
-		return err
-	}
-	if shared {
-		glog.V(4).Infof("Directory %s is already on a shared mount", path)
-		return nil
-	}
-
-	glog.V(2).Infof("Bind-mounting %q with shared mount propagation", path)
-	// mount --bind /var/lib/kubelet /var/lib/kubelet
-	if err := syscall.Mount(path, path, "" /*fstype*/, syscall.MS_BIND, "" /*data*/); err != nil {
-		return fmt.Errorf("failed to bind-mount %s: %v", path, err)
-	}
-
-	// mount --make-rshared /var/lib/kubelet
-	if err := syscall.Mount(path, path, "" /*fstype*/, syscall.MS_SHARED|syscall.MS_REC, "" /*data*/); err != nil {
-		return fmt.Errorf("failed to make %s rshared: %v", path, err)
-	}
-
-	return nil
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/mount_unsupported.go b/vendor/k8s.io/kubernetes/pkg/util/mount/mount_unsupported.go
deleted file mode 100644
index 87d1e3748..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/mount_unsupported.go
+++ /dev/null
@@ -1,110 +0,0 @@
-// +build !linux,!windows
-
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"errors"
-)
-
-type Mounter struct {
-	mounterPath string
-}
-
-// New returns a mount.Interface for the current system.
-// It provides options to override the default mounter behavior.
-// mounterPath allows using an alternative to `/bin/mount` for mounting.
-func New(mounterPath string) Interface {
-	return &Mounter{
-		mounterPath: mounterPath,
-	}
-}
-
-func (mounter *Mounter) Mount(source string, target string, fstype string, options []string) error {
-	return nil
-}
-
-func (mounter *Mounter) Unmount(target string) error {
-	return nil
-}
-
-// GetMountRefs finds all other references to the device referenced
-// by mountPath; returns a list of paths.
-func GetMountRefs(mounter Interface, mountPath string) ([]string, error) {
-	return []string{}, nil
-}
-
-func (mounter *Mounter) List() ([]MountPoint, error) {
-	return []MountPoint{}, nil
-}
-
-func (mounter *Mounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return (mp.Path == dir)
-}
-
-func (mounter *Mounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(mounter, dir)
-}
-
-func (mounter *Mounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	return true, nil
-}
-
-func (mounter *Mounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return "", nil
-}
-
-func getDeviceNameFromMount(mounter Interface, mountPath, pluginDir string) (string, error) {
-	return "", nil
-}
-
-func (mounter *Mounter) DeviceOpened(pathname string) (bool, error) {
-	return false, nil
-}
-
-func (mounter *Mounter) PathIsDevice(pathname string) (bool, error) {
-	return true, nil
-}
-
-func (mounter *Mounter) MakeRShared(path string) error {
-	return nil
-}
-
-func (mounter *SafeFormatAndMount) formatAndMount(source string, target string, fstype string, options []string) error {
-	return mounter.Interface.Mount(source, target, fstype, options)
-}
-
-func (mounter *SafeFormatAndMount) diskLooksUnformatted(disk string) (bool, error) {
-	return true, nil
-}
-
-func (mounter *Mounter) GetFileType(pathname string) (FileType, error) {
-	return FileType("fake"), errors.New("not implemented")
-}
-
-func (mounter *Mounter) MakeDir(pathname string) error {
-	return nil
-}
-
-func (mounter *Mounter) MakeFile(pathname string) error {
-	return nil
-}
-
-func (mounter *Mounter) ExistsPath(pathname string) bool {
-	return true
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/mount_windows.go b/vendor/k8s.io/kubernetes/pkg/util/mount/mount_windows.go
deleted file mode 100644
index 0c63626ea..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/mount_windows.go
+++ /dev/null
@@ -1,346 +0,0 @@
-// +build windows
-
-/*
-Copyright 2017 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-
-	"github.com/golang/glog"
-)
-
-// Mounter provides the default implementation of mount.Interface
-// for the windows platform.  This implementation assumes that the
-// kubelet is running in the host's root mount namespace.
-type Mounter struct {
-	mounterPath string
-}
-
-// New returns a mount.Interface for the current system.
-// It provides options to override the default mounter behavior.
-// mounterPath allows using an alternative to `/bin/mount` for mounting.
-func New(mounterPath string) Interface {
-	return &Mounter{
-		mounterPath: mounterPath,
-	}
-}
-
-// Mount : mounts source to target as NTFS with given options.
-func (mounter *Mounter) Mount(source string, target string, fstype string, options []string) error {
-	target = normalizeWindowsPath(target)
-
-	if source == "tmpfs" {
-		glog.V(3).Infof("azureMount: mounting source (%q), target (%q), with options (%q)", source, target, options)
-		return os.MkdirAll(target, 0755)
-	}
-
-	parentDir := filepath.Dir(target)
-	if err := os.MkdirAll(parentDir, 0755); err != nil {
-		return err
-	}
-
-	glog.V(4).Infof("azureMount: mount options(%q) source:%q, target:%q, fstype:%q, begin to mount",
-		options, source, target, fstype)
-	bindSource := ""
-
-	// tell it's going to mount azure disk or azure file according to options
-	if bind, _ := isBind(options); bind {
-		// mount azure disk
-		bindSource = normalizeWindowsPath(source)
-	} else {
-		if len(options) < 2 {
-			glog.Warningf("azureMount: mount options(%q) command number(%d) less than 2, source:%q, target:%q, skip mounting",
-				options, len(options), source, target)
-			return nil
-		}
-
-		// currently only cifs mount is supported
-		if strings.ToLower(fstype) != "cifs" {
-			return fmt.Errorf("azureMount: only cifs mount is supported now, fstype: %q, mounting source (%q), target (%q), with options (%q)", fstype, source, target, options)
-		}
-
-		cmdLine := fmt.Sprintf(`$User = "%s";$PWord = ConvertTo-SecureString -String "%s" -AsPlainText -Force;`+
-			`$Credential = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $User, $PWord`,
-			options[0], options[1])
-
-		bindSource = source
-		cmdLine += fmt.Sprintf(";New-SmbGlobalMapping -RemotePath %s -Credential $Credential", source)
-
-		if output, err := exec.Command("powershell", "/c", cmdLine).CombinedOutput(); err != nil {
-			return fmt.Errorf("azureMount: SmbGlobalMapping failed: %v, only SMB mount is supported now, output: %q", err, string(output))
-		}
-	}
-
-	if output, err := exec.Command("cmd", "/c", "mklink", "/D", target, bindSource).CombinedOutput(); err != nil {
-		glog.Errorf("mklink failed: %v, source(%q) target(%q) output: %q", err, bindSource, target, string(output))
-		return err
-	}
-
-	return nil
-}
-
-// Unmount unmounts the target.
-func (mounter *Mounter) Unmount(target string) error {
-	glog.V(4).Infof("azureMount: Unmount target (%q)", target)
-	target = normalizeWindowsPath(target)
-	if output, err := exec.Command("cmd", "/c", "rmdir", target).CombinedOutput(); err != nil {
-		glog.Errorf("rmdir failed: %v, output: %q", err, string(output))
-		return err
-	}
-	return nil
-}
-
-// GetMountRefs finds all other references to the device(drive) referenced
-// by mountPath; returns a list of paths.
-func GetMountRefs(mounter Interface, mountPath string) ([]string, error) {
-	refs, err := getAllParentLinks(normalizeWindowsPath(mountPath))
-	if err != nil {
-		return nil, err
-	}
-	return refs, nil
-}
-
-// List returns a list of all mounted filesystems. todo
-func (mounter *Mounter) List() ([]MountPoint, error) {
-	return []MountPoint{}, nil
-}
-
-// IsMountPointMatch determines if the mountpoint matches the dir
-func (mounter *Mounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return mp.Path == dir
-}
-
-// IsNotMountPoint determines if a directory is a mountpoint.
-func (mounter *Mounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(mounter, dir)
-}
-
-// IsLikelyNotMountPoint determines if a directory is not a mountpoint.
-func (mounter *Mounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	stat, err := os.Lstat(file)
-	if err != nil {
-		return true, err
-	}
-	// If current file is a symlink, then it is a mountpoint.
-	if stat.Mode()&os.ModeSymlink != 0 {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-// GetDeviceNameFromMount given a mnt point, find the device
-func (mounter *Mounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return getDeviceNameFromMount(mounter, mountPath, pluginDir)
-}
-
-// getDeviceNameFromMount find the device(drive) name in which
-// the mount path reference should match the given plugin directory. In case no mount path reference
-// matches, returns the volume name taken from its given mountPath
-func getDeviceNameFromMount(mounter Interface, mountPath, pluginDir string) (string, error) {
-	refs, err := GetMountRefs(mounter, mountPath)
-	if err != nil {
-		glog.V(4).Infof("GetMountRefs failed for mount path %q: %v", mountPath, err)
-		return "", err
-	}
-	if len(refs) == 0 {
-		return "", fmt.Errorf("directory %s is not mounted", mountPath)
-	}
-	basemountPath := normalizeWindowsPath(path.Join(pluginDir, MountsInGlobalPDPath))
-	for _, ref := range refs {
-		if strings.Contains(ref, basemountPath) {
-			volumeID, err := filepath.Rel(normalizeWindowsPath(basemountPath), ref)
-			if err != nil {
-				glog.Errorf("Failed to get volume id from mount %s - %v", mountPath, err)
-				return "", err
-			}
-			return volumeID, nil
-		}
-	}
-
-	return path.Base(mountPath), nil
-}
-
-// DeviceOpened determines if the device is in use elsewhere
-func (mounter *Mounter) DeviceOpened(pathname string) (bool, error) {
-	return false, nil
-}
-
-// PathIsDevice determines if a path is a device.
-func (mounter *Mounter) PathIsDevice(pathname string) (bool, error) {
-	return false, nil
-}
-
-// MakeRShared checks that given path is on a mount with 'rshared' mount
-// propagation. Empty implementation here.
-func (mounter *Mounter) MakeRShared(path string) error {
-	return nil
-}
-
-// GetFileType checks for sockets/block/character devices
-func (mounter *Mounter) GetFileType(pathname string) (FileType, error) {
-	var pathType FileType
-	info, err := os.Stat(pathname)
-	if os.IsNotExist(err) {
-		return pathType, fmt.Errorf("path %q does not exist", pathname)
-	}
-	// err in call to os.Stat
-	if err != nil {
-		return pathType, err
-	}
-
-	mode := info.Sys().(*syscall.Win32FileAttributeData).FileAttributes
-	switch mode & syscall.S_IFMT {
-	case syscall.S_IFSOCK:
-		return FileTypeSocket, nil
-	case syscall.S_IFBLK:
-		return FileTypeBlockDev, nil
-	case syscall.S_IFCHR:
-		return FileTypeCharDev, nil
-	case syscall.S_IFDIR:
-		return FileTypeDirectory, nil
-	case syscall.S_IFREG:
-		return FileTypeFile, nil
-	}
-
-	return pathType, fmt.Errorf("only recognise file, directory, socket, block device and character device")
-}
-
-// MakeFile creates a new directory
-func (mounter *Mounter) MakeDir(pathname string) error {
-	err := os.MkdirAll(pathname, os.FileMode(0755))
-	if err != nil {
-		if !os.IsExist(err) {
-			return err
-		}
-	}
-	return nil
-}
-
-// MakeFile creates an empty file
-func (mounter *Mounter) MakeFile(pathname string) error {
-	f, err := os.OpenFile(pathname, os.O_CREATE, os.FileMode(0644))
-	defer f.Close()
-	if err != nil {
-		if !os.IsExist(err) {
-			return err
-		}
-	}
-	return nil
-}
-
-// ExistsPath checks whether the path exists
-func (mounter *Mounter) ExistsPath(pathname string) bool {
-	_, err := os.Stat(pathname)
-	if err != nil {
-		return false
-	}
-	return true
-}
-
-func (mounter *SafeFormatAndMount) formatAndMount(source string, target string, fstype string, options []string) error {
-	// Try to mount the disk
-	glog.V(4).Infof("Attempting to formatAndMount disk: %s %s %s", fstype, source, target)
-
-	if err := ValidateDiskNumber(source); err != nil {
-		glog.Errorf("azureMount: formatAndMount failed, err: %v\n", err)
-		return err
-	}
-
-	driveLetter, err := getDriveLetterByDiskNumber(source, mounter.Exec)
-	if err != nil {
-		return err
-	}
-	driverPath := driveLetter + ":"
-	target = normalizeWindowsPath(target)
-	glog.V(4).Infof("Attempting to formatAndMount disk: %s %s %s", fstype, driverPath, target)
-	if output, err := mounter.Exec.Run("cmd", "/c", "mklink", "/D", target, driverPath); err != nil {
-		glog.Errorf("mklink failed: %v, output: %q", err, string(output))
-		return err
-	}
-	return nil
-}
-
-func normalizeWindowsPath(path string) string {
-	normalizedPath := strings.Replace(path, "/", "\\", -1)
-	if strings.HasPrefix(normalizedPath, "\\") {
-		normalizedPath = "c:" + normalizedPath
-	}
-	return normalizedPath
-}
-
-// ValidateDiskNumber : disk number should be a number in [0, 99]
-func ValidateDiskNumber(disk string) error {
-	diskNum, err := strconv.Atoi(disk)
-	if err != nil {
-		return fmt.Errorf("wrong disk number format: %q, err:%v", disk, err)
-	}
-
-	if diskNum < 0 || diskNum > 99 {
-		return fmt.Errorf("disk number out of range: %q", disk)
-	}
-
-	return nil
-}
-
-// Get drive letter according to windows disk number
-func getDriveLetterByDiskNumber(diskNum string, exec Exec) (string, error) {
-	cmd := fmt.Sprintf("(Get-Partition -DiskNumber %s).DriveLetter", diskNum)
-	output, err := exec.Run("powershell", "/c", cmd)
-	if err != nil {
-		return "", fmt.Errorf("azureMount: Get Drive Letter failed: %v, output: %q", err, string(output))
-	}
-	if len(string(output)) < 1 {
-		return "", fmt.Errorf("azureMount: Get Drive Letter failed, output is empty")
-	}
-	return string(output)[:1], nil
-}
-
-// getAllParentLinks walks all symbolic links and return all the parent targets recursively
-func getAllParentLinks(path string) ([]string, error) {
-	const maxIter = 255
-	links := []string{}
-	for {
-		links = append(links, path)
-		if len(links) > maxIter {
-			return links, fmt.Errorf("unexpected length of parent links: %v", links)
-		}
-
-		fi, err := os.Lstat(path)
-		if err != nil {
-			return links, fmt.Errorf("Lstat: %v", err)
-		}
-		if fi.Mode()&os.ModeSymlink == 0 {
-			break
-		}
-
-		path, err = os.Readlink(path)
-		if err != nil {
-			return links, fmt.Errorf("Readlink error: %v", err)
-		}
-	}
-
-	return links, nil
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount.go b/vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount.go
deleted file mode 100644
index 99e81837f..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount.go
+++ /dev/null
@@ -1,272 +0,0 @@
-// +build linux
-
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/golang/glog"
-	"k8s.io/kubernetes/pkg/util/nsenter"
-)
-
-const (
-	// hostProcMountsPath is the default mount path for rootfs
-	hostProcMountsPath = "/rootfs/proc/1/mounts"
-	// hostProcMountinfoPath is the default mount info path for rootfs
-	hostProcMountinfoPath = "/rootfs/proc/1/mountinfo"
-)
-
-// Currently, all docker containers receive their own mount namespaces.
-// NsenterMounter works by executing nsenter to run commands in
-// the host's mount namespace.
-type NsenterMounter struct {
-	ne *nsenter.Nsenter
-}
-
-func NewNsenterMounter() *NsenterMounter {
-	return &NsenterMounter{ne: nsenter.NewNsenter()}
-}
-
-// NsenterMounter implements mount.Interface
-var _ = Interface(&NsenterMounter{})
-
-// Mount runs mount(8) in the host's root mount namespace.  Aside from this
-// aspect, Mount has the same semantics as the mounter returned by mount.New()
-func (n *NsenterMounter) Mount(source string, target string, fstype string, options []string) error {
-	bind, bindRemountOpts := isBind(options)
-
-	if bind {
-		err := n.doNsenterMount(source, target, fstype, []string{"bind"})
-		if err != nil {
-			return err
-		}
-		return n.doNsenterMount(source, target, fstype, bindRemountOpts)
-	}
-
-	return n.doNsenterMount(source, target, fstype, options)
-}
-
-// doNsenterMount nsenters the host's mount namespace and performs the
-// requested mount.
-func (n *NsenterMounter) doNsenterMount(source, target, fstype string, options []string) error {
-	glog.V(5).Infof("nsenter mount %s %s %s %v", source, target, fstype, options)
-	cmd, args := n.makeNsenterArgs(source, target, fstype, options)
-	outputBytes, err := n.ne.Exec(cmd, args).CombinedOutput()
-	if len(outputBytes) != 0 {
-		glog.V(5).Infof("Output of mounting %s to %s: %v", source, target, string(outputBytes))
-	}
-	return err
-}
-
-// makeNsenterArgs makes a list of argument to nsenter in order to do the
-// requested mount.
-func (n *NsenterMounter) makeNsenterArgs(source, target, fstype string, options []string) (string, []string) {
-	mountCmd := n.ne.AbsHostPath("mount")
-	mountArgs := makeMountArgs(source, target, fstype, options)
-
-	if systemdRunPath, hasSystemd := n.ne.SupportsSystemd(); hasSystemd {
-		// Complete command line:
-		// nsenter --mount=/rootfs/proc/1/ns/mnt -- /bin/systemd-run --description=... --scope -- /bin/mount -t <type> <what> <where>
-		// Expected flow is:
-		// * nsenter breaks out of container's mount namespace and executes
-		//   host's systemd-run.
-		// * systemd-run creates a transient scope (=~ cgroup) and executes its
-		//   argument (/bin/mount) there.
-		// * mount does its job, forks a fuse daemon if necessary and finishes.
-		//   (systemd-run --scope finishes at this point, returning mount's exit
-		//   code and stdout/stderr - thats one of --scope benefits).
-		// * systemd keeps the fuse daemon running in the scope (i.e. in its own
-		//   cgroup) until the fuse daemon dies (another --scope benefit).
-		//   Kubelet container can be restarted and the fuse daemon survives.
-		// * When the daemon dies (e.g. during unmount) systemd removes the
-		//   scope automatically.
-		mountCmd, mountArgs = addSystemdScope(systemdRunPath, target, mountCmd, mountArgs)
-	} else {
-		// Fall back to simple mount when the host has no systemd.
-		// Complete command line:
-		// nsenter --mount=/rootfs/proc/1/ns/mnt -- /bin/mount -t <type> <what> <where>
-		// Expected flow is:
-		// * nsenter breaks out of container's mount namespace and executes host's /bin/mount.
-		// * mount does its job, forks a fuse daemon if necessary and finishes.
-		// * Any fuse daemon runs in cgroup of kubelet docker container,
-		//   restart of kubelet container will kill it!
-
-		// No code here, mountCmd and mountArgs use /bin/mount
-	}
-
-	return mountCmd, mountArgs
-}
-
-// Unmount runs umount(8) in the host's mount namespace.
-func (n *NsenterMounter) Unmount(target string) error {
-	args := []string{target}
-	// No need to execute systemd-run here, it's enough that unmount is executed
-	// in the host's mount namespace. It will finish appropriate fuse daemon(s)
-	// running in any scope.
-	glog.V(5).Infof("nsenter unmount args: %v", args)
-	outputBytes, err := n.ne.Exec("umount", args).CombinedOutput()
-	if len(outputBytes) != 0 {
-		glog.V(5).Infof("Output of unmounting %s: %v", target, string(outputBytes))
-	}
-	return err
-}
-
-// List returns a list of all mounted filesystems in the host's mount namespace.
-func (*NsenterMounter) List() ([]MountPoint, error) {
-	return listProcMounts(hostProcMountsPath)
-}
-
-func (m *NsenterMounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(m, dir)
-}
-
-func (*NsenterMounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	deletedDir := fmt.Sprintf("%s\\040(deleted)", dir)
-	return (mp.Path == dir) || (mp.Path == deletedDir)
-}
-
-// IsLikelyNotMountPoint determines whether a path is a mountpoint by calling findmnt
-// in the host's root mount namespace.
-func (n *NsenterMounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	file, err := filepath.Abs(file)
-	if err != nil {
-		return true, err
-	}
-
-	// Check the directory exists
-	if _, err = os.Stat(file); os.IsNotExist(err) {
-		glog.V(5).Infof("findmnt: directory %s does not exist", file)
-		return true, err
-	}
-	// Add --first-only option: since we are testing for the absence of a mountpoint, it is sufficient to get only
-	// the first of multiple possible mountpoints using --first-only.
-	// Also add fstype output to make sure that the output of target file will give the full path
-	// TODO: Need more refactoring for this function. Track the solution with issue #26996
-	args := []string{"-o", "target,fstype", "--noheadings", "--first-only", "--target", file}
-	glog.V(5).Infof("nsenter findmnt args: %v", args)
-	out, err := n.ne.Exec("findmnt", args).CombinedOutput()
-	if err != nil {
-		glog.V(2).Infof("Failed findmnt command for path %s: %s %v", file, out, err)
-		// Different operating systems behave differently for paths which are not mount points.
-		// On older versions (e.g. 2.20.1) we'd get error, on newer ones (e.g. 2.26.2) we'd get "/".
-		// It's safer to assume that it's not a mount point.
-		return true, nil
-	}
-	mountTarget, err := parseFindMnt(string(out))
-	if err != nil {
-		return false, err
-	}
-
-	glog.V(5).Infof("IsLikelyNotMountPoint findmnt output for path %s: %v:", file, mountTarget)
-
-	if mountTarget == file {
-		glog.V(5).Infof("IsLikelyNotMountPoint: %s is a mount point", file)
-		return false, nil
-	}
-	glog.V(5).Infof("IsLikelyNotMountPoint: %s is not a mount point", file)
-	return true, nil
-}
-
-// parse output of "findmnt -o target,fstype" and return just the target
-func parseFindMnt(out string) (string, error) {
-	// cut trailing newline
-	out = strings.TrimSuffix(out, "\n")
-	// cut everything after the last space - it's the filesystem type
-	i := strings.LastIndex(out, " ")
-	if i == -1 {
-		return "", fmt.Errorf("error parsing findmnt output, expected at least one space: %q", out)
-	}
-	return out[:i], nil
-}
-
-// DeviceOpened checks if block device in use by calling Open with O_EXCL flag.
-// Returns true if open returns errno EBUSY, and false if errno is nil.
-// Returns an error if errno is any error other than EBUSY.
-// Returns with error if pathname is not a device.
-func (n *NsenterMounter) DeviceOpened(pathname string) (bool, error) {
-	return exclusiveOpenFailsOnDevice(pathname)
-}
-
-// PathIsDevice uses FileInfo returned from os.Stat to check if path refers
-// to a device.
-func (n *NsenterMounter) PathIsDevice(pathname string) (bool, error) {
-	pathType, err := n.GetFileType(pathname)
-	isDevice := pathType == FileTypeCharDev || pathType == FileTypeBlockDev
-	return isDevice, err
-}
-
-//GetDeviceNameFromMount given a mount point, find the volume id from checking /proc/mounts
-func (n *NsenterMounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return getDeviceNameFromMount(n, mountPath, pluginDir)
-}
-
-func (n *NsenterMounter) MakeRShared(path string) error {
-	return doMakeRShared(path, hostProcMountinfoPath)
-}
-
-func (mounter *NsenterMounter) GetFileType(pathname string) (FileType, error) {
-	var pathType FileType
-	outputBytes, err := mounter.ne.Exec("stat", []string{"-L", `--printf "%F"`, pathname}).CombinedOutput()
-	if err != nil {
-		return pathType, err
-	}
-
-	switch string(outputBytes) {
-	case "socket":
-		return FileTypeSocket, nil
-	case "character special file":
-		return FileTypeCharDev, nil
-	case "block special file":
-		return FileTypeBlockDev, nil
-	case "directory":
-		return FileTypeDirectory, nil
-	case "regular file":
-		return FileTypeFile, nil
-	}
-
-	return pathType, fmt.Errorf("only recognise file, directory, socket, block device and character device")
-}
-
-func (mounter *NsenterMounter) MakeDir(pathname string) error {
-	args := []string{"-p", pathname}
-	if _, err := mounter.ne.Exec("mkdir", args).CombinedOutput(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (mounter *NsenterMounter) MakeFile(pathname string) error {
-	args := []string{pathname}
-	if _, err := mounter.ne.Exec("touch", args).CombinedOutput(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (mounter *NsenterMounter) ExistsPath(pathname string) bool {
-	args := []string{pathname}
-	_, err := mounter.ne.Exec("ls", args).CombinedOutput()
-	if err == nil {
-		return true
-	}
-	return false
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount_unsupported.go b/vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount_unsupported.go
deleted file mode 100644
index f4eb692f9..000000000
--- a/vendor/k8s.io/kubernetes/pkg/util/mount/nsenter_mount_unsupported.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// +build !linux
-
-/*
-Copyright 2014 The Kubernetes Authors.
-
-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.
-*/
-
-package mount
-
-import (
-	"errors"
-)
-
-type NsenterMounter struct{}
-
-func NewNsenterMounter() *NsenterMounter {
-	return &NsenterMounter{}
-}
-
-var _ = Interface(&NsenterMounter{})
-
-func (*NsenterMounter) Mount(source string, target string, fstype string, options []string) error {
-	return nil
-}
-
-func (*NsenterMounter) Unmount(target string) error {
-	return nil
-}
-
-func (*NsenterMounter) List() ([]MountPoint, error) {
-	return []MountPoint{}, nil
-}
-
-func (m *NsenterMounter) IsNotMountPoint(dir string) (bool, error) {
-	return IsNotMountPoint(m, dir)
-}
-
-func (*NsenterMounter) IsMountPointMatch(mp MountPoint, dir string) bool {
-	return (mp.Path == dir)
-}
-
-func (*NsenterMounter) IsLikelyNotMountPoint(file string) (bool, error) {
-	return true, nil
-}
-
-func (*NsenterMounter) DeviceOpened(pathname string) (bool, error) {
-	return false, nil
-}
-
-func (*NsenterMounter) PathIsDevice(pathname string) (bool, error) {
-	return true, nil
-}
-
-func (*NsenterMounter) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
-	return "", nil
-}
-
-func (*NsenterMounter) MakeRShared(path string) error {
-	return nil
-}
-
-func (*NsenterMounter) GetFileType(_ string) (FileType, error) {
-	return FileType("fake"), errors.New("not implemented")
-}
-
-func (*NsenterMounter) MakeDir(pathname string) error {
-	return nil
-}
-
-func (*NsenterMounter) MakeFile(pathname string) error {
-	return nil
-}
-
-func (*NsenterMounter) ExistsPath(pathname string) bool {
-	return true
-}