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) }