1. docker
  2. Commit 6990b76a696dd265674f4c2973f25755a6485f05
Browse code

Lint package pkg/devicemapper

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

Vincent Demeester authored on 2015/09/05 06:02:29
Showing 7 changed files
daemon/graphdriver/devmapper/deviceset.go
History View file @ 6990b76
... ... 
@@ -266,7 +266,7 @@ func (devices *DeviceSet) allocateTransactionID() uint64 {
266 266 
 }
267 267
268 268 
 func (devices *DeviceSet) updatePoolTransactionID() error {
269 
-	if err := devicemapper.SetTransactionId(devices.getPoolDevName(), devices.TransactionID, devices.OpenTransactionID); err != nil {
269 
+	if err := devicemapper.SetTransactionID(devices.getPoolDevName(), devices.TransactionID, devices.OpenTransactionID); err != nil {
270 270 
 		return fmt.Errorf("Error setting devmapper transaction ID: %s", err)
271 271 
 	}
272 272 
 	devices.TransactionID = devices.OpenTransactionID
... ... 
@@ -596,7 +596,7 @@ func (devices *DeviceSet) createRegisterDevice(hash string) (*devInfo, error) {
596 596
597 597 
 	for {
598 598 
 		if err := devicemapper.CreateDevice(devices.getPoolDevName(), deviceID); err != nil {
599 
-			if devicemapper.DeviceIdExists(err) {
599 
+			if devicemapper.DeviceIDExists(err) {
600 600 
 				// Device ID already exists. This should not
601 601 
 				// happen. Now we have a mechianism to find
602 602 
 				// a free device ID. So something is not right.
... ... 
@@ -648,7 +648,7 @@ func (devices *DeviceSet) createRegisterSnapDevice(hash string, baseInfo *devInf
648 648
649 649 
 	for {
650 650 
 		if err := devicemapper.CreateSnapDevice(devices.getPoolDevName(), deviceID, baseInfo.Name(), baseInfo.DeviceID); err != nil {
651 
-			if devicemapper.DeviceIdExists(err) {
651 
+			if devicemapper.DeviceIDExists(err) {
652 652 
 				// Device ID already exists. This should not
653 653 
 				// happen. Now we have a mechianism to find
654 654 
 				// a free device ID. So something is not right.
pkg/devicemapper/attach_loopback.go
History View file @ 6990b76
... ... 
@@ -82,7 +82,7 @@ func openNextAvailableLoopback(index int, sparseFile *os.File) (loopFile *os.Fil
82 82 
 	return loopFile, nil
83 83 
 }
84 84
85 
-// attachLoopDevice attaches the given sparse file to the next
85 
+// AttachLoopDevice attaches the given sparse file to the next
86 86 
 // available loopback device. It returns an opened *os.File.
87 87 
 func AttachLoopDevice(sparseName string) (loop *os.File, err error) {
88 88
... ... 
@@ -108,7 +108,7 @@ func AttachLoopDevice(sparseName string) (loop *os.File, err error) {
108 108 
 	}
109 109
110 110 
 	// Set the status of the loopback device
111 
-	loopInfo := &LoopInfo64{
111 
+	loopInfo := &loopInfo64{
112 112 
 		loFileName: stringToLoopName(loopFile.Name()),
113 113 
 		loOffset:   0,
114 114 
 		loFlags:    LoFlagsAutoClear,
pkg/devicemapper/devmapper.go
History View file @ 6990b76
... ... 
@@ -13,37 +13,39 @@ import (
13 13 
 	"github.com/Sirupsen/logrus"
14 14 
 )
15 15
16 
+// DevmapperLogger defines methods for logging with devicemapper.
16 17 
 type DevmapperLogger interface {
17 18 
 	DMLog(level int, file string, line int, dmError int, message string)
18 19 
 }
19 20
20 21 
 const (
21 
-	DeviceCreate TaskType = iota
22 
-	DeviceReload
23 
-	DeviceRemove
24 
-	DeviceRemoveAll
25 
-	DeviceSuspend
26 
-	DeviceResume
27 
-	DeviceInfo
28 
-	DeviceDeps
29 
-	DeviceRename
30 
-	DeviceVersion
31 
-	DeviceStatus
32 
-	DeviceTable
33 
-	DeviceWaitevent
34 
-	DeviceList
35 
-	DeviceClear
36 
-	DeviceMknodes
37 
-	DeviceListVersions
38 
-	DeviceTargetMsg
39 
-	DeviceSetGeometry
22 
+	deviceCreate TaskType = iota
23 
+	deviceReload
24 
+	deviceRemove
25 
+	deviceRemoveAll
26 
+	deviceSuspend
27 
+	deviceResume
28 
+	deviceInfo
29 
+	deviceDeps
30 
+	deviceRename
31 
+	deviceVersion
32 
+	deviceStatus
33 
+	deviceTable
34 
+	deviceWaitevent
35 
+	deviceList
36 
+	deviceClear
37 
+	deviceMknodes
38 
+	deviceListVersions
39 
+	deviceTargetMsg
40 
+	deviceSetGeometry
40 41 
 )
41 42
42 43 
 const (
43 
-	AddNodeOnResume AddNodeType = iota
44 
-	AddNodeOnCreate
44 
+	addNodeOnResume AddNodeType = iota
45 
+	addNodeOnCreate
45 46 
 )
46 47
48 
+// List of errors returned when using devicemapper.
47 49 
 var (
48 50 
 	ErrTaskRun                = errors.New("dm_task_run failed")
49 51 
 	ErrTaskSetName            = errors.New("dm_task_set_name failed")
... ... 
@@ -63,29 +65,35 @@ var (
63 63 
 	ErrUdevWait               = errors.New("wait on udev cookie failed")
64 64 
 	ErrSetDevDir              = errors.New("dm_set_dev_dir failed")
65 65 
 	ErrGetLibraryVersion      = errors.New("dm_get_library_version failed")
66 
-	ErrCreateRemoveTask       = errors.New("Can't create task of type DeviceRemove")
66 
+	ErrCreateRemoveTask       = errors.New("Can't create task of type deviceRemove")
67 67 
 	ErrRunRemoveDevice        = errors.New("running RemoveDevice failed")
68 68 
 	ErrInvalidAddNode         = errors.New("Invalid AddNode type")
69 69 
 	ErrGetLoopbackBackingFile = errors.New("Unable to get loopback backing file")
70 70 
 	ErrLoopbackSetCapacity    = errors.New("Unable set loopback capacity")
71 71 
 	ErrBusy                   = errors.New("Device is Busy")
72 
-	ErrDeviceIdExists         = errors.New("Device Id Exists")
72 
+	ErrDeviceIDExists         = errors.New("Device Id Exists")
73 73 
 	ErrEnxio                  = errors.New("No such device or address")
74 
+)
74 75
76 
+var (
75 77 
 	dmSawBusy  bool
76 78 
 	dmSawExist bool
77 79 
 	dmSawEnxio bool // No Such Device or Address
78 80 
 )
79 81
80 82 
 type (
83 
+	// Task represents a devicemapper task (like lvcreate, etc.) ; a task is needed for each ioctl
84 
+	// command to execute.
81 85 
 	Task struct {
82 
-		unmanaged *CDmTask
86 
+		unmanaged *cdmTask
83 87 
 	}
88 
+	// Deps represents dependents (layer) of a device.
84 89 
 	Deps struct {
85 90 
 		Count  uint32
86 91 
 		Filler uint32
87 92 
 		Device []uint64
88 93 
 	}
94 
+	// Info represents information about a device.
89 95 
 	Info struct {
90 96 
 		Exists         int
91 97 
 		Suspended      int
... ... 
@@ -99,18 +107,20 @@ type (
99 99 
 		TargetCount    int32
100 100 
 		DeferredRemove int
101 101 
 	}
102 
-	TaskType    int
102 
+	// TaskType represents a type of task
103 
+	TaskType int
104 
+	// AddNodeType represents a type of node to be added (?)
103 105 
 	AddNodeType int
104 106 
 )
105 107
106 
-// Returns whether error conveys the information about device Id already
108 
+// DeviceIDExists returns whether error conveys the information about device Id already
107 109 
 // exist or not. This will be true if device creation or snap creation
108 110 
 // operation fails if device or snap device already exists in pool.
109 111 
 // Current implementation is little crude as it scans the error string
110 112 
 // for exact pattern match. Replacing it with more robust implementation
111 113 
 // is desirable.
112 
-func DeviceIdExists(err error) bool {
113 
-	return fmt.Sprint(err) == fmt.Sprint(ErrDeviceIdExists)
114 
+func DeviceIDExists(err error) bool {
115 
+	return fmt.Sprint(err) == fmt.Sprint(ErrDeviceIDExists)
114 116 
 }
115 117
116 118 
 func (t *Task) destroy() {
... ... 
@@ -127,7 +137,7 @@ func TaskCreateNamed(t TaskType, name string) (*Task, error) {
127 127 
 	if task == nil {
128 128 
 		return nil, fmt.Errorf("Can't create task of type %d", int(t))
129 129 
 	}
130 
-	if err := task.SetName(name); err != nil {
130 
+	if err := task.setName(name); err != nil {
131 131 
 		return nil, fmt.Errorf("Can't set task name %s", name)
132 132 
 	}
133 133 
 	return task, nil
... ... 
@@ -144,35 +154,35 @@ func TaskCreate(tasktype TaskType) *Task {
144 144 
 	return task
145 145 
 }
146 146
147 
-func (t *Task) Run() error {
147 
+func (t *Task) run() error {
148 148 
 	if res := DmTaskRun(t.unmanaged); res != 1 {
149 149 
 		return ErrTaskRun
150 150 
 	}
151 151 
 	return nil
152 152 
 }
153 153
154 
-func (t *Task) SetName(name string) error {
154 
+func (t *Task) setName(name string) error {
155 155 
 	if res := DmTaskSetName(t.unmanaged, name); res != 1 {
156 156 
 		return ErrTaskSetName
157 157 
 	}
158 158 
 	return nil
159 159 
 }
160 160
161 
-func (t *Task) SetMessage(message string) error {
161 
+func (t *Task) setMessage(message string) error {
162 162 
 	if res := DmTaskSetMessage(t.unmanaged, message); res != 1 {
163 163 
 		return ErrTaskSetMessage
164 164 
 	}
165 165 
 	return nil
166 166 
 }
167 167
168 
-func (t *Task) SetSector(sector uint64) error {
168 
+func (t *Task) setSector(sector uint64) error {
169 169 
 	if res := DmTaskSetSector(t.unmanaged, sector); res != 1 {
170 170 
 		return ErrTaskSetSector
171 171 
 	}
172 172 
 	return nil
173 173 
 }
174 174
175 
-func (t *Task) SetCookie(cookie *uint, flags uint16) error {
175 
+func (t *Task) setCookie(cookie *uint, flags uint16) error {
176 176 
 	if cookie == nil {
177 177 
 		return ErrNilCookie
178 178 
 	}
... ... 
@@ -182,8 +192,8 @@ func (t *Task) SetCookie(cookie *uint, flags uint16) error {
182 182 
 	return nil
183 183 
 }
184 184
185 
-func (t *Task) SetAddNode(addNode AddNodeType) error {
186 
-	if addNode != AddNodeOnResume && addNode != AddNodeOnCreate {
185 
+func (t *Task) setAddNode(addNode AddNodeType) error {
186 
+	if addNode != addNodeOnResume && addNode != addNodeOnCreate {
187 187 
 		return ErrInvalidAddNode
188 188 
 	}
189 189 
 	if res := DmTaskSetAddNode(t.unmanaged, addNode); res != 1 {
... ... 
@@ -192,14 +202,14 @@ func (t *Task) SetAddNode(addNode AddNodeType) error {
192 192 
 	return nil
193 193 
 }
194 194
195 
-func (t *Task) SetRo() error {
195 
+func (t *Task) setRo() error {
196 196 
 	if res := DmTaskSetRo(t.unmanaged); res != 1 {
197 197 
 		return ErrTaskSetRo
198 198 
 	}
199 199 
 	return nil
200 200 
 }
201 201
202 
-func (t *Task) AddTarget(start, size uint64, ttype, params string) error {
202 
+func (t *Task) addTarget(start, size uint64, ttype, params string) error {
203 203 
 	if res := DmTaskAddTarget(t.unmanaged, start, size,
204 204 
 		ttype, params); res != 1 {
205 205 
 		return ErrTaskAddTarget
... ... 
@@ -207,7 +217,7 @@ func (t *Task) AddTarget(start, size uint64, ttype, params string) error {
207 207 
 	return nil
208 208 
 }
209 209
210 
-func (t *Task) GetDeps() (*Deps, error) {
210 
+func (t *Task) getDeps() (*Deps, error) {
211 211 
 	var deps *Deps
212 212 
 	if deps = DmTaskGetDeps(t.unmanaged); deps == nil {
213 213 
 		return nil, ErrTaskGetDeps
... ... 
@@ -215,7 +225,7 @@ func (t *Task) GetDeps() (*Deps, error) {
215 215 
 	return deps, nil
216 216 
 }
217 217
218 
-func (t *Task) GetInfo() (*Info, error) {
218 
+func (t *Task) getInfo() (*Info, error) {
219 219 
 	info := &Info{}
220 220 
 	if res := DmTaskGetInfo(t.unmanaged, info); res != 1 {
221 221 
 		return nil, ErrTaskGetInfo
... ... 
@@ -223,7 +233,7 @@ func (t *Task) GetInfo() (*Info, error) {
223 223 
 	return info, nil
224 224 
 }
225 225
226 
-func (t *Task) GetInfoWithDeferred() (*Info, error) {
226 
+func (t *Task) getInfoWithDeferred() (*Info, error) {
227 227 
 	info := &Info{}
228 228 
 	if res := DmTaskGetInfoWithDeferred(t.unmanaged, info); res != 1 {
229 229 
 		return nil, ErrTaskGetInfo
... ... 
@@ -231,7 +241,7 @@ func (t *Task) GetInfoWithDeferred() (*Info, error) {
231 231 
 	return info, nil
232 232 
 }
233 233
234 
-func (t *Task) GetDriverVersion() (string, error) {
234 
+func (t *Task) getDriverVersion() (string, error) {
235 235 
 	res := DmTaskGetDriverVersion(t.unmanaged)
236 236 
 	if res == "" {
237 237 
 		return "", ErrTaskGetDriverVersion
... ... 
@@ -239,7 +249,7 @@ func (t *Task) GetDriverVersion() (string, error) {
239 239 
 	return res, nil
240 240 
 }
241 241
242 
-func (t *Task) GetNextTarget(next unsafe.Pointer) (nextPtr unsafe.Pointer, start uint64,
242 
+func (t *Task) getNextTarget(next unsafe.Pointer) (nextPtr unsafe.Pointer, start uint64,
243 243 
 	length uint64, targetType string, params string) {
244 244
245 245 
 	return DmGetNextTarget(t.unmanaged, next, &start, &length,
... ... 
@@ -256,6 +266,7 @@ func getLoopbackBackingFile(file *os.File) (uint64, uint64, error) {
256 256 
 	return loopInfo.loDevice, loopInfo.loInode, nil
257 257 
 }
258 258
259 
+// LoopbackSetCapacity reloads the size for the loopback device.
259 260 
 func LoopbackSetCapacity(file *os.File) error {
260 261 
 	if err := ioctlLoopSetCapacity(file.Fd(), 0); err != nil {
261 262 
 		logrus.Errorf("Error loopbackSetCapacity: %s", err)
... ... 
@@ -264,6 +275,8 @@ func LoopbackSetCapacity(file *os.File) error {
264 264 
 	return nil
265 265 
 }
266 266
267 
+// FindLoopDeviceFor returns a loopback device file for the specified file which
268 
+// is backing file of a loop back device.
267 269 
 func FindLoopDeviceFor(file *os.File) *os.File {
268 270 
 	stat, err := file.Stat()
269 271 
 	if err != nil {
... ... 
@@ -296,6 +309,7 @@ func FindLoopDeviceFor(file *os.File) *os.File {
296 296 
 	return nil
297 297 
 }
298 298
299 
+// UdevWait wakes any processes that are waiting for udev to complete the specified cookie. (?)
299 300 
 func UdevWait(cookie *uint) error {
300 301 
 	if res := DmUdevWait(*cookie); res != 1 {
301 302 
 		logrus.Debugf("Failed to wait on udev cookie %d", *cookie)
... ... 
@@ -304,18 +318,20 @@ func UdevWait(cookie *uint) error {
304 304 
 	return nil
305 305 
 }
306 306
307 
+// LogInitVerbose is an interface to initialize the verbose logger for the device mapper library. (?)
307 308 
 func LogInitVerbose(level int) {
308 309 
 	DmLogInitVerbose(level)
309 310 
 }
310 311
311 
-var dmLogger DevmapperLogger = nil
312 
+var dmLogger DevmapperLogger
312 313
313 
-// initialize the logger for the device mapper library
314 
+// LogInit initializes the logger for the device mapper library.
314 315 
 func LogInit(logger DevmapperLogger) {
315 316 
 	dmLogger = logger
316 317 
 	LogWithErrnoInit()
317 318 
 }
318 319
320 
+// SetDevDir sets the dev folder for the device mapper library (usually /dev).
319 321 
 func SetDevDir(dir string) error {
320 322 
 	if res := DmSetDevDir(dir); res != 1 {
321 323 
 		logrus.Debugf("Error dm_set_dev_dir")
... ... 
@@ -324,6 +340,7 @@ func SetDevDir(dir string) error {
324 324 
 	return nil
325 325 
 }
326 326
327 
+// GetLibraryVersion returns the device mapper library version.
327 328 
 func GetLibraryVersion() (string, error) {
328 329 
 	var version string
329 330 
 	if res := DmGetLibraryVersion(&version); res != 1 {
... ... 
@@ -359,21 +376,21 @@ func CookieSupported() bool {
359 359 
 	return DmCookieSupported() != 0
360 360 
 }
361 361
362 
-// Useful helper for cleanup
362 
+// RemoveDevice is a useful helper for cleaning up a device.
363 363 
 func RemoveDevice(name string) error {
364 
-	task, err := TaskCreateNamed(DeviceRemove, name)
364 
+	task, err := TaskCreateNamed(deviceRemove, name)
365 365 
 	if task == nil {
366 366 
 		return err
367 367 
 	}
368 368
369 
-	var cookie uint = 0
370 
-	if err := task.SetCookie(&cookie, 0); err != nil {
369 
+	var cookie uint
370 
+	if err := task.setCookie(&cookie, 0); err != nil {
371 371 
 		return fmt.Errorf("Can not set cookie: %s", err)
372 372 
 	}
373 373 
 	defer UdevWait(&cookie)
374 374
375 375 
 	dmSawBusy = false // reset before the task is run
376 
-	if err = task.Run(); err != nil {
376 
+	if err = task.run(); err != nil {
377 377 
 		if dmSawBusy {
378 378 
 			return ErrBusy
379 379 
 		}
... ... 
@@ -383,10 +400,11 @@ func RemoveDevice(name string) error {
383 383 
 	return nil
384 384 
 }
385 385
386 
+// RemoveDeviceDeferred is a useful helper for cleaning up a device, but deferred.
386 387 
 func RemoveDeviceDeferred(name string) error {
387 388 
 	logrus.Debugf("[devmapper] RemoveDeviceDeferred START(%s)", name)
388 389 
 	defer logrus.Debugf("[devmapper] RemoveDeviceDeferred END(%s)", name)
389 
-	task, err := TaskCreateNamed(DeviceRemove, name)
390 
+	task, err := TaskCreateNamed(deviceRemove, name)
390 391 
 	if task == nil {
391 392 
 		return err
392 393 
 	}
... ... 
@@ -395,31 +413,31 @@ func RemoveDeviceDeferred(name string) error {
395 395 
 		return ErrTaskDeferredRemove
396 396 
 	}
397 397
398 
-	if err = task.Run(); err != nil {
398 
+	if err = task.run(); err != nil {
399 399 
 		return fmt.Errorf("Error running RemoveDeviceDeferred %s", err)
400 400 
 	}
401 401
402 402 
 	return nil
403 403 
 }
404 404
405 
-// Useful helper for cleanup
405 
+// CancelDeferredRemove cancels a deferred remove for a device.
406 406 
 func CancelDeferredRemove(deviceName string) error {
407 
-	task, err := TaskCreateNamed(DeviceTargetMsg, deviceName)
407 
+	task, err := TaskCreateNamed(deviceTargetMsg, deviceName)
408 408 
 	if task == nil {
409 409 
 		return err
410 410 
 	}
411 411
412 
-	if err := task.SetSector(0); err != nil {
412 
+	if err := task.setSector(0); err != nil {
413 413 
 		return fmt.Errorf("Can't set sector %s", err)
414 414 
 	}
415 415
416 
-	if err := task.SetMessage(fmt.Sprintf("@cancel_deferred_remove")); err != nil {
416 
+	if err := task.setMessage(fmt.Sprintf("@cancel_deferred_remove")); err != nil {
417 417 
 		return fmt.Errorf("Can't set message %s", err)
418 418 
 	}
419 419
420 420 
 	dmSawBusy = false
421 421 
 	dmSawEnxio = false
422 
-	if err := task.Run(); err != nil {
422 
+	if err := task.run(); err != nil {
423 423 
 		// A device might be being deleted already
424 424 
 		if dmSawBusy {
425 425 
 			return ErrBusy
... ... 
@@ -432,6 +450,7 @@ func CancelDeferredRemove(deviceName string) error {
432 432 
 	return nil
433 433 
 }
434 434
435 
+// GetBlockDeviceSize returns the size of a block device identified by the specified file.
435 436 
 func GetBlockDeviceSize(file *os.File) (uint64, error) {
436 437 
 	size, err := ioctlBlkGetSize64(file.Fd())
437 438 
 	if err != nil {
... ... 
@@ -441,6 +460,10 @@ func GetBlockDeviceSize(file *os.File) (uint64, error) {
441 441 
 	return uint64(size), nil
442 442 
 }
443 443
444 
+// BlockDeviceDiscard runs discard for the given path.
445 
+// This is used as a workaround for the kernel not discarding block so
446 
+// on the thin pool when we remove a thinp device, so we do it
447 
+// manually
444 448 
 func BlockDeviceDiscard(path string) error {
445 449 
 	file, err := os.OpenFile(path, os.O_RDWR, 0)
446 450 
 	if err != nil {
... ... 
@@ -464,9 +487,10 @@ func BlockDeviceDiscard(path string) error {
464 464 
 	return nil
465 465 
 }
466 466
467 
-// This is the programmatic example of "dmsetup create"
467 
+// CreatePool is the programmatic example of "dmsetup create".
468 
+// It creates a device with the specified poolName, data and metadata file and block size.
468 469 
 func CreatePool(poolName string, dataFile, metadataFile *os.File, poolBlockSize uint32) error {
469 
-	task, err := TaskCreateNamed(DeviceCreate, poolName)
470 
+	task, err := TaskCreateNamed(deviceCreate, poolName)
470 471 
 	if task == nil {
471 472 
 		return err
472 473 
 	}
... ... 
@@ -477,26 +501,29 @@ func CreatePool(poolName string, dataFile, metadataFile *os.File, poolBlockSize
477 477 
 	}
478 478
479 479 
 	params := fmt.Sprintf("%s %s %d 32768 1 skip_block_zeroing", metadataFile.Name(), dataFile.Name(), poolBlockSize)
480 
-	if err := task.AddTarget(0, size/512, "thin-pool", params); err != nil {
480 
+	if err := task.addTarget(0, size/512, "thin-pool", params); err != nil {
481 481 
 		return fmt.Errorf("Can't add target %s", err)
482 482 
 	}
483 483
484 
-	var cookie uint = 0
485 
-	var flags uint16 = DmUdevDisableSubsystemRulesFlag | DmUdevDisableDiskRulesFlag | DmUdevDisableOtherRulesFlag
486 
-	if err := task.SetCookie(&cookie, flags); err != nil {
484 
+	var cookie uint
485 
+	var flags uint16
486 
+	flags = DmUdevDisableSubsystemRulesFlag | DmUdevDisableDiskRulesFlag | DmUdevDisableOtherRulesFlag
487 
+	if err := task.setCookie(&cookie, flags); err != nil {
487 488 
 		return fmt.Errorf("Can't set cookie %s", err)
488 489 
 	}
489 490 
 	defer UdevWait(&cookie)
490 491
491 
-	if err := task.Run(); err != nil {
492 
-		return fmt.Errorf("Error running DeviceCreate (CreatePool) %s", err)
492 
+	if err := task.run(); err != nil {
493 
+		return fmt.Errorf("Error running deviceCreate (CreatePool) %s", err)
493 494 
 	}
494 495
495 496 
 	return nil
496 497 
 }
497 498
499 
+// ReloadPool is the programmatic example of "dmsetup reload".
500 
+// It reloads the table with the specified poolName, data and metadata file and block size.
498 501 
 func ReloadPool(poolName string, dataFile, metadataFile *os.File, poolBlockSize uint32) error {
499 
-	task, err := TaskCreateNamed(DeviceReload, poolName)
502 
+	task, err := TaskCreateNamed(deviceReload, poolName)
500 503 
 	if task == nil {
501 504 
 		return err
502 505 
 	}
... ... 
@@ -507,73 +534,83 @@ func ReloadPool(poolName string, dataFile, metadataFile *os.File, poolBlockSize
507 507 
 	}
508 508
509 509 
 	params := fmt.Sprintf("%s %s %d 32768 1 skip_block_zeroing", metadataFile.Name(), dataFile.Name(), poolBlockSize)
510 
-	if err := task.AddTarget(0, size/512, "thin-pool", params); err != nil {
510 
+	if err := task.addTarget(0, size/512, "thin-pool", params); err != nil {
511 511 
 		return fmt.Errorf("Can't add target %s", err)
512 512 
 	}
513 513
514 
-	if err := task.Run(); err != nil {
515 
-		return fmt.Errorf("Error running DeviceCreate %s", err)
514 
+	if err := task.run(); err != nil {
515 
+		return fmt.Errorf("Error running deviceCreate %s", err)
516 516 
 	}
517 517
518 518 
 	return nil
519 519 
 }
520 520
521 
+// GetDeps is the programmatic example of "dmsetup deps".
522 
+// It outputs a list of devices referenced by the live table for the specified device.
521 523 
 func GetDeps(name string) (*Deps, error) {
522 
-	task, err := TaskCreateNamed(DeviceDeps, name)
524 
+	task, err := TaskCreateNamed(deviceDeps, name)
523 525 
 	if task == nil {
524 526 
 		return nil, err
525 527 
 	}
526 
-	if err := task.Run(); err != nil {
528 
+	if err := task.run(); err != nil {
527 529 
 		return nil, err
528 530 
 	}
529 
-	return task.GetDeps()
531 
+	return task.getDeps()
530 532 
 }
531 533
534 
+// GetInfo is the programmatic example of "dmsetup info".
535 
+// It outputs some brief information about the device.
532 536 
 func GetInfo(name string) (*Info, error) {
533 
-	task, err := TaskCreateNamed(DeviceInfo, name)
537 
+	task, err := TaskCreateNamed(deviceInfo, name)
534 538 
 	if task == nil {
535 539 
 		return nil, err
536 540 
 	}
537 
-	if err := task.Run(); err != nil {
541 
+	if err := task.run(); err != nil {
538 542 
 		return nil, err
539 543 
 	}
540 
-	return task.GetInfo()
544 
+	return task.getInfo()
541 545 
 }
542 546
547 
+// GetInfoWithDeferred is the programmatic example of "dmsetup info", but deferred.
548 
+// It outputs some brief information about the device.
543 549 
 func GetInfoWithDeferred(name string) (*Info, error) {
544 
-	task, err := TaskCreateNamed(DeviceInfo, name)
550 
+	task, err := TaskCreateNamed(deviceInfo, name)
545 551 
 	if task == nil {
546 552 
 		return nil, err
547 553 
 	}
548 
-	if err := task.Run(); err != nil {
554 
+	if err := task.run(); err != nil {
549 555 
 		return nil, err
550 556 
 	}
551 
-	return task.GetInfoWithDeferred()
557 
+	return task.getInfoWithDeferred()
552 558 
 }
553 559
560 
+// GetDriverVersion is the programmatic example of "dmsetup version".
561 
+// It outputs version information of the driver.
554 562 
 func GetDriverVersion() (string, error) {
555 
-	task := TaskCreate(DeviceVersion)
563 
+	task := TaskCreate(deviceVersion)
556 564 
 	if task == nil {
557 
-		return "", fmt.Errorf("Can't create DeviceVersion task")
565 
+		return "", fmt.Errorf("Can't create deviceVersion task")
558 566 
 	}
559 
-	if err := task.Run(); err != nil {
567 
+	if err := task.run(); err != nil {
560 568 
 		return "", err
561 569 
 	}
562 
-	return task.GetDriverVersion()
570 
+	return task.getDriverVersion()
563 571 
 }
564 572
573 
+// GetStatus is the programmatic example of "dmsetup status".
574 
+// It outputs status information for the specified device name.
565 575 
 func GetStatus(name string) (uint64, uint64, string, string, error) {
566 
-	task, err := TaskCreateNamed(DeviceStatus, name)
576 
+	task, err := TaskCreateNamed(deviceStatus, name)
567 577 
 	if task == nil {
568 578 
 		logrus.Debugf("GetStatus: Error TaskCreateNamed: %s", err)
569 579 
 		return 0, 0, "", "", err
570 580 
 	}
571 
-	if err := task.Run(); err != nil {
581 
+	if err := task.run(); err != nil {
572 582 
 		logrus.Debugf("GetStatus: Error Run: %s", err)
573 583 
 		return 0, 0, "", "", err
574 584 
 	}
575 585
576 
-	devinfo, err := task.GetInfo()
586 
+	devinfo, err := task.getInfo()
577 587 
 	if err != nil {
578 588 
 		logrus.Debugf("GetStatus: Error GetInfo: %s", err)
579 589 
 		return 0, 0, "", "", err
... ... 
@@ -583,22 +620,24 @@ func GetStatus(name string) (uint64, uint64, string, string, error) {
583 583 
 		return 0, 0, "", "", fmt.Errorf("Non existing device %s", name)
584 584 
 	}
585 585
586 
-	_, start, length, targetType, params := task.GetNextTarget(unsafe.Pointer(nil))
586 
+	_, start, length, targetType, params := task.getNextTarget(unsafe.Pointer(nil))
587 587 
 	return start, length, targetType, params, nil
588 588 
 }
589 589
590 
+// GetTable is the programmatic example for "dmsetup table".
591 
+// It outputs the current table for the specified device name.
590 592 
 func GetTable(name string) (uint64, uint64, string, string, error) {
591 
-	task, err := TaskCreateNamed(DeviceTable, name)
593 
+	task, err := TaskCreateNamed(deviceTable, name)
592 594 
 	if task == nil {
593 595 
 		logrus.Debugf("GetTable: Error TaskCreateNamed: %s", err)
594 596 
 		return 0, 0, "", "", err
595 597 
 	}
596 
-	if err := task.Run(); err != nil {
598 
+	if err := task.run(); err != nil {
597 599 
 		logrus.Debugf("GetTable: Error Run: %s", err)
598 600 
 		return 0, 0, "", "", err
599 601 
 	}
600 602
601 
-	devinfo, err := task.GetInfo()
603 
+	devinfo, err := task.getInfo()
602 604 
 	if err != nil {
603 605 
 		logrus.Debugf("GetTable: Error GetInfo: %s", err)
604 606 
 		return 0, 0, "", "", err
... ... 
@@ -608,80 +647,86 @@ func GetTable(name string) (uint64, uint64, string, string, error) {
608 608 
 		return 0, 0, "", "", fmt.Errorf("Non existing device %s", name)
609 609 
 	}
610 610
611 
-	_, start, length, targetType, params := task.GetNextTarget(unsafe.Pointer(nil))
611 
+	_, start, length, targetType, params := task.getNextTarget(unsafe.Pointer(nil))
612 612 
 	return start, length, targetType, params, nil
613 613 
 }
614 614
615 
-func SetTransactionId(poolName string, oldId uint64, newId uint64) error {
616 
-	task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
615 
+// SetTransactionID sets a transaction id for the specified device name.
616 
+func SetTransactionID(poolName string, oldID uint64, newID uint64) error {
617 
+	task, err := TaskCreateNamed(deviceTargetMsg, poolName)
617 618 
 	if task == nil {
618 619 
 		return err
619 620 
 	}
620 621
621 
-	if err := task.SetSector(0); err != nil {
622 
+	if err := task.setSector(0); err != nil {
622 623 
 		return fmt.Errorf("Can't set sector %s", err)
623 624 
 	}
624 625
625 
-	if err := task.SetMessage(fmt.Sprintf("set_transaction_id %d %d", oldId, newId)); err != nil {
626 
+	if err := task.setMessage(fmt.Sprintf("set_transaction_id %d %d", oldID, newID)); err != nil {
626 627 
 		return fmt.Errorf("Can't set message %s", err)
627 628 
 	}
628 629
629 
-	if err := task.Run(); err != nil {
630 
-		return fmt.Errorf("Error running SetTransactionId %s", err)
630 
+	if err := task.run(); err != nil {
631 
+		return fmt.Errorf("Error running SetTransactionID %s", err)
631 632 
 	}
632 633 
 	return nil
633 634 
 }
634 635
636 
+// SuspendDevice is the programmatic example of "dmsetup suspend".
637 
+// It suspends the specified device.
635 638 
 func SuspendDevice(name string) error {
636 
-	task, err := TaskCreateNamed(DeviceSuspend, name)
639 
+	task, err := TaskCreateNamed(deviceSuspend, name)
637 640 
 	if task == nil {
638 641 
 		return err
639 642 
 	}
640 
-	if err := task.Run(); err != nil {
641 
-		return fmt.Errorf("Error running DeviceSuspend %s", err)
643 
+	if err := task.run(); err != nil {
644 
+		return fmt.Errorf("Error running deviceSuspend %s", err)
642 645 
 	}
643 646 
 	return nil
644 647 
 }
645 648
649 
+// ResumeDevice is the programmatic example of "dmsetup resume".
650 
+// It un-suspends the specified device.
646 651 
 func ResumeDevice(name string) error {
647 
-	task, err := TaskCreateNamed(DeviceResume, name)
652 
+	task, err := TaskCreateNamed(deviceResume, name)
648 653 
 	if task == nil {
649 654 
 		return err
650 655 
 	}
651 656
652 
-	var cookie uint = 0
653 
-	if err := task.SetCookie(&cookie, 0); err != nil {
657 
+	var cookie uint
658 
+	if err := task.setCookie(&cookie, 0); err != nil {
654 659 
 		return fmt.Errorf("Can't set cookie %s", err)
655 660 
 	}
656 661 
 	defer UdevWait(&cookie)
657 662
658 
-	if err := task.Run(); err != nil {
659 
-		return fmt.Errorf("Error running DeviceResume %s", err)
663 
+	if err := task.run(); err != nil {
664 
+		return fmt.Errorf("Error running deviceResume %s", err)
660 665 
 	}
661 666
662 667 
 	return nil
663 668 
 }
664 669
665 
-func CreateDevice(poolName string, deviceId int) error {
666 
-	logrus.Debugf("[devmapper] CreateDevice(poolName=%v, deviceId=%v)", poolName, deviceId)
667 
-	task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
670 
+// CreateDevice creates a device with the specified poolName with the specified device id. (?)
671 
+func CreateDevice(poolName string, deviceID int) error {
672 
+	logrus.Debugf("[devmapper] CreateDevice(poolName=%v, deviceID=%v)", poolName, deviceID)
673 
+	task, err := TaskCreateNamed(deviceTargetMsg, poolName)
668 674 
 	if task == nil {
669 675 
 		return err
670 676 
 	}
671 677
672 
-	if err := task.SetSector(0); err != nil {
678 
+	if err := task.setSector(0); err != nil {
673 679 
 		return fmt.Errorf("Can't set sector %s", err)
674 680 
 	}
675 681
676 
-	if err := task.SetMessage(fmt.Sprintf("create_thin %d", deviceId)); err != nil {
682 
+	if err := task.setMessage(fmt.Sprintf("create_thin %d", deviceID)); err != nil {
677 683 
 		return fmt.Errorf("Can't set message %s", err)
678 684 
 	}
679 685
680 686 
 	dmSawExist = false // reset before the task is run
681 
-	if err := task.Run(); err != nil {
682 
-		// Caller wants to know about ErrDeviceIdExists so that it can try with a different device id.
687 
+	if err := task.run(); err != nil {
688 
+		// Caller wants to know about ErrDeviceIDExists so that it can try with a different device id.
683 689 
 		if dmSawExist {
684 
-			return ErrDeviceIdExists
690 
+			return ErrDeviceIDExists
685 691 
 		}
686 692
687 693 
 		return fmt.Errorf("Error running CreateDevice %s", err)
... ... 
@@ -690,68 +735,74 @@ func CreateDevice(poolName string, deviceId int) error {
690 690 
 	return nil
691 691 
 }
692 692
693 
-func DeleteDevice(poolName string, deviceId int) error {
694 
-	task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
693 
+// DeleteDevice deletes a device with the specified poolName with the specified device id. (?)
694 
+func DeleteDevice(poolName string, deviceID int) error {
695 
+	task, err := TaskCreateNamed(deviceTargetMsg, poolName)
695 696 
 	if task == nil {
696 697 
 		return err
697 698 
 	}
698 699
699 
-	if err := task.SetSector(0); err != nil {
700 
+	if err := task.setSector(0); err != nil {
700 701 
 		return fmt.Errorf("Can't set sector %s", err)
701 702 
 	}
702 703
703 
-	if err := task.SetMessage(fmt.Sprintf("delete %d", deviceId)); err != nil {
704 
+	if err := task.setMessage(fmt.Sprintf("delete %d", deviceID)); err != nil {
704 705 
 		return fmt.Errorf("Can't set message %s", err)
705 706 
 	}
706 707
707 
-	if err := task.Run(); err != nil {
708 
+	if err := task.run(); err != nil {
708 709 
 		return fmt.Errorf("Error running DeleteDevice %s", err)
709 710 
 	}
710 711 
 	return nil
711 712 
 }
712 713
713 
-func ActivateDevice(poolName string, name string, deviceId int, size uint64) error {
714 
-	return activateDevice(poolName, name, deviceId, size, "")
714 
+// ActivateDevice activates the device identified by the specified
715 
+// poolName, name and deviceID with the specified size.
716 
+func ActivateDevice(poolName string, name string, deviceID int, size uint64) error {
717 
+	return activateDevice(poolName, name, deviceID, size, "")
715 718 
 }
716 719
717 
-func ActivateDeviceWithExternal(poolName string, name string, deviceId int, size uint64, external string) error {
718 
-	return activateDevice(poolName, name, deviceId, size, external)
720 
+// ActivateDeviceWithExternal activates the device identified by the specified
721 
+// poolName, name and deviceID with the specified size. (?)
722 
+func ActivateDeviceWithExternal(poolName string, name string, deviceID int, size uint64, external string) error {
723 
+	return activateDevice(poolName, name, deviceID, size, external)
719 724 
 }
720 725
721 
-func activateDevice(poolName string, name string, deviceId int, size uint64, external string) error {
722 
-	task, err := TaskCreateNamed(DeviceCreate, name)
726 
+func activateDevice(poolName string, name string, deviceID int, size uint64, external string) error {
727 
+	task, err := TaskCreateNamed(deviceCreate, name)
723 728 
 	if task == nil {
724 729 
 		return err
725 730 
 	}
726 731
727 732 
 	var params string
728 733 
 	if len(external) > 0 {
729 
-		params = fmt.Sprintf("%s %d %s", poolName, deviceId, external)
734 
+		params = fmt.Sprintf("%s %d %s", poolName, deviceID, external)
730 735 
 	} else {
731 
-		params = fmt.Sprintf("%s %d", poolName, deviceId)
736 
+		params = fmt.Sprintf("%s %d", poolName, deviceID)
732 737 
 	}
733 
-	if err := task.AddTarget(0, size/512, "thin", params); err != nil {
738 
+	if err := task.addTarget(0, size/512, "thin", params); err != nil {
734 739 
 		return fmt.Errorf("Can't add target %s", err)
735 740 
 	}
736 
-	if err := task.SetAddNode(AddNodeOnCreate); err != nil {
741 
+	if err := task.setAddNode(addNodeOnCreate); err != nil {
737 742 
 		return fmt.Errorf("Can't add node %s", err)
738 743 
 	}
739 744
740 
-	var cookie uint = 0
741 
-	if err := task.SetCookie(&cookie, 0); err != nil {
745 
+	var cookie uint
746 
+	if err := task.setCookie(&cookie, 0); err != nil {
742 747 
 		return fmt.Errorf("Can't set cookie %s", err)
743 748 
 	}
744 749
745 750 
 	defer UdevWait(&cookie)
746 751
747 
-	if err := task.Run(); err != nil {
748 
-		return fmt.Errorf("Error running DeviceCreate (ActivateDevice) %s", err)
752 
+	if err := task.run(); err != nil {
753 
+		return fmt.Errorf("Error running deviceCreate (ActivateDevice) %s", err)
749 754 
 	}
750 755
751 756 
 	return nil
752 757 
 }
753 758
754 
-func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDeviceId int) error {
759 
+// CreateSnapDevice creates a snapshot based on the device identified by the baseName and baseDeviceId,
760 
+func CreateSnapDevice(poolName string, deviceID int, baseName string, baseDeviceID int) error {
755 761 
 	devinfo, _ := GetInfo(baseName)
756 762 
 	doSuspend := devinfo != nil && devinfo.Exists != 0
757 763
... ... 
@@ -761,7 +812,7 @@ func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDevice
761 761 
 		}
762 762 
 	}
763 763
764 
-	task, err := TaskCreateNamed(DeviceTargetMsg, poolName)
764 
+	task, err := TaskCreateNamed(deviceTargetMsg, poolName)
765 765 
 	if task == nil {
766 766 
 		if doSuspend {
767 767 
 			ResumeDevice(baseName)
... ... 
@@ -769,14 +820,14 @@ func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDevice
769 769 
 		return err
770 770 
 	}
771 771
772 
-	if err := task.SetSector(0); err != nil {
772 
+	if err := task.setSector(0); err != nil {
773 773 
 		if doSuspend {
774 774 
 			ResumeDevice(baseName)
775 775 
 		}
776 776 
 		return fmt.Errorf("Can't set sector %s", err)
777 777 
 	}
778 778
779 
-	if err := task.SetMessage(fmt.Sprintf("create_snap %d %d", deviceId, baseDeviceId)); err != nil {
779 
+	if err := task.setMessage(fmt.Sprintf("create_snap %d %d", deviceID, baseDeviceID)); err != nil {
780 780 
 		if doSuspend {
781 781 
 			ResumeDevice(baseName)
782 782 
 		}
... ... 
@@ -784,16 +835,16 @@ func CreateSnapDevice(poolName string, deviceId int, baseName string, baseDevice
784 784 
 	}
785 785
786 786 
 	dmSawExist = false // reset before the task is run
787 
-	if err := task.Run(); err != nil {
787 
+	if err := task.run(); err != nil {
788 788 
 		if doSuspend {
789 789 
 			ResumeDevice(baseName)
790 790 
 		}
791 
-		// Caller wants to know about ErrDeviceIdExists so that it can try with a different device id.
791 
+		// Caller wants to know about ErrDeviceIDExists so that it can try with a different device id.
792 792 
 		if dmSawExist {
793 
-			return ErrDeviceIdExists
793 
+			return ErrDeviceIDExists
794 794 
 		}
795 795
796 
-		return fmt.Errorf("Error running DeviceCreate (createSnapDevice) %s", err)
796 
+		return fmt.Errorf("Error running deviceCreate (createSnapDevice) %s", err)
797 797
798 798 
 	}
799 799
pkg/devicemapper/devmapper_wrapper.go
History View file @ 6990b76
... ... 
@@ -44,23 +44,23 @@ import (
44 44 
 )
45 45
46 46 
 type (
47 
-	CDmTask C.struct_dm_task
48 
-
49 
-	CLoopInfo64 C.struct_loop_info64
50 
-	LoopInfo64  struct {
51 
-		loDevice           uint64 /* ioctl r/o */
52 
-		loInode            uint64 /* ioctl r/o */
53 
-		loRdevice          uint64 /* ioctl r/o */
54 
-		loOffset           uint64
55 
-		loSizelimit        uint64 /* bytes, 0 == max available */
56 
-		loNumber           uint32 /* ioctl r/o */
57 
-		loEncrypt_type     uint32
58 
-		loEncrypt_key_size uint32 /* ioctl w/o */
59 
-		loFlags            uint32 /* ioctl r/o */
60 
-		loFileName         [LoNameSize]uint8
61 
-		loCryptName        [LoNameSize]uint8
62 
-		loEncryptKey       [LoKeySize]uint8 /* ioctl w/o */
63 
-		loInit             [2]uint64
47 
+	cdmTask C.struct_dm_task
48 
+
49 
+	cLoopInfo64 C.struct_loop_info64
50 
+	loopInfo64  struct {
51 
+		loDevice         uint64 /* ioctl r/o */
52 
+		loInode          uint64 /* ioctl r/o */
53 
+		loRdevice        uint64 /* ioctl r/o */
54 
+		loOffset         uint64
55 
+		loSizelimit      uint64 /* bytes, 0 == max available */
56 
+		loNumber         uint32 /* ioctl r/o */
57 
+		loEncryptType    uint32
58 
+		loEncryptKeySize uint32 /* ioctl w/o */
59 
+		loFlags          uint32 /* ioctl r/o */
60 
+		loFileName       [LoNameSize]uint8
61 
+		loCryptName      [LoNameSize]uint8
62 
+		loEncryptKey     [LoKeySize]uint8 /* ioctl w/o */
63 
+		loInit           [2]uint64
64 64 
 	}
65 65 
 )
66 66
... ... 
@@ -77,6 +77,7 @@ const (
77 77 
 	LoopSetCapacity = C.LOOP_SET_CAPACITY
78 78 
 )
79 79
80 
+// LOOP consts. (?)
80 81 
 const (
81 82 
 	LoFlagsAutoClear = C.LO_FLAGS_AUTOCLEAR
82 83 
 	LoFlagsReadOnly  = C.LO_FLAGS_READ_ONLY
... ... 
@@ -85,6 +86,7 @@ const (
85 85 
 	LoNameSize       = C.LO_NAME_SIZE
86 86 
 )
87 87
88 
+// DeviceMapper Udev consts. (?)
88 89 
 const (
89 90 
 	DmUdevDisableSubsystemRulesFlag = C.DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG
90 91 
 	DmUdevDisableDiskRulesFlag      = C.DM_UDEV_DISABLE_DISK_RULES_FLAG
... ... 
@@ -92,6 +94,7 @@ const (
92 92 
 	DmUdevDisableLibraryFallback    = C.DM_UDEV_DISABLE_LIBRARY_FALLBACK
93 93 
 )
94 94
95 
+// DeviceMapper mapped functions.
95 96 
 var (
96 97 
 	DmGetLibraryVersion       = dmGetLibraryVersionFct
97 98 
 	DmGetNextTarget           = dmGetNextTargetFct
... ... 
@@ -123,38 +126,38 @@ func free(p *C.char) {
123 123 
 	C.free(unsafe.Pointer(p))
124 124 
 }
125 125
126 
-func dmTaskDestroyFct(task *CDmTask) {
126 
+func dmTaskDestroyFct(task *cdmTask) {
127 127 
 	C.dm_task_destroy((*C.struct_dm_task)(task))
128 128 
 }
129 129
130 
-func dmTaskCreateFct(taskType int) *CDmTask {
131 
-	return (*CDmTask)(C.dm_task_create(C.int(taskType)))
130 
+func dmTaskCreateFct(taskType int) *cdmTask {
131 
+	return (*cdmTask)(C.dm_task_create(C.int(taskType)))
132 132 
 }
133 133
134 
-func dmTaskRunFct(task *CDmTask) int {
134 
+func dmTaskRunFct(task *cdmTask) int {
135 135 
 	ret, _ := C.dm_task_run((*C.struct_dm_task)(task))
136 136 
 	return int(ret)
137 137 
 }
138 138
139 
-func dmTaskSetNameFct(task *CDmTask, name string) int {
139 
+func dmTaskSetNameFct(task *cdmTask, name string) int {
140 140 
 	Cname := C.CString(name)
141 141 
 	defer free(Cname)
142 142
143 143 
 	return int(C.dm_task_set_name((*C.struct_dm_task)(task), Cname))
144 144 
 }
145 145
146 
-func dmTaskSetMessageFct(task *CDmTask, message string) int {
146 
+func dmTaskSetMessageFct(task *cdmTask, message string) int {
147 147 
 	Cmessage := C.CString(message)
148 148 
 	defer free(Cmessage)
149 149
150 150 
 	return int(C.dm_task_set_message((*C.struct_dm_task)(task), Cmessage))
151 151 
 }
152 152
153 
-func dmTaskSetSectorFct(task *CDmTask, sector uint64) int {
153 
+func dmTaskSetSectorFct(task *cdmTask, sector uint64) int {
154 154 
 	return int(C.dm_task_set_sector((*C.struct_dm_task)(task), C.uint64_t(sector)))
155 155 
 }
156 156
157 
-func dmTaskSetCookieFct(task *CDmTask, cookie *uint, flags uint16) int {
157 
+func dmTaskSetCookieFct(task *cdmTask, cookie *uint, flags uint16) int {
158 158 
 	cCookie := C.uint32_t(*cookie)
159 159 
 	defer func() {
160 160 
 		*cookie = uint(cCookie)
... ... 
@@ -162,15 +165,15 @@ func dmTaskSetCookieFct(task *CDmTask, cookie *uint, flags uint16) int {
162 162 
 	return int(C.dm_task_set_cookie((*C.struct_dm_task)(task), &cCookie, C.uint16_t(flags)))
163 163 
 }
164 164
165 
-func dmTaskSetAddNodeFct(task *CDmTask, addNode AddNodeType) int {
165 
+func dmTaskSetAddNodeFct(task *cdmTask, addNode AddNodeType) int {
166 166 
 	return int(C.dm_task_set_add_node((*C.struct_dm_task)(task), C.dm_add_node_t(addNode)))
167 167 
 }
168 168
169 
-func dmTaskSetRoFct(task *CDmTask) int {
169 
+func dmTaskSetRoFct(task *cdmTask) int {
170 170 
 	return int(C.dm_task_set_ro((*C.struct_dm_task)(task)))
171 171 
 }
172 172
173 
-func dmTaskAddTargetFct(task *CDmTask,
173 
+func dmTaskAddTargetFct(task *cdmTask,
174 174 
 	start, size uint64, ttype, params string) int {
175 175
176 176 
 	Cttype := C.CString(ttype)
... ... 
@@ -182,7 +185,7 @@ func dmTaskAddTargetFct(task *CDmTask,
182 182 
 	return int(C.dm_task_add_target((*C.struct_dm_task)(task), C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))
183 183 
 }
184 184
185 
-func dmTaskGetDepsFct(task *CDmTask) *Deps {
185 
+func dmTaskGetDepsFct(task *cdmTask) *Deps {
186 186 
 	Cdeps := C.dm_task_get_deps((*C.struct_dm_task)(task))
187 187 
 	if Cdeps == nil {
188 188 
 		return nil
... ... 
@@ -206,7 +209,7 @@ func dmTaskGetDepsFct(task *CDmTask) *Deps {
206 206 
 	return deps
207 207 
 }
208 208
209 
-func dmTaskGetInfoFct(task *CDmTask, info *Info) int {
209 
+func dmTaskGetInfoFct(task *cdmTask, info *Info) int {
210 210 
 	Cinfo := C.struct_dm_info{}
211 211 
 	defer func() {
212 212 
 		info.Exists = int(Cinfo.exists)
... ... 
@@ -223,7 +226,7 @@ func dmTaskGetInfoFct(task *CDmTask, info *Info) int {
223 223 
 	return int(C.dm_task_get_info((*C.struct_dm_task)(task), &Cinfo))
224 224 
 }
225 225
226 
-func dmTaskGetDriverVersionFct(task *CDmTask) string {
226 
+func dmTaskGetDriverVersionFct(task *cdmTask) string {
227 227 
 	buffer := C.malloc(128)
228 228 
 	defer C.free(buffer)
229 229 
 	res := C.dm_task_get_driver_version((*C.struct_dm_task)(task), (*C.char)(buffer), 128)
... ... 
@@ -233,7 +236,7 @@ func dmTaskGetDriverVersionFct(task *CDmTask) string {
233 233 
 	return C.GoString((*C.char)(buffer))
234 234 
 }
235 235
236 
-func dmGetNextTargetFct(task *CDmTask, next unsafe.Pointer, start, length *uint64, target, params *string) unsafe.Pointer {
236 
+func dmGetNextTargetFct(task *cdmTask, next unsafe.Pointer, start, length *uint64, target, params *string) unsafe.Pointer {
237 237 
 	var (
238 238 
 		Cstart, Clength      C.uint64_t
239 239 
 		CtargetType, Cparams *C.char
pkg/devicemapper/devmapper_wrapper_deferred_remove.go
History View file @ 6990b76
... ... 
@@ -8,6 +8,7 @@ package devicemapper
8 8 
 */
9 9 
 import "C"
10 10
11 
+// LibraryDeferredRemovalsupport is supported when statically linked.
11 12 
 const LibraryDeferredRemovalSupport = true
12 13
13 14 
 func dmTaskDeferredRemoveFct(task *CDmTask) int {
pkg/devicemapper/devmapper_wrapper_no_deferred_remove.go
History View file @ 6990b76
... ... 
@@ -2,13 +2,14 @@
2 2
3 3 
 package devicemapper
4 4
5 
+// LibraryDeferredRemovalsupport is not supported when statically linked.
5 6 
 const LibraryDeferredRemovalSupport = false
6 7
7 
-func dmTaskDeferredRemoveFct(task *CDmTask) int {
8 
+func dmTaskDeferredRemoveFct(task *cdmTask) int {
8 9 
 	// Error. Nobody should be calling it.
9 10 
 	return -1
10 11 
 }
11 12
12 
-func dmTaskGetInfoWithDeferredFct(task *CDmTask, info *Info) int {
13 
+func dmTaskGetInfoWithDeferredFct(task *cdmTask, info *Info) int {
13 14 
 	return -1
14 15 
 }
pkg/devicemapper/ioctl.go
History View file @ 6990b76
... ... 
@@ -22,7 +22,7 @@ func ioctlLoopSetFd(loopFd, sparseFd uintptr) error {
22 22 
 	return nil
23 23 
 }
24 24
25 
-func ioctlLoopSetStatus64(loopFd uintptr, loopInfo *LoopInfo64) error {
25 
+func ioctlLoopSetStatus64(loopFd uintptr, loopInfo *loopInfo64) error {
26 26 
 	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopSetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 {
27 27 
 		return err
28 28 
 	}
... ... 
@@ -36,8 +36,8 @@ func ioctlLoopClrFd(loopFd uintptr) error {
36 36 
 	return nil
37 37 
 }
38 38
39 
-func ioctlLoopGetStatus64(loopFd uintptr) (*LoopInfo64, error) {
40 
-	loopInfo := &LoopInfo64{}
39 
+func ioctlLoopGetStatus64(loopFd uintptr) (*loopInfo64, error) {
40 
+	loopInfo := &loopInfo64{}
41 41
42 42 
 	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, loopFd, LoopGetStatus64, uintptr(unsafe.Pointer(loopInfo))); err != 0 {
43 43 
 		return nil, err