// 在thin pool中创建一个新thin device
// 调用路径:driver.Create()
1.1 func (devices *DeviceSet) AddDevice(hash, baseHash string) error {
//查找父device
baseInfo, err := devices.lookupDevice(baseHash)
if err != nil {
return err
}
baseInfo.lock.Lock()
defer baseInfo.lock.Unlock()
devices.Lock()
defer devices.Unlock()
//检查imageid/containerid对应的image是否存在
if info, _ := devices.lookupDevice(hash); info != nil {
return fmt.Errorf("device %s already exists", hash)
}
deviceId := devices.nextDeviceId
//创建父设备的镜像
if err := createSnapDevice(devices.getPoolDevName(), &deviceId, baseInfo.Name(), baseInfo.DeviceId); err != nil {
utils.Debugf("Error creating snap device: %s\n", err)
return err
}
//创建thin device的DevInfo,并保存信息到/var/lib/docker/devicemapper/metadata/$id文件中
if _, err := devices.registerDevice(deviceId, hash, baseInfo.Size); err != nil {
deleteDevice(devices.getPoolDevName(), deviceId)
utils.Debugf("Error registering device: %s\n", err)
return err
}
return nil
}
// 创建镜像文件的快照
// libdevmapper通过发送msg发送命令
// 调用路径:AddDevice->createSnapDevice
1.2 func createSnapDevice(poolName string, deviceId *int, baseName string, baseDeviceId int) error {
devinfo, _ := getInfo(baseName)
doSuspend := devinfo != nil && devinfo.Exists != 0
//设备存在,则在快照前要先挂起父设备
if doSuspend {
if err := suspendDevice(baseName); err != nil {
return err
}
}
for {
//创建task,libdevmapper通过msg传递命令
task, err := createTask(DeviceTargetMsg, poolName)
if task == nil {
//创建task失败,恢复父device
if doSuspend {
resumeDevice(baseName)
}
return err
}
if err := task.SetSector(0); err != nil {
if doSuspend {
resumeDevice(baseName)
}
return fmt.Errorf("Can't set sector %s", err)
}
//发送创建命令
if err := task.SetMessage(fmt.Sprintf("create_snap %d %d", *deviceId, baseDeviceId)); err != nil {
if doSuspend {
resumeDevice(baseName)
}
return fmt.Errorf("Can't set message %s", err)
}
dmSawExist = false
if err := task.Run(); err != nil {
//deviceid已存在,继续尝试下一个id
if dmSawExist {
*deviceId++
continue
}
if doSuspend {
resumeDevice(baseName)
}
return fmt.Errorf("Error running DeviceCreate (createSnapDevice) %s", err)
}
break
}
//创建成功,恢复父设备
if doSuspend {
if err := resumeDevice(baseName); err != nil {
return err
}
}
return nil
}
// 注册thin device信息
// 添加devinfo到devices.Devices哈希表,并保存devinfo到/var/lib/docker/devicemapper/metadata/$id文件
// 调用路径:AddDevice->registerDevice
1.3 func (devices *DeviceSet) registerDevice(id int, hash string, size uint64) (*DevInfo, error) {
info := &DevInfo{
Hash: hash,
DeviceId: id,
Size: size,
//分配一个新的transactionid
TransactionId: devices.allocateTransactionId(),
Initialized: false,
devices: devices,
}
devices.devicesLock.Lock()
//添加devinfo到hash表
devices.Devices[hash] = info
devices.devicesLock.Unlock()
//保存devinfo到/var/lib/docker/devicemapper/metadata/$id文件
if err := devices.saveMetadata(info); err != nil {
devices.devicesLock.Lock()
delete(devices.Devices, hash)
devices.devicesLock.Unlock()
return nil, err
}
return info, nil
}
// 删除设备
// 调用路径:driver.Remove()
2.1 func (devices *DeviceSet) DeleteDevice(hash string) error {
//检查设备是否存在
info, err := devices.lookupDevice(hash)
if err != nil {
return err
}
info.lock.Lock()
defer info.lock.Unlock()
devices.Lock()
defer devices.Unlock()
//传递devinfo,删除设备
return devices.deleteDevice(info)
// 删除设备
// 1.discard thin device的block
// 2.传递device name删除设备名
// 3.传递device id删除设备
// 4.删除/var/lib/docker/devicemapper/metadata/$id文件
// 调用路径:DeleteDevice->deleteDevice
2.2 func (devices *DeviceSet) deleteDevice(info *DevInfo) error {
//删除设备时,discard其占用的block
if devices.doBlkDiscard {
//激活thin device设备
if err := devices.activateDeviceIfNeeded(info); err == nil {
//discard设备占用的block
if err := BlockDeviceDiscard(info.DevName()); err != nil {
utils.Debugf("Error discarding block on device: %s (ignoring)\n", err)
}
}
}
devinfo, _ := getInfo(info.Name())
if devinfo != nil && devinfo.Exists != 0 {
//传递thin device名(docker-$major:$minor-$inode-$id)给libdevmapper,删除设备名
if err := devices.removeDeviceAndWait(info.Name()); err != nil {
utils.Debugf("Error removing device: %s\n", err)
return err
}
}
//通过thin device id删除设备
if err := deleteDevice(devices.getPoolDevName(), info.DeviceId); err != nil {
utils.Debugf("Error deleting device: %s\n", err)
return err
}
devices.allocateTransactionId()
devices.devicesLock.Lock()
//从内存中删除devinfo
delete(devices.Devices, info.Hash)
devices.devicesLock.Unlock()
//删除/var/lib/docker/devicemapper/metadata/$id文件
if err := devices.removeMetadata(info); err != nil {
devices.devicesLock.Lock()
devices.Devices[info.Hash] = info
devices.devicesLock.Unlock()
utils.Debugf("Error removing meta data: %s\n", err)
return err
}
return nil
}
// 挂载设备到指定路径
// hash指定要挂载的thin device id
// path指定要挂载到的路径
// 一个thin device可以被多次挂载到同一个路径
// 调用路径:driver.Get()
3.1 func (devices *DeviceSet) MountDevice(hash, path, mountLabel string) error {
info, err := devices.lookupDevice(hash)
if err != nil {
return err
}
info.lock.Lock()
defer info.lock.Unlock()
devices.Lock()
defer devices.Unlock()
//thin device不允许被挂载到多个不同路径
if info.mountCount > 0 {
if path != info.mountPath {
return fmt.Errorf("Trying to mount devmapper device in multple places (%s, %s)", info.mountPath, path)
}
info.mountCount++
return nil
}
//激活设备
if err := devices.activateDeviceIfNeeded(info); err != nil {
return fmt.Errorf("Error activating devmapper device for '%s': %s", hash, err)
}
var flags uintptr = syscall.MS_MGC_VAL
//获取thin device上文件系统的类型
//info.DevName()传递
fstype, err := ProbeFsType(info.DevName())
if err != nil {
return err
}
options := ""
//通过--storage-option 传递的mount选项
options = joinMountOptions(options, devices.mountOptions)
options = joinMountOptions(options, label.FormatMountLabel("", mountLabel))
//mount thin device到指定path
err = syscall.Mount(info.DevName(), path, fstype, flags, joinMountOptions("discard", options))
if err != nil && err == syscall.EINVAL {
err = syscall.Mount(info.DevName(), path, fstype, flags, options)
}
if err != nil {
return fmt.Errorf("Error mounting '%s' on '%s': %s", info.DevName(), path, err)
}
info.mountCount = 1
info.mountPath = path
return nil
}
// 解挂thin device
// hash为imageid或containerid
// 直到挂载计数=0时才真正解挂
// 调用路径:driver.Put()
4.1 func (devices *DeviceSet) UnmountDevice(hash string) error {
//查找devinfo
info, err := devices.lookupDevice(hash)
if err != nil {
return err
}
info.lock.Lock()
defer info.lock.Unlock()
devices.Lock()
defer devices.Unlock()
//挂载了不止一次,成功返回
info.mountCount--
if info.mountCount > 0 {
return nil
}
//从指定路径解挂
if err := syscall.Unmount(info.mountPath, 0); err != nil {
return err
}
//停止设备
if err := devices.deactivateDevice(info); err != nil {
return err
}
info.mountPath = ""
return nil
}
// 停止thin device
// 等待thin device从/var/lib/docker/devicemapper/mnt/$id解挂,删除thin device名
// 调用路径:UnmountDevice->deactivateDevice
4.2 func (devices *DeviceSet) deactivateDevice(info *DevInfo) error {
//等待thin device解挂,通过device id获取设备信息,打开计数降到0
if err := devices.waitClose(info); err != nil {
utils.Errorf("Warning: error waiting for device %s to close: %s\n", info.Hash, err)
}
devinfo, err := getInfo(info.Name())
if err != nil {
return err
}
if devinfo.Exists != 0 {
//删除设备名
if err := devices.removeDeviceAndWait(info.Name()); err != nil {
return err
}
}
return nil
}