Small fixes

deviceset.go

@@ -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,
-	}
-}

devmapper/deviceset_devmapper.go

@@ -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)

devmapper/devmapper.go

@@ -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))
+}

utils_test.go

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