2014-08-02 07:46:15 +00:00
|
|
|
// +build linux
|
2013-11-28 03:12:51 +00:00
|
|
|
|
2014-11-05 23:10:38 +00:00
|
|
|
package devicemapper
|
2013-11-13 22:36:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
#cgo LDFLAGS: -L. -ldevmapper
|
|
|
|
#include <libdevmapper.h>
|
2013-11-27 07:16:34 +00:00
|
|
|
#include <linux/fs.h> // FIXME: present only for BLKGETSIZE64, maybe we can remove it?
|
2013-11-13 22:36:31 +00:00
|
|
|
|
2013-11-27 07:16:34 +00:00
|
|
|
// FIXME: Can't we find a way to do the logging in pure Go?
|
2013-11-13 22:36:31 +00:00
|
|
|
extern void DevmapperLogCallback(int level, char *file, int line, int dm_errno_or_class, char *str);
|
|
|
|
|
2013-11-27 07:16:34 +00:00
|
|
|
static void log_cb(int level, const char *file, int line, int dm_errno_or_class, const char *f, ...)
|
2013-11-13 22:36:31 +00:00
|
|
|
{
|
|
|
|
char buffer[256];
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, f);
|
|
|
|
vsnprintf(buffer, 256, f, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
DevmapperLogCallback(level, (char *)file, line, dm_errno_or_class, buffer);
|
|
|
|
}
|
|
|
|
|
2013-11-13 23:35:52 +00:00
|
|
|
static void log_with_errno_init()
|
2013-11-13 22:36:31 +00:00
|
|
|
{
|
|
|
|
dm_log_with_errno_init(log_cb);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
import "C"
|
|
|
|
|
2015-08-07 14:18:20 +00:00
|
|
|
import (
|
|
|
|
"reflect"
|
|
|
|
"unsafe"
|
|
|
|
)
|
2013-11-13 22:36:31 +00:00
|
|
|
|
|
|
|
type (
|
2015-09-04 21:02:29 +00:00
|
|
|
cdmTask C.struct_dm_task
|
2013-11-13 22:36:31 +00:00
|
|
|
)
|
|
|
|
|
2013-11-28 19:53:09 +00:00
|
|
|
// IOCTL consts
|
2013-11-27 07:16:34 +00:00
|
|
|
const (
|
2013-11-28 19:53:09 +00:00
|
|
|
BlkGetSize64 = C.BLKGETSIZE64
|
2013-12-17 08:12:44 +00:00
|
|
|
BlkDiscard = C.BLKDISCARD
|
2013-11-27 07:16:34 +00:00
|
|
|
)
|
|
|
|
|
2015-09-30 08:35:02 +00:00
|
|
|
// Devicemapper cookie flags.
|
2014-10-31 00:26:39 +00:00
|
|
|
const (
|
|
|
|
DmUdevDisableSubsystemRulesFlag = C.DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG
|
|
|
|
DmUdevDisableDiskRulesFlag = C.DM_UDEV_DISABLE_DISK_RULES_FLAG
|
|
|
|
DmUdevDisableOtherRulesFlag = C.DM_UDEV_DISABLE_OTHER_RULES_FLAG
|
2015-01-19 20:52:39 +00:00
|
|
|
DmUdevDisableLibraryFallback = C.DM_UDEV_DISABLE_LIBRARY_FALLBACK
|
2014-10-31 00:26:39 +00:00
|
|
|
)
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
// DeviceMapper mapped functions.
|
2013-11-13 22:36:31 +00:00
|
|
|
var (
|
2015-04-21 22:14:59 +00:00
|
|
|
DmGetLibraryVersion = dmGetLibraryVersionFct
|
|
|
|
DmGetNextTarget = dmGetNextTargetFct
|
|
|
|
DmLogInitVerbose = dmLogInitVerboseFct
|
|
|
|
DmSetDevDir = dmSetDevDirFct
|
|
|
|
DmTaskAddTarget = dmTaskAddTargetFct
|
|
|
|
DmTaskCreate = dmTaskCreateFct
|
|
|
|
DmTaskDestroy = dmTaskDestroyFct
|
|
|
|
DmTaskGetDeps = dmTaskGetDepsFct
|
|
|
|
DmTaskGetInfo = dmTaskGetInfoFct
|
|
|
|
DmTaskGetDriverVersion = dmTaskGetDriverVersionFct
|
|
|
|
DmTaskRun = dmTaskRunFct
|
|
|
|
DmTaskSetAddNode = dmTaskSetAddNodeFct
|
|
|
|
DmTaskSetCookie = dmTaskSetCookieFct
|
|
|
|
DmTaskSetMessage = dmTaskSetMessageFct
|
|
|
|
DmTaskSetName = dmTaskSetNameFct
|
|
|
|
DmTaskSetRo = dmTaskSetRoFct
|
|
|
|
DmTaskSetSector = dmTaskSetSectorFct
|
|
|
|
DmUdevWait = dmUdevWaitFct
|
|
|
|
DmUdevSetSyncSupport = dmUdevSetSyncSupportFct
|
|
|
|
DmUdevGetSyncSupport = dmUdevGetSyncSupportFct
|
|
|
|
DmCookieSupported = dmCookieSupportedFct
|
|
|
|
LogWithErrnoInit = logWithErrnoInitFct
|
|
|
|
DmTaskDeferredRemove = dmTaskDeferredRemoveFct
|
|
|
|
DmTaskGetInfoWithDeferred = dmTaskGetInfoWithDeferredFct
|
2013-11-13 22:36:31 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
func free(p *C.char) {
|
|
|
|
C.free(unsafe.Pointer(p))
|
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskDestroyFct(task *cdmTask) {
|
2013-11-13 22:36:31 +00:00
|
|
|
C.dm_task_destroy((*C.struct_dm_task)(task))
|
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskCreateFct(taskType int) *cdmTask {
|
|
|
|
return (*cdmTask)(C.dm_task_create(C.int(taskType)))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskRunFct(task *cdmTask) int {
|
2013-11-27 07:16:34 +00:00
|
|
|
ret, _ := C.dm_task_run((*C.struct_dm_task)(task))
|
|
|
|
return int(ret)
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskSetNameFct(task *cdmTask, name string) int {
|
2013-11-13 22:36:31 +00:00
|
|
|
Cname := C.CString(name)
|
|
|
|
defer free(Cname)
|
|
|
|
|
2013-11-27 07:16:34 +00:00
|
|
|
return int(C.dm_task_set_name((*C.struct_dm_task)(task), Cname))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskSetMessageFct(task *cdmTask, message string) int {
|
2013-11-13 22:36:31 +00:00
|
|
|
Cmessage := C.CString(message)
|
|
|
|
defer free(Cmessage)
|
|
|
|
|
2013-11-27 07:16:34 +00:00
|
|
|
return int(C.dm_task_set_message((*C.struct_dm_task)(task), Cmessage))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskSetSectorFct(task *cdmTask, sector uint64) int {
|
2013-11-27 07:16:34 +00:00
|
|
|
return int(C.dm_task_set_sector((*C.struct_dm_task)(task), C.uint64_t(sector)))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskSetCookieFct(task *cdmTask, cookie *uint, flags uint16) int {
|
2013-11-13 22:36:31 +00:00
|
|
|
cCookie := C.uint32_t(*cookie)
|
|
|
|
defer func() {
|
|
|
|
*cookie = uint(cCookie)
|
|
|
|
}()
|
2013-11-27 07:16:34 +00:00
|
|
|
return int(C.dm_task_set_cookie((*C.struct_dm_task)(task), &cCookie, C.uint16_t(flags)))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskSetAddNodeFct(task *cdmTask, addNode AddNodeType) int {
|
2013-11-27 07:16:34 +00:00
|
|
|
return int(C.dm_task_set_add_node((*C.struct_dm_task)(task), C.dm_add_node_t(addNode)))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskSetRoFct(task *cdmTask) int {
|
2013-11-13 22:36:31 +00:00
|
|
|
return int(C.dm_task_set_ro((*C.struct_dm_task)(task)))
|
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskAddTargetFct(task *cdmTask,
|
2013-11-13 22:36:31 +00:00
|
|
|
start, size uint64, ttype, params string) int {
|
|
|
|
|
|
|
|
Cttype := C.CString(ttype)
|
|
|
|
defer free(Cttype)
|
|
|
|
|
|
|
|
Cparams := C.CString(params)
|
|
|
|
defer free(Cparams)
|
|
|
|
|
2013-11-27 07:16:34 +00:00
|
|
|
return int(C.dm_task_add_target((*C.struct_dm_task)(task), C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskGetDepsFct(task *cdmTask) *Deps {
|
2014-09-25 14:57:37 +00:00
|
|
|
Cdeps := C.dm_task_get_deps((*C.struct_dm_task)(task))
|
|
|
|
if Cdeps == nil {
|
|
|
|
return nil
|
|
|
|
}
|
2015-08-07 14:18:20 +00:00
|
|
|
|
|
|
|
// golang issue: https://github.com/golang/go/issues/11925
|
|
|
|
hdr := reflect.SliceHeader{
|
|
|
|
Data: uintptr(unsafe.Pointer(uintptr(unsafe.Pointer(Cdeps)) + unsafe.Sizeof(*Cdeps))),
|
|
|
|
Len: int(Cdeps.count),
|
|
|
|
Cap: int(Cdeps.count),
|
|
|
|
}
|
|
|
|
devices := *(*[]C.uint64_t)(unsafe.Pointer(&hdr))
|
|
|
|
|
2014-09-25 14:57:37 +00:00
|
|
|
deps := &Deps{
|
|
|
|
Count: uint32(Cdeps.count),
|
|
|
|
Filler: uint32(Cdeps.filler),
|
|
|
|
}
|
2015-08-07 14:18:20 +00:00
|
|
|
for _, device := range devices {
|
|
|
|
deps.Device = append(deps.Device, uint64(device))
|
2014-09-25 14:57:37 +00:00
|
|
|
}
|
|
|
|
return deps
|
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskGetInfoFct(task *cdmTask, info *Info) int {
|
2013-11-13 22:36:31 +00:00
|
|
|
Cinfo := C.struct_dm_info{}
|
|
|
|
defer func() {
|
|
|
|
info.Exists = int(Cinfo.exists)
|
|
|
|
info.Suspended = int(Cinfo.suspended)
|
|
|
|
info.LiveTable = int(Cinfo.live_table)
|
|
|
|
info.InactiveTable = int(Cinfo.inactive_table)
|
|
|
|
info.OpenCount = int32(Cinfo.open_count)
|
|
|
|
info.EventNr = uint32(Cinfo.event_nr)
|
|
|
|
info.Major = uint32(Cinfo.major)
|
|
|
|
info.Minor = uint32(Cinfo.minor)
|
|
|
|
info.ReadOnly = int(Cinfo.read_only)
|
|
|
|
info.TargetCount = int32(Cinfo.target_count)
|
|
|
|
}()
|
|
|
|
return int(C.dm_task_get_info((*C.struct_dm_task)(task), &Cinfo))
|
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmTaskGetDriverVersionFct(task *cdmTask) string {
|
2014-03-27 16:45:02 +00:00
|
|
|
buffer := C.malloc(128)
|
|
|
|
defer C.free(buffer)
|
|
|
|
res := C.dm_task_get_driver_version((*C.struct_dm_task)(task), (*C.char)(buffer), 128)
|
|
|
|
if res == 0 {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return C.GoString((*C.char)(buffer))
|
|
|
|
}
|
|
|
|
|
2015-09-04 21:02:29 +00:00
|
|
|
func dmGetNextTargetFct(task *cdmTask, next unsafe.Pointer, start, length *uint64, target, params *string) unsafe.Pointer {
|
2013-11-13 22:36:31 +00:00
|
|
|
var (
|
|
|
|
Cstart, Clength C.uint64_t
|
|
|
|
CtargetType, Cparams *C.char
|
|
|
|
)
|
|
|
|
defer func() {
|
|
|
|
*start = uint64(Cstart)
|
|
|
|
*length = uint64(Clength)
|
|
|
|
*target = C.GoString(CtargetType)
|
|
|
|
*params = C.GoString(Cparams)
|
|
|
|
}()
|
2013-11-20 20:49:01 +00:00
|
|
|
|
2015-03-27 19:16:25 +00:00
|
|
|
nextp := C.dm_get_next_target((*C.struct_dm_task)(task), next, &Cstart, &Clength, &CtargetType, &Cparams)
|
|
|
|
return nextp
|
2013-11-13 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
2015-01-19 20:10:37 +00:00
|
|
|
func dmUdevSetSyncSupportFct(syncWithUdev int) {
|
|
|
|
(C.dm_udev_set_sync_support(C.int(syncWithUdev)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func dmUdevGetSyncSupportFct() int {
|
|
|
|
return int(C.dm_udev_get_sync_support())
|
|
|
|
}
|
|
|
|
|
2013-11-13 22:36:31 +00:00
|
|
|
func dmUdevWaitFct(cookie uint) int {
|
|
|
|
return int(C.dm_udev_wait(C.uint32_t(cookie)))
|
|
|
|
}
|
|
|
|
|
2015-01-19 20:31:54 +00:00
|
|
|
func dmCookieSupportedFct() int {
|
|
|
|
return int(C.dm_cookie_supported())
|
|
|
|
}
|
|
|
|
|
2013-11-13 22:36:31 +00:00
|
|
|
func dmLogInitVerboseFct(level int) {
|
|
|
|
C.dm_log_init_verbose(C.int(level))
|
|
|
|
}
|
|
|
|
|
|
|
|
func logWithErrnoInitFct() {
|
|
|
|
C.log_with_errno_init()
|
|
|
|
}
|
|
|
|
|
|
|
|
func dmSetDevDirFct(dir string) int {
|
|
|
|
Cdir := C.CString(dir)
|
|
|
|
defer free(Cdir)
|
|
|
|
|
|
|
|
return int(C.dm_set_dev_dir(Cdir))
|
|
|
|
}
|
|
|
|
|
|
|
|
func dmGetLibraryVersionFct(version *string) int {
|
|
|
|
buffer := C.CString(string(make([]byte, 128)))
|
|
|
|
defer free(buffer)
|
|
|
|
defer func() {
|
|
|
|
*version = C.GoString(buffer)
|
|
|
|
}()
|
|
|
|
return int(C.dm_get_library_version(buffer, 128))
|
|
|
|
}
|