@@ -65,6 +65,9 @@ func (cli *DockerCli) CmdVolumeLs(args ...string) error {

 	w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)

 	if !*quiet {

+		for _, warn := range volumes.Warnings {

+			fmt.Fprintln(cli.err, warn)

+		}

 		fmt.Fprintf(w, "DRIVER \tVOLUME NAME")

 		fmt.Fprintf(w, "\n")

 	}

@@ -102,7 +105,7 @@ func (cli *DockerCli) CmdVolumeInspect(args ...string) error {

 	return cli.inspectElements(*tmplStr, cmd.Args(), inspectSearcher)

 }

-// CmdVolumeCreate creates a new container from a given image.

+// CmdVolumeCreate creates a new volume.

 //

 // Usage: docker volume create [OPTIONS]

 func (cli *DockerCli) CmdVolumeCreate(args ...string) error {

@@ -131,7 +134,7 @@ func (cli *DockerCli) CmdVolumeCreate(args ...string) error {

 	return nil

 }

-// CmdVolumeRm removes one or more containers.

+// CmdVolumeRm removes one or more volumes.

 //

 // Usage: docker volume rm VOLUME [VOLUME...]

 func (cli *DockerCli) CmdVolumeRm(args ...string) error {

@@ -140,6 +143,7 @@ func (cli *DockerCli) CmdVolumeRm(args ...string) error {

 	cmd.ParseFlags(args, true)

 	var status = 0

+

 	for _, name := range cmd.Args() {

 		if err := cli.client.VolumeRemove(name); err != nil {

 			fmt.Fprintf(cli.err, "%s\n", err)

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

 // Backend is the methods that need to be implemented to provide

 // volume specific functionality

 type Backend interface {

-	Volumes(filter string) ([]*types.Volume, error)

+	Volumes(filter string) ([]*types.Volume, []string, error)

 	VolumeInspect(name string) (*types.Volume, error)

 	VolumeCreate(name, driverName string,

 		opts map[string]string) (*types.Volume, error)

@@ -14,11 +14,11 @@ func (v *volumeRouter) getVolumesList(ctx context.Context, w http.ResponseWriter

 		return err

 	}

-	volumes, err := v.backend.Volumes(r.Form.Get("filters"))

+	volumes, warnings, err := v.backend.Volumes(r.Form.Get("filters"))

 	if err != nil {

 		return err

 	}

-	return httputils.WriteJSON(w, http.StatusOK, &types.VolumesListResponse{Volumes: volumes})

+	return httputils.WriteJSON(w, http.StatusOK, &types.VolumesListResponse{Volumes: volumes, Warnings: warnings})

 }

 func (v *volumeRouter) getVolumeByName(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

@@ -366,7 +366,8 @@ type Volume struct {

 // VolumesListResponse contains the response for the remote API:

 // GET "/volumes"

 type VolumesListResponse struct {

-	Volumes []*Volume // Volumes is the list of volumes being returned

+	Volumes  []*Volume // Volumes is the list of volumes being returned

+	Warnings []string  // Warnings is a list of warnings that occurred when getting the list from the volume drivers

 }

 // VolumeCreateRequest contains the response for the remote API:

@@ -10,7 +10,7 @@ import (

 	"github.com/docker/docker/layer"

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

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

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

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

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

 )

@@ -162,17 +162,12 @@ func (daemon *Daemon) VolumeCreate(name, driverName string, opts map[string]stri

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

 	if err != nil {

+		if volumestore.IsNameConflict(err) {

+			return nil, derr.ErrorVolumeNameTaken.WithArgs(name)

+		}

 		return nil, err

 	}

-	// keep "docker run -v existing_volume:/foo --volume-driver other_driver" work

-	if (driverName != "" && v.DriverName() != driverName) || (driverName == "" && v.DriverName() != volume.DefaultDriverName) {

-		return nil, derr.ErrorVolumeNameTaken.WithArgs(name, v.DriverName())

-	}

-

-	if driverName == "" {

-		driverName = volume.DefaultDriverName

-	}

-	daemon.LogVolumeEvent(name, "create", map[string]string{"driver": driverName})

+	daemon.LogVolumeEvent(v.Name(), "create", map[string]string{"driver": v.DriverName()})

 	return volumeToAPIType(v), nil

 }

@@ -51,7 +51,7 @@ func (daemon *Daemon) createContainerPlatformSpecificSettings(container *contain

 			}

 		}

-		v, err := daemon.createVolume(name, volumeDriver, nil)

+		v, err := daemon.volumes.CreateWithRef(name, volumeDriver, container.ID, nil)

 		if err != nil {

 			return err

 		}

@@ -42,7 +42,7 @@ func (daemon *Daemon) createContainerPlatformSpecificSettings(container *contain

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

 		// a new one will be created.

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

+		v, err := daemon.volumes.CreateWithRef(mp.Name, volumeDriver, container.ID, nil)

 		if err != nil {

 			return err

 		}

@@ -1487,10 +1487,7 @@ func configureVolumes(config *Config, rootUID, rootGID int) (*store.VolumeStore,

 	}

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

-	s := store.New()

-	s.AddAll(volumesDriver.List())

-

-	return s, nil

+	return store.New(), nil

 }

 // AuthenticateToRegistry checks the validity of credentials in authConfig

@@ -151,6 +151,7 @@ func (daemon *Daemon) VolumeRm(name string) error {

 	if err != nil {

 		return err

 	}

+

 	if err := daemon.volumes.Remove(v); err != nil {

 		if volumestore.IsInUse(err) {

 			return derr.ErrorCodeRmVolumeInUse.WithArgs(err)

@@ -392,24 +392,27 @@ func (daemon *Daemon) transformContainer(container *container.Container, ctx *li

 // Volumes lists known volumes, using the filter to restrict the range

 // of volumes returned.

-func (daemon *Daemon) Volumes(filter string) ([]*types.Volume, error) {

+func (daemon *Daemon) Volumes(filter string) ([]*types.Volume, []string, error) {

 	var volumesOut []*types.Volume

 	volFilters, err := filters.FromParam(filter)

 	if err != nil {

-		return nil, err

+		return nil, nil, err

 	}

 	filterUsed := volFilters.Include("dangling") &&

 		(volFilters.ExactMatch("dangling", "true") || volFilters.ExactMatch("dangling", "1"))

-	volumes := daemon.volumes.List()

+	volumes, warnings, err := daemon.volumes.List()

+	if err != nil {

+		return nil, nil, err

+	}

+	if filterUsed {

+		volumes = daemon.volumes.FilterByUsed(volumes)

+	}

 	for _, v := range volumes {

-		if filterUsed && daemon.volumes.Count(v) > 0 {

-			continue

-		}

 		volumesOut = append(volumesOut, volumeToAPIType(v))

 	}

-	return volumesOut, nil

+	return volumesOut, warnings, nil

 }

 func populateImageFilterByParents(ancestorMap map[image.ID]bool, imageID image.ID, getChildren func(image.ID) []image.ID) {

@@ -11,10 +11,11 @@ import (

 func (daemon *Daemon) prepareMountPoints(container *container.Container) error {

 	for _, config := range container.MountPoints {

 		if len(config.Driver) > 0 {

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

+			v, err := daemon.volumes.GetWithRef(config.Name, config.Driver, container.ID)

 			if err != nil {

 				return err

 			}

+

 			config.Volume = v

 		}

 	}

@@ -27,10 +28,10 @@ func (daemon *Daemon) removeMountPoints(container *container.Container, rm bool)

 		if m.Volume == nil {

 			continue

 		}

-		daemon.volumes.Decrement(m.Volume)

+		daemon.volumes.Dereference(m.Volume, container.ID)

 		if rm {

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

-			// ErrVolumeInUse is ignored because having this

+			// Ignore volume in use errors 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"

@@ -32,16 +32,6 @@ func volumeToAPIType(v volume.Volume) *types.Volume {

 	}

 }

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

@@ -103,7 +93,7 @@ func (daemon *Daemon) registerMountPoints(container *container.Container, hostCo

 			}

 			if len(cp.Source) == 0 {

-				v, err := daemon.createVolume(cp.Name, cp.Driver, nil)

+				v, err := daemon.volumes.GetWithRef(cp.Name, cp.Driver, container.ID)

 				if err != nil {

 					return err

 				}

@@ -128,7 +118,7 @@ func (daemon *Daemon) registerMountPoints(container *container.Container, hostCo

 		if len(bind.Name) > 0 && len(bind.Driver) > 0 {

 			// create the volume

-			v, err := daemon.createVolume(bind.Name, bind.Driver, nil)

+			v, err := daemon.volumes.CreateWithRef(bind.Name, bind.Driver, container.ID, nil)

 			if err != nil {

 				return err

 			}

@@ -153,7 +143,7 @@ func (daemon *Daemon) registerMountPoints(container *container.Container, hostCo

 	for _, m := range mountPoints {

 		if m.BackwardsCompatible() {

 			if mp, exists := container.MountPoints[m.Destination]; exists && mp.Volume != nil {

-				daemon.volumes.Decrement(mp.Volume)

+				daemon.volumes.Dereference(mp.Volume, container.ID)

 			}

 		}

 	}

@@ -908,7 +908,7 @@ var (

 	// trying to create a volume that has existed using different driver.

 	ErrorVolumeNameTaken = errcode.Register(errGroup, errcode.ErrorDescriptor{

 		Value:          "VOLUME_NAME_TAKEN",

-		Message:        "A volume named %q already exists with the %q driver. Choose a different volume name.",

+		Message:        "A volume named %s already exists. Choose a different volume name.",

 		Description:    "An attempt to create a volume using a driver but the volume already exists with a different driver",

 		HTTPStatusCode: http.StatusInternalServerError,

 	})

@@ -1733,8 +1733,8 @@ func (s *DockerDaemonSuite) TestDaemonRestartRmVolumeInUse(c *check.C) {

 	c.Assert(s.d.Restart(), check.IsNil)

 	out, err = s.d.Cmd("volume", "rm", "test")

-	c.Assert(err, check.Not(check.IsNil), check.Commentf("should not be able to remove in use volume after daemon restart"))

-	c.Assert(strings.Contains(out, "in use"), check.Equals, true)

+	c.Assert(err, check.NotNil, check.Commentf("should not be able to remove in use volume after daemon restart"))

+	c.Assert(out, checker.Contains, "in use")

 }

 func (s *DockerDaemonSuite) TestDaemonRestartLocalVolumes(c *check.C) {

@@ -32,6 +32,8 @@ type eventCounter struct {

 	mounts      int

 	unmounts    int

 	paths       int

+	lists       int

+	gets        int

 }

 type DockerExternalVolumeSuite struct {

@@ -64,6 +66,12 @@ func (s *DockerExternalVolumeSuite) SetUpSuite(c *check.C) {

 		Err        string `json:",omitempty"`

 	}

+	type vol struct {

+		Name       string

+		Mountpoint string

+	}

+	var volList []vol

+

 	read := func(b io.ReadCloser) (pluginRequest, error) {

 		defer b.Close()

 		var pr pluginRequest

@@ -93,29 +101,61 @@ func (s *DockerExternalVolumeSuite) SetUpSuite(c *check.C) {

 	mux.HandleFunc("/VolumeDriver.Create", func(w http.ResponseWriter, r *http.Request) {

 		s.ec.creations++

+		pr, err := read(r.Body)

+		if err != nil {

+			send(w, err)

+			return

+		}

+		volList = append(volList, vol{Name: pr.Name})

+		send(w, nil)

+	})

-		_, err := read(r.Body)

+	mux.HandleFunc("/VolumeDriver.List", func(w http.ResponseWriter, r *http.Request) {

+		s.ec.lists++

+		send(w, map[string][]vol{"Volumes": volList})

+	})

+

+	mux.HandleFunc("/VolumeDriver.Get", func(w http.ResponseWriter, r *http.Request) {

+		s.ec.gets++

+		pr, err := read(r.Body)

 		if err != nil {

 			send(w, err)

 			return

 		}

-		send(w, nil)

+		for _, v := range volList {

+			if v.Name == pr.Name {

+				v.Mountpoint = hostVolumePath(pr.Name)

+				send(w, map[string]vol{"Volume": v})

+				return

+			}

+		}

+		send(w, `{"Err": "no such volume"}`)

 	})

 	mux.HandleFunc("/VolumeDriver.Remove", func(w http.ResponseWriter, r *http.Request) {

 		s.ec.removals++

-

 		pr, err := read(r.Body)

 		if err != nil {

 			send(w, err)

 			return

 		}

+

 		if err := os.RemoveAll(hostVolumePath(pr.Name)); err != nil {

 			send(w, &pluginResp{Err: err.Error()})

 			return

 		}

+		for i, v := range volList {

+			if v.Name == pr.Name {

+				if err := os.RemoveAll(hostVolumePath(v.Name)); err != nil {

+					send(w, fmt.Sprintf(`{"Err": "%v"}`, err))

+					return

+				}

+				volList = append(volList[:i], volList[i+1:]...)

+				break

+			}

+		}

 		send(w, nil)

 	})

@@ -128,8 +168,7 @@ func (s *DockerExternalVolumeSuite) SetUpSuite(c *check.C) {

 			return

 		}

 		p := hostVolumePath(pr.Name)

-

-		fmt.Fprintln(w, fmt.Sprintf("{\"Mountpoint\": \"%s\"}", p))

+		send(w, &pluginResp{Mountpoint: p})

 	})

 	mux.HandleFunc("/VolumeDriver.Mount", func(w http.ResponseWriter, r *http.Request) {

@@ -164,7 +203,7 @@ func (s *DockerExternalVolumeSuite) SetUpSuite(c *check.C) {

 			return

 		}

-		fmt.Fprintln(w, nil)

+		send(w, nil)

 	})

 	err := os.MkdirAll("/etc/docker/plugins", 0755)

@@ -287,8 +326,8 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamedCheckBindLocalV

 // Make sure a request to use a down driver doesn't block other requests

 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverLookupNotBlocked(c *check.C) {

 	specPath := "/etc/docker/plugins/down-driver.spec"

-	err := ioutil.WriteFile("/etc/docker/plugins/down-driver.spec", []byte("tcp://127.0.0.7:9999"), 0644)

-	c.Assert(err, checker.IsNil)

+	err := ioutil.WriteFile(specPath, []byte("tcp://127.0.0.7:9999"), 0644)

+	c.Assert(err, check.IsNil)

 	defer os.RemoveAll(specPath)

 	chCmd1 := make(chan struct{})

@@ -316,10 +355,11 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverLookupNotBlocked(c *

 	case err := <-chCmd2:

 		c.Assert(err, checker.IsNil)

 	case <-time.After(5 * time.Second):

-		c.Fatal("volume creates are blocked by previous create requests when previous driver is down")

 		cmd2.Process.Kill()

+		c.Fatal("volume creates are blocked by previous create requests when previous driver is down")

 	}

 }

+

 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverRetryNotImmediatelyExists(c *check.C) {

 	err := s.d.StartWithBusybox()

 	c.Assert(err, checker.IsNil)

@@ -371,3 +411,24 @@ func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverBindExternalVolume(c

 	c.Assert(mounts[0].Name, checker.Equals, "foo")

 	c.Assert(mounts[0].Driver, checker.Equals, "test-external-volume-driver")

 }

+

+func (s *DockerExternalVolumeSuite) TestStartExternalVolumeDriverList(c *check.C) {

+	dockerCmd(c, "volume", "create", "-d", "test-external-volume-driver", "--name", "abc")

+	out, _ := dockerCmd(c, "volume", "ls")

+	ls := strings.Split(strings.TrimSpace(out), "\n")

+	c.Assert(len(ls), check.Equals, 2, check.Commentf("\n%s", out))

+

+	vol := strings.Fields(ls[len(ls)-1])

+	c.Assert(len(vol), check.Equals, 2, check.Commentf("%v", vol))

+	c.Assert(vol[0], check.Equals, "test-external-volume-driver")

+	c.Assert(vol[1], check.Equals, "abc")

+

+	c.Assert(s.ec.lists, check.Equals, 1)

+}

+

+func (s *DockerExternalVolumeSuite) TestStartExternalVolumeDriverGet(c *check.C) {

+	out, _, err := dockerCmdWithError("volume", "inspect", "dummy")

+	c.Assert(err, check.NotNil, check.Commentf(out))

+	c.Assert(s.ec.gets, check.Equals, 1)

+	c.Assert(out, checker.Contains, "No such volume")

+}

@@ -4,9 +4,7 @@ import (

 	"os/exec"

 	"strings"

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

 	"github.com/docker/docker/pkg/integration/checker"

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

 	"github.com/go-check/check"

 )

@@ -25,8 +23,7 @@ func (s *DockerSuite) TestVolumeCliCreateOptionConflict(c *check.C) {

 	dockerCmd(c, "volume", "create", "--name=test")

 	out, _, err := dockerCmdWithError("volume", "create", "--name", "test", "--driver", "nosuchdriver")

 	c.Assert(err, check.NotNil, check.Commentf("volume create exception name already in use with another driver"))

-	stderr := derr.ErrorVolumeNameTaken.WithArgs("test", volume.DefaultDriverName).Error()

-	c.Assert(strings.Contains(out, strings.TrimPrefix(stderr, "volume name taken: ")), check.Equals, true)

+	c.Assert(out, checker.Contains, "A volume named test already exists")

 	out, _ = dockerCmd(c, "volume", "inspect", "--format='{{ .Driver }}'", "test")

 	_, _, err = dockerCmdWithError("volume", "create", "--name", "test", "--driver", strings.TrimSpace(out))

@@ -25,6 +25,38 @@ func newLocalRegistry() localRegistry {

 	return localRegistry{}

 }

+// Scan scans all the plugin paths and returns all the names it found

+func Scan() ([]string, error) {

+	var names []string

+	if err := filepath.Walk(socketsPath, func(path string, fi os.FileInfo, err error) error {

+		if err != nil {

+			return nil

+		}

+

+		if fi.Mode()&os.ModeSocket != 0 {

+			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))

+			names = append(names, name)

+		}

+		return nil

+	}); err != nil {

+		return nil, err

+	}

+

+	for _, path := range specsPaths {

+		if err := filepath.Walk(path, func(p string, fi os.FileInfo, err error) error {

+			if err != nil || fi.IsDir() {

+				return nil

+			}

+			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))

+			names = append(names, name)

+			return nil

+		}); err != nil {

+			return nil, err

+		}

+	}

+	return names, nil

+}

+

 // Plugin returns the plugin registered with the given name (or returns an error).

 func (l *localRegistry) Plugin(name string) (*Plugin, error) {

 	socketpaths := pluginPaths(socketsPath, name, ".sock")

@@ -108,6 +108,15 @@ func (p *Plugin) activateWithLock() error {

 	return nil

 }

+func (p *Plugin) implements(kind string) bool {

+	for _, driver := range p.Manifest.Implements {

+		if driver == kind {

+			return true

+		}

+	}

+	return false

+}

+

 func load(name string) (*Plugin, error) {

 	return loadWithRetry(name, true)

 }

@@ -166,11 +175,9 @@ func Get(name, imp string) (*Plugin, error) {

 	if err != nil {

 		return nil, err

 	}

-	for _, driver := range pl.Manifest.Implements {

-		logrus.Debugf("%s implements: %s", name, driver)

-		if driver == imp {

-			return pl, nil

-		}

+	if pl.implements(imp) {

+		logrus.Debugf("%s implements: %s", name, imp)

+		return pl, nil

 	}

 	return nil, ErrNotImplements

 }

@@ -179,3 +186,37 @@ func Get(name, imp string) (*Plugin, error) {

 func Handle(iface string, fn func(string, *Client)) {

 	extpointHandlers[iface] = fn

 }

+

+// GetAll returns all the plugins for the specified implementation

+func GetAll(imp string) ([]*Plugin, error) {

+	pluginNames, err := Scan()

+	if err != nil {

+		return nil, err

+	}

+

+	type plLoad struct {

+		pl  *Plugin

+		err error

+	}

+

+	chPl := make(chan plLoad, len(pluginNames))

+	for _, name := range pluginNames {

+		go func(name string) {

+			pl, err := loadWithRetry(name, false)

+			chPl <- plLoad{pl, err}

+		}(name)

+	}

+

+	var out []*Plugin

+	for i := 0; i < len(pluginNames); i++ {

+		pl := <-chPl

+		if pl.err != nil {

+			logrus.Error(err)

+			continue

+		}

+		if pl.pl.implements(imp) {

+			out = append(out, pl.pl)

+		}

+	}

+	return out, nil

+}

@@ -26,6 +26,38 @@ func (a *volumeDriverAdapter) Remove(v volume.Volume) error {

 	return a.proxy.Remove(v.Name())

 }

+func (a *volumeDriverAdapter) List() ([]volume.Volume, error) {

+	ls, err := a.proxy.List()

+	if err != nil {

+		return nil, err

+	}

+

+	var out []volume.Volume

+	for _, vp := range ls {

+		out = append(out, &volumeAdapter{

+			proxy:      a.proxy,

+			name:       vp.Name,

+			driverName: a.name,

+			eMount:     vp.Mountpoint,

+		})

+	}

+	return out, nil

+}

+

+func (a *volumeDriverAdapter) Get(name string) (volume.Volume, error) {

+	v, err := a.proxy.Get(name)

+	if err != nil {

+		return nil, err

+	}

+

+	return &volumeAdapter{

+		proxy:      a.proxy,

+		name:       v.Name,

+		driverName: a.Name(),

+		eMount:     v.Mountpoint,

+	}, nil

+}

+

 type volumeAdapter struct {

 	proxy      *volumeDriverProxy

 	name       string

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

 var drivers = &driverExtpoint{extensions: make(map[string]volume.Driver)}

+const extName = "VolumeDriver"

+

 // NewVolumeDriver returns a driver has the given name mapped on the given client.

 func NewVolumeDriver(name string, c client) volume.Driver {

 	proxy := &volumeDriverProxy{c}

@@ -22,6 +24,7 @@ func NewVolumeDriver(name string, c client) volume.Driver {

 }

 type opts map[string]string

+type list []*proxyVolume

 // volumeDriver defines the available functions that volume plugins must implement.

 // This interface is only defined to generate the proxy objects.

@@ -37,6 +40,10 @@ type volumeDriver interface {

 	Mount(name string) (mountpoint string, err error)

 	// Unmount the given volume

 	Unmount(name string) (err error)

+	// List lists all the volumes known to the driver

+	List() (volumes list, err error)

+	// Get retreives the volume with the requested name

+	Get(name string) (volume *proxyVolume, err error)

 }

 type driverExtpoint struct {

@@ -82,7 +89,7 @@ func Lookup(name string) (volume.Driver, error) {

 	if ok {

 		return ext, nil

 	}

-	pl, err := plugins.Get(name, "VolumeDriver")

+	pl, err := plugins.Get(name, extName)

 	if err != nil {

 		return nil, fmt.Errorf("Error looking up volume plugin %s: %v", name, err)

 	}

@@ -116,3 +123,30 @@ func GetDriverList() []string {

 	}

 	return driverList

 }

+

+// GetAllDrivers lists all the registered drivers

+func GetAllDrivers() ([]volume.Driver, error) {

+	plugins, err := plugins.GetAll(extName)

+	if err != nil {

+		return nil, err

+	}

+	var ds []volume.Driver

+

+	drivers.Lock()

+	defer drivers.Unlock()

+

+	for _, d := range drivers.extensions {

+		ds = append(ds, d)

+	}

+

+	for _, p := range plugins {

+		ext, ok := drivers.extensions[p.Name]

+		if ok {

+			continue

+		}

+		ext = NewVolumeDriver(p.Name, p.Client)

+		drivers.extensions[p.Name] = ext

+		ds = append(ds, ext)

+	}

+	return ds, nil

+}

@@ -11,7 +11,8 @@ func TestGetDriver(t *testing.T) {

 	if err == nil {

 		t.Fatal("Expected error, was nil")

 	}

-	Register(volumetestutils.FakeDriver{}, "fake")

+

+	Register(volumetestutils.NewFakeDriver("fake"), "fake")

 	d, err := GetDriver("fake")

 	if err != nil {

 		t.Fatal(err)

@@ -149,3 +149,59 @@ func (pp *volumeDriverProxy) Unmount(name string) (err error) {

 	return

 }

+

+type volumeDriverProxyListRequest struct {

+}

+

+type volumeDriverProxyListResponse struct {

+	Volumes list

+	Err     string

+}

+

+func (pp *volumeDriverProxy) List() (volumes list, err error) {

+	var (

+		req volumeDriverProxyListRequest

+		ret volumeDriverProxyListResponse

+	)

+

+	if err = pp.Call("VolumeDriver.List", req, &ret); err != nil {

+		return

+	}

+

+	volumes = ret.Volumes

+

+	if ret.Err != "" {

+		err = errors.New(ret.Err)

+	}

+

+	return

+}

+

+type volumeDriverProxyGetRequest struct {

+	Name string

+}

+

+type volumeDriverProxyGetResponse struct {

+	Volume *proxyVolume

+	Err    string

+}

+

+func (pp *volumeDriverProxy) Get(name string) (volume *proxyVolume, err error) {

+	var (

+		req volumeDriverProxyGetRequest

+		ret volumeDriverProxyGetResponse

+	)

+

+	req.Name = name

+	if err = pp.Call("VolumeDriver.Get", req, &ret); err != nil {

+		return

+	}

+

+	volume = ret.Volume

+

+	if ret.Err != "" {

+		err = errors.New(ret.Err)

+	}

+

+	return

+}

@@ -42,6 +42,16 @@ func TestVolumeRequestError(t *testing.T) {

 		fmt.Fprintln(w, `{"Err": "Unknown volume"}`)

 	})

+	mux.HandleFunc("/VolumeDriver.List", func(w http.ResponseWriter, r *http.Request) {

+		w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")

+		fmt.Fprintln(w, `{"Err": "Cannot list volumes"}`)

+	})

+

+	mux.HandleFunc("/VolumeDriver.Get", func(w http.ResponseWriter, r *http.Request) {

+		w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")

+		fmt.Fprintln(w, `{"Err": "Cannot get volume"}`)

+	})

+

 	u, _ := url.Parse(server.URL)

 	client, err := plugins.NewClient("tcp://"+u.Host, tlsconfig.Options{InsecureSkipVerify: true})

 	if err != nil {

@@ -93,4 +103,20 @@ func TestVolumeRequestError(t *testing.T) {

 	if !strings.Contains(err.Error(), "Unknown volume") {

 		t.Fatalf("Unexpected error: %v\n", err)

 	}

+

+	_, err = driver.List()

+	if err == nil {

+		t.Fatal("Expected error, was nil")

+	}

+	if !strings.Contains(err.Error(), "Cannot list volumes") {

+		t.Fatalf("Unexpected error: %v\n", err)

+	}

+

+	_, err = driver.Get("volume")

+	if err == nil {

+		t.Fatal("Expected error, was nil")

+	}

+	if !strings.Contains(err.Error(), "Cannot get volume") {

+		t.Fatalf("Unexpected error: %v\n", err)

+	}

 }

@@ -82,12 +82,12 @@ type Root struct {

 }

 // List lists all the volumes

-func (r *Root) List() []volume.Volume {

+func (r *Root) List() ([]volume.Volume, error) {

 	var ls []volume.Volume

 	for _, v := range r.volumes {

 		ls = append(ls, v)

 	}

-	return ls

+	return ls, nil

 }

 // DataPath returns the constructed path of this volume.

@@ -43,7 +43,7 @@ func TestRemove(t *testing.T) {

 		t.Fatal("volume dir not removed")

 	}

-	if len(r.List()) != 0 {

+	if l, _ := r.List(); len(l) != 0 {

 		t.Fatal("expected there to be no volumes")

 	}

 }

@@ -1,6 +1,9 @@

 package store

-import "errors"

+import (

+	"errors"

+	"strings"

+)

 var (

 	// errVolumeInUse is a typed error returned when trying to remove a volume that is currently in use by a container

@@ -9,6 +12,8 @@ var (

 	errNoSuchVolume = errors.New("no such volume")

 	// errInvalidName is a typed error returned when creating a volume with a name that is not valid on the platform

 	errInvalidName = errors.New("volume name is not valid on this platform")

+	// errNameConflict is a typed error returned on create when a volume exists with the given name, but for a different driver

+	errNameConflict = errors.New("conflict: volume name must be unique")

 )

 // OpErr is the error type returned by functions in the store package. It describes

@@ -20,6 +25,8 @@ type OpErr struct {

 	Op string

 	// Name is the name of the resource being requested for this op, typically the volume name or the driver name.

 	Name string

+	// Refs is the list of references associated with the resource.

+	Refs []string

 }

 // Error satisfies the built-in error interface type.

@@ -33,6 +40,9 @@ func (e *OpErr) Error() string {

 	}

 	s = s + ": " + e.Err.Error()

+	if len(e.Refs) > 0 {

+		s = s + " - " + "[" + strings.Join(e.Refs, ", ") + "]"

+	}

 	return s

 }

@@ -47,6 +57,12 @@ func IsNotExist(err error) bool {

 	return isErr(err, errNoSuchVolume)

 }

+// IsNameConflict returns a boolean indicating whether the error indicates that a

+// volume name is already taken

+func IsNameConflict(err error) bool {

+	return isErr(err, errNameConflict)

+}

+

 func isErr(err error, expected error) bool {

 	switch pe := err.(type) {

 	case nil:

@@ -13,66 +13,153 @@ import (

 // reference counting of volumes in the system.

 func New() *VolumeStore {

 	return &VolumeStore{

-		vols:  make(map[string]*volumeCounter),

 		locks: &locker.Locker{},

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

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

 	}

 }

-func (s *VolumeStore) get(name string) (*volumeCounter, bool) {

+func (s *VolumeStore) getNamed(name string) (string, bool) {

 	s.globalLock.Lock()

-	vc, exists := s.vols[name]

+	driverName, exists := s.names[name]

 	s.globalLock.Unlock()