@@ -3,13 +3,13 @@ package image

 import (

 	"fmt"

 	"io"

-	"os"

 	"golang.org/x/net/context"

 	"github.com/docker/docker/cli"

 	"github.com/docker/docker/cli/command"

 	"github.com/docker/docker/pkg/jsonmessage"

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

 	"github.com/spf13/cobra"

 )

@@ -43,7 +43,9 @@ func runLoad(dockerCli *command.DockerCli, opts loadOptions) error {

 	var input io.Reader = dockerCli.In()

 	if opts.input != "" {

-		file, err := os.Open(opts.input)

+		// We use system.OpenSequential to use sequential file access on Windows, avoiding

+		// depleting the standby list un-necessarily. On Linux, this equates to a regular os.Open.

+		file, err := system.OpenSequential(opts.input)

 		if err != nil {

 			return err

 		}

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

 	"github.com/docker/docker/pkg/streamformatter"

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

 	"github.com/docker/docker/pkg/symlink"

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

 	"github.com/docker/docker/reference"

 )

@@ -164,7 +165,9 @@ func (l *tarexporter) setParentID(id, parentID image.ID) error {

 }

 func (l *tarexporter) loadLayer(filename string, rootFS image.RootFS, id string, foreignSrc distribution.Descriptor, progressOutput progress.Output) (layer.Layer, error) {

-	rawTar, err := os.Open(filename)

+	// We use system.OpenSequential to use sequential file access on Windows, avoiding

+	// depleting the standby list. On Linux, this equates to a regular os.Open.

+	rawTar, err := system.OpenSequential(filename)

 	if err != nil {

 		logrus.Debugf("Error reading embedded tar: %v", err)

 		return nil, err

@@ -315,8 +315,10 @@ func (s *saveSession) saveLayer(id layer.ChainID, legacyImg image.V1Image, creat

 		}

 		os.Symlink(relPath, layerPath)

 	} else {

-

-		tarFile, err := os.Create(layerPath)

+		// Use system.CreateSequential rather than os.Create. This ensures sequential

+		// file access on Windows to avoid eating into MM standby list.

+		// On Linux, this equates to a regular os.Create.

+		tarFile, err := system.CreateSequential(layerPath)

 		if err != nil {

 			return distribution.Descriptor{}, err

 		}

@@ -374,7 +374,10 @@ func (ta *tarAppender) addTarFile(path, name string) error {

 	}

 	if hdr.Typeflag == tar.TypeReg && hdr.Size > 0 {

-		file, err := os.Open(path)

+		// We use system.OpenSequential to ensure we use sequential file

+		// access on Windows to avoid depleting the standby list.

+		// On Linux, this equates to a regular os.Open.

+		file, err := system.OpenSequential(path)

 		if err != nil {

 			return err

 		}

@@ -412,8 +415,10 @@ func createTarFile(path, extractDir string, hdr *tar.Header, reader io.Reader, L

 		}

 	case tar.TypeReg, tar.TypeRegA:

-		// Source is regular file

-		file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, hdrInfo.Mode())

+		// Source is regular file. We use system.OpenFileSequential to use sequential

+		// file access to avoid depleting the standby list on Windows.

+		// On Linux, this equates to a regular os.OpenFile

+		file, err := system.OpenFileSequential(path, os.O_CREATE|os.O_WRONLY, hdrInfo.Mode())

 		if err != nil {

 			return err

 		}

@@ -23,3 +23,32 @@ func MkdirAll(path string, perm os.FileMode) error {

 func IsAbs(path string) bool {

 	return filepath.IsAbs(path)

 }

+

+// The functions below here are wrappers for the equivalents in the os package.

+// They are passthrough on Unix platforms, and only relevant on Windows.

+

+// CreateSequential creates the named file with mode 0666 (before umask), truncating

+// it if it already exists. If successful, methods on the returned

+// File can be used for I/O; the associated file descriptor has mode

+// O_RDWR.

+// If there is an error, it will be of type *PathError.

+func CreateSequential(name string) (*os.File, error) {

+	return os.Create(name)

+}

+

+// OpenSequential opens the named file for reading. If successful, methods on

+// the returned file can be used for reading; the associated file

+// descriptor has mode O_RDONLY.

+// If there is an error, it will be of type *PathError.

+func OpenSequential(name string) (*os.File, error) {

+	return os.Open(name)

+}

+

+// OpenFileSequential is the generalized open call; most users will use Open

+// or Create instead. It opens the named file with specified flag

+// (O_RDONLY etc.) and perm, (0666 etc.) if applicable. If successful,

+// methods on the returned File can be used for I/O.

+// If there is an error, it will be of type *PathError.

+func OpenFileSequential(name string, flag int, perm os.FileMode) (*os.File, error) {

+	return os.OpenFile(name, flag, perm)

+}

@@ -131,3 +131,106 @@ func IsAbs(path string) bool {

 	}

 	return true

 }

+

+// The origin of the functions below here are the golang OS and syscall packages,

+// slightly modified to only cope with files, not directories due to the

+// specific use case.

+//

+// The alteration is to allow a file on Windows to be opened with

+// FILE_FLAG_SEQUENTIAL_SCAN (particular for docker load), to avoid eating

+// the standby list, particularly when accessing large files such as layer.tar.

+

+// CreateSequential creates the named file with mode 0666 (before umask), truncating

+// it if it already exists. If successful, methods on the returned

+// File can be used for I/O; the associated file descriptor has mode

+// O_RDWR.

+// If there is an error, it will be of type *PathError.

+func CreateSequential(name string) (*os.File, error) {

+	return OpenFileSequential(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0)

+}

+

+// OpenSequential opens the named file for reading. If successful, methods on

+// the returned file can be used for reading; the associated file

+// descriptor has mode O_RDONLY.

+// If there is an error, it will be of type *PathError.

+func OpenSequential(name string) (*os.File, error) {

+	return OpenFileSequential(name, os.O_RDONLY, 0)

+}

+

+// OpenFileSequential is the generalized open call; most users will use Open

+// or Create instead.

+// If there is an error, it will be of type *PathError.

+func OpenFileSequential(name string, flag int, _ os.FileMode) (*os.File, error) {

+	if name == "" {

+		return nil, &os.PathError{"open", name, syscall.ENOENT}

+	}

+	r, errf := syscallOpenFileSequential(name, flag, 0)

+	if errf == nil {

+		return r, nil

+	}

+	return nil, &os.PathError{"open", name, errf}

+}

+

+func syscallOpenFileSequential(name string, flag int, _ os.FileMode) (file *os.File, err error) {

+	r, e := syscallOpenSequential(name, flag|syscall.O_CLOEXEC, 0)

+	if e != nil {

+		return nil, e

+	}

+	return os.NewFile(uintptr(r), name), nil

+}

+

+func makeInheritSa() *syscall.SecurityAttributes {

+	var sa syscall.SecurityAttributes

+	sa.Length = uint32(unsafe.Sizeof(sa))

+	sa.InheritHandle = 1

+	return &sa

+}

+

+func syscallOpenSequential(path string, mode int, _ uint32) (fd syscall.Handle, err error) {

+	if len(path) == 0 {

+		return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND

+	}

+	pathp, err := syscall.UTF16PtrFromString(path)

+	if err != nil {

+		return syscall.InvalidHandle, err

+	}

+	var access uint32

+	switch mode & (syscall.O_RDONLY | syscall.O_WRONLY | syscall.O_RDWR) {

+	case syscall.O_RDONLY:

+		access = syscall.GENERIC_READ

+	case syscall.O_WRONLY:

+		access = syscall.GENERIC_WRITE

+	case syscall.O_RDWR:

+		access = syscall.GENERIC_READ | syscall.GENERIC_WRITE

+	}

+	if mode&syscall.O_CREAT != 0 {

+		access |= syscall.GENERIC_WRITE

+	}

+	if mode&syscall.O_APPEND != 0 {

+		access &^= syscall.GENERIC_WRITE

+		access |= syscall.FILE_APPEND_DATA

+	}

+	sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE)

+	var sa *syscall.SecurityAttributes

+	if mode&syscall.O_CLOEXEC == 0 {

+		sa = makeInheritSa()

+	}

+	var createmode uint32

+	switch {

+	case mode&(syscall.O_CREAT|syscall.O_EXCL) == (syscall.O_CREAT | syscall.O_EXCL):

+		createmode = syscall.CREATE_NEW

+	case mode&(syscall.O_CREAT|syscall.O_TRUNC) == (syscall.O_CREAT | syscall.O_TRUNC):

+		createmode = syscall.CREATE_ALWAYS

+	case mode&syscall.O_CREAT == syscall.O_CREAT:

+		createmode = syscall.OPEN_ALWAYS

+	case mode&syscall.O_TRUNC == syscall.O_TRUNC:

+		createmode = syscall.TRUNCATE_EXISTING

+	default:

+		createmode = syscall.OPEN_EXISTING

+	}

+	// Use FILE_FLAG_SEQUENTIAL_SCAN rather than FILE_ATTRIBUTE_NORMAL as implemented in golang.

+	//https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx

+	const fileFlagSequentialScan = 0x08000000 // FILE_FLAG_SEQUENTIAL_SCAN

+	h, e := syscall.CreateFile(pathp, access, sharemode, sa, createmode, fileFlagSequentialScan, 0)

+	return h, e

+}