Merge pull request #13699 from calavera/volume_backwards

Allow to downgrade local volumes from > 1.7 to 1.6.

daemon/container.go

@@ -73,7 +73,10 @@ type CommonContainer struct {
 	MountLabel, ProcessLabel string
 	RestartCount             int
 	UpdateDns                bool
-	MountPoints              map[string]*mountPoint
+
+	MountPoints map[string]*mountPoint
+	Volumes     map[string]string // Deprecated since 1.7, kept for backwards compatibility
+	VolumesRW   map[string]bool   // Deprecated since 1.7, kept for backwards compatibility
 
 	hostConfig *runconfig.HostConfig
 	command    *execdriver.Command

daemon/daemon.go

@@ -50,8 +50,6 @@ import (
 	"github.com/docker/docker/volume/local"
 )
 
-const defaultVolumesPathName = "volumes"
-
 var (
 	validContainerNameChars   = `[a-zA-Z0-9][a-zA-Z0-9_.-]`
 	validContainerNamePattern = regexp.MustCompile(`^/?` + validContainerNameChars + `+$`)
@@ -155,12 +153,7 @@ func (daemon *Daemon) containerRoot(id string) string {
 // This is typically done at startup.
 func (daemon *Daemon) load(id string) (*Container, error) {
 	container := &Container{
-		CommonContainer: CommonContainer{
-			State:        NewState(),
-			root:         daemon.containerRoot(id),
-			MountPoints:  make(map[string]*mountPoint),
-			execCommands: newExecStore(),
-		},
+		CommonContainer: daemon.newBaseContainer(id),
 	}
 
 	if err := container.FromDisk(); err != nil {
@@ -506,25 +499,21 @@ func (daemon *Daemon) newContainer(name string, config *runconfig.Config, imgID
 	daemon.generateHostname(id, config)
 	entrypoint, args := daemon.getEntrypointAndArgs(config.Entrypoint, config.Cmd)
 
+	base := daemon.newBaseContainer(id)
+	base.Created = time.Now().UTC()
+	base.Path = entrypoint
+	base.Args = args //FIXME: de-duplicate from config
+	base.Config = config
+	base.hostConfig = &runconfig.HostConfig{}
+	base.ImageID = imgID
+	base.NetworkSettings = &network.Settings{}
+	base.Name = name
+	base.Driver = daemon.driver.String()
+	base.ExecDriver = daemon.execDriver.Name()
+
 	container := &Container{
-		CommonContainer: CommonContainer{
-			ID:              id, // FIXME: we should generate the ID here instead of receiving it as an argument
-			Created:         time.Now().UTC(),
-			Path:            entrypoint,
-			Args:            args, //FIXME: de-duplicate from config
-			Config:          config,
-			hostConfig:      &runconfig.HostConfig{},
-			ImageID:         imgID,
-			NetworkSettings: &network.Settings{},
-			Name:            name,
-			Driver:          daemon.driver.String(),
-			ExecDriver:      daemon.execDriver.Name(),
-			State:           NewState(),
-			execCommands:    newExecStore(),
-			MountPoints:     map[string]*mountPoint{},
-		},
-	}
-	container.root = daemon.containerRoot(container.ID)
+		CommonContainer: base,
+	}
 
 	return container, err
 }
@@ -772,7 +761,7 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo
 		return nil, err
 	}
 
-	volumesDriver, err := local.New(filepath.Join(config.Root, defaultVolumesPathName))
+	volumesDriver, err := local.New(config.Root)
 	if err != nil {
 		return nil, err
 	}
@@ -1246,3 +1235,15 @@ func (daemon *Daemon) setHostConfig(container *Container, hostConfig *runconfig.
 	container.toDisk()
 	return nil
 }
+
+func (daemon *Daemon) newBaseContainer(id string) CommonContainer {
+	return CommonContainer{
+		ID:           id,
+		State:        NewState(),
+		MountPoints:  make(map[string]*mountPoint),
+		Volumes:      make(map[string]string),
+		VolumesRW:    make(map[string]bool),
+		execCommands: newExecStore(),
+		root:         daemon.containerRoot(id),
+	}
+}

daemon/daemon_test.go

@@ -12,6 +12,8 @@ import (
 	"github.com/docker/docker/pkg/stringid"
 	"github.com/docker/docker/pkg/truncindex"
 	"github.com/docker/docker/volume"
+	"github.com/docker/docker/volume/drivers"
+	"github.com/docker/docker/volume/local"
 )
 
 //
@@ -178,10 +180,11 @@ func TestLoadWithVolume(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	daemon := &Daemon{
-		repository: tmp,
-		root:       tmp,
+	daemon, err := initDaemonForVolumesTest(tmp)
+	if err != nil {
+		t.Fatal(err)
 	}
+	defer volumedrivers.Unregister(volume.DefaultDriverName)
 
 	c, err := daemon.load(containerId)
 	if err != nil {
@@ -214,7 +217,7 @@ func TestLoadWithVolume(t *testing.T) {
 		t.Fatalf("Expected mount driver local, was %s\n", m.Driver)
 	}
 
-	newVolumeContent := filepath.Join(volumePath, "helo")
+	newVolumeContent := filepath.Join(volumePath, local.VolumeDataPathName, "helo")
 	b, err := ioutil.ReadFile(newVolumeContent)
 	if err != nil {
 		t.Fatal(err)
@@ -265,10 +268,11 @@ func TestLoadWithBindMount(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	daemon := &Daemon{
-		repository: tmp,
-		root:       tmp,
+	daemon, err := initDaemonForVolumesTest(tmp)
+	if err != nil {
+		t.Fatal(err)
 	}
+	defer volumedrivers.Unregister(volume.DefaultDriverName)
 
 	c, err := daemon.load(containerId)
 	if err != nil {
@@ -301,3 +305,212 @@ func TestLoadWithBindMount(t *testing.T) {
 		t.Fatalf("Expected mount point to be RW but it was not\n")
 	}
 }
+
+func TestLoadWithVolume17RC(t *testing.T) {
+	tmp, err := ioutil.TempDir("", "docker-daemon-test-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+
+	containerId := "d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e"
+	containerPath := filepath.Join(tmp, containerId)
+	if err := os.MkdirAll(containerPath, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	hostVolumeId := "6a3c03fc4a4e588561a543cc3bdd50089e27bd11bbb0e551e19bf735e2514101"
+	volumePath := filepath.Join(tmp, "volumes", hostVolumeId)
+
+	if err := os.MkdirAll(volumePath, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	content := filepath.Join(volumePath, "helo")
+	if err := ioutil.WriteFile(content, []byte("HELO"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	config := `{"State":{"Running":true,"Paused":false,"Restarting":false,"OOMKilled":false,"Dead":false,"Pid":2464,"ExitCode":0,
+"Error":"","StartedAt":"2015-05-26T16:48:53.869308965Z","FinishedAt":"0001-01-01T00:00:00Z"},
+"ID":"d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e","Created":"2015-05-26T16:48:53.7987917Z","Path":"top",
+"Args":[],"Config":{"Hostname":"d59df5276e7b","Domainname":"","User":"","Memory":0,"MemorySwap":0,"CpuShares":0,"Cpuset":"",
+"AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"PortSpecs":null,"ExposedPorts":null,"Tty":true,"OpenStdin":true,
+"StdinOnce":false,"Env":null,"Cmd":["top"],"Image":"ubuntu:latest","Volumes":null,"WorkingDir":"","Entrypoint":null,
+"NetworkDisabled":false,"MacAddress":"","OnBuild":null,"Labels":{}},"Image":"07f8e8c5e66084bef8f848877857537ffe1c47edd01a93af27e7161672ad0e95",
+"NetworkSettings":{"IPAddress":"172.17.0.1","IPPrefixLen":16,"MacAddress":"02:42:ac:11:00:01","LinkLocalIPv6Address":"fe80::42:acff:fe11:1",
+"LinkLocalIPv6PrefixLen":64,"GlobalIPv6Address":"","GlobalIPv6PrefixLen":0,"Gateway":"172.17.42.1","IPv6Gateway":"","Bridge":"docker0","PortMapping":null,"Ports":{}},
+"ResolvConfPath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/resolv.conf",
+"HostnamePath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/hostname",
+"HostsPath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/hosts",
+"LogPath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e-json.log",
+"Name":"/ubuntu","Driver":"aufs","ExecDriver":"native-0.2","MountLabel":"","ProcessLabel":"","AppArmorProfile":"","RestartCount":0,
+"UpdateDns":false,"MountPoints":{"/vol1":{"Name":"6a3c03fc4a4e588561a543cc3bdd50089e27bd11bbb0e551e19bf735e2514101","Destination":"/vol1","Driver":"local","RW":true,"Source":"","Relabel":""}},"AppliedVolumesFrom":null}`
+
+	if err = ioutil.WriteFile(filepath.Join(containerPath, "config.json"), []byte(config), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	hostConfig := `{"Binds":[],"ContainerIDFile":"","LxcConf":[],"Memory":0,"MemorySwap":0,"CpuShares":0,"CpusetCpus":"",
+"Privileged":false,"PortBindings":{},"Links":null,"PublishAllPorts":false,"Dns":null,"DnsSearch":null,"ExtraHosts":null,"VolumesFrom":null,
+"Devices":[],"NetworkMode":"bridge","IpcMode":"","PidMode":"","CapAdd":null,"CapDrop":null,"RestartPolicy":{"Name":"no","MaximumRetryCount":0},
+"SecurityOpt":null,"ReadonlyRootfs":false,"Ulimits":null,"LogConfig":{"Type":"","Config":null},"CgroupParent":""}`
+	if err = ioutil.WriteFile(filepath.Join(containerPath, "hostconfig.json"), []byte(hostConfig), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	daemon, err := initDaemonForVolumesTest(tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer volumedrivers.Unregister(volume.DefaultDriverName)
+
+	c, err := daemon.load(containerId)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = daemon.verifyVolumesInfo(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(c.MountPoints) != 1 {
+		t.Fatalf("Expected 1 volume mounted, was 0\n")
+	}
+
+	m := c.MountPoints["/vol1"]
+	if m.Name != hostVolumeId {
+		t.Fatalf("Expected mount name to be %s, was %s\n", hostVolumeId, m.Name)
+	}
+
+	if m.Destination != "/vol1" {
+		t.Fatalf("Expected mount destination /vol1, was %s\n", m.Destination)
+	}
+
+	if !m.RW {
+		t.Fatalf("Expected mount point to be RW but it was not\n")
+	}
+
+	if m.Driver != volume.DefaultDriverName {
+		t.Fatalf("Expected mount driver local, was %s\n", m.Driver)
+	}
+
+	newVolumeContent := filepath.Join(volumePath, local.VolumeDataPathName, "helo")
+	b, err := ioutil.ReadFile(newVolumeContent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(b) != "HELO" {
+		t.Fatalf("Expected HELO, was %s\n", string(b))
+	}
+}
+
+func TestRemoveLocalVolumesFollowingSymlinks(t *testing.T) {
+	tmp, err := ioutil.TempDir("", "docker-daemon-test-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+
+	containerId := "d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e"
+	containerPath := filepath.Join(tmp, containerId)
+	if err := os.MkdirAll(containerPath, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	hostVolumeId := stringid.GenerateRandomID()
+	vfsPath := filepath.Join(tmp, "vfs", "dir", hostVolumeId)
+	volumePath := filepath.Join(tmp, "volumes", hostVolumeId)
+
+	if err := os.MkdirAll(vfsPath, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(volumePath, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	content := filepath.Join(vfsPath, "helo")
+	if err := ioutil.WriteFile(content, []byte("HELO"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	config := `{"State":{"Running":true,"Paused":false,"Restarting":false,"OOMKilled":false,"Dead":false,"Pid":2464,"ExitCode":0,
+"Error":"","StartedAt":"2015-05-26T16:48:53.869308965Z","FinishedAt":"0001-01-01T00:00:00Z"},
+"ID":"d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e","Created":"2015-05-26T16:48:53.7987917Z","Path":"top",
+"Args":[],"Config":{"Hostname":"d59df5276e7b","Domainname":"","User":"","Memory":0,"MemorySwap":0,"CpuShares":0,"Cpuset":"",
+"AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"PortSpecs":null,"ExposedPorts":null,"Tty":true,"OpenStdin":true,
+"StdinOnce":false,"Env":null,"Cmd":["top"],"Image":"ubuntu:latest","Volumes":null,"WorkingDir":"","Entrypoint":null,
+"NetworkDisabled":false,"MacAddress":"","OnBuild":null,"Labels":{}},"Image":"07f8e8c5e66084bef8f848877857537ffe1c47edd01a93af27e7161672ad0e95",
+"NetworkSettings":{"IPAddress":"172.17.0.1","IPPrefixLen":16,"MacAddress":"02:42:ac:11:00:01","LinkLocalIPv6Address":"fe80::42:acff:fe11:1",
+"LinkLocalIPv6PrefixLen":64,"GlobalIPv6Address":"","GlobalIPv6PrefixLen":0,"Gateway":"172.17.42.1","IPv6Gateway":"","Bridge":"docker0","PortMapping":null,"Ports":{}},
+"ResolvConfPath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/resolv.conf",
+"HostnamePath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/hostname",
+"HostsPath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/hosts",
+"LogPath":"/var/lib/docker/containers/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e/d59df5276e7b219d510fe70565e0404bc06350e0d4b43fe961f22f339980170e-json.log",
+"Name":"/ubuntu","Driver":"aufs","ExecDriver":"native-0.2","MountLabel":"","ProcessLabel":"","AppArmorProfile":"","RestartCount":0,
+"UpdateDns":false,"Volumes":{"/vol1":"%s"},"VolumesRW":{"/vol1":true},"AppliedVolumesFrom":null}`
+
+	cfg := fmt.Sprintf(config, vfsPath)
+	if err = ioutil.WriteFile(filepath.Join(containerPath, "config.json"), []byte(cfg), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	hostConfig := `{"Binds":[],"ContainerIDFile":"","LxcConf":[],"Memory":0,"MemorySwap":0,"CpuShares":0,"CpusetCpus":"",
+"Privileged":false,"PortBindings":{},"Links":null,"PublishAllPorts":false,"Dns":null,"DnsSearch":null,"ExtraHosts":null,"VolumesFrom":null,
+"Devices":[],"NetworkMode":"bridge","IpcMode":"","PidMode":"","CapAdd":null,"CapDrop":null,"RestartPolicy":{"Name":"no","MaximumRetryCount":0},
+"SecurityOpt":null,"ReadonlyRootfs":false,"Ulimits":null,"LogConfig":{"Type":"","Config":null},"CgroupParent":""}`
+	if err = ioutil.WriteFile(filepath.Join(containerPath, "hostconfig.json"), []byte(hostConfig), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	daemon, err := initDaemonForVolumesTest(tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer volumedrivers.Unregister(volume.DefaultDriverName)
+
+	c, err := daemon.load(containerId)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = daemon.verifyVolumesInfo(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(c.MountPoints) != 1 {
+		t.Fatalf("Expected 1 volume mounted, was 0\n")
+	}
+
+	m := c.MountPoints["/vol1"]
+	v, err := createVolume(m.Name, m.Driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := removeVolume(v); err != nil {
+		t.Fatal(err)
+	}
+
+	fi, err := os.Stat(vfsPath)
+	if err == nil || !os.IsNotExist(err) {
+		t.Fatalf("Expected vfs path to not exist: %v - %v\n", fi, err)
+	}
+}
+
+func initDaemonForVolumesTest(tmp string) (*Daemon, error) {
+	daemon := &Daemon{
+		repository: tmp,
+		root:       tmp,
+	}
+
+	volumesDriver, err := local.New(tmp)
+	if err != nil {
+		return nil, err
+	}
+	volumedrivers.Register(volumesDriver, volumesDriver.Name())
+
+	return daemon, nil
+}

daemon/volumes.go

@@ -1,16 +1,17 @@
 package daemon
 
 import (
-	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
 
+	"github.com/Sirupsen/logrus"
 	"github.com/docker/docker/pkg/chrootarchive"
 	"github.com/docker/docker/runconfig"
 	"github.com/docker/docker/volume"
+	"github.com/docker/docker/volume/local"
 	"github.com/docker/libcontainer/label"
 )
 
@@ -52,6 +53,13 @@ func (m *mountPoint) Path() string {
 	return m.Source
 }
 
+// BackwardsCompatible decides whether this mount point can be
+// used in old versions of Docker or not.
+// Only bind mounts and local volumes can be used in old versions of Docker.
+func (m *mountPoint) BackwardsCompatible() bool {
+	return len(m.Source) > 0 || m.Driver == volume.DefaultDriverName
+}
+
 func parseBindMount(spec string, mountLabel string, config *runconfig.Config) (*mountPoint, error) {
 	bind := &mountPoint{
 		RW: true,
@@ -231,8 +239,20 @@ func (daemon *Daemon) registerMountPoints(container *Container, hostConfig *runc
 		mountPoints[bind.Destination] = bind
 	}
 
+	// Keep backwards compatible structures
+	bcVolumes := map[string]string{}
+	bcVolumesRW := map[string]bool{}
+	for _, m := range mountPoints {
+		if m.BackwardsCompatible() {
+			bcVolumes[m.Destination] = m.Path()
+			bcVolumesRW[m.Destination] = m.RW
+		}
+	}
+
 	container.Lock()
 	container.MountPoints = mountPoints
+	container.Volumes = bcVolumes
+	container.VolumesRW = bcVolumesRW
 	container.Unlock()
 
 	return nil
@@ -241,53 +261,77 @@ func (daemon *Daemon) registerMountPoints(container *Container, hostConfig *runc
 // verifyVolumesInfo ports volumes configured for the containers pre docker 1.7.
 // It reads the container configuration and creates valid mount points for the old volumes.
 func (daemon *Daemon) verifyVolumesInfo(container *Container) error {
-	jsonPath, err := container.jsonPath()
-	if err != nil {
-		return err
-	}
-	f, err := os.Open(jsonPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
+	// Inspect old structures only when we're upgrading from old versions
+	// to versions >= 1.7 and the MountPoints has not been populated with volumes data.
+	if len(container.MountPoints) == 0 && len(container.Volumes) > 0 {
+		for destination, hostPath := range container.Volumes {
+			vfsPath := filepath.Join(daemon.root, "vfs", "dir")
+			rw := container.VolumesRW != nil && container.VolumesRW[destination]
+
+			if strings.HasPrefix(hostPath, vfsPath) {
+				id := filepath.Base(hostPath)
+				if err := migrateVolume(id, hostPath); err != nil {
+					return err
+				}
+				container.addLocalMountPoint(id, destination, rw)
+			} else { // Bind mount
+				id, source, err := parseVolumeSource(hostPath)
+				// We should not find an error here coming
+				// from the old configuration, but who knows.
+				if err != nil {
+					return err
+				}
+				container.addBindMountPoint(id, source, destination, rw)
+			}
+		}
+	} else if len(container.MountPoints) > 0 {
+		// Volumes created with a Docker version >= 1.7. We verify integrity in case of data created
+		// with Docker 1.7 RC versions that put the information in
+		// DOCKER_ROOT/volumes/VOLUME_ID rather than DOCKER_ROOT/volumes/VOLUME_ID/_container_data.
+		l, err := getVolumeDriver(volume.DefaultDriverName)
+		if err != nil {
+			return err
 		}
-		return err
-	}
-
-	type oldContVolCfg struct {
-		Volumes   map[string]string
-		VolumesRW map[string]bool
-	}
 
-	vols := oldContVolCfg{
-		Volumes:   make(map[string]string),
-		VolumesRW: make(map[string]bool),
-	}
-	if err := json.NewDecoder(f).Decode(&vols); err != nil {
-		return err
-	}
+		for _, m := range container.MountPoints {
+			if m.Driver != volume.DefaultDriverName {
+				continue
+			}
+			dataPath := l.(*local.Root).DataPath(m.Name)
+			volumePath := filepath.Dir(dataPath)
 
-	for destination, hostPath := range vols.Volumes {
-		vfsPath := filepath.Join(daemon.root, "vfs", "dir")
-		rw := vols.VolumesRW[destination]
+			d, err := ioutil.ReadDir(volumePath)
+			if err != nil {
+				// If the volume directory doesn't exist yet it will be recreated,
+				// so we only return the error when there is a different issue.
+				if !os.IsNotExist(err) {
+					return err
+				}
+				// Do not check when the volume directory does not exist.
+				continue
+			}
+			if validVolumeLayout(d) {
+				continue
+			}
 
-		if strings.HasPrefix(hostPath, vfsPath) {
-			id := filepath.Base(hostPath)
-			if err := daemon.migrateVolume(id, hostPath); err != nil {
+			if err := os.Mkdir(dataPath, 0755); err != nil {
 				return err
 			}
-			container.addLocalMountPoint(id, destination, rw)
-		} else { // Bind mount
-			id, source, err := parseVolumeSource(hostPath)
-			// We should not find an error here coming
-			// from the old configuration, but who knows.
-			if err != nil {
-				return err
+
+			// Move data inside the data directory
+			for _, f := range d {
+				oldp := filepath.Join(volumePath, f.Name())
+				newp := filepath.Join(dataPath, f.Name())
+				if err := os.Rename(oldp, newp); err != nil {
+					logrus.Errorf("Unable to move %s to %s\n", oldp, newp)
+				}
 			}
-			container.addBindMountPoint(id, source, destination, rw)
 		}
+
+		return container.ToDisk()
 	}
 
-	return container.ToDisk()
+	return nil
 }
 
 func createVolume(name, driverName string) (volume.Volume, error) {

daemon/volumes_linux.go

@@ -8,9 +8,10 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/Sirupsen/logrus"
 	"github.com/docker/docker/daemon/execdriver"
 	"github.com/docker/docker/pkg/system"
+	"github.com/docker/docker/volume"
+	"github.com/docker/docker/volume/local"
 )
 
 // copyOwnership copies the permissions and uid:gid of the source file
@@ -70,33 +71,49 @@ func (m mounts) parts(i int) int {
 	return len(strings.Split(filepath.Clean(m[i].Destination), string(os.PathSeparator)))
 }
 
-// migrateVolume moves the contents of a volume created pre Docker 1.7
-// to the location expected by the local driver. Steps:
-// 1. Save old directory that includes old volume's config json file.
-// 2. Move virtual directory with content to where the local driver expects it to be.
-// 3. Remove the backup of the old volume config.
-func (daemon *Daemon) migrateVolume(id, vfs string) error {
-	volumeInfo := filepath.Join(daemon.root, defaultVolumesPathName, id)
-	backup := filepath.Join(daemon.root, defaultVolumesPathName, id+".back")
-
-	var err error
-	if err = os.Rename(volumeInfo, backup); err != nil {
+// migrateVolume links the contents of a volume created pre Docker 1.7
+// into the location expected by the local driver.
+// It creates a symlink from DOCKER_ROOT/vfs/dir/VOLUME_ID to DOCKER_ROOT/volumes/VOLUME_ID/_container_data.
+// It preserves the volume json configuration generated pre Docker 1.7 to be able to
+// downgrade from Docker 1.7 to Docker 1.6 without losing volume compatibility.
+func migrateVolume(id, vfs string) error {
+	l, err := getVolumeDriver(volume.DefaultDriverName)
+	if err != nil {
 		return err
 	}
-	defer func() {
-		// Put old configuration back in place in case one of the next steps fails.
-		if err != nil {
-			os.Rename(backup, volumeInfo)
-		}
-	}()
 
-	if err = os.Rename(vfs, volumeInfo); err != nil {
+	newDataPath := l.(*local.Root).DataPath(id)
+	fi, err := os.Stat(newDataPath)
+	if err != nil && !os.IsNotExist(err) {
 		return err
 	}
 
-	if err = os.RemoveAll(backup); err != nil {
-		logrus.Errorf("Unable to remove volume info backup directory %s: %v", backup, err)
+	if fi != nil && fi.IsDir() {
+		return nil
+	}
+
+	return os.Symlink(vfs, newDataPath)
+}
+
+// validVolumeLayout checks whether the volume directory layout
+// is valid to work with Docker post 1.7 or not.
+func validVolumeLayout(files []os.FileInfo) bool {
+	if len(files) == 1 && files[0].Name() == local.VolumeDataPathName && files[0].IsDir() {
+		return true
+	}
+
+	if len(files) != 2 {
+		return false
+	}
+
+	for _, f := range files {
+		if f.Name() == "config.json" ||
+			(f.Name() == local.VolumeDataPathName && f.Mode()&os.ModeSymlink == os.ModeSymlink) {
+			// Old volume configuration, we ignore it
+			continue
+		}
+		return false
 	}
 
-	return nil
+	return true
 }

daemon/volumes_windows.go

@@ -2,7 +2,11 @@
 
 package daemon
 
-import "github.com/docker/docker/daemon/execdriver"
+import (
+	"os"
+
+	"github.com/docker/docker/daemon/execdriver"
+)
 
 // Not supported on Windows
 func copyOwnership(source, destination string) error {
@@ -13,6 +17,10 @@ func (container *Container) setupMounts() ([]execdriver.Mount, error) {
 	return nil, nil
 }
 
-func (daemon *Daemon) migrateVolume(id, vfs string) error {
+func migrateVolume(id, vfs string) error {
 	return nil
 }
+
+func validVolumeLayout(files []os.FileInfo) bool {
+	return true
+}

volume/local/local.go

@@ -6,29 +6,46 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 
 	"github.com/docker/docker/volume"
 )
 
-func New(rootDirectory string) (*Root, error) {
+// VolumeDataPathName is the name of the directory where the volume data is stored.
+// It uses a very distintive name to avoid colissions migrating data between
+// Docker versions.
+const (
+	VolumeDataPathName = "_data"
+	volumesPathName    = "volumes"
+)
+
+var oldVfsDir = filepath.Join("vfs", "dir")
+
+func New(scope string) (*Root, error) {
+	rootDirectory := filepath.Join(scope, volumesPathName)
+
 	if err := os.MkdirAll(rootDirectory, 0700); err != nil {
 		return nil, err
 	}
+
 	r := &Root{
+		scope:   scope,
 		path:    rootDirectory,
 		volumes: make(map[string]*Volume),
 	}
+
 	dirs, err := ioutil.ReadDir(rootDirectory)
 	if err != nil {
 		return nil, err
 	}
+
 	for _, d := range dirs {
 		name := filepath.Base(d.Name())
 		r.volumes[name] = &Volume{
 			driverName: r.Name(),
 			name:       name,
-			path:       filepath.Join(rootDirectory, name),
+			path:       r.DataPath(name),
 		}
 	}
 	return r, nil
@@ -36,10 +53,15 @@ func New(rootDirectory string) (*Root, error) {
 
 type Root struct {
 	m       sync.Mutex
+	scope   string
 	path    string
 	volumes map[string]*Volume
 }
 
+func (r *Root) DataPath(volumeName string) string {
+	return filepath.Join(r.path, volumeName, VolumeDataPathName)
+}
+
 func (r *Root) Name() string {
 	return "local"
 }
@@ -47,12 +69,13 @@ func (r *Root) Name() string {
 func (r *Root) Create(name string) (volume.Volume, error) {
 	r.m.Lock()
 	defer r.m.Unlock()
+
 	v, exists := r.volumes[name]
 	if !exists {
-		path := filepath.Join(r.path, name)
-		if err := os.Mkdir(path, 0755); err != nil {
+		path := r.DataPath(name)
+		if err := os.MkdirAll(path, 0755); err != nil {
 			if os.IsExist(err) {
-				return nil, fmt.Errorf("volume already exists under %s", path)
+				return nil, fmt.Errorf("volume already exists under %s", filepath.Dir(path))
 			}
 			return nil, err
 		}
@@ -76,12 +99,40 @@ func (r *Root) Remove(v volume.Volume) error {
 	}
 	lv.release()
 	if lv.usedCount == 0 {
+		realPath, err := filepath.EvalSymlinks(lv.path)
+		if err != nil {
+			return err
+		}
+		if !r.scopedPath(realPath) {
+			return fmt.Errorf("Unable to remove a directory of out the Docker root: %s", realPath)
+		}
+
+		if err := os.RemoveAll(realPath); err != nil {
+			return err
+		}
+
 		delete(r.volumes, lv.name)
-		return os.RemoveAll(lv.path)
+		return os.RemoveAll(filepath.Dir(lv.path))
 	}
 	return nil
 }
 
+// scopedPath verifies that the path where the volume is located
+// is under Docker's root and the valid local paths.
+func (r *Root) scopedPath(realPath string) bool {
+	// Volumes path for Docker version >= 1.7
+	if strings.HasPrefix(realPath, filepath.Join(r.scope, volumesPathName)) {
+		return true
+	}
+
+	// Volumes path for Docker version < 1.7
+	if strings.HasPrefix(realPath, filepath.Join(r.scope, oldVfsDir)) {
+		return true
+	}
+
+	return false
+}
+
 type Volume struct {
 	m         sync.Mutex
 	usedCount int