devmapper_wrapper.go 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
  1. // +build linux
  2. package devicemapper
  3. /*
  4. #cgo LDFLAGS: -L. -ldevmapper
  5. #include <libdevmapper.h>
  6. #include <linux/loop.h> // FIXME: present only for defines, maybe we can remove it?
  7. #include <linux/fs.h> // FIXME: present only for BLKGETSIZE64, maybe we can remove it?
  8. #ifndef LOOP_CTL_GET_FREE
  9. #define LOOP_CTL_GET_FREE 0x4C82
  10. #endif
  11. #ifndef LO_FLAGS_PARTSCAN
  12. #define LO_FLAGS_PARTSCAN 8
  13. #endif
  14. // FIXME: Can't we find a way to do the logging in pure Go?
  15. extern void DevmapperLogCallback(int level, char *file, int line, int dm_errno_or_class, char *str);
  16. static void log_cb(int level, const char *file, int line, int dm_errno_or_class, const char *f, ...)
  17. {
  18. char buffer[256];
  19. va_list ap;
  20. va_start(ap, f);
  21. vsnprintf(buffer, 256, f, ap);
  22. va_end(ap);
  23. DevmapperLogCallback(level, (char *)file, line, dm_errno_or_class, buffer);
  24. }
  25. static void log_with_errno_init()
  26. {
  27. dm_log_with_errno_init(log_cb);
  28. }
  29. */
  30. import "C"
  31. import "unsafe"
  32. type (
  33. CDmTask C.struct_dm_task
  34. CLoopInfo64 C.struct_loop_info64
  35. LoopInfo64 struct {
  36. loDevice uint64 /* ioctl r/o */
  37. loInode uint64 /* ioctl r/o */
  38. loRdevice uint64 /* ioctl r/o */
  39. loOffset uint64
  40. loSizelimit uint64 /* bytes, 0 == max available */
  41. loNumber uint32 /* ioctl r/o */
  42. loEncrypt_type uint32
  43. loEncrypt_key_size uint32 /* ioctl w/o */
  44. loFlags uint32 /* ioctl r/o */
  45. loFileName [LoNameSize]uint8
  46. loCryptName [LoNameSize]uint8
  47. loEncryptKey [LoKeySize]uint8 /* ioctl w/o */
  48. loInit [2]uint64
  49. }
  50. )
  51. // IOCTL consts
  52. const (
  53. BlkGetSize64 = C.BLKGETSIZE64
  54. BlkDiscard = C.BLKDISCARD
  55. LoopSetFd = C.LOOP_SET_FD
  56. LoopCtlGetFree = C.LOOP_CTL_GET_FREE
  57. LoopGetStatus64 = C.LOOP_GET_STATUS64
  58. LoopSetStatus64 = C.LOOP_SET_STATUS64
  59. LoopClrFd = C.LOOP_CLR_FD
  60. LoopSetCapacity = C.LOOP_SET_CAPACITY
  61. )
  62. const (
  63. LoFlagsAutoClear = C.LO_FLAGS_AUTOCLEAR
  64. LoFlagsReadOnly = C.LO_FLAGS_READ_ONLY
  65. LoFlagsPartScan = C.LO_FLAGS_PARTSCAN
  66. LoKeySize = C.LO_KEY_SIZE
  67. LoNameSize = C.LO_NAME_SIZE
  68. )
  69. const (
  70. DmUdevDisableSubsystemRulesFlag = C.DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG
  71. DmUdevDisableDiskRulesFlag = C.DM_UDEV_DISABLE_DISK_RULES_FLAG
  72. DmUdevDisableOtherRulesFlag = C.DM_UDEV_DISABLE_OTHER_RULES_FLAG
  73. )
  74. var (
  75. DmGetLibraryVersion = dmGetLibraryVersionFct
  76. DmGetNextTarget = dmGetNextTargetFct
  77. DmLogInitVerbose = dmLogInitVerboseFct
  78. DmSetDevDir = dmSetDevDirFct
  79. DmTaskAddTarget = dmTaskAddTargetFct
  80. DmTaskCreate = dmTaskCreateFct
  81. DmTaskDestroy = dmTaskDestroyFct
  82. DmTaskGetDeps = dmTaskGetDepsFct
  83. DmTaskGetInfo = dmTaskGetInfoFct
  84. DmTaskGetDriverVersion = dmTaskGetDriverVersionFct
  85. DmTaskRun = dmTaskRunFct
  86. DmTaskSetAddNode = dmTaskSetAddNodeFct
  87. DmTaskSetCookie = dmTaskSetCookieFct
  88. DmTaskSetMessage = dmTaskSetMessageFct
  89. DmTaskSetName = dmTaskSetNameFct
  90. DmTaskSetRo = dmTaskSetRoFct
  91. DmTaskSetSector = dmTaskSetSectorFct
  92. DmUdevWait = dmUdevWaitFct
  93. DmUdevSetSyncSupport = dmUdevSetSyncSupportFct
  94. DmUdevGetSyncSupport = dmUdevGetSyncSupportFct
  95. LogWithErrnoInit = logWithErrnoInitFct
  96. )
  97. func free(p *C.char) {
  98. C.free(unsafe.Pointer(p))
  99. }
  100. func dmTaskDestroyFct(task *CDmTask) {
  101. C.dm_task_destroy((*C.struct_dm_task)(task))
  102. }
  103. func dmTaskCreateFct(taskType int) *CDmTask {
  104. return (*CDmTask)(C.dm_task_create(C.int(taskType)))
  105. }
  106. func dmTaskRunFct(task *CDmTask) int {
  107. ret, _ := C.dm_task_run((*C.struct_dm_task)(task))
  108. return int(ret)
  109. }
  110. func dmTaskSetNameFct(task *CDmTask, name string) int {
  111. Cname := C.CString(name)
  112. defer free(Cname)
  113. return int(C.dm_task_set_name((*C.struct_dm_task)(task), Cname))
  114. }
  115. func dmTaskSetMessageFct(task *CDmTask, message string) int {
  116. Cmessage := C.CString(message)
  117. defer free(Cmessage)
  118. return int(C.dm_task_set_message((*C.struct_dm_task)(task), Cmessage))
  119. }
  120. func dmTaskSetSectorFct(task *CDmTask, sector uint64) int {
  121. return int(C.dm_task_set_sector((*C.struct_dm_task)(task), C.uint64_t(sector)))
  122. }
  123. func dmTaskSetCookieFct(task *CDmTask, cookie *uint, flags uint16) int {
  124. cCookie := C.uint32_t(*cookie)
  125. defer func() {
  126. *cookie = uint(cCookie)
  127. }()
  128. return int(C.dm_task_set_cookie((*C.struct_dm_task)(task), &cCookie, C.uint16_t(flags)))
  129. }
  130. func dmTaskSetAddNodeFct(task *CDmTask, addNode AddNodeType) int {
  131. return int(C.dm_task_set_add_node((*C.struct_dm_task)(task), C.dm_add_node_t(addNode)))
  132. }
  133. func dmTaskSetRoFct(task *CDmTask) int {
  134. return int(C.dm_task_set_ro((*C.struct_dm_task)(task)))
  135. }
  136. func dmTaskAddTargetFct(task *CDmTask,
  137. start, size uint64, ttype, params string) int {
  138. Cttype := C.CString(ttype)
  139. defer free(Cttype)
  140. Cparams := C.CString(params)
  141. defer free(Cparams)
  142. return int(C.dm_task_add_target((*C.struct_dm_task)(task), C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))
  143. }
  144. func dmTaskGetDepsFct(task *CDmTask) *Deps {
  145. Cdeps := C.dm_task_get_deps((*C.struct_dm_task)(task))
  146. if Cdeps == nil {
  147. return nil
  148. }
  149. deps := &Deps{
  150. Count: uint32(Cdeps.count),
  151. Filler: uint32(Cdeps.filler),
  152. }
  153. for _, device := range Cdeps.device {
  154. deps.Device = append(deps.Device, (uint64)(device))
  155. }
  156. return deps
  157. }
  158. func dmTaskGetInfoFct(task *CDmTask, info *Info) int {
  159. Cinfo := C.struct_dm_info{}
  160. defer func() {
  161. info.Exists = int(Cinfo.exists)
  162. info.Suspended = int(Cinfo.suspended)
  163. info.LiveTable = int(Cinfo.live_table)
  164. info.InactiveTable = int(Cinfo.inactive_table)
  165. info.OpenCount = int32(Cinfo.open_count)
  166. info.EventNr = uint32(Cinfo.event_nr)
  167. info.Major = uint32(Cinfo.major)
  168. info.Minor = uint32(Cinfo.minor)
  169. info.ReadOnly = int(Cinfo.read_only)
  170. info.TargetCount = int32(Cinfo.target_count)
  171. }()
  172. return int(C.dm_task_get_info((*C.struct_dm_task)(task), &Cinfo))
  173. }
  174. func dmTaskGetDriverVersionFct(task *CDmTask) string {
  175. buffer := C.malloc(128)
  176. defer C.free(buffer)
  177. res := C.dm_task_get_driver_version((*C.struct_dm_task)(task), (*C.char)(buffer), 128)
  178. if res == 0 {
  179. return ""
  180. }
  181. return C.GoString((*C.char)(buffer))
  182. }
  183. func dmGetNextTargetFct(task *CDmTask, next uintptr, start, length *uint64, target, params *string) uintptr {
  184. var (
  185. Cstart, Clength C.uint64_t
  186. CtargetType, Cparams *C.char
  187. )
  188. defer func() {
  189. *start = uint64(Cstart)
  190. *length = uint64(Clength)
  191. *target = C.GoString(CtargetType)
  192. *params = C.GoString(Cparams)
  193. }()
  194. nextp := C.dm_get_next_target((*C.struct_dm_task)(task), unsafe.Pointer(next), &Cstart, &Clength, &CtargetType, &Cparams)
  195. return uintptr(nextp)
  196. }
  197. func dmUdevSetSyncSupportFct(syncWithUdev int) {
  198. (C.dm_udev_set_sync_support(C.int(syncWithUdev)))
  199. }
  200. func dmUdevGetSyncSupportFct() int {
  201. return int(C.dm_udev_get_sync_support())
  202. }
  203. func dmUdevWaitFct(cookie uint) int {
  204. return int(C.dm_udev_wait(C.uint32_t(cookie)))
  205. }
  206. func dmLogInitVerboseFct(level int) {
  207. C.dm_log_init_verbose(C.int(level))
  208. }
  209. func logWithErrnoInitFct() {
  210. C.log_with_errno_init()
  211. }
  212. func dmSetDevDirFct(dir string) int {
  213. Cdir := C.CString(dir)
  214. defer free(Cdir)
  215. return int(C.dm_set_dev_dir(Cdir))
  216. }
  217. func dmGetLibraryVersionFct(version *string) int {
  218. buffer := C.CString(string(make([]byte, 128)))
  219. defer free(buffer)
  220. defer func() {
  221. *version = C.GoString(buffer)
  222. }()
  223. return int(C.dm_get_library_version(buffer, 128))
  224. }