docker: github.com/docker/docker/daemon/graphdriver Index | Files | Directories

package graphdriver

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

Index

Package Files

counter.go driver.go driver_linux.go errors.go fsdiff.go plugin.go proxy.go

Constants

const (
    // FsMagicAufs filesystem id for Aufs
    FsMagicAufs = FsMagic(0x61756673)
    // FsMagicBtrfs filesystem id for Btrfs
    FsMagicBtrfs = FsMagic(0x9123683E)
    // FsMagicCramfs filesystem id for Cramfs
    FsMagicCramfs = FsMagic(0x28cd3d45)
    // FsMagicEcryptfs filesystem id for eCryptfs
    FsMagicEcryptfs = FsMagic(0xf15f)
    // FsMagicExtfs filesystem id for Extfs
    FsMagicExtfs = FsMagic(0x0000EF53)
    // FsMagicF2fs filesystem id for F2fs
    FsMagicF2fs = FsMagic(0xF2F52010)
    // FsMagicGPFS filesystem id for GPFS
    FsMagicGPFS = FsMagic(0x47504653)
    // FsMagicJffs2Fs filesystem if for Jffs2Fs
    FsMagicJffs2Fs = FsMagic(0x000072b6)
    // FsMagicJfs filesystem id for Jfs
    FsMagicJfs = FsMagic(0x3153464a)
    // FsMagicNfsFs filesystem id for NfsFs
    FsMagicNfsFs = FsMagic(0x00006969)
    // FsMagicRAMFs filesystem id for RamFs
    FsMagicRAMFs = FsMagic(0x858458f6)
    // FsMagicReiserFs filesystem id for ReiserFs
    FsMagicReiserFs = FsMagic(0x52654973)
    // FsMagicSmbFs filesystem id for SmbFs
    FsMagicSmbFs = FsMagic(0x0000517B)
    // FsMagicSquashFs filesystem id for SquashFs
    FsMagicSquashFs = FsMagic(0x73717368)
    // FsMagicTmpFs filesystem id for TmpFs
    FsMagicTmpFs = FsMagic(0x01021994)
    // FsMagicVxFS filesystem id for VxFs
    FsMagicVxFS = FsMagic(0xa501fcf5)
    // FsMagicXfs filesystem id for Xfs
    FsMagicXfs = FsMagic(0x58465342)
    // FsMagicZfs filesystem id for Zfs
    FsMagicZfs = FsMagic(0x2fc12fc1)
    // FsMagicOverlay filesystem id for overlay
    FsMagicOverlay = FsMagic(0x794C7630)
    // FsMagicFUSE filesystem id for FUSE
    FsMagicFUSE = FsMagic(0x65735546)
)
const (
    // FsMagicUnsupported is a predefined constant value other than a valid filesystem id.
    FsMagicUnsupported = FsMagic(0x00000000)
)

Variables

var (
    // ApplyUncompressedLayer defines the unpack method used by the graph
    // driver.
    ApplyUncompressedLayer = chrootarchive.ApplyUncompressedLayer
)
var (

    // FsNames maps filesystem id to name of the filesystem.
    FsNames = map[FsMagic]string{
        FsMagicAufs:        "aufs",
        FsMagicBtrfs:       "btrfs",
        FsMagicCramfs:      "cramfs",
        FsMagicEcryptfs:    "ecryptfs",
        FsMagicExtfs:       "extfs",
        FsMagicF2fs:        "f2fs",
        FsMagicFUSE:        "fuse",
        FsMagicGPFS:        "gpfs",
        FsMagicJffs2Fs:     "jffs2",
        FsMagicJfs:         "jfs",
        FsMagicNfsFs:       "nfs",
        FsMagicOverlay:     "overlayfs",
        FsMagicRAMFs:       "ramfs",
        FsMagicReiserFs:    "reiserfs",
        FsMagicSmbFs:       "smb",
        FsMagicSquashFs:    "squashfs",
        FsMagicTmpFs:       "tmpfs",
        FsMagicUnsupported: "unsupported",
        FsMagicVxFS:        "vxfs",
        FsMagicXfs:         "xfs",
        FsMagicZfs:         "zfs",
    }
)

func IsDriverNotSupported Uses

func IsDriverNotSupported(err error) bool

IsDriverNotSupported returns true if the error initializing the graph driver is a non-supported error.

func IsInitialized Uses

func IsInitialized(driverHome string) bool

IsInitialized checks if the driver's home-directory exists and is non-empty.

func Mounted Uses

func Mounted(fsType FsMagic, mountPath string) (bool, error)

Mounted checks if the given path is mounted as the fs type

func Register Uses

func Register(name string, initFunc InitFunc) error

Register registers an InitFunc for the driver.

type Capabilities Uses

