@@ -331,7 +331,12 @@ func (s *router) postContainersCreate(ctx context.Context, w http.ResponseWriter

 	version := httputils.VersionFromContext(ctx)

 	adjustCPUShares := version.LessThan("1.19")

-	ccr, err := s.daemon.ContainerCreate(name, config, hostConfig, adjustCPUShares)

+	ccr, err := s.daemon.ContainerCreate(&daemon.ContainerCreateConfig{

+		Name:            name,

+		Config:          config,

+		HostConfig:      hostConfig,

+		AdjustCPUShares: adjustCPUShares,

+	})

 	if err != nil {

 		return err

 	}

@@ -186,7 +186,7 @@ func platformSupports(command string) error {

 		return nil

 	}

 	switch command {

-	case "expose", "volume", "user", "stopsignal", "arg":

+	case "expose", "user", "stopsignal", "arg":

 		return fmt.Errorf("The daemon on this platform does not support the command '%s'", command)

 	}

 	return nil

@@ -8,7 +8,7 @@ package daemon

 func checkIfPathIsInAVolume(container *Container, absPath string) (bool, error) {

 	var toVolume bool

 	for _, mnt := range container.MountPoints {

-		if toVolume = mnt.hasResource(absPath); toVolume {

+		if toVolume = mnt.HasResource(absPath); toVolume {

 			if mnt.RW {

 				break

 			}

@@ -8,6 +8,7 @@ import (

 	"io/ioutil"

 	"os"

 	"path/filepath"

+	"strings"

 	"sync"

 	"syscall"

 	"time"

@@ -30,8 +31,10 @@ import (

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

 	"github.com/docker/docker/pkg/signal"

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

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

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/docker/volume"

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

 )

 var (

@@ -72,6 +75,7 @@ type CommonContainer struct {

 	RestartCount           int

 	HasBeenStartedBefore   bool

 	HasBeenManuallyStopped bool // used for unless-stopped restart policy

+	MountPoints            map[string]*volume.MountPoint

 	hostConfig             *runconfig.HostConfig

 	command                *execdriver.Command

 	monitor                *containerMonitor

@@ -1108,29 +1112,109 @@ func (container *Container) mountVolumes() error {

 	return nil

 }

-func (container *Container) copyImagePathContent(v volume.Volume, destination string) error {

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

-	if err != nil {

-		return err

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

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

+		if len(config.Driver) > 0 {

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

+			if err != nil {

+				return err

+			}

+			config.Volume = v

+		}

 	}

+	return nil

+}

-	if _, err = ioutil.ReadDir(rootfs); err != nil {

-		if os.IsNotExist(err) {

-			return nil

+func (container *Container) removeMountPoints(rm bool) error {

+	var rmErrors []string

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

+		if m.Volume == nil {

+			continue

+		}

+		container.daemon.volumes.Decrement(m.Volume)

+		if rm {

+			err := container.daemon.volumes.Remove(m.Volume)

+			// ErrVolumeInUse is ignored because having this

+			// volume being referenced by other container is

+			// not an error, but an implementation detail.

+			// This prevents docker from logging "ERROR: Volume in use"

+			// where there is another container using the volume.

+			if err != nil && err != store.ErrVolumeInUse {

+				rmErrors = append(rmErrors, err.Error())

+			}

 		}

-		return err

 	}

+	if len(rmErrors) > 0 {

+		return derr.ErrorCodeRemovingVolume.WithArgs(strings.Join(rmErrors, "\n"))

+	}

+	return nil

+}

-	path, err := v.Mount()

-	if err != nil {

-		return err

+func (container *Container) unmountVolumes(forceSyscall bool) error {

+	var (

+		volumeMounts []volume.MountPoint

+		err          error

+	)

+

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

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

+		if err != nil {

+			return err

+		}

+

+		volumeMounts = append(volumeMounts, volume.MountPoint{Destination: dest, Volume: mntPoint.Volume})

 	}

-	if err := copyExistingContents(rootfs, path); err != nil {

+	// Append any network mounts to the list (this is a no-op on Windows)

+	if volumeMounts, err = appendNetworkMounts(container, volumeMounts); err != nil {

 		return err

 	}

-	return v.Unmount()

+	for _, volumeMount := range volumeMounts {

+		if forceSyscall {

+			system.UnmountWithSyscall(volumeMount.Destination)

+		}

+

+		if volumeMount.Volume != nil {

+			if err := volumeMount.Volume.Unmount(); err != nil {

+				return err

+			}

+		}

+	}

+

+	return nil

+}

+

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

+	container.MountPoints[destination] = &volume.MountPoint{

+		Name:        name,

+		Source:      source,

+		Destination: destination,

+		RW:          rw,

+	}

+}

+

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

+	container.MountPoints[destination] = &volume.MountPoint{

+		Name:        name,

+		Driver:      volume.DefaultDriverName,

+		Destination: destination,

+		RW:          rw,

+	}

+}

+

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

+	container.MountPoints[destination] = &volume.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) stopSignal() int {

@@ -23,12 +23,12 @@ import (

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

 	"github.com/docker/docker/pkg/nat"

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

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

 	"github.com/docker/docker/pkg/system"

 	"github.com/docker/docker/pkg/ulimit"

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/docker/utils"

 	"github.com/docker/docker/volume"

-	"github.com/docker/docker/volume/store"

 	"github.com/docker/libnetwork"

 	"github.com/docker/libnetwork/drivers/bridge"

 	"github.com/docker/libnetwork/netlabel"

@@ -54,9 +54,8 @@ type Container struct {

 	AppArmorProfile string

 	HostnamePath    string

 	HostsPath       string

-	ShmPath         string

-	MqueuePath      string

-	MountPoints     map[string]*mountPoint

+	ShmPath         string // TODO Windows - Factor this out (GH15862)

+	MqueuePath      string // TODO Windows - Factor this out (GH15862)

 	ResolvConfPath  string

 	Volumes   map[string]string // Deprecated since 1.7, kept for backwards compatibility

@@ -1197,40 +1196,16 @@ func (container *Container) disconnectFromNetwork(n libnetwork.Network) error {

 	return nil

 }

-func (container *Container) unmountVolumes(forceSyscall bool) error {

-	var volumeMounts []mountPoint

-

-	for _, mntPoint := range container.MountPoints {

-		dest, err := container.GetResourcePath(mntPoint.Destination)

-		if err != nil {

-			return err

-		}

-

-		volumeMounts = append(volumeMounts, mountPoint{Destination: dest, Volume: mntPoint.Volume})

-	}

-

+// appendNetworkMounts appends any network mounts to the array of mount points passed in

+func appendNetworkMounts(container *Container, volumeMounts []volume.MountPoint) ([]volume.MountPoint, error) {

 	for _, mnt := range container.networkMounts() {

 		dest, err := container.GetResourcePath(mnt.Destination)

 		if err != nil {

-			return err

-		}

-

-		volumeMounts = append(volumeMounts, mountPoint{Destination: dest})

-	}

-

-	for _, volumeMount := range volumeMounts {

-		if forceSyscall {

-			syscall.Unmount(volumeMount.Destination, 0)

-		}

-

-		if volumeMount.Volume != nil {

-			if err := volumeMount.Volume.Unmount(); err != nil {

-				return err

-			}

+			return nil, err

 		}

+		volumeMounts = append(volumeMounts, volume.MountPoint{Destination: dest})

 	}

-

-	return nil

+	return volumeMounts, nil

 }

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

@@ -1290,74 +1265,29 @@ func (container *Container) networkMounts() []execdriver.Mount {

 	return mounts

 }

-func (container *Container) addBindMountPoint(name, source, destination string, rw bool) {

-	container.MountPoints[destination] = &mountPoint{

-		Name:        name,

-		Source:      source,

-		Destination: destination,

-		RW:          rw,

+func (container *Container) copyImagePathContent(v volume.Volume, destination string) error {

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

+	if err != nil {

+		return err

 	}

-}

-func (container *Container) addLocalMountPoint(name, destination string, rw bool) {

-	container.MountPoints[destination] = &mountPoint{

-		Name:        name,

-		Driver:      volume.DefaultDriverName,

-		Destination: destination,

-		RW:          rw,

+	if _, err = ioutil.ReadDir(rootfs); err != nil {

+		if os.IsNotExist(err) {

+			return nil

+		}

+		return err

 	}

-}

-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,

+	path, err := v.Mount()

+	if err != nil {

+		return err

 	}

-}

-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 := container.daemon.createVolume(config.Name, config.Driver, nil)

-			if err != nil {

-				return err

-			}

-			config.Volume = v

-		}

+	if err := copyExistingContents(rootfs, path); err != nil {

+		return err

 	}

-	return nil

-}

-func (container *Container) removeMountPoints(rm bool) error {

-	var rmErrors []string

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

-		if m.Volume == nil {

-			continue

-		}

-		container.daemon.volumes.Decrement(m.Volume)

-		if rm {

-			err := container.daemon.volumes.Remove(m.Volume)

-			// ErrVolumeInUse is ignored because having this

-			// volume being referenced by othe container is

-			// not an error, but an implementation detail.

-			// This prevents docker from logging "ERROR: Volume in use"

-			// where there is another container using the volume.

-			if err != nil && err != store.ErrVolumeInUse {

-				rmErrors = append(rmErrors, err.Error())

-			}

-		}

-	}

-	if len(rmErrors) > 0 {

-		return derr.ErrorCodeRemovingVolume.WithArgs(strings.Join(rmErrors, "\n"))

-	}

-	return nil

+	return v.Unmount()

 }

 func (container *Container) shmPath() (string, error) {

@@ -7,6 +7,7 @@ import (

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

 	derr "github.com/docker/docker/errors"

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

 	"github.com/docker/libnetwork"

 )

@@ -169,18 +170,11 @@ func (container *Container) updateNetwork() error {

 func (container *Container) releaseNetwork() {

 }

-func (container *Container) unmountVolumes(forceSyscall bool) error {

-	return nil

-}

-

-// prepareMountPoints is a no-op on Windows

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

-	return nil

-}

-

-// removeMountPoints is a no-op on Windows.

-func (container *Container) removeMountPoints(_ bool) error {

-	return nil

+// appendNetworkMounts appends any network mounts to the array of mount points passed in.

+// Windows does not support network mounts (not to be confused with SMB network mounts), so

+// this is a no-op.

+func appendNetworkMounts(container *Container, volumeMounts []volume.MountPoint) ([]volume.MountPoint, error) {

+	return volumeMounts, nil

 }

 func (container *Container) setupIpcDirs() error {

@@ -15,26 +15,34 @@ import (

 	"github.com/opencontainers/runc/libcontainer/label"

 )

+// ContainerCreateConfig is the parameter set to ContainerCreate()

+type ContainerCreateConfig struct {

+	Name            string

+	Config          *runconfig.Config

+	HostConfig      *runconfig.HostConfig

+	AdjustCPUShares bool

+}

+

 // ContainerCreate takes configs and creates a container.

-func (daemon *Daemon) ContainerCreate(name string, config *runconfig.Config, hostConfig *runconfig.HostConfig, adjustCPUShares bool) (types.ContainerCreateResponse, error) {

-	if config == nil {

+func (daemon *Daemon) ContainerCreate(params *ContainerCreateConfig) (types.ContainerCreateResponse, error) {

+	if params.Config == nil {

 		return types.ContainerCreateResponse{}, derr.ErrorCodeEmptyConfig

 	}

-	warnings, err := daemon.verifyContainerSettings(hostConfig, config)

+	warnings, err := daemon.verifyContainerSettings(params.HostConfig, params.Config)

 	if err != nil {

 		return types.ContainerCreateResponse{"", warnings}, err

 	}

-	daemon.adaptContainerSettings(hostConfig, adjustCPUShares)

+	daemon.adaptContainerSettings(params.HostConfig, params.AdjustCPUShares)

-	container, err := daemon.Create(config, hostConfig, name)

+	container, err := daemon.create(params)

 	if err != nil {

-		if daemon.Graph().IsNotExist(err, config.Image) {

-			if strings.Contains(config.Image, "@") {

-				return types.ContainerCreateResponse{"", warnings}, derr.ErrorCodeNoSuchImageHash.WithArgs(config.Image)

+		if daemon.Graph().IsNotExist(err, params.Config.Image) {

+			if strings.Contains(params.Config.Image, "@") {

+				return types.ContainerCreateResponse{"", warnings}, derr.ErrorCodeNoSuchImageHash.WithArgs(params.Config.Image)

 			}

-			img, tag := parsers.ParseRepositoryTag(config.Image)

+			img, tag := parsers.ParseRepositoryTag(params.Config.Image)

 			if tag == "" {

 				tag = tags.DefaultTag

 			}

@@ -47,7 +55,7 @@ func (daemon *Daemon) ContainerCreate(name string, config *runconfig.Config, hos

 }

 // Create creates a new container from the given configuration with a given name.

-func (daemon *Daemon) Create(config *runconfig.Config, hostConfig *runconfig.HostConfig, name string) (retC *Container, retErr error) {

+func (daemon *Daemon) create(params *ContainerCreateConfig) (retC *Container, retErr error) {

 	var (

 		container *Container

 		img       *image.Image

@@ -55,8 +63,8 @@ func (daemon *Daemon) Create(config *runconfig.Config, hostConfig *runconfig.Hos

 		err       error

 	)

-	if config.Image != "" {

-		img, err = daemon.repositories.LookupImage(config.Image)

+	if params.Config.Image != "" {

+		img, err = daemon.repositories.LookupImage(params.Config.Image)

 		if err != nil {

 			return nil, err

 		}

@@ -66,20 +74,20 @@ func (daemon *Daemon) Create(config *runconfig.Config, hostConfig *runconfig.Hos

 		imgID = img.ID

 	}

-	if err := daemon.mergeAndVerifyConfig(config, img); err != nil {

+	if err := daemon.mergeAndVerifyConfig(params.Config, img); err != nil {

 		return nil, err

 	}

-	if hostConfig == nil {

-		hostConfig = &runconfig.HostConfig{}

+	if params.HostConfig == nil {

+		params.HostConfig = &runconfig.HostConfig{}

 	}

-	if hostConfig.SecurityOpt == nil {

-		hostConfig.SecurityOpt, err = daemon.generateSecurityOpt(hostConfig.IpcMode, hostConfig.PidMode)

+	if params.HostConfig.SecurityOpt == nil {

+		params.HostConfig.SecurityOpt, err = daemon.generateSecurityOpt(params.HostConfig.IpcMode, params.HostConfig.PidMode)

 		if err != nil {

 			return nil, err

 		}

 	}

-	if container, err = daemon.newContainer(name, config, imgID); err != nil {

+	if container, err = daemon.newContainer(params.Name, params.Config, imgID); err != nil {

 		return nil, err

 	}

 	defer func() {

@@ -96,7 +104,7 @@ func (daemon *Daemon) Create(config *runconfig.Config, hostConfig *runconfig.Hos

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

 		return nil, err

 	}

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

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

 		return nil, err

 	}

 	defer func() {

@@ -111,7 +119,7 @@ func (daemon *Daemon) Create(config *runconfig.Config, hostConfig *runconfig.Hos

 	}

 	defer container.Unmount()

-	if err := createContainerPlatformSpecificSettings(container, config, hostConfig, img); err != nil {

+	if err := createContainerPlatformSpecificSettings(container, params.Config, params.HostConfig, img); err != nil {

 		return nil, err

 	}

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

 // createContainerPlatformSpecificSettings performs platform specific container create functionality

 func createContainerPlatformSpecificSettings(container *Container, config *runconfig.Config, hostConfig *runconfig.HostConfig, img *image.Image) error {

+	var name, destination string

+

 	for spec := range config.Volumes {

-		name := stringid.GenerateNonCryptoID()

-		destination := filepath.Clean(spec)

+		name = stringid.GenerateNonCryptoID()

+		destination = filepath.Clean(spec)

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

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

@@ -1,11 +1,83 @@

 package daemon

 import (

+	"fmt"

+

 	"github.com/docker/docker/image"

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

 	"github.com/docker/docker/runconfig"

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

 )

 // createContainerPlatformSpecificSettings performs platform specific container create functionality

 func createContainerPlatformSpecificSettings(container *Container, config *runconfig.Config, hostConfig *runconfig.HostConfig, img *image.Image) error {

+	for spec := range config.Volumes {

+

+		mp, err := volume.ParseMountSpec(spec, hostConfig.VolumeDriver)

+		if err != nil {

+			return fmt.Errorf("Unrecognised volume spec: %v", err)

+		}

+

+		// If the mountpoint doesn't have a name, generate one.

+		if len(mp.Name) == 0 {

+			mp.Name = stringid.GenerateNonCryptoID()

+		}

+

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

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

+		if container.isDestinationMounted(mp.Destination) {

+			continue

+		}

+

+		volumeDriver := hostConfig.VolumeDriver

+		if mp.Destination != "" && img != nil {

+			if _, ok := img.ContainerConfig.Volumes[mp.Destination]; ok {

+				// check for whether bind is not specified and then set to local

+				if _, ok := container.MountPoints[mp.Destination]; !ok {

+					volumeDriver = volume.DefaultDriverName

+				}

+			}

+		}

+

+		// Create the volume in the volume driver. If it doesn't exist,

+		// a new one will be created.

+		v, err := container.daemon.createVolume(mp.Name, volumeDriver, nil)

+		if err != nil {

+			return err

+		}

+

+		// FIXME Windows: This code block is present in the Linux version and

+		// allows the contents to be copied to the container FS prior to it

+		// being started. However, the function utilises the FollowSymLinkInScope

+		// path which does not cope with Windows volume-style file paths. There

+		// is a seperate effort to resolve this (@swernli), so this processing

+		// is deferred for now. A case where this would be useful is when

+		// a dockerfile includes a VOLUME statement, but something is created

+		// in that directory during the dockerfile processing. What this means

+		// on Windows for TP4 is that in that scenario, the contents will not

+		// copied, but that's (somewhat) OK as HCS will bomb out soon after

+		// at it doesn't support mapped directories which have contents in the

+		// destination path anyway.

+		//

+		// Example for repro later:

+		//   FROM windowsservercore

+		//   RUN mkdir c:\myvol

+		//   RUN copy c:\windows\system32\ntdll.dll c:\myvol

+		//   VOLUME "c:\myvol"

+		//

+		// Then

+		//   docker build -t vol .

+		//   docker run -it --rm vol cmd  <-- This is where HCS will error out.

+		//

+		//	// never attempt to copy existing content in a container FS to a shared volume

+		//	if v.DriverName() == volume.DefaultDriverName {

+		//		if err := container.copyImagePathContent(v, mp.Destination); err != nil {

+		//			return err

+		//		}

+		//	}

+

+		// Add it to container.MountPoints

+		container.addMountPointWithVolume(mp.Destination, v, mp.RW)

+	}

 	return nil

 }

@@ -22,6 +22,7 @@ import (

 	"github.com/docker/docker/pkg/sysinfo"

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/docker/utils"

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

 	"github.com/docker/libnetwork"

 	nwconfig "github.com/docker/libnetwork/config"

 	"github.com/docker/libnetwork/drivers/bridge"

@@ -603,10 +604,10 @@ func (daemon *Daemon) newBaseContainer(id string) Container {

 			State:        NewState(),

 			execCommands: newExecStore(),

 			root:         daemon.containerRoot(id),

+			MountPoints:  make(map[string]*volume.MountPoint),

 		},

-		MountPoints: make(map[string]*mountPoint),

-		Volumes:     make(map[string]string),

-		VolumesRW:   make(map[string]bool),

+		Volumes:   make(map[string]string),

+		VolumesRW: make(map[string]bool),

 	}

 }

@@ -83,7 +83,12 @@ func (d Docker) Container(id string) (*daemon.Container, error) {

 // Create creates a new Docker container and returns potential warnings

 func (d Docker) Create(cfg *runconfig.Config, hostCfg *runconfig.HostConfig) (*daemon.Container, []string, error) {

-	ccr, err := d.Daemon.ContainerCreate("", cfg, hostCfg, true)

+	ccr, err := d.Daemon.ContainerCreate(&daemon.ContainerCreateConfig{

+		Name:            "",

+		Config:          cfg,

+		HostConfig:      hostCfg,

+		AdjustCPUShares: true,

+	})

 	if err != nil {

 		return nil, nil, err

 	}

@@ -165,16 +165,8 @@ type ResourceStats struct {

 	SystemUsage uint64    `json:"system_usage"`

 }

-// Mount contains information for a mount operation.

-type Mount struct {

-	Source      string `json:"source"`

-	Destination string `json:"destination"`

-	Writable    bool   `json:"writable"`

-	Private     bool   `json:"private"`

-	Slave       bool   `json:"slave"`

-}

-

 // User contains the uid and gid representing a Unix user

+// TODO Windows: Factor out User

 type User struct {

 	UID int `json:"root_uid"`

 	GID int `json:"root_gid"`

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

 	"github.com/opencontainers/runc/libcontainer/configs"

 )

+// Mount contains information for a mount operation.

+type Mount struct {

+	Source      string `json:"source"`

+	Destination string `json:"destination"`

+	Writable    bool   `json:"writable"`

+	Private     bool   `json:"private"`

+	Slave       bool   `json:"slave"`

+}

+

 // Network settings of the container

 type Network struct {

 	Mtu            int    `json:"mtu"`

@@ -2,6 +2,13 @@ package execdriver

 import "github.com/docker/docker/pkg/nat"

+// Mount contains information for a mount operation.

+type Mount struct {

+	Source      string `json:"source"`

+	Destination string `json:"destination"`

+	Writable    bool   `json:"writable"`

+}

+

 // Network settings of the container

 type Network struct {

 	Interface   *NetworkInterface `json:"interface"`

@@ -2,8 +2,6 @@

 package windows

-// Note this is alpha code for the bring up of containers on Windows.

-

 import (

 	"encoding/json"

 	"errors"

@@ -60,18 +58,25 @@ type device struct {

 	Settings   interface{}

 }

+type mappedDir struct {

+	HostPath      string

+	ContainerPath string

+	ReadOnly      bool

+}

+

 type containerInit struct {

-	SystemType              string   // HCS requires this to be hard-coded to "Container"

-	Name                    string   // Name of the container. We use the docker ID.

-	Owner                   string   // The management platform that created this container

-	IsDummy                 bool     // Used for development purposes.

-	VolumePath              string   // Windows volume path for scratch space

-	Devices                 []device // Devices used by the container

-	IgnoreFlushesDuringBoot bool     // Optimisation hint for container startup in Windows

-	LayerFolderPath         string   // Where the layer folders are located

-	Layers                  []layer  // List of storage layers

-	ProcessorWeight         int64    // CPU Shares 1..9 on Windows; or 0 is platform default.

-	HostName                string   // Hostname

+	SystemType              string      // HCS requires this to be hard-coded to "Container"

+	Name                    string      // Name of the container. We use the docker ID.

+	Owner                   string      // The management platform that created this container

+	IsDummy                 bool        // Used for development purposes.

+	VolumePath              string      // Windows volume path for scratch space

+	Devices                 []device    // Devices used by the container

+	IgnoreFlushesDuringBoot bool        // Optimisation hint for container startup in Windows

+	LayerFolderPath         string      // Where the layer folders are located

+	Layers                  []layer     // List of storage layers

+	ProcessorWeight         int64       // CPU Shares 1..9 on Windows; or 0 is platform default.

+	HostName                string      // Hostname

+	MappedDirectories       []mappedDir // List of mapped directories (volumes/mounts)

 }

 // defaultOwner is a tag passed to HCS to allow it to differentiate between

@@ -105,18 +110,28 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, hooks execd

 		HostName:                c.Hostname,

 	}

-	for i := 0; i < len(c.LayerPaths); i++ {

-		_, filename := filepath.Split(c.LayerPaths[i])

+	for _, layerPath := range c.LayerPaths {

+		_, filename := filepath.Split(layerPath)

 		g, err := hcsshim.NameToGuid(filename)

 		if err != nil {

 			return execdriver.ExitStatus{ExitCode: -1}, err

 		}

 		cu.Layers = append(cu.Layers, layer{

 			ID:   g.ToString(),

-			Path: c.LayerPaths[i],

+			Path: layerPath,

 		})

 	}

+	// Add the mounts (volumes, bind mounts etc) to the structure

+	mds := make([]mappedDir, len(c.Mounts))

+	for i, mount := range c.Mounts {

+		mds[i] = mappedDir{

+			HostPath:      mount.Source,

+			ContainerPath: mount.Destination,

+			ReadOnly:      !mount.Writable}

+	}

+	cu.MappedDirectories = mds

+

 	// TODO Windows. At some point, when there is CLI on docker run to

 	// enable the IP Address of the container to be passed into docker run,

 	// the IP Address needs to be wired through to HCS in the JSON. It

@@ -8,7 +8,17 @@ func setPlatformSpecificContainerFields(container *Container, contJSONBase *type

 }

 func addMountPoints(container *Container) []types.MountPoint {

-	return nil

+	mountPoints := make([]types.MountPoint, 0, len(container.MountPoints))

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

+		mountPoints = append(mountPoints, types.MountPoint{

+			Name:        m.Name,

+			Source:      m.Path(),

+			Destination: m.Destination,

+			Driver:      m.Driver,

+			RW:          m.RW,

+		})

+	}

+	return mountPoints

 }

 // ContainerInspectPre120 get containers for pre 1.20 APIs.

@@ -2,18 +2,16 @@ package daemon

 import (

 	"errors"

-	"fmt"

-	"io/ioutil"

 	"os"

 	"path/filepath"

 	"strings"

-	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/api/types"

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

 	derr "github.com/docker/docker/errors"

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

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

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

 	"github.com/docker/docker/volume"

+	"github.com/opencontainers/runc/libcontainer/label"

 )

 var (

@@ -22,88 +20,136 @@ var (

 	ErrVolumeReadonly = errors.New("mounted volume is marked read-only")

 )

-// mountPoint is the intersection point between a volume and a container. It

-// specifies which volume is to be used and where inside a container it should

-// be mounted.

-type mountPoint struct {

-	Name        string

-	Destination string

-	Driver      string

-	RW          bool

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

-	Source      string

-	Mode        string `json:"Relabel"` // Originally field was `Relabel`"

-}

+type mounts []execdriver.Mount

-// Setup sets up a mount point by either mounting the volume if it is

-// configured, or creating the source directory if supplied.

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

-	if m.Volume != nil {

-		return m.Volume.Mount()

+// volumeToAPIType converts a volume.Volume to the type used by the remote API

+func volumeToAPIType(v volume.Volume) *types.Volume {

+	return &types.Volume{

+		Name:       v.Name(),

+		Driver:     v.DriverName(),

+		Mountpoint: v.Path(),

 	}

+}

-	if len(m.Source) > 0 {

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

-			if !os.IsNotExist(err) {

-				return "", err

-			}

-			logrus.Warnf("Auto-creating non-existant volume host path %s, this is deprecated and will be removed soon", m.Source)

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

-				return "", err

-			}

-		}

-		return m.Source, nil

+// createVolume creates a volume.

+func (daemon *Daemon) createVolume(name, driverName string, opts map[string]string) (volume.Volume, error) {

+	v, err := daemon.volumes.Create(name, driverName, opts)

+	if err != nil {

+		return nil, err

 	}

+	daemon.volumes.Increment(v)

+	return v, nil

+}

+

+// Len returns the number of mounts. Used in sorting.

+func (m mounts) Len() int {

+	return len(m)

+}

-	return "", derr.ErrorCodeMountSetup

+// Less returns true if the number of parts (a/b/c would be 3 parts) in the

+// mount indexed by parameter 1 is less than that of the mount indexed by

+// parameter 2. Used in sorting.

+func (m mounts) Less(i, j int) bool {

+	return m.parts(i) < m.parts(j)