devmapper_wrapper.go 6.7 KB

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