@@ -6,19 +6,18 @@ import (

 	"errors"

 	"fmt"

 	"io"

-	"net"

 	"net/http"

 	"os"

 	"path/filepath"

 	"reflect"

 	"strings"

 	"text/template"

-	"time"

 	"github.com/docker/docker/cliconfig"

 	"github.com/docker/docker/pkg/homedir"

 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/term"

+	"github.com/docker/docker/utils"

 )

 // DockerCli represents the docker command line client.

@@ -178,19 +177,7 @@ func NewDockerCli(in io.ReadCloser, out, err io.Writer, keyFile string, proto, a

 	tr := &http.Transport{

 		TLSClientConfig: tlsConfig,

 	}

-

-	// Why 32? See https://github.com/docker/docker/pull/8035.

-	timeout := 32 * time.Second

-	if proto == "unix" {

-		// No need for compression in local communications.

-		tr.DisableCompression = true

-		tr.Dial = func(_, _ string) (net.Conn, error) {

-			return net.DialTimeout(proto, addr, timeout)

-		}

-	} else {

-		tr.Proxy = http.ProxyFromEnvironment

-		tr.Dial = (&net.Dialer{Timeout: timeout}).Dial

-	}

+	utils.ConfigureTCPTransport(tr, proto, addr)

 	configFile, e := cliconfig.Load(filepath.Join(homedir.Get(), ".docker"))

 	if e != nil {

@@ -773,7 +773,7 @@ func (b *Builder) clearTmp() {

 			fmt.Fprintf(b.OutStream, "Error removing intermediate container %s: %v\n", stringid.TruncateID(c), err)

 			return

 		}

-		b.Daemon.DeleteVolumes(tmp.VolumePaths())

+		b.Daemon.DeleteVolumes(tmp)

 		delete(b.TmpContainers, c)

 		fmt.Fprintf(b.OutStream, "Removing intermediate container %s\n", stringid.TruncateID(c))

 	}

@@ -26,9 +26,11 @@ import (

 	"github.com/docker/docker/pkg/broadcastwriter"

 	"github.com/docker/docker/pkg/ioutils"

 	"github.com/docker/docker/pkg/jsonlog"

+	"github.com/docker/docker/pkg/mount"

 	"github.com/docker/docker/pkg/promise"

 	"github.com/docker/docker/pkg/symlink"

 	"github.com/docker/docker/runconfig"

+	"github.com/docker/docker/volume"

 )

 var (

@@ -48,46 +50,37 @@ type StreamConfig struct {

 // CommonContainer holds the settings for a container which are applicable

 // across all platforms supported by the daemon.

 type CommonContainer struct {

+	StreamConfig

+

 	*State `json:"State"` // Needed for remote api version <= 1.11

 	root   string         // Path to the "home" of the container, including metadata.

 	basefs string         // Path to the graphdriver mountpoint

-	ID string

-

-	Created time.Time

-

-	Path string

-	Args []string

-

-	Config  *runconfig.Config

-	ImageID string `json:"Image"`

-

-	NetworkSettings *network.Settings

-

-	ResolvConfPath string

-	HostnamePath   string

-	HostsPath      string

-	LogPath        string

-	Name           string

-	Driver         string

-	ExecDriver     string

-

-	command *execdriver.Command

-	StreamConfig

-

-	daemon                   *Daemon

+	ID                       string

+	Created                  time.Time

+	Path                     string

+	Args                     []string

+	Config                   *runconfig.Config

+	ImageID                  string `json:"Image"`

+	NetworkSettings          *network.Settings

+	ResolvConfPath           string

+	HostnamePath             string

+	HostsPath                string

+	LogPath                  string

+	Name                     string

+	Driver                   string

+	ExecDriver               string

 	MountLabel, ProcessLabel string

 	RestartCount             int

 	UpdateDns                bool

+	MountPoints              map[string]*mountPoint

-	// Maps container paths to volume paths.  The key in this is the path to which

-	// the volume is being mounted inside the container.  Value is the path of the

-	// volume on disk

-	Volumes    map[string]string

 	hostConfig *runconfig.HostConfig

+	command    *execdriver.Command

 	monitor      *containerMonitor

 	execCommands *execStore

+	daemon       *Daemon

 	// logDriver for closing

 	logDriver logger.Logger

 	logCopier *logger.Copier

@@ -259,9 +252,6 @@ func (container *Container) Start() (err error) {

 		return err

 	}

 	container.verifyDaemonSettings()

-	if err := container.prepareVolumes(); err != nil {

-		return err

-	}

 	linkedEnv, err := container.setupLinkedContainers()

 	if err != nil {

 		return err

@@ -273,10 +263,13 @@ func (container *Container) Start() (err error) {

 	if err := populateCommand(container, env); err != nil {

 		return err

 	}

-	if err := container.setupMounts(); err != nil {

+

+	mounts, err := container.setupMounts()

+	if err != nil {

 		return err

 	}

+	container.command.Mounts = mounts

 	return container.waitForStart()

 }

@@ -571,27 +564,38 @@ func (container *Container) Copy(resource string) (io.ReadCloser, error) {

 	if err := container.Mount(); err != nil {

 		return nil, err

 	}

+	var paths []string

+	unmount := func() {

+		for _, p := range paths {

+			syscall.Unmount(p, 0)

+		}

+	}

 	defer func() {

 		if err != nil {

+			// unmount any volumes

+			unmount()

+			// unmount the container's rootfs

 			container.Unmount()

 		}

 	}()

-

-	if err = container.mountVolumes(); err != nil {

-		container.unmountVolumes()

+	mounts, err := container.setupMounts()

+	if err != nil {

 		return nil, err

 	}

-	defer func() {

+	for _, m := range mounts {

+		dest, err := container.GetResourcePath(m.Destination)

 		if err != nil {

-			container.unmountVolumes()

+			return nil, err

 		}

-	}()

-

+		paths = append(paths, dest)

+		if err := mount.Mount(m.Source, dest, "bind", "rbind,ro"); err != nil {

+			return nil, err

+		}

+	}

 	basePath, err := container.GetResourcePath(resource)

 	if err != nil {

 		return nil, err

 	}

-

 	stat, err := os.Stat(basePath)

 	if err != nil {

 		return nil, err

@@ -605,7 +609,6 @@ func (container *Container) Copy(resource string) (io.ReadCloser, error) {

 		filter = []string{filepath.Base(basePath)}

 		basePath = filepath.Dir(basePath)

 	}

-

 	archive, err := archive.TarWithOptions(basePath, &archive.TarOptions{

 		Compression:  archive.Uncompressed,

 		IncludeFiles: filter,

@@ -613,10 +616,9 @@ func (container *Container) Copy(resource string) (io.ReadCloser, error) {

 	if err != nil {

 		return nil, err

 	}

-

 	return ioutils.NewReadCloserWrapper(archive, func() error {

 			err := archive.Close()

-			container.unmountVolumes()

+			unmount()

 			container.Unmount()

 			return err

 		}),

@@ -1007,3 +1009,84 @@ func copyEscapable(dst io.Writer, src io.ReadCloser) (written int64, err error)

 	}

 	return written, err

 }

+

+func (container *Container) networkMounts() []execdriver.Mount {

+	var mounts []execdriver.Mount

+	if container.ResolvConfPath != "" {

+		mounts = append(mounts, execdriver.Mount{

+			Source:      container.ResolvConfPath,

+			Destination: "/etc/resolv.conf",

+			Writable:    !container.hostConfig.ReadonlyRootfs,

+			Private:     true,

+		})

+	}

+	if container.HostnamePath != "" {

+		mounts = append(mounts, execdriver.Mount{

+			Source:      container.HostnamePath,

+			Destination: "/etc/hostname",

+			Writable:    !container.hostConfig.ReadonlyRootfs,

+			Private:     true,

+		})

+	}

+	if container.HostsPath != "" {

+		mounts = append(mounts, execdriver.Mount{

+			Source:      container.HostsPath,

+			Destination: "/etc/hosts",

+			Writable:    !container.hostConfig.ReadonlyRootfs,

+			Private:     true,

+		})

+	}

+	return mounts

+}

+

+func (container *Container) AddLocalMountPoint(name, destination string, rw bool) {

+	container.MountPoints[destination] = &mountPoint{

+		Name:        name,

+		Driver:      volume.DefaultDriverName,

+		Destination: destination,

+		RW:          rw,

+	}

+}

+

+func (container *Container) AddMountPointWithVolume(destination string, vol volume.Volume, rw bool) {

+	container.MountPoints[destination] = &mountPoint{

+		Name:        vol.Name(),

+		Driver:      vol.DriverName(),

+		Destination: destination,

+		RW:          rw,

+		Volume:      vol,

+	}

+}

+

+func (container *Container) IsDestinationMounted(destination string) bool {

+	return container.MountPoints[destination] != nil

+}

+

+func (container *Container) PrepareMountPoints() error {

+	for _, config := range container.MountPoints {

+		if len(config.Driver) > 0 {

+			v, err := createVolume(config.Name, config.Driver)

+			if err != nil {

+				return err

+			}

+			config.Volume = v

+		}

+	}

+	return nil

+}

+

+func (container *Container) RemoveMountPoints() error {

+	for _, m := range container.MountPoints {

+		if m.Volume != nil {

+			if err := removeVolume(m.Volume); err != nil {

+				return err

+			}

+		}

+	}

+	return nil

+}

+

+func (container *Container) ShouldRestart() bool {

+	return container.hostConfig.RestartPolicy.Name == "always" ||

+		(container.hostConfig.RestartPolicy.Name == "on-failure" && container.ExitCode != 0)

+}

@@ -42,14 +42,7 @@ type Container struct {

 	// Fields below here are platform specific.

 	AppArmorProfile string

-

-	// Store rw/ro in a separate structure to preserve reverse-compatibility on-disk.

-	// Easier than migrating older container configs :)

-	VolumesRW map[string]bool

-

-	AppliedVolumesFrom map[string]struct{}

-

-	activeLinks map[string]*links.Link

+	activeLinks     map[string]*links.Link

 }

 func killProcessDirectly(container *Container) error {

@@ -27,12 +27,6 @@ type Container struct {

 	// removed in subsequent PRs.

 	AppArmorProfile string

-

-	// Store rw/ro in a separate structure to preserve reverse-compatibility on-disk.

-	// Easier than migrating older container configs :)

-	VolumesRW map[string]bool

-

-	AppliedVolumesFrom map[string]struct{}

 	// ---- END OF TEMPORARY DECLARATION ----

 }

@@ -2,11 +2,15 @@ package daemon

 import (

 	"fmt"

+	"os"

 	"path/filepath"

+	"strings"

 	"github.com/docker/docker/graph"

 	"github.com/docker/docker/image"

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

+	"github.com/docker/docker/pkg/stringid"

+	"github.com/docker/docker/pkg/symlink"

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/libcontainer/label"

 )

@@ -87,17 +91,52 @@ func (daemon *Daemon) Create(config *runconfig.Config, hostConfig *runconfig.Hos

 	if err := daemon.createRootfs(container); err != nil {

 		return nil, nil, err

 	}

-	if hostConfig != nil {

-		if err := daemon.setHostConfig(container, hostConfig); err != nil {

-			return nil, nil, err

-		}

+	if err := daemon.setHostConfig(container, hostConfig); err != nil {

+		return nil, nil, err

 	}

 	if err := container.Mount(); err != nil {

 		return nil, nil, err

 	}

 	defer container.Unmount()

-	if err := container.prepareVolumes(); err != nil {

-		return nil, nil, err

+

+	for spec := range config.Volumes {

+		var (

+			name, destination string

+			parts             = strings.Split(spec, ":")

+		)

+		switch len(parts) {

+		case 2:

+			name, destination = parts[0], filepath.Clean(parts[1])

+		default:

+			name = stringid.GenerateRandomID()

+			destination = filepath.Clean(parts[0])

+		}

+		// Skip volumes for which we already have something mounted on that

+		// destination because of a --volume-from.

+		if container.IsDestinationMounted(destination) {

+			continue

+		}

+		path, err := container.GetResourcePath(destination)

+		if err != nil {

+			return nil, nil, err

+		}

+		if stat, err := os.Stat(path); err == nil && !stat.IsDir() {

+			return nil, nil, fmt.Errorf("cannot mount volume over existing file, file exists %s", path)

+		}

+		v, err := createVolume(name, config.VolumeDriver)

+		if err != nil {

+			return nil, nil, err

+		}

+		rootfs, err := symlink.FollowSymlinkInScope(filepath.Join(container.basefs, destination), container.basefs)

+		if err != nil {

+			return nil, nil, err

+		}

+		if path, err = v.Mount(); err != nil {

+			return nil, nil, err

+		}

+		copyExistingContents(rootfs, path)

+

+		container.AddMountPointWithVolume(destination, v, true)

 	}

 	if err := container.ToDisk(); err != nil {

 		return nil, nil, err

@@ -46,9 +46,12 @@ import (

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/docker/trust"

 	"github.com/docker/docker/utils"

-	"github.com/docker/docker/volumes"

+	volumedrivers "github.com/docker/docker/volume/drivers"

+	"github.com/docker/docker/volume/local"

 )

+const defaultVolumesPathName = "volumes"

+

 var (

 	validContainerNameChars   = `[a-zA-Z0-9][a-zA-Z0-9_.-]`

 	validContainerNamePattern = regexp.MustCompile(`^/?` + validContainerNameChars + `+$`)

@@ -99,7 +102,6 @@ type Daemon struct {

 	repositories     *graph.TagStore

 	idIndex          *truncindex.TruncIndex

 	sysInfo          *sysinfo.SysInfo

-	volumes          *volumes.Repository

 	config           *Config

 	containerGraph   *graphdb.Database

 	driver           graphdriver.Driver

@@ -109,6 +111,7 @@ type Daemon struct {

 	RegistryService  *registry.Service

 	EventsService    *events.Events

 	netController    libnetwork.NetworkController

+	root             string

 }

 // Get looks for a container using the provided information, which could be

@@ -209,7 +212,13 @@ func (daemon *Daemon) register(container *Container, updateSuffixarray bool) err

 	// we'll waste time if we update it for every container

 	daemon.idIndex.Add(container.ID)

-	container.registerVolumes()

+	if err := daemon.verifyOldVolumesInfo(container); err != nil {

+		return err

+	}

+

+	if err := container.PrepareMountPoints(); err != nil {

+		return err

+	}

 	if container.IsRunning() {

 		logrus.Debugf("killing old running container %s", container.ID)

@@ -249,10 +258,15 @@ func (daemon *Daemon) ensureName(container *Container) error {

 }

 func (daemon *Daemon) restore() error {

+	type cr struct {

+		container  *Container

+		registered bool

+	}

+

 	var (

 		debug         = (os.Getenv("DEBUG") != "" || os.Getenv("TEST") != "")

-		containers    = make(map[string]*Container)

 		currentDriver = daemon.driver.String()

+		containers    = make(map[string]*cr)

 	)

 	if !debug {

@@ -278,14 +292,12 @@ func (daemon *Daemon) restore() error {

 		if (container.Driver == "" && currentDriver == "aufs") || container.Driver == currentDriver {

 			logrus.Debugf("Loaded container %v", container.ID)

-			containers[container.ID] = container

+			containers[container.ID] = &cr{container: container}

 		} else {

 			logrus.Debugf("Cannot load container %s because it was created with another graph driver.", container.ID)

 		}

 	}

-	registeredContainers := []*Container{}

-

 	if entities := daemon.containerGraph.List("/", -1); entities != nil {

 		for _, p := range entities.Paths() {

 			if !debug && logrus.GetLevel() == logrus.InfoLevel {

@@ -294,50 +306,43 @@ func (daemon *Daemon) restore() error {

 			e := entities[p]

-			if container, ok := containers[e.ID()]; ok {

-				if err := daemon.register(container, false); err != nil {

-					logrus.Debugf("Failed to register container %s: %s", container.ID, err)

-				}

-

-				registeredContainers = append(registeredContainers, container)

-

-				// delete from the map so that a new name is not automatically generated

-				delete(containers, e.ID())

+			if c, ok := containers[e.ID()]; ok {

+				c.registered = true

 			}

 		}

 	}

-	// Any containers that are left over do not exist in the graph

-	for _, container := range containers {

-		// Try to set the default name for a container if it exists prior to links

-		container.Name, err = daemon.generateNewName(container.ID)

-		if err != nil {

-			logrus.Debugf("Setting default id - %s", err)

-		}

+	group := sync.WaitGroup{}

+	for _, c := range containers {

+		group.Add(1)

-		if err := daemon.register(container, false); err != nil {

-			logrus.Debugf("Failed to register container %s: %s", container.ID, err)

-		}

+		go func(container *Container, registered bool) {

+			defer group.Done()

-		registeredContainers = append(registeredContainers, container)

-	}

+			if !registered {

+				// Try to set the default name for a container if it exists prior to links

+				container.Name, err = daemon.generateNewName(container.ID)

+				if err != nil {

+					logrus.Debugf("Setting default id - %s", err)

+				}

+			}

-	// check the restart policy on the containers and restart any container with

-	// the restart policy of "always"

-	if daemon.config.AutoRestart {

-		logrus.Debug("Restarting containers...")

+			if err := daemon.register(container, false); err != nil {

+				logrus.Debugf("Failed to register container %s: %s", container.ID, err)

+			}

-		for _, container := range registeredContainers {

-			if container.hostConfig.RestartPolicy.IsAlways() ||

-				(container.hostConfig.RestartPolicy.IsOnFailure() && container.ExitCode != 0) {

+			// check the restart policy on the containers and restart any container with

+			// the restart policy of "always"

+			if daemon.config.AutoRestart && container.ShouldRestart() {

 				logrus.Debugf("Starting container %s", container.ID)

 				if err := container.Start(); err != nil {

 					logrus.Debugf("Failed to start container %s: %s", container.ID, err)

 				}

 			}

-		}

+		}(c.container, c.registered)

 	}

+	group.Wait()

 	if !debug {

 		if logrus.GetLevel() == logrus.InfoLevel {

@@ -535,6 +540,7 @@ func (daemon *Daemon) newContainer(name string, config *runconfig.Config, imgID

 			ExecDriver:      daemon.execDriver.Name(),

 			State:           NewState(),

 			execCommands:    newExecStore(),

+			MountPoints:     map[string]*mountPoint{},

 		},

 	}

 	container.root = daemon.containerRoot(container.ID)

@@ -785,15 +791,11 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 		return nil, err

 	}

-	volumesDriver, err := graphdriver.GetDriver("vfs", config.Root, config.GraphOptions)

-	if err != nil {

-		return nil, err

-	}

-

-	volumes, err := volumes.NewRepository(filepath.Join(config.Root, "volumes"), volumesDriver)

+	volumesDriver, err := local.New(filepath.Join(config.Root, defaultVolumesPathName))

 	if err != nil {

 		return nil, err

 	}

+	volumedrivers.Register(volumesDriver, volumesDriver.Name())

 	trustKey, err := api.LoadOrCreateTrustKey(config.TrustKeyPath)

 	if err != nil {

@@ -872,7 +874,6 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 	d.repositories = repositories

 	d.idIndex = truncindex.NewTruncIndex([]string{})

 	d.sysInfo = sysInfo

-	d.volumes = volumes

 	d.config = config

 	d.sysInitPath = sysInitPath

 	d.execDriver = ed

@@ -880,6 +881,7 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 	d.defaultLogConfig = config.LogConfig

 	d.RegistryService = registryService

 	d.EventsService = eventsService

+	d.root = config.Root

 	if err := d.restore(); err != nil {

 		return nil, err

@@ -1218,6 +1220,10 @@ func (daemon *Daemon) verifyHostConfig(hostConfig *runconfig.HostConfig) ([]stri

 }

 func (daemon *Daemon) setHostConfig(container *Container, hostConfig *runconfig.HostConfig) error {

+	if err := daemon.registerMountPoints(container, hostConfig); err != nil {

+		return err

+	}

+

 	container.Lock()

 	defer container.Unlock()

 	if err := parseSecurityOpt(container, hostConfig); err != nil {

@@ -1231,6 +1237,5 @@ func (daemon *Daemon) setHostConfig(container *Container, hostConfig *runconfig.

 	container.hostConfig = hostConfig

 	container.toDisk()

-

 	return nil

 }

@@ -71,21 +71,12 @@ func (daemon *Daemon) ContainerRm(name string, config *ContainerRmConfig) error

 		}

 		container.LogEvent("destroy")

 		if config.RemoveVolume {

-			daemon.DeleteVolumes(container.VolumePaths())

+			container.RemoveMountPoints()

 		}

 	}

 	return nil

 }

-func (daemon *Daemon) DeleteVolumes(volumeIDs map[string]struct{}) {

-	for id := range volumeIDs {

-		if err := daemon.volumes.Delete(id); err != nil {

-			logrus.Infof("%s", err)

-			continue

-		}

-	}

-}

-

 func (daemon *Daemon) Rm(container *Container) (err error) {

 	return daemon.commonRm(container, false)

 }

@@ -134,7 +125,6 @@ func (daemon *Daemon) commonRm(container *Container, forceRemove bool) (err erro

 		}

 	}()

-	container.derefVolumes()

 	if _, err := daemon.containerGraph.Purge(container.ID); err != nil {

 		logrus.Debugf("Unable to remove container from link graph: %s", err)

 	}

@@ -162,3 +152,7 @@ func (daemon *Daemon) commonRm(container *Container, forceRemove bool) (err erro

 	return nil

 }

+

+func (daemon *Daemon) DeleteVolumes(c *Container) error {

+	return c.RemoveMountPoints()

+}

@@ -10,6 +10,10 @@ import (

 type ContainerJSONRaw struct {

 	*Container

 	HostConfig *runconfig.HostConfig

+

+	// Unused fields for backward compatibility with API versions < 1.12.

+	Volumes   map[string]string

+	VolumesRW map[string]bool

 }

 func (daemon *Daemon) ContainerInspect(name string) (*types.ContainerJSON, error) {

@@ -48,6 +52,14 @@ func (daemon *Daemon) ContainerInspect(name string) (*types.ContainerJSON, error

 		FinishedAt: container.State.FinishedAt,

 	}

+	volumes := make(map[string]string)

+	volumesRW := make(map[string]bool)

+

+	for _, m := range container.MountPoints {

+		volumes[m.Destination] = m.Path()

+		volumesRW[m.Destination] = m.RW

+	}

+

 	contJSON := &types.ContainerJSON{

 		Id:              container.ID,

 		Created:         container.Created,

@@ -67,8 +79,8 @@ func (daemon *Daemon) ContainerInspect(name string) (*types.ContainerJSON, error

 		ExecDriver:      container.ExecDriver,

 		MountLabel:      container.MountLabel,

 		ProcessLabel:    container.ProcessLabel,

-		Volumes:         container.Volumes,

-		VolumesRW:       container.VolumesRW,

+		Volumes:         volumes,

+		VolumesRW:       volumesRW,

 		AppArmorProfile: container.AppArmorProfile,

 		ExecIDs:         container.GetExecIDs(),

 		HostConfig:      &hostConfig,

@@ -1,213 +1,116 @@

 package daemon

 import (

+	"encoding/json"

 	"fmt"

 	"io/ioutil"

 	"os"

 	"path/filepath"

-	"sort"

 	"strings"

-	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/daemon/execdriver"

 	"github.com/docker/docker/pkg/chrootarchive"

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

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

+	"github.com/docker/docker/runconfig"

+	"github.com/docker/docker/volume"

+	volumedrivers "github.com/docker/docker/volume/drivers"

 )

-type volumeMount struct {

-	containerPath string

-	hostPath      string

-	writable      bool

-	copyData      bool

-	from          string

-}

-

-func (container *Container) createVolumes() error {

-	mounts := make(map[string]*volumeMount)

-

-	// get the normal volumes

-	for path := range container.Config.Volumes {

-		path = filepath.Clean(path)

-		// skip if there is already a volume for this container path

-		if _, exists := container.Volumes[path]; exists {

-			continue

-		}

-

-		realPath, err := container.GetResourcePath(path)

-		if err != nil {

-			return err

-		}

-		if stat, err := os.Stat(realPath); err == nil {

-			if !stat.IsDir() {

-				return fmt.Errorf("can't mount to container path, file exists - %s", path)

-			}

-		}

-

-		mnt := &volumeMount{

-			containerPath: path,

-			writable:      true,

-			copyData:      true,

-		}

-		mounts[mnt.containerPath] = mnt

-	}

-

-	// Get all the bind mounts

-	// track bind paths separately due to #10618

-	bindPaths := make(map[string]struct{})

-	for _, spec := range container.hostConfig.Binds {

-		mnt, err := parseBindMountSpec(spec)

-		if err != nil {

-			return err

-		}

-

-		// #10618

-		if _, exists := bindPaths[mnt.containerPath]; exists {

-			return fmt.Errorf("Duplicate volume mount %s", mnt.containerPath)

-		}

-

-		bindPaths[mnt.containerPath] = struct{}{}

-		mounts[mnt.containerPath] = mnt

-	}

-

-	// Get volumes from

-	for _, from := range container.hostConfig.VolumesFrom {

-		cID, mode, err := parseVolumesFromSpec(from)

-		if err != nil {

-			return err

-		}

-		if _, exists := container.AppliedVolumesFrom[cID]; exists {

-			// skip since it's already been applied

-			continue

-		}

+var localMountErr = fmt.Errorf("Invalid driver: %s driver doesn't support named volumes", volume.DefaultDriverName)

-		c, err := container.daemon.Get(cID)

-		if err != nil {

-			return fmt.Errorf("container %s not found, impossible to mount its volumes", cID)

-		}

+type mountPoint struct {

+	Name        string

+	Destination string

+	Driver      string

+	RW          bool

+	Volume      volume.Volume `json:"-"`

+	Source      string

+}

-		for _, mnt := range c.volumeMounts() {

-			mnt.writable = mnt.writable && (mode == "rw")

-			mnt.from = cID

-			mounts[mnt.containerPath] = mnt

-		}

+func (m *mountPoint) Setup() (string, error) {

+	if m.Volume != nil {

+		return m.Volume.Mount()

 	}

-	for _, mnt := range mounts {

-		containerMntPath, err := symlink.FollowSymlinkInScope(filepath.Join(container.basefs, mnt.containerPath), container.basefs)

-		if err != nil {

-			return err

-		}

-

-		// Create the actual volume

-		v, err := container.daemon.volumes.FindOrCreateVolume(mnt.hostPath, mnt.writable)

-		if err != nil {

-			return err

-		}

-

-		container.VolumesRW[mnt.containerPath] = mnt.writable

-		container.Volumes[mnt.containerPath] = v.Path

-		v.AddContainer(container.ID)

-		if mnt.from != "" {

-			container.AppliedVolumesFrom[mnt.from] = struct{}{}

-		}

-

-		if mnt.writable && mnt.copyData {

-			// Copy whatever is in the container at the containerPath to the volume

-			copyExistingContents(containerMntPath, v.Path)

+	if len(m.Source) > 0 {

+		if _, err := os.Stat(m.Source); err != nil {

+			if !os.IsNotExist(err) {

+				return "", err

+			}

+			if err := os.MkdirAll(m.Source, 0755); err != nil {

+				return "", err

+			}

 		}

+		return m.Source, nil

 	}

-	return nil

+	return "", fmt.Errorf("Unable to setup mount point, neither source nor volume defined")

 }

-// sortedVolumeMounts returns the list of container volume mount points sorted in lexicographic order

-func (container *Container) sortedVolumeMounts() []string {

-	var mountPaths []string

-	for path := range container.Volumes {

-		mountPaths = append(mountPaths, path)

+func (m *mountPoint) Path() string {

+	if m.Volume != nil {

+		return m.Volume.Path()

 	}

-	sort.Strings(mountPaths)

-	return mountPaths

+	return m.Source

 }

-func (container *Container) VolumePaths() map[string]struct{} {

-	var paths = make(map[string]struct{})

-	for _, path := range container.Volumes {