@@ -12,62 +12,3 @@ type DeviceSet interface {

 	HasActivatedDevice(hash string) bool

 	Shutdown() error

 }

-

-type DeviceSetWrapper struct {

-	wrapped DeviceSet

-	prefix  string

-}

-

-func (wrapper *DeviceSetWrapper) wrap(hash string) string {

-	if hash != "" {

-		hash = wrapper.prefix + "-" + hash

-	}

-	return hash

-}

-

-func (wrapper *DeviceSetWrapper) AddDevice(hash, baseHash string) error {

-	return wrapper.wrapped.AddDevice(wrapper.wrap(hash), wrapper.wrap(baseHash))

-}

-

-func (wrapper *DeviceSetWrapper) SetInitialized(hash string) error {

-	return wrapper.wrapped.SetInitialized(wrapper.wrap(hash))

-}

-

-func (wrapper *DeviceSetWrapper) DeactivateDevice(hash string) error {

-	return wrapper.wrapped.DeactivateDevice(wrapper.wrap(hash))

-}

-

-func (wrapper *DeviceSetWrapper) Shutdown() error {

-	return nil

-}

-

-func (wrapper *DeviceSetWrapper) RemoveDevice(hash string) error {

-	return wrapper.wrapped.RemoveDevice(wrapper.wrap(hash))

-}

-

-func (wrapper *DeviceSetWrapper) MountDevice(hash, path string) error {

-	return wrapper.wrapped.MountDevice(wrapper.wrap(hash), path)

-}

-

-func (wrapper *DeviceSetWrapper) UnmountDevice(hash, path string) error {

-	return wrapper.wrapped.UnmountDevice(wrapper.wrap(hash), path)

-}

-

-func (wrapper *DeviceSetWrapper) HasDevice(hash string) bool {

-	return wrapper.wrapped.HasDevice(wrapper.wrap(hash))

-}

-

-func (wrapper *DeviceSetWrapper) HasInitializedDevice(hash string) bool {

-	return wrapper.wrapped.HasInitializedDevice(wrapper.wrap(hash))

-}

-

-func (wrapper *DeviceSetWrapper) HasActivatedDevice(hash string) bool {

-	return wrapper.wrapped.HasActivatedDevice(wrapper.wrap(hash))

-}

-

-func NewDeviceSetWrapper(wrapped DeviceSet, prefix string) DeviceSet {

-	return &DeviceSetWrapper{

-		wrapped: wrapped,

-		prefix:  prefix,

-	}

-}

