From 069fdc8a083cb1663e4f86fe3fd9b9a1aebc3e54 Mon Sep 17 00:00:00 2001 From: Christopher Jones Date: Tue, 23 May 2017 10:22:32 -0400 Subject: [PATCH] [project] change syscall to /x/sys/unix|windows Changes most references of syscall to golang.org/x/sys/ Ones aren't changes include, Errno, Signal and SysProcAttr as they haven't been implemented in /x/sys/. Signed-off-by: Christopher Jones [s390x] switch utsname from unsigned to signed per https://github.com/golang/sys/commit/33267e036fd93fcd26ea95b7bdaf2d8306cb743c char in s390x in the /x/sys/unix package is now signed, so change the buildtags Signed-off-by: Christopher Jones --- cmd/dockerd/daemon_solaris.go | 6 +- cmd/dockerd/daemon_unix.go | 8 +- cmd/dockerd/daemon_windows.go | 6 +- cmd/dockerd/service_windows.go | 13 ++- daemon/container_operations_unix.go | 10 +-- daemon/debugtrap_unix.go | 4 +- daemon/debugtrap_windows.go | 6 +- daemon/graphdriver/aufs/aufs.go | 14 ++-- daemon/graphdriver/aufs/mount.go | 4 +- daemon/graphdriver/aufs/mount_linux.go | 4 +- daemon/graphdriver/btrfs/btrfs.go | 26 +++--- daemon/graphdriver/devmapper/deviceset.go | 19 +++-- daemon/graphdriver/driver_freebsd.go | 4 +- daemon/graphdriver/driver_linux.go | 10 +-- .../graphdriver/graphtest/graphtest_unix.go | 6 +- daemon/graphdriver/graphtest/testutil_unix.go | 5 +- daemon/graphdriver/overlay/copy.go | 5 +- daemon/graphdriver/overlay/overlay.go | 8 +- daemon/graphdriver/overlay2/check.go | 6 +- daemon/graphdriver/overlay2/mount.go | 4 +- daemon/graphdriver/overlay2/overlay.go | 10 +-- daemon/graphdriver/overlay2/overlay_test.go | 4 +- daemon/graphdriver/overlay2/randomid.go | 3 +- daemon/graphdriver/quota/projectquota.go | 15 ++-- daemon/graphdriver/windows/windows.go | 10 +-- daemon/graphdriver/zfs/zfs.go | 8 +- daemon/graphdriver/zfs/zfs_freebsd.go | 6 +- daemon/graphdriver/zfs/zfs_linux.go | 6 +- daemon/initlayer/setup_unix.go | 4 +- daemon/logger/etwlogs/etwlogs_windows.go | 13 ++- daemon/metrics_unix.go | 4 +- daemon/oci_windows.go | 5 +- distribution/errors.go | 2 +- integration-cli/daemon/daemon_unix.go | 8 +- integration-cli/daemon/daemon_windows.go | 10 +-- .../docker_api_swarm_service_test.go | 4 +- .../docker_cli_daemon_plugins_test.go | 4 +- integration-cli/docker_cli_daemon_test.go | 24 +++--- .../docker_cli_events_unix_test.go | 6 +- .../docker_cli_network_unix_test.go | 10 +-- libcontainerd/client_linux.go | 14 ++-- libcontainerd/container_unix.go | 14 ++-- libcontainerd/container_windows.go | 6 +- libcontainerd/remote_unix.go | 8 +- libcontainerd/utils_linux.go | 3 +- pkg/archive/archive_linux.go | 6 +- pkg/archive/archive_linux_test.go | 3 +- pkg/archive/archive_unix.go | 11 +-- pkg/archive/archive_unix_test.go | 7 +- pkg/archive/changes_linux.go | 7 +- pkg/archive/changes_unix.go | 5 +- pkg/chrootarchive/chroot_linux.go | 18 ++--- pkg/chrootarchive/chroot_unix.go | 6 +- pkg/devicemapper/devmapper.go | 4 +- pkg/devicemapper/ioctl.go | 7 +- pkg/fsutils/fsutils_linux.go | 13 +-- pkg/fsutils/fsutils_linux_test.go | 7 +- pkg/loopback/attach_loopback.go | 4 +- pkg/loopback/ioctl.go | 15 ++-- pkg/mount/flags_linux.go | 48 +++++------ pkg/mount/mounter_freebsd.go | 5 +- pkg/mount/mounter_linux.go | 18 ++--- pkg/mount/sharedsubtree_linux_test.go | 5 +- pkg/parsers/kernel/kernel_windows.go | 21 ++--- pkg/parsers/kernel/uname_linux.go | 14 ++-- .../operatingsystem_windows.go | 19 ++--- pkg/pidfile/pidfile_darwin.go | 4 +- pkg/pidfile/pidfile_windows.go | 10 ++- pkg/platform/architecture_linux.go | 6 +- pkg/platform/utsname_int8.go | 4 +- pkg/platform/utsname_int8_test.go | 2 +- pkg/platform/utsname_uint8.go | 4 +- pkg/platform/utsname_uint8_test.go | 2 +- pkg/reexec/command_linux.go | 4 +- pkg/signal/signal_linux.go | 72 +++++++++-------- pkg/symlink/fs_windows.go | 20 ++--- pkg/sysinfo/numcpu_linux.go | 7 +- pkg/sysinfo/sysinfo_linux.go | 6 +- pkg/system/chtimes_windows.go | 19 ++--- pkg/system/events_windows.go | 24 +++--- pkg/system/filesys_windows.go | 80 +++++++++---------- pkg/system/lstat_unix.go | 4 +- pkg/system/mknod.go | 4 +- pkg/system/process_unix.go | 8 +- pkg/system/stat_unix.go | 4 +- pkg/system/syscall_unix.go | 4 +- pkg/system/syscall_windows.go | 14 ++-- pkg/system/umask.go | 4 +- pkg/system/utimes_freebsd.go | 8 +- pkg/system/utimes_linux.go | 13 ++- pkg/system/xattrs_linux.go | 21 ++--- plugin/manager_linux.go | 6 +- profiles/seccomp/seccomp_default.go | 7 +- 93 files changed, 499 insertions(+), 474 deletions(-) diff --git a/cmd/dockerd/daemon_solaris.go b/cmd/dockerd/daemon_solaris.go index e12da525a5..dab4d4aaad 100644 --- a/cmd/dockerd/daemon_solaris.go +++ b/cmd/dockerd/daemon_solaris.go @@ -7,10 +7,10 @@ import ( "net" "os" "path/filepath" - "syscall" "github.com/docker/docker/libcontainerd" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/unix" ) const defaultDaemonConfigFile = "" @@ -30,8 +30,8 @@ func currentUserIsOwner(f string) bool { // caused by custom umask func setDefaultUmask() error { desiredUmask := 0022 - syscall.Umask(desiredUmask) - if umask := syscall.Umask(desiredUmask); umask != desiredUmask { + unix.Umask(desiredUmask) + if umask := unix.Umask(desiredUmask); umask != desiredUmask { return fmt.Errorf("failed to set umask: expected %#o, got %#o", desiredUmask, umask) } diff --git a/cmd/dockerd/daemon_unix.go b/cmd/dockerd/daemon_unix.go index 46ef58541f..7909d98da5 100644 --- a/cmd/dockerd/daemon_unix.go +++ b/cmd/dockerd/daemon_unix.go @@ -9,12 +9,12 @@ import ( "os/signal" "path/filepath" "strconv" - "syscall" "github.com/docker/docker/cmd/dockerd/hack" "github.com/docker/docker/daemon" "github.com/docker/docker/libcontainerd" "github.com/docker/libnetwork/portallocator" + "golang.org/x/sys/unix" ) const defaultDaemonConfigFile = "/etc/docker/daemon.json" @@ -23,8 +23,8 @@ const defaultDaemonConfigFile = "/etc/docker/daemon.json" // caused by custom umask func setDefaultUmask() error { desiredUmask := 0022 - syscall.Umask(desiredUmask) - if umask := syscall.Umask(desiredUmask); umask != desiredUmask { + unix.Umask(desiredUmask) + if umask := unix.Umask(desiredUmask); umask != desiredUmask { return fmt.Errorf("failed to set umask: expected %#o, got %#o", desiredUmask, umask) } @@ -38,7 +38,7 @@ func getDaemonConfDir(_ string) string { // setupConfigReloadTrap configures the USR2 signal to reload the configuration. func (cli *DaemonCli) setupConfigReloadTrap() { c := make(chan os.Signal, 1) - signal.Notify(c, syscall.SIGHUP) + signal.Notify(c, unix.SIGHUP) go func() { for range c { cli.reloadConfig() diff --git a/cmd/dockerd/daemon_windows.go b/cmd/dockerd/daemon_windows.go index 6682cc8cda..2e9598d4cf 100644 --- a/cmd/dockerd/daemon_windows.go +++ b/cmd/dockerd/daemon_windows.go @@ -5,11 +5,11 @@ import ( "net" "os" "path/filepath" - "syscall" "github.com/Sirupsen/logrus" "github.com/docker/docker/libcontainerd" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/windows" ) var defaultDaemonConfigFile = "" @@ -58,14 +58,14 @@ func notifyShutdown(err error) { // setupConfigReloadTrap configures a Win32 event to reload the configuration. func (cli *DaemonCli) setupConfigReloadTrap() { go func() { - sa := syscall.SecurityAttributes{ + sa := windows.SecurityAttributes{ Length: 0, } ev := "Global\\docker-daemon-config-" + fmt.Sprint(os.Getpid()) if h, _ := system.CreateEvent(&sa, false, false, ev); h != 0 { logrus.Debugf("Config reload - waiting signal at %s", ev) for { - syscall.WaitForSingleObject(h, syscall.INFINITE) + windows.WaitForSingleObject(h, windows.INFINITE) cli.reloadConfig() } } diff --git a/cmd/dockerd/service_windows.go b/cmd/dockerd/service_windows.go index 749cc9009e..87d57e41f6 100644 --- a/cmd/dockerd/service_windows.go +++ b/cmd/dockerd/service_windows.go @@ -9,7 +9,6 @@ import ( "os" "os/exec" "path/filepath" - "syscall" "time" "unsafe" @@ -30,7 +29,7 @@ var ( flRunService *bool setStdHandle = windows.NewLazySystemDLL("kernel32.dll").NewProc("SetStdHandle") - oldStderr syscall.Handle + oldStderr windows.Handle panicFile *os.File service *handler @@ -131,14 +130,14 @@ func (h *etwHook) Fire(e *logrus.Entry) error { err error ) - ss[0], err = syscall.UTF16PtrFromString(e.Message) + ss[0], err = windows.UTF16PtrFromString(e.Message) if err != nil { return err } count := uint16(1) if exts != "" { - ss[1], err = syscall.UTF16PtrFromString(exts) + ss[1], err = windows.UTF16PtrFromString(exts) if err != nil { return err } @@ -397,8 +396,8 @@ func initPanicFile(path string) error { // Update STD_ERROR_HANDLE to point to the panic file so that Go writes to // it when it panics. Remember the old stderr to restore it before removing // the panic file. - sh := syscall.STD_ERROR_HANDLE - h, err := syscall.GetStdHandle(sh) + sh := windows.STD_ERROR_HANDLE + h, err := windows.GetStdHandle(sh) if err != nil { return err } @@ -422,7 +421,7 @@ func initPanicFile(path string) error { func removePanicFile() { if st, err := panicFile.Stat(); err == nil { if st.Size() == 0 { - sh := syscall.STD_ERROR_HANDLE + sh := windows.STD_ERROR_HANDLE setStdHandle.Call(uintptr(sh), uintptr(oldStderr)) panicFile.Close() os.Remove(panicFile.Name()) diff --git a/daemon/container_operations_unix.go b/daemon/container_operations_unix.go index 09c2b7df18..8c1b44b601 100644 --- a/daemon/container_operations_unix.go +++ b/daemon/container_operations_unix.go @@ -9,7 +9,6 @@ import ( "os" "path/filepath" "strconv" - "syscall" "time" "github.com/Sirupsen/logrus" @@ -22,6 +21,7 @@ import ( "github.com/docker/libnetwork" "github.com/opencontainers/selinux/go-selinux/label" "github.com/pkg/errors" + "golang.org/x/sys/unix" ) func (daemon *Daemon) setupLinkedContainers(container *container.Container) ([]string, error) { @@ -125,7 +125,7 @@ func (daemon *Daemon) setupIpcDirs(c *container.Container) error { shmSize = c.HostConfig.ShmSize } shmproperty := "mode=1777,size=" + strconv.FormatInt(shmSize, 10) - if err := syscall.Mount("shm", shmPath, "tmpfs", uintptr(syscall.MS_NOEXEC|syscall.MS_NOSUID|syscall.MS_NODEV), label.FormatMountLabel(shmproperty, c.GetMountLabel())); err != nil { + if err := unix.Mount("shm", shmPath, "tmpfs", uintptr(unix.MS_NOEXEC|unix.MS_NOSUID|unix.MS_NODEV), label.FormatMountLabel(shmproperty, c.GetMountLabel())); err != nil { return fmt.Errorf("mounting shm tmpfs: %s", err) } if err := os.Chown(shmPath, rootIDs.UID, rootIDs.GID); err != nil { @@ -301,8 +301,8 @@ func killProcessDirectly(cntr *container.Container) error { // Ensure that we don't kill ourselves if pid := cntr.GetPID(); pid != 0 { logrus.Infof("Container %s failed to exit within 10 seconds of kill - trying direct SIGKILL", stringid.TruncateID(cntr.ID)) - if err := syscall.Kill(pid, 9); err != nil { - if err != syscall.ESRCH { + if err := unix.Kill(pid, 9); err != nil { + if err != unix.ESRCH { return err } e := errNoSuchProcess{pid, 9} @@ -315,7 +315,7 @@ func killProcessDirectly(cntr *container.Container) error { } func detachMounted(path string) error { - return syscall.Unmount(path, syscall.MNT_DETACH) + return unix.Unmount(path, unix.MNT_DETACH) } func isLinkable(child *container.Container) bool { diff --git a/daemon/debugtrap_unix.go b/daemon/debugtrap_unix.go index 8605d1d2b5..39298dfd62 100644 --- a/daemon/debugtrap_unix.go +++ b/daemon/debugtrap_unix.go @@ -5,15 +5,15 @@ package daemon import ( "os" "os/signal" - "syscall" "github.com/Sirupsen/logrus" stackdump "github.com/docker/docker/pkg/signal" + "golang.org/x/sys/unix" ) func (d *Daemon) setupDumpStackTrap(root string) { c := make(chan os.Signal, 1) - signal.Notify(c, syscall.SIGUSR1) + signal.Notify(c, unix.SIGUSR1) go func() { for range c { path, err := stackdump.DumpStacks(root) diff --git a/daemon/debugtrap_windows.go b/daemon/debugtrap_windows.go index d01f7f332d..dfaf953244 100644 --- a/daemon/debugtrap_windows.go +++ b/daemon/debugtrap_windows.go @@ -3,13 +3,13 @@ package daemon import ( "fmt" "os" - "syscall" "unsafe" winio "github.com/Microsoft/go-winio" "github.com/Sirupsen/logrus" "github.com/docker/docker/pkg/signal" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/windows" ) func (d *Daemon) setupDumpStackTrap(root string) { @@ -22,7 +22,7 @@ func (d *Daemon) setupDumpStackTrap(root string) { logrus.Errorf("failed to get security descriptor for debug stackdump event %s: %s", ev, err.Error()) return } - var sa syscall.SecurityAttributes + var sa windows.SecurityAttributes sa.Length = uint32(unsafe.Sizeof(sa)) sa.InheritHandle = 1 sa.SecurityDescriptor = uintptr(unsafe.Pointer(&sd[0])) @@ -34,7 +34,7 @@ func (d *Daemon) setupDumpStackTrap(root string) { go func() { logrus.Debugf("Stackdump - waiting signal at %s", ev) for { - syscall.WaitForSingleObject(h, syscall.INFINITE) + windows.WaitForSingleObject(h, windows.INFINITE) path, err := signal.DumpStacks(root) if err != nil { logrus.WithError(err).Error("failed to write goroutines dump") diff --git a/daemon/graphdriver/aufs/aufs.go b/daemon/graphdriver/aufs/aufs.go index b245143e1e..c68c98cf80 100644 --- a/daemon/graphdriver/aufs/aufs.go +++ b/daemon/graphdriver/aufs/aufs.go @@ -33,12 +33,9 @@ import ( "path/filepath" "strings" "sync" - "syscall" "time" "github.com/Sirupsen/logrus" - "github.com/vbatts/tar-split/tar/storage" - "github.com/docker/docker/daemon/graphdriver" "github.com/docker/docker/pkg/archive" "github.com/docker/docker/pkg/chrootarchive" @@ -47,9 +44,10 @@ import ( "github.com/docker/docker/pkg/locker" mountpk "github.com/docker/docker/pkg/mount" "github.com/docker/docker/pkg/system" - rsystem "github.com/opencontainers/runc/libcontainer/system" "github.com/opencontainers/selinux/go-selinux/label" + "github.com/vbatts/tar-split/tar/storage" + "golang.org/x/sys/unix" ) var ( @@ -295,7 +293,7 @@ func (a *Driver) Remove(id string) error { } if err := a.unmount(mountpoint); err != nil { - if err != syscall.EBUSY { + if err != unix.EBUSY { return fmt.Errorf("aufs: unmount error: %s: %v", mountpoint, err) } if retries >= 5 { @@ -315,7 +313,7 @@ func (a *Driver) Remove(id string) error { // the whole tree. tmpMntPath := path.Join(a.mntPath(), fmt.Sprintf("%s-removing", id)) if err := os.Rename(mountpoint, tmpMntPath); err != nil && !os.IsNotExist(err) { - if err == syscall.EBUSY { + if err == unix.EBUSY { logrus.Warn("os.Rename err due to EBUSY") } return err @@ -575,7 +573,7 @@ func (a *Driver) aufsMount(ro []string, rw, target, mountLabel string) (err erro if useDirperm() { offset += len(",dirperm1") } - b := make([]byte, syscall.Getpagesize()-len(mountLabel)-offset) // room for xino & mountLabel + b := make([]byte, unix.Getpagesize()-len(mountLabel)-offset) // room for xino & mountLabel bp := copy(b, fmt.Sprintf("br:%s=rw", rw)) index := 0 @@ -599,7 +597,7 @@ func (a *Driver) aufsMount(ro []string, rw, target, mountLabel string) (err erro for ; index < len(ro); index++ { layer := fmt.Sprintf(":%s=ro+wh", ro[index]) data := label.FormatMountLabel(fmt.Sprintf("append%s", layer), mountLabel) - if err = mount("none", target, "aufs", syscall.MS_REMOUNT, data); err != nil { + if err = mount("none", target, "aufs", unix.MS_REMOUNT, data); err != nil { return } } diff --git a/daemon/graphdriver/aufs/mount.go b/daemon/graphdriver/aufs/mount.go index da1e892f44..890213b80e 100644 --- a/daemon/graphdriver/aufs/mount.go +++ b/daemon/graphdriver/aufs/mount.go @@ -4,9 +4,9 @@ package aufs import ( "os/exec" - "syscall" "github.com/Sirupsen/logrus" + "golang.org/x/sys/unix" ) // Unmount the target specified. @@ -14,7 +14,7 @@ func Unmount(target string) error { if err := exec.Command("auplink", target, "flush").Run(); err != nil { logrus.Warnf("Couldn't run auplink before unmount %s: %s", target, err) } - if err := syscall.Unmount(target, 0); err != nil { + if err := unix.Unmount(target, 0); err != nil { return err } return nil diff --git a/daemon/graphdriver/aufs/mount_linux.go b/daemon/graphdriver/aufs/mount_linux.go index 8062bae420..937104ba3f 100644 --- a/daemon/graphdriver/aufs/mount_linux.go +++ b/daemon/graphdriver/aufs/mount_linux.go @@ -1,7 +1,7 @@ package aufs -import "syscall" +import "golang.org/x/sys/unix" func mount(source string, target string, fstype string, flags uintptr, data string) error { - return syscall.Mount(source, target, fstype, flags, data) + return unix.Mount(source, target, fstype, flags, data) } diff --git a/daemon/graphdriver/btrfs/btrfs.go b/daemon/graphdriver/btrfs/btrfs.go index 3eb4ce8ed1..25998422c5 100644 --- a/daemon/graphdriver/btrfs/btrfs.go +++ b/daemon/graphdriver/btrfs/btrfs.go @@ -24,7 +24,6 @@ import ( "strconv" "strings" "sync" - "syscall" "unsafe" "github.com/Sirupsen/logrus" @@ -35,6 +34,7 @@ import ( "github.com/docker/docker/pkg/system" "github.com/docker/go-units" "github.com/opencontainers/selinux/go-selinux/label" + "golang.org/x/sys/unix" ) func init() { @@ -197,7 +197,7 @@ func subvolCreate(path, name string) error { args.name[i] = C.char(c) } - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_SUBVOL_CREATE, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_SUBVOL_CREATE, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to create btrfs subvolume: %v", errno.Error()) @@ -225,7 +225,7 @@ func subvolSnapshot(src, dest, name string) error { C.set_name_btrfs_ioctl_vol_args_v2(&args, cs) C.free(unsafe.Pointer(cs)) - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(destDir), C.BTRFS_IOC_SNAP_CREATE_V2, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(destDir), C.BTRFS_IOC_SNAP_CREATE_V2, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to create btrfs snapshot: %v", errno.Error()) @@ -234,8 +234,8 @@ func subvolSnapshot(src, dest, name string) error { } func isSubvolume(p string) (bool, error) { - var bufStat syscall.Stat_t - if err := syscall.Lstat(p, &bufStat); err != nil { + var bufStat unix.Stat_t + if err := unix.Lstat(p, &bufStat); err != nil { return false, err } @@ -287,7 +287,7 @@ func subvolDelete(dirpath, name string, quotaEnabled bool) error { var args C.struct_btrfs_ioctl_qgroup_create_args args.qgroupid = C.__u64(qgroupid) - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QGROUP_CREATE, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QGROUP_CREATE, uintptr(unsafe.Pointer(&args))) if errno != 0 { logrus.Errorf("Failed to delete btrfs qgroup %v for %s: %v", qgroupid, fullPath, errno.Error()) @@ -302,7 +302,7 @@ func subvolDelete(dirpath, name string, quotaEnabled bool) error { for i, c := range []byte(name) { args.name[i] = C.char(c) } - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_SNAP_DESTROY, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_SNAP_DESTROY, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to destroy btrfs snapshot %s for %s: %v", dirpath, name, errno.Error()) @@ -338,7 +338,7 @@ func (d *Driver) subvolEnableQuota() error { var args C.struct_btrfs_ioctl_quota_ctl_args args.cmd = C.BTRFS_QUOTA_CTL_ENABLE - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QUOTA_CTL, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QUOTA_CTL, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to enable btrfs quota for %s: %v", dir, errno.Error()) @@ -364,7 +364,7 @@ func (d *Driver) subvolDisableQuota() error { var args C.struct_btrfs_ioctl_quota_ctl_args args.cmd = C.BTRFS_QUOTA_CTL_DISABLE - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QUOTA_CTL, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QUOTA_CTL, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to disable btrfs quota for %s: %v", dir, errno.Error()) @@ -389,7 +389,7 @@ func (d *Driver) subvolRescanQuota() error { defer closeDir(dir) var args C.struct_btrfs_ioctl_quota_rescan_args - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QUOTA_RESCAN_WAIT, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QUOTA_RESCAN_WAIT, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to rescan btrfs quota for %s: %v", dir, errno.Error()) @@ -408,7 +408,7 @@ func subvolLimitQgroup(path string, size uint64) error { var args C.struct_btrfs_ioctl_qgroup_limit_args args.lim.max_referenced = C.__u64(size) args.lim.flags = C.BTRFS_QGROUP_LIMIT_MAX_RFER - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QGROUP_LIMIT, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_QGROUP_LIMIT, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to limit qgroup for %s: %v", dir, errno.Error()) @@ -437,7 +437,7 @@ func subvolQgroupStatus(path string) error { args.key.max_transid = C.__u64(math.MaxUint64) args.key.nr_items = 4096 - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_TREE_SEARCH, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_TREE_SEARCH, uintptr(unsafe.Pointer(&args))) if errno != 0 { return fmt.Errorf("Failed to search qgroup for %s: %v", path, errno.Error()) @@ -459,7 +459,7 @@ func subvolLookupQgroup(path string) (uint64, error) { var args C.struct_btrfs_ioctl_ino_lookup_args args.objectid = C.BTRFS_FIRST_FREE_OBJECTID - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_INO_LOOKUP, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.BTRFS_IOC_INO_LOOKUP, uintptr(unsafe.Pointer(&args))) if errno != 0 { return 0, fmt.Errorf("Failed to lookup qgroup for %s: %v", dir, errno.Error()) diff --git a/daemon/graphdriver/devmapper/deviceset.go b/daemon/graphdriver/devmapper/deviceset.go index c0116c7993..522277936d 100644 --- a/daemon/graphdriver/devmapper/deviceset.go +++ b/daemon/graphdriver/devmapper/deviceset.go @@ -20,7 +20,6 @@ import ( "time" "github.com/Sirupsen/logrus" - "github.com/docker/docker/daemon/graphdriver" "github.com/docker/docker/dockerversion" "github.com/docker/docker/pkg/devicemapper" @@ -29,9 +28,9 @@ import ( "github.com/docker/docker/pkg/mount" "github.com/docker/docker/pkg/parsers" units "github.com/docker/go-units" - "github.com/pkg/errors" - "github.com/opencontainers/selinux/go-selinux/label" + "github.com/pkg/errors" + "golang.org/x/sys/unix" ) var ( @@ -1197,7 +1196,7 @@ func (devices *DeviceSet) growFS(info *devInfo) error { return fmt.Errorf("Error mounting '%s' on '%s': %s", info.DevName(), fsMountPoint, err) } - defer syscall.Unmount(fsMountPoint, syscall.MNT_DETACH) + defer unix.Unmount(fsMountPoint, unix.MNT_DETACH) switch devices.BaseDeviceFilesystem { case "ext4": @@ -1266,7 +1265,7 @@ func setCloseOnExec(name string) { if link == name { fd, err := strconv.Atoi(i.Name()) if err == nil { - syscall.CloseOnExec(fd) + unix.CloseOnExec(fd) } } } @@ -2287,7 +2286,7 @@ func (devices *DeviceSet) Shutdown(home string) error { // We use MNT_DETACH here in case it is still busy in some running // container. This means it'll go away from the global scope directly, // and the device will be released when that container dies. - if err := syscall.Unmount(p, syscall.MNT_DETACH); err != nil { + if err := unix.Unmount(p, unix.MNT_DETACH); err != nil { logrus.Debugf("devmapper: Shutdown unmounting %s, error: %s", p, err) } } @@ -2400,7 +2399,7 @@ func (devices *DeviceSet) MountDevice(hash, path, mountLabel string) error { if fstype == "xfs" && devices.xfsNospaceRetries != "" { if err := devices.xfsSetNospaceRetries(info); err != nil { - syscall.Unmount(path, syscall.MNT_DETACH) + unix.Unmount(path, unix.MNT_DETACH) devices.deactivateDevice(info) return err } @@ -2426,7 +2425,7 @@ func (devices *DeviceSet) UnmountDevice(hash, mountPath string) error { defer devices.Unlock() logrus.Debugf("devmapper: Unmount(%s)", mountPath) - if err := syscall.Unmount(mountPath, syscall.MNT_DETACH); err != nil { + if err := unix.Unmount(mountPath, unix.MNT_DETACH); err != nil { return err } logrus.Debug("devmapper: Unmount done") @@ -2523,8 +2522,8 @@ func (devices *DeviceSet) MetadataDevicePath() string { } func (devices *DeviceSet) getUnderlyingAvailableSpace(loopFile string) (uint64, error) { - buf := new(syscall.Statfs_t) - if err := syscall.Statfs(loopFile, buf); err != nil { + buf := new(unix.Statfs_t) + if err := unix.Statfs(loopFile, buf); err != nil { logrus.Warnf("devmapper: Couldn't stat loopfile filesystem %v: %v", loopFile, err) return 0, err } diff --git a/daemon/graphdriver/driver_freebsd.go b/daemon/graphdriver/driver_freebsd.go index 2891a84f3a..fb13ac3d5e 100644 --- a/daemon/graphdriver/driver_freebsd.go +++ b/daemon/graphdriver/driver_freebsd.go @@ -1,6 +1,6 @@ package graphdriver -import "syscall" +import "golang.org/x/sys/unix" var ( // Slice of drivers that should be used in an order @@ -11,7 +11,7 @@ var ( // Mounted checks if the given path is mounted as the fs type func Mounted(fsType FsMagic, mountPath string) (bool, error) { - var buf syscall.Statfs_t + var buf unix.Statfs_t if err := syscall.Statfs(mountPath, &buf); err != nil { return false, err } diff --git a/daemon/graphdriver/driver_linux.go b/daemon/graphdriver/driver_linux.go index 46b6eec09b..a92993d45a 100644 --- a/daemon/graphdriver/driver_linux.go +++ b/daemon/graphdriver/driver_linux.go @@ -4,9 +4,9 @@ package graphdriver import ( "path/filepath" - "syscall" "github.com/docker/docker/pkg/mount" + "golang.org/x/sys/unix" ) const ( @@ -88,8 +88,8 @@ var ( // GetFSMagic returns the filesystem id given the path. func GetFSMagic(rootpath string) (FsMagic, error) { - var buf syscall.Statfs_t - if err := syscall.Statfs(filepath.Dir(rootpath), &buf); err != nil { + var buf unix.Statfs_t + if err := unix.Statfs(filepath.Dir(rootpath), &buf); err != nil { return 0, err } return FsMagic(buf.Type), nil @@ -127,8 +127,8 @@ func (c *defaultChecker) IsMounted(path string) bool { // Mounted checks if the given path is mounted as the fs type func Mounted(fsType FsMagic, mountPath string) (bool, error) { - var buf syscall.Statfs_t - if err := syscall.Statfs(mountPath, &buf); err != nil { + var buf unix.Statfs_t + if err := unix.Statfs(mountPath, &buf); err != nil { return false, err } return FsMagic(buf.Type) == fsType, nil diff --git a/daemon/graphdriver/graphtest/graphtest_unix.go b/daemon/graphdriver/graphtest/graphtest_unix.go index 6852ca9f4c..2f8ae54777 100644 --- a/daemon/graphdriver/graphtest/graphtest_unix.go +++ b/daemon/graphdriver/graphtest/graphtest_unix.go @@ -9,7 +9,6 @@ import ( "os" "path" "reflect" - "syscall" "testing" "unsafe" @@ -18,6 +17,7 @@ import ( "github.com/docker/go-units" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "golang.org/x/sys/unix" ) var ( @@ -329,8 +329,8 @@ func DriverTestSetQuota(t *testing.T, drivername string) { quota := uint64(50 * units.MiB) err = writeRandomFile(path.Join(mountPath, "file"), quota*2) - if pathError, ok := err.(*os.PathError); ok && pathError.Err != syscall.EDQUOT { - t.Fatalf("expect write() to fail with %v, got %v", syscall.EDQUOT, err) + if pathError, ok := err.(*os.PathError); ok && pathError.Err != unix.EDQUOT { + t.Fatalf("expect write() to fail with %v, got %v", unix.EDQUOT, err) } } diff --git a/daemon/graphdriver/graphtest/testutil_unix.go b/daemon/graphdriver/graphtest/testutil_unix.go index 63a934176e..96474487aa 100644 --- a/daemon/graphdriver/graphtest/testutil_unix.go +++ b/daemon/graphdriver/graphtest/testutil_unix.go @@ -12,6 +12,7 @@ import ( "github.com/docker/docker/daemon/graphdriver" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "golang.org/x/sys/unix" ) func verifyFile(t testing.TB, path string, mode os.FileMode, uid, gid uint32) { @@ -33,8 +34,8 @@ func verifyFile(t testing.TB, path string, mode os.FileMode, uid, gid uint32) { func createBase(t testing.TB, driver graphdriver.Driver, name string) { // We need to be able to set any perms - oldmask := syscall.Umask(0) - defer syscall.Umask(oldmask) + oldmask := unix.Umask(0) + defer unix.Umask(oldmask) err := driver.CreateReadWrite(name, "", nil) require.NoError(t, err) diff --git a/daemon/graphdriver/overlay/copy.go b/daemon/graphdriver/overlay/copy.go index 666a5c0e04..53ea5bff11 100644 --- a/daemon/graphdriver/overlay/copy.go +++ b/daemon/graphdriver/overlay/copy.go @@ -12,6 +12,7 @@ import ( "github.com/docker/docker/pkg/pools" "github.com/docker/docker/pkg/system" rsystem "github.com/opencontainers/runc/libcontainer/system" + "golang.org/x/sys/unix" ) type copyFlags int @@ -110,12 +111,12 @@ func copyDir(srcDir, dstDir string, flags copyFlags) error { // cannot create a device if running in user namespace return nil } - if err := syscall.Mkfifo(dstPath, stat.Mode); err != nil { + if err := unix.Mkfifo(dstPath, stat.Mode); err != nil { return err } case os.ModeDevice: - if err := syscall.Mknod(dstPath, stat.Mode, int(stat.Rdev)); err != nil { + if err := unix.Mknod(dstPath, stat.Mode, int(stat.Rdev)); err != nil { return err } diff --git a/daemon/graphdriver/overlay/overlay.go b/daemon/graphdriver/overlay/overlay.go index 7f849c96ff..9db2e9405f 100644 --- a/daemon/graphdriver/overlay/overlay.go +++ b/daemon/graphdriver/overlay/overlay.go @@ -11,7 +11,6 @@ import ( "os/exec" "path" "strconv" - "syscall" "github.com/Sirupsen/logrus" "github.com/docker/docker/daemon/graphdriver" @@ -23,6 +22,7 @@ import ( "github.com/docker/docker/pkg/mount" "github.com/docker/docker/pkg/system" "github.com/opencontainers/selinux/go-selinux/label" + "golang.org/x/sys/unix" ) // This is a small wrapper over the NaiveDiffWriter that lets us have a custom @@ -363,7 +363,7 @@ func (d *Driver) Get(id string, mountLabel string) (s string, err error) { defer func() { if err != nil { if c := d.ctr.Decrement(mergedDir); c <= 0 { - syscall.Unmount(mergedDir, 0) + unix.Unmount(mergedDir, 0) } } }() @@ -377,7 +377,7 @@ func (d *Driver) Get(id string, mountLabel string) (s string, err error) { workDir = path.Join(dir, "work") opts = fmt.Sprintf("lowerdir=%s,upperdir=%s,workdir=%s", lowerDir, upperDir, workDir) ) - if err := syscall.Mount("overlay", mergedDir, "overlay", 0, label.FormatMountLabel(opts, mountLabel)); err != nil { + if err := unix.Mount("overlay", mergedDir, "overlay", 0, label.FormatMountLabel(opts, mountLabel)); err != nil { return "", fmt.Errorf("error creating overlay mount to %s: %v", mergedDir, err) } // chown "workdir/work" to the remapped root UID/GID. Overlay fs inside a @@ -404,7 +404,7 @@ func (d *Driver) Put(id string) error { if count := d.ctr.Decrement(mountpoint); count > 0 { return nil } - if err := syscall.Unmount(mountpoint, syscall.MNT_DETACH); err != nil { + if err := unix.Unmount(mountpoint, unix.MNT_DETACH); err != nil { logrus.Debugf("Failed to unmount %s overlay: %v", id, err) } return nil diff --git a/daemon/graphdriver/overlay2/check.go b/daemon/graphdriver/overlay2/check.go index 53a7199292..35e088aa32 100644 --- a/daemon/graphdriver/overlay2/check.go +++ b/daemon/graphdriver/overlay2/check.go @@ -8,11 +8,11 @@ import ( "os" "path" "path/filepath" - "syscall" "github.com/Sirupsen/logrus" "github.com/docker/docker/pkg/system" "github.com/pkg/errors" + "golang.org/x/sys/unix" ) // hasOpaqueCopyUpBug checks whether the filesystem has a bug @@ -52,11 +52,11 @@ func hasOpaqueCopyUpBug(d string) error { } opts := fmt.Sprintf("lowerdir=%s:%s,upperdir=%s,workdir=%s", path.Join(td, "l2"), path.Join(td, "l1"), path.Join(td, "l3"), path.Join(td, "work")) - if err := syscall.Mount("overlay", filepath.Join(td, "merged"), "overlay", 0, opts); err != nil { + if err := unix.Mount("overlay", filepath.Join(td, "merged"), "overlay", 0, opts); err != nil { return errors.Wrap(err, "failed to mount overlay") } defer func() { - if err := syscall.Unmount(filepath.Join(td, "merged"), 0); err != nil { + if err := unix.Unmount(filepath.Join(td, "merged"), 0); err != nil { logrus.Warnf("Failed to unmount check directory %v: %v", filepath.Join(td, "merged"), err) } }() diff --git a/daemon/graphdriver/overlay2/mount.go b/daemon/graphdriver/overlay2/mount.go index 60e248b6d7..77bff06621 100644 --- a/daemon/graphdriver/overlay2/mount.go +++ b/daemon/graphdriver/overlay2/mount.go @@ -9,9 +9,9 @@ import ( "fmt" "os" "runtime" - "syscall" "github.com/docker/docker/pkg/reexec" + "golang.org/x/sys/unix" ) func init() { @@ -80,7 +80,7 @@ func mountFromMain() { fatal(err) } - if err := syscall.Mount(options.Device, options.Target, options.Type, uintptr(options.Flag), options.Label); err != nil { + if err := unix.Mount(options.Device, options.Target, options.Type, uintptr(options.Flag), options.Label); err != nil { fatal(err) } diff --git a/daemon/graphdriver/overlay2/overlay.go b/daemon/graphdriver/overlay2/overlay.go index deea3e0176..4ef2a8caaf 100644 --- a/daemon/graphdriver/overlay2/overlay.go +++ b/daemon/graphdriver/overlay2/overlay.go @@ -15,7 +15,6 @@ import ( "strconv" "strings" "sync" - "syscall" "github.com/Sirupsen/logrus" @@ -35,6 +34,7 @@ import ( units "github.com/docker/go-units" "github.com/opencontainers/selinux/go-selinux/label" + "golang.org/x/sys/unix" ) var ( @@ -539,7 +539,7 @@ func (d *Driver) Get(id string, mountLabel string) (s string, err error) { defer func() { if err != nil { if c := d.ctr.Decrement(mergedDir); c <= 0 { - syscall.Unmount(mergedDir, 0) + unix.Unmount(mergedDir, 0) } } }() @@ -552,10 +552,10 @@ func (d *Driver) Get(id string, mountLabel string) (s string, err error) { } opts := fmt.Sprintf("lowerdir=%s,upperdir=%s,workdir=%s", strings.Join(absLowers, ":"), path.Join(dir, "diff"), path.Join(dir, "work")) mountData := label.FormatMountLabel(opts, mountLabel) - mount := syscall.Mount + mount := unix.Mount mountTarget := mergedDir - pageSize := syscall.Getpagesize() + pageSize := unix.Getpagesize() // Go can return a larger page size than supported by the system // as of go 1.7. This will be fixed in 1.8 and this block can be @@ -619,7 +619,7 @@ func (d *Driver) Put(id string) error { if count := d.ctr.Decrement(mountpoint); count > 0 { return nil } - if err := syscall.Unmount(mountpoint, syscall.MNT_DETACH); err != nil { + if err := unix.Unmount(mountpoint, unix.MNT_DETACH); err != nil { logrus.Debugf("Failed to unmount %s overlay: %s - %v", id, mountpoint, err) } return nil diff --git a/daemon/graphdriver/overlay2/overlay_test.go b/daemon/graphdriver/overlay2/overlay_test.go index cf77ff22be..2ff0b339e3 100644 --- a/daemon/graphdriver/overlay2/overlay_test.go +++ b/daemon/graphdriver/overlay2/overlay_test.go @@ -5,13 +5,13 @@ package overlay2 import ( "io/ioutil" "os" - "syscall" "testing" "github.com/docker/docker/daemon/graphdriver" "github.com/docker/docker/daemon/graphdriver/graphtest" "github.com/docker/docker/pkg/archive" "github.com/docker/docker/pkg/reexec" + "golang.org/x/sys/unix" ) func init() { @@ -31,7 +31,7 @@ func cdMountFrom(dir, device, target, mType, label string) error { os.Chdir(dir) defer os.Chdir(wd) - return syscall.Mount(device, target, mType, 0, label) + return unix.Mount(device, target, mType, 0, label) } func skipIfNaive(t *testing.T) { diff --git a/daemon/graphdriver/overlay2/randomid.go b/daemon/graphdriver/overlay2/randomid.go index af5cb659d5..04212c0694 100644 --- a/daemon/graphdriver/overlay2/randomid.go +++ b/daemon/graphdriver/overlay2/randomid.go @@ -12,6 +12,7 @@ import ( "time" "github.com/Sirupsen/logrus" + "golang.org/x/sys/unix" ) // generateID creates a new random string identifier with the given length @@ -69,7 +70,7 @@ func retryOnError(err error) bool { case *os.PathError: return retryOnError(err.Err) // unpack the target error case syscall.Errno: - if err == syscall.EPERM { + if err == unix.EPERM { // EPERM represents an entropy pool exhaustion, a condition under // which we backoff and retry. return true diff --git a/daemon/graphdriver/quota/projectquota.go b/daemon/graphdriver/quota/projectquota.go index 48ade10348..194c30e9af 100644 --- a/daemon/graphdriver/quota/projectquota.go +++ b/daemon/graphdriver/quota/projectquota.go @@ -59,6 +59,7 @@ import ( "unsafe" "github.com/Sirupsen/logrus" + "golang.org/x/sys/unix" ) // Quota limit params - currently we only control blocks hard limit @@ -184,7 +185,7 @@ func setProjectQuota(backingFsBlockDev string, projectID uint32, quota Quota) er var cs = C.CString(backingFsBlockDev) defer C.free(unsafe.Pointer(cs)) - _, _, errno := syscall.Syscall6(syscall.SYS_QUOTACTL, C.Q_XSETPQLIM, + _, _, errno := unix.Syscall6(unix.SYS_QUOTACTL, C.Q_XSETPQLIM, uintptr(unsafe.Pointer(cs)), uintptr(d.d_id), uintptr(unsafe.Pointer(&d)), 0, 0) if errno != 0 { @@ -211,7 +212,7 @@ func (q *Control) GetQuota(targetPath string, quota *Quota) error { var cs = C.CString(q.backingFsBlockDev) defer C.free(unsafe.Pointer(cs)) - _, _, errno := syscall.Syscall6(syscall.SYS_QUOTACTL, C.Q_XGETPQUOTA, + _, _, errno := unix.Syscall6(unix.SYS_QUOTACTL, C.Q_XGETPQUOTA, uintptr(unsafe.Pointer(cs)), uintptr(C.__u32(projectID)), uintptr(unsafe.Pointer(&d)), 0, 0) if errno != 0 { @@ -232,7 +233,7 @@ func getProjectID(targetPath string) (uint32, error) { defer closeDir(dir) var fsx C.struct_fsxattr - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.FS_IOC_FSGETXATTR, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.FS_IOC_FSGETXATTR, uintptr(unsafe.Pointer(&fsx))) if errno != 0 { return 0, fmt.Errorf("Failed to get projid for %s: %v", targetPath, errno.Error()) @@ -250,14 +251,14 @@ func setProjectID(targetPath string, projectID uint32) error { defer closeDir(dir) var fsx C.struct_fsxattr - _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.FS_IOC_FSGETXATTR, + _, _, errno := unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.FS_IOC_FSGETXATTR, uintptr(unsafe.Pointer(&fsx))) if errno != 0 { return fmt.Errorf("Failed to get projid for %s: %v", targetPath, errno.Error()) } fsx.fsx_projid = C.__u32(projectID) fsx.fsx_xflags |= C.FS_XFLAG_PROJINHERIT - _, _, errno = syscall.Syscall(syscall.SYS_IOCTL, getDirFd(dir), C.FS_IOC_FSSETXATTR, + _, _, errno = unix.Syscall(unix.SYS_IOCTL, getDirFd(dir), C.FS_IOC_FSSETXATTR, uintptr(unsafe.Pointer(&fsx))) if errno != 0 { return fmt.Errorf("Failed to set projid for %s: %v", targetPath, errno.Error()) @@ -329,9 +330,9 @@ func makeBackingFsDev(home string) (string, error) { backingFsBlockDev := path.Join(home, "backingFsBlockDev") // Re-create just in case someone copied the home directory over to a new device - syscall.Unlink(backingFsBlockDev) + unix.Unlink(backingFsBlockDev) stat := fileinfo.Sys().(*syscall.Stat_t) - if err := syscall.Mknod(backingFsBlockDev, syscall.S_IFBLK|0600, int(stat.Dev)); err != nil { + if err := unix.Mknod(backingFsBlockDev, unix.S_IFBLK|0600, int(stat.Dev)); err != nil { return "", fmt.Errorf("Failed to mknod %s: %v", backingFsBlockDev, err) } diff --git a/daemon/graphdriver/windows/windows.go b/daemon/graphdriver/windows/windows.go index 6b18c8c242..49c8d34a57 100644 --- a/daemon/graphdriver/windows/windows.go +++ b/daemon/graphdriver/windows/windows.go @@ -124,7 +124,7 @@ func getFileSystemType(drive string) (fsType string, hr error) { modkernel32 = windows.NewLazySystemDLL("kernel32.dll") procGetVolumeInformation = modkernel32.NewProc("GetVolumeInformationW") buf = make([]uint16, 255) - size = syscall.MAX_PATH + 1 + size = windows.MAX_PATH + 1 ) if len(drive) != 1 { hr = errors.New("getFileSystemType must be called with a drive letter") @@ -132,11 +132,11 @@ func getFileSystemType(drive string) (fsType string, hr error) { } drive += `:\` n := uintptr(unsafe.Pointer(nil)) - r0, _, _ := syscall.Syscall9(procGetVolumeInformation.Addr(), 8, uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(drive))), n, n, n, n, n, uintptr(unsafe.Pointer(&buf[0])), uintptr(size), 0) + r0, _, _ := syscall.Syscall9(procGetVolumeInformation.Addr(), 8, uintptr(unsafe.Pointer(windows.StringToUTF16Ptr(drive))), n, n, n, n, n, uintptr(unsafe.Pointer(&buf[0])), uintptr(size), 0) if int32(r0) < 0 { hr = syscall.Errno(win32FromHresult(r0)) } - fsType = syscall.UTF16ToString(buf) + fsType = windows.UTF16ToString(buf) return } @@ -904,12 +904,12 @@ func (fg *fileGetCloserWithBackupPrivileges) Get(filename string) (io.ReadCloser // standby list - Microsoft VSO Bug Tracker #9900466 err := winio.RunWithPrivilege(winio.SeBackupPrivilege, func() error { path := longpath.AddPrefix(filepath.Join(fg.path, filename)) - p, err := syscall.UTF16FromString(path) + p, err := windows.UTF16FromString(path) if err != nil { return err } const fileFlagSequentialScan = 0x08000000 // FILE_FLAG_SEQUENTIAL_SCAN - h, err := syscall.CreateFile(&p[0], syscall.GENERIC_READ, syscall.FILE_SHARE_READ, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS|fileFlagSequentialScan, 0) + h, err := windows.CreateFile(&p[0], windows.GENERIC_READ, windows.FILE_SHARE_READ, nil, windows.OPEN_EXISTING, windows.FILE_FLAG_BACKUP_SEMANTICS|fileFlagSequentialScan, 0) if err != nil { return &os.PathError{Op: "open", Path: path, Err: err} } diff --git a/daemon/graphdriver/zfs/zfs.go b/daemon/graphdriver/zfs/zfs.go index bc2b4192a1..a772cc9ee6 100644 --- a/daemon/graphdriver/zfs/zfs.go +++ b/daemon/graphdriver/zfs/zfs.go @@ -10,7 +10,6 @@ import ( "strconv" "strings" "sync" - "syscall" "time" "github.com/Sirupsen/logrus" @@ -20,6 +19,7 @@ import ( "github.com/docker/docker/pkg/parsers" zfs "github.com/mistifyio/go-zfs" "github.com/opencontainers/selinux/go-selinux/label" + "golang.org/x/sys/unix" ) type zfsOptions struct { @@ -141,8 +141,8 @@ func parseOptions(opt []string) (zfsOptions, error) { } func lookupZfsDataset(rootdir string) (string, error) { - var stat syscall.Stat_t - if err := syscall.Stat(rootdir, &stat); err != nil { + var stat unix.Stat_t + if err := unix.Stat(rootdir, &stat); err != nil { return "", fmt.Errorf("Failed to access '%s': %s", rootdir, err) } wantedDev := stat.Dev @@ -152,7 +152,7 @@ func lookupZfsDataset(rootdir string) (string, error) { return "", err } for _, m := range mounts { - if err := syscall.Stat(m.Mountpoint, &stat); err != nil { + if err := unix.Stat(m.Mountpoint, &stat); err != nil { logrus.Debugf("[zfs] failed to stat '%s' while scanning for zfs mount: %v", m.Mountpoint, err) continue // may fail on fuse file systems } diff --git a/daemon/graphdriver/zfs/zfs_freebsd.go b/daemon/graphdriver/zfs/zfs_freebsd.go index 1c05fa794c..e02012afe2 100644 --- a/daemon/graphdriver/zfs/zfs_freebsd.go +++ b/daemon/graphdriver/zfs/zfs_freebsd.go @@ -3,15 +3,15 @@ package zfs import ( "fmt" "strings" - "syscall" "github.com/Sirupsen/logrus" "github.com/docker/docker/daemon/graphdriver" + "golang.org/x/sys/unix" ) func checkRootdirFs(rootdir string) error { - var buf syscall.Statfs_t - if err := syscall.Statfs(rootdir, &buf); err != nil { + var buf unix.Statfs_t + if err := unix.Statfs(rootdir, &buf); err != nil { return fmt.Errorf("Failed to access '%s': %s", rootdir, err) } diff --git a/daemon/graphdriver/zfs/zfs_linux.go b/daemon/graphdriver/zfs/zfs_linux.go index 52ed516049..53aa4c8c6f 100644 --- a/daemon/graphdriver/zfs/zfs_linux.go +++ b/daemon/graphdriver/zfs/zfs_linux.go @@ -2,15 +2,15 @@ package zfs import ( "fmt" - "syscall" "github.com/Sirupsen/logrus" "github.com/docker/docker/daemon/graphdriver" + "golang.org/x/sys/unix" ) func checkRootdirFs(rootdir string) error { - var buf syscall.Statfs_t - if err := syscall.Statfs(rootdir, &buf); err != nil { + var buf unix.Statfs_t + if err := unix.Statfs(rootdir, &buf); err != nil { return fmt.Errorf("Failed to access '%s': %s", rootdir, err) } diff --git a/daemon/initlayer/setup_unix.go b/daemon/initlayer/setup_unix.go index cdd8973481..e26d3a05f1 100644 --- a/daemon/initlayer/setup_unix.go +++ b/daemon/initlayer/setup_unix.go @@ -6,9 +6,9 @@ import ( "os" "path/filepath" "strings" - "syscall" "github.com/docker/docker/pkg/idtools" + "golang.org/x/sys/unix" ) // Setup populates a directory with mountpoints suitable @@ -33,7 +33,7 @@ func Setup(initLayer string, rootIDs idtools.IDPair) error { prev := "/" for _, p := range parts[1:] { prev = filepath.Join(prev, p) - syscall.Unlink(filepath.Join(initLayer, prev)) + unix.Unlink(filepath.Join(initLayer, prev)) } if _, err := os.Stat(filepath.Join(initLayer, pth)); err != nil { diff --git a/daemon/logger/etwlogs/etwlogs_windows.go b/daemon/logger/etwlogs/etwlogs_windows.go index cc44d51f56..8608f15ca1 100644 --- a/daemon/logger/etwlogs/etwlogs_windows.go +++ b/daemon/logger/etwlogs/etwlogs_windows.go @@ -16,7 +16,6 @@ import ( "errors" "fmt" "sync" - "syscall" "unsafe" "github.com/Sirupsen/logrus" @@ -42,12 +41,12 @@ var ( procEventWriteString = modAdvapi32.NewProc("EventWriteString") procEventUnregister = modAdvapi32.NewProc("EventUnregister") ) -var providerHandle syscall.Handle +var providerHandle windows.Handle var refCount int var mu sync.Mutex func init() { - providerHandle = syscall.InvalidHandle + providerHandle = windows.InvalidHandle if err := logger.RegisterLogDriver(name, New); err != nil { logrus.Fatal(err) } @@ -70,7 +69,7 @@ func New(info logger.Info) (logger.Logger, error) { // Log logs the message to the ETW stream. func (etwLogger *etwLogs) Log(msg *logger.Message) error { - if providerHandle == syscall.InvalidHandle { + if providerHandle == windows.InvalidHandle { // This should never be hit, if it is, it indicates a programming error. errorMessage := "ETWLogs cannot log the message, because the event provider has not been registered." logrus.Error(errorMessage) @@ -121,7 +120,7 @@ func unregisterETWProvider() { if refCount == 1 { if callEventUnregister() { refCount-- - providerHandle = syscall.InvalidHandle + providerHandle = windows.InvalidHandle } // Not returning an error if EventUnregister fails, because etwLogs will continue to work } else { @@ -131,7 +130,7 @@ func unregisterETWProvider() { func callEventRegister() error { // The provider's GUID is {a3693192-9ed6-46d2-a981-f8226c8363bd} - guid := syscall.GUID{ + guid := windows.GUID{ Data1: 0xa3693192, Data2: 0x9ed6, Data3: 0x46d2, @@ -148,7 +147,7 @@ func callEventRegister() error { } func callEventWriteString(message string) error { - utf16message, err := syscall.UTF16FromString(message) + utf16message, err := windows.UTF16FromString(message) if err != nil { return err diff --git a/daemon/metrics_unix.go b/daemon/metrics_unix.go index cda7355e8e..84166d1a80 100644 --- a/daemon/metrics_unix.go +++ b/daemon/metrics_unix.go @@ -7,7 +7,6 @@ import ( "net/http" "os" "path/filepath" - "syscall" "github.com/Sirupsen/logrus" "github.com/docker/docker/pkg/mount" @@ -15,11 +14,12 @@ import ( "github.com/docker/docker/pkg/plugins" metrics "github.com/docker/go-metrics" "github.com/pkg/errors" + "golang.org/x/sys/unix" ) func (daemon *Daemon) listenMetricsSock() (string, error) { path := filepath.Join(daemon.configStore.ExecRoot, "metrics.sock") - syscall.Unlink(path) + unix.Unlink(path) l, err := net.Listen("unix", path) if err != nil { return "", errors.Wrap(err, "error setting up metrics plugin listener") diff --git a/daemon/oci_windows.go b/daemon/oci_windows.go index f114230efa..555a466fe9 100644 --- a/daemon/oci_windows.go +++ b/daemon/oci_windows.go @@ -1,14 +1,13 @@ package daemon import ( - "syscall" - containertypes "github.com/docker/docker/api/types/container" "github.com/docker/docker/container" "github.com/docker/docker/oci" "github.com/docker/docker/pkg/sysinfo" "github.com/docker/docker/pkg/system" "github.com/opencontainers/runtime-spec/specs-go" + "golang.org/x/sys/windows" ) func (daemon *Daemon) createSpec(c *container.Container) (*specs.Spec, error) { @@ -196,7 +195,7 @@ func (daemon *Daemon) createSpecLinuxFields(c *container.Container, s *specs.Spe func escapeArgs(args []string) []string { escapedArgs := make([]string, len(args)) for i, a := range args { - escapedArgs[i] = syscall.EscapeArg(a) + escapedArgs[i] = windows.EscapeArg(a) } return escapedArgs } diff --git a/distribution/errors.go b/distribution/errors.go index 7f97c1d5eb..f453c01cc0 100644 --- a/distribution/errors.go +++ b/distribution/errors.go @@ -113,7 +113,7 @@ func continueOnError(err error) bool { case ImageConfigPullError: return false case error: - return !strings.Contains(err.Error(), strings.ToLower(syscall.ENOSPC.Error())) + return !strings.Contains(err.Error(), strings.ToLower(syscall.ESRCH.Error())) } // let's be nice and fallback if the error is a completely // unexpected one. diff --git a/integration-cli/daemon/daemon_unix.go b/integration-cli/daemon/daemon_unix.go index cacff728f0..77eda2de22 100644 --- a/integration-cli/daemon/daemon_unix.go +++ b/integration-cli/daemon/daemon_unix.go @@ -5,9 +5,9 @@ package daemon import ( "os" "path/filepath" - "syscall" "github.com/go-check/check" + "golang.org/x/sys/unix" ) func cleanupExecRoot(c *check.C, execRoot string) { @@ -18,7 +18,7 @@ func cleanupExecRoot(c *check.C, execRoot string) { // new exec root. netnsPath := filepath.Join(execRoot, "netns") filepath.Walk(netnsPath, func(path string, info os.FileInfo, err error) error { - if err := syscall.Unmount(path, syscall.MNT_FORCE); err != nil { + if err := unix.Unmount(path, unix.MNT_FORCE); err != nil { c.Logf("unmount of %s failed: %v", path, err) } os.Remove(path) @@ -28,9 +28,9 @@ func cleanupExecRoot(c *check.C, execRoot string) { // SignalDaemonDump sends a signal to the daemon to write a dump file func SignalDaemonDump(pid int) { - syscall.Kill(pid, syscall.SIGQUIT) + unix.Kill(pid, unix.SIGQUIT) } func signalDaemonReload(pid int) error { - return syscall.Kill(pid, syscall.SIGHUP) + return unix.Kill(pid, unix.SIGHUP) } diff --git a/integration-cli/daemon/daemon_windows.go b/integration-cli/daemon/daemon_windows.go index 81dae7a485..f8df27cf5d 100644 --- a/integration-cli/daemon/daemon_windows.go +++ b/integration-cli/daemon/daemon_windows.go @@ -10,21 +10,21 @@ import ( "golang.org/x/sys/windows" ) -func openEvent(desiredAccess uint32, inheritHandle bool, name string, proc *windows.LazyProc) (handle syscall.Handle, err error) { - namep, _ := syscall.UTF16PtrFromString(name) +func openEvent(desiredAccess uint32, inheritHandle bool, name string, proc *windows.LazyProc) (handle windows.Handle, err error) { + namep, _ := windows.UTF16PtrFromString(name) var _p2 uint32 if inheritHandle { _p2 = 1 } r0, _, e1 := proc.Call(uintptr(desiredAccess), uintptr(_p2), uintptr(unsafe.Pointer(namep))) - handle = syscall.Handle(r0) - if handle == syscall.InvalidHandle { + handle = windows.Handle(r0) + if handle == windows.InvalidHandle { err = e1 } return } -func pulseEvent(handle syscall.Handle, proc *windows.LazyProc) (err error) { +func pulseEvent(handle windows.Handle, proc *windows.LazyProc) (err error) { r0, _, _ := proc.Call(uintptr(handle)) if r0 != 0 { err = syscall.Errno(r0) diff --git a/integration-cli/docker_api_swarm_service_test.go b/integration-cli/docker_api_swarm_service_test.go index 66e17c4def..2ec56ccd8d 100644 --- a/integration-cli/docker_api_swarm_service_test.go +++ b/integration-cli/docker_api_swarm_service_test.go @@ -7,7 +7,6 @@ import ( "path" "strconv" "strings" - "syscall" "time" "github.com/docker/docker/api/types/swarm" @@ -17,6 +16,7 @@ import ( "github.com/docker/docker/integration-cli/fixtures/plugin" "github.com/go-check/check" "golang.org/x/net/context" + "golang.org/x/sys/unix" ) func setPortConfig(portConfig []swarm.PortConfig) daemon.ServiceConstructor { @@ -584,7 +584,7 @@ func (s *DockerSwarmSuite) TestAPISwarmServicesStateReporting(c *check.C) { c.Assert(err, checker.IsNil) pid, err := strconv.Atoi(strings.TrimSpace(pidStr)) c.Assert(err, checker.IsNil) - c.Assert(syscall.Kill(pid, syscall.SIGKILL), checker.IsNil) + c.Assert(unix.Kill(pid, unix.SIGKILL), checker.IsNil) time.Sleep(time.Second) // give some time to handle the signal diff --git a/integration-cli/docker_cli_daemon_plugins_test.go b/integration-cli/docker_cli_daemon_plugins_test.go index 1be69a267a..66c9f6ecea 100644 --- a/integration-cli/docker_cli_daemon_plugins_test.go +++ b/integration-cli/docker_cli_daemon_plugins_test.go @@ -6,12 +6,12 @@ import ( "os" "path/filepath" "strings" - "syscall" "github.com/docker/docker/integration-cli/checker" "github.com/docker/docker/pkg/mount" icmd "github.com/docker/docker/pkg/testutil/cmd" "github.com/go-check/check" + "golang.org/x/sys/unix" ) // TestDaemonRestartWithPluginEnabled tests state restore for an enabled plugin @@ -145,7 +145,7 @@ func (s *DockerDaemonSuite) TestDaemonShutdownWithPlugins(c *check.C) { } for { - if err := syscall.Kill(s.d.Pid(), 0); err == syscall.ESRCH { + if err := unix.Kill(s.d.Pid(), 0); err == unix.ESRCH { break } } diff --git a/integration-cli/docker_cli_daemon_test.go b/integration-cli/docker_cli_daemon_test.go index 5954c57aa6..6a98cabdfa 100644 --- a/integration-cli/docker_cli_daemon_test.go +++ b/integration-cli/docker_cli_daemon_test.go @@ -19,7 +19,6 @@ import ( "strconv" "strings" "sync" - "syscall" "time" "crypto/tls" @@ -42,6 +41,7 @@ import ( "github.com/docker/libtrust" "github.com/go-check/check" "github.com/kr/pty" + "golang.org/x/sys/unix" ) // TestLegacyDaemonCommand test starting docker daemon using "deprecated" docker daemon @@ -2309,8 +2309,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFile(c *check.C) { fmt.Fprintf(configFile, "%s", daemonConfig) configFile.Close() - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) - // syscall.Kill(s.d.cmd.Process.Pid, syscall.SIGHUP) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) + // unix.Kill(s.d.cmd.Process.Pid, unix.SIGHUP) time.Sleep(3 * time.Second) @@ -2350,8 +2350,8 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFileReload(c *chec fmt.Fprintf(configFile, "%s", daemonConfig) configFile.Close() - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) - // syscall.Kill(s.d.cmd.Process.Pid, syscall.SIGHUP) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) + // unix.Kill(s.d.cmd.Process.Pid, unix.SIGHUP) time.Sleep(3 * time.Second) @@ -2368,7 +2368,7 @@ func (s *DockerDaemonSuite) TestDaemonMaxConcurrencyWithConfigFileReload(c *chec fmt.Fprintf(configFile, "%s", daemonConfig) configFile.Close() - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) time.Sleep(3 * time.Second) @@ -2455,7 +2455,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *check.C) { } ` ioutil.WriteFile(configName, []byte(config), 0644) - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) // Give daemon time to reload config <-time.After(1 * time.Second) @@ -2484,7 +2484,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *check.C) { } ` ioutil.WriteFile(configName, []byte(config), 0644) - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) // Give daemon time to reload config <-time.After(1 * time.Second) @@ -2510,7 +2510,7 @@ func (s *DockerDaemonSuite) TestRunWithRuntimeFromConfigFile(c *check.C) { } ` ioutil.WriteFile(configName, []byte(config), 0644) - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) // Give daemon time to reload config <-time.After(1 * time.Second) @@ -2762,7 +2762,7 @@ func (s *DockerDaemonSuite) TestDaemonShutdownTimeout(c *check.C) { _, err := s.d.Cmd("run", "-d", "busybox", "top") c.Assert(err, check.IsNil) - c.Assert(s.d.Signal(syscall.SIGINT), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGINT), checker.IsNil) select { case <-s.d.Wait: @@ -2796,7 +2796,7 @@ func (s *DockerDaemonSuite) TestDaemonShutdownTimeoutWithConfigFile(c *check.C) fmt.Fprintf(configFile, "%s", daemonConfig) configFile.Close() - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) select { case <-s.d.Wait: @@ -2897,7 +2897,7 @@ func (s *DockerDaemonSuite) TestRestartPolicyWithLiveRestore(c *check.C) { pidint, err := strconv.Atoi(strings.TrimSpace(pid)) c.Assert(err, check.IsNil) c.Assert(pidint, checker.GreaterThan, 0) - c.Assert(syscall.Kill(pidint, syscall.SIGKILL), check.IsNil) + c.Assert(unix.Kill(pidint, unix.SIGKILL), check.IsNil) ticker := time.NewTicker(50 * time.Millisecond) timeout := time.After(10 * time.Second) diff --git a/integration-cli/docker_cli_events_unix_test.go b/integration-cli/docker_cli_events_unix_test.go index fe053aa596..1f87d5fe8c 100644 --- a/integration-cli/docker_cli_events_unix_test.go +++ b/integration-cli/docker_cli_events_unix_test.go @@ -10,7 +10,6 @@ import ( "os" "os/exec" "strings" - "syscall" "time" "unicode" @@ -18,6 +17,7 @@ import ( "github.com/docker/docker/integration-cli/cli/build" "github.com/go-check/check" "github.com/kr/pty" + "golang.org/x/sys/unix" ) // #5979 @@ -421,7 +421,7 @@ func (s *DockerDaemonSuite) TestDaemonEvents(c *check.C) { fmt.Fprintf(configFile, "%s", daemonConfig) configFile.Close() - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) time.Sleep(3 * time.Second) @@ -459,7 +459,7 @@ func (s *DockerDaemonSuite) TestDaemonEventsWithFilters(c *check.C) { } c.Assert(daemonID, checker.Not(checker.Equals), "") - c.Assert(s.d.Signal(syscall.SIGHUP), checker.IsNil) + c.Assert(s.d.Signal(unix.SIGHUP), checker.IsNil) time.Sleep(3 * time.Second) diff --git a/integration-cli/docker_cli_network_unix_test.go b/integration-cli/docker_cli_network_unix_test.go index 28581bf503..05cc078bcb 100644 --- a/integration-cli/docker_cli_network_unix_test.go +++ b/integration-cli/docker_cli_network_unix_test.go @@ -12,7 +12,6 @@ import ( "os" "path/filepath" "strings" - "syscall" "time" "github.com/docker/docker/api/types" @@ -30,6 +29,7 @@ import ( "github.com/docker/libnetwork/netlabel" "github.com/go-check/check" "github.com/vishvananda/netlink" + "golang.org/x/sys/unix" ) const dummyNetworkDriver = "dummy-network-driver" @@ -1810,12 +1810,12 @@ func (s *DockerNetworkSuite) TestConntrackFlowsLeak(c *check.C) { cli.DockerCmd(c, "run", "-d", "--name", "client", "--net=host", "appropriate/nc", "sh", "-c", cmd) // Get all the flows using netlink - flows, err := netlink.ConntrackTableList(netlink.ConntrackTable, syscall.AF_INET) + flows, err := netlink.ConntrackTableList(netlink.ConntrackTable, unix.AF_INET) c.Assert(err, check.IsNil) var flowMatch int for _, flow := range flows { // count only the flows that we are interested in, skipping others that can be laying around the host - if flow.Forward.Protocol == syscall.IPPROTO_UDP && + if flow.Forward.Protocol == unix.IPPROTO_UDP && flow.Forward.DstIP.Equal(net.ParseIP("192.168.10.1")) && flow.Forward.DstPort == 8080 { flowMatch++ @@ -1828,11 +1828,11 @@ func (s *DockerNetworkSuite) TestConntrackFlowsLeak(c *check.C) { cli.DockerCmd(c, "rm", "-fv", "server") // Fetch again all the flows and validate that there is no server flow in the conntrack laying around - flows, err = netlink.ConntrackTableList(netlink.ConntrackTable, syscall.AF_INET) + flows, err = netlink.ConntrackTableList(netlink.ConntrackTable, unix.AF_INET) c.Assert(err, check.IsNil) flowMatch = 0 for _, flow := range flows { - if flow.Forward.Protocol == syscall.IPPROTO_UDP && + if flow.Forward.Protocol == unix.IPPROTO_UDP && flow.Forward.DstIP.Equal(net.ParseIP("192.168.10.1")) && flow.Forward.DstPort == 8080 { flowMatch++ diff --git a/libcontainerd/client_linux.go b/libcontainerd/client_linux.go index a6986b5200..54eaf35530 100644 --- a/libcontainerd/client_linux.go +++ b/libcontainerd/client_linux.go @@ -5,7 +5,6 @@ import ( "os" "strings" "sync" - "syscall" "time" "github.com/Sirupsen/logrus" @@ -17,6 +16,7 @@ import ( "github.com/golang/protobuf/ptypes/timestamp" specs "github.com/opencontainers/runtime-spec/specs-go" "golang.org/x/net/context" + "golang.org/x/sys/unix" ) type client struct { @@ -95,9 +95,9 @@ func (clnt *client) AddProcess(ctx context.Context, containerID, processFriendly AdditionalGids: sp.User.AdditionalGids, }, Pid: processFriendlyName, - Stdin: p.fifo(syscall.Stdin), - Stdout: p.fifo(syscall.Stdout), - Stderr: p.fifo(syscall.Stderr), + Stdin: p.fifo(unix.Stdin), + Stdout: p.fifo(unix.Stdout), + Stderr: p.fifo(unix.Stderr), Capabilities: sp.Capabilities.Effective, ApparmorProfile: sp.ApparmorProfile, SelinuxLabel: sp.SelinuxLabel, @@ -226,7 +226,7 @@ func (clnt *client) cleanupOldRootfs(containerID string) { if mts, err := mount.GetMounts(); err == nil { for _, mts := range mts { if strings.HasSuffix(mts.Mountpoint, containerID+"/rootfs") { - if err := syscall.Unmount(mts.Mountpoint, syscall.MNT_DETACH); err == nil { + if err := unix.Unmount(mts.Mountpoint, unix.MNT_DETACH); err == nil { os.RemoveAll(strings.TrimSuffix(mts.Mountpoint, "/rootfs")) } break @@ -524,7 +524,7 @@ func (clnt *client) Restore(containerID string, attachStdio StdioCallback, optio container.discardFifos() - if err := clnt.Signal(containerID, int(syscall.SIGTERM)); err != nil { + if err := clnt.Signal(containerID, int(unix.SIGTERM)); err != nil { logrus.Errorf("libcontainerd: error sending sigterm to %v: %v", containerID, err) } @@ -541,7 +541,7 @@ func (clnt *client) Restore(containerID string, attachStdio StdioCallback, optio select { case <-time.After(10 * time.Second): - if err := clnt.Signal(containerID, int(syscall.SIGKILL)); err != nil { + if err := clnt.Signal(containerID, int(unix.SIGKILL)); err != nil { logrus.Errorf("libcontainerd: error sending sigkill to %v: %v", containerID, err) } select { diff --git a/libcontainerd/container_unix.go b/libcontainerd/container_unix.go index be1699943e..869f88523f 100644 --- a/libcontainerd/container_unix.go +++ b/libcontainerd/container_unix.go @@ -9,7 +9,6 @@ import ( "os" "path/filepath" "sync" - "syscall" "time" "github.com/Sirupsen/logrus" @@ -18,6 +17,7 @@ import ( specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/tonistiigi/fifo" "golang.org/x/net/context" + "golang.org/x/sys/unix" ) type container struct { @@ -69,7 +69,7 @@ func (ctr *container) clean() error { // Caller needs to lock container ID before calling this method. func (ctr *container) cleanProcess(id string) { if p, ok := ctr.processes[id]; ok { - for _, i := range []int{syscall.Stdin, syscall.Stdout, syscall.Stderr} { + for _, i := range []int{unix.Stdin, unix.Stdout, unix.Stderr} { if err := os.Remove(p.fifo(i)); err != nil && !os.IsNotExist(err) { logrus.Warnf("libcontainerd: failed to remove %v for process %v: %v", p.fifo(i), id, err) } @@ -137,9 +137,9 @@ func (ctr *container) start(spec *specs.Spec, checkpoint, checkpointDir string, r := &containerd.CreateContainerRequest{ Id: ctr.containerID, BundlePath: ctr.dir, - Stdin: ctr.fifo(syscall.Stdin), - Stdout: ctr.fifo(syscall.Stdout), - Stderr: ctr.fifo(syscall.Stderr), + Stdin: ctr.fifo(unix.Stdin), + Stdout: ctr.fifo(unix.Stdout), + Stderr: ctr.fifo(unix.Stderr), Checkpoint: checkpoint, CheckpointDir: checkpointDir, // check to see if we are running in ramdisk to disable pivot root @@ -233,8 +233,8 @@ func (ctr *container) handleEvent(e *containerd.Event) error { // that may be blocked on the writer side. func (ctr *container) discardFifos() { ctx, _ := context.WithTimeout(context.Background(), 3*time.Second) - for _, i := range []int{syscall.Stdout, syscall.Stderr} { - f, err := fifo.OpenFifo(ctx, ctr.fifo(i), syscall.O_RDONLY|syscall.O_NONBLOCK, 0) + for _, i := range []int{unix.Stdout, unix.Stderr} { + f, err := fifo.OpenFifo(ctx, ctr.fifo(i), unix.O_RDONLY|unix.O_NONBLOCK, 0) if err != nil { logrus.Warnf("error opening fifo %v for discarding: %+v", f, err) continue diff --git a/libcontainerd/container_windows.go b/libcontainerd/container_windows.go index af3e0ef579..e895fa0302 100644 --- a/libcontainerd/container_windows.go +++ b/libcontainerd/container_windows.go @@ -6,13 +6,13 @@ import ( "io" "io/ioutil" "strings" - "syscall" "time" "github.com/Microsoft/hcsshim" "github.com/Sirupsen/logrus" "github.com/docker/docker/pkg/system" "github.com/opencontainers/runtime-spec/specs-go" + "golang.org/x/sys/windows" ) type container struct { @@ -185,7 +185,7 @@ func (ctr *container) waitProcessExitCode(process *process) int { // Block indefinitely for the process to exit. err := process.hcsProcess.Wait() if err != nil { - if herr, ok := err.(*hcsshim.ProcessError); ok && herr.Err != syscall.ERROR_BROKEN_PIPE { + if herr, ok := err.(*hcsshim.ProcessError); ok && herr.Err != windows.ERROR_BROKEN_PIPE { logrus.Warnf("libcontainerd: Wait() failed (container may have been killed): %s", err) } // Fall through here, do not return. This ensures we attempt to continue the @@ -195,7 +195,7 @@ func (ctr *container) waitProcessExitCode(process *process) int { exitCode, err := process.hcsProcess.ExitCode() if err != nil { - if herr, ok := err.(*hcsshim.ProcessError); ok && herr.Err != syscall.ERROR_BROKEN_PIPE { + if herr, ok := err.(*hcsshim.ProcessError); ok && herr.Err != windows.ERROR_BROKEN_PIPE { logrus.Warnf("libcontainerd: unable to get exit code from container %s", ctr.containerID) } // Since we got an error retrieving the exit code, make sure that the code we return diff --git a/libcontainerd/remote_unix.go b/libcontainerd/remote_unix.go index a81a93cbda..24fbc5ad60 100644 --- a/libcontainerd/remote_unix.go +++ b/libcontainerd/remote_unix.go @@ -15,7 +15,6 @@ import ( "strconv" "strings" "sync" - "syscall" "time" "github.com/Sirupsen/logrus" @@ -25,6 +24,7 @@ import ( "github.com/golang/protobuf/ptypes" "github.com/golang/protobuf/ptypes/timestamp" "golang.org/x/net/context" + "golang.org/x/sys/unix" "google.golang.org/grpc" "google.golang.org/grpc/grpclog" "google.golang.org/grpc/health/grpc_health_v1" @@ -185,7 +185,7 @@ func (r *remote) Cleanup() { r.closedManually = true r.rpcConn.Close() // Ask the daemon to quit - syscall.Kill(r.daemonPid, syscall.SIGTERM) + unix.Kill(r.daemonPid, unix.SIGTERM) // Wait up to 15secs for it to stop for i := time.Duration(0); i < containerdShutdownTimeout; i += time.Second { @@ -197,7 +197,7 @@ func (r *remote) Cleanup() { if system.IsProcessAlive(r.daemonPid) { logrus.Warnf("libcontainerd: containerd (%d) didn't stop within 15 secs, killing it\n", r.daemonPid) - syscall.Kill(r.daemonPid, syscall.SIGKILL) + unix.Kill(r.daemonPid, unix.SIGKILL) } // cleanup some files @@ -224,7 +224,7 @@ func (r *remote) Client(b Backend) (Client, error) { } func (r *remote) updateEventTimestamp(t time.Time) { - f, err := os.OpenFile(r.eventTsPath, syscall.O_CREAT|syscall.O_WRONLY|syscall.O_TRUNC, 0600) + f, err := os.OpenFile(r.eventTsPath, unix.O_CREAT|unix.O_WRONLY|unix.O_TRUNC, 0600) if err != nil { logrus.Warnf("libcontainerd: failed to open event timestamp file: %v", err) return diff --git a/libcontainerd/utils_linux.go b/libcontainerd/utils_linux.go index 5fd5bf6de1..170f90b8e5 100644 --- a/libcontainerd/utils_linux.go +++ b/libcontainerd/utils_linux.go @@ -5,6 +5,7 @@ import ( containerd "github.com/containerd/containerd/api/grpc/types" "github.com/opencontainers/runtime-spec/specs-go" + "golang.org/x/sys/unix" ) func getRootIDs(s specs.Spec) (int, int, error) { @@ -57,6 +58,6 @@ func convertRlimits(sr []specs.LinuxRlimit) (cr []*containerd.Rlimit) { func setSysProcAttr(sid bool) *syscall.SysProcAttr { return &syscall.SysProcAttr{ Setsid: sid, - Pdeathsig: syscall.SIGKILL, + Pdeathsig: unix.SIGKILL, } } diff --git a/pkg/archive/archive_linux.go b/pkg/archive/archive_linux.go index f072534d52..6e950e93cf 100644 --- a/pkg/archive/archive_linux.go +++ b/pkg/archive/archive_linux.go @@ -5,9 +5,9 @@ import ( "os" "path/filepath" "strings" - "syscall" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/unix" ) func getWhiteoutConverter(format WhiteoutFormat) tarWhiteoutConverter { @@ -67,7 +67,7 @@ func (overlayWhiteoutConverter) ConvertRead(hdr *tar.Header, path string) (bool, // if a directory is marked as opaque by the AUFS special file, we need to translate that to overlay if base == WhiteoutOpaqueDir { - err := syscall.Setxattr(dir, "trusted.overlay.opaque", []byte{'y'}, 0) + err := unix.Setxattr(dir, "trusted.overlay.opaque", []byte{'y'}, 0) // don't write the file itself return false, err } @@ -77,7 +77,7 @@ func (overlayWhiteoutConverter) ConvertRead(hdr *tar.Header, path string) (bool, originalBase := base[len(WhiteoutPrefix):] originalPath := filepath.Join(dir, originalBase) - if err := syscall.Mknod(originalPath, syscall.S_IFCHR, 0); err != nil { + if err := unix.Mknod(originalPath, unix.S_IFCHR, 0); err != nil { return false, err } if err := os.Chown(originalPath, hdr.Uid, hdr.Gid); err != nil { diff --git a/pkg/archive/archive_linux_test.go b/pkg/archive/archive_linux_test.go index d5f046e9df..f219b3e67e 100644 --- a/pkg/archive/archive_linux_test.go +++ b/pkg/archive/archive_linux_test.go @@ -8,6 +8,7 @@ import ( "testing" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/unix" ) // setupOverlayTestDir creates files in a directory with overlay whiteouts @@ -51,7 +52,7 @@ func setupOverlayTestDir(t *testing.T, src string) { t.Fatal(err) } - if err := system.Mknod(filepath.Join(src, "d3", "f1"), syscall.S_IFCHR, 0); err != nil { + if err := system.Mknod(filepath.Join(src, "d3", "f1"), unix.S_IFCHR, 0); err != nil { t.Fatal(err) } } diff --git a/pkg/archive/archive_unix.go b/pkg/archive/archive_unix.go index a33f0fe779..1213174322 100644 --- a/pkg/archive/archive_unix.go +++ b/pkg/archive/archive_unix.go @@ -12,6 +12,7 @@ import ( "github.com/docker/docker/pkg/idtools" "github.com/docker/docker/pkg/system" rsystem "github.com/opencontainers/runc/libcontainer/system" + "golang.org/x/sys/unix" ) // fixVolumePathPrefix does platform specific processing to ensure that if @@ -47,8 +48,8 @@ func setHeaderForSpecialDevice(hdr *tar.Header, name string, stat interface{}) ( if ok { // Currently go does not fill in the major/minors - if s.Mode&syscall.S_IFBLK != 0 || - s.Mode&syscall.S_IFCHR != 0 { + if s.Mode&unix.S_IFBLK != 0 || + s.Mode&unix.S_IFCHR != 0 { hdr.Devmajor = int64(major(uint64(s.Rdev))) hdr.Devminor = int64(minor(uint64(s.Rdev))) } @@ -95,11 +96,11 @@ func handleTarTypeBlockCharFifo(hdr *tar.Header, path string) error { mode := uint32(hdr.Mode & 07777) switch hdr.Typeflag { case tar.TypeBlock: - mode |= syscall.S_IFBLK + mode |= unix.S_IFBLK case tar.TypeChar: - mode |= syscall.S_IFCHR + mode |= unix.S_IFCHR case tar.TypeFifo: - mode |= syscall.S_IFIFO + mode |= unix.S_IFIFO } return system.Mknod(path, mode, int(system.Mkdev(hdr.Devmajor, hdr.Devminor))) diff --git a/pkg/archive/archive_unix_test.go b/pkg/archive/archive_unix_test.go index 4eeafdd128..90f8adaa5d 100644 --- a/pkg/archive/archive_unix_test.go +++ b/pkg/archive/archive_unix_test.go @@ -13,6 +13,7 @@ import ( "testing" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/unix" ) func TestCanonicalTarNameForPath(t *testing.T) { @@ -159,13 +160,13 @@ func TestTarWithBlockCharFifo(t *testing.T) { if err := ioutil.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700); err != nil { t.Fatal(err) } - if err := system.Mknod(filepath.Join(origin, "2"), syscall.S_IFBLK, int(system.Mkdev(int64(12), int64(5)))); err != nil { + if err := system.Mknod(filepath.Join(origin, "2"), unix.S_IFBLK, int(system.Mkdev(int64(12), int64(5)))); err != nil { t.Fatal(err) } - if err := system.Mknod(filepath.Join(origin, "3"), syscall.S_IFCHR, int(system.Mkdev(int64(12), int64(5)))); err != nil { + if err := system.Mknod(filepath.Join(origin, "3"), unix.S_IFCHR, int(system.Mkdev(int64(12), int64(5)))); err != nil { t.Fatal(err) } - if err := system.Mknod(filepath.Join(origin, "4"), syscall.S_IFIFO, int(system.Mkdev(int64(12), int64(5)))); err != nil { + if err := system.Mknod(filepath.Join(origin, "4"), unix.S_IFIFO, int(system.Mkdev(int64(12), int64(5)))); err != nil { t.Fatal(err) } diff --git a/pkg/archive/changes_linux.go b/pkg/archive/changes_linux.go index 771860294a..b987e52245 100644 --- a/pkg/archive/changes_linux.go +++ b/pkg/archive/changes_linux.go @@ -10,6 +10,7 @@ import ( "unsafe" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/unix" ) // walker is used to implement collectFileInfoForChanges on linux. Where this @@ -233,7 +234,7 @@ func readdirnames(dirname string) (names []nameIno, err error) { // Refill the buffer if necessary if bufp >= nbuf { bufp = 0 - nbuf, err = syscall.ReadDirent(int(f.Fd()), buf) // getdents on linux + nbuf, err = unix.ReadDirent(int(f.Fd()), buf) // getdents on linux if nbuf < 0 { nbuf = 0 } @@ -255,12 +256,12 @@ func readdirnames(dirname string) (names []nameIno, err error) { return sl, nil } -// parseDirent is a minor modification of syscall.ParseDirent (linux version) +// parseDirent is a minor modification of unix.ParseDirent (linux version) // which returns {name,inode} pairs instead of just names. func parseDirent(buf []byte, names []nameIno) (consumed int, newnames []nameIno) { origlen := len(buf) for len(buf) > 0 { - dirent := (*syscall.Dirent)(unsafe.Pointer(&buf[0])) + dirent := (*unix.Dirent)(unsafe.Pointer(&buf[0])) buf = buf[dirent.Reclen:] if dirent.Ino == 0 { // File absent in directory. continue diff --git a/pkg/archive/changes_unix.go b/pkg/archive/changes_unix.go index 3778b732cf..98e2b39aea 100644 --- a/pkg/archive/changes_unix.go +++ b/pkg/archive/changes_unix.go @@ -7,6 +7,7 @@ import ( "syscall" "github.com/docker/docker/pkg/system" + "golang.org/x/sys/unix" ) func statDifferent(oldStat *system.StatT, newStat *system.StatT) bool { @@ -16,7 +17,7 @@ func statDifferent(oldStat *system.StatT, newStat *system.StatT) bool { oldStat.GID() != newStat.GID() || oldStat.Rdev() != newStat.Rdev() || // Don't look at size for dirs, its not a good measure of change - (oldStat.Mode()&syscall.S_IFDIR != syscall.S_IFDIR && + (oldStat.Mode()&unix.S_IFDIR != unix.S_IFDIR && (!sameFsTimeSpec(oldStat.Mtim(), newStat.Mtim()) || (oldStat.Size() != newStat.Size()))) { return true } @@ -24,7 +25,7 @@ func statDifferent(oldStat *system.StatT, newStat *system.StatT) bool { } func (info *FileInfo) isDir() bool { - return info.parent == nil || info.stat.Mode()&syscall.S_IFDIR != 0 + return info.parent == nil || info.stat.Mode()&unix.S_IFDIR != 0 } func getIno(fi os.FileInfo) uint64 { diff --git a/pkg/chrootarchive/chroot_linux.go b/pkg/chrootarchive/chroot_linux.go index f9d7fed633..ebc3b84466 100644 --- a/pkg/chrootarchive/chroot_linux.go +++ b/pkg/chrootarchive/chroot_linux.go @@ -5,10 +5,10 @@ import ( "io/ioutil" "os" "path/filepath" - "syscall" "github.com/docker/docker/pkg/mount" rsystem "github.com/opencontainers/runc/libcontainer/system" + "golang.org/x/sys/unix" ) // chroot on linux uses pivot_root instead of chroot @@ -22,7 +22,7 @@ func chroot(path string) (err error) { if rsystem.RunningInUserNS() { return realChroot(path) } - if err := syscall.Unshare(syscall.CLONE_NEWNS); err != nil { + if err := unix.Unshare(unix.CLONE_NEWNS); err != nil { return fmt.Errorf("Error creating mount namespace before pivot: %v", err) } @@ -47,7 +47,7 @@ func chroot(path string) (err error) { defer func() { if mounted { // make sure pivotDir is not mounted before we try to remove it - if errCleanup := syscall.Unmount(pivotDir, syscall.MNT_DETACH); errCleanup != nil { + if errCleanup := unix.Unmount(pivotDir, unix.MNT_DETACH); errCleanup != nil { if err == nil { err = errCleanup } @@ -66,7 +66,7 @@ func chroot(path string) (err error) { } }() - if err := syscall.PivotRoot(path, pivotDir); err != nil { + if err := unix.PivotRoot(path, pivotDir); err != nil { // If pivot fails, fall back to the normal chroot after cleaning up temp dir if err := os.Remove(pivotDir); err != nil { return fmt.Errorf("Error cleaning up after failed pivot: %v", err) @@ -79,17 +79,17 @@ func chroot(path string) (err error) { // This dir contains the rootfs of the caller, which we need to remove so it is not visible during extraction pivotDir = filepath.Join("/", filepath.Base(pivotDir)) - if err := syscall.Chdir("/"); err != nil { + if err := unix.Chdir("/"); err != nil { return fmt.Errorf("Error changing to new root: %v", err) } // Make the pivotDir (where the old root lives) private so it can be unmounted without propagating to the host - if err := syscall.Mount("", pivotDir, "", syscall.MS_PRIVATE|syscall.MS_REC, ""); err != nil { + if err := unix.Mount("", pivotDir, "", unix.MS_PRIVATE|unix.MS_REC, ""); err != nil { return fmt.Errorf("Error making old root private after pivot: %v", err) } // Now unmount the old root so it's no longer visible from the new root - if err := syscall.Unmount(pivotDir, syscall.MNT_DETACH); err != nil { + if err := unix.Unmount(pivotDir, unix.MNT_DETACH); err != nil { return fmt.Errorf("Error while unmounting old root after pivot: %v", err) } mounted = false @@ -98,10 +98,10 @@ func chroot(path string) (err error) { } func realChroot(path string) error { - if err := syscall.Chroot(path); err != nil { + if err := unix.Chroot(path); err != nil { return fmt.Errorf("Error after fallback to chroot: %v", err) } - if err := syscall.Chdir("/"); err != nil { + if err := unix.Chdir("/"); err != nil { return fmt.Errorf("Error changing to new root after chroot: %v", err) } return nil diff --git a/pkg/chrootarchive/chroot_unix.go b/pkg/chrootarchive/chroot_unix.go index 16354bf648..f9b5dece8c 100644 --- a/pkg/chrootarchive/chroot_unix.go +++ b/pkg/chrootarchive/chroot_unix.go @@ -2,11 +2,11 @@ package chrootarchive -import "syscall" +import "golang.org/x/sys/unix" func chroot(path string) error { - if err := syscall.Chroot(path); err != nil { + if err := unix.Chroot(path); err != nil { return err } - return syscall.Chdir("/") + return unix.Chdir("/") } diff --git a/pkg/devicemapper/devmapper.go b/pkg/devicemapper/devmapper.go index 08e0c06aad..05dda663b7 100644 --- a/pkg/devicemapper/devmapper.go +++ b/pkg/devicemapper/devmapper.go @@ -7,10 +7,10 @@ import ( "fmt" "os" "runtime" - "syscall" "unsafe" "github.com/Sirupsen/logrus" + "golang.org/x/sys/unix" ) // DevmapperLogger defines methods for logging with devicemapper. @@ -449,7 +449,7 @@ func BlockDeviceDiscard(path string) error { // Without this sometimes the remove of the device that happens after // discard fails with EBUSY. - syscall.Sync() + unix.Sync() return nil } diff --git a/pkg/devicemapper/ioctl.go b/pkg/devicemapper/ioctl.go index b745291442..50ea7c4823 100644 --- a/pkg/devicemapper/ioctl.go +++ b/pkg/devicemapper/ioctl.go @@ -3,13 +3,14 @@ package devicemapper import ( - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) func ioctlBlkGetSize64(fd uintptr) (int64, error) { var size int64 - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, BlkGetSize64, uintptr(unsafe.Pointer(&size))); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, BlkGetSize64, uintptr(unsafe.Pointer(&size))); err != 0 { return 0, err } return size, nil @@ -20,7 +21,7 @@ func ioctlBlkDiscard(fd uintptr, offset, length uint64) error { r[0] = offset r[1] = length - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, BlkDiscard, uintptr(unsafe.Pointer(&r[0]))); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, BlkDiscard, uintptr(unsafe.Pointer(&r[0]))); err != 0 { return err } return nil diff --git a/pkg/fsutils/fsutils_linux.go b/pkg/fsutils/fsutils_linux.go index c8cac30720..e6094b55b7 100644 --- a/pkg/fsutils/fsutils_linux.go +++ b/pkg/fsutils/fsutils_linux.go @@ -6,8 +6,9 @@ import ( "fmt" "io/ioutil" "os" - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) func locateDummyIfEmpty(path string) (string, error) { @@ -40,9 +41,9 @@ func SupportsDType(path string) (bool, error) { visited := 0 supportsDType := true - fn := func(ent *syscall.Dirent) bool { + fn := func(ent *unix.Dirent) bool { visited++ - if ent.Type == syscall.DT_UNKNOWN { + if ent.Type == unix.DT_UNKNOWN { supportsDType = false // stop iteration return true @@ -59,7 +60,7 @@ func SupportsDType(path string) (bool, error) { return supportsDType, nil } -func iterateReadDir(path string, fn func(*syscall.Dirent) bool) error { +func iterateReadDir(path string, fn func(*unix.Dirent) bool) error { d, err := os.Open(path) if err != nil { return err @@ -68,7 +69,7 @@ func iterateReadDir(path string, fn func(*syscall.Dirent) bool) error { fd := int(d.Fd()) buf := make([]byte, 4096) for { - nbytes, err := syscall.ReadDirent(fd, buf) + nbytes, err := unix.ReadDirent(fd, buf) if err != nil { return err } @@ -76,7 +77,7 @@ func iterateReadDir(path string, fn func(*syscall.Dirent) bool) error { break } for off := 0; off < nbytes; { - ent := (*syscall.Dirent)(unsafe.Pointer(&buf[off])) + ent := (*unix.Dirent)(unsafe.Pointer(&buf[off])) if stop := fn(ent); stop { return nil } diff --git a/pkg/fsutils/fsutils_linux_test.go b/pkg/fsutils/fsutils_linux_test.go index 4a648239c0..816752e418 100644 --- a/pkg/fsutils/fsutils_linux_test.go +++ b/pkg/fsutils/fsutils_linux_test.go @@ -6,8 +6,9 @@ import ( "io/ioutil" "os" "os/exec" - "syscall" "testing" + + "golang.org/x/sys/unix" ) func testSupportsDType(t *testing.T, expected bool, mkfsCommand string, mkfsArg ...string) { @@ -53,7 +54,7 @@ func testSupportsDType(t *testing.T, expected bool, mkfsCommand string, mkfsArg } // loopback-mount the image. - // for ease of setting up loopback device, we use os/exec rather than syscall.Mount + // for ease of setting up loopback device, we use os/exec rather than unix.Mount out, err = exec.Command("mount", "-o", "loop", imageFileName, mountpoint).CombinedOutput() if len(out) > 0 { t.Log(string(out)) @@ -62,7 +63,7 @@ func testSupportsDType(t *testing.T, expected bool, mkfsCommand string, mkfsArg t.Skip("skipping the test because mount failed") } defer func() { - if err := syscall.Unmount(mountpoint, 0); err != nil { + if err := unix.Unmount(mountpoint, 0); err != nil { t.Fatal(err) } }() diff --git a/pkg/loopback/attach_loopback.go b/pkg/loopback/attach_loopback.go index dafa94bede..6ea9a309d3 100644 --- a/pkg/loopback/attach_loopback.go +++ b/pkg/loopback/attach_loopback.go @@ -6,9 +6,9 @@ import ( "errors" "fmt" "os" - "syscall" "github.com/Sirupsen/logrus" + "golang.org/x/sys/unix" ) // Loopback related errors @@ -69,7 +69,7 @@ func openNextAvailableLoopback(index int, sparseFile *os.File) (loopFile *os.Fil loopFile.Close() // If the error is EBUSY, then try the next loopback - if err != syscall.EBUSY { + if err != unix.EBUSY { logrus.Errorf("Cannot set up loopback device %s: %s", target, err) return nil, ErrAttachLoopbackDevice } diff --git a/pkg/loopback/ioctl.go b/pkg/loopback/ioctl.go index ea6841958d..534907a023 100644 --- a/pkg/loopback/ioctl.go +++ b/pkg/loopback/ioctl.go @@ -3,12 +3,13 @@ package loopback import ( - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) func ioctlLoopCtlGetFree(fd uintptr) (int, error) { - index, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, LoopCtlGetFree, 0) + index, _, err := unix.Syscall(unix.SYS_IOCTL, fd, LoopCtlGetFree, 0) if err != 0 { return 0, err } @@ -16,21 +17,21 @@ func ioctlLoopCtlGetFree(fd uintptr) (int, error) { } func ioctlLoopSetFd(loopFd, sparseFd uintptr) error { - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopSetFd, sparseFd); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, loopFd, LoopSetFd, sparseFd); err != 0 { return err } return nil } func ioctlLoopSetStatus64(loopFd uintptr, loopInfo *loopInfo64) error { - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopSetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, loopFd, LoopSetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 { return err } return nil } func ioctlLoopClrFd(loopFd uintptr) error { - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopClrFd, 0); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, loopFd, LoopClrFd, 0); err != 0 { return err } return nil @@ -39,14 +40,14 @@ func ioctlLoopClrFd(loopFd uintptr) error { func ioctlLoopGetStatus64(loopFd uintptr) (*loopInfo64, error) { loopInfo := &loopInfo64{} - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopGetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, loopFd, LoopGetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 { return nil, err } return loopInfo, nil } func ioctlLoopSetCapacity(loopFd uintptr, value int) error { - if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopSetCapacity, uintptr(value)); err != 0 { + if _, _, err := unix.Syscall(unix.SYS_IOCTL, loopFd, LoopSetCapacity, uintptr(value)); err != 0 { return err } return nil diff --git a/pkg/mount/flags_linux.go b/pkg/mount/flags_linux.go index 25f466183e..0425d0dd63 100644 --- a/pkg/mount/flags_linux.go +++ b/pkg/mount/flags_linux.go @@ -1,87 +1,87 @@ package mount import ( - "syscall" + "golang.org/x/sys/unix" ) const ( // RDONLY will mount the file system read-only. - RDONLY = syscall.MS_RDONLY + RDONLY = unix.MS_RDONLY // NOSUID will not allow set-user-identifier or set-group-identifier bits to // take effect. - NOSUID = syscall.MS_NOSUID + NOSUID = unix.MS_NOSUID // NODEV will not interpret character or block special devices on the file // system. - NODEV = syscall.MS_NODEV + NODEV = unix.MS_NODEV // NOEXEC will not allow execution of any binaries on the mounted file system. - NOEXEC = syscall.MS_NOEXEC + NOEXEC = unix.MS_NOEXEC // SYNCHRONOUS will allow I/O to the file system to be done synchronously. - SYNCHRONOUS = syscall.MS_SYNCHRONOUS + 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 = syscall.MS_DIRSYNC + 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 = syscall.MS_REMOUNT + REMOUNT = unix.MS_REMOUNT // MANDLOCK will force mandatory locks on a filesystem. - MANDLOCK = syscall.MS_MANDLOCK + MANDLOCK = unix.MS_MANDLOCK // NOATIME will not update the file access time when reading from a file. - NOATIME = syscall.MS_NOATIME + NOATIME = unix.MS_NOATIME // NODIRATIME will not update the directory access time. - NODIRATIME = syscall.MS_NODIRATIME + NODIRATIME = unix.MS_NODIRATIME // BIND remounts a subtree somewhere else. - BIND = syscall.MS_BIND + BIND = unix.MS_BIND // RBIND remounts a subtree and all possible submounts somewhere else. - RBIND = syscall.MS_BIND | syscall.MS_REC + RBIND = unix.MS_BIND | unix.MS_REC // UNBINDABLE creates a mount which cannot be cloned through a bind operation. - UNBINDABLE = syscall.MS_UNBINDABLE + UNBINDABLE = unix.MS_UNBINDABLE // RUNBINDABLE marks the entire mount tree as UNBINDABLE. - RUNBINDABLE = syscall.MS_UNBINDABLE | syscall.MS_REC + RUNBINDABLE = unix.MS_UNBINDABLE | unix.MS_REC // PRIVATE creates a mount which carries no propagation abilities. - PRIVATE = syscall.MS_PRIVATE + PRIVATE = unix.MS_PRIVATE // RPRIVATE marks the entire mount tree as PRIVATE. - RPRIVATE = syscall.MS_PRIVATE | syscall.MS_REC + RPRIVATE = unix.MS_PRIVATE | unix.MS_REC // SLAVE creates a mount which receives propagation from its master, but not // vice versa. - SLAVE = syscall.MS_SLAVE + SLAVE = unix.MS_SLAVE // RSLAVE marks the entire mount tree as SLAVE. - RSLAVE = syscall.MS_SLAVE | syscall.MS_REC + 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 = syscall.MS_SHARED + SHARED = unix.MS_SHARED // RSHARED marks the entire mount tree as SHARED. - RSHARED = syscall.MS_SHARED | syscall.MS_REC + RSHARED = unix.MS_SHARED | unix.MS_REC // RELATIME updates inode access times relative to modify or change time. - RELATIME = syscall.MS_RELATIME + 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 = syscall.MS_STRICTATIME + STRICTATIME = unix.MS_STRICTATIME - mntDetach = syscall.MNT_DETACH + mntDetach = unix.MNT_DETACH ) diff --git a/pkg/mount/mounter_freebsd.go b/pkg/mount/mounter_freebsd.go index bb870e6f59..814896cc9e 100644 --- a/pkg/mount/mounter_freebsd.go +++ b/pkg/mount/mounter_freebsd.go @@ -13,8 +13,9 @@ import "C" import ( "fmt" "strings" - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) func allocateIOVecs(options []string) []C.struct_iovec { @@ -55,5 +56,5 @@ func mount(device, target, mType string, flag uintptr, data string) error { } func unmount(target string, flag int) error { - return syscall.Unmount(target, flag) + return unix.Unmount(target, flag) } diff --git a/pkg/mount/mounter_linux.go b/pkg/mount/mounter_linux.go index 3ef2ce6f0d..e88905cc35 100644 --- a/pkg/mount/mounter_linux.go +++ b/pkg/mount/mounter_linux.go @@ -1,18 +1,18 @@ package mount import ( - "syscall" + "golang.org/x/sys/unix" ) const ( // ptypes is the set propagation types. - ptypes = syscall.MS_SHARED | syscall.MS_PRIVATE | syscall.MS_SLAVE | syscall.MS_UNBINDABLE + 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 | syscall.MS_REC | syscall.MS_SILENT + pflags = ptypes | unix.MS_REC | unix.MS_SILENT // broflags is the combination of bind and read only - broflags = syscall.MS_BIND | syscall.MS_RDONLY + broflags = unix.MS_BIND | unix.MS_RDONLY ) // isremount returns true if either device name or flags identify a remount request, false otherwise. @@ -20,7 +20,7 @@ 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&syscall.MS_REMOUNT != 0, device == "", device == "none": + case flags&unix.MS_REMOUNT != 0, device == "", device == "none": return true default: return false @@ -31,26 +31,26 @@ func mount(device, target, mType string, flags uintptr, data string) error { oflags := flags &^ ptypes if !isremount(device, flags) { // Initial call applying all non-propagation flags. - if err := syscall.Mount(device, target, mType, oflags, data); err != nil { + if err := unix.Mount(device, target, mType, oflags, data); err != nil { return err } } if flags&ptypes != 0 { // Change the propagation type. - if err := syscall.Mount("", target, "", flags&pflags, ""); err != nil { + if err := unix.Mount("", target, "", flags&pflags, ""); err != nil { return err } } if oflags&broflags == broflags { // Remount the bind to apply read only. - return syscall.Mount("", target, "", oflags|syscall.MS_REMOUNT, "") + return unix.Mount("", target, "", oflags|unix.MS_REMOUNT, "") } return nil } func unmount(target string, flag int) error { - return syscall.Unmount(target, flag) + return unix.Unmount(target, flag) } diff --git a/pkg/mount/sharedsubtree_linux_test.go b/pkg/mount/sharedsubtree_linux_test.go index c1837942e3..f25ab19fed 100644 --- a/pkg/mount/sharedsubtree_linux_test.go +++ b/pkg/mount/sharedsubtree_linux_test.go @@ -5,8 +5,9 @@ package mount import ( "os" "path" - "syscall" "testing" + + "golang.org/x/sys/unix" ) // nothing is propagated in or out @@ -309,7 +310,7 @@ func TestSubtreeUnbindable(t *testing.T) { }() // then attempt to mount it to target. It should fail - if err := Mount(sourceDir, targetDir, "none", "bind,rw"); err != nil && err != syscall.EINVAL { + if err := Mount(sourceDir, targetDir, "none", "bind,rw"); err != nil && err != unix.EINVAL { t.Fatal(err) } else if err == nil { t.Fatalf("%q should not have been bindable", sourceDir) diff --git a/pkg/parsers/kernel/kernel_windows.go b/pkg/parsers/kernel/kernel_windows.go index 80fab8ff64..e598672776 100644 --- a/pkg/parsers/kernel/kernel_windows.go +++ b/pkg/parsers/kernel/kernel_windows.go @@ -4,8 +4,9 @@ package kernel import ( "fmt" - "syscall" "unsafe" + + "golang.org/x/sys/windows" ) // VersionInfo holds information about the kernel. @@ -24,28 +25,28 @@ func (k *VersionInfo) String() string { func GetKernelVersion() (*VersionInfo, error) { var ( - h syscall.Handle + h windows.Handle dwVersion uint32 err error ) KVI := &VersionInfo{"Unknown", 0, 0, 0} - if err = syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, - syscall.StringToUTF16Ptr(`SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\`), + if err = windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE, + windows.StringToUTF16Ptr(`SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\`), 0, - syscall.KEY_READ, + windows.KEY_READ, &h); err != nil { return KVI, err } - defer syscall.RegCloseKey(h) + defer windows.RegCloseKey(h) var buf [1 << 10]uint16 var typ uint32 n := uint32(len(buf) * 2) // api expects array of bytes, not uint16 - if err = syscall.RegQueryValueEx(h, - syscall.StringToUTF16Ptr("BuildLabEx"), + if err = windows.RegQueryValueEx(h, + windows.StringToUTF16Ptr("BuildLabEx"), nil, &typ, (*byte)(unsafe.Pointer(&buf[0])), @@ -53,11 +54,11 @@ func GetKernelVersion() (*VersionInfo, error) { return KVI, err } - KVI.kvi = syscall.UTF16ToString(buf[:]) + KVI.kvi = windows.UTF16ToString(buf[:]) // Important - docker.exe MUST be manifested for this API to return // the correct information. - if dwVersion, err = syscall.GetVersion(); err != nil { + if dwVersion, err = windows.GetVersion(); err != nil { return KVI, err } diff --git a/pkg/parsers/kernel/uname_linux.go b/pkg/parsers/kernel/uname_linux.go index bb9b32641e..e913fad001 100644 --- a/pkg/parsers/kernel/uname_linux.go +++ b/pkg/parsers/kernel/uname_linux.go @@ -1,18 +1,16 @@ package kernel -import ( - "syscall" -) +import "golang.org/x/sys/unix" // Utsname represents the system name structure. -// It is passthrough for syscall.Utsname in order to make it portable with +// It is passthrough for unix.Utsname in order to make it portable with // other platforms where it is not available. -type Utsname syscall.Utsname +type Utsname unix.Utsname -func uname() (*syscall.Utsname, error) { - uts := &syscall.Utsname{} +func uname() (*unix.Utsname, error) { + uts := &unix.Utsname{} - if err := syscall.Uname(uts); err != nil { + if err := unix.Uname(uts); err != nil { return nil, err } return uts, nil diff --git a/pkg/parsers/operatingsystem/operatingsystem_windows.go b/pkg/parsers/operatingsystem/operatingsystem_windows.go index 3c86b6af9c..5d8b42cc36 100644 --- a/pkg/parsers/operatingsystem/operatingsystem_windows.go +++ b/pkg/parsers/operatingsystem/operatingsystem_windows.go @@ -1,8 +1,9 @@ package operatingsystem import ( - "syscall" "unsafe" + + "golang.org/x/sys/windows" ) // See https://code.google.com/p/go/source/browse/src/pkg/mime/type_windows.go?r=d14520ac25bf6940785aabb71f5be453a286f58c @@ -11,33 +12,33 @@ import ( // GetOperatingSystem gets the name of the current operating system. func GetOperatingSystem() (string, error) { - var h syscall.Handle + var h windows.Handle // Default return value ret := "Unknown Operating System" - if err := syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, - syscall.StringToUTF16Ptr(`SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\`), + if err := windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE, + windows.StringToUTF16Ptr(`SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\`), 0, - syscall.KEY_READ, + windows.KEY_READ, &h); err != nil { return ret, err } - defer syscall.RegCloseKey(h) + defer windows.RegCloseKey(h) var buf [1 << 10]uint16 var typ uint32 n := uint32(len(buf) * 2) // api expects array of bytes, not uint16 - if err := syscall.RegQueryValueEx(h, - syscall.StringToUTF16Ptr("ProductName"), + if err := windows.RegQueryValueEx(h, + windows.StringToUTF16Ptr("ProductName"), nil, &typ, (*byte)(unsafe.Pointer(&buf[0])), &n); err != nil { return ret, err } - ret = syscall.UTF16ToString(buf[:]) + ret = windows.UTF16ToString(buf[:]) return ret, nil } diff --git a/pkg/pidfile/pidfile_darwin.go b/pkg/pidfile/pidfile_darwin.go index f490f53580..2cd001a70a 100644 --- a/pkg/pidfile/pidfile_darwin.go +++ b/pkg/pidfile/pidfile_darwin.go @@ -3,12 +3,12 @@ package pidfile import ( - "syscall" + "golang.org/x/sys/unix" ) func processExists(pid int) bool { // OS X does not have a proc filesystem. // Use kill -0 pid to judge if the process exists. - err := syscall.Kill(pid, 0) + err := unix.Kill(pid, 0) return err == nil } diff --git a/pkg/pidfile/pidfile_windows.go b/pkg/pidfile/pidfile_windows.go index ae489c627a..86850d465f 100644 --- a/pkg/pidfile/pidfile_windows.go +++ b/pkg/pidfile/pidfile_windows.go @@ -1,6 +1,8 @@ package pidfile -import "syscall" +import ( + "golang.org/x/sys/windows" +) const ( processQueryLimitedInformation = 0x1000 @@ -9,13 +11,13 @@ const ( ) func processExists(pid int) bool { - h, err := syscall.OpenProcess(processQueryLimitedInformation, false, uint32(pid)) + h, err := windows.OpenProcess(processQueryLimitedInformation, false, uint32(pid)) if err != nil { return false } var c uint32 - err = syscall.GetExitCodeProcess(h, &c) - syscall.Close(h) + err = windows.GetExitCodeProcess(h, &c) + windows.Close(h) if err != nil { return c == stillActive } diff --git a/pkg/platform/architecture_linux.go b/pkg/platform/architecture_linux.go index 2cdc2c5918..061127cd24 100644 --- a/pkg/platform/architecture_linux.go +++ b/pkg/platform/architecture_linux.go @@ -3,13 +3,13 @@ package platform import ( - "syscall" + "golang.org/x/sys/unix" ) // runtimeArchitecture gets the name of the current architecture (x86, x86_64, …) func runtimeArchitecture() (string, error) { - utsname := &syscall.Utsname{} - if err := syscall.Uname(utsname); err != nil { + utsname := &unix.Utsname{} + if err := unix.Uname(utsname); err != nil { return "", err } return charsToString(utsname.Machine), nil diff --git a/pkg/platform/utsname_int8.go b/pkg/platform/utsname_int8.go index 5dcbadfdfe..a948873cd5 100644 --- a/pkg/platform/utsname_int8.go +++ b/pkg/platform/utsname_int8.go @@ -1,5 +1,5 @@ -// +build linux,386 linux,amd64 linux,arm64 -// see golang's sources src/syscall/ztypes_linux_*.go that use int8 +// +build linux,386 linux,amd64 linux,arm64 s390x +// see golang's sources golang.org/x/sys/unix/ztypes_linux_*.go that use int8 package platform diff --git a/pkg/platform/utsname_int8_test.go b/pkg/platform/utsname_int8_test.go index 9dada23591..7cd7208f65 100644 --- a/pkg/platform/utsname_int8_test.go +++ b/pkg/platform/utsname_int8_test.go @@ -1,4 +1,4 @@ -// +build linux,386 linux,amd64 linux,arm64 +// +build linux,386 linux,amd64 linux,arm64 s390x package platform diff --git a/pkg/platform/utsname_uint8.go b/pkg/platform/utsname_uint8.go index c9875cf6e6..b4af7a5c8e 100644 --- a/pkg/platform/utsname_uint8.go +++ b/pkg/platform/utsname_uint8.go @@ -1,5 +1,5 @@ -// +build linux,arm linux,ppc64 linux,ppc64le s390x -// see golang's sources src/syscall/ztypes_linux_*.go that use uint8 +// +build linux,arm linux,ppc64 linux,ppc64le +// see golang's sources golang.org/x/sys/unix/ztypes_linux_*.go that use uint8 package platform diff --git a/pkg/platform/utsname_uint8_test.go b/pkg/platform/utsname_uint8_test.go index 444b83bdbe..835eaa9306 100644 --- a/pkg/platform/utsname_uint8_test.go +++ b/pkg/platform/utsname_uint8_test.go @@ -1,4 +1,4 @@ -// +build linux,arm linux,ppc64 linux,ppc64le s390x +// +build linux,arm linux,ppc64 linux,ppc64le package platform diff --git a/pkg/reexec/command_linux.go b/pkg/reexec/command_linux.go index 34ae2a9dcd..05319eacc9 100644 --- a/pkg/reexec/command_linux.go +++ b/pkg/reexec/command_linux.go @@ -5,6 +5,8 @@ package reexec import ( "os/exec" "syscall" + + "golang.org/x/sys/unix" ) // Self returns the path to the current process's binary. @@ -22,7 +24,7 @@ func Command(args ...string) *exec.Cmd { Path: Self(), Args: args, SysProcAttr: &syscall.SysProcAttr{ - Pdeathsig: syscall.SIGTERM, + Pdeathsig: unix.SIGTERM, }, } } diff --git a/pkg/signal/signal_linux.go b/pkg/signal/signal_linux.go index d418cbe9e3..3594796caf 100644 --- a/pkg/signal/signal_linux.go +++ b/pkg/signal/signal_linux.go @@ -2,6 +2,8 @@ package signal import ( "syscall" + + "golang.org/x/sys/unix" ) const ( @@ -11,41 +13,41 @@ const ( // SignalMap is a map of Linux signals. var SignalMap = map[string]syscall.Signal{ - "ABRT": syscall.SIGABRT, - "ALRM": syscall.SIGALRM, - "BUS": syscall.SIGBUS, - "CHLD": syscall.SIGCHLD, - "CLD": syscall.SIGCLD, - "CONT": syscall.SIGCONT, - "FPE": syscall.SIGFPE, - "HUP": syscall.SIGHUP, - "ILL": syscall.SIGILL, - "INT": syscall.SIGINT, - "IO": syscall.SIGIO, - "IOT": syscall.SIGIOT, - "KILL": syscall.SIGKILL, - "PIPE": syscall.SIGPIPE, - "POLL": syscall.SIGPOLL, - "PROF": syscall.SIGPROF, - "PWR": syscall.SIGPWR, - "QUIT": syscall.SIGQUIT, - "SEGV": syscall.SIGSEGV, - "STKFLT": syscall.SIGSTKFLT, - "STOP": syscall.SIGSTOP, - "SYS": syscall.SIGSYS, - "TERM": syscall.SIGTERM, - "TRAP": syscall.SIGTRAP, - "TSTP": syscall.SIGTSTP, - "TTIN": syscall.SIGTTIN, - "TTOU": syscall.SIGTTOU, - "UNUSED": syscall.SIGUNUSED, - "URG": syscall.SIGURG, - "USR1": syscall.SIGUSR1, - "USR2": syscall.SIGUSR2, - "VTALRM": syscall.SIGVTALRM, - "WINCH": syscall.SIGWINCH, - "XCPU": syscall.SIGXCPU, - "XFSZ": syscall.SIGXFSZ, + "ABRT": unix.SIGABRT, + "ALRM": unix.SIGALRM, + "BUS": unix.SIGBUS, + "CHLD": unix.SIGCHLD, + "CLD": unix.SIGCLD, + "CONT": unix.SIGCONT, + "FPE": unix.SIGFPE, + "HUP": unix.SIGHUP, + "ILL": unix.SIGILL, + "INT": unix.SIGINT, + "IO": unix.SIGIO, + "IOT": unix.SIGIOT, + "KILL": unix.SIGKILL, + "PIPE": unix.SIGPIPE, + "POLL": unix.SIGPOLL, + "PROF": unix.SIGPROF, + "PWR": unix.SIGPWR, + "QUIT": unix.SIGQUIT, + "SEGV": unix.SIGSEGV, + "STKFLT": unix.SIGSTKFLT, + "STOP": unix.SIGSTOP, + "SYS": unix.SIGSYS, + "TERM": unix.SIGTERM, + "TRAP": unix.SIGTRAP, + "TSTP": unix.SIGTSTP, + "TTIN": unix.SIGTTIN, + "TTOU": unix.SIGTTOU, + "UNUSED": unix.SIGUNUSED, + "URG": unix.SIGURG, + "USR1": unix.SIGUSR1, + "USR2": unix.SIGUSR2, + "VTALRM": unix.SIGVTALRM, + "WINCH": unix.SIGWINCH, + "XCPU": unix.SIGXCPU, + "XFSZ": unix.SIGXFSZ, "RTMIN": sigrtmin, "RTMIN+1": sigrtmin + 1, "RTMIN+2": sigrtmin + 2, diff --git a/pkg/symlink/fs_windows.go b/pkg/symlink/fs_windows.go index 241e531f9d..31523ade92 100644 --- a/pkg/symlink/fs_windows.go +++ b/pkg/symlink/fs_windows.go @@ -6,49 +6,49 @@ import ( "os" "path/filepath" "strings" - "syscall" "github.com/docker/docker/pkg/longpath" + "golang.org/x/sys/windows" ) func toShort(path string) (string, error) { - p, err := syscall.UTF16FromString(path) + p, err := windows.UTF16FromString(path) if err != nil { return "", err } b := p // GetShortPathName says we can reuse buffer - n, err := syscall.GetShortPathName(&p[0], &b[0], uint32(len(b))) + n, err := windows.GetShortPathName(&p[0], &b[0], uint32(len(b))) if err != nil { return "", err } if n > uint32(len(b)) { b = make([]uint16, n) - if _, err = syscall.GetShortPathName(&p[0], &b[0], uint32(len(b))); err != nil { + if _, err = windows.GetShortPathName(&p[0], &b[0], uint32(len(b))); err != nil { return "", err } } - return syscall.UTF16ToString(b), nil + return windows.UTF16ToString(b), nil } func toLong(path string) (string, error) { - p, err := syscall.UTF16FromString(path) + p, err := windows.UTF16FromString(path) if err != nil { return "", err } b := p // GetLongPathName says we can reuse buffer - n, err := syscall.GetLongPathName(&p[0], &b[0], uint32(len(b))) + n, err := windows.GetLongPathName(&p[0], &b[0], uint32(len(b))) if err != nil { return "", err } if n > uint32(len(b)) { b = make([]uint16, n) - n, err = syscall.GetLongPathName(&p[0], &b[0], uint32(len(b))) + n, err = windows.GetLongPathName(&p[0], &b[0], uint32(len(b))) if err != nil { return "", err } } b = b[:n] - return syscall.UTF16ToString(b), nil + return windows.UTF16ToString(b), nil } func evalSymlinks(path string) (string, error) { @@ -65,7 +65,7 @@ func evalSymlinks(path string) (string, error) { if err != nil { return "", err } - // syscall.GetLongPathName does not change the case of the drive letter, + // windows.GetLongPathName does not change the case of the drive letter, // but the result of EvalSymlinks must be unique, so we have // EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`). // Make drive letter upper case. diff --git a/pkg/sysinfo/numcpu_linux.go b/pkg/sysinfo/numcpu_linux.go index 5eacd35121..f1d2d9db30 100644 --- a/pkg/sysinfo/numcpu_linux.go +++ b/pkg/sysinfo/numcpu_linux.go @@ -4,8 +4,9 @@ package sysinfo import ( "runtime" - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) // numCPU queries the system for the count of threads available @@ -15,10 +16,10 @@ import ( // Returns 0 on errors. Use |runtime.NumCPU| in that case. func numCPU() int { // Gets the affinity mask for a process: The very one invoking this function. - pid, _, _ := syscall.RawSyscall(syscall.SYS_GETPID, 0, 0, 0) + pid, _, _ := unix.RawSyscall(unix.SYS_GETPID, 0, 0, 0) var mask [1024 / 64]uintptr - _, _, err := syscall.RawSyscall(syscall.SYS_SCHED_GETAFFINITY, pid, uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask[0]))) + _, _, err := unix.RawSyscall(unix.SYS_SCHED_GETAFFINITY, pid, uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask[0]))) if err != 0 { return 0 } diff --git a/pkg/sysinfo/sysinfo_linux.go b/pkg/sysinfo/sysinfo_linux.go index 7ad84a8309..2d33b4dbc3 100644 --- a/pkg/sysinfo/sysinfo_linux.go +++ b/pkg/sysinfo/sysinfo_linux.go @@ -6,10 +6,10 @@ import ( "os" "path" "strings" - "syscall" "github.com/Sirupsen/logrus" "github.com/opencontainers/runc/libcontainer/cgroups" + "golang.org/x/sys/unix" ) const ( @@ -60,9 +60,9 @@ func New(quiet bool) *SysInfo { } // Check if Seccomp is supported, via CONFIG_SECCOMP. - if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_GET_SECCOMP, 0, 0); err != syscall.EINVAL { + if _, _, err := unix.RawSyscall(unix.SYS_PRCTL, unix.PR_GET_SECCOMP, 0, 0); err != unix.EINVAL { // Make sure the kernel has CONFIG_SECCOMP_FILTER. - if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_SECCOMP, SeccompModeFilter, 0); err != syscall.EINVAL { + if _, _, err := unix.RawSyscall(unix.SYS_PRCTL, unix.PR_SET_SECCOMP, SeccompModeFilter, 0); err != unix.EINVAL { sysInfo.Seccomp = true } } diff --git a/pkg/system/chtimes_windows.go b/pkg/system/chtimes_windows.go index 2945868465..45428c141c 100644 --- a/pkg/system/chtimes_windows.go +++ b/pkg/system/chtimes_windows.go @@ -3,25 +3,26 @@ package system import ( - "syscall" "time" + + "golang.org/x/sys/windows" ) //setCTime will set the create time on a file. On Windows, this requires //calling SetFileTime and explicitly including the create time. func setCTime(path string, ctime time.Time) error { - ctimespec := syscall.NsecToTimespec(ctime.UnixNano()) - pathp, e := syscall.UTF16PtrFromString(path) + ctimespec := windows.NsecToTimespec(ctime.UnixNano()) + pathp, e := windows.UTF16PtrFromString(path) if e != nil { return e } - h, e := syscall.CreateFile(pathp, - syscall.FILE_WRITE_ATTRIBUTES, syscall.FILE_SHARE_WRITE, nil, - syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS, 0) + h, e := windows.CreateFile(pathp, + windows.FILE_WRITE_ATTRIBUTES, windows.FILE_SHARE_WRITE, nil, + windows.OPEN_EXISTING, windows.FILE_FLAG_BACKUP_SEMANTICS, 0) if e != nil { return e } - defer syscall.Close(h) - c := syscall.NsecToFiletime(syscall.TimespecToNsec(ctimespec)) - return syscall.SetFileTime(h, &c, nil, nil) + defer windows.Close(h) + c := windows.NsecToFiletime(windows.TimespecToNsec(ctimespec)) + return windows.SetFileTime(h, &c, nil, nil) } diff --git a/pkg/system/events_windows.go b/pkg/system/events_windows.go index 3ec6d22151..192e367882 100644 --- a/pkg/system/events_windows.go +++ b/pkg/system/events_windows.go @@ -19,8 +19,8 @@ var ( ) // CreateEvent implements win32 CreateEventW func in golang. It will create an event object. -func CreateEvent(eventAttributes *syscall.SecurityAttributes, manualReset bool, initialState bool, name string) (handle syscall.Handle, err error) { - namep, _ := syscall.UTF16PtrFromString(name) +func CreateEvent(eventAttributes *windows.SecurityAttributes, manualReset bool, initialState bool, name string) (handle windows.Handle, err error) { + namep, _ := windows.UTF16PtrFromString(name) var _p1 uint32 if manualReset { _p1 = 1 @@ -31,45 +31,45 @@ func CreateEvent(eventAttributes *syscall.SecurityAttributes, manualReset bool, } r0, _, e1 := procCreateEvent.Call(uintptr(unsafe.Pointer(eventAttributes)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(namep))) use(unsafe.Pointer(namep)) - handle = syscall.Handle(r0) - if handle == syscall.InvalidHandle { + handle = windows.Handle(r0) + if handle == windows.InvalidHandle { err = e1 } return } // OpenEvent implements win32 OpenEventW func in golang. It opens an event object. -func OpenEvent(desiredAccess uint32, inheritHandle bool, name string) (handle syscall.Handle, err error) { - namep, _ := syscall.UTF16PtrFromString(name) +func OpenEvent(desiredAccess uint32, inheritHandle bool, name string) (handle windows.Handle, err error) { + namep, _ := windows.UTF16PtrFromString(name) var _p1 uint32 if inheritHandle { _p1 = 1 } r0, _, e1 := procOpenEvent.Call(uintptr(desiredAccess), uintptr(_p1), uintptr(unsafe.Pointer(namep))) use(unsafe.Pointer(namep)) - handle = syscall.Handle(r0) - if handle == syscall.InvalidHandle { + handle = windows.Handle(r0) + if handle == windows.InvalidHandle { err = e1 } return } // SetEvent implements win32 SetEvent func in golang. -func SetEvent(handle syscall.Handle) (err error) { +func SetEvent(handle windows.Handle) (err error) { return setResetPulse(handle, procSetEvent) } // ResetEvent implements win32 ResetEvent func in golang. -func ResetEvent(handle syscall.Handle) (err error) { +func ResetEvent(handle windows.Handle) (err error) { return setResetPulse(handle, procResetEvent) } // PulseEvent implements win32 PulseEvent func in golang. -func PulseEvent(handle syscall.Handle) (err error) { +func PulseEvent(handle windows.Handle) (err error) { return setResetPulse(handle, procPulseEvent) } -func setResetPulse(handle syscall.Handle, proc *windows.LazyProc) (err error) { +func setResetPulse(handle windows.Handle, proc *windows.LazyProc) (err error) { r0, _, _ := proc.Call(uintptr(handle)) if r0 != 0 { err = syscall.Errno(r0) diff --git a/pkg/system/filesys_windows.go b/pkg/system/filesys_windows.go index 20117db919..a61b53d0ba 100644 --- a/pkg/system/filesys_windows.go +++ b/pkg/system/filesys_windows.go @@ -14,6 +14,7 @@ import ( "unsafe" winio "github.com/Microsoft/go-winio" + "golang.org/x/sys/windows" ) const ( @@ -99,13 +100,12 @@ func mkdirall(path string, applyACL bool, sddl string) error { // mkdirWithACL creates a new directory. If there is an error, it will be of // type *PathError. . // -// This is a modified and combined version of os.Mkdir and syscall.Mkdir +// This is a modified and combined version of os.Mkdir and windows.Mkdir // in golang to cater for creating a directory am ACL permitting full // access, with inheritance, to any subfolder/file for Built-in Administrators // and Local System. func mkdirWithACL(name string, sddl string) error { - sa := syscall.SecurityAttributes{Length: 0} - + sa := windows.SecurityAttributes{Length: 0} sd, err := winio.SddlToSecurityDescriptor(sddl) if err != nil { return &os.PathError{Op: "mkdir", Path: name, Err: err} @@ -114,12 +114,12 @@ func mkdirWithACL(name string, sddl string) error { sa.InheritHandle = 1 sa.SecurityDescriptor = uintptr(unsafe.Pointer(&sd[0])) - namep, err := syscall.UTF16PtrFromString(name) + namep, err := windows.UTF16PtrFromString(name) if err != nil { return &os.PathError{Op: "mkdir", Path: name, Err: err} } - e := syscall.CreateDirectory(namep, &sa) + e := windows.CreateDirectory(namep, &sa) if e != nil { return &os.PathError{Op: "mkdir", Path: name, Err: e} } @@ -142,7 +142,7 @@ func IsAbs(path string) bool { return true } -// The origin of the functions below here are the golang OS and syscall packages, +// The origin of the functions below here are the golang OS and windows packages, // slightly modified to only cope with files, not directories due to the // specific use case. // @@ -174,74 +174,74 @@ func OpenFileSequential(name string, flag int, _ os.FileMode) (*os.File, error) if name == "" { return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT} } - r, errf := syscallOpenFileSequential(name, flag, 0) + r, errf := windowsOpenFileSequential(name, flag, 0) if errf == nil { return r, nil } return nil, &os.PathError{Op: "open", Path: name, Err: errf} } -func syscallOpenFileSequential(name string, flag int, _ os.FileMode) (file *os.File, err error) { - r, e := syscallOpenSequential(name, flag|syscall.O_CLOEXEC, 0) +func windowsOpenFileSequential(name string, flag int, _ os.FileMode) (file *os.File, err error) { + r, e := windowsOpenSequential(name, flag|windows.O_CLOEXEC, 0) if e != nil { return nil, e } return os.NewFile(uintptr(r), name), nil } -func makeInheritSa() *syscall.SecurityAttributes { - var sa syscall.SecurityAttributes +func makeInheritSa() *windows.SecurityAttributes { + var sa windows.SecurityAttributes sa.Length = uint32(unsafe.Sizeof(sa)) sa.InheritHandle = 1 return &sa } -func syscallOpenSequential(path string, mode int, _ uint32) (fd syscall.Handle, err error) { +func windowsOpenSequential(path string, mode int, _ uint32) (fd windows.Handle, err error) { if len(path) == 0 { - return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND + return windows.InvalidHandle, windows.ERROR_FILE_NOT_FOUND } - pathp, err := syscall.UTF16PtrFromString(path) + pathp, err := windows.UTF16PtrFromString(path) if err != nil { - return syscall.InvalidHandle, err + return windows.InvalidHandle, err } var access uint32 - switch mode & (syscall.O_RDONLY | syscall.O_WRONLY | syscall.O_RDWR) { - case syscall.O_RDONLY: - access = syscall.GENERIC_READ - case syscall.O_WRONLY: - access = syscall.GENERIC_WRITE - case syscall.O_RDWR: - access = syscall.GENERIC_READ | syscall.GENERIC_WRITE + switch mode & (windows.O_RDONLY | windows.O_WRONLY | windows.O_RDWR) { + case windows.O_RDONLY: + access = windows.GENERIC_READ + case windows.O_WRONLY: + access = windows.GENERIC_WRITE + case windows.O_RDWR: + access = windows.GENERIC_READ | windows.GENERIC_WRITE } - if mode&syscall.O_CREAT != 0 { - access |= syscall.GENERIC_WRITE + if mode&windows.O_CREAT != 0 { + access |= windows.GENERIC_WRITE } - if mode&syscall.O_APPEND != 0 { - access &^= syscall.GENERIC_WRITE - access |= syscall.FILE_APPEND_DATA + if mode&windows.O_APPEND != 0 { + access &^= windows.GENERIC_WRITE + access |= windows.FILE_APPEND_DATA } - sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE) - var sa *syscall.SecurityAttributes - if mode&syscall.O_CLOEXEC == 0 { + sharemode := uint32(windows.FILE_SHARE_READ | windows.FILE_SHARE_WRITE) + var sa *windows.SecurityAttributes + if mode&windows.O_CLOEXEC == 0 { sa = makeInheritSa() } var createmode uint32 switch { - case mode&(syscall.O_CREAT|syscall.O_EXCL) == (syscall.O_CREAT | syscall.O_EXCL): - createmode = syscall.CREATE_NEW - case mode&(syscall.O_CREAT|syscall.O_TRUNC) == (syscall.O_CREAT | syscall.O_TRUNC): - createmode = syscall.CREATE_ALWAYS - case mode&syscall.O_CREAT == syscall.O_CREAT: - createmode = syscall.OPEN_ALWAYS - case mode&syscall.O_TRUNC == syscall.O_TRUNC: - createmode = syscall.TRUNCATE_EXISTING + case mode&(windows.O_CREAT|windows.O_EXCL) == (windows.O_CREAT | windows.O_EXCL): + createmode = windows.CREATE_NEW + case mode&(windows.O_CREAT|windows.O_TRUNC) == (windows.O_CREAT | windows.O_TRUNC): + createmode = windows.CREATE_ALWAYS + case mode&windows.O_CREAT == windows.O_CREAT: + createmode = windows.OPEN_ALWAYS + case mode&windows.O_TRUNC == windows.O_TRUNC: + createmode = windows.TRUNCATE_EXISTING default: - createmode = syscall.OPEN_EXISTING + createmode = windows.OPEN_EXISTING } // Use FILE_FLAG_SEQUENTIAL_SCAN rather than FILE_ATTRIBUTE_NORMAL as implemented in golang. //https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx const fileFlagSequentialScan = 0x08000000 // FILE_FLAG_SEQUENTIAL_SCAN - h, e := syscall.CreateFile(pathp, access, sharemode, sa, createmode, fileFlagSequentialScan, 0) + h, e := windows.CreateFile(pathp, access, sharemode, sa, createmode, fileFlagSequentialScan, 0) return h, e } diff --git a/pkg/system/lstat_unix.go b/pkg/system/lstat_unix.go index 62fda5bacf..bd23c4d50b 100644 --- a/pkg/system/lstat_unix.go +++ b/pkg/system/lstat_unix.go @@ -2,7 +2,9 @@ package system -import "syscall" +import ( + "syscall" +) // Lstat takes a path to a file and returns // a system.StatT type pertaining to that file. diff --git a/pkg/system/mknod.go b/pkg/system/mknod.go index 73958182b4..af79a65383 100644 --- a/pkg/system/mknod.go +++ b/pkg/system/mknod.go @@ -3,13 +3,13 @@ package system import ( - "syscall" + "golang.org/x/sys/unix" ) // Mknod creates a filesystem node (file, device special file or named pipe) named path // with attributes specified by mode and dev. func Mknod(path string, mode uint32, dev int) error { - return syscall.Mknod(path, mode, dev) + return unix.Mknod(path, mode, dev) } // Mkdev is used to build the value of linux devices (in /dev/) which specifies major diff --git a/pkg/system/process_unix.go b/pkg/system/process_unix.go index c99d796d13..26c8b42c17 100644 --- a/pkg/system/process_unix.go +++ b/pkg/system/process_unix.go @@ -4,12 +4,14 @@ package system import ( "syscall" + + "golang.org/x/sys/unix" ) // IsProcessAlive returns true if process with a given pid is running. func IsProcessAlive(pid int) bool { - err := syscall.Kill(pid, syscall.Signal(0)) - if err == nil || err == syscall.EPERM { + err := unix.Kill(pid, syscall.Signal(0)) + if err == nil || err == unix.EPERM { return true } @@ -18,5 +20,5 @@ func IsProcessAlive(pid int) bool { // KillProcess force-stops a process. func KillProcess(pid int) { - syscall.Kill(pid, syscall.SIGKILL) + unix.Kill(pid, unix.SIGKILL) } diff --git a/pkg/system/stat_unix.go b/pkg/system/stat_unix.go index 6208e74606..91c7d121cc 100644 --- a/pkg/system/stat_unix.go +++ b/pkg/system/stat_unix.go @@ -2,7 +2,9 @@ package system -import "syscall" +import ( + "syscall" +) // StatT type contains status of a file. It contains metadata // like permission, owner, group, size, etc about a file. diff --git a/pkg/system/syscall_unix.go b/pkg/system/syscall_unix.go index 3ae9128468..49dbdd3781 100644 --- a/pkg/system/syscall_unix.go +++ b/pkg/system/syscall_unix.go @@ -2,12 +2,12 @@ package system -import "syscall" +import "golang.org/x/sys/unix" // Unmount is a platform-specific helper function to call // the unmount syscall. func Unmount(dest string) error { - return syscall.Unmount(dest, 0) + return unix.Unmount(dest, 0) } // CommandLineToArgv should not be used on Unix. diff --git a/pkg/system/syscall_windows.go b/pkg/system/syscall_windows.go index c328a6fb86..eded233b9c 100644 --- a/pkg/system/syscall_windows.go +++ b/pkg/system/syscall_windows.go @@ -1,14 +1,14 @@ package system import ( - "syscall" "unsafe" "github.com/Sirupsen/logrus" + "golang.org/x/sys/windows" ) var ( - ntuserApiset = syscall.NewLazyDLL("ext-ms-win-ntuser-window-l1-1-0") + ntuserApiset = windows.NewLazyDLL("ext-ms-win-ntuser-window-l1-1-0") procGetVersionExW = modkernel32.NewProc("GetVersionExW") procGetProductInfo = modkernel32.NewProc("GetProductInfo") ) @@ -42,7 +42,7 @@ type osVersionInfoEx struct { func GetOSVersion() OSVersion { var err error osv := OSVersion{} - osv.Version, err = syscall.GetVersion() + osv.Version, err = windows.GetVersion() if err != nil { // GetVersion never fails. panic(err) @@ -93,20 +93,20 @@ func Unmount(dest string) error { func CommandLineToArgv(commandLine string) ([]string, error) { var argc int32 - argsPtr, err := syscall.UTF16PtrFromString(commandLine) + argsPtr, err := windows.UTF16PtrFromString(commandLine) if err != nil { return nil, err } - argv, err := syscall.CommandLineToArgv(argsPtr, &argc) + argv, err := windows.CommandLineToArgv(argsPtr, &argc) if err != nil { return nil, err } - defer syscall.LocalFree(syscall.Handle(uintptr(unsafe.Pointer(argv)))) + defer windows.LocalFree(windows.Handle(uintptr(unsafe.Pointer(argv)))) newArgs := make([]string, argc) for i, v := range (*argv)[:argc] { - newArgs[i] = string(syscall.UTF16ToString((*v)[:])) + newArgs[i] = string(windows.UTF16ToString((*v)[:])) } return newArgs, nil diff --git a/pkg/system/umask.go b/pkg/system/umask.go index 3d0146b01a..5a10eda5af 100644 --- a/pkg/system/umask.go +++ b/pkg/system/umask.go @@ -3,11 +3,11 @@ package system import ( - "syscall" + "golang.org/x/sys/unix" ) // Umask sets current process's file mode creation mask to newmask // and returns oldmask. func Umask(newmask int) (oldmask int, err error) { - return syscall.Umask(newmask), nil + return unix.Umask(newmask), nil } diff --git a/pkg/system/utimes_freebsd.go b/pkg/system/utimes_freebsd.go index e2eac3b553..6a77524376 100644 --- a/pkg/system/utimes_freebsd.go +++ b/pkg/system/utimes_freebsd.go @@ -3,18 +3,20 @@ package system import ( "syscall" "unsafe" + + "golang.org/x/sys/unix" ) // LUtimesNano is used to change access and modification time of the specified path. -// It's used for symbol link file because syscall.UtimesNano doesn't support a NOFOLLOW flag atm. +// It's used for symbol link file because unix.UtimesNano doesn't support a NOFOLLOW flag atm. func LUtimesNano(path string, ts []syscall.Timespec) error { var _path *byte - _path, err := syscall.BytePtrFromString(path) + _path, err := unix.BytePtrFromString(path) if err != nil { return err } - if _, _, err := syscall.Syscall(syscall.SYS_LUTIMES, uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), 0); err != 0 && err != syscall.ENOSYS { + if _, _, err := unix.Syscall(unix.SYS_LUTIMES, uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), 0); err != 0 && err != unix.ENOSYS { return err } diff --git a/pkg/system/utimes_linux.go b/pkg/system/utimes_linux.go index fc8a1aba95..edc588a63f 100644 --- a/pkg/system/utimes_linux.go +++ b/pkg/system/utimes_linux.go @@ -3,22 +3,21 @@ package system import ( "syscall" "unsafe" + + "golang.org/x/sys/unix" ) // LUtimesNano is used to change access and modification time of the specified path. -// It's used for symbol link file because syscall.UtimesNano doesn't support a NOFOLLOW flag atm. +// It's used for symbol link file because unix.UtimesNano doesn't support a NOFOLLOW flag atm. func LUtimesNano(path string, ts []syscall.Timespec) error { - // These are not currently available in syscall - atFdCwd := -100 - atSymLinkNoFollow := 0x100 + atFdCwd := unix.AT_FDCWD var _path *byte - _path, err := syscall.BytePtrFromString(path) + _path, err := unix.BytePtrFromString(path) if err != nil { return err } - - if _, _, err := syscall.Syscall6(syscall.SYS_UTIMENSAT, uintptr(atFdCwd), uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), uintptr(atSymLinkNoFollow), 0, 0); err != 0 && err != syscall.ENOSYS { + if _, _, err := unix.Syscall6(unix.SYS_UTIMENSAT, uintptr(atFdCwd), uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), unix.AT_SYMLINK_NOFOLLOW, 0, 0); err != 0 && err != unix.ENOSYS { return err } diff --git a/pkg/system/xattrs_linux.go b/pkg/system/xattrs_linux.go index d2e2c05799..762bc3db1b 100644 --- a/pkg/system/xattrs_linux.go +++ b/pkg/system/xattrs_linux.go @@ -1,33 +1,34 @@ package system import ( - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) // Lgetxattr retrieves the value of the extended attribute identified by attr // and associated with the given path in the file system. // It will returns a nil slice and nil error if the xattr is not set. func Lgetxattr(path string, attr string) ([]byte, error) { - pathBytes, err := syscall.BytePtrFromString(path) + pathBytes, err := unix.BytePtrFromString(path) if err != nil { return nil, err } - attrBytes, err := syscall.BytePtrFromString(attr) + attrBytes, err := unix.BytePtrFromString(attr) if err != nil { return nil, err } dest := make([]byte, 128) destBytes := unsafe.Pointer(&dest[0]) - sz, _, errno := syscall.Syscall6(syscall.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(destBytes), uintptr(len(dest)), 0, 0) - if errno == syscall.ENODATA { + sz, _, errno := unix.Syscall6(unix.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(destBytes), uintptr(len(dest)), 0, 0) + if errno == unix.ENODATA { return nil, nil } - if errno == syscall.ERANGE { + if errno == unix.ERANGE { dest = make([]byte, sz) destBytes := unsafe.Pointer(&dest[0]) - sz, _, errno = syscall.Syscall6(syscall.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(destBytes), uintptr(len(dest)), 0, 0) + sz, _, errno = unix.Syscall6(unix.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(destBytes), uintptr(len(dest)), 0, 0) } if errno != 0 { return nil, errno @@ -41,11 +42,11 @@ var _zero uintptr // Lsetxattr sets the value of the extended attribute identified by attr // and associated with the given path in the file system. func Lsetxattr(path string, attr string, data []byte, flags int) error { - pathBytes, err := syscall.BytePtrFromString(path) + pathBytes, err := unix.BytePtrFromString(path) if err != nil { return err } - attrBytes, err := syscall.BytePtrFromString(attr) + attrBytes, err := unix.BytePtrFromString(attr) if err != nil { return err } @@ -55,7 +56,7 @@ func Lsetxattr(path string, attr string, data []byte, flags int) error { } else { dataBytes = unsafe.Pointer(&_zero) } - _, _, errno := syscall.Syscall6(syscall.SYS_LSETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(dataBytes), uintptr(len(data)), uintptr(flags), 0) + _, _, errno := unix.Syscall6(unix.SYS_LSETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(dataBytes), uintptr(len(data)), uintptr(flags), 0) if errno != 0 { return errno } diff --git a/plugin/manager_linux.go b/plugin/manager_linux.go index 7f79e6900e..9b84af68dc 100644 --- a/plugin/manager_linux.go +++ b/plugin/manager_linux.go @@ -8,7 +8,6 @@ import ( "net" "os" "path/filepath" - "syscall" "time" "github.com/Sirupsen/logrus" @@ -23,6 +22,7 @@ import ( "github.com/opencontainers/go-digest" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/pkg/errors" + "golang.org/x/sys/unix" ) func (pm *Manager) enable(p *v2.Plugin, c *controller, force bool) error { @@ -146,7 +146,7 @@ func (pm *Manager) restore(p *v2.Plugin) error { func shutdownPlugin(p *v2.Plugin, c *controller, containerdClient libcontainerd.Client) { pluginID := p.GetID() - err := containerdClient.Signal(pluginID, int(syscall.SIGTERM)) + err := containerdClient.Signal(pluginID, int(unix.SIGTERM)) if err != nil { logrus.Errorf("Sending SIGTERM to plugin failed with error: %v", err) } else { @@ -155,7 +155,7 @@ func shutdownPlugin(p *v2.Plugin, c *controller, containerdClient libcontainerd. logrus.Debug("Clean shutdown of plugin") case <-time.After(time.Second * 10): logrus.Debug("Force shutdown plugin") - if err := containerdClient.Signal(pluginID, int(syscall.SIGKILL)); err != nil { + if err := containerdClient.Signal(pluginID, int(unix.SIGKILL)); err != nil { logrus.Errorf("Sending SIGKILL to plugin failed with error: %v", err) } } diff --git a/profiles/seccomp/seccomp_default.go b/profiles/seccomp/seccomp_default.go index 833dcd5a8a..1e6ea90e34 100644 --- a/profiles/seccomp/seccomp_default.go +++ b/profiles/seccomp/seccomp_default.go @@ -3,9 +3,8 @@ package seccomp import ( - "syscall" - "github.com/docker/docker/api/types" + "golang.org/x/sys/unix" ) func arches() []types.Architecture { @@ -510,7 +509,7 @@ func DefaultProfile() *types.Seccomp { Args: []*types.Arg{ { Index: 0, - Value: syscall.CLONE_NEWNS | syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWUSER | syscall.CLONE_NEWPID | syscall.CLONE_NEWNET, + Value: unix.CLONE_NEWNS | unix.CLONE_NEWUTS | unix.CLONE_NEWIPC | unix.CLONE_NEWUSER | unix.CLONE_NEWPID | unix.CLONE_NEWNET, ValueTwo: 0, Op: types.OpMaskedEqual, }, @@ -528,7 +527,7 @@ func DefaultProfile() *types.Seccomp { Args: []*types.Arg{ { Index: 1, - Value: syscall.CLONE_NEWNS | syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWUSER | syscall.CLONE_NEWPID | syscall.CLONE_NEWNET, + Value: unix.CLONE_NEWNS | unix.CLONE_NEWUTS | unix.CLONE_NEWIPC | unix.CLONE_NEWUSER | unix.CLONE_NEWPID | unix.CLONE_NEWNET, ValueTwo: 0, Op: types.OpMaskedEqual, },