type Capabilities struct {
    // Flags that this driver is capable of reproducing exactly equivalent
    // diffs for read-only layers. If set, clients can rely on the driver
    // for consistent tar streams, and avoid extra processing to account
    // for potential differences (eg: the layer store's use of tar-split).
    ReproducesExactDiffs bool
}

Capabilities defines a list of capabilities a driver may implement. These capabilities are not required; however, they do determine how a graphdriver can be used.

type CapabilityDriver Uses

type CapabilityDriver interface {
    Capabilities() Capabilities
}

CapabilityDriver is the interface for layered file system drivers that can report on their Capabilities.

type Checker Uses

type Checker interface {
    // IsMounted returns true if the provided path is mounted for the specific checker
    IsMounted(path string) bool
}

Checker makes checks on specified filesystems.

func NewDefaultChecker Uses

func NewDefaultChecker() Checker

NewDefaultChecker returns a check that parses /proc/mountinfo to check if the specified path is mounted.

func NewFsChecker Uses

func NewFsChecker(t FsMagic) Checker

NewFsChecker returns a checker configured for the provided FsMagic

type CreateOpts Uses

type CreateOpts struct {
    MountLabel string
    StorageOpt map[string]string
}

CreateOpts contains optional arguments for Create() and CreateReadWrite() methods.

type DiffDriver Uses

type DiffDriver interface {
    // Diff produces an archive of the changes between the specified
    // layer and its parent layer which may be "".
    Diff(id, parent string) (io.ReadCloser, error)
    // Changes produces a list of changes between the specified layer
    // and its parent layer. If parent is "", then all changes will be ADD changes.
    Changes(id, parent string) ([]archive.Change, error)
    // ApplyDiff extracts the changeset from the given diff into the
    // layer with the specified id and parent, returning the size of the
    // new layer in bytes.
    // The archive.Reader must be an uncompressed stream.
    ApplyDiff(id, parent string, diff io.Reader) (size int64, err error)
    // DiffSize calculates the changes between the specified id
    // and its parent and returns the size in bytes of the changes
    // relative to its base filesystem directory.
    DiffSize(id, parent string) (size int64, err error)
}

DiffDriver is the interface to use to implement graph diffs

type DiffGetterDriver Uses

type DiffGetterDriver interface {
    Driver
    // DiffGetter returns an interface to efficiently retrieve the contents
    // of files in a layer.
    DiffGetter(id string) (FileGetCloser, error)
}

DiffGetterDriver is the interface for layered file system drivers that provide a specialized function for getting file contents for tar-split.

type Driver Uses

type Driver interface {
    ProtoDriver
    DiffDriver
}

Driver is the interface for layered/snapshot file system drivers.

func GetDriver Uses

func GetDriver(name string, pg plugingetter.PluginGetter, config Options) (Driver, error)

GetDriver initializes and returns the registered driver

func New Uses

func New(name string, pg plugingetter.PluginGetter, config Options) (Driver, error)

New creates the driver and initializes it at the specified root.

func NewNaiveDiffDriver Uses

func NewNaiveDiffDriver(driver ProtoDriver, uidMaps, gidMaps []idtools.IDMap) Driver

NewNaiveDiffDriver returns a fully functional driver that wraps the given ProtoDriver and adds the capability of the following methods which it may or may not support on its own:

Diff(id, parent string) (archive.Archive, error)
Changes(id, parent string) ([]archive.Change, error)
ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error)
DiffSize(id, parent string) (size int64, err error)

type ErrUnSupported Uses

type ErrUnSupported interface {
    NotSupported()
}

ErrUnSupported signals that the graph-driver is not supported on the current configuration

type FileGetCloser Uses

type FileGetCloser interface {
    storage.FileGetter
    // Close cleans up any resources associated with the FileGetCloser.
    Close() error
}

FileGetCloser extends the storage.FileGetter interface with a Close method for cleaning up.

type FsMagic Uses

type FsMagic uint32

FsMagic unsigned id of the filesystem in use.

func GetFSMagic Uses

func GetFSMagic(rootpath string) (FsMagic, error)

GetFSMagic returns the filesystem id given the path.

type InitFunc Uses

type InitFunc func(root string, options []string, uidMaps, gidMaps []idtools.IDMap) (Driver, error)

InitFunc initializes the storage driver.

type NaiveDiffDriver Uses

type NaiveDiffDriver struct {
    ProtoDriver
    // contains filtered or unexported fields
}

NaiveDiffDriver takes a ProtoDriver and adds the capability of the Diffing methods on the local file system, which it may or may not support on its own. See the comment on the exported NewNaiveDiffDriver function below. Notably, the AUFS driver doesn't need to be wrapped like this.

func (*NaiveDiffDriver) ApplyDiff Uses