@@ -442,6 +442,7 @@ func (devices *DeviceSetDM) registerDevice(id int, hash string, size uint64) (*D

 }

 func (devices *DeviceSetDM) activateDeviceIfNeeded(hash string) error {

+	utils.Debugf("activateDeviceIfNeeded()")

 	info := devices.Devices[hash]

 	if info == nil {

 		return fmt.Errorf("Unknown device %s", hash)

@@ -14,14 +14,13 @@ package devmapper

 #include <linux/fs.h>

 #include <errno.h>

-static char *

-attach_loop_device(const char *filename, int *loop_fd_out)

+char*			attach_loop_device(const char *filename, int *loop_fd_out)

 {

-  struct loop_info64 loopinfo = { 0 };

-  struct stat st;

-  char buf[64];

-  int i, loop_fd, fd, start_index;

-  char *loopname;

+  struct loop_info64	loopinfo = {0};

+  struct stat		st;

+  char			buf[64];

+  int			i, loop_fd, fd, start_index;

+  char*			loopname;

   *loop_fd_out = -1;

@@ -37,6 +36,7 @@ attach_loop_device(const char *filename, int *loop_fd_out)

   fd = open(filename, O_RDWR);

   if (fd < 0) {

+    perror("open");

     return NULL;

   }

@@ -44,6 +44,7 @@ attach_loop_device(const char *filename, int *loop_fd_out)

   for (i = start_index ; loop_fd < 0 ; i++ ) {

     if (sprintf(buf, "/dev/loop%d", i) < 0) {

       close(fd);

+	perror("sprintf");

       return NULL;

     }

@@ -55,12 +56,14 @@ attach_loop_device(const char *filename, int *loop_fd_out)

     loop_fd = open(buf, O_RDWR);

     if (loop_fd < 0 && errno == ENOENT) {

       close(fd);

+      perror("open");

       fprintf (stderr, "no available loopback device!");

       return NULL;

     } else if (loop_fd < 0)

       continue;

     if (ioctl (loop_fd, LOOP_SET_FD, (void *)(size_t)fd) < 0) {

+      perror("ioctl");

       close(loop_fd);

       loop_fd = -1;

       if (errno != EBUSY) {

@@ -78,7 +81,10 @@ attach_loop_device(const char *filename, int *loop_fd_out)

     loopinfo.lo_flags = LO_FLAGS_AUTOCLEAR;

     if (ioctl(loop_fd, LOOP_SET_STATUS64, &loopinfo) < 0) {

-      ioctl(loop_fd, LOOP_CLR_FD, 0);

+      perror("ioctl1");

+      if (ioctl(loop_fd, LOOP_CLR_FD, 0) < 0) {

+        perror("ioctl2");

+      }

       close(loop_fd);

       fprintf (stderr, "cannot set up loopback device info");

       return NULL;

@@ -105,39 +111,19 @@ get_block_size(int fd)

   return (int64_t)size;

 }

-

 */

 import "C"

 import (

+	"errors"

 	"fmt"

 	"github.com/dotcloud/docker/utils"

 	"os"

 	"runtime"

+	"syscall"

 	"unsafe"

 )

-func SetDevDir(dir string) error {

-	c_dir := C.CString(dir)

-	defer C.free(unsafe.Pointer(c_dir))

-

-	if res := C.dm_set_dev_dir(c_dir); res != 1 {

-		utils.Debugf("Error dm_set_dev_dir")

-		return fmt.Errorf("dm_set_dev_dir failed")

-	}

-	return nil

-}

-

-func GetLibraryVersion() (string, error) {

-	buffer := make([]byte, 128)

-	if res := C.dm_get_library_version((*C.char)(unsafe.Pointer(&buffer)), 128); res != 1 {

-		return "", fmt.Errorf("dm_get_library_version failed")

-	}

-	return string(buffer), nil

-}

-

-type TaskType int

-

 const (

 	DeviceCreate TaskType = iota

 	DeviceReload

@@ -160,22 +146,41 @@ const (

 	DeviceSetGeometry

 )

-type Task struct {

-	unmanaged *C.struct_dm_task

-}

+var (

+	ErrTaskRun              = errors.New("dm_task_run failed")

+	ErrTaskSetName          = errors.New("dm_task_set_name failed")

+	ErrTaskSetMessage       = errors.New("dm_task_set_message failed")

+	ErrTaskSetAddNode       = errors.New("dm_task_set_add_node failed")

+	ErrTaskSetRO            = errors.New("dm_task_set_ro failed")

+	ErrTaskAddTarget        = errors.New("dm_task_add_target failed")

+	ErrGetDriverVersion     = errors.New("dm_task_get_driver_version failed")

+	ErrAttachLoopbackDevice = errors.New("loopback mounting failed")

+	ErrGetBlockSize         = errors.New("Can't get block size")

+	ErrUdevWait             = errors.New("wait on udev cookie failed")

+	ErrSetDevDir            = errors.New("dm_set_dev_dir failed")

+	ErrGetLibraryVersion    = errors.New("dm_get_library_version failed")

+	ErrCreateRemoveTask     = errors.New("Can't create task of type DeviceRemove")

+	ErrRunRemoveDevice      = errors.New("running removeDevice failed")

+)

-type Info struct {

-	Exists        int

-	Suspended     int

-	LiveTable     int

-	InactiveTable int

-	OpenCount     int32

-	EventNr       uint32

-	Major         uint32

-	Minor         uint32

-	ReadOnly      int

-	TargetCount   int32

-}

+type (

+	Task struct {

+		unmanaged *C.struct_dm_task

+	}

+	Info struct {

+		Exists        int

+		Suspended     int

+		LiveTable     int

+		InactiveTable int

+		OpenCount     int32

+		EventNr       uint32

+		Major         uint32

+		Minor         uint32

+		ReadOnly      int

+		TargetCount   int32

+	}

+	TaskType int

+)

 func (t *Task) destroy() {

 	if t != nil {

@@ -196,37 +201,37 @@ func TaskCreate(tasktype TaskType) *Task {

 func (t *Task) Run() error {

 	if res := C.dm_task_run(t.unmanaged); res != 1 {

-		return fmt.Errorf("dm_task_run failed")

+		return ErrTaskRun

 	}

 	return nil

 }

 func (t *Task) SetName(name string) error {

 	c_name := C.CString(name)

-	defer C.free(unsafe.Pointer(c_name))

+	defer free(c_name)

 	if res := C.dm_task_set_name(t.unmanaged, c_name); res != 1 {

 		if os.Getenv("DEBUG") != "" {

 			C.perror(C.CString(fmt.Sprintf("[debug] Error dm_task_set_name(%s, %#v)", name, t.unmanaged)))

 		}

-		return fmt.Errorf("dm_task_set_name failed")

+		return ErrTaskSetName

 	}

 	return nil

 }

 func (t *Task) SetMessage(message string) error {

 	c_message := C.CString(message)

-	defer C.free(unsafe.Pointer(c_message))

+	defer free(c_message)

 	if res := C.dm_task_set_message(t.unmanaged, c_message); res != 1 {

-		return fmt.Errorf("dm_task_set_message failed")

+		return ErrTaskSetMessage

 	}

 	return nil

 }

 func (t *Task) SetSector(sector uint64) error {

 	if res := C.dm_task_set_sector(t.unmanaged, C.uint64_t(sector)); res != 1 {

-		return fmt.Errorf("dm_task_set_add_node failed")

+		return ErrTaskSetAddNode

 	}

 	return nil

 }

@@ -234,7 +239,7 @@ func (t *Task) SetSector(sector uint64) error {

 func (t *Task) SetCookie(cookie *uint32, flags uint16) error {

 	c_cookie := C.uint32_t(*cookie)

 	if res := C.dm_task_set_cookie(t.unmanaged, &c_cookie, C.uint16_t(flags)); res != 1 {

-		return fmt.Errorf("dm_task_set_add_node failed")

+		return ErrTaskSetAddNode

 	}

 	*cookie = uint32(c_cookie)

 	return nil

@@ -242,30 +247,30 @@ func (t *Task) SetCookie(cookie *uint32, flags uint16) error {

 func (t *Task) SetRo() error {

 	if res := C.dm_task_set_ro(t.unmanaged); res != 1 {

-		return fmt.Errorf("dm_task_set_ro failed")

+		return ErrTaskSetRO

 	}

 	return nil

 }

 func (t *Task) AddTarget(start uint64, size uint64, ttype string, params string) error {

 	c_ttype := C.CString(ttype)

-	defer C.free(unsafe.Pointer(c_ttype))

+	defer free(c_ttype)

 	c_params := C.CString(params)

-	defer C.free(unsafe.Pointer(c_params))

+	defer free(c_params)

 	if res := C.dm_task_add_target(t.unmanaged, C.uint64_t(start), C.uint64_t(size), c_ttype, c_params); res != 1 {

-		return fmt.Errorf("dm_task_add_target failed")

+		return ErrTaskAddTarget

 	}

 	return nil

 }

 func (t *Task) GetDriverVersion() (string, error) {

-	buffer := (*C.char)(C.malloc(128))

-	defer C.free(unsafe.Pointer(buffer))

+	buffer := C.CString(string(make([]byte, 128)))

+	defer free(buffer)

 	if res := C.dm_task_get_driver_version(t.unmanaged, buffer, 128); res != 1 {

-		return "", fmt.Errorf("dm_task_get_driver_version")

+		return "", ErrGetDriverVersion

 	}

 	return C.GoString(buffer), nil

 }

@@ -273,7 +278,7 @@ func (t *Task) GetDriverVersion() (string, error) {

 func (t *Task) GetInfo() (*Info, error) {

 	c_info := C.struct_dm_info{}

 	if res := C.dm_task_get_info(t.unmanaged, &c_info); res != 1 {

-		return nil, fmt.Errorf("dm_task_get_driver_version")

+		return nil, ErrGetDriverVersion

 	}

 	return &Info{

 		Exists:        int(c_info.exists),

@@ -301,29 +306,40 @@ func (t *Task) GetNextTarget(next uintptr) (uintptr, uint64, uint64, string, str

 func AttachLoopDevice(filename string) (*os.File, error) {

 	c_filename := C.CString(filename)

-	defer C.free(unsafe.Pointer(c_filename))

+	defer free(c_filename)

 	var fd C.int

 	res := C.attach_loop_device(c_filename, &fd)

 	if res == nil {

-		return nil, fmt.Errorf("error loopback mounting")

+		return nil, ErrAttachLoopbackDevice

 	}

-	defer C.free(unsafe.Pointer(res))

+	defer free(res)

+

 	return os.NewFile(uintptr(fd), C.GoString(res)), nil

 }

+func getBlockSize(fd uintptr) int {

+	var size uint64

+

+	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64, uintptr(unsafe.Pointer(&size))); err != 0 {

+		utils.Debugf("Error ioctl: %s", err)

+		return -1

+	}

+	return int(size)

+}

+

 func GetBlockDeviceSize(file *os.File) (uint64, error) {

 	if size := C.get_block_size(C.int(file.Fd())); size == -1 {

-		return 0, fmt.Errorf("Can't get block size")

+		return 0, ErrGetBlockSize

 	} else {

 		return uint64(size), nil

 	}

 }

 func UdevWait(cookie uint32) error {

-	res := C.dm_udev_wait(C.uint32_t(cookie))

-	if res != 1 {

-		return fmt.Errorf("Failed to wait on udev cookie %d", cookie)

+	if res := C.dm_udev_wait(C.uint32_t(cookie)); res != 1 {

+		utils.Debugf("Failed to wait on udev cookie %d", cookie)

+		return ErrUdevWait

 	}

 	return nil

 }

@@ -332,17 +348,43 @@ func LogInitVerbose(level int) {

 	C.dm_log_init_verbose(C.int(level))

 }

+func SetDevDir(dir string) error {

+	c_dir := C.CString(dir)

+	defer free(c_dir)

+

+	if res := C.dm_set_dev_dir(c_dir); res != 1 {

+		utils.Debugf("Error dm_set_dev_dir")

+		return ErrSetDevDir

+	}

+	return nil

+}

+

+func GetLibraryVersion() (string, error) {

+	buffer := C.CString(string(make([]byte, 128)))

+	defer free(buffer)

+

+	if res := C.dm_get_library_version(buffer, 128); res != 1 {

+		return "", ErrGetLibraryVersion

+	}

+	return C.GoString(buffer), nil

+}

+

 // Useful helper for cleanup

 func RemoveDevice(name string) error {

 	task := TaskCreate(DeviceRemove)

 	if task == nil {

-		return fmt.Errorf("Can't create task of type DeviceRemove")

+		return ErrCreateRemoveTask

 	}

 	if err := task.SetName(name); err != nil {

-		return fmt.Errorf("Can't set task name %s", name)

+		utils.Debugf("Can't set task name %s", name)

+		return err

 	}

 	if err := task.Run(); err != nil {

-		return fmt.Errorf("Error running removeDevice")

+		return ErrRunRemoveDevice

 	}

 	return nil

 }

+

+func free(p *C.char) {

+	C.free(unsafe.Pointer(p))

+}

@@ -319,3 +319,62 @@ func TestParseLxcConfOpt(t *testing.T) {

 		}

 	}

 }

+

+type DeviceSetWrapper struct {

+	wrapped DeviceSet

+	prefix  string

+}

+

+func (wrapper *DeviceSetWrapper) wrap(hash string) string {

+	if hash != "" {

+		hash = wrapper.prefix + "-" + hash

+	}

+	return hash

+}

+

+func (wrapper *DeviceSetWrapper) AddDevice(hash, baseHash string) error {

+	return wrapper.wrapped.AddDevice(wrapper.wrap(hash), wrapper.wrap(baseHash))

+}

+

+func (wrapper *DeviceSetWrapper) SetInitialized(hash string) error {

+	return wrapper.wrapped.SetInitialized(wrapper.wrap(hash))

+}

+

+func (wrapper *DeviceSetWrapper) DeactivateDevice(hash string) error {

+	return wrapper.wrapped.DeactivateDevice(wrapper.wrap(hash))

+}

+

+func (wrapper *DeviceSetWrapper) Shutdown() error {

+	return nil

+}

+

+func (wrapper *DeviceSetWrapper) RemoveDevice(hash string) error {

+	return wrapper.wrapped.RemoveDevice(wrapper.wrap(hash))

+}

+

+func (wrapper *DeviceSetWrapper) MountDevice(hash, path string) error {

+	return wrapper.wrapped.MountDevice(wrapper.wrap(hash), path)

+}

+

+func (wrapper *DeviceSetWrapper) UnmountDevice(hash, path string) error {

+	return wrapper.wrapped.UnmountDevice(wrapper.wrap(hash), path)

+}

+

+func (wrapper *DeviceSetWrapper) HasDevice(hash string) bool {

+	return wrapper.wrapped.HasDevice(wrapper.wrap(hash))

+}

+

+func (wrapper *DeviceSetWrapper) HasInitializedDevice(hash string) bool {

+	return wrapper.wrapped.HasInitializedDevice(wrapper.wrap(hash))

+}

+

+func (wrapper *DeviceSetWrapper) HasActivatedDevice(hash string) bool {

+	return wrapper.wrapped.HasActivatedDevice(wrapper.wrap(hash))

+}

+

+func NewDeviceSetWrapper(wrapped DeviceSet, prefix string) DeviceSet {

+	return &DeviceSetWrapper{

+		wrapped: wrapped,

+		prefix:  prefix,

+	}

+}