From 05d70cbcf4ebf30b11d54a177e47649e4e229403 Mon Sep 17 00:00:00 2001 From: "Guillaume J. Charmes" Date: Wed, 13 Nov 2013 16:46:10 -0800 Subject: [PATCH] More dm unit tests --- devmapper/devmapper.go | 54 ++++++++++---------------- devmapper/devmapper_test.go | 70 +++++++++++++++++++++++++++++++-- devmapper/devmapper_wrapper.go | 71 +++++++++++++--------------------- 3 files changed, 113 insertions(+), 82 deletions(-) diff --git a/devmapper/devmapper.go b/devmapper/devmapper.go index d6e3720129..54e21adddb 100644 --- a/devmapper/devmapper.go +++ b/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") - 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 { diff --git a/devmapper/devmapper_test.go b/devmapper/devmapper_test.go index 81a793c48c..8d93ab30b1 100644 --- a/devmapper/devmapper_test.go +++ b/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) diff --git a/devmapper/devmapper_wrapper.go b/devmapper/devmapper_wrapper.go index a52d2992b4..fcd125e6c5 100644 --- a/devmapper/devmapper_wrapper.go +++ b/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 - 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))) }