@@ -12,7 +12,6 @@ import (

 	"path/filepath"

 	"strconv"

 	"sync"

-	"syscall"

 	"time"

 )

@@ -344,7 +343,7 @@ func setCloseOnExec(name string) {

 			if link == name {

 				fd, err := strconv.Atoi(i.Name())

 				if err == nil {

-					SyscallCloseOnExec(fd)

+					sysCloseOnExec(fd)

 				}

 			}

 		}

@@ -468,7 +467,7 @@ func (devices *DeviceSet) initDevmapper(doInit bool) error {

 	if err != nil {

 		return fmt.Errorf("Error looking up dir %s: %s", devices.root, err)

 	}

-	sysSt := st.Sys().(*syscall.Stat_t)

+	sysSt := toSysStatT(st.Sys())

 	// "reg-" stands for "regular file".

 	// In the future we might use "dev-" for "device file", etc.

 	// docker-maj,min[-inode] stands for:

@@ -708,15 +707,16 @@ func (devices *DeviceSet) byHash(hash string) (devname string, err error) {

 }

 func (devices *DeviceSet) Shutdown() error {

-	utils.Debugf("[deviceset %s] shutdown()", devices.devicePrefix)

-	defer utils.Debugf("[deviceset %s] shutdown END", devices.devicePrefix)

 	devices.Lock()

-	utils.Debugf("[devmapper] Shutting down DeviceSet: %s", devices.root)

 	defer devices.Unlock()

+	utils.Debugf("[deviceset %s] shutdown()", devices.devicePrefix)

+	utils.Debugf("[devmapper] Shutting down DeviceSet: %s", devices.root)

+	defer utils.Debugf("[deviceset %s] shutdown END", devices.devicePrefix)

+

 	for path, count := range devices.activeMounts {

 		for i := count; i > 0; i-- {

-			if err := SyscallUnmount(path, 0); err != nil {

+			if err := sysUnmount(path, 0); err != nil {

 				utils.Debugf("Shutdown unmounting %s, error: %s\n", path, err)

 			}

 		}

@@ -752,15 +752,15 @@ func (devices *DeviceSet) MountDevice(hash, path string, readOnly bool) error {

 	info := devices.Devices[hash]

-	var flags uintptr = syscall.MS_MGC_VAL

+	var flags uintptr = sysMsMgcVal

 	if readOnly {

-		flags = flags | syscall.MS_RDONLY

+		flags = flags | sysMsRdOnly

 	}

-	err := SyscallMount(info.DevName(), path, "ext4", flags, "discard")

-	if err != nil && err == syscall.EINVAL {

-		err = SyscallMount(info.DevName(), path, "ext4", flags, "")

+	err := sysMount(info.DevName(), path, "ext4", flags, "discard")

+	if err != nil && err == sysEInval {

+		err = sysMount(info.DevName(), path, "ext4", flags, "")

 	}

 	if err != nil {

 		return fmt.Errorf("Error mounting '%s' on '%s': %s", info.DevName(), path, err)

@@ -779,7 +779,7 @@ func (devices *DeviceSet) UnmountDevice(hash, path string, deactivate bool) erro

 	defer devices.Unlock()

 	utils.Debugf("[devmapper] Unmount(%s)", path)

-	if err := SyscallUnmount(path, 0); err != nil {

+	if err := sysUnmount(path, 0); err != nil {

 		utils.Debugf("\n--->Err: %s\n", err)

 		return err

 	}

@@ -6,7 +6,6 @@ import (

 	"github.com/dotcloud/docker/utils"

 	"os"

 	"runtime"

-	"syscall"

 )

 type DevmapperLogger interface {

@@ -210,13 +209,13 @@ func FindLoopDeviceFor(file *os.File) *os.File {

 	if err != nil {

 		return nil

 	}

-	targetInode := stat.Sys().(*syscall.Stat_t).Ino

-	targetDevice := stat.Sys().(*syscall.Stat_t).Dev

+	targetInode := stat.Sys().(*sysStatT).Ino

+	targetDevice := stat.Sys().(*sysStatT).Dev

 	for i := 0; true; i++ {

 		path := fmt.Sprintf("/dev/loop%d", i)

-		file, err := OSOpenFile(path, os.O_RDWR, 0)

+		file, err := osOpenFile(path, os.O_RDWR, 0)

 		if err != nil {

 			if os.IsNotExist(err) {

 				return nil

@@ -394,8 +393,8 @@ func getStatus(name string) (uint64, uint64, string, string, error) {

 		return 0, 0, "", "", fmt.Errorf("Non existing device %s", name)

 	}

-	_, start, length, target_type, params := task.GetNextTarget(0)

-	return start, length, target_type, params, nil

+	_, start, length, targetType, params := task.GetNextTarget(0)

+	return start, length, targetType, params, nil

 }

 func setTransactionId(poolName string, oldId uint64, newId uint64) error {

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

 package devmapper

 import (

-	"syscall"

 	"testing"

 )

@@ -264,7 +263,7 @@ func dmAttachLoopDeviceFail(filename string, fd *int) string {

 	return ""

 }

-func sysGetBlockSizeFail(fd uintptr, size *uint64) syscall.Errno {

+func sysGetBlockSizeFail(fd uintptr, size *uint64) sysErrno {

 	return 1

 }

@@ -140,7 +140,6 @@ static void	log_with_errno_init()

 import "C"

 import (

-	"syscall"

 	"unsafe"

 )

@@ -239,23 +238,22 @@ func dmTaskAddTargetFct(task *CDmTask,

 		C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))

 }

-func dmGetLoopbackBackingFile(fd uintptr) (uint64, uint64, syscall.Errno) {

+func dmGetLoopbackBackingFile(fd uintptr) (uint64, uint64, sysErrno) {

 	var lo64 C.struct_loop_info64

-	_, _, err := SyscallSyscall(syscall.SYS_IOCTL, fd, C.LOOP_GET_STATUS64,

+	_, _, err := sysSyscall(sysSysIoctl, fd, C.LOOP_GET_STATUS64,

 		uintptr(unsafe.Pointer(&lo64)))

-	return uint64(lo64.lo_device), uint64(lo64.lo_inode), err

+	return uint64(lo64.lo_device), uint64(lo64.lo_inode), sysErrno(err)

 }

-func dmLoopbackSetCapacity(fd uintptr) syscall.Errno {

-	_, _, err := SyscallSyscall(syscall.SYS_IOCTL, fd, C.LOOP_SET_CAPACITY, 0)

-	return err

+func dmLoopbackSetCapacity(fd uintptr) sysErrno {

+	_, _, err := sysSyscall(sysSysIoctl, fd, C.LOOP_SET_CAPACITY, 0)

+	return sysErrno(err)

 }

-func dmGetBlockSizeFct(fd uintptr) (int64, syscall.Errno) {

+func dmGetBlockSizeFct(fd uintptr) (int64, sysErrno) {

 	var size int64

-	_, _, err := SyscallSyscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64,

-		uintptr(unsafe.Pointer(&size)))

-	return size, err

+	_, _, err := sysSyscall(sysSysIoctl, fd, C.BLKGETSIZE64, uintptr(unsafe.Pointer(&size)))

+	return size, sysErrno(err)

 }

 func dmTaskGetInfoFct(task *CDmTask, info *Info) int {

@@ -275,9 +273,7 @@ func dmTaskGetInfoFct(task *CDmTask, info *Info) int {

 	return int(C.dm_task_get_info((*C.struct_dm_task)(task), &Cinfo))

 }

-func dmGetNextTargetFct(task *CDmTask, next uintptr, start, length *uint64,

-	target, params *string) uintptr {

-

+func dmGetNextTargetFct(task *CDmTask, next uintptr, start, length *uint64, target, params *string) uintptr {

 	var (

 		Cstart, Clength      C.uint64_t

 		CtargetType, Cparams *C.char

@@ -288,6 +284,7 @@ func dmGetNextTargetFct(task *CDmTask, next uintptr, start, length *uint64,

 		*target = C.GoString(CtargetType)

 		*params = C.GoString(Cparams)

 	}()

+

 	nextp := C.dm_get_next_target((*C.struct_dm_task)(task),

 		unsafe.Pointer(next), &Cstart, &Clength, &CtargetType, &Cparams)

 	return uintptr(nextp)

@@ -307,10 +304,9 @@ func dmAttachLoopDeviceFct(filename string, fd *int) string {

 	return C.GoString(ret)

 }

-func getBlockSizeFct(fd uintptr, size *uint64) syscall.Errno {

-	_, _, err := SyscallSyscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64,

-		uintptr(unsafe.Pointer(&size)))

-	return err

+func getBlockSizeFct(fd uintptr, size *uint64) sysErrno {

+	_, _, err := sysSyscall(sysSysIoctl, fd, C.BLKGETSIZE64, uintptr(unsafe.Pointer(&size)))

+	return sysErrno(err)

 }

 func dmUdevWaitFct(cookie uint) int {

@@ -3,7 +3,6 @@ package devmapper

 import (

 	"os"

 	"path/filepath"

-	"syscall"

 )

 // FIXME: this is copy-pasted from the aufs driver.

@@ -21,7 +20,7 @@ func Mounted(mountpoint string) (bool, error) {

 	if err != nil {

 		return false, err

 	}

-	mntpointSt := mntpoint.Sys().(*syscall.Stat_t)

-	parentSt := parent.Sys().(*syscall.Stat_t)

+	mntpointSt := toSysStatT(mntpoint.Sys())

+	parentSt := toSysStatT(parent.Sys())

 	return mntpointSt.Dev != parentSt.Dev, nil

 }

@@ -1,15 +1,31 @@

 package devmapper

-

 import (

+	"os"

 	"syscall"

 )

+type (

+	sysStatT syscall.Stat_t

+	sysErrno syscall.Errno

+)

 var (

-	SyscallMount		= syscall.Mount

-	SyscallUnmount		= syscall.Unmount

-	SyscallCloseOnExec	= syscall.CloseOnExec

-	SyscallSyscall		= syscall.Syscall

-	OSOpenFile		= os.OpenFile

+	// functions

+	sysMount       = syscall.Mount

+	sysUnmount     = syscall.Unmount

+	sysCloseOnExec = syscall.CloseOnExec

+	sysSyscall     = syscall.Syscall

+	osOpenFile     = os.OpenFile

 )

+

+const (

+	sysMsMgcVal = syscall.MS_MGC_VAL

+	sysMsRdOnly = syscall.MS_RDONLY

+	sysEInval   = syscall.EINVAL

+	sysSysIoctl = syscall.SYS_IOCTL

+)

+

+func toSysStatT(i interface{}) *sysStatT {

+	return (*sysStatT)(i.(*syscall.Stat_t))

+}