@@ -241,20 +241,12 @@ func (b *builder) runContextCommand(args []string, allowRemote bool, allowDecomp

 	}

 	defer container.Unmount()

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

-		return err

-	}

-

 	for _, ci := range copyInfos {

 		if err := b.addContext(container, ci.origPath, ci.destPath, ci.decompress); err != nil {

 			return err

 		}

 	}

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

-		return err

-	}

-

 	if err := b.commit(container.ID, cmd, fmt.Sprintf("%s %s in %s", cmdName, origPaths, dest)); err != nil {

 		return err

 	}

@@ -227,6 +227,21 @@ func (container *Container) GetRootResourcePath(path string) (string, error) {

 	return symlink.FollowSymlinkInScope(filepath.Join(container.root, cleanPath), container.root)

 }

+func (container *Container) ExportRw() (archive.Archive, error) {

+	if container.daemon == nil {

+		return nil, fmt.Errorf("Can't load storage driver for unregistered container %s", container.ID)

+	}

+	archive, err := container.daemon.Diff(container)

+	if err != nil {

+		return nil, err

+	}

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

+			err := archive.Close()

+			return err

+		}),

+		nil

+}

+

 func (container *Container) Start() (err error) {

 	container.Lock()

 	defer container.Unlock()

@@ -258,12 +273,6 @@ func (container *Container) Start() (err error) {

 		return err

 	}

-	// No-op if non-Windows. Once the container filesystem is mounted,

-	// prepare the layer to boot using the Windows driver.

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

-		return err

-	}

-

 	// Make sure NetworkMode has an acceptable value. We do this to ensure

 	// backwards API compatibility.

 	container.hostConfig = runconfig.SetDefaultNetModeIfBlank(container.hostConfig)

@@ -345,10 +354,6 @@ func (container *Container) isNetworkAllocated() bool {

 func (container *Container) cleanup() {

 	container.ReleaseNetwork()

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

-		logrus.Errorf("%v: Failed to cleanup storage: %v", container.ID, err)

-	}

-

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

 		logrus.Errorf("%v: Failed to umount filesystem: %v", container.ID, err)

 	}

@@ -658,14 +663,8 @@ func (container *Container) Copy(resource string) (rc io.ReadCloser, err error)

 		return nil, err

 	}

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

-		container.Unmount()

-		return nil, err

-	}

-

 	reader := ioutils.NewReadCloserWrapper(archive, func() error {

 		err := archive.Close()

-		container.CleanupStorage()

 		container.UnmountVolumes(true)

 		container.Unmount()

 		container.Unlock()

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

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

 	"github.com/docker/docker/daemon/links"

 	"github.com/docker/docker/daemon/network"

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

 	"github.com/docker/docker/pkg/directory"

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

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

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

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

@@ -948,21 +946,6 @@ func (container *Container) initializeNetworking() error {

 	return container.buildHostnameFile()

 }

-func (container *Container) ExportRw() (archive.Archive, error) {

-	if container.daemon == nil {

-		return nil, fmt.Errorf("Can't load storage driver for unregistered container %s", container.ID)

-	}

-	archive, err := container.daemon.Diff(container)

-	if err != nil {

-		return nil, err

-	}

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

-			err := archive.Close()

-			return err

-		}),

-		nil

-}

-

 func (container *Container) getIpcContainer() (*Container, error) {

 	containerID := container.hostConfig.IpcMode.Container()

 	c, err := container.daemon.Get(containerID)

@@ -1107,14 +1090,6 @@ func (container *Container) UnmountVolumes(forceSyscall bool) error {

 	return nil

 }

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

-	return nil

-}

-

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

-	return nil

-}

-

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

 	var mounts []execdriver.Mount

 	mode := "Z"

@@ -4,14 +4,9 @@ package daemon

 import (

 	"fmt"

-	"path/filepath"

 	"strings"

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

-	"github.com/docker/docker/daemon/graphdriver/windows"

-	"github.com/docker/docker/image"

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

-	"github.com/microsoft/hcsshim"

 )

 // This is deliberately empty on Windows as the default path will be set by

