@@ -6,13 +6,12 @@ import (

 	"io/ioutil"

 	"os"

+	"github.com/containerd/continuity/fs"

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

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

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

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

 	"github.com/docker/docker/pkg/mount"

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

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

 	"github.com/docker/docker/volume"

 	"github.com/opencontainers/selinux/go-selinux/label"

 	"github.com/pkg/errors"

@@ -398,53 +397,15 @@ func (container *Container) DetachAndUnmount(volumeEventLog func(name, action st

 // copyExistingContents copies from the source to the destination and

 // ensures the ownership is appropriately set.

 func copyExistingContents(source, destination string) error {

-	volList, err := ioutil.ReadDir(source)

+	dstList, err := ioutil.ReadDir(destination)

 	if err != nil {

 		return err

 	}

-	if len(volList) > 0 {

-		srcList, err := ioutil.ReadDir(destination)

-		if err != nil {

-			return err

-		}

-		if len(srcList) == 0 {

-			// If the source volume is empty, copies files from the root into the volume

-			if err := chrootarchive.NewArchiver(nil).CopyWithTar(source, destination); err != nil {

-				return err

-			}

-		}

-	}

-	return copyOwnership(source, destination)

-}

-

-// copyOwnership copies the permissions and uid:gid of the source file

-// to the destination file

-func copyOwnership(source, destination string) error {

-	stat, err := system.Stat(source)

-	if err != nil {

-		return err

-	}

-

-	destStat, err := system.Stat(destination)

-	if err != nil {

-		return err

-	}

-

-	// In some cases, even though UID/GID match and it would effectively be a no-op,

-	// this can return a permission denied error... for example if this is an NFS

-	// mount.

-	// Since it's not really an error that we can't chown to the same UID/GID, don't

-	// even bother trying in such cases.

-	if stat.UID() != destStat.UID() || stat.GID() != destStat.GID() {

-		if err := os.Chown(destination, int(stat.UID()), int(stat.GID())); err != nil {

-			return err

-		}

-	}

-

-	if stat.Mode() != destStat.Mode() {

-		return os.Chmod(destination, os.FileMode(stat.Mode()))

+	if len(dstList) != 0 {

+		// destination is not empty, do not copy

+		return nil

 	}

-	return nil

+	return fs.CopyDir(destination, source)

 }

 // TmpfsMounts returns the list of tmpfs mounts

@@ -106,7 +106,7 @@ google.golang.org/genproto d80a6e20e776b0b17a324d0ba1ab50a39c8e8944

 # containerd

 github.com/containerd/containerd 3fa104f843ec92328912e042b767d26825f202aa

 github.com/containerd/fifo fbfb6a11ec671efbe94ad1c12c2e98773f19e1e6

-github.com/containerd/continuity 35d55c5e8dd23b32037d56cf97174aff3efdfa83

+github.com/containerd/continuity 992a5f112bd2211d0983a1cc8562d2882848f3a3

 github.com/containerd/cgroups 29da22c6171a4316169f9205ab6c49f59b5b852f

 github.com/containerd/console 84eeaae905fa414d03e07bcd6c8d3f19e7cf180e

 github.com/containerd/go-runc ed1cbe1fc31f5fb2359d3a54b6330d1a097858b7

deleted file mode 100644

@@ -1,15 +0,0 @@

-package devices

-

-// from /usr/include/sys/types.h

-

-func getmajor(dev int32) uint64 {

-	return (uint64(dev) >> 24) & 0xff

-}

-

-func getminor(dev int32) uint64 {

-	return uint64(dev) & 0xffffff

-}

-

-func makedev(major int, minor int) int {

-	return ((major << 24) | minor)

-}

deleted file mode 100644

@@ -1,23 +0,0 @@

-// +build solaris,!cgo

-

-//

-// Implementing the functions below requires cgo support.  Non-cgo stubs

-// versions are defined below to enable cross-compilation of source code

-// that depends on these functions, but the resultant cross-compiled

-// binaries cannot actually be used.  If the stub function(s) below are

-// actually invoked they will cause the calling process to exit.

-//

-

-package devices

-

-func getmajor(dev uint64) uint64 {

-	panic("getmajor() support requires cgo.")

-}

-

-func getminor(dev uint64) uint64 {

-	panic("getminor() support requires cgo.")

-}

-

-func makedev(major int, minor int) int {

-	panic("makedev() support requires cgo.")

-}

deleted file mode 100644

@@ -1,15 +0,0 @@

-package devices

-

-// from /usr/include/sys/types.h

-

-func getmajor(dev uint32) uint64 {

-	return (uint64(dev) >> 24) & 0xff

-}

-

-func getminor(dev uint32) uint64 {

-	return uint64(dev) & 0xffffff

-}

-

-func makedev(major int, minor int) int {

-	return ((major << 24) | minor)

-}

deleted file mode 100644

@@ -1,15 +0,0 @@

-package devices

-

-// from /usr/include/linux/kdev_t.h

-

-func getmajor(dev uint64) uint64 {

-	return dev >> 8

-}

-

-func getminor(dev uint64) uint64 {

-	return dev & 0xff

-}

-

-func makedev(major int, minor int) int {

-	return ((major << 8) | minor)

-}

deleted file mode 100644

@@ -1,18 +0,0 @@

-// +build cgo

-

-package devices

-

-//#include <sys/mkdev.h>

-import "C"

-

-func getmajor(dev uint64) uint64 {

-	return uint64(C.major(C.dev_t(dev)))

-}

-

-func getminor(dev uint64) uint64 {

-	return uint64(C.minor(C.dev_t(dev)))

-}

-

-func makedev(major int, minor int) int {

-	return int(C.makedev(C.major_t(major), C.minor_t(minor)))

-}

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

 	"fmt"

 	"os"

 	"syscall"

+

+	"golang.org/x/sys/unix"

 )

 func DeviceInfo(fi os.FileInfo) (uint64, uint64, error) {

@@ -14,42 +16,43 @@ func DeviceInfo(fi os.FileInfo) (uint64, uint64, error) {

 		return 0, 0, fmt.Errorf("cannot extract device from os.FileInfo")

 	}

-	return getmajor(sys.Rdev), getminor(sys.Rdev), nil

+	dev := uint64(sys.Rdev)

+	return uint64(unix.Major(dev)), uint64(unix.Minor(dev)), nil

 }

 // mknod provides a shortcut for syscall.Mknod

 func Mknod(p string, mode os.FileMode, maj, min int) error {

 	var (

 		m   = syscallMode(mode.Perm())

-		dev int

+		dev uint64

 	)

 	if mode&os.ModeDevice != 0 {

-		dev = makedev(maj, min)

+		dev = unix.Mkdev(uint32(maj), uint32(min))

 		if mode&os.ModeCharDevice != 0 {

-			m |= syscall.S_IFCHR

+			m |= unix.S_IFCHR

 		} else {

-			m |= syscall.S_IFBLK

+			m |= unix.S_IFBLK

 		}

 	} else if mode&os.ModeNamedPipe != 0 {

-		m |= syscall.S_IFIFO

+		m |= unix.S_IFIFO

 	}

-	return syscall.Mknod(p, m, dev)

+	return unix.Mknod(p, m, int(dev))

 }

 // syscallMode returns the syscall-specific mode bits from Go's portable mode bits.

 func syscallMode(i os.FileMode) (o uint32) {

 	o |= uint32(i.Perm())

 	if i&os.ModeSetuid != 0 {

-		o |= syscall.S_ISUID

+		o |= unix.S_ISUID

 	}

 	if i&os.ModeSetgid != 0 {

-		o |= syscall.S_ISGID

+		o |= unix.S_ISGID

 	}

 	if i&os.ModeSticky != 0 {

-		o |= syscall.S_ISVTX

+		o |= unix.S_ISVTX

 	}

 	return

 }

new file mode 100644

@@ -0,0 +1,119 @@

+package fs

+

+import (

+	"io/ioutil"

+	"os"

+	"path/filepath"

+	"sync"

+

+	"github.com/pkg/errors"

+)

+

+var bufferPool = &sync.Pool{

+	New: func() interface{} {

+		buffer := make([]byte, 32*1024)

+		return &buffer

+	},

+}

+

+// CopyDir copies the directory from src to dst.

+// Most efficient copy of files is attempted.

+func CopyDir(dst, src string) error {

+	inodes := map[uint64]string{}

+	return copyDirectory(dst, src, inodes)

+}

+

+func copyDirectory(dst, src string, inodes map[uint64]string) error {

+	stat, err := os.Stat(src)

+	if err != nil {

+		return errors.Wrapf(err, "failed to stat %s", src)

+	}

+	if !stat.IsDir() {

+		return errors.Errorf("source is not directory")

+	}

+

+	if st, err := os.Stat(dst); err != nil {

+		if err := os.Mkdir(dst, stat.Mode()); err != nil {

+			return errors.Wrapf(err, "failed to mkdir %s", dst)

+		}

+	} else if !st.IsDir() {

+		return errors.Errorf("cannot copy to non-directory: %s", dst)

+	} else {

+		if err := os.Chmod(dst, stat.Mode()); err != nil {

+			return errors.Wrapf(err, "failed to chmod on %s", dst)

+		}

+	}

+

+	fis, err := ioutil.ReadDir(src)

+	if err != nil {

+		return errors.Wrapf(err, "failed to read %s", src)

+	}

+

+	if err := copyFileInfo(stat, dst); err != nil {

+		return errors.Wrapf(err, "failed to copy file info for %s", dst)

+	}

+

+	for _, fi := range fis {

+		source := filepath.Join(src, fi.Name())

+		target := filepath.Join(dst, fi.Name())

+

+		switch {

+		case fi.IsDir():

+			if err := copyDirectory(target, source, inodes); err != nil {

+				return err

+			}

+			continue

+		case (fi.Mode() & os.ModeType) == 0:

+			link, err := getLinkSource(target, fi, inodes)

+			if err != nil {

+				return errors.Wrap(err, "failed to get hardlink")

+			}

+			if link != "" {

+				if err := os.Link(link, target); err != nil {

+					return errors.Wrap(err, "failed to create hard link")

+				}

+			} else if err := copyFile(source, target); err != nil {

+				return errors.Wrap(err, "failed to copy files")

+			}

+		case (fi.Mode() & os.ModeSymlink) == os.ModeSymlink:

+			link, err := os.Readlink(source)

+			if err != nil {

+				return errors.Wrapf(err, "failed to read link: %s", source)

+			}

+			if err := os.Symlink(link, target); err != nil {

+				return errors.Wrapf(err, "failed to create symlink: %s", target)

+			}

+		case (fi.Mode() & os.ModeDevice) == os.ModeDevice:

+			if err := copyDevice(target, fi); err != nil {

+				return errors.Wrapf(err, "failed to create device")

+			}

+		default:

+			// TODO: Support pipes and sockets

+			return errors.Wrapf(err, "unsupported mode %s", fi.Mode())

+		}

+		if err := copyFileInfo(fi, target); err != nil {

+			return errors.Wrap(err, "failed to copy file info")

+		}

+

+		if err := copyXAttrs(target, source); err != nil {

+			return errors.Wrap(err, "failed to copy xattrs")

+		}

+	}

+

+	return nil

+}

+

+func copyFile(source, target string) error {

+	src, err := os.Open(source)

+	if err != nil {

+		return errors.Wrapf(err, "failed to open source %s", source)

+	}

+	defer src.Close()

+	tgt, err := os.Create(target)

+	if err != nil {

+		return errors.Wrapf(err, "failed to open target %s", target)

+	}

+	defer tgt.Close()

+

+	return copyFileContent(tgt, src)

+}

new file mode 100644

@@ -0,0 +1,95 @@

+package fs

+

+import (

+	"io"

+	"os"

+	"syscall"

+

+	"github.com/containerd/continuity/sysx"

+	"github.com/pkg/errors"

+	"golang.org/x/sys/unix"

+)

+

+func copyFileInfo(fi os.FileInfo, name string) error {

+	st := fi.Sys().(*syscall.Stat_t)

+	if err := os.Lchown(name, int(st.Uid), int(st.Gid)); err != nil {

+		if os.IsPermission(err) {

+			// Normally if uid/gid are the same this would be a no-op, but some

+			// filesystems may still return EPERM... for instance NFS does this.

+			// In such a case, this is not an error.

+			if dstStat, err2 := os.Lstat(name); err2 == nil {

+				st2 := dstStat.Sys().(*syscall.Stat_t)

+				if st.Uid == st2.Uid && st.Gid == st2.Gid {

+					err = nil

+				}

+			}

+		}

+		if err != nil {

+			return errors.Wrapf(err, "failed to chown %s", name)

+		}

+	}

+

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

+		if err := os.Chmod(name, fi.Mode()); err != nil {

+			return errors.Wrapf(err, "failed to chmod %s", name)

+		}

+	}

+

+	timespec := []unix.Timespec{unix.Timespec(StatAtime(st)), unix.Timespec(StatMtime(st))}

+	if err := unix.UtimesNanoAt(unix.AT_FDCWD, name, timespec, unix.AT_SYMLINK_NOFOLLOW); err != nil {

+		return errors.Wrapf(err, "failed to utime %s", name)

+	}

+

+	return nil

+}

+

+func copyFileContent(dst, src *os.File) error {

+	st, err := src.Stat()

+	if err != nil {

+		return errors.Wrap(err, "unable to stat source")

+	}

+

+	n, err := unix.CopyFileRange(int(src.Fd()), nil, int(dst.Fd()), nil, int(st.Size()), 0)

+	if err != nil {

+		if err != unix.ENOSYS && err != unix.EXDEV {

+			return errors.Wrap(err, "copy file range failed")

+		}

+

+		buf := bufferPool.Get().(*[]byte)

+		_, err = io.CopyBuffer(dst, src, *buf)

+		bufferPool.Put(buf)

+		return err

+	}

+

+	if int64(n) != st.Size() {

+		return errors.Wrapf(err, "short copy: %d of %d", int64(n), st.Size())

+	}

+

+	return nil

+}

+

+func copyXAttrs(dst, src string) error {

+	xattrKeys, err := sysx.LListxattr(src)

+	if err != nil {

+		return errors.Wrapf(err, "failed to list xattrs on %s", src)

+	}

+	for _, xattr := range xattrKeys {

+		data, err := sysx.LGetxattr(src, xattr)

+		if err != nil {

+			return errors.Wrapf(err, "failed to get xattr %q on %s", xattr, src)

+		}

+		if err := sysx.LSetxattr(dst, xattr, data, 0); err != nil {

+			return errors.Wrapf(err, "failed to set xattr %q on %s", xattr, dst)

+		}

+	}

+

+	return nil

+}

+

+func copyDevice(dst string, fi os.FileInfo) error {

+	st, ok := fi.Sys().(*syscall.Stat_t)

+	if !ok {

+		return errors.New("unsupported stat type")

+	}

+	return unix.Mknod(dst, uint32(fi.Mode()), int(st.Rdev))

+}

new file mode 100644

@@ -0,0 +1,80 @@

+// +build solaris darwin freebsd

+

+package fs

+

+import (

+	"io"

+	"os"

+	"syscall"

+

+	"github.com/containerd/continuity/sysx"

+	"github.com/pkg/errors"

+	"golang.org/x/sys/unix"

+)

+

+func copyFileInfo(fi os.FileInfo, name string) error {

+	st := fi.Sys().(*syscall.Stat_t)

+	if err := os.Lchown(name, int(st.Uid), int(st.Gid)); err != nil {

+		if os.IsPermission(err) {

+			// Normally if uid/gid are the same this would be a no-op, but some

+			// filesystems may still return EPERM... for instance NFS does this.

+			// In such a case, this is not an error.

+			if dstStat, err2 := os.Lstat(name); err2 == nil {

+				st2 := dstStat.Sys().(*syscall.Stat_t)

+				if st.Uid == st2.Uid && st.Gid == st2.Gid {

+					err = nil

+				}

+			}

+		}

+		if err != nil {

+			return errors.Wrapf(err, "failed to chown %s", name)

+		}

+	}

+

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

+		if err := os.Chmod(name, fi.Mode()); err != nil {

+			return errors.Wrapf(err, "failed to chmod %s", name)

+		}

+	}

+

+	timespec := []syscall.Timespec{StatAtime(st), StatMtime(st)}

+	if err := syscall.UtimesNano(name, timespec); err != nil {

+		return errors.Wrapf(err, "failed to utime %s", name)

+	}

+

+	return nil

+}

+

+func copyFileContent(dst, src *os.File) error {

+	buf := bufferPool.Get().(*[]byte)

+	_, err := io.CopyBuffer(dst, src, *buf)

+	bufferPool.Put(buf)

+

+	return err

+}

+

+func copyXAttrs(dst, src string) error {

+	xattrKeys, err := sysx.LListxattr(src)

+	if err != nil {

+		return errors.Wrapf(err, "failed to list xattrs on %s", src)

+	}

+	for _, xattr := range xattrKeys {

+		data, err := sysx.LGetxattr(src, xattr)

+		if err != nil {

+			return errors.Wrapf(err, "failed to get xattr %q on %s", xattr, src)

+		}

+		if err := sysx.LSetxattr(dst, xattr, data, 0); err != nil {

+			return errors.Wrapf(err, "failed to set xattr %q on %s", xattr, dst)

+		}

+	}

+

+	return nil

+}

+

+func copyDevice(dst string, fi os.FileInfo) error {

+	st, ok := fi.Sys().(*syscall.Stat_t)

+	if !ok {

+		return errors.New("unsupported stat type")

+	}

+	return unix.Mknod(dst, uint32(fi.Mode()), int(st.Rdev))

+}

new file mode 100644

@@ -0,0 +1,33 @@

+package fs

+

+import (

+	"io"

+	"os"

+

+	"github.com/pkg/errors"

+)

+

+func copyFileInfo(fi os.FileInfo, name string) error {

+	if err := os.Chmod(name, fi.Mode()); err != nil {

+		return errors.Wrapf(err, "failed to chmod %s", name)

+	}

+

+	// TODO: copy windows specific metadata

+

+	return nil

+}

+

+func copyFileContent(dst, src *os.File) error {

+	buf := bufferPool.Get().(*[]byte)

+	_, err := io.CopyBuffer(dst, src, *buf)

+	bufferPool.Put(buf)

+	return err

+}

+

+func copyXAttrs(dst, src string) error {

+	return nil

+}

+

+func copyDevice(dst string, fi os.FileInfo) error {

+	return errors.New("device copy not supported")

+}

new file mode 100644

@@ -0,0 +1,310 @@

+package fs

+

+import (

+	"context"

+	"os"

+	"path/filepath"

+	"strings"

+

+	"golang.org/x/sync/errgroup"

+

+	"github.com/sirupsen/logrus"

+)

+

+// ChangeKind is the type of modification that

+// a change is making.

+type ChangeKind int

+

+const (

+	// ChangeKindUnmodified represents an unmodified

+	// file

+	ChangeKindUnmodified = iota

+

+	// ChangeKindAdd represents an addition of

+	// a file

+	ChangeKindAdd

+

+	// ChangeKindModify represents a change to

+	// an existing file

+	ChangeKindModify

+

+	// ChangeKindDelete represents a delete of

+	// a file

+	ChangeKindDelete

+)

+

+func (k ChangeKind) String() string {

+	switch k {

+	case ChangeKindUnmodified:

+		return "unmodified"

+	case ChangeKindAdd:

+		return "add"

+	case ChangeKindModify:

+		return "modify"

+	case ChangeKindDelete:

+		return "delete"

+	default:

+		return ""

+	}

+}

+

+// Change represents single change between a diff and its parent.

+type Change struct {

+	Kind ChangeKind

+	Path string

+}

+

+// ChangeFunc is the type of function called for each change

+// computed during a directory changes calculation.

+type ChangeFunc func(ChangeKind, string, os.FileInfo, error) error

+

+// Changes computes changes between two directories calling the

+// given change function for each computed change. The first

+// directory is intended to the base directory and second

+// directory the changed directory.

+//

+// The change callback is called by the order of path names and

+// should be appliable in that order.

+//  Due to this apply ordering, the following is true

+//  - Removed directory trees only create a single change for the root

+//    directory removed. Remaining changes are implied.

+//  - A directory which is modified to become a file will not have

+//    delete entries for sub-path items, their removal is implied

+//    by the removal of the parent directory.

+//

+// Opaque directories will not be treated specially and each file

+// removed from the base directory will show up as a removal.

+//

+// File content comparisons will be done on files which have timestamps

+// which may have been truncated. If either of the files being compared

+// has a zero value nanosecond value, each byte will be compared for

+// differences. If 2 files have the same seconds value but different

+// nanosecond values where one of those values is zero, the files will

+// be considered unchanged if the content is the same. This behavior

+// is to account for timestamp truncation during archiving.

+func Changes(ctx context.Context, a, b string, changeFn ChangeFunc) error {

+	if a == "" {

+		logrus.Debugf("Using single walk diff for %s", b)

+		return addDirChanges(ctx, changeFn, b)

+	} else if diffOptions := detectDirDiff(b, a); diffOptions != nil {

+		logrus.Debugf("Using single walk diff for %s from %s", diffOptions.diffDir, a)

+		return diffDirChanges(ctx, changeFn, a, diffOptions)

+	}

+

+	logrus.Debugf("Using double walk diff for %s from %s", b, a)

+	return doubleWalkDiff(ctx, changeFn, a, b)

+}

+

+func addDirChanges(ctx context.Context, changeFn ChangeFunc, root string) error {

+	return filepath.Walk(root, func(path string, f os.FileInfo, err error) error {

+		if err != nil {

+			return err

+		}

+

+		// Rebase path

+		path, err = filepath.Rel(root, path)

+		if err != nil {

+			return err

+		}

+

+		path = filepath.Join(string(os.PathSeparator), path)

+

+		// Skip root

+		if path == string(os.PathSeparator) {

+			return nil

+		}

+

+		return changeFn(ChangeKindAdd, path, f, nil)

+	})

+}

+

+// diffDirOptions is used when the diff can be directly calculated from

+// a diff directory to its base, without walking both trees.

+type diffDirOptions struct {

+	diffDir      string

+	skipChange   func(string) (bool, error)

+	deleteChange func(string, string, os.FileInfo) (string, error)

+}

+

+// diffDirChanges walks the diff directory and compares changes against the base.

+func diffDirChanges(ctx context.Context, changeFn ChangeFunc, base string, o *diffDirOptions) error {

+	changedDirs := make(map[string]struct{})

+	return filepath.Walk(o.diffDir, func(path string, f os.FileInfo, err error) error {

+		if err != nil {

+			return err

+		}

+

+		// Rebase path

+		path, err = filepath.Rel(o.diffDir, path)

+		if err != nil {

+			return err

+		}

+

+		path = filepath.Join(string(os.PathSeparator), path)

+

+		// Skip root

+		if path == string(os.PathSeparator) {

+			return nil

+		}

+

+		// TODO: handle opaqueness, start new double walker at this

+		// location to get deletes, and skip tree in single walker

+

+		if o.skipChange != nil {

+			if skip, err := o.skipChange(path); skip {

+				return err

+			}

+		}

+

+		var kind ChangeKind

+

+		deletedFile, err := o.deleteChange(o.diffDir, path, f)

+		if err != nil {

+			return err

+		}

+

+		// Find out what kind of modification happened

+		if deletedFile != "" {

+			path = deletedFile

+			kind = ChangeKindDelete

+			f = nil

+		} else {

+			// Otherwise, the file was added

+			kind = ChangeKindAdd

+

+			// ...Unless it already existed in a base, in which case, it's a modification

+			stat, err := os.Stat(filepath.Join(base, path))

+			if err != nil && !os.IsNotExist(err) {

+				return err

+			}

+			if err == nil {

+				// The file existed in the base, so that's a modification

+

+				// However, if it's a directory, maybe it wasn't actually modified.

+				// If you modify /foo/bar/baz, then /foo will be part of the changed files only because it's the parent of bar

+				if stat.IsDir() && f.IsDir() {

+					if f.Size() == stat.Size() && f.Mode() == stat.Mode() && sameFsTime(f.ModTime(), stat.ModTime()) {

+						// Both directories are the same, don't record the change

+						return nil

+					}

+				}

+				kind = ChangeKindModify

+			}

+		}

+

+		// If /foo/bar/file.txt is modified, then /foo/bar must be part of the changed files.

+		// This block is here to ensure the change is recorded even if the

+		// modify time, mode and size of the parent directory in the rw and ro layers are all equal.

+		// Check https://github.com/docker/docker/pull/13590 for details.

+		if f.IsDir() {

+			changedDirs[path] = struct{}{}

+		}

+		if kind == ChangeKindAdd || kind == ChangeKindDelete {

+			parent := filepath.Dir(path)

+			if _, ok := changedDirs[parent]; !ok && parent != "/" {

+				pi, err := os.Stat(filepath.Join(o.diffDir, parent))

+				if err := changeFn(ChangeKindModify, parent, pi, err); err != nil {

+					return err

+				}

+				changedDirs[parent] = struct{}{}

+			}

+		}

+

+		return changeFn(kind, path, f, nil)

+	})

+}

+

+// doubleWalkDiff walks both directories to create a diff

+func doubleWalkDiff(ctx context.Context, changeFn ChangeFunc, a, b string) (err error) {

+	g, ctx := errgroup.WithContext(ctx)

+

+	var (

+		c1 = make(chan *currentPath)

+		c2 = make(chan *currentPath)

+

+		f1, f2 *currentPath

+		rmdir  string

+	)

+	g.Go(func() error {

+		defer close(c1)

+		return pathWalk(ctx, a, c1)

+	})

+	g.Go(func() error {

+		defer close(c2)

+		return pathWalk(ctx, b, c2)

+	})

+	g.Go(func() error {

+		for c1 != nil || c2 != nil {

+			if f1 == nil && c1 != nil {

+				f1, err = nextPath(ctx, c1)

+				if err != nil {

+					return err

+				}

+				if f1 == nil {

+					c1 = nil

+				}

+			}

+

+			if f2 == nil && c2 != nil {

+				f2, err = nextPath(ctx, c2)

+				if err != nil {

+					return err

+				}

+				if f2 == nil {

+					c2 = nil

+				}

+			}

+			if f1 == nil && f2 == nil {

+				continue

+			}

+

+			var f os.FileInfo

+			k, p := pathChange(f1, f2)

+			switch k {

+			case ChangeKindAdd:

+				if rmdir != "" {

+					rmdir = ""

+				}

+				f = f2.f

+				f2 = nil

+			case ChangeKindDelete:

+				// Check if this file is already removed by being

+				// under of a removed directory

+				if rmdir != "" && strings.HasPrefix(f1.path, rmdir) {

+					f1 = nil

+					continue