volume/linux_parser.go - third_party/github.com/moby/moby - Git at Google

 package volume

 import (
 	"errors"
 	"fmt"
 	"path"
 	"path/filepath"
 	"strings"

 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/pkg/stringid"
 )

 type linuxParser struct {
 }

 func linuxSplitRawSpec(raw string) ([]string, error) {
 	if strings.Count(raw, ":") > 2 {
 		return nil, errInvalidSpec(raw)
 	}

 	arr := strings.SplitN(raw, ":", 3)
 	if arr[0] == "" {
 		return nil, errInvalidSpec(raw)
 	}
 	return arr, nil
 }

 func linuxValidateNotRoot(p string) error {
 	p = path.Clean(strings.Replace(p, `\`, `/`, -1))
 	if p == "/" {
 		return fmt.Errorf("invalid specification: destination can't be '/'")
 	}
 	return nil
 }
 func linuxValidateAbsolute(p string) error {
 	p = strings.Replace(p, `\`, `/`, -1)
 	if path.IsAbs(p) {
 		return nil
 	}
 	return fmt.Errorf("invalid mount path: '%s' mount path must be absolute", p)
 }
 func (p *linuxParser) ValidateMountConfig(mnt *mount.Mount) error {
 	// there was something looking like a bug in existing codebase:
 	// - validateMountConfig on linux was called with options skipping bind source existence when calling ParseMountRaw
 	// - but not when calling ParseMountSpec directly... nor when the unit test called it directly
 	return p.validateMountConfigImpl(mnt, true)
 }
 func (p *linuxParser) validateMountConfigImpl(mnt *mount.Mount, validateBindSourceExists bool) error {
 	if len(mnt.Target) == 0 {
 		return &errMountConfig{mnt, errMissingField("Target")}
 	}

 	if err := linuxValidateNotRoot(mnt.Target); err != nil {
 		return &errMountConfig{mnt, err}
 	}

 	if err := linuxValidateAbsolute(mnt.Target); err != nil {
 		return &errMountConfig{mnt, err}
 	}

 	switch mnt.Type {
 	case mount.TypeBind:
 		if len(mnt.Source) == 0 {
 			return &errMountConfig{mnt, errMissingField("Source")}
 		}
 		// Don't error out just because the propagation mode is not supported on the platform
 		if opts := mnt.BindOptions; opts != nil {
 			if len(opts.Propagation) > 0 && len(linuxPropagationModes) > 0 {
 				if _, ok := linuxPropagationModes[opts.Propagation]; !ok {
 					return &errMountConfig{mnt, fmt.Errorf("invalid propagation mode: %s", opts.Propagation)}
 				}
 			}
 		}
 		if mnt.VolumeOptions != nil {
 			return &errMountConfig{mnt, errExtraField("VolumeOptions")}
 		}

 		if err := linuxValidateAbsolute(mnt.Source); err != nil {
 			return &errMountConfig{mnt, err}
 		}

 		if validateBindSourceExists {
 			exists, _, _ := currentFileInfoProvider.fileInfo(mnt.Source)
 			if !exists {
 				return &errMountConfig{mnt, errBindNotExist}
 			}
 		}

 	case mount.TypeVolume:
 		if mnt.BindOptions != nil {
 			return &errMountConfig{mnt, errExtraField("BindOptions")}
 		}

 		if len(mnt.Source) == 0 && mnt.ReadOnly {
 			return &errMountConfig{mnt, fmt.Errorf("must not set ReadOnly mode when using anonymous volumes")}
 		}
 	case mount.TypeTmpfs:
 		if len(mnt.Source) != 0 {
 			return &errMountConfig{mnt, errExtraField("Source")}
 		}
 		if _, err := p.ConvertTmpfsOptions(mnt.TmpfsOptions, mnt.ReadOnly); err != nil {
 			return &errMountConfig{mnt, err}
 		}
 	default:
 		return &errMountConfig{mnt, errors.New("mount type unknown")}
 	}
 	return nil
 }

 // read-write modes
 var rwModes = map[string]bool{
 	"rw": true,
 	"ro": true,
 }

 // label modes
 var linuxLabelModes = map[string]bool{
 	"Z": true,
 	"z": true,
 }

 // consistency modes
 var linuxConsistencyModes = map[mount.Consistency]bool{
 	mount.ConsistencyFull:      true,
 	mount.ConsistencyCached:    true,
 	mount.ConsistencyDelegated: true,
 }
 var linuxPropagationModes = map[mount.Propagation]bool{
 	mount.PropagationPrivate:  true,
 	mount.PropagationRPrivate: true,
 	mount.PropagationSlave:    true,
 	mount.PropagationRSlave:   true,
 	mount.PropagationShared:   true,
 	mount.PropagationRShared:  true,
 }

 const linuxDefaultPropagationMode = mount.PropagationRPrivate

 func linuxGetPropagation(mode string) mount.Propagation {
 	for _, o := range strings.Split(mode, ",") {
 		prop := mount.Propagation(o)
 		if linuxPropagationModes[prop] {
 			return prop
 		}
 	}
 	return linuxDefaultPropagationMode
 }

 func linuxHasPropagation(mode string) bool {
 	for _, o := range strings.Split(mode, ",") {
 		if linuxPropagationModes[mount.Propagation(o)] {
 			return true
 		}
 	}
 	return false
 }

 func linuxValidMountMode(mode string) bool {
 	if mode == "" {
 		return true
 	}

 	rwModeCount := 0
 	labelModeCount := 0
 	propagationModeCount := 0
 	copyModeCount := 0
 	consistencyModeCount := 0

 	for _, o := range strings.Split(mode, ",") {
 		switch {
 		case rwModes[o]:
 			rwModeCount++
 		case linuxLabelModes[o]:
 			labelModeCount++
 		case linuxPropagationModes[mount.Propagation(o)]:
 			propagationModeCount++
 		case copyModeExists(o):
 			copyModeCount++
 		case linuxConsistencyModes[mount.Consistency(o)]:
 			consistencyModeCount++
 		default:
 			return false
 		}
 	}

 	// Only one string for each mode is allowed.
 	if rwModeCount > 1 || labelModeCount > 1 || propagationModeCount > 1 || copyModeCount > 1 || consistencyModeCount > 1 {
 		return false
 	}
 	return true
 }

 func (p *linuxParser) ReadWrite(mode string) bool {
 	if !linuxValidMountMode(mode) {
 		return false
 	}

 	for _, o := range strings.Split(mode, ",") {
 		if o == "ro" {
 			return false
 		}
 	}
 	return true
 }

 func (p *linuxParser) ParseMountRaw(raw, volumeDriver string) (*MountPoint, error) {
 	arr, err := linuxSplitRawSpec(raw)
 	if err != nil {
 		return nil, err
 	}

 	var spec mount.Mount
 	var mode string
 	switch len(arr) {
 	case 1:
 		// Just a destination path in the container
 		spec.Target = arr[0]
 	case 2:
 		if linuxValidMountMode(arr[1]) {
 			// Destination + Mode is not a valid volume - volumes
 			// cannot include a mode. e.g. /foo:rw
 			return nil, errInvalidSpec(raw)
 		}
 		// Host Source Path or Name + Destination
 		spec.Source = arr[0]
 		spec.Target = arr[1]
 	case 3:
 		// HostSourcePath+DestinationPath+Mode
 		spec.Source = arr[0]
 		spec.Target = arr[1]
 		mode = arr[2]
 	default:
 		return nil, errInvalidSpec(raw)
 	}

 	if !linuxValidMountMode(mode) {
 		return nil, errInvalidMode(mode)
 	}

 	if path.IsAbs(spec.Source) {
 		spec.Type = mount.TypeBind
 	} else {
 		spec.Type = mount.TypeVolume
 	}

 	spec.ReadOnly = !p.ReadWrite(mode)

 	// cannot assume that if a volume driver is passed in that we should set it
 	if volumeDriver != "" && spec.Type == mount.TypeVolume {
 		spec.VolumeOptions = &mount.VolumeOptions{
 			DriverConfig: &mount.Driver{Name: volumeDriver},
 		}
 	}

 	if copyData, isSet := getCopyMode(mode, p.DefaultCopyMode()); isSet {
 		if spec.VolumeOptions == nil {
 			spec.VolumeOptions = &mount.VolumeOptions{}
 		}
 		spec.VolumeOptions.NoCopy = !copyData
 	}
 	if linuxHasPropagation(mode) {
 		spec.BindOptions = &mount.BindOptions{
 			Propagation: linuxGetPropagation(mode),
 		}
 	}

 	mp, err := p.parseMountSpec(spec, false)
 	if mp != nil {
 		mp.Mode = mode
 	}
 	if err != nil {
 		err = fmt.Errorf("%v: %v", errInvalidSpec(raw), err)
 	}
 	return mp, err
 }
 func (p *linuxParser) ParseMountSpec(cfg mount.Mount) (*MountPoint, error) {
 	return p.parseMountSpec(cfg, true)
 }
 func (p *linuxParser) parseMountSpec(cfg mount.Mount, validateBindSourceExists bool) (*MountPoint, error) {
 	if err := p.validateMountConfigImpl(&cfg, validateBindSourceExists); err != nil {
 		return nil, err
 	}
 	mp := &MountPoint{
 		RW:          !cfg.ReadOnly,
 		Destination: path.Clean(filepath.ToSlash(cfg.Target)),
 		Type:        cfg.Type,
 		Spec:        cfg,
 	}

 	switch cfg.Type {
 	case mount.TypeVolume:
 		if cfg.Source == "" {
 			mp.Name = stringid.GenerateNonCryptoID()
 		} else {
 			mp.Name = cfg.Source
 		}
 		mp.CopyData = p.DefaultCopyMode()

 		if cfg.VolumeOptions != nil {
 			if cfg.VolumeOptions.DriverConfig != nil {
 				mp.Driver = cfg.VolumeOptions.DriverConfig.Name
 			}
 			if cfg.VolumeOptions.NoCopy {
 				mp.CopyData = false
 			}
 		}
 	case mount.TypeBind:
 		mp.Source = path.Clean(filepath.ToSlash(cfg.Source))
 		if cfg.BindOptions != nil && len(cfg.BindOptions.Propagation) > 0 {
 			mp.Propagation = cfg.BindOptions.Propagation
 		} else {
 			// If user did not specify a propagation mode, get
 			// default propagation mode.
 			mp.Propagation = linuxDefaultPropagationMode
 		}
 	case mount.TypeTmpfs:
 		// NOP
 	}
 	return mp, nil
 }

 func (p *linuxParser) ParseVolumesFrom(spec string) (string, string, error) {
 	if len(spec) == 0 {
 		return "", "", fmt.Errorf("volumes-from specification cannot be an empty string")
 	}

 	specParts := strings.SplitN(spec, ":", 2)
 	id := specParts[0]
 	mode := "rw"

 	if len(specParts) == 2 {
 		mode = specParts[1]
 		if !linuxValidMountMode(mode) {
 			return "", "", errInvalidMode(mode)
 		}
 		// For now don't allow propagation properties while importing
 		// volumes from data container. These volumes will inherit
 		// the same propagation property as of the original volume
 		// in data container. This probably can be relaxed in future.
 		if linuxHasPropagation(mode) {
 			return "", "", errInvalidMode(mode)
 		}
 		// Do not allow copy modes on volumes-from
 		if _, isSet := getCopyMode(mode, p.DefaultCopyMode()); isSet {
 			return "", "", errInvalidMode(mode)
 		}
 	}
 	return id, mode, nil
 }

 func (p *linuxParser) DefaultPropagationMode() mount.Propagation {
 	return linuxDefaultPropagationMode
 }

 func (p *linuxParser) ConvertTmpfsOptions(opt *mount.TmpfsOptions, readOnly bool) (string, error) {
 	var rawOpts []string
 	if readOnly {
 		rawOpts = append(rawOpts, "ro")
 	}

 	if opt != nil && opt.Mode != 0 {
 		rawOpts = append(rawOpts, fmt.Sprintf("mode=%o", opt.Mode))
 	}

 	if opt != nil && opt.SizeBytes != 0 {
 		// calculate suffix here, making this linux specific, but that is
 		// okay, since API is that way anyways.

 		// we do this by finding the suffix that divides evenly into the
 		// value, returning the value itself, with no suffix, if it fails.
 		//
 		// For the most part, we don't enforce any semantic to this values.
 		// The operating system will usually align this and enforce minimum
 		// and maximums.
 		var (
 			size   = opt.SizeBytes
 			suffix string
 		)
 		for _, r := range []struct {
 			suffix  string
 			divisor int64
 		}{
 			{"g", 1 << 30},
 			{"m", 1 << 20},
 			{"k", 1 << 10},
 		} {
 			if size%r.divisor == 0 {
 				size = size / r.divisor
 				suffix = r.suffix
 				break
 			}
 		}

 		rawOpts = append(rawOpts, fmt.Sprintf("size=%d%s", size, suffix))
 	}
 	return strings.Join(rawOpts, ","), nil
 }

 func (p *linuxParser) DefaultCopyMode() bool {
 	return true
 }
 func (p *linuxParser) ValidateVolumeName(name string) error {
 	return nil
 }

 func (p *linuxParser) IsBackwardCompatible(m *MountPoint) bool {
 	return len(m.Source) > 0 || m.Driver == DefaultDriverName
 }

 func (p *linuxParser) ValidateTmpfsMountDestination(dest string) error {
 	if err := linuxValidateNotRoot(dest); err != nil {
 		return err
 	}
 	return linuxValidateAbsolute(dest)
 }
	package volume

	import (
	"errors"
	"fmt"
	"path"
	"path/filepath"
	"strings"

	"github.com/docker/docker/api/types/mount"
	"github.com/docker/docker/pkg/stringid"
	)

	type linuxParser struct {
	}

	func linuxSplitRawSpec(raw string) ([]string, error) {
	if strings.Count(raw, ":") > 2 {
	return nil, errInvalidSpec(raw)
	}

	arr := strings.SplitN(raw, ":", 3)
	if arr[0] == "" {
	return nil, errInvalidSpec(raw)
	}
	return arr, nil
	}

	func linuxValidateNotRoot(p string) error {
	p = path.Clean(strings.Replace(p, `\`, `/`, -1))
	if p == "/" {
	return fmt.Errorf("invalid specification: destination can't be '/'")
	}
	return nil
	}
	func linuxValidateAbsolute(p string) error {
	p = strings.Replace(p, `\`, `/`, -1)
	if path.IsAbs(p) {
	return nil
	}
	return fmt.Errorf("invalid mount path: '%s' mount path must be absolute", p)
	}
	func (p linuxParser) ValidateMountConfig(mnt mount.Mount) error {
	// there was something looking like a bug in existing codebase:
	// - validateMountConfig on linux was called with options skipping bind source existence when calling ParseMountRaw
	// - but not when calling ParseMountSpec directly... nor when the unit test called it directly
	return p.validateMountConfigImpl(mnt, true)
	}
	func (p linuxParser) validateMountConfigImpl(mnt mount.Mount, validateBindSourceExists bool) error {
	if len(mnt.Target) == 0 {
	return &errMountConfig{mnt, errMissingField("Target")}
	}

	if err := linuxValidateNotRoot(mnt.Target); err != nil {
	return &errMountConfig{mnt, err}
	}

	if err := linuxValidateAbsolute(mnt.Target); err != nil {
	return &errMountConfig{mnt, err}
	}

	switch mnt.Type {
	case mount.TypeBind:
	if len(mnt.Source) == 0 {
	return &errMountConfig{mnt, errMissingField("Source")}
	}
	// Don't error out just because the propagation mode is not supported on the platform
	if opts := mnt.BindOptions; opts != nil {
	if len(opts.Propagation) > 0 && len(linuxPropagationModes) > 0 {
	if _, ok := linuxPropagationModes[opts.Propagation]; !ok {
	return &errMountConfig{mnt, fmt.Errorf("invalid propagation mode: %s", opts.Propagation)}
	}
	}
	}
	if mnt.VolumeOptions != nil {
	return &errMountConfig{mnt, errExtraField("VolumeOptions")}
	}

	if err := linuxValidateAbsolute(mnt.Source); err != nil {
	return &errMountConfig{mnt, err}
	}

	if validateBindSourceExists {
	exists, _, _ := currentFileInfoProvider.fileInfo(mnt.Source)
	if !exists {
	return &errMountConfig{mnt, errBindNotExist}
	}
	}

	case mount.TypeVolume:
	if mnt.BindOptions != nil {
	return &errMountConfig{mnt, errExtraField("BindOptions")}
	}

	if len(mnt.Source) == 0 && mnt.ReadOnly {
	return &errMountConfig{mnt, fmt.Errorf("must not set ReadOnly mode when using anonymous volumes")}
	}
	case mount.TypeTmpfs:
	if len(mnt.Source) != 0 {
	return &errMountConfig{mnt, errExtraField("Source")}
	}
	if _, err := p.ConvertTmpfsOptions(mnt.TmpfsOptions, mnt.ReadOnly); err != nil {
	return &errMountConfig{mnt, err}
	}
	default:
	return &errMountConfig{mnt, errors.New("mount type unknown")}
	}
	return nil
	}

	// read-write modes
	var rwModes = map[string]bool{
	"rw": true,
	"ro": true,
	}

	// label modes
	var linuxLabelModes = map[string]bool{
	"Z": true,
	"z": true,
	}

	// consistency modes
	var linuxConsistencyModes = map[mount.Consistency]bool{
	mount.ConsistencyFull: true,
	mount.ConsistencyCached: true,
	mount.ConsistencyDelegated: true,
	}
	var linuxPropagationModes = map[mount.Propagation]bool{
	mount.PropagationPrivate: true,
	mount.PropagationRPrivate: true,
	mount.PropagationSlave: true,
	mount.PropagationRSlave: true,
	mount.PropagationShared: true,
	mount.PropagationRShared: true,
	}

	const linuxDefaultPropagationMode = mount.PropagationRPrivate

	func linuxGetPropagation(mode string) mount.Propagation {
	for _, o := range strings.Split(mode, ",") {
	prop := mount.Propagation(o)
	if linuxPropagationModes[prop] {
	return prop
	}
	}
	return linuxDefaultPropagationMode
	}

	func linuxHasPropagation(mode string) bool {
	for _, o := range strings.Split(mode, ",") {
	if linuxPropagationModes[mount.Propagation(o)] {
	return true
	}
	}
	return false
	}

	func linuxValidMountMode(mode string) bool {
	if mode == "" {
	return true
	}

	rwModeCount := 0
	labelModeCount := 0
	propagationModeCount := 0
	copyModeCount := 0
	consistencyModeCount := 0

	for _, o := range strings.Split(mode, ",") {
	switch {
	case rwModes[o]:
	rwModeCount++
	case linuxLabelModes[o]:
	labelModeCount++
	case linuxPropagationModes[mount.Propagation(o)]:
	propagationModeCount++
	case copyModeExists(o):
	copyModeCount++
	case linuxConsistencyModes[mount.Consistency(o)]:
	consistencyModeCount++
	default:
	return false
	}
	}

	// Only one string for each mode is allowed.
	if rwModeCount > 1 \|\| labelModeCount > 1 \|\| propagationModeCount > 1 \|\| copyModeCount > 1 \|\| consistencyModeCount > 1 {
	return false
	}
	return true
	}

	func (p *linuxParser) ReadWrite(mode string) bool {
	if !linuxValidMountMode(mode) {
	return false
	}

	for _, o := range strings.Split(mode, ",") {
	if o == "ro" {
	return false
	}
	}
	return true
	}

	func (p linuxParser) ParseMountRaw(raw, volumeDriver string) (MountPoint, error) {
	arr, err := linuxSplitRawSpec(raw)
	if err != nil {
	return nil, err
	}

	var spec mount.Mount
	var mode string
	switch len(arr) {
	case 1:
	// Just a destination path in the container
	spec.Target = arr[0]
	case 2:
	if linuxValidMountMode(arr[1]) {
	// Destination + Mode is not a valid volume - volumes
	// cannot include a mode. e.g. /foo:rw
	return nil, errInvalidSpec(raw)
	}
	// Host Source Path or Name + Destination
	spec.Source = arr[0]
	spec.Target = arr[1]
	case 3:
	// HostSourcePath+DestinationPath+Mode
	spec.Source = arr[0]
	spec.Target = arr[1]
	mode = arr[2]
	default:
	return nil, errInvalidSpec(raw)
	}

	if !linuxValidMountMode(mode) {
	return nil, errInvalidMode(mode)
	}

	if path.IsAbs(spec.Source) {
	spec.Type = mount.TypeBind
	} else {
	spec.Type = mount.TypeVolume
	}

	spec.ReadOnly = !p.ReadWrite(mode)

	// cannot assume that if a volume driver is passed in that we should set it
	if volumeDriver != "" && spec.Type == mount.TypeVolume {
	spec.VolumeOptions = &mount.VolumeOptions{
	DriverConfig: &mount.Driver{Name: volumeDriver},
	}
	}

	if copyData, isSet := getCopyMode(mode, p.DefaultCopyMode()); isSet {
	if spec.VolumeOptions == nil {
	spec.VolumeOptions = &mount.VolumeOptions{}
	}
	spec.VolumeOptions.NoCopy = !copyData
	}
	if linuxHasPropagation(mode) {
	spec.BindOptions = &mount.BindOptions{
	Propagation: linuxGetPropagation(mode),
	}
	}

	mp, err := p.parseMountSpec(spec, false)
	if mp != nil {
	mp.Mode = mode
	}
	if err != nil {
	err = fmt.Errorf("%v: %v", errInvalidSpec(raw), err)
	}
	return mp, err
	}
	func (p linuxParser) ParseMountSpec(cfg mount.Mount) (MountPoint, error) {
	return p.parseMountSpec(cfg, true)
	}
	func (p linuxParser) parseMountSpec(cfg mount.Mount, validateBindSourceExists bool) (MountPoint, error) {
	if err := p.validateMountConfigImpl(&cfg, validateBindSourceExists); err != nil {
	return nil, err
	}
	mp := &MountPoint{
	RW: !cfg.ReadOnly,
	Destination: path.Clean(filepath.ToSlash(cfg.Target)),
	Type: cfg.Type,
	Spec: cfg,
	}

	switch cfg.Type {
	case mount.TypeVolume:
	if cfg.Source == "" {
	mp.Name = stringid.GenerateNonCryptoID()
	} else {
	mp.Name = cfg.Source
	}
	mp.CopyData = p.DefaultCopyMode()

	if cfg.VolumeOptions != nil {
	if cfg.VolumeOptions.DriverConfig != nil {
	mp.Driver = cfg.VolumeOptions.DriverConfig.Name
	}
	if cfg.VolumeOptions.NoCopy {
	mp.CopyData = false
	}
	}
	case mount.TypeBind:
	mp.Source = path.Clean(filepath.ToSlash(cfg.Source))
	if cfg.BindOptions != nil && len(cfg.BindOptions.Propagation) > 0 {
	mp.Propagation = cfg.BindOptions.Propagation
	} else {
	// If user did not specify a propagation mode, get
	// default propagation mode.
	mp.Propagation = linuxDefaultPropagationMode
	}
	case mount.TypeTmpfs:
	// NOP
	}
	return mp, nil
	}

	func (p *linuxParser) ParseVolumesFrom(spec string) (string, string, error) {
	if len(spec) == 0 {
	return "", "", fmt.Errorf("volumes-from specification cannot be an empty string")
	}

	specParts := strings.SplitN(spec, ":", 2)
	id := specParts[0]
	mode := "rw"

	if len(specParts) == 2 {
	mode = specParts[1]
	if !linuxValidMountMode(mode) {
	return "", "", errInvalidMode(mode)
	}
	// For now don't allow propagation properties while importing
	// volumes from data container. These volumes will inherit
	// the same propagation property as of the original volume
	// in data container. This probably can be relaxed in future.
	if linuxHasPropagation(mode) {
	return "", "", errInvalidMode(mode)
	}
	// Do not allow copy modes on volumes-from
	if _, isSet := getCopyMode(mode, p.DefaultCopyMode()); isSet {
	return "", "", errInvalidMode(mode)
	}
	}
	return id, mode, nil
	}

	func (p *linuxParser) DefaultPropagationMode() mount.Propagation {
	return linuxDefaultPropagationMode
	}

	func (p linuxParser) ConvertTmpfsOptions(opt mount.TmpfsOptions, readOnly bool) (string, error) {
	var rawOpts []string
	if readOnly {
	rawOpts = append(rawOpts, "ro")
	}

	if opt != nil && opt.Mode != 0 {
	rawOpts = append(rawOpts, fmt.Sprintf("mode=%o", opt.Mode))
	}

	if opt != nil && opt.SizeBytes != 0 {
	// calculate suffix here, making this linux specific, but that is
	// okay, since API is that way anyways.

	// we do this by finding the suffix that divides evenly into the
	// value, returning the value itself, with no suffix, if it fails.
	//
	// For the most part, we don't enforce any semantic to this values.
	// The operating system will usually align this and enforce minimum
	// and maximums.
	var (
	size = opt.SizeBytes
	suffix string
	)
	for _, r := range []struct {
	suffix string
	divisor int64
	}{
	{"g", 1 << 30},
	{"m", 1 << 20},
	{"k", 1 << 10},
	} {
	if size%r.divisor == 0 {
	size = size / r.divisor
	suffix = r.suffix
	break
	}
	}

	rawOpts = append(rawOpts, fmt.Sprintf("size=%d%s", size, suffix))
	}
	return strings.Join(rawOpts, ","), nil
	}

	func (p *linuxParser) DefaultCopyMode() bool {
	return true
	}
	func (p *linuxParser) ValidateVolumeName(name string) error {
	return nil
	}

	func (p linuxParser) IsBackwardCompatible(m MountPoint) bool {
	return len(m.Source) > 0 \|\| m.Driver == DefaultDriverName
	}

	func (p *linuxParser) ValidateTmpfsMountDestination(dest string) error {
	if err := linuxValidateNotRoot(dest); err != nil {
	return err
	}
	return linuxValidateAbsolute(dest)
	}