@@ -5,7 +5,6 @@

 builder/**                              @tonistiigi

 contrib/mkimage/**                      @tianon

-daemon/graphdriver/devmapper/**         @rhvgoyal

 daemon/graphdriver/overlay2/**          @dmcgowan

 daemon/graphdriver/windows/**           @johnstep

 daemon/logger/awslogs/**                @samuelkarp  

@@ -28,7 +28,7 @@ export VALIDATE_ORIGIN_BRANCH

 # option of "go build". For example, a built-in graphdriver priority list

 # can be changed during build time like this:

 #

-# make DOCKER_LDFLAGS="-X github.com/docker/docker/daemon/graphdriver.priority=overlay2,devicemapper" dynbinary

+# make DOCKER_LDFLAGS="-X github.com/docker/docker/daemon/graphdriver.priority=overlay2,zfs" dynbinary

 #

 DOCKER_ENVS := \

 	-e BUILD_APT_MIRROR \

@@ -6561,7 +6561,7 @@ paths:

                 StopSignal: "SIGTERM"

                 StopTimeout: 10

               Created: "2015-01-06T15:47:31.485331387Z"

-              Driver: "devicemapper"

+              Driver: "overlay2"

               ExecIDs:

                 - "b35395de42bc8abd327f9dd65d913b9ba28c74d2f0734eeeae84fa1c616a0fca"

                 - "3fc1232e5cd20c8de182ed81178503dc6437f4e7ef12b52cc5e8de020652f1c4"

@@ -374,11 +374,6 @@ check_flags BTRFS_FS_POSIX_ACL | sed 's/^/    /'

 [ "$EXITCODE" = 0 ] && STORAGE=0

 EXITCODE=0

-echo "  - \"$(wrap_color 'devicemapper' blue)\":"

-check_flags BLK_DEV_DM DM_THIN_PROVISIONING | sed 's/^/    /'

-[ "$EXITCODE" = 0 ] && STORAGE=0

-EXITCODE=0

-

 echo "  - \"$(wrap_color 'overlay' blue)\":"

 check_flags OVERLAY_FS | sed 's/^/    /'

 [ "$EXITCODE" = 0 ] && STORAGE=0

deleted file mode 100644

@@ -1,14 +0,0 @@

-Docker device tool for devicemapper storage driver backend

-===================

-

-The ./contrib/docker-device-tool contains a tool to manipulate devicemapper thin-pool.

-

-Compile

-========

-

-    $ make shell

-    ## inside build container

-    $ go build contrib/docker-device-tool/device_tool.go

-

-    # if devicemapper version is old and compilation fails, compile with `libdm_no_deferred_remove` tag

-    $ go build -tags libdm_no_deferred_remove contrib/docker-device-tool/device_tool.go

deleted file mode 100644

@@ -1,169 +0,0 @@

-//go:build !windows

-// +build !windows

-

-package main

-

-import (

-	"flag"

-	"fmt"

-	"os"

-	"path"

-	"sort"

-	"strconv"

-	"strings"

-

-	"github.com/docker/docker/daemon/graphdriver/devmapper"

-	"github.com/docker/docker/pkg/devicemapper"

-	"github.com/docker/docker/pkg/idtools"

-	"github.com/sirupsen/logrus"

-)

-

-func usage() {

-	fmt.Fprintf(os.Stderr, "Usage: %s <flags>  [status] | [list] | [device id]  | [resize new-pool-size] | [snap new-id base-id] | [remove id] | [mount id mountpoint]\n", os.Args[0])

-	flag.PrintDefaults()

-	os.Exit(1)

-}

-

-func byteSizeFromString(arg string) (int64, error) {

-	digits := ""

-	rest := ""

-	last := strings.LastIndexAny(arg, "0123456789")

-	if last >= 0 {

-		digits = arg[:last+1]

-		rest = arg[last+1:]

-	}

-

-	val, err := strconv.ParseInt(digits, 10, 64)

-	if err != nil {

-		return val, err

-	}

-

-	rest = strings.ToLower(strings.TrimSpace(rest))

-

-	var multiplier int64

-	switch rest {

-	case "":

-		multiplier = 1

-	case "k", "kb":

-		multiplier = 1024

-	case "m", "mb":

-		multiplier = 1024 * 1024

-	case "g", "gb":

-		multiplier = 1024 * 1024 * 1024

-	case "t", "tb":

-		multiplier = 1024 * 1024 * 1024 * 1024

-	default:

-		return 0, fmt.Errorf("Unknown size unit: %s", rest)

-	}

-

-	return val * multiplier, nil

-}

-

-func main() {

-	root := flag.String("r", "/var/lib/docker", "Docker root dir")

-	flDebug := flag.Bool("D", false, "Debug mode")

-

-	flag.Parse()

-

-	if *flDebug {

-		os.Setenv("DEBUG", "1")

-		logrus.SetLevel(logrus.DebugLevel)

-	}

-

-	if flag.NArg() < 1 {

-		usage()

-	}

-

-	args := flag.Args()

-

-	home := path.Join(*root, "devicemapper")

-	devices, err := devmapper.NewDeviceSet(home, false, nil, idtools.IdentityMapping{})

-	if err != nil {

-		fmt.Println("Can't initialize device mapper: ", err)

-		os.Exit(1)

-	}

-

-	switch args[0] {

-	case "status":

-		status := devices.Status()

-		fmt.Printf("Pool name: %s\n", status.PoolName)

-		fmt.Printf("Data Loopback file: %s\n", status.DataLoopback)

-		fmt.Printf("Metadata Loopback file: %s\n", status.MetadataLoopback)

-		fmt.Printf("Sector size: %d\n", status.SectorSize)

-		fmt.Printf("Data use: %d of %d (%.1f %%)\n", status.Data.Used, status.Data.Total, 100.0*float64(status.Data.Used)/float64(status.Data.Total))

-		fmt.Printf("Metadata use: %d of %d (%.1f %%)\n", status.Metadata.Used, status.Metadata.Total, 100.0*float64(status.Metadata.Used)/float64(status.Metadata.Total))

-	case "list":

-		ids := devices.List()

-		sort.Strings(ids)

-		for _, id := range ids {

-			fmt.Println(id)

-		}

-	case "device":

-		if flag.NArg() < 2 {

-			usage()

-		}

-		status, err := devices.GetDeviceStatus(args[1])

-		if err != nil {

-			fmt.Println("Can't get device info: ", err)

-			os.Exit(1)

-		}

-		fmt.Printf("Id: %d\n", status.DeviceID)

-		fmt.Printf("Size: %d\n", status.Size)

-		fmt.Printf("Transaction Id: %d\n", status.TransactionID)

-		fmt.Printf("Size in Sectors: %d\n", status.SizeInSectors)

-		fmt.Printf("Mapped Sectors: %d\n", status.MappedSectors)

-		fmt.Printf("Highest Mapped Sector: %d\n", status.HighestMappedSector)

-	case "resize":

-		if flag.NArg() < 2 {

-			usage()

-		}

-

-		size, err := byteSizeFromString(args[1])

-		if err != nil {

-			fmt.Println("Invalid size: ", err)

-			os.Exit(1)

-		}

-

-		err = devices.ResizePool(size)

-		if err != nil {

-			fmt.Println("Error resizing pool: ", err)

-			os.Exit(1)

-		}

-

-	case "snap":

-		if flag.NArg() < 3 {

-			usage()

-		}

-

-		err := devices.AddDevice(args[1], args[2], nil)

-		if err != nil {

-			fmt.Println("Can't create snap device: ", err)

-			os.Exit(1)

-		}

-	case "remove":

-		if flag.NArg() < 2 {

-			usage()

-		}

-

-		err := devicemapper.RemoveDevice(args[1])

-		if err != nil {

-			fmt.Println("Can't remove device: ", err)

-			os.Exit(1)

-		}

-	case "mount":

-		if flag.NArg() < 3 {

-			usage()

-		}

-

-		err := devices.MountDevice(args[1], args[2], "")

-		if err != nil {

-			fmt.Println("Can't mount device: ", err)

-			os.Exit(1)

-		}

-	default:

-		fmt.Printf("Unknown command %s\n", args[0])

-		usage()

-

-		os.Exit(1)

-	}

-}

deleted file mode 100644

@@ -1,4 +0,0 @@

-package main

-

-func main() {

-}

deleted file mode 100644

@@ -1,98 +0,0 @@

-# devicemapper - a storage backend based on Device Mapper

-

-## Theory of operation

-

-The device mapper graphdriver uses the device mapper thin provisioning

-module (dm-thinp) to implement CoW snapshots. The preferred model is

-to have a thin pool reserved outside of Docker and passed to the

-daemon via the `--storage-opt dm.thinpooldev` option. Alternatively,

-the device mapper graphdriver can setup a block device to handle this

-for you via the `--storage-opt dm.directlvm_device` option.

-

-As a fallback if no thin pool is provided, loopback files will be

-created.  Loopback is very slow, but can be used without any

-pre-configuration of storage.  It is strongly recommended that you do

-not use loopback in production.  Ensure your Docker daemon has a

-`--storage-opt dm.thinpooldev` argument provided.

-

-In loopback, a thin pool is created at `/var/lib/docker/devicemapper`

-(devicemapper graph location) based on two block devices, one for

-data and one for metadata. By default these block devices are created

-automatically by using loopback mounts of automatically created sparse

-files.

-

-The default loopback files used are

-`/var/lib/docker/devicemapper/devicemapper/data` and

-`/var/lib/docker/devicemapper/devicemapper/metadata`. Additional metadata

-required to map from docker entities to the corresponding devicemapper

-volumes is stored in the `/var/lib/docker/devicemapper/devicemapper/json`

-file (encoded as Json).

-

-In order to support multiple devicemapper graphs on a system, the thin

-pool will be named something like: `docker-0:33-19478248-pool`, where

-the `0:33` part is the minor/major device nr and `19478248` is the

-inode number of the `/var/lib/docker/devicemapper` directory.

-

-On the thin pool, docker automatically creates a base thin device,

-called something like `docker-0:33-19478248-base` of a fixed

-size. This is automatically formatted with an empty filesystem on

-creation. This device is the base of all docker images and

-containers. All base images are snapshots of this device and those

-images are then in turn used as snapshots for other images and

-eventually containers.

-

-## Information on `docker info`

-

-As of docker-1.4.1, `docker info` when using the `devicemapper` storage driver

-will display something like:

-

-	$ sudo docker info

-	[...]

-	Storage Driver: devicemapper

-	 Pool Name: docker-253:1-17538953-pool

-	 Pool Blocksize: 65.54 kB

-	 Base Device Size: 107.4 GB

-	 Data file: /dev/loop4

-	 Metadata file: /dev/loop4

-	 Data Space Used: 2.536 GB

-	 Data Space Total: 107.4 GB

-	 Data Space Available: 104.8 GB

-	 Metadata Space Used: 7.93 MB

-	 Metadata Space Total: 2.147 GB

-	 Metadata Space Available: 2.14 GB

-	 Udev Sync Supported: true

-	 Data loop file: /home/docker/devicemapper/devicemapper/data

-	 Metadata loop file: /home/docker/devicemapper/devicemapper/metadata

-	 Library Version: 1.02.82-git (2013-10-04)

-	[...]

-

-### status items

-

-Each item in the indented section under `Storage Driver: devicemapper` are

-status information about the driver.

- *  `Pool Name` name of the devicemapper pool for this driver.

- *  `Pool Blocksize` tells the blocksize the thin pool was initialized with. This only changes on creation.

- *  `Base Device Size` tells the maximum size of a container and image

- *  `Data file` blockdevice file used for the devicemapper data

- *  `Metadata file` blockdevice file used for the devicemapper metadata

- *  `Data Space Used` tells how much of `Data file` is currently used

- *  `Data Space Total` tells max size the `Data file`

- *  `Data Space Available` tells how much free space there is in the `Data file`. If you are using a loop device this will report the actual space available to the loop device on the underlying filesystem.

- *  `Metadata Space Used` tells how much of `Metadata file` is currently used

- *  `Metadata Space Total` tells max size the `Metadata file`

- *  `Metadata Space Available` tells how much free space there is in the `Metadata file`. If you are using a loop device this will report the actual space available to the loop device on the underlying filesystem.

- *  `Udev Sync Supported` tells whether devicemapper is able to sync with Udev. Should be `true`.

- *  `Data loop file` file attached to `Data file`, if loopback device is used

- *  `Metadata loop file` file attached to `Metadata file`, if loopback device is used

- *  `Library Version` from the libdevmapper used

-

-## About the devicemapper options

-

-The devicemapper backend supports some options that you can specify

-when starting the docker daemon using the `--storage-opt` flags.

-This uses the `dm` prefix and would be used something like `dockerd --storage-opt dm.foo=bar`.

-

-These options are currently documented both in [the man

-page](../../../man/docker.1.md) and in [the online

-documentation](https://docs.docker.com/engine/reference/commandline/dockerd/#/storage-driver-options).

-If you add an options, update both the `man` page and the documentation.

deleted file mode 100644

@@ -1,230 +0,0 @@

-package devmapper // import "github.com/docker/docker/daemon/graphdriver/devmapper"

-

-import (

-	"bufio"

-	"bytes"

-	"encoding/json"

-	"fmt"

-	"os"

-	"os/exec"

-	"path/filepath"

-	"reflect"

-	"strings"

-

-	"github.com/pkg/errors"

-	"github.com/sirupsen/logrus"

-)

-

-type directLVMConfig struct {

-	Device              string

-	ThinpPercent        uint64

-	ThinpMetaPercent    uint64

-	AutoExtendPercent   uint64

-	AutoExtendThreshold uint64

-}

-

-var (

-	errThinpPercentMissing = errors.New("must set both `dm.thinp_percent` and `dm.thinp_metapercent` if either is specified")

-	errThinpPercentTooBig  = errors.New("combined `dm.thinp_percent` and `dm.thinp_metapercent` must not be greater than 100")

-	errMissingSetupDevice  = errors.New("must provide device path in `dm.directlvm_device` in order to configure direct-lvm")

-)

-

-func validateLVMConfig(cfg directLVMConfig) error {

-	if reflect.DeepEqual(cfg, directLVMConfig{}) {

-		return nil

-	}

-	if cfg.Device == "" {

-		return errMissingSetupDevice

-	}

-	if (cfg.ThinpPercent > 0 && cfg.ThinpMetaPercent == 0) || cfg.ThinpMetaPercent > 0 && cfg.ThinpPercent == 0 {

-		return errThinpPercentMissing

-	}

-

-	if cfg.ThinpPercent+cfg.ThinpMetaPercent > 100 {

-		return errThinpPercentTooBig

-	}

-	return nil

-}

-

-func checkDevAvailable(dev string) error {

-	lvmScan, err := exec.LookPath("lvmdiskscan")

-	if err != nil {

-		logrus.Debug("could not find lvmdiskscan")

-		return nil

-	}

-

-	out, err := exec.Command(lvmScan).CombinedOutput()

-	if err != nil {

-		logrus.WithError(err).Error(string(out))

-		return nil

-	}

-

-	if !bytes.Contains(out, []byte(dev)) {

-		return errors.Errorf("%s is not available for use with devicemapper", dev)

-	}

-	return nil

-}

-

-func checkDevInVG(dev string) error {

-	pvDisplay, err := exec.LookPath("pvdisplay")

-	if err != nil {

-		logrus.Debug("could not find pvdisplay")

-		return nil

-	}

-

-	out, err := exec.Command(pvDisplay, dev).CombinedOutput()

-	if err != nil {

-		logrus.WithError(err).Error(string(out))

-		return nil

-	}

-

-	scanner := bufio.NewScanner(bytes.NewReader(bytes.TrimSpace(out)))

-	for scanner.Scan() {

-		fields := strings.SplitAfter(strings.TrimSpace(scanner.Text()), "VG Name")

-		if len(fields) > 1 {

-			// got "VG Name" line"

-			vg := strings.TrimSpace(fields[1])

-			if len(vg) > 0 {

-				return errors.Errorf("%s is already part of a volume group %q: must remove this device from any volume group or provide a different device", dev, vg)

-			}

-			logrus.Error(fields)

-			break

-		}

-	}

-	return nil

-}

-

-func checkDevHasFS(dev string) error {

-	blkid, err := exec.LookPath("blkid")

-	if err != nil {

-		logrus.Debug("could not find blkid")

-		return nil

-	}

-

-	out, err := exec.Command(blkid, dev).CombinedOutput()

-	if err != nil {

-		logrus.WithError(err).Error(string(out))

-		return nil

-	}

-

-	fields := bytes.Fields(out)

-	for _, f := range fields {

-		kv := bytes.Split(f, []byte{'='})

-		if bytes.Equal(kv[0], []byte("TYPE")) {

-			v := bytes.Trim(kv[1], "\"")

-			if len(v) > 0 {

-				return errors.Errorf("%s has a filesystem already, use dm.directlvm_device_force=true if you want to wipe the device", dev)

-			}

-			return nil

-		}

-	}

-	return nil

-}

-

-func verifyBlockDevice(dev string, force bool) error {

-	if err := checkDevAvailable(dev); err != nil {

-		return err

-	}

-	if err := checkDevInVG(dev); err != nil {

-		return err

-	}

-	if force {

-		return nil

-	}

-	return checkDevHasFS(dev)

-}

-

-func readLVMConfig(root string) (directLVMConfig, error) {

-	var cfg directLVMConfig

-

-	p := filepath.Join(root, "setup-config.json")

-	b, err := os.ReadFile(p)

-	if err != nil {

-		if os.IsNotExist(err) {

-			return cfg, nil

-		}

-		return cfg, errors.Wrap(err, "error reading existing setup config")

-	}

-

-	// check if this is just an empty file, no need to produce a json error later if so

-	if len(b) == 0 {

-		return cfg, nil

-	}

-

-	err = json.Unmarshal(b, &cfg)

-	return cfg, errors.Wrap(err, "error unmarshaling previous device setup config")

-}

-

-func writeLVMConfig(root string, cfg directLVMConfig) error {

-	p := filepath.Join(root, "setup-config.json")

-	b, err := json.Marshal(cfg)

-	if err != nil {

-		return errors.Wrap(err, "error marshalling direct lvm config")

-	}

-	err = os.WriteFile(p, b, 0600)

-	return errors.Wrap(err, "error writing direct lvm config to file")

-}

-

-func setupDirectLVM(cfg directLVMConfig) error {

-	lvmProfileDir := "/etc/lvm/profile"

-	binaries := []string{"pvcreate", "vgcreate", "lvcreate", "lvconvert", "lvchange", "thin_check"}

-

-	for _, bin := range binaries {

-		if _, err := exec.LookPath(bin); err != nil {

-			return errors.Wrap(err, "error looking up command `"+bin+"` while setting up direct lvm")

-		}

-	}

-

-	err := os.MkdirAll(lvmProfileDir, 0755)

-	if err != nil {

-		return errors.Wrap(err, "error creating lvm profile directory")

-	}

-

-	if cfg.AutoExtendPercent == 0 {

-		cfg.AutoExtendPercent = 20

-	}

-

-	if cfg.AutoExtendThreshold == 0 {

-		cfg.AutoExtendThreshold = 80

-	}

-

-	if cfg.ThinpPercent == 0 {

-		cfg.ThinpPercent = 95

-	}

-	if cfg.ThinpMetaPercent == 0 {

-		cfg.ThinpMetaPercent = 1

-	}

-

-	out, err := exec.Command("pvcreate", "-f", cfg.Device).CombinedOutput()

-	if err != nil {

-		return errors.Wrap(err, string(out))

-	}

-

-	out, err = exec.Command("vgcreate", "docker", cfg.Device).CombinedOutput()

-	if err != nil {

-		return errors.Wrap(err, string(out))

-	}

-

-	out, err = exec.Command("lvcreate", "--wipesignatures", "y", "-n", "thinpool", "docker", "--extents", fmt.Sprintf("%d%%VG", cfg.ThinpPercent)).CombinedOutput()

-	if err != nil {

-		return errors.Wrap(err, string(out))

-	}

-	out, err = exec.Command("lvcreate", "--wipesignatures", "y", "-n", "thinpoolmeta", "docker", "--extents", fmt.Sprintf("%d%%VG", cfg.ThinpMetaPercent)).CombinedOutput()

-	if err != nil {

-		return errors.Wrap(err, string(out))

-	}

-

-	out, err = exec.Command("lvconvert", "-y", "--zero", "n", "-c", "512K", "--thinpool", "docker/thinpool", "--poolmetadata", "docker/thinpoolmeta").CombinedOutput()

-	if err != nil {

-		return errors.Wrap(err, string(out))

-	}

-

-	profile := fmt.Sprintf("activation{\nthin_pool_autoextend_threshold=%d\nthin_pool_autoextend_percent=%d\n}", cfg.AutoExtendThreshold, cfg.AutoExtendPercent)

-	err = os.WriteFile(lvmProfileDir+"/docker-thinpool.profile", []byte(profile), 0600)

-	if err != nil {

-		return errors.Wrap(err, "error writing docker thinp autoextend profile")

-	}

-

-	out, err = exec.Command("lvchange", "--metadataprofile", "docker-thinpool", "docker/thinpool").CombinedOutput()

-	return errors.Wrap(err, string(out))

-}

deleted file mode 100644

@@ -1,2811 +0,0 @@

-//go:build linux

-// +build linux

-

-package devmapper // import "github.com/docker/docker/daemon/graphdriver/devmapper"

-

-import (

-	"bufio"

-	"encoding/json"

-	"fmt"

-	"io"

-	"os"

-	"os/exec"

-	"path"

-	"path/filepath"

-	"reflect"

-	"strconv"

-	"strings"

-	"sync"

-	"time"

-

-	"github.com/docker/docker/daemon/graphdriver"

-	"github.com/docker/docker/pkg/devicemapper"

-	"github.com/docker/docker/pkg/dmesg"

-	"github.com/docker/docker/pkg/idtools"

-	"github.com/docker/docker/pkg/loopback"

-	"github.com/docker/docker/pkg/parsers"

-	"github.com/docker/docker/pkg/parsers/kernel"

-	units "github.com/docker/go-units"

-	"github.com/moby/sys/mount"

-	"github.com/opencontainers/selinux/go-selinux/label"

-	"github.com/pkg/errors"

-	"github.com/sirupsen/logrus"

-	"golang.org/x/sys/unix"

-)

-

-var (

-	defaultDataLoopbackSize      int64  = 100 * 1024 * 1024 * 1024

-	defaultMetaDataLoopbackSize  int64  = 2 * 1024 * 1024 * 1024

-	defaultBaseFsSize            uint64 = 10 * 1024 * 1024 * 1024

-	defaultThinpBlockSize        uint32 = 128 // 64K = 128 512b sectors

-	defaultUdevSyncOverride             = false

-	maxDeviceID                         = 0xffffff // 24 bit, pool limit

-	deviceIDMapSz                       = (maxDeviceID + 1) / 8

-	driverDeferredRemovalSupport        = false

-	enableDeferredRemoval               = false

-	enableDeferredDeletion              = false

-	userBaseSize                        = false

-	defaultMinFreeSpacePercent   uint32 = 10

-	lvmSetupConfigForce          bool

-)

-

-const deviceSetMetaFile = "deviceset-metadata"

-const transactionMetaFile = "transaction-metadata"

-

-type transaction struct {

-	OpenTransactionID uint64 `json:"open_transaction_id"`

-	DeviceIDHash      string `json:"device_hash"`

-	DeviceID          int    `json:"device_id"`

-}

-

-type devInfo struct {

-	Hash          string `json:"-"`

-	DeviceID      int    `json:"device_id"`

-	Size          uint64 `json:"size"`

-	TransactionID uint64 `json:"transaction_id"`

-	Initialized   bool   `json:"initialized"`

-	Deleted       bool   `json:"deleted"`

-	devices       *DeviceSet

-

-	// The global DeviceSet lock guarantees that we serialize all

-	// the calls to libdevmapper (which is not threadsafe), but we

-	// sometimes release that lock while sleeping. In that case

-	// this per-device lock is still held, protecting against

-	// other accesses to the device that we're doing the wait on.

-	//

-	// WARNING: In order to avoid AB-BA deadlocks when releasing

-	// the global lock while holding the per-device locks all

-	// device locks must be acquired *before* the device lock, and

-	// multiple device locks should be acquired parent before child.

-	lock sync.Mutex

-}

-

-type metaData struct {

-	Devices map[string]*devInfo `json:"Devices"`

-}

-

-// DeviceSet holds information about list of devices

-type DeviceSet struct {

-	metaData      `json:"-"`

-	sync.Mutex    `json:"-"` // Protects all fields of DeviceSet and serializes calls into libdevmapper

-	root          string

-	devicePrefix  string

-	TransactionID uint64 `json:"-"`

-	NextDeviceID  int    `json:"next_device_id"`

-	deviceIDMap   []byte

-

-	// Options

-	dataLoopbackSize      int64

-	metaDataLoopbackSize  int64

-	baseFsSize            uint64

-	filesystem            string

-	mountOptions          string

-	mkfsArgs              []string

-	dataDevice            string // block or loop dev

-	dataLoopFile          string // loopback file, if used

-	metadataDevice        string // block or loop dev

-	metadataLoopFile      string // loopback file, if used

-	doBlkDiscard          bool

-	thinpBlockSize        uint32

-	thinPoolDevice        string

-	transaction           `json:"-"`

-	overrideUdevSyncCheck bool

-	deferredRemove        bool   // use deferred removal

-	deferredDelete        bool   // use deferred deletion

-	BaseDeviceUUID        string // save UUID of base device

-	BaseDeviceFilesystem  string // save filesystem of base device

-	nrDeletedDevices      uint   // number of deleted devices

-	deletionWorkerTicker  *time.Ticker

-	idMap                 idtools.IdentityMapping

-	minFreeSpacePercent   uint32 // min free space percentage in thinpool

-	xfsNospaceRetries     string // max retries when xfs receives ENOSPC

-	lvmSetupConfig        directLVMConfig

-}

-

-// DiskUsage contains information about disk usage and is used when reporting Status of a device.

-type DiskUsage struct {

-	// Used bytes on the disk.

-	Used uint64

-	// Total bytes on the disk.

-	Total uint64

-	// Available bytes on the disk.

-	Available uint64

-}

-

-// Status returns the information about the device.

-type Status struct {

-	// PoolName is the name of the data pool.

-	PoolName string

-	// DataFile is the actual block device for data.

-	DataFile string

-	// DataLoopback loopback file, if used.

-	DataLoopback string

-	// MetadataFile is the actual block device for metadata.

-	MetadataFile string

-	// MetadataLoopback is the loopback file, if used.

-	MetadataLoopback string

-	// Data is the disk used for data.

-	Data DiskUsage

-	// Metadata is the disk used for meta data.

-	Metadata DiskUsage

-	// BaseDeviceSize is base size of container and image

-	BaseDeviceSize uint64

-	// BaseDeviceFS is backing filesystem.

-	BaseDeviceFS string

-	// SectorSize size of the vector.

-	SectorSize uint64

-	// UdevSyncSupported is true if sync is supported.

-	UdevSyncSupported bool

-	// DeferredRemoveEnabled is true then the device is not unmounted.

-	DeferredRemoveEnabled bool

-	// True if deferred deletion is enabled. This is different from

-	// deferred removal. "removal" means that device mapper device is

-	// deactivated. Thin device is still in thin pool and can be activated

-	// again. But "deletion" means that thin device will be deleted from

-	// thin pool and it can't be activated again.

-	DeferredDeleteEnabled      bool

-	DeferredDeletedDeviceCount uint

-	MinFreeSpace               uint64

-}

-

-// Structure used to export image/container metadata in docker inspect.

-type deviceMetadata struct {

-	deviceID   int

-	deviceSize uint64 // size in bytes

-	deviceName string // Device name as used during activation

-}

-

-// DevStatus returns information about device mounted containing its id, size and sector information.

-type DevStatus struct {

-	// DeviceID is the id of the device.

-	DeviceID int

-	// Size is the size of the filesystem.

-	Size uint64

-	// TransactionID is a unique integer per device set used to identify an operation on the file system, this number is incremental.

-	TransactionID uint64

-	// SizeInSectors indicates the size of the sectors allocated.

-	SizeInSectors uint64

-	// MappedSectors indicates number of mapped sectors.

-	MappedSectors uint64

-	// HighestMappedSector is the pointer to the highest mapped sector.

-	HighestMappedSector uint64

-}

-

-func getDevName(name string) string {

-	return "/dev/mapper/" + name

-}

-

-func (info *devInfo) Name() string {

-	hash := info.Hash

-	if hash == "" {

-		hash = "base"

-	}

-	return fmt.Sprintf("%s-%s", info.devices.devicePrefix, hash)

-}

-

-func (info *devInfo) DevName() string {

-	return getDevName(info.Name())

-}

-

-func (devices *DeviceSet) loopbackDir() string {

-	return path.Join(devices.root, "devicemapper")

-}

-

-func (devices *DeviceSet) metadataDir() string {

-	return path.Join(devices.root, "metadata")

-}

-

-func (devices *DeviceSet) metadataFile(info *devInfo) string {

-	file := info.Hash

-	if file == "" {

-		file = "base"

-	}

-	return path.Join(devices.metadataDir(), file)

-}

-

-func (devices *DeviceSet) transactionMetaFile() string {

-	return path.Join(devices.metadataDir(), transactionMetaFile)

-}

-

-func (devices *DeviceSet) deviceSetMetaFile() string {

-	return path.Join(devices.metadataDir(), deviceSetMetaFile)

-}

-

-func (devices *DeviceSet) oldMetadataFile() string {

-	return path.Join(devices.loopbackDir(), "json")

-}

-

-func (devices *DeviceSet) getPoolName() string {

-	if devices.thinPoolDevice == "" {

-		return devices.devicePrefix + "-pool"

-	}

-	return devices.thinPoolDevice

-}

-

-func (devices *DeviceSet) getPoolDevName() string {

-	return getDevName(devices.getPoolName())

-}

-

-func (devices *DeviceSet) hasImage(name string) bool {

-	dirname := devices.loopbackDir()

-	filename := path.Join(dirname, name)

-

-	_, err := os.Stat(filename)

-	return err == nil

-}

-

-// ensureImage creates a sparse file of <size> bytes at the path

-// <root>/devicemapper/<name>.

-// If the file already exists and new size is larger than its current size, it grows to the new size.

-// Either way it returns the full path.

-func (devices *DeviceSet) ensureImage(name string, size int64) (string, error) {

-	dirname := devices.loopbackDir()

-	filename := path.Join(dirname, name)

-

-	if err := idtools.MkdirAllAndChown(dirname, 0700, devices.idMap.RootPair()); err != nil {

-		return "", err

-	}

-

-	if fi, err := os.Stat(filename); err != nil {

-		if !os.IsNotExist(err) {

-			return "", err

-		}

-		logrus.WithField("storage-driver", "devicemapper").Debugf("Creating loopback file %s for device-manage use", filename)

-		file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0600)

-		if err != nil {

-			return "", err

-		}

-		defer file.Close()

-

-		if err := file.Truncate(size); err != nil {

-			return "", err

-		}

-	} else {