More dm unit tests

devmapper/devmapper.go

@@ -44,11 +44,11 @@ var (
 	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")
+	ErrTaskSetRo            = errors.New("dm_task_set_ro failed")
 	ErrTaskAddTarget        = errors.New("dm_task_add_target failed")
 	ErrTaskSetSector        = errors.New("dm_task_set_sector failed")
-	ErrGetInfo              = errors.New("dm_task_get_info failed")
+	ErrTaskGetInfo          = errors.New("dm_task_get_info failed")
-	ErrGetDriverVersion     = errors.New("dm_task_get_driver_version failed")
+	ErrTaskGetDriverVersion = errors.New("dm_task_get_driver_version failed")
 	ErrTaskSetCookie        = errors.New("dm_task_set_cookie failed")
 	ErrNilCookie            = errors.New("cookie ptr can't be nil")
 	ErrAttachLoopbackDevice = errors.New("loopback mounting failed")
@@ -58,6 +58,7 @@ var (
 	ErrGetLibraryVersion    = errors.New("dm_get_library_version failed")
 	ErrCreateRemoveTask     = errors.New("Can't create task of type DeviceRemove")
 	ErrRunRemoveDevice      = errors.New("running removeDevice failed")
+	ErrInvalidAddNode       = errors.New("Invalide AddNoce type")
 )
 
 type (
@@ -136,6 +137,9 @@ func (t *Task) SetCookie(cookie *uint, flags uint16) error {
 }
 
 func (t *Task) SetAddNode(addNode AddNodeType) error {
+	if addNode != AddNodeOnResume && addNode != AddNodeOnCreate {
+		return ErrInvalidAddNode
+	}
 	if res := DmTaskSetAddNode(t.unmanaged, addNode); res != 1 {
 		return ErrTaskSetAddNode
 	}
@@ -144,7 +148,7 @@ func (t *Task) SetAddNode(addNode AddNodeType) error {
 
 func (t *Task) SetRo() error {
 	if res := DmTaskSetRo(t.unmanaged); res != 1 {
-		return ErrTaskSetRO
+		return ErrTaskSetRo
 	}
 	return nil
 }
@@ -157,18 +161,10 @@ func (t *Task) AddTarget(start, size uint64, ttype, params string) error {
 	return nil
 }
 
-func (t *Task) GetDriverVersion() (string, error) {
-	var version string
-	if res := DmTaskGetDriverVersion(t.unmanaged, &version); res != 1 {
-		return "", ErrGetDriverVersion
-	}
-	return version, nil
-}
-
 func (t *Task) GetInfo() (*Info, error) {
 	info := &Info{}
 	if res := DmTaskGetInfo(t.unmanaged, info); res != 1 {
-		return nil, ErrGetInfo
+		return nil, ErrTaskGetInfo
 	}
 	return info, nil
 }
@@ -190,24 +186,6 @@ func AttachLoopDevice(filename string) (*os.File, error) {
 	return os.NewFile(uintptr(fd), res), nil
 }
 
-func getBlockSize(fd uintptr) int {
-	var size uint64
-
-	if err := SysGetBlockSize(fd, &size); err != 0 {
-		utils.Debugf("Error ioctl (getBlockSize: %s)", err)
-		return -1
-	}
-	return int(size)
-}
-
-func GetBlockDeviceSize(file *os.File) (uint64, error) {
-	size := DmGetBlockSize(file.Fd())
-	if size == -1 {
-		return 0, ErrGetBlockSize
-	}
-	return uint64(size), nil
-}
-
 func UdevWait(cookie uint) error {
 	if res := DmUdevWait(cookie); res != 1 {
 		utils.Debugf("Failed to wait on udev cookie %d", cookie)
@@ -259,6 +237,14 @@ func RemoveDevice(name string) error {
 	return nil
 }
 
+func GetBlockDeviceSize(file *os.File) (uint64, error) {
+	size, errno := DmGetBlockSize(file.Fd())
+	if size == -1 || errno != 0 {
+		return 0, ErrGetBlockSize
+	}
+	return uint64(size), nil
+}
+
 // This is the programmatic example of "dmsetup create"
 func createPool(poolName string, dataFile *os.File, metadataFile *os.File) error {
 	task, err := createTask(DeviceCreate, poolName)
@@ -282,7 +268,7 @@ func createPool(poolName string, dataFile *os.File, metadataFile *os.File) error
 	}
 
 	if err := task.Run(); err != nil {
-		return fmt.Errorf("Error running DeviceCreate")
+		return fmt.Errorf("Error running DeviceCreate (createPool)")
 	}
 
 	UdevWait(cookie)
@@ -462,7 +448,7 @@ func activateDevice(poolName string, name string, deviceId int, size uint64) err
 	}
 
 	if err := task.Run(); err != nil {
-		return fmt.Errorf("Error running DeviceCreate")
+		return fmt.Errorf("Error running DeviceCreate (activateDevice)")
 	}
 
 	UdevWait(cookie)
@@ -506,7 +492,7 @@ func (devices *DeviceSet) createSnapDevice(poolName string, deviceId int, baseNa
 		if doSuspend {
 			resumeDevice(baseName)
 		}
-		return fmt.Errorf("Error running DeviceCreate")
+		return fmt.Errorf("Error running DeviceCreate (createSnapDevice)")
 	}
 
 	if doSuspend {

devmapper/devmapper_test.go

@@ -36,11 +36,11 @@ func TestTaskRun(t *testing.T) {
 
 	task = taskCreate(t, DeviceInfo)
 	// Perform the RUN
-	if err := task.Run(); err == nil {
+	if err := task.Run(); err != ErrTaskRun {
 		t.Fatalf("An error should have occured while running task.")
 	}
 	// Make sure GetInfo also fails
-	if _, err := task.GetInfo(); err == nil {
+	if _, err := task.GetInfo(); err != ErrTaskGetInfo {
 		t.Fatalf("GetInfo should fail if task.Run() failed.")
 	}
 }
@@ -56,6 +56,7 @@ func TestTaskSetName(t *testing.T) {
 	// Test failure
 	DmTaskSetName = dmTaskSetNameFail
 	defer func() { DmTaskSetName = dmTaskSetNameFct }()
+
 	if err := task.SetName("test"); err != ErrTaskSetName {
 		t.Fatalf("An error should have occured while runnign SetName.")
 	}
@@ -72,6 +73,7 @@ func TestTaskSetMessage(t *testing.T) {
 	// Test failure
 	DmTaskSetMessage = dmTaskSetMessageFail
 	defer func() { DmTaskSetMessage = dmTaskSetMessageFct }()
+
 	if err := task.SetMessage("test"); err != ErrTaskSetMessage {
 		t.Fatalf("An error should have occured while runnign SetMessage.")
 	}
@@ -120,22 +122,84 @@ func TestTaskSetCookie(t *testing.T) {
 
 func TestTaskSetAddNode(t *testing.T) {
 	task := taskCreate(t, DeviceInfo)
+
+	// Test success
 	if err := task.SetAddNode(0); err != nil {
 		t.Fatal(err)
 	}
+
+	// Test failure
+	if err := task.SetAddNode(-1); err != ErrInvalidAddNode {
+		t.Fatalf("An error should have occured running SetAddNode with wrong node.")
+	}
+
+	DmTaskSetAddNode = dmTaskSetAddNodeFail
+	defer func() { DmTaskSetAddNode = dmTaskSetAddNodeFct }()
+
+	if err := task.SetAddNode(0); err != ErrTaskSetAddNode {
+		t.Fatalf("An error should have occured running SetAddNode.")
+	}
 }
 
 func TestTaskSetRo(t *testing.T) {
 	task := taskCreate(t, DeviceInfo)
+
+	// Test success
 	if err := task.SetRo(); err != nil {
 		t.Fatal(err)
 	}
+
+	// Test failure
+	DmTaskSetRo = dmTaskSetRoFail
+	defer func() { DmTaskSetRo = dmTaskSetRoFct }()
+
+	if err := task.SetRo(); err != ErrTaskSetRo {
+		t.Fatalf("An error should have occured running SetRo.")
+	}
 }
 
 func TestTaskAddTarget(t *testing.T) {
-	//	task := taskCreate(t, DeviceInfo)
+	task := taskCreate(t, DeviceInfo)
+
+	// Test success
+	if err := task.AddTarget(0, 128, "thinp", ""); err != nil {
+		t.Fatal(err)
+	}
+
+	// Test failure
+	DmTaskAddTarget = dmTaskAddTargetFail
+	defer func() { DmTaskAddTarget = dmTaskAddTargetFct }()
+
+	if err := task.AddTarget(0, 128, "thinp", ""); err != ErrTaskAddTarget {
+		t.Fatalf("An error should have occured running AddTarget.")
+	}
 }
 
+// func TestTaskGetInfo(t *testing.T) {
+// 	task := taskCreate(t, DeviceInfo)
+
+// 	// Test success
+// 	if _, err := task.GetInfo(); err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	// Test failure
+// 	DmTaskGetInfo = dmTaskGetInfoFail
+// 	defer func() { DmTaskGetInfo = dmTaskGetInfoFct }()
+
+// 	if _, err := task.GetInfo(); err != ErrTaskGetInfo {
+// 		t.Fatalf("An error should have occured running GetInfo.")
+// 	}
+// }
+
+// func TestTaskGetNextTarget(t *testing.T) {
+// 	task := taskCreate(t, DeviceInfo)
+
+// 	if next, _, _, _, _ := task.GetNextTarget(0); next == 0 {
+// 		t.Fatalf("The next target should not be 0.")
+// 	}
+// }
+
 /// Utils
 func taskCreate(t *testing.T, taskType TaskType) *Task {
 	task := TaskCreate(taskType)

devmapper/devmapper_wrapper.go

@@ -116,15 +116,6 @@ char*			attach_loop_device(const char *filename, int *loop_fd_out)
   return (NULL);
 }
 
-static int64_t	get_block_size(int fd)
-{
-  uint64_t	size;
-
-  if (ioctl(fd, BLKGETSIZE64, &size) == -1)
-    return -1;
-  return ((int64_t)size);
-}
-
 extern void DevmapperLogCallback(int level, char *file, int line, int dm_errno_or_class, char *str);
 
 static void	log_cb(int level, const char *file, int line,
@@ -158,27 +149,26 @@ type (
 )
 
 var (
-	DmTaskDestory          = dmTaskDestroyFct
+	DmTaskDestory       = dmTaskDestroyFct
-	DmTaskCreate           = dmTaskCreateFct
+	DmTaskCreate        = dmTaskCreateFct
-	DmTaskRun              = dmTaskRunFct
+	DmTaskRun           = dmTaskRunFct
-	DmTaskSetName          = dmTaskSetNameFct
+	DmTaskSetName       = dmTaskSetNameFct
-	DmTaskSetMessage       = dmTaskSetMessageFct
+	DmTaskSetMessage    = dmTaskSetMessageFct
-	DmTaskSetSector        = dmTaskSetSectorFct
+	DmTaskSetSector     = dmTaskSetSectorFct
-	DmTaskSetCookie        = dmTaskSetCookieFct
+	DmTaskSetCookie     = dmTaskSetCookieFct
-	DmTaskSetAddNode       = dmTaskSetAddNodeFct
+	DmTaskSetAddNode    = dmTaskSetAddNodeFct
-	DmTaskSetRo            = dmTaskSetRoFct
+	DmTaskSetRo         = dmTaskSetRoFct
-	DmTaskAddTarget        = dmTaskAddTargetFct
+	DmTaskAddTarget     = dmTaskAddTargetFct
-	DmTaskGetDriverVersion = dmTaskGetDriverVersionFct
+	DmTaskGetInfo       = dmTaskGetInfoFct
-	DmTaskGetInfo          = dmTaskGetInfoFct
+	DmGetNextTarget     = dmGetNextTargetFct
-	DmGetNextTarget        = dmGetNextTargetFct
+	DmGetBlockSize      = dmGetBlockSizeFct
-	DmAttachLoopDevice     = dmAttachLoopDeviceFct
+	DmAttachLoopDevice  = dmAttachLoopDeviceFct
-	SysGetBlockSize        = sysGetBlockSizeFct
+	DmUdevWait          = dmUdevWaitFct
-	DmGetBlockSize         = dmGetBlockSizeFct
+	DmLogInitVerbose    = dmLogInitVerboseFct
-	DmUdevWait             = dmUdevWaitFct
+	DmSetDevDir         = dmSetDevDirFct
-	DmLogInitVerbose       = dmLogInitVerboseFct
+	DmGetLibraryVersion = dmGetLibraryVersionFct
-	LogWithErrnoInit       = logWithErrnoInitFct
+	LogWithErrnoInit    = logWithErrnoInitFct
-	DmSetDevDir            = dmSetDevDirFct
+	GetBlockSize        = getBlockSizeFct
-	DmGetLibraryVersion    = dmGetLibraryVersionFct
 )
 
 func free(p *C.char) {
@@ -249,14 +239,11 @@ func dmTaskAddTargetFct(task *CDmTask,
 		C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))
 }
 
-func dmTaskGetDriverVersionFct(task *CDmTask, version *string) int {
+func dmGetBlockSizeFct(fd uintptr) (int64, syscall.Errno) {
-	buffer := C.CString(string(make([]byte, 128)))
+	var size int64
-	defer free(buffer)
+	_, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64,
-	defer func() {
+		uintptr(unsafe.Pointer(&size)))
-		*version = C.GoString(buffer)
+	return size, err
-	}()
-	return int(C.dm_task_get_driver_version((*C.struct_dm_task)(task),
-		buffer, 128))
 }
 
 func dmTaskGetInfoFct(task *CDmTask, info *Info) int {
@@ -308,18 +295,12 @@ func dmAttachLoopDeviceFct(filename string, fd *int) string {
 	return C.GoString(ret)
 }
 
-// sysGetBlockSizeFct retrieves the block size from IOCTL
+func getBlockSizeFct(fd uintptr, size *uint64) syscall.Errno {
-func sysGetBlockSizeFct(fd uintptr, size *uint64) syscall.Errno {
 	_, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64,
 		uintptr(unsafe.Pointer(&size)))
 	return err
 }
 
-// dmGetBlockSizeFct retrieves the block size from library call
-func dmGetBlockSizeFct(fd uintptr) int64 {
-	return int64(C.get_block_size(C.int(fd)))
-}
-
 func dmUdevWaitFct(cookie uint) int {
 	return int(C.dm_udev_wait(C.uint32_t(cookie)))
 }