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

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

+	ErrTaskGetInfo          = errors.New("dm_task_get_info 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 {

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

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

-	DmTaskCreate           = dmTaskCreateFct

-	DmTaskRun              = dmTaskRunFct

-	DmTaskSetName          = dmTaskSetNameFct

-	DmTaskSetMessage       = dmTaskSetMessageFct

-	DmTaskSetSector        = dmTaskSetSectorFct

-	DmTaskSetCookie        = dmTaskSetCookieFct

-	DmTaskSetAddNode       = dmTaskSetAddNodeFct

-	DmTaskSetRo            = dmTaskSetRoFct

-	DmTaskAddTarget        = dmTaskAddTargetFct

-	DmTaskGetDriverVersion = dmTaskGetDriverVersionFct

-	DmTaskGetInfo          = dmTaskGetInfoFct

-	DmGetNextTarget        = dmGetNextTargetFct

-	DmAttachLoopDevice     = dmAttachLoopDeviceFct

-	SysGetBlockSize        = sysGetBlockSizeFct

-	DmGetBlockSize         = dmGetBlockSizeFct

-	DmUdevWait             = dmUdevWaitFct

-	DmLogInitVerbose       = dmLogInitVerboseFct

-	LogWithErrnoInit       = logWithErrnoInitFct

-	DmSetDevDir            = dmSetDevDirFct

-	DmGetLibraryVersion    = dmGetLibraryVersionFct

+	DmTaskDestory       = dmTaskDestroyFct

+	DmTaskCreate        = dmTaskCreateFct

+	DmTaskRun           = dmTaskRunFct

+	DmTaskSetName       = dmTaskSetNameFct

+	DmTaskSetMessage    = dmTaskSetMessageFct

+	DmTaskSetSector     = dmTaskSetSectorFct

+	DmTaskSetCookie     = dmTaskSetCookieFct

+	DmTaskSetAddNode    = dmTaskSetAddNodeFct

+	DmTaskSetRo         = dmTaskSetRoFct

+	DmTaskAddTarget     = dmTaskAddTargetFct

+	DmTaskGetInfo       = dmTaskGetInfoFct

+	DmGetNextTarget     = dmGetNextTargetFct

+	DmGetBlockSize      = dmGetBlockSizeFct

+	DmAttachLoopDevice  = dmAttachLoopDeviceFct

+	DmUdevWait          = dmUdevWaitFct

+	DmLogInitVerbose    = dmLogInitVerboseFct

+	DmSetDevDir         = dmSetDevDirFct

+	DmGetLibraryVersion = dmGetLibraryVersionFct

+	LogWithErrnoInit    = logWithErrnoInitFct

+	GetBlockSize        = getBlockSizeFct

 )

 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 {

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

-	defer free(buffer)

-	defer func() {

-		*version = C.GoString(buffer)

-	}()

-	return int(C.dm_task_get_driver_version((*C.struct_dm_task)(task),

-		buffer, 128))

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

+	var size int64

+	_, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, C.BLKGETSIZE64,

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

+	return size, err

 }

 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 sysGetBlockSizeFct(fd uintptr, size *uint64) syscall.Errno {

+func getBlockSizeFct(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)))

 }