func (gdw *NaiveDiffDriver) ApplyDiff(id, parent string, diff io.Reader) (size int64, err error)

ApplyDiff extracts the changeset from the given diff into the layer with the specified id and parent, returning the size of the new layer in bytes.

func (*NaiveDiffDriver) Changes Uses

func (gdw *NaiveDiffDriver) Changes(id, parent string) ([]archive.Change, error)

Changes produces a list of changes between the specified layer and its parent layer. If parent is "", then all changes will be ADD changes.

func (*NaiveDiffDriver) Diff Uses

func (gdw *NaiveDiffDriver) Diff(id, parent string) (arch io.ReadCloser, err error)

Diff produces an archive of the changes between the specified layer and its parent layer which may be "".

func (*NaiveDiffDriver) DiffSize Uses

func (gdw *NaiveDiffDriver) DiffSize(id, parent string) (size int64, err error)

DiffSize calculates the changes between the specified layer and its parent and returns the size in bytes of the changes relative to its base filesystem directory.

type NotSupportedError Uses

type NotSupportedError string

NotSupportedError signals that the graph-driver is not supported on the current configuration

const (
    // ErrNotSupported returned when driver is not supported.
    ErrNotSupported NotSupportedError = "driver not supported"
    // ErrPrerequisites returned when driver does not meet prerequisites.
    ErrPrerequisites NotSupportedError = "prerequisites for driver not satisfied (wrong filesystem?)"
    // ErrIncompatibleFS returned when file system is not supported.
    ErrIncompatibleFS NotSupportedError = "backing file system is unsupported for this graph driver"
)

func (NotSupportedError) Error Uses

func (e NotSupportedError) Error() string

func (NotSupportedError) NotSupported Uses

func (e NotSupportedError) NotSupported()

NotSupported signals that a graph-driver is not supported.

type Options Uses

type Options struct {
    Root                string
    DriverOptions       []string
    UIDMaps             []idtools.IDMap
    GIDMaps             []idtools.IDMap
    ExperimentalEnabled bool
}

Options is used to initialize a graphdriver

type ProtoDriver Uses

type ProtoDriver interface {
    // String returns a string representation of this driver.
    String() string
    // CreateReadWrite creates a new, empty filesystem layer that is ready
    // to be used as the storage for a container. Additional options can
    // be passed in opts. parent may be "" and opts may be nil.
    CreateReadWrite(id, parent string, opts *CreateOpts) error
    // Create creates a new, empty, filesystem layer with the
    // specified id and parent and options passed in opts. Parent
    // may be "" and opts may be nil.
    Create(id, parent string, opts *CreateOpts) error
    // Remove attempts to remove the filesystem layer with this id.
    Remove(id string) error
    // Get returns the mountpoint for the layered filesystem referred
    // to by this id. You can optionally specify a mountLabel or "".
    // Returns the absolute path to the mounted layered filesystem.
    Get(id, mountLabel string) (fs containerfs.ContainerFS, err error)
    // Put releases the system resources for the specified id,
    // e.g, unmounting layered filesystem.
    Put(id string) error
    // Exists returns whether a filesystem layer with the specified
    // ID exists on this driver.
    Exists(id string) bool
    // Status returns a set of key-value pairs which give low
    // level diagnostic status about this driver.
    Status() [][2]string
    // Returns a set of key-value pairs which give low level information
    // about the image/container driver is managing.
    GetMetadata(id string) (map[string]string, error)
    // Cleanup performs necessary tasks to release resources
    // held by the driver, e.g., unmounting all layered filesystems
    // known to this driver.
    Cleanup() error
}

ProtoDriver defines the basic capabilities of a driver. This interface exists solely to be a minimum set of methods for client code which choose not to implement the entire Driver interface and use the NaiveDiffDriver wrapper constructor.

Use of ProtoDriver directly by client code is not recommended.

type RefCounter Uses

type RefCounter struct {
    // contains filtered or unexported fields
}

RefCounter is a generic counter for use by graphdriver Get/Put calls

func NewRefCounter Uses

func NewRefCounter(c Checker) *RefCounter

NewRefCounter returns a new RefCounter

func (*RefCounter) Decrement Uses

func (c *RefCounter) Decrement(path string) int

Decrement decreases the ref count for the given id and returns the current count

func (*RefCounter) Increment Uses

func (c *RefCounter) Increment(path string) int

Increment increases the ref count for the given id and returns the current count

Directories

PathSynopsis
aufs
btrfs
copy
devmapper
fuse-overlayfs
graphtest
lcow
overlay
overlay2
overlayutils
register
vfs
windows
zfs

Package graphdriver imports 22 packages (graph) and is imported by 7902 packages. Updated 2021-01-27. Refresh now. Tools for package owners.