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