@@ -17,7 +17,7 @@ import (

 // ImageComponent provides an interface for working with images

 type ImageComponent interface {

 	SquashImage(from string, to string) (string, error)

-	TagImageWithReference(image.ID, string, reference.Named) error

+	TagImageWithReference(image.ID, reference.Named) error

 }

 // Builder defines interface for running a build

@@ -3,11 +3,9 @@ package build

 import (

 	"fmt"

 	"io"

-	"runtime"

 	"github.com/docker/distribution/reference"

 	"github.com/docker/docker/image"

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

 	"github.com/pkg/errors"

 )

@@ -35,12 +33,7 @@ func NewTagger(backend ImageComponent, stdout io.Writer, names []string) (*Tagge

 // TagImages creates image tags for the imageID

 func (bt *Tagger) TagImages(imageID image.ID) error {

 	for _, rt := range bt.repoAndTags {

-		// TODO @jhowardmsft LCOW support. Will need revisiting.

-		platform := runtime.GOOS

-		if system.LCOWSupported() {

-			platform = "linux"

-		}

-		if err := bt.imageComponent.TagImageWithReference(imageID, platform, rt); err != nil {

+		if err := bt.imageComponent.TagImageWithReference(imageID, rt); err != nil {

 			return err

 		}

 		fmt.Fprintf(bt.stdout, "Successfully tagged %s\n", reference.FamiliarString(rt))

@@ -44,7 +44,7 @@ type Backend interface {

 	// ContainerCreateWorkdir creates the workdir

 	ContainerCreateWorkdir(containerID string) error

-	CreateImage(config []byte, parent string, platform string) (Image, error)

+	CreateImage(config []byte, parent string) (Image, error)

 	ImageCacheBuilder

 }

@@ -79,7 +79,7 @@ type Result struct {

 // ImageCacheBuilder represents a generator for stateful image cache.

 type ImageCacheBuilder interface {

 	// MakeImageCache creates a stateful image cache.

-	MakeImageCache(cacheFrom []string, platform string) ImageCache

+	MakeImageCache(cacheFrom []string) ImageCache

 }

 // ImageCache abstracts an image cache.

@@ -123,7 +123,7 @@ func (bm *BuildManager) Build(ctx context.Context, config backend.BuildConfig) (

 		PathCache:      bm.pathCache,

 		IDMappings:     bm.idMappings,

 	}

-	return newBuilder(ctx, builderOptions, os).build(source, dockerfile)

+	return newBuilder(ctx, builderOptions).build(source, dockerfile)

 }

 func (bm *BuildManager) initializeClientSession(ctx context.Context, cancel func(), options *types.ImageBuildOptions) (builder.Source, error) {

@@ -190,7 +190,7 @@ type Builder struct {

 }

 // newBuilder creates a new Dockerfile builder from an optional dockerfile and a Options.

-func newBuilder(clientCtx context.Context, options builderOptions, os string) *Builder {

+func newBuilder(clientCtx context.Context, options builderOptions) *Builder {

 	config := options.Options

 	if config == nil {

 		config = new(types.ImageBuildOptions)

@@ -207,7 +207,7 @@ func newBuilder(clientCtx context.Context, options builderOptions, os string) *B

 		idMappings:       options.IDMappings,

 		imageSources:     newImageSources(clientCtx, options),

 		pathCache:        options.PathCache,

-		imageProber:      newImageProber(options.Backend, config.CacheFrom, os, config.NoCache),

+		imageProber:      newImageProber(options.Backend, config.CacheFrom, config.NoCache),

 		containerManager: newContainerManager(options.Backend),

 	}

@@ -367,14 +367,9 @@ func BuildFromConfig(config *container.Config, changes []string) (*container.Con

 		return nil, errdefs.InvalidParameter(err)

 	}

-	os := runtime.GOOS

-	if dockerfile.OS != "" {

-		os = dockerfile.OS

-	}

-

 	b := newBuilder(context.Background(), builderOptions{

 		Options: &types.ImageBuildOptions{NoCache: true},

-	}, os)

+	})

 	// ensure that the commands are valid

 	for _, n := range dockerfile.AST.Children {

@@ -31,7 +31,7 @@ func newBuilderWithMockBackend() *Builder {

 			Options: &types.ImageBuildOptions{Platform: runtime.GOOS},

 			Backend: mockBackend,

 		}),

-		imageProber:      newImageProber(mockBackend, nil, runtime.GOOS, false),

+		imageProber:      newImageProber(mockBackend, nil, false),

 		containerManager: newContainerManager(mockBackend),

 	}

 	return b

@@ -427,10 +427,10 @@ func TestRunWithBuildArgs(t *testing.T) {

 	}

 	mockBackend := b.docker.(*MockBackend)

-	mockBackend.makeImageCacheFunc = func(_ []string, _ string) builder.ImageCache {

+	mockBackend.makeImageCacheFunc = func(_ []string) builder.ImageCache {

 		return imageCache

 	}

-	b.imageProber = newImageProber(mockBackend, nil, runtime.GOOS, false)

+	b.imageProber = newImageProber(mockBackend, nil, false)

 	mockBackend.getImageFunc = func(_ string) (builder.Image, builder.ReleaseableLayer, error) {

 		return &mockImage{

 			id:     "abcdef",

@@ -19,13 +19,13 @@ type imageProber struct {

 	cacheBusted bool

 }

-func newImageProber(cacheBuilder builder.ImageCacheBuilder, cacheFrom []string, platform string, noCache bool) ImageProber {

+func newImageProber(cacheBuilder builder.ImageCacheBuilder, cacheFrom []string, noCache bool) ImageProber {

 	if noCache {

 		return &nopProber{}

 	}

 	reset := func() builder.ImageCache {

-		return cacheBuilder.MakeImageCache(cacheFrom, platform)

+		return cacheBuilder.MakeImageCache(cacheFrom)

 	}

 	return &imageProber{cache: reset(), reset: reset}

 }

@@ -154,7 +154,7 @@ func (b *Builder) exportImage(state *dispatchState, imageMount *imageMount, runC

 		return errors.Wrap(err, "failed to encode image config")

 	}

-	exportedImage, err := b.docker.CreateImage(config, state.imageID, parentImage.OS)

+	exportedImage, err := b.docker.CreateImage(config, state.imageID)

 	if err != nil {

 		return errors.Wrapf(err, "failed to export image")

 	}

@@ -20,7 +20,7 @@ type MockBackend struct {

 	containerCreateFunc func(config types.ContainerCreateConfig) (container.ContainerCreateCreatedBody, error)

 	commitFunc          func(string, *backend.ContainerCommitConfig) (string, error)

 	getImageFunc        func(string) (builder.Image, builder.ReleaseableLayer, error)

-	makeImageCacheFunc  func(cacheFrom []string, platform string) builder.ImageCache

+	makeImageCacheFunc  func(cacheFrom []string) builder.ImageCache

 }

 func (m *MockBackend) ContainerAttachRaw(cID string, stdin io.ReadCloser, stdout, stderr io.Writer, stream bool, attached chan struct{}) error {

@@ -73,14 +73,14 @@ func (m *MockBackend) GetImageAndReleasableLayer(ctx context.Context, refOrID st

 	return &mockImage{id: "theid"}, &mockLayer{}, nil

 }

-func (m *MockBackend) MakeImageCache(cacheFrom []string, platform string) builder.ImageCache {

+func (m *MockBackend) MakeImageCache(cacheFrom []string) builder.ImageCache {

 	if m.makeImageCacheFunc != nil {

-		return m.makeImageCacheFunc(cacheFrom, platform)

+		return m.makeImageCacheFunc(cacheFrom)

 	}

 	return nil

 }

-func (m *MockBackend) CreateImage(config []byte, parent string, platform string) (builder.Image, error) {

+func (m *MockBackend) CreateImage(config []byte, parent string) (builder.Image, error) {

 	return nil, nil

 }

@@ -2,7 +2,6 @@ package daemon

 import (

 	"io"

-	"runtime"

 	"github.com/docker/distribution/reference"

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

@@ -24,6 +23,7 @@ type releaseableLayer struct {

 	layerStore layer.Store

 	roLayer    layer.Layer

 	rwLayer    layer.RWLayer

+	os         string

 }

 func (rl *releaseableLayer) Mount() (containerfs.ContainerFS, error) {

@@ -35,7 +35,7 @@ func (rl *releaseableLayer) Mount() (containerfs.ContainerFS, error) {

 	}

 	mountID := stringid.GenerateRandomID()

-	rl.rwLayer, err = rl.layerStore.CreateRWLayer(mountID, chainID, nil)

+	rl.rwLayer, err = rl.layerStore.CreateRWLayer(mountID, chainID, rl.os, nil)

 	if err != nil {

 		return nil, errors.Wrap(err, "failed to create rwlayer")

 	}

@@ -67,12 +67,12 @@ func (rl *releaseableLayer) Commit(os string) (builder.ReleaseableLayer, error)

 	}

 	defer stream.Close()

-	newLayer, err := rl.layerStore.Register(stream, chainID, layer.OS(os))

+	newLayer, err := rl.layerStore.Register(stream, chainID, os)

 	if err != nil {

 		return nil, err

 	}

-	// TODO: An optimization would be to handle empty layers before returning

-	return &releaseableLayer{layerStore: rl.layerStore, roLayer: newLayer}, nil

+	// TODO: An optimization woudld be to handle empty layers before returning

+	return &releaseableLayer{layerStore: rl.layerStore, roLayer: newLayer, os: os}, nil

 }

 func (rl *releaseableLayer) DiffID() layer.DiffID {

@@ -128,9 +128,9 @@ func (rl *releaseableLayer) releaseROLayer() error {

 	return err

 }

-func newReleasableLayerForImage(img *image.Image, layerStore layer.Store) (builder.ReleaseableLayer, error) {

+func newReleasableLayerForImage(img *image.Image, layerStore layer.Store, os string) (builder.ReleaseableLayer, error) {

 	if img == nil || img.RootFS.ChainID() == "" {

-		return &releaseableLayer{layerStore: layerStore}, nil

+		return &releaseableLayer{layerStore: layerStore, os: os}, nil

 	}

 	// Hold a reference to the image layer so that it can't be removed before

 	// it is released

@@ -138,11 +138,11 @@ func newReleasableLayerForImage(img *image.Image, layerStore layer.Store) (build

 	if err != nil {

 		return nil, errors.Wrapf(err, "failed to get layer for image %s", img.ImageID())

 	}

-	return &releaseableLayer{layerStore: layerStore, roLayer: roLayer}, nil

+	return &releaseableLayer{layerStore: layerStore, roLayer: roLayer, os: os}, nil

 }

 // TODO: could this use the regular daemon PullImage ?

-func (daemon *Daemon) pullForBuilder(ctx context.Context, name string, authConfigs map[string]types.AuthConfig, output io.Writer, platform string) (*image.Image, error) {

+func (daemon *Daemon) pullForBuilder(ctx context.Context, name string, authConfigs map[string]types.AuthConfig, output io.Writer, os string) (*image.Image, error) {

 	ref, err := reference.ParseNormalizedNamed(name)

 	if err != nil {

 		return nil, err

@@ -161,7 +161,7 @@ func (daemon *Daemon) pullForBuilder(ctx context.Context, name string, authConfi

 		pullRegistryAuth = &resolvedConfig

 	}

-	if err := daemon.pullImageWithReference(ctx, ref, platform, nil, pullRegistryAuth, output); err != nil {

+	if err := daemon.pullImageWithReference(ctx, ref, os, nil, pullRegistryAuth, output); err != nil {

 		return nil, err

 	}

 	return daemon.GetImage(name)

@@ -172,7 +172,7 @@ func (daemon *Daemon) pullForBuilder(ctx context.Context, name string, authConfi

 // leaking of layers.

 func (daemon *Daemon) GetImageAndReleasableLayer(ctx context.Context, refOrID string, opts backend.GetImageAndLayerOptions) (builder.Image, builder.ReleaseableLayer, error) {

 	if refOrID == "" {

-		layer, err := newReleasableLayerForImage(nil, daemon.stores[opts.OS].layerStore)

+		layer, err := newReleasableLayerForImage(nil, daemon.layerStore, opts.OS)

 		return nil, layer, err

 	}

@@ -183,7 +183,7 @@ func (daemon *Daemon) GetImageAndReleasableLayer(ctx context.Context, refOrID st

 		}

 		// TODO: shouldn't we error out if error is different from "not found" ?

 		if image != nil {

-			layer, err := newReleasableLayerForImage(image, daemon.stores[opts.OS].layerStore)

+			layer, err := newReleasableLayerForImage(image, daemon.layerStore, image.OperatingSystem())

 			return image, layer, err

 		}

 	}

@@ -192,29 +192,26 @@ func (daemon *Daemon) GetImageAndReleasableLayer(ctx context.Context, refOrID st

 	if err != nil {

 		return nil, nil, err

 	}

-	layer, err := newReleasableLayerForImage(image, daemon.stores[opts.OS].layerStore)

+	layer, err := newReleasableLayerForImage(image, daemon.layerStore, image.OperatingSystem())

 	return image, layer, err

 }

 // CreateImage creates a new image by adding a config and ID to the image store.

 // This is similar to LoadImage() except that it receives JSON encoded bytes of

 // an image instead of a tar archive.

-func (daemon *Daemon) CreateImage(config []byte, parent string, platform string) (builder.Image, error) {

-	if platform == "" {

-		platform = runtime.GOOS

-	}

-	id, err := daemon.stores[platform].imageStore.Create(config)

+func (daemon *Daemon) CreateImage(config []byte, parent string) (builder.Image, error) {

+	id, err := daemon.imageStore.Create(config)

 	if err != nil {

 		return nil, errors.Wrapf(err, "failed to create image")

 	}

 	if parent != "" {

-		if err := daemon.stores[platform].imageStore.SetParent(id, image.ID(parent)); err != nil {

+		if err := daemon.imageStore.SetParent(id, image.ID(parent)); err != nil {

 			return nil, errors.Wrapf(err, "failed to set parent %s", parent)

 		}

 	}

-	return daemon.stores[platform].imageStore.Get(id)

+	return daemon.imageStore.Get(id)

 }

 // IDMappings returns uid/gid mappings for the builder

@@ -7,12 +7,12 @@ import (

 )

 // MakeImageCache creates a stateful image cache.

-func (daemon *Daemon) MakeImageCache(sourceRefs []string, platform string) builder.ImageCache {

+func (daemon *Daemon) MakeImageCache(sourceRefs []string) builder.ImageCache {

 	if len(sourceRefs) == 0 {

-		return cache.NewLocal(daemon.stores[platform].imageStore)

+		return cache.NewLocal(daemon.imageStore)

 	}

-	cache := cache.New(daemon.stores[platform].imageStore)

+	cache := cache.New(daemon.imageStore)

 	for _, ref := range sourceRefs {

 		img, err := daemon.GetImage(ref)

@@ -180,17 +180,17 @@ func (daemon *Daemon) Commit(name string, c *backend.ContainerCommitConfig) (str

 		parent = new(image.Image)

 		parent.RootFS = image.NewRootFS()

 	} else {

-		parent, err = daemon.stores[container.OS].imageStore.Get(container.ImageID)

+		parent, err = daemon.imageStore.Get(container.ImageID)

 		if err != nil {

 			return "", err

 		}

 	}

-	l, err := daemon.stores[container.OS].layerStore.Register(rwTar, parent.RootFS.ChainID(), layer.OS(container.OS))

+	l, err := daemon.layerStore.Register(rwTar, parent.RootFS.ChainID(), container.OS)

 	if err != nil {

 		return "", err

 	}

-	defer layer.ReleaseAndLog(daemon.stores[container.OS].layerStore, l)

+	defer layer.ReleaseAndLog(daemon.layerStore, l)

 	containerConfig := c.ContainerConfig

 	if containerConfig == nil {

@@ -209,13 +209,13 @@ func (daemon *Daemon) Commit(name string, c *backend.ContainerCommitConfig) (str

 		return "", err

 	}

-	id, err := daemon.stores[container.OS].imageStore.Create(config)

+	id, err := daemon.imageStore.Create(config)

 	if err != nil {

 		return "", err

 	}

 	if container.ImageID != "" {

-		if err := daemon.stores[container.OS].imageStore.SetParent(id, container.ImageID); err != nil {

+		if err := daemon.imageStore.SetParent(id, container.ImageID); err != nil {

 			return "", err

 		}

 	}

@@ -234,7 +234,7 @@ func (daemon *Daemon) Commit(name string, c *backend.ContainerCommitConfig) (str

 				return "", err

 			}

 		}

-		if err := daemon.TagImageWithReference(id, container.OS, newTag); err != nil {

+		if err := daemon.TagImageWithReference(id, newTag); err != nil {

 			return "", err

 		}

 		imageRef = reference.FamiliarString(newTag)

@@ -257,7 +257,7 @@ func (daemon *Daemon) generateSecurityOpt(hostConfig *containertypes.HostConfig)

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

 	var layerID layer.ChainID

 	if container.ImageID != "" {

-		img, err := daemon.stores[container.OS].imageStore.Get(container.ImageID)

+		img, err := daemon.imageStore.Get(container.ImageID)

 		if err != nil {

 			return err

 		}

@@ -270,7 +270,7 @@ func (daemon *Daemon) setRWLayer(container *container.Container) error {

 		StorageOpt: container.HostConfig.StorageOpt,

 	}

-	rwLayer, err := daemon.stores[container.OS].layerStore.CreateRWLayer(container.ID, layerID, rwLayerOpts)

+	rwLayer, err := daemon.layerStore.CreateRWLayer(container.ID, layerID, container.OS, rwLayerOpts)

 	if err != nil {

 		return err

 	}

@@ -69,50 +69,46 @@ var (

 	errSystemNotSupported = errors.New("the Docker daemon is not supported on this platform")

 )

-type daemonStore struct {

-	graphDriver               string

-	imageRoot                 string

+// Daemon holds information about the Docker daemon.

+type Daemon struct {

+	ID                        string

+	repository                string

+	containers                container.Store

+	containersReplica         container.ViewDB

+	execCommands              *exec.Store

+	downloadManager           *xfer.LayerDownloadManager

+	uploadManager             *xfer.LayerUploadManager

+	trustKey                  libtrust.PrivateKey

+	idIndex                   *truncindex.TruncIndex

+	configStore               *config.Config

+	statsCollector            *stats.Collector

+	defaultLogConfig          containertypes.LogConfig

+	RegistryService           registry.Service

+	EventsService             *events.Events

+	netController             libnetwork.NetworkController

+	volumes                   *store.VolumeStore

+	discoveryWatcher          discovery.Reloader

+	root                      string

+	seccompEnabled            bool

+	apparmorEnabled           bool

+	shutdown                  bool

+	idMappings                *idtools.IDMappings

+	graphDrivers              map[string]string // By operating system

+	referenceStore            refstore.Store

 	imageStore                image.Store

+	imageRoot                 string

 	layerStore                layer.Store

 	distributionMetadataStore dmetadata.Store

-}

-

-// Daemon holds information about the Docker daemon.

-type Daemon struct {

-	ID                    string

-	repository            string

-	containers            container.Store

-	containersReplica     container.ViewDB

-	execCommands          *exec.Store

-	downloadManager       *xfer.LayerDownloadManager

-	uploadManager         *xfer.LayerUploadManager

-	trustKey              libtrust.PrivateKey

-	idIndex               *truncindex.TruncIndex

-	configStore           *config.Config

-	statsCollector        *stats.Collector

-	defaultLogConfig      containertypes.LogConfig

-	RegistryService       registry.Service

-	EventsService         *events.Events

-	netController         libnetwork.NetworkController

-	volumes               *store.VolumeStore

-	discoveryWatcher      discovery.Reloader

-	root                  string

-	seccompEnabled        bool

-	apparmorEnabled       bool

-	shutdown              bool

-	idMappings            *idtools.IDMappings

-	stores                map[string]daemonStore // By container target platform

-	referenceStore        refstore.Store

-	PluginStore           *plugin.Store // todo: remove

-	pluginManager         *plugin.Manager

-	linkIndex             *linkIndex

-	containerd            libcontainerd.Client

-	containerdRemote      libcontainerd.Remote

-	defaultIsolation      containertypes.Isolation // Default isolation mode on Windows

-	clusterProvider       cluster.Provider

-	cluster               Cluster

-	genericResources      []swarm.GenericResource

-	metricsPluginListener net.Listener

+	PluginStore               *plugin.Store // todo: remove

+	pluginManager             *plugin.Manager

+	linkIndex                 *linkIndex

+	containerd                libcontainerd.Client

+	containerdRemote          libcontainerd.Remote

+	defaultIsolation          containertypes.Isolation // Default isolation mode on Windows

+	clusterProvider           cluster.Provider

+	cluster                   Cluster

+	genericResources          []swarm.GenericResource

+	metricsPluginListener     net.Listener

 	machineMemory uint64

@@ -161,9 +157,9 @@ func (daemon *Daemon) restore() error {

 		}

 		// Ignore the container if it does not support the current driver being used by the graph

-		currentDriverForContainerOS := daemon.stores[container.OS].graphDriver

+		currentDriverForContainerOS := daemon.graphDrivers[container.OS]

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

-			rwlayer, err := daemon.stores[container.OS].layerStore.GetRWLayer(container.ID)

+			rwlayer, err := daemon.layerStore.GetRWLayer(container.ID)

 			if err != nil {

 				logrus.Errorf("Failed to load container mount %v: %v", id, err)

 				continue

@@ -706,11 +702,11 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 	// lcow. Unix platforms however run a single graphdriver for all containers, and it can

 	// be set through an environment variable, a daemon start parameter, or chosen through

 	// initialization of the layerstore through driver priority order for example.

-	d.stores = make(map[string]daemonStore)

+	d.graphDrivers = make(map[string]string)

 	if runtime.GOOS == "windows" {

-		d.stores["windows"] = daemonStore{graphDriver: "windowsfilter"}

+		d.graphDrivers[runtime.GOOS] = "windowsfilter"

 		if system.LCOWSupported() {

-			d.stores["linux"] = daemonStore{graphDriver: "lcow"}

+			d.graphDrivers["linux"] = "lcow"

 		}

 	} else {

 		driverName := os.Getenv("DOCKER_DRIVER")

@@ -719,7 +715,7 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 		} else {

 			logrus.Infof("Setting the storage driver from the $DOCKER_DRIVER environment variable (%s)", driverName)

 		}

-		d.stores[runtime.GOOS] = daemonStore{graphDriver: driverName} // May still be empty. Layerstore init determines instead.

+		d.graphDrivers[runtime.GOOS] = driverName // May still be empty. Layerstore init determines instead.

 	}

 	d.RegistryService = registryService

@@ -750,55 +746,43 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 		return nil, errors.Wrap(err, "couldn't create plugin manager")

 	}

-	var graphDrivers []string

-	for operatingSystem, ds := range d.stores {

-		ls, err := layer.NewStoreFromOptions(layer.StoreOptions{

-			StorePath:                 config.Root,

-			MetadataStorePathTemplate: filepath.Join(config.Root, "image", "%s", "layerdb"),

-			GraphDriver:               ds.graphDriver,

-			GraphDriverOptions:        config.GraphOptions,

-			IDMappings:                idMappings,

-			PluginGetter:              d.PluginStore,

-			ExperimentalEnabled:       config.Experimental,

-			OS:                        operatingSystem,

-		})

-		if err != nil {

-			return nil, err

-		}

-		ds.graphDriver = ls.DriverName() // As layerstore may set the driver

-		ds.layerStore = ls

-		d.stores[operatingSystem] = ds

-		graphDrivers = append(graphDrivers, ls.DriverName())

+	d.layerStore, err = layer.NewStoreFromOptions(layer.StoreOptions{

+		Root: config.Root,

+		MetadataStorePathTemplate: filepath.Join(config.Root, "image", "%s", "layerdb"),

+		GraphDrivers:              d.graphDrivers,

+		GraphDriverOptions:        config.GraphOptions,

+		IDMappings:                idMappings,

+		PluginGetter:              d.PluginStore,

+		ExperimentalEnabled:       config.Experimental,

+	})

+	if err != nil {

+		return nil, err

 	}

-	// Configure and validate the kernels security support

-	if err := configureKernelSecuritySupport(config, graphDrivers); err != nil {

+	// As layerstore may set the driver

+	for os := range d.graphDrivers {

+		d.graphDrivers[os] = d.layerStore.DriverName(os)

+	}

+

+	// Configure and validate the kernels security support. Note this is a Linux/FreeBSD

+	// operation only, so it is safe to pass *just* the runtime OS graphdriver.

+	if err := configureKernelSecuritySupport(config, d.graphDrivers[runtime.GOOS]); err != nil {

 		return nil, err

 	}

 	logrus.Debugf("Max Concurrent Downloads: %d", *config.MaxConcurrentDownloads)

-	lsMap := make(map[string]layer.Store)

-	for operatingSystem, ds := range d.stores {

-		lsMap[operatingSystem] = ds.layerStore

-	}

-	d.downloadManager = xfer.NewLayerDownloadManager(lsMap, *config.MaxConcurrentDownloads)

+	d.downloadManager = xfer.NewLayerDownloadManager(d.layerStore, *config.MaxConcurrentDownloads)

 	logrus.Debugf("Max Concurrent Uploads: %d", *config.MaxConcurrentUploads)

 	d.uploadManager = xfer.NewLayerUploadManager(*config.MaxConcurrentUploads)

-	for operatingSystem, ds := range d.stores {

-		imageRoot := filepath.Join(config.Root, "image", ds.graphDriver)

-		ifs, err := image.NewFSStoreBackend(filepath.Join(imageRoot, "imagedb"))

-		if err != nil {

-			return nil, err

-		}

-		var is image.Store

-		is, err = image.NewImageStore(ifs, operatingSystem, ds.layerStore)

-		if err != nil {

-			return nil, err

-		}

-		ds.imageRoot = imageRoot

-		ds.imageStore = is

-		d.stores[operatingSystem] = ds

+	d.imageRoot = filepath.Join(config.Root, "image", d.graphDrivers[runtime.GOOS])

+	ifs, err := image.NewFSStoreBackend(filepath.Join(d.imageRoot, "imagedb"))

+	if err != nil {

+		return nil, err

+	}

+	d.imageStore, err = image.NewImageStore(ifs, d.layerStore)

+	if err != nil {

+		return nil, err

 	}

 	// Configure the volumes driver

@@ -830,30 +814,25 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 	// operating systems, the list of graphdrivers available isn't user configurable.

 	// For backwards compatibility, we just put it under the windowsfilter

 	// directory regardless.

-	refStoreLocation := filepath.Join(d.stores[runtime.GOOS].imageRoot, `repositories.json`)

+	refStoreLocation := filepath.Join(d.imageRoot, `repositories.json`)

 	rs, err := refstore.NewReferenceStore(refStoreLocation)

 	if err != nil {

 		return nil, fmt.Errorf("Couldn't create reference store repository: %s", err)

 	}

 	d.referenceStore = rs

-	for platform, ds := range d.stores {

-		dms, err := dmetadata.NewFSMetadataStore(filepath.Join(ds.imageRoot, "distribution"), platform)

-		if err != nil {

-			return nil, err

-		}

-

-		ds.distributionMetadataStore = dms

-		d.stores[platform] = ds

+	d.distributionMetadataStore, err = dmetadata.NewFSMetadataStore(filepath.Join(d.imageRoot, "distribution"))

+	if err != nil {

+		return nil, err

+	}

-		// No content-addressability migration on Windows as it never supported pre-CA

-		if runtime.GOOS != "windows" {

-			migrationStart := time.Now()

-			if err := v1.Migrate(config.Root, ds.graphDriver, ds.layerStore, ds.imageStore, rs, dms); err != nil {

-				logrus.Errorf("Graph migration failed: %q. Your old graph data was found to be too inconsistent for upgrading to content-addressable storage. Some of the old data was probably not upgraded. We recommend starting over with a clean storage directory if possible.", err)

-			}

-			logrus.Infof("Graph migration to content-addressability took %.2f seconds", time.Since(migrationStart).Seconds())

+	// No content-addressability migration on Windows as it never supported pre-CA

+	if runtime.GOOS != "windows" {

+		migrationStart := time.Now()

+		if err := v1.Migrate(config.Root, d.graphDrivers[runtime.GOOS], d.layerStore, d.imageStore, rs, d.distributionMetadataStore); err != nil {

+			logrus.Errorf("Graph migration failed: %q. Your old graph data was found to be too inconsistent for upgrading to content-addressable storage. Some of the old data was probably not upgraded. We recommend starting over with a clean storage directory if possible.", err)

 		}

+		logrus.Infof("Graph migration to content-addressability took %.2f seconds", time.Since(migrationStart).Seconds())

 	}

 	// Discovery is only enabled when the daemon is launched with an address to advertise.  When

@@ -922,13 +901,13 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 	engineMemory.Set(float64(info.MemTotal))

 	gd := ""

-	for platform, ds := range d.stores {

+	for os, driver := range d.graphDrivers {

 		if len(gd) > 0 {

 			gd += ", "

 		}

-		gd += ds.graphDriver

-		if len(d.stores) > 1 {

-			gd = fmt.Sprintf("%s (%s)", gd, platform)

+		gd += driver

+		if len(d.graphDrivers) > 1 {

+			gd = fmt.Sprintf("%s (%s)", gd, os)

 		}

 	}

 	logrus.WithFields(logrus.Fields{

@@ -1009,7 +988,7 @@ func (daemon *Daemon) Shutdown() error {

 				logrus.Errorf("Stop container error: %v", err)

 				return

 			}

-			if mountid, err := daemon.stores[c.OS].layerStore.GetMountID(c.ID); err == nil {

+			if mountid, err := daemon.layerStore.GetMountID(c.ID); err == nil {

 				daemon.cleanupMountsByID(mountid)

 			}

 			logrus.Debugf("container stopped %s", c.ID)

@@ -1022,12 +1001,8 @@ func (daemon *Daemon) Shutdown() error {

 		}

 	}

-	for platform, ds := range daemon.stores {

-		if ds.layerStore != nil {

-			if err := ds.layerStore.Cleanup(); err != nil {

-				logrus.Errorf("Error during layer Store.Cleanup(): %v %s", err, platform)

-			}

-		}

+	if err := daemon.layerStore.Cleanup(); err != nil {

+		logrus.Errorf("Error during layer Store.Cleanup(): %v", err)

 	}

 	// If we are part of a cluster, clean up cluster's stuff

@@ -1107,8 +1082,8 @@ func (daemon *Daemon) Subnets() ([]net.IPNet, []net.IPNet) {

 }

 // GraphDriverName returns the name of the graph driver used by the layer.Store

-func (daemon *Daemon) GraphDriverName(platform string) string {

-	return daemon.stores[platform].layerStore.DriverName()

+func (daemon *Daemon) GraphDriverName(os string) string {

+	return daemon.layerStore.DriverName(os)

 }

 // prepareTempDir prepares and returns the default directory to use

@@ -814,22 +814,14 @@ func overlaySupportsSelinux() (bool, error) {

 }

 // configureKernelSecuritySupport configures and validates security support for the kernel

-func configureKernelSecuritySupport(config *config.Config, driverNames []string) error {

+func configureKernelSecuritySupport(config *config.Config, driverName string) error {

 	if config.EnableSelinuxSupport {

 		if !selinuxEnabled() {

 			logrus.Warn("Docker could not enable SELinux on the host system")

 			return nil

 		}

-		overlayFound := false

-		for _, d := range driverNames {

-			if d == "overlay" || d == "overlay2" {

-				overlayFound = true

-				break

-			}

-		}

-

-		if overlayFound {

+		if driverName == "overlay" || driverName == "overlay2" {

 			// If driver is overlay or overlay2, make sure kernel

 			// supports selinux with overlay.

 			supported, err := overlaySupportsSelinux()

@@ -838,7 +830,7 @@ func configureKernelSecuritySupport(config *config.Config, driverNames []string)

 			}

 			if !supported {

-				logrus.Warnf("SELinux is not supported with the %v graph driver on this kernel", driverNames)

+				logrus.Warnf("SELinux is not supported with the %v graph driver on this kernel", driverName)

 			}

 		}

 	} else {

@@ -262,7 +262,7 @@ func ensureServicesInstalled(services []string) error {

 }

 // configureKernelSecuritySupport configures and validate security support for the kernel

-func configureKernelSecuritySupport(config *config.Config, driverNames []string) error {

+func configureKernelSecuritySupport(config *config.Config, driverName string) error {

 	return nil

 }

@@ -118,7 +118,7 @@ func (daemon *Daemon) cleanupContainer(container *container.Container, forceRemo

 	// When container creation fails and `RWLayer` has not been created yet, we

 	// do not call `ReleaseRWLayer`

 	if container.RWLayer != nil {

-		metadata, err := daemon.stores[container.OS].layerStore.ReleaseRWLayer(container.RWLayer)

+		metadata, err := daemon.layerStore.ReleaseRWLayer(container.RWLayer)

 		layer.LogReleaseMetadata(metadata)

 		if err != nil && err != layer.ErrMountDoesNotExist && !os.IsNotExist(errors.Cause(err)) {

 			e := errors.Wrapf(err, "driver %q failed to remove root filesystem for %s", daemon.GraphDriverName(container.OS), container.ID)

@@ -15,12 +15,12 @@ import (

 	"github.com/sirupsen/logrus"

 )

-func (daemon *Daemon) getLayerRefs(platform string) map[layer.ChainID]int {

-	tmpImages := daemon.stores[platform].imageStore.Map()

+func (daemon *Daemon) getLayerRefs() map[layer.ChainID]int {

+	tmpImages := daemon.imageStore.Map()

 	layerRefs := map[layer.ChainID]int{}

 	for id, img := range tmpImages {

 		dgst := digest.Digest(id)

-		if len(daemon.referenceStore.References(dgst)) == 0 && len(daemon.stores[platform].imageStore.Children(id)) != 0 {

+		if len(daemon.referenceStore.References(dgst)) == 0 && len(daemon.imageStore.Children(id)) != 0 {

 			continue

 		}

@@ -53,7 +53,6 @@ func (daemon *Daemon) SystemDiskUsage(ctx context.Context) (*types.DiskUsage, er

 	}

 	// Get all top images with extra attributes

-	// TODO @jhowardmsft LCOW. This may need revisiting

 	allImages, err := daemon.Images(filters.NewArgs(), false, true)

 	if err != nil {

 		return nil, fmt.Errorf("failed to retrieve image list: %v", err)

@@ -96,24 +95,22 @@ func (daemon *Daemon) SystemDiskUsage(ctx context.Context) (*types.DiskUsage, er

 	// Get total layers size on disk

 	var allLayersSize int64

-	for platform := range daemon.stores {

-		layerRefs := daemon.getLayerRefs(platform)

-		allLayers := daemon.stores[platform].layerStore.Map()

-		for _, l := range allLayers {

-			select {

-			case <-ctx.Done():

-				return nil, ctx.Err()

-			default:

-				size, err := l.DiffSize()

-				if err == nil {

-					if _, ok := layerRefs[l.ChainID()]; ok {

-						allLayersSize += size

-					} else {

-						logrus.Warnf("found leaked image layer %v platform %s", l.ChainID(), platform)

-					}

+	layerRefs := daemon.getLayerRefs()

+	allLayers := daemon.layerStore.Map()

+	for _, l := range allLayers {

+		select {

+		case <-ctx.Done():

+			return nil, ctx.Err()

+		default:

+			size, err := l.DiffSize()

+			if err == nil {

+				if _, ok := layerRefs[l.ChainID()]; ok {

+					allLayersSize += size

 				} else {

-					logrus.Warnf("failed to get diff size for layer %v %s", l.ChainID(), platform)

+					logrus.Warnf("found leaked image layer %v", l.ChainID())

 				}

+			} else {

+				logrus.Warnf("failed to get diff size for layer %v", l.ChainID())

 			}

 		}

 	}

@@ -15,12 +15,12 @@ func (daemon *Daemon) getSize(containerID string) (int64, int64) {

 		err                error

 	)

-	rwlayer, err := daemon.stores[runtime.GOOS].layerStore.GetRWLayer(containerID)

+	rwlayer, err := daemon.layerStore.GetRWLayer(containerID)

 	if err != nil {

 		logrus.Errorf("Failed to compute size of container rootfs %v: %v", containerID, err)

 		return sizeRw, sizeRootfs

 	}

-	defer daemon.stores[runtime.GOOS].layerStore.ReleaseRWLayer(rwlayer)

+	defer daemon.layerStore.ReleaseRWLayer(rwlayer)

 	sizeRw, err = rwlayer.Size()

 	if err != nil {

@@ -38,32 +38,31 @@ func (daemon *Daemon) GetImageIDAndOS(refOrID string) (image.ID, string, error)

 			return "", "", errImageDoesNotExist{ref}

 		}

 		id := image.IDFromDigest(digested.Digest())

-		for platform := range daemon.stores {

-			if _, err = daemon.stores[platform].imageStore.Get(id); err == nil {

-				return id, platform, nil

-			}

+		if img, err := daemon.imageStore.Get(id); err == nil {

+			return id, img.OperatingSystem(), nil

 		}

 		return "", "", errImageDoesNotExist{ref}

 	}

 	if digest, err := daemon.referenceStore.Get(namedRef); err == nil {

 		// Search the image stores to get the operating system, defaulting to host OS.

-		imageOS := runtime.GOOS

 		id := image.IDFromDigest(digest)

-		for os := range daemon.stores {

-			if img, err := daemon.stores[os].imageStore.Get(id); err == nil {

-				imageOS = img.OperatingSystem()

-				break

-			}

+		if img, err := daemon.imageStore.Get(id); err == nil {

+			return id, img.OperatingSystem(), nil

 		}

-		return id, imageOS, nil

 	}

 	// Search based on ID

-	for os := range daemon.stores {

-		if id, err := daemon.stores[os].imageStore.Search(refOrID); err == nil {

-			return id, os, nil

+	if id, err := daemon.imageStore.Search(refOrID); err == nil {

+		img, err := daemon.imageStore.Get(id)

+		if err != nil {