@@ -102,6 +102,6 @@ type Image interface {

 type ReleaseableLayer interface {

 	Release() error

 	Mount() (containerfs.ContainerFS, error)

-	Commit(platform string) (ReleaseableLayer, error)

+	Commit() (ReleaseableLayer, error)

 	DiffID() layer.DiffID

 }

@@ -357,7 +357,7 @@ func addNodesForLabelOption(dockerfile *parser.Node, labels map[string]string) {

 // coming from the query parameter of the same name.

 //

 // TODO: Remove?

-func BuildFromConfig(config *container.Config, changes []string) (*container.Config, error) {

+func BuildFromConfig(config *container.Config, changes []string, os string) (*container.Config, error) {

 	if len(changes) == 0 {

 		return config, nil

 	}

@@ -395,6 +395,7 @@ func BuildFromConfig(config *container.Config, changes []string) (*container.Con

 	// We make mutations to the configuration, ensure we have a copy

 	dispatchRequest.state.runConfig = copyRunConfig(config)

 	dispatchRequest.state.imageID = config.Image

+	dispatchRequest.state.operatingSystem = os

 	for _, cmd := range commands {

 		err := dispatch(dispatchRequest, cmd)

 		if err != nil {

@@ -28,7 +28,7 @@ func newContainerManager(docker builder.ExecBackend) *containerManager {

 }

 // Create a container

-func (c *containerManager) Create(runConfig *container.Config, hostConfig *container.HostConfig, platform string) (container.ContainerCreateCreatedBody, error) {

+func (c *containerManager) Create(runConfig *container.Config, hostConfig *container.HostConfig) (container.ContainerCreateCreatedBody, error) {

 	container, err := c.backend.ContainerCreate(types.ContainerCreateConfig{

 		Config:     runConfig,

 		HostConfig: hostConfig,

@@ -261,8 +261,8 @@ func dispatchOnbuild(d dispatchRequest, c *instructions.OnbuildCommand) error {

 func dispatchWorkdir(d dispatchRequest, c *instructions.WorkdirCommand) error {

 	runConfig := d.state.runConfig

 	var err error

-	optionsOS := system.ParsePlatform(d.builder.options.Platform).OS

-	runConfig.WorkingDir, err = normalizeWorkdir(optionsOS, runConfig.WorkingDir, c.Path)

+	baseImageOS := system.ParsePlatform(d.state.operatingSystem).OS

+	runConfig.WorkingDir, err = normalizeWorkdir(baseImageOS, runConfig.WorkingDir, c.Path)

 	if err != nil {

 		return err

 	}

@@ -278,7 +278,7 @@ func dispatchWorkdir(d dispatchRequest, c *instructions.WorkdirCommand) error {

 	}

 	comment := "WORKDIR " + runConfig.WorkingDir

-	runConfigWithCommentCmd := copyRunConfig(runConfig, withCmdCommentString(comment, optionsOS))

+	runConfigWithCommentCmd := copyRunConfig(runConfig, withCmdCommentString(comment, baseImageOS))

 	containerID, err := d.builder.probeAndCreate(d.state, runConfigWithCommentCmd)

 	if err != nil || containerID == "" {

 		return err

@@ -290,10 +290,10 @@ func dispatchWorkdir(d dispatchRequest, c *instructions.WorkdirCommand) error {

 	return d.builder.commitContainer(d.state, containerID, runConfigWithCommentCmd)

 }

-func resolveCmdLine(cmd instructions.ShellDependantCmdLine, runConfig *container.Config, platform string) []string {

+func resolveCmdLine(cmd instructions.ShellDependantCmdLine, runConfig *container.Config, os string) []string {

 	result := cmd.CmdLine

 	if cmd.PrependShell && result != nil {

-		result = append(getShell(runConfig, platform), result...)

+		result = append(getShell(runConfig, os), result...)

 	}

 	return result

 }

@@ -311,8 +311,7 @@ func resolveCmdLine(cmd instructions.ShellDependantCmdLine, runConfig *container

 func dispatchRun(d dispatchRequest, c *instructions.RunCommand) error {

 	stateRunConfig := d.state.runConfig

-	optionsOS := system.ParsePlatform(d.builder.options.Platform).OS

-	cmdFromArgs := resolveCmdLine(c.ShellDependantCmdLine, stateRunConfig, optionsOS)

+	cmdFromArgs := resolveCmdLine(c.ShellDependantCmdLine, stateRunConfig, d.state.operatingSystem)

 	buildArgs := d.state.buildArgs.FilterAllowed(stateRunConfig.Env)

 	saveCmd := cmdFromArgs

@@ -104,13 +104,14 @@ func dispatch(d dispatchRequest, cmd instructions.Command) (err error) {

 // dispatchState is a data object which is modified by dispatchers

 type dispatchState struct {

-	runConfig  *container.Config

-	maintainer string

-	cmdSet     bool

-	imageID    string

-	baseImage  builder.Image

-	stageName  string

-	buildArgs  *buildArgs

+	runConfig       *container.Config

+	maintainer      string

+	cmdSet          bool

+	imageID         string

+	baseImage       builder.Image

+	stageName       string

+	buildArgs       *buildArgs

+	operatingSystem string

 }

 func newDispatchState(baseArgs *buildArgs) *dispatchState {

@@ -213,6 +214,7 @@ func (s *dispatchState) hasFromImage() bool {

 func (s *dispatchState) beginStage(stageName string, image builder.Image) {

 	s.stageName = stageName

 	s.imageID = image.ImageID()

+	s.operatingSystem = image.OperatingSystem()

 	if image.RunConfig() != nil {

 		// copy avoids referencing the same instance when 2 stages have the same base

@@ -229,7 +231,7 @@ func (s *dispatchState) beginStage(stageName string, image builder.Image) {

 // Add the default PATH to runConfig.ENV if one exists for the operating system and there

 // is no PATH set. Note that Windows containers on Windows won't have one as it's set by HCS

 func (s *dispatchState) setDefaultPath() {

-	defaultPath := system.DefaultPathEnv(s.baseImage.OperatingSystem())

+	defaultPath := system.DefaultPathEnv(s.operatingSystem)

 	if defaultPath == "" {

 		return

 	}

@@ -125,8 +125,7 @@ func (b *Builder) commitContainer(dispatchState *dispatchState, id string, conta

 }

 func (b *Builder) exportImage(state *dispatchState, imageMount *imageMount, runConfig *container.Config) error {

-	optionsPlatform := system.ParsePlatform(b.options.Platform)

-	newLayer, err := imageMount.Layer().Commit(optionsPlatform.OS)

+	newLayer, err := imageMount.Layer().Commit()

 	if err != nil {

 		return err

 	}

@@ -502,15 +501,13 @@ func (b *Builder) probeAndCreate(dispatchState *dispatchState, runConfig *contai

 	}

 	// Set a log config to override any default value set on the daemon

 	hostConfig := &container.HostConfig{LogConfig: defaultLogConfig}

-	optionsPlatform := system.ParsePlatform(b.options.Platform)

-	container, err := b.containerManager.Create(runConfig, hostConfig, optionsPlatform.OS)

+	container, err := b.containerManager.Create(runConfig, hostConfig)

 	return container.ID, err

 }

 func (b *Builder) create(runConfig *container.Config) (string, error) {

 	hostConfig := hostConfigFromOptions(b.options)

-	optionsPlatform := system.ParsePlatform(b.options.Platform)

-	container, err := b.containerManager.Create(runConfig, hostConfig, optionsPlatform.OS)

+	container, err := b.containerManager.Create(runConfig, hostConfig)

 	if err != nil {

 		return "", err

 	}

@@ -127,7 +127,7 @@ func (l *mockLayer) Mount() (containerfs.ContainerFS, error) {

 	return containerfs.NewLocalContainerFS("mountPath"), nil

 }

-func (l *mockLayer) Commit(string) (builder.ReleaseableLayer, error) {

+func (l *mockLayer) Commit() (builder.ReleaseableLayer, error) {

 	return nil, nil

 }

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

 	layerStore layer.Store

 	roLayer    layer.Layer

 	rwLayer    layer.RWLayer

-	os         string

 }

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

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

 	}

 	mountID := stringid.GenerateRandomID()

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

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

 	if err != nil {

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

 	}

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

 	return mountPath, nil

 }

-func (rl *releaseableLayer) Commit(os string) (builder.ReleaseableLayer, error) {

+func (rl *releaseableLayer) Commit() (builder.ReleaseableLayer, error) {

 	var chainID layer.ChainID

 	if rl.roLayer != nil {

 		chainID = rl.roLayer.ChainID()

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

 	}

 	defer stream.Close()

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

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

 	if err != nil {

 		return nil, err

 	}

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

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

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

 }

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

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

 	return err

 }

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

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

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

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

+		return &releaseableLayer{layerStore: layerStore}, nil

 	}

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

 	// it is released

@@ -138,7 +137,7 @@ func newReleasableLayerForImage(img *image.Image, layerStore layer.Store, os str

 	if err != nil {

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

 	}

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

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

 }

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

@@ -172,7 +171,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.layerStore, opts.OS)

+		layer, err := newReleasableLayerForImage(nil, daemon.layerStores[opts.OS])

 		return nil, layer, err

 	}

@@ -183,7 +182,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.layerStore, image.OperatingSystem())

+			layer, err := newReleasableLayerForImage(image, daemon.layerStores[image.OperatingSystem()])

 			return image, layer, err

 		}

 	}

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

 	if err != nil {

 		return nil, nil, err

 	}

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

+	layer, err := newReleasableLayerForImage(image, daemon.layerStores[image.OperatingSystem()])

 	return image, layer, err

 }

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

 		c.Config = container.Config

 	}

-	newConfig, err := dockerfile.BuildFromConfig(c.Config, c.Changes)

+	newConfig, err := dockerfile.BuildFromConfig(c.Config, c.Changes, container.OS)

 	if err != nil {

 		return "", err

 	}

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

 		}

 	}

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

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

 	if err != nil {

 		return "", err

 	}

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

+	defer layer.ReleaseAndLog(daemon.layerStores[container.OS], l)

 	containerConfig := c.ContainerConfig

 	if containerConfig == nil {

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

 }

 func (daemon *Daemon) exportContainerRw(container *container.Container) (arch io.ReadCloser, err error) {

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

+	rwlayer, err := daemon.layerStores[container.OS].GetRWLayer(container.ID)

 	if err != nil {

 		return nil, err

 	}

 	defer func() {

 		if err != nil {

-			daemon.stores[container.OS].layerStore.ReleaseRWLayer(rwlayer)

+			daemon.layerStores[container.OS].ReleaseRWLayer(rwlayer)

 		}

 	}()

@@ -278,7 +278,7 @@ func (daemon *Daemon) exportContainerRw(container *container.Container) (arch io

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

 			archive.Close()

 			err = rwlayer.Unmount()

-			daemon.stores[container.OS].layerStore.ReleaseRWLayer(rwlayer)

+			daemon.layerStores[container.OS].ReleaseRWLayer(rwlayer)

 			return err

 		}),

 		nil

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

 		StorageOpt: container.HostConfig.StorageOpt,

 	}

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

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

 	if err != nil {

 		return err

 	}

@@ -97,7 +97,7 @@ type Daemon struct {

 	referenceStore            refstore.Store

 	imageStore                image.Store

 	imageRoot                 string

-	layerStore                layer.Store

+	layerStores               map[string]layer.Store // By operating system

 	distributionMetadataStore dmetadata.Store

 	PluginStore               *plugin.Store // todo: remove

 	pluginManager             *plugin.Manager

@@ -159,7 +159,7 @@ func (daemon *Daemon) restore() error {

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

 		currentDriverForContainerOS := daemon.graphDrivers[container.OS]

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

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

+			rwlayer, err := daemon.layerStores[container.OS].GetRWLayer(container.ID)

 			if err != nil {

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

 				continue

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

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

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

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

+	d.layerStores = make(map[string]layer.Store)

 	if runtime.GOOS == "windows" {

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

 		if system.LCOWSupported() {

@@ -746,22 +747,25 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

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

 	}

-	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

+	for operatingSystem, gd := range d.graphDrivers {

+		d.layerStores[operatingSystem], err = layer.NewStoreFromOptions(layer.StoreOptions{

+			Root: config.Root,

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

+			GraphDriver:               gd,

+			GraphDriverOptions:        config.GraphOptions,

+			IDMappings:                idMappings,

+			PluginGetter:              d.PluginStore,

+			ExperimentalEnabled:       config.Experimental,

+			OS:                        operatingSystem,

+		})

+		if err != nil {

+			return nil, err

+		}

 	}

-	// As layerstore may set the driver

+	// As layerstore initialization may set the driver

 	for os := range d.graphDrivers {

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

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

 	}

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

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

 	}

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

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

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

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

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

@@ -780,7 +784,12 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 	if err != nil {

 		return nil, err

 	}

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

+

+	lgrMap := make(map[string]image.LayerGetReleaser)

+	for os, ls := range d.layerStores {

+		lgrMap[os] = ls

+	}

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

 	if err != nil {

 		return nil, err

 	}

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

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

+		if err := v1.Migrate(config.Root, d.graphDrivers[runtime.GOOS], d.layerStores[runtime.GOOS], 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())

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

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

 				return

 			}

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

+			if mountid, err := daemon.layerStores[c.OS].GetMountID(c.ID); err == nil {

 				daemon.cleanupMountsByID(mountid)

 			}

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

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

 		}

 	}

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

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

+	for os, ls := range daemon.layerStores {

+		if ls != nil {

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

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

+			}

+		}

 	}

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

@@ -1083,7 +1096,7 @@ 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(os string) string {

-	return daemon.layerStore.DriverName(os)

+	return daemon.layerStores[os].DriverName()

 }

 // prepareTempDir prepares and returns the default directory to use

@@ -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.layerStore.ReleaseRWLayer(container.RWLayer)

+		metadata, err := daemon.layerStores[container.OS].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)

@@ -96,21 +96,23 @@ func (daemon *Daemon) SystemDiskUsage(ctx context.Context) (*types.DiskUsage, er

 	// Get total layers size on disk

 	var allLayersSize int64

 	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

+	for _, ls := range daemon.layerStores {

+		allLayers := ls.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", l.ChainID())

+					}

 				} else {

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

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

 				}

-			} else {

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

 			}

 		}

 	}

@@ -47,13 +47,13 @@ func (daemon *Daemon) ContainerExport(name string, out io.Writer) error {

 }

 func (daemon *Daemon) containerExport(container *container.Container) (arch io.ReadCloser, err error) {

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

+	rwlayer, err := daemon.layerStores[container.OS].GetRWLayer(container.ID)

 	if err != nil {

 		return nil, err

 	}

 	defer func() {

 		if err != nil {

-			daemon.stores[container.OS].layerStore.ReleaseRWLayer(rwlayer)

+			daemon.layerStores[container.OS].ReleaseRWLayer(rwlayer)

 		}

 	}()

@@ -74,7 +74,7 @@ func (daemon *Daemon) containerExport(container *container.Container) (arch io.R

 	arch = ioutils.NewReadCloserWrapper(archive, func() error {

 		err := archive.Close()

 		rwlayer.Unmount()

-		daemon.stores[container.OS].layerStore.ReleaseRWLayer(rwlayer)

+		daemon.layerStores[container.OS].ReleaseRWLayer(rwlayer)

 		return err

 	})

 	daemon.LogContainerEvent(container, "export")

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

 		err                error

 	)

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

+	// Safe to index by runtime.GOOS as Unix hosts don't support multiple

+	// container operating systems.

+	rwlayer, err := daemon.layerStores[runtime.GOOS].GetRWLayer(containerID)

 	if err != nil {

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

 		return sizeRw, sizeRootfs

 	}

-	defer daemon.layerStore.ReleaseRWLayer(rwlayer)

+	defer daemon.layerStores[runtime.GOOS].ReleaseRWLayer(rwlayer)

 	sizeRw, err = rwlayer.Size()

 	if err != nil {

@@ -931,8 +931,6 @@ func parseStorageOpt(storageOpt map[string]string) (*storageOptions, error) {

 				return nil, err

 			}

 			options.size = uint64(size)

-		default:

-			return nil, fmt.Errorf("Unknown storage option: %s", key)

 		}

 	}

 	return &options, nil

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

 import (

 	"fmt"

-	"runtime"

 	"github.com/docker/distribution/reference"

 	"github.com/docker/docker/errdefs"

@@ -58,11 +57,7 @@ func (daemon *Daemon) GetImageIDAndOS(refOrID string) (image.ID, string, error)

 		if err != nil {

 			return "", "", errImageDoesNotExist{ref}

 		}

-		imageOS := img.OperatingSystem()

-		if imageOS == "" {

-			imageOS = runtime.GOOS

-		}

-		return id, imageOS, nil

+		return id, img.OperatingSystem(), nil

 	}

 	return "", "", errImageDoesNotExist{ref}

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

 // the same tag are exported. names is the set of tags to export, and

 // outStream is the writer which the images are written to.

 func (daemon *Daemon) ExportImage(names []string, outStream io.Writer) error {

-	imageExporter := tarexport.NewTarExporter(daemon.imageStore, daemon.layerStore, daemon.referenceStore, daemon)

+	imageExporter := tarexport.NewTarExporter(daemon.imageStore, daemon.layerStores, daemon.referenceStore, daemon)

 	return imageExporter.Save(names, outStream)

 }

@@ -20,6 +20,6 @@ func (daemon *Daemon) ExportImage(names []string, outStream io.Writer) error {

 // complement of ImageExport.  The input stream is an uncompressed tar

 // ball containing images and metadata.

 func (daemon *Daemon) LoadImage(inTar io.ReadCloser, outStream io.Writer, quiet bool) error {

-	imageExporter := tarexport.NewTarExporter(daemon.imageStore, daemon.layerStore, daemon.referenceStore, daemon)

+	imageExporter := tarexport.NewTarExporter(daemon.imageStore, daemon.layerStores, daemon.referenceStore, daemon)

 	return imageExporter.Load(inTar, outStream, quiet)

 }

@@ -33,12 +33,12 @@ func (daemon *Daemon) ImageHistory(name string) ([]*image.HistoryResponseItem, e

 			}

 			rootFS.Append(img.RootFS.DiffIDs[layerCounter])

-			l, err := daemon.layerStore.Get(rootFS.ChainID())

+			l, err := daemon.layerStores[img.OperatingSystem()].Get(rootFS.ChainID())

 			if err != nil {

 				return nil, err

 			}

 			layerSize, err = l.DiffSize()

-			layer.ReleaseAndLog(daemon.layerStore, l)

+			layer.ReleaseAndLog(daemon.layerStores[img.OperatingSystem()], l)

 			if err != nil {

 				return nil, err

 			}

@@ -1,7 +1,6 @@

 package daemon

 import (

-	"runtime"

 	"time"

 	"github.com/docker/distribution/reference"

@@ -18,12 +17,6 @@ func (daemon *Daemon) LookupImage(name string) (*types.ImageInspect, error) {

 		return nil, errors.Wrapf(err, "no such image: %s", name)

 	}

-	// If the image OS isn't set, assume it's the host OS

-	os := img.OS

-	if os == "" {

-		os = runtime.GOOS

-	}

-

 	refs := daemon.referenceStore.References(img.ID().Digest())

 	repoTags := []string{}

 	repoDigests := []string{}

@@ -40,11 +33,11 @@ func (daemon *Daemon) LookupImage(name string) (*types.ImageInspect, error) {

 	var layerMetadata map[string]string

 	layerID := img.RootFS.ChainID()

 	if layerID != "" {

-		l, err := daemon.layerStore.Get(layerID)

+		l, err := daemon.layerStores[img.OperatingSystem()].Get(layerID)

 		if err != nil {

 			return nil, err

 		}

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

+		defer layer.ReleaseAndLog(daemon.layerStores[img.OperatingSystem()], l)

 		size, err = l.Size()

 		if err != nil {

 			return nil, err

@@ -79,7 +72,7 @@ func (daemon *Daemon) LookupImage(name string) (*types.ImageInspect, error) {

 		Author:          img.Author,

 		Config:          img.Config,

 		Architecture:    img.Architecture,

-		Os:              os,

+		Os:              img.OperatingSystem(),

 		OsVersion:       img.OSVersion,

 		Size:            size,

 		VirtualSize:     size, // TODO: field unused, deprecate

@@ -89,7 +82,7 @@ func (daemon *Daemon) LookupImage(name string) (*types.ImageInspect, error) {

 		},

 	}

-	imageInspect.GraphDriver.Name = daemon.GraphDriverName(os)

+	imageInspect.GraphDriver.Name = daemon.GraphDriverName(img.OperatingSystem())

 	imageInspect.GraphDriver.Data = layerMetadata

 	return imageInspect, nil

@@ -51,7 +51,7 @@ func (daemon *Daemon) PushImage(ctx context.Context, image, tag string, metaHead

 			ReferenceStore:   daemon.referenceStore,

 		},

 		ConfigMediaType: schema2.MediaTypeImageConfig,

-		LayerStore:      distribution.NewLayerProviderFromStore(daemon.layerStore),

+		LayerStores:     distribution.NewLayerProvidersFromStores(daemon.layerStores),

 		TrustKey:        daemon.trustKey,

 		UploadManager:   daemon.uploadManager,

 	}

@@ -116,7 +116,7 @@ func (daemon *Daemon) Images(imageFilters filters.Args, all bool, withExtraAttrs

 		layerID := img.RootFS.ChainID()

 		var size int64

 		if layerID != "" {

-			l, err := daemon.layerStore.Get(layerID)

+			l, err := daemon.layerStores[img.OperatingSystem()].Get(layerID)

 			if err != nil {

 				// The layer may have been deleted between the call to `Map()` or

 				// `Heads()` and the call to `Get()`, so we just ignore this error

@@ -127,7 +127,7 @@ func (daemon *Daemon) Images(imageFilters filters.Args, all bool, withExtraAttrs

 			}

 			size, err = l.Size()

-			layer.ReleaseAndLog(daemon.layerStore, l)

+			layer.ReleaseAndLog(daemon.layerStores[img.OperatingSystem()], l)

 			if err != nil {

 				return nil, err

 			}

@@ -179,7 +179,7 @@ func (daemon *Daemon) Images(imageFilters filters.Args, all bool, withExtraAttrs

 			// lazily init variables

 			if imagesMap == nil {

 				allContainers = daemon.List()

-				allLayers = daemon.layerStore.Map()

+				allLayers = daemon.layerStores[img.OperatingSystem()].Map()

 				imagesMap = make(map[*image.Image]*types.ImageSummary)

 				layerRefs = make(map[layer.ChainID]int)

 			}

@@ -264,11 +264,11 @@ func (daemon *Daemon) SquashImage(id, parent string) (string, error) {

 		parentImg = &image.Image{RootFS: rootFS}

 	}

-	l, err := daemon.layerStore.Get(img.RootFS.ChainID())

+	l, err := daemon.layerStores[img.OperatingSystem()].Get(img.RootFS.ChainID())

 	if err != nil {

 		return "", errors.Wrap(err, "error getting image layer")

 	}

-	defer daemon.layerStore.Release(l)

+	defer daemon.layerStores[img.OperatingSystem()].Release(l)

 	ts, err := l.TarStreamFrom(parentChainID)

 	if err != nil {

@@ -276,11 +276,11 @@ func (daemon *Daemon) SquashImage(id, parent string) (string, error) {

 	}

 	defer ts.Close()

-	newL, err := daemon.layerStore.Register(ts, parentChainID, img.OperatingSystem())

+	newL, err := daemon.layerStores[img.OperatingSystem()].Register(ts, parentChainID)

 	if err != nil {

 		return "", errors.Wrap(err, "error registering layer")

 	}

-	defer daemon.layerStore.Release(newL)

+	defer daemon.layerStores[img.OperatingSystem()].Release(newL)

 	newImage := *img

 	newImage.RootFS = nil

@@ -57,7 +57,7 @@ func (daemon *Daemon) ImportImage(src string, repository, os string, tag string,

 		}

 	}

-	config, err := dockerfile.BuildFromConfig(&container.Config{}, changes)

+	config, err := dockerfile.BuildFromConfig(&container.Config{}, changes, os)

 	if err != nil {

 		return err

 	}

@@ -91,11 +91,11 @@ func (daemon *Daemon) ImportImage(src string, repository, os string, tag string,

 	if err != nil {

 		return err

 	}

-	l, err := daemon.layerStore.Register(inflatedLayerData, "", os)

+	l, err := daemon.layerStores[os].Register(inflatedLayerData, "")

 	if err != nil {

 		return err

 	}

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

+	defer layer.ReleaseAndLog(daemon.layerStores[os], l)

 	created := time.Now().UTC()

 	imgConfig, err := json.Marshal(&image.Image{

@@ -81,7 +81,7 @@ func (daemon *Daemon) SystemInfo() (*types.Info, error) {

 	var ds [][2]string

 	drivers := ""

 	for os, gd := range daemon.graphDrivers {

-		ds = append(ds, daemon.layerStore.DriverStatus(os)...)

+		ds = append(ds, daemon.layerStores[os].DriverStatus()...)

 		drivers += gd

 		if len(daemon.graphDrivers) > 1 {

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

@@ -138,9 +138,9 @@ func (daemon *Daemon) createSpec(c *container.Container) (*specs.Spec, error) {

 	max := len(img.RootFS.DiffIDs)

 	for i := 1; i <= max; i++ {

 		img.RootFS.DiffIDs = img.RootFS.DiffIDs[:i]

-		layerPath, err := layer.GetLayerPath(daemon.layerStore, img.RootFS.ChainID())

+		layerPath, err := layer.GetLayerPath(daemon.layerStores[img.OperatingSystem()], img.RootFS.ChainID())

 		if err != nil {

-			return nil, fmt.Errorf("failed to get layer path from graphdriver %s for ImageID %s - %s", daemon.layerStore, img.RootFS.ChainID(), err)

+			return nil, fmt.Errorf("failed to get layer path from graphdriver %s for ImageID %s - %s", daemon.layerStores[img.OperatingSystem()], img.RootFS.ChainID(), err)

 		}

 		// Reverse order, expecting parent most first

 		s.Windows.LayerFolders = append([]string{layerPath}, s.Windows.LayerFolders...)

@@ -205,7 +205,12 @@ func (daemon *Daemon) ImagesPrune(ctx context.Context, pruneFilters filters.Args

 	}

 	// Filter intermediary images and get their unique size

-	allLayers := daemon.layerStore.Map()

+	allLayers := make(map[layer.ChainID]layer.Layer)

+	for _, ls := range daemon.layerStores {

+		for k, v := range ls.Map() {

+			allLayers[k] = v

+		}

+	}

 	topImages := map[image.ID]*image.Image{}

 	for id, img := range allImages {

 		select {

@@ -222,7 +222,7 @@ func (daemon *Daemon) Cleanup(container *container.Container) {

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

 		// FIXME: remove once reference counting for graphdrivers has been refactored

 		// Ensure that all the mounts are gone

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

+		if mountid, err := daemon.layerStores[container.OS].GetMountID(container.ID); err == nil {

 			daemon.cleanupMountsByID(mountid)

 		}

 	}

@@ -71,8 +71,8 @@ type ImagePushConfig struct {

 	// ConfigMediaType is the configuration media type for

 	// schema2 manifests.

 	ConfigMediaType string

-	// LayerStore manages layers.

-	LayerStore PushLayerProvider

+	// LayerStores (indexed by operating system) manages layers.

+	LayerStores map[string]PushLayerProvider

 	// TrustKey is the private key for legacy signatures. This is typically

 	// an ephemeral key, since these signatures are no longer verified.

 	TrustKey libtrust.PrivateKey

@@ -165,13 +165,15 @@ type storeLayerProvider struct {

 	ls layer.Store

 }

-// NewLayerProviderFromStore returns a layer provider backed by

+// NewLayerProvidersFromStores returns layer providers backed by

 // an instance of LayerStore. Only getting layers as gzipped

 // tars is supported.

-func NewLayerProviderFromStore(ls layer.Store) PushLayerProvider {

-	return &storeLayerProvider{

-		ls: ls,

+func NewLayerProvidersFromStores(lss map[string]layer.Store) map[string]PushLayerProvider {

+	plps := make(map[string]PushLayerProvider)

+	for os, ls := range lss {

+		plps[os] = &storeLayerProvider{ls: ls}

 	}

+	return plps

 }

 func (p *storeLayerProvider) Get(lid layer.ChainID) (PushLayer, error) {

@@ -210,7 +210,7 @@ func (p *v1Pusher) imageListForTag(imgID image.ID, dependenciesSeen map[layer.Ch

 	topLayerID := img.RootFS.ChainID()

-	pl, err := p.config.LayerStore.Get(topLayerID)

+	pl, err := p.config.LayerStores[img.OperatingSystem()].Get(topLayerID)

 	*referencedLayers = append(*referencedLayers, pl)

 	if err != nil {

 		return nil, fmt.Errorf("failed to get top layer from image: %v", err)

@@ -118,12 +118,12 @@ func (p *v2Pusher) pushV2Tag(ctx context.Context, ref reference.NamedTagged, id

 		return fmt.Errorf("could not find image from tag %s: %v", reference.FamiliarString(ref), err)

 	}

-	rootfs, _, err := p.config.ImageStore.RootFSAndOSFromConfig(imgConfig)

+	rootfs, os, err := p.config.ImageStore.RootFSAndOSFromConfig(imgConfig)

 	if err != nil {

 		return fmt.Errorf("unable to get rootfs for image %s: %s", reference.FamiliarString(ref), err)

 	}

-	l, err := p.config.LayerStore.Get(rootfs.ChainID())

+	l, err := p.config.LayerStores[os].Get(rootfs.ChainID())

 	if err != nil {

 		return fmt.Errorf("failed to get top layer from image: %v", err)

 	}

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

 	"errors"

 	"fmt"

 	"io"

+	"runtime"

 	"time"

 	"github.com/docker/distribution"

@@ -22,7 +23,7 @@ const maxDownloadAttempts = 5

 // registers and downloads those, taking into account dependencies between

 // layers.

 type LayerDownloadManager struct {

-	layerStore   layer.Store

+	layerStores  map[string]layer.Store

 	tm           TransferManager

 	waitDuration time.Duration

 }

@@ -33,9 +34,9 @@ func (ldm *LayerDownloadManager) SetConcurrency(concurrency int) {

 }

 // NewLayerDownloadManager returns a new LayerDownloadManager.

-func NewLayerDownloadManager(layerStore layer.Store, concurrencyLimit int, options ...func(*LayerDownloadManager)) *LayerDownloadManager {

+func NewLayerDownloadManager(layerStores map[string]layer.Store, concurrencyLimit int, options ...func(*LayerDownloadManager)) *LayerDownloadManager {

 	manager := LayerDownloadManager{

-		layerStore:   layerStore,

+		layerStores:  layerStores,

 		tm:           NewTransferManager(concurrencyLimit),