@@ -98,25 +93,27 @@ func populateCommand(c *Container, env []string) error {

 	processConfig.Env = env

-	var layerFolder string

 	var layerPaths []string

-

-	// The following is specific to the Windows driver. We do this to

-	// enable VFS to continue operating for development purposes.

-	if wd, ok := c.daemon.driver.(*windows.WindowsGraphDriver); ok {

-		var err error

-		var img *image.Image

-		var ids []string

-

-		if img, err = c.daemon.graph.Get(c.ImageID); err != nil {

-			return fmt.Errorf("Failed to graph.Get on ImageID %s - %s", c.ImageID, err)

+	img, err := c.daemon.graph.Get(c.ImageID)

+	if err != nil {

+		return fmt.Errorf("Failed to graph.Get on ImageID %s - %s", c.ImageID, err)

+	}

+	for i := img; i != nil && err == nil; i, err = c.daemon.graph.GetParent(i) {

+		lp, err := c.daemon.driver.Get(i.ID, "")

+		if err != nil {

+			return fmt.Errorf("Failed to get layer path from graphdriver %s for ImageID %s - %s", c.daemon.driver.String(), i.ID, err)

 		}

-		if ids, err = c.daemon.graph.ParentLayerIds(img); err != nil {

-			return fmt.Errorf("Failed to get parentlayer ids %s", img.ID)

+		layerPaths = append(layerPaths, lp)

+		err = c.daemon.driver.Put(i.ID)

+		if err != nil {

+			return fmt.Errorf("Failed to put layer path from graphdriver %s for ImageID %s - %s", c.daemon.driver.String(), i.ID, err)

 		}

-		layerPaths = wd.LayerIdsToPaths(ids)

-		layerFolder = filepath.Join(wd.Info().HomeDir, filepath.Base(c.ID))

 	}

+	m, err := c.daemon.driver.GetMetadata(c.ID)

+	if err != nil {

+		return fmt.Errorf("Failed to get layer metadata - %s", err)

+	}

+	layerFolder := m["dir"]

 	// TODO Windows: Factor out remainder of unused fields.

 	c.command = &execdriver.Command{

@@ -151,14 +148,6 @@ func (container *Container) AllocateNetwork() error {

 	return nil

 }

-func (container *Container) ExportRw() (archive.Archive, error) {

-	if container.IsRunning() {

-		return nil, fmt.Errorf("Cannot export a running container.")

-	}

-	// TODO Windows. Implementation (different to Linux)

-	return nil, nil

-}

-

 func (container *Container) UpdateNetwork() error {

 	return nil

 }

@@ -174,36 +163,6 @@ func (container *Container) UnmountVolumes(forceSyscall bool) error {

 	return nil

 }

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

-	if wd, ok := container.daemon.driver.(*windows.WindowsGraphDriver); ok {

-		// Get list of paths to parent layers.

-		var ids []string

-		if container.ImageID != "" {

-			img, err := container.daemon.graph.Get(container.ImageID)

-			if err != nil {

-				return err

-			}

-

-			ids, err = container.daemon.graph.ParentLayerIds(img)

-			if err != nil {

-				return err

-			}

-		}

-

-		if err := hcsshim.PrepareLayer(wd.Info(), container.ID, wd.LayerIdsToPaths(ids)); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

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

-	if wd, ok := container.daemon.driver.(*windows.WindowsGraphDriver); ok {

-		return hcsshim.UnprepareLayer(wd.Info(), container.ID)

-	}

-	return nil

-}

-

 // prepareMountPoints is a no-op on Windows

 func (container *Container) prepareMountPoints() error {

 	return nil

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

 	"github.com/docker/docker/daemon/network"

 	"github.com/docker/docker/graph"

 	"github.com/docker/docker/image"

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

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

 	"github.com/docker/docker/pkg/fileutils"

 	"github.com/docker/docker/pkg/graphdb"

@@ -683,6 +684,12 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 		return nil, fmt.Errorf("Couldn't create Tag store repositories-%s: %s", d.driver.String(), err)

 	}

+	if restorer, ok := d.driver.(graphdriver.ImageRestorer); ok {

+		if _, err := restorer.RestoreCustomImages(repositories, g); err != nil {

+			return nil, fmt.Errorf("Couldn't restore custom images: %s", err)

+		}

+	}

+

 	d.netController, err = initNetworkController(config)

 	if err != nil {

 		return nil, fmt.Errorf("Error initializing network controller: %v", err)

@@ -840,6 +847,46 @@ func (daemon *Daemon) UnsubscribeToContainerStats(name string, ch chan interface

 	return nil

 }

+func (daemon *Daemon) Changes(container *Container) ([]archive.Change, error) {

+	initID := fmt.Sprintf("%s-init", container.ID)

+	return daemon.driver.Changes(container.ID, initID)

+}

+

+func (daemon *Daemon) Diff(container *Container) (archive.Archive, error) {

+	initID := fmt.Sprintf("%s-init", container.ID)

+	return daemon.driver.Diff(container.ID, initID)

+}

+

+func (daemon *Daemon) createRootfs(container *Container) error {

+	// Step 1: create the container directory.

+	// This doubles as a barrier to avoid race conditions.

+	if err := os.Mkdir(container.root, 0700); err != nil {

+		return err

+	}

+	initID := fmt.Sprintf("%s-init", container.ID)

+	if err := daemon.driver.Create(initID, container.ImageID); err != nil {

+		return err

+	}

+	initPath, err := daemon.driver.Get(initID, "")

+	if err != nil {

+		return err

+	}

+

+	if err := setupInitLayer(initPath); err != nil {

+		daemon.driver.Put(initID)

+		return err

+	}

+

+	// We want to unmount init layer before we take snapshot of it

+	// for the actual container.

+	daemon.driver.Put(initID)

+

+	if err := daemon.driver.Create(container.ID, initID); err != nil {

+		return err

+	}

+	return nil

+}

+

 // FIXME: this is a convenience function for integration tests

 // which need direct access to daemon.graph.

 // Once the tests switch to using engine and jobs, this method

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

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/autogen/dockerversion"

 	"github.com/docker/docker/daemon/graphdriver"

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

 	"github.com/docker/docker/pkg/fileutils"

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

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

@@ -39,16 +38,6 @@ const (

 	platformSupported = true

 )

-func (daemon *Daemon) Changes(container *Container) ([]archive.Change, error) {

-	initID := fmt.Sprintf("%s-init", container.ID)

-	return daemon.driver.Changes(container.ID, initID)

-}

-

-func (daemon *Daemon) Diff(container *Container) (archive.Archive, error) {

-	initID := fmt.Sprintf("%s-init", container.ID)

-	return daemon.driver.Diff(container.ID, initID)

-}

-

 func parseSecurityOpt(container *Container, config *runconfig.HostConfig) error {

 	var (

 		labelOpts []string

@@ -74,36 +63,6 @@ func parseSecurityOpt(container *Container, config *runconfig.HostConfig) error

 	return err

 }

-func (daemon *Daemon) createRootfs(container *Container) error {

-	// Step 1: create the container directory.

-	// This doubles as a barrier to avoid race conditions.

-	if err := os.Mkdir(container.root, 0700); err != nil {

-		return err

-	}

-	initID := fmt.Sprintf("%s-init", container.ID)

-	if err := daemon.driver.Create(initID, container.ImageID); err != nil {

-		return err

-	}

-	initPath, err := daemon.driver.Get(initID, "")

-	if err != nil {

-		return err

-	}

-

-	if err := setupInitLayer(initPath); err != nil {

-		daemon.driver.Put(initID)

-		return err

-	}

-

-	// We want to unmount init layer before we take snapshot of it

-	// for the actual container.

-	daemon.driver.Put(initID)

-

-	if err := daemon.driver.Create(container.ID, initID); err != nil {

-		return err

-	}

-	return nil

-}

-

 func checkKernel() error {

 	// Check for unsupported kernel versions

 	// FIXME: it would be cleaner to not test for specific versions, but rather

@@ -5,14 +5,11 @@ import (

 	"os"

 	"syscall"

-	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/daemon/graphdriver"

-	"github.com/docker/docker/daemon/graphdriver/windows"

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

+	_ "github.com/docker/docker/daemon/graphdriver/windows"

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

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/libnetwork"

-	"github.com/microsoft/hcsshim"

 )

 const (

@@ -20,55 +17,11 @@ const (

 	platformSupported    = true

 )

-func (daemon *Daemon) Changes(container *Container) ([]archive.Change, error) {

-	return daemon.driver.Changes(container.ID, container.ImageID)

-}

-

-func (daemon *Daemon) Diff(container *Container) (archive.Archive, error) {

-	return daemon.driver.Diff(container.ID, container.ImageID)

-}

-

 func parseSecurityOpt(container *Container, config *runconfig.HostConfig) error {

 	return nil

 }

-func (daemon *Daemon) createRootfs(container *Container) error {

-	// Step 1: create the container directory.

-	// This doubles as a barrier to avoid race conditions.

-	if err := os.Mkdir(container.root, 0700); err != nil {

-		return err

-	}

-

-	if wd, ok := daemon.driver.(*windows.WindowsGraphDriver); ok {

-		if container.ImageID != "" {

-			// Get list of paths to parent layers.

-			logrus.Debugln("createRootfs: Container has parent image:", container.ImageID)

-			img, err := daemon.graph.Get(container.ImageID)

-			if err != nil {

-				return err

-			}

-

-			ids, err := daemon.graph.ParentLayerIds(img)

-			if err != nil {

-				return err

-			}

-			logrus.Debugf("Got image ids: %d", len(ids))

-

-			if err := hcsshim.CreateSandboxLayer(wd.Info(), container.ID, container.ImageID, wd.LayerIdsToPaths(ids)); err != nil {

-				return err

-			}

-		} else {

-			if err := daemon.driver.Create(container.ID, container.ImageID); err != nil {

-				return err

-			}

-		}

-	} else {

-		// Fall-back code path to allow the use of the VFS driver for development

-		if err := daemon.driver.Create(container.ID, container.ImageID); err != nil {

-			return err

-		}

-

-	}

+func setupInitLayer(initLayer string) error {

 	return nil

 }

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

 	"fmt"

 	"os"

 	"path"

-	"runtime"

 	"github.com/Sirupsen/logrus"

 )

@@ -117,12 +116,9 @@ func (daemon *Daemon) rm(container *Container, forceRemove bool) (err error) {

 		return fmt.Errorf("Driver %s failed to remove root filesystem %s: %s", daemon.driver, container.ID, err)

 	}

-	// There will not be an -init on Windows, so don't fail by not attempting to delete it

-	if runtime.GOOS != "windows" {

-		initID := fmt.Sprintf("%s-init", container.ID)

-		if err := daemon.driver.Remove(initID); err != nil {

-			return fmt.Errorf("Driver %s failed to remove init filesystem %s: %s", daemon.driver, initID, err)

-		}

+	initID := fmt.Sprintf("%s-init", container.ID)

+	if err := daemon.driver.Remove(initID); err != nil {

+		return fmt.Errorf("Driver %s failed to remove init filesystem %s: %s", daemon.driver, initID, err)

 	}

 	if err = os.RemoveAll(container.root); err != nil {

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

 	"errors"

 	"fmt"

 	"os"

+	"path/filepath"

 	"strconv"

 	"strings"

@@ -100,8 +101,13 @@ func (d *Driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba

 	}

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

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

+		g, err := hcsshim.NameToGuid(filename)

+		if err != nil {

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

+		}

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

-			ID:   hcsshim.NewGUID(c.LayerPaths[i]).ToString(),

+			ID:   g.ToString(),

 			Path: c.LayerPaths[i],

 		})

 	}

@@ -1,19 +1,5 @@

 package graphdriver

-import (

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

-	"github.com/microsoft/hcsshim"

-)

-

-type WindowsGraphDriver interface {

-	Driver

-	CopyDiff(id, sourceId string, parentLayerPaths []string) error

-	LayerIdsToPaths(ids []string) []string

-	Info() hcsshim.DriverInfo

-	Export(id string, parentLayerPaths []string) (archive.Archive, error)

-	Import(id string, layerData archive.Reader, parentLayerPaths []string) (int64, error)

-}

-

 var (

 	// Slice of drivers that should be used in order

 	priority = []string{

new file mode 100644

@@ -0,0 +1,30 @@

+package graphdriver

+

+import (

+	"github.com/docker/docker/image"

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

+)

+

+// NOTE: These interfaces are used for implementing specific features of the Windows

+// graphdriver implementation.  The current versions are a short-term solution and

+// likely to change or possibly be eliminated, so avoid using them outside of the Windows

+// graphdriver code.

+

+// ImageRestorer interface allows the implementer to add a custom image to

+// the graph and tagstore.

+type ImageRestorer interface {

+	RestoreCustomImages(tagger Tagger, recorder Recorder) ([]string, error)

+}

+

+// Tagger is an interface that exposes the TagStore.Tag function without needing

+// to import graph.

+type Tagger interface {

+	Tag(repoName, tag, imageName string, force bool) error

+}

+

+// Recorder is an interface that exposes the Graph.Register and Graph.Exists

+// functions without needing to import graph.

+type Recorder interface {

+	Exists(id string) bool

+	Register(img *image.Image, layerData archive.Reader) error

+}

@@ -3,17 +3,26 @@

 package windows

 import (

+	"crypto/sha512"

+	"encoding/json"

 	"fmt"

+	"io/ioutil"

 	"os"

 	"path/filepath"

+	"runtime"

+	"strconv"

+	"strings"

 	"sync"

 	"time"

 	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/autogen/dockerversion"

 	"github.com/docker/docker/daemon/graphdriver"

+	"github.com/docker/docker/image"

 	"github.com/docker/docker/pkg/archive"

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

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

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

 	"github.com/microsoft/hcsshim"

 )

@@ -27,7 +36,7 @@ const (

 	filterDriver

 )

-type WindowsGraphDriver struct {

+type Driver struct {

 	info       hcsshim.DriverInfo

 	sync.Mutex // Protects concurrent modification to active

 	active     map[string]int

@@ -36,7 +45,7 @@ type WindowsGraphDriver struct {

 // New returns a new Windows storage filter driver.

 func InitFilter(home string, options []string) (graphdriver.Driver, error) {

 	logrus.Debugf("WindowsGraphDriver InitFilter at %s", home)

-	d := &WindowsGraphDriver{

+	d := &Driver{

 		info: hcsshim.DriverInfo{

 			HomeDir: home,

 			Flavour: filterDriver,

@@ -49,7 +58,7 @@ func InitFilter(home string, options []string) (graphdriver.Driver, error) {

 // New returns a new Windows differencing disk driver.

 func InitDiff(home string, options []string) (graphdriver.Driver, error) {

 	logrus.Debugf("WindowsGraphDriver InitDiff at %s", home)

-	d := &WindowsGraphDriver{

+	d := &Driver{

 		info: hcsshim.DriverInfo{

 			HomeDir: home,

 			Flavour: diffDriver,

@@ -59,11 +68,7 @@ func InitDiff(home string, options []string) (graphdriver.Driver, error) {

 	return d, nil

 }

-func (d *WindowsGraphDriver) Info() hcsshim.DriverInfo {

-	return d.info

-}

-

-func (d *WindowsGraphDriver) String() string {

+func (d *Driver) String() string {

 	switch d.info.Flavour {

 	case diffDriver:

 		return "windowsdiff"

@@ -74,7 +79,7 @@ func (d *WindowsGraphDriver) String() string {

 	}

 }

-func (d *WindowsGraphDriver) Status() [][2]string {

+func (d *Driver) Status() [][2]string {

 	return [][2]string{

 		{"Windows", ""},

 	}

@@ -82,45 +87,137 @@ func (d *WindowsGraphDriver) Status() [][2]string {

 // Exists returns true if the given id is registered with

 // this driver

-func (d *WindowsGraphDriver) Exists(id string) bool {

-	result, err := hcsshim.LayerExists(d.info, id)

+func (d *Driver) Exists(id string) bool {

+	rId, err := d.resolveId(id)

+	if err != nil {

+		return false

+	}

+	result, err := hcsshim.LayerExists(d.info, rId)

 	if err != nil {

 		return false

 	}

 	return result

 }

-func (d *WindowsGraphDriver) Create(id, parent string) error {

-	return hcsshim.CreateLayer(d.info, id, parent)

+func (d *Driver) Create(id, parent string) error {

+	rPId, err := d.resolveId(parent)

+	if err != nil {

+		return err

+	}

+

+	parentChain, err := d.getLayerChain(rPId)

+	if err != nil {

+		return err

+	}

+

+	var layerChain []string

+

+	parentIsInit := strings.HasSuffix(rPId, "-init")

+

+	if !parentIsInit && rPId != "" {

+		parentPath, err := hcsshim.GetLayerMountPath(d.info, rPId)

+		if err != nil {

+			return err

+		}

+		layerChain = []string{parentPath}

+	}

+

+	layerChain = append(layerChain, parentChain...)

+

+	if parentIsInit {

+		if len(layerChain) == 0 {

+			return fmt.Errorf("Cannot create a read/write layer without a parent layer.")

+		}

+		if err := hcsshim.CreateSandboxLayer(d.info, id, layerChain[0], layerChain); err != nil {

+			return err

+		}

+	} else {

+		if err := hcsshim.CreateLayer(d.info, id, rPId); err != nil {

+			return err

+		}

+	}

+

+	if _, err := os.Lstat(d.dir(parent)); err == nil {

+		if err := d.setLayerChain(id, layerChain); err != nil {

+			if err2 := hcsshim.DestroyLayer(d.info, id); err2 != nil {

+				logrus.Warnf("Failed to DestroyLayer %s: %s", id, err)

+			}

+			return err

+		}

+	} else if os.IsNotExist(err) {

+		// If the parent doesn't exist, this must be a special creation for an image

+		// registered at an alternate location. Use the parent id as the alternate ID.

+		if err := d.setId(id, parent); err != nil {

+			if err2 := hcsshim.DestroyLayer(d.info, id); err2 != nil {

+				logrus.Warnf("Failed to DestroyLayer %s: %s", id, err)

+			}

+			return err

+		}

+	} else {

+		if err2 := hcsshim.DestroyLayer(d.info, id); err2 != nil {

+			logrus.Warnf("Failed to DestroyLayer %s: %s", id, err)

+		}

+		return err

+	}

+

+	return nil

 }

-func (d *WindowsGraphDriver) dir(id string) string {

+func (d *Driver) dir(id string) string {

 	return filepath.Join(d.info.HomeDir, filepath.Base(id))

 }

 // Remove unmounts and removes the dir information

-func (d *WindowsGraphDriver) Remove(id string) error {

-	return hcsshim.DestroyLayer(d.info, id)

+func (d *Driver) Remove(id string) error {

+	rId, err := d.resolveId(id)

+	if err != nil {

+		return err

+	}

+

+	return hcsshim.DestroyLayer(d.info, rId)

 }

 // Get returns the rootfs path for the id. This will mount the dir at it's given path

-func (d *WindowsGraphDriver) Get(id, mountLabel string) (string, error) {

+func (d *Driver) Get(id, mountLabel string) (string, error) {

+	logrus.Debugf("WindowsGraphDriver Get() id %s mountLabel %s", id, mountLabel)

 	var dir string

 	d.Lock()

 	defer d.Unlock()

-	if d.active[id] == 0 {

-		if err := hcsshim.ActivateLayer(d.info, id); err != nil {

+	rId, err := d.resolveId(id)

+	if err != nil {

+		return "", err

+	}

+

+	// Getting the layer paths must be done outside of the lock.

+	layerChain, err := d.getLayerChain(rId)

+	if err != nil {

+		return "", err

+	}

+

+	if d.active[rId] == 0 {

+		if err := hcsshim.ActivateLayer(d.info, rId); err != nil {

+			return "", err

+		}

+		if err := hcsshim.PrepareLayer(d.info, rId, layerChain); err != nil {

+			if err2 := hcsshim.DeactivateLayer(d.info, rId); err2 != nil {

+				logrus.Warnf("Failed to Deactivate %s: %s", id, err)

+			}

 			return "", err

 		}

 	}

-	mountPath, err := hcsshim.GetLayerMountPath(d.info, id)

+	mountPath, err := hcsshim.GetLayerMountPath(d.info, rId)

 	if err != nil {

+		if err2 := hcsshim.DeactivateLayer(d.info, rId); err2 != nil {

+			logrus.Warnf("Failed to Deactivate %s: %s", id, err)

+		}

 		return "", err

 	}

+	d.active[rId]++

+

 	// If the layer has a mount path, use that. Otherwise, use the

 	// folder path.

 	if mountPath != "" {

@@ -129,61 +226,131 @@ func (d *WindowsGraphDriver) Get(id, mountLabel string) (string, error) {

 		dir = d.dir(id)

 	}

-	d.active[id]++

-

 	return dir, nil

 }

-func (d *WindowsGraphDriver) Put(id string) error {

+func (d *Driver) Put(id string) error {

 	logrus.Debugf("WindowsGraphDriver Put() id %s", id)

+	rId, err := d.resolveId(id)

+	if err != nil {

+		return err

+	}

+

 	d.Lock()

 	defer d.Unlock()

-	if d.active[id] > 1 {

-		d.active[id]--

-	} else if d.active[id] == 1 {

-		if err := hcsshim.DeactivateLayer(d.info, id); err != nil {

+	if d.active[rId] > 1 {

+		d.active[rId]--

+	} else if d.active[rId] == 1 {

+		if err := hcsshim.UnprepareLayer(d.info, rId); err != nil {

 			return err

 		}

-		delete(d.active, id)

+		if err := hcsshim.DeactivateLayer(d.info, rId); err != nil {

+			return err

+		}

+		delete(d.active, rId)

 	}

 	return nil

 }

-func (d *WindowsGraphDriver) Cleanup() error {

+func (d *Driver) Cleanup() error {

 	return nil

 }

 // Diff produces an archive of the changes between the specified

 // layer and its parent layer which may be "".

-func (d *WindowsGraphDriver) Diff(id, parent string) (arch archive.Archive, err error) {

-	return nil, fmt.Errorf("The Windows graphdriver does not support Diff()")

+func (d *Driver) Diff(id, parent string) (arch archive.Archive, err error) {

+	rId, err := d.resolveId(id)

+	if err != nil {

+		return

+	}

+

+	// Getting the layer paths must be done outside of the lock.

+	layerChain, err := d.getLayerChain(rId)

+	if err != nil {

+		return

+	}

+

+	d.Lock()

+

+	// To support export, a layer must be activated but not prepared.

+	if d.info.Flavour == filterDriver {

+		if d.active[rId] == 0 {

+			if err = hcsshim.ActivateLayer(d.info, rId); err != nil {

+				d.Unlock()

+				return

+			}

+			defer func() {

+				if err := hcsshim.DeactivateLayer(d.info, rId); err != nil {

+					logrus.Warnf("Failed to Deactivate %s: %s", rId, err)

+				}

+			}()

+		} else {

+			if err = hcsshim.UnprepareLayer(d.info, rId); err != nil {

+				d.Unlock()

+				return

+			}

+			defer func() {

+				if err := hcsshim.PrepareLayer(d.info, rId, layerChain); err != nil {

+					logrus.Warnf("Failed to re-PrepareLayer %s: %s", rId, err)

+				}

+			}()

+		}

+	}

+

+	d.Unlock()

+

+	return d.exportLayer(rId, layerChain)

 }

 // Changes produces a list of changes between the specified layer

 // and its parent layer. If parent is "", then all changes will be ADD changes.

-func (d *WindowsGraphDriver) Changes(id, parent string) ([]archive.Change, error) {

+func (d *Driver) Changes(id, parent string) ([]archive.Change, error) {

 	return nil, fmt.Errorf("The Windows graphdriver does not support Changes()")

 }

 // ApplyDiff extracts the changeset from the given diff into the

 // layer with the specified id and parent, returning the size of the

 // new layer in bytes.

-func (d *WindowsGraphDriver) ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error) {

-	start := time.Now().UTC()

-	logrus.Debugf("WindowsGraphDriver ApplyDiff: Start untar layer")

+func (d *Driver) ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error) {