@@ -13,7 +13,43 @@

 // operations. The downside of safe-mode is that operations are slower as

 // a new service utility VM has to be started and torn-down when needed.

 //

-// To enable global mode, run with --storage-opt lcow.globalmode=true

+// Options (needs official documentation, but lets get full functionality first...) @jhowardmsft

+//

+// The following options are read by the graphdriver itself:

+//

+//   * lcow.globalmode - Enables global service VM Mode

+//        -- Possible values:     true/false

+//        -- Default if omitted:  false

+//

+//   * lcow.sandboxsize - Specifies a custom sandbox size in GB for starting a container

+//        -- Possible values:      >= default sandbox size (opengcs defined, currently 20)

+//        -- Default if ommitted:  20

+//

+// The following options are read by opengcs:

+//

+//   * lcow.kirdpath - Specifies a custom path to a kernel/initrd pair

+//        -- Possible values:      Any local path that is not a mapped drive

+//        -- Default if ommitted:  %ProgramFiles%\Linux Containers

+//

+//   * lcow.kernel - Specifies a custom kernel file located in the `lcow.kirdpath` path

+//        -- Possible values:      Any valid filename

+//        -- Default if ommitted:  bootx64.efi

+//

+//   * lcow.initrd - Specifies a custom initrd file located in the `lcow.kirdpath` path

+//        -- Possible values:      Any valid filename

+//        -- Default if ommitted:  initrd.img

+//

+//   * lcow.bootparameters - Specifies additional boot parameters for booting in kernel+initrd mode

+//        -- Possible values:      Any valid linux kernel boot options

+//        -- Default if ommitted:  <nil>

+//

+//   * lcow.vhdx - Specifies a custom vhdx file to boot (instead of a kernel+initrd)

+//        -- Possible values:      Any valid filename

+//        -- Default if ommitted:  C:\Program Files\Linux Containers\uvm.vhdx

+//

+//   * lcow.timeout - Specifies a timeout for utility VM operations in seconds

+//        -- Possible values:      >=0

+//        -- Default if ommitted:  300

 // TODO: Grab logs from SVM at terminate or errors

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

 # the following lines are in sorted order, FYI

 github.com/Azure/go-ansiterm 19f72df4d05d31cbe1c56bfc8045c96babff6c7e

 github.com/Microsoft/hcsshim v0.6.1

-github.com/Microsoft/go-winio v0.4.2

+github.com/Microsoft/go-winio v0.4.4

 github.com/moby/buildkit da2b9dc7dab99e824b2b1067ad7d0523e32dd2d9 https://github.com/dmcgowan/buildkit.git

 github.com/davecgh/go-spew 346938d642f2ec3594ed81d874461961cd0faa76

 github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

@@ -23,6 +23,13 @@ type atomicBool int32

 func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }

 func (b *atomicBool) setFalse()   { atomic.StoreInt32((*int32)(b), 0) }

 func (b *atomicBool) setTrue()    { atomic.StoreInt32((*int32)(b), 1) }

+func (b *atomicBool) swap(new bool) bool {

+	var newInt int32

+	if new {

+		newInt = 1

+	}

+	return atomic.SwapInt32((*int32)(b), newInt) == 1

+}

 const (

 	cFILE_SKIP_COMPLETION_PORT_ON_SUCCESS = 1

@@ -71,7 +78,7 @@ func initIo() {

 type win32File struct {

 	handle        syscall.Handle

 	wg            sync.WaitGroup

-	closing       bool

+	closing       atomicBool

 	readDeadline  deadlineHandler

 	writeDeadline deadlineHandler

 }

@@ -107,9 +114,9 @@ func MakeOpenFile(h syscall.Handle) (io.ReadWriteCloser, error) {

 // closeHandle closes the resources associated with a Win32 handle

 func (f *win32File) closeHandle() {

-	if !f.closing {

+	// Atomically set that we are closing, releasing the resources only once.

+	if !f.closing.swap(true) {

 		// cancel all IO and wait for it to complete

-		f.closing = true

 		cancelIoEx(f.handle, nil)

 		f.wg.Wait()

 		// at this point, no new IO can start

@@ -127,10 +134,10 @@ func (f *win32File) Close() error {

 // prepareIo prepares for a new IO operation.

 // The caller must call f.wg.Done() when the IO is finished, prior to Close() returning.

 func (f *win32File) prepareIo() (*ioOperation, error) {

-	f.wg.Add(1)

-	if f.closing {

+	if f.closing.isSet() {

 		return nil, ErrFileClosed

 	}

+	f.wg.Add(1)

 	c := &ioOperation{}

 	c.ch = make(chan ioResult)

 	return c, nil

@@ -159,7 +166,7 @@ func (f *win32File) asyncIo(c *ioOperation, d *deadlineHandler, bytes uint32, er

 		return int(bytes), err

 	}

-	if f.closing {

+	if f.closing.isSet() {

 		cancelIoEx(f.handle, &c.o)

 	}

@@ -175,7 +182,7 @@ func (f *win32File) asyncIo(c *ioOperation, d *deadlineHandler, bytes uint32, er

 	case r = <-c.ch:

 		err = r.err

 		if err == syscall.ERROR_OPERATION_ABORTED {

-			if f.closing {

+			if f.closing.isSet() {

 				err = ErrFileClosed

 			}

 		}

new file mode 100644

@@ -0,0 +1,82 @@

+// +build windows

+

+package vhd

+

+import "syscall"

+

+//go:generate go run mksyscall_windows.go -output zvhd.go vhd.go

+

+//sys createVirtualDisk(virtualStorageType *virtualStorageType, path string, virtualDiskAccessMask uint32, securityDescriptor *uintptr, flags uint32, providerSpecificFlags uint32, parameters *createVirtualDiskParameters, o *syscall.Overlapped, handle *syscall.Handle) (err error) [failretval != 0] = VirtDisk.CreateVirtualDisk

+

+type virtualStorageType struct {

+	DeviceID uint32

+	VendorID [16]byte

+}

+

+const virtualDiskAccessNONE uint32 = 0

+const virtualDiskAccessATTACHRO uint32 = 65536

+const virtualDiskAccessATTACHRW uint32 = 131072

+const virtualDiskAccessDETACH uint32 = 262144

+const virtualDiskAccessGETINFO uint32 = 524288

+const virtualDiskAccessCREATE uint32 = 1048576

+const virtualDiskAccessMETAOPS uint32 = 2097152

+const virtualDiskAccessREAD uint32 = 851968

+const virtualDiskAccessALL uint32 = 4128768

+const virtualDiskAccessWRITABLE uint32 = 3276800

+

+const createVirtualDiskFlagNone uint32 = 0

+const createVirtualDiskFlagFullPhysicalAllocation uint32 = 1

+const createVirtualDiskFlagPreventWritesToSourceDisk uint32 = 2

+const createVirtualDiskFlagDoNotCopyMetadataFromParent uint32 = 4

+

+type version2 struct {

+	UniqueID                 [16]byte // GUID

+	MaximumSize              uint64

+	BlockSizeInBytes         uint32

+	SectorSizeInBytes        uint32

+	ParentPath               *uint16 // string

+	SourcePath               *uint16 // string

+	OpenFlags                uint32

+	ParentVirtualStorageType virtualStorageType

+	SourceVirtualStorageType virtualStorageType

+	ResiliencyGUID           [16]byte // GUID

+}

+

+type createVirtualDiskParameters struct {

+	Version  uint32 // Must always be set to 2

+	Version2 version2

+}

+

+// CreateVhdx will create a simple vhdx file at the given path using default values.

+func CreateVhdx(path string, maxSizeInGb, blockSizeInMb uint32) error {

+	var defaultType virtualStorageType

+

+	parameters := createVirtualDiskParameters{

+		Version: 2,

+		Version2: version2{

+			MaximumSize:      uint64(maxSizeInGb) * 1024 * 1024 * 1024,

+			BlockSizeInBytes: blockSizeInMb * 1024 * 1024,

+		},

+	}

+

+	var handle syscall.Handle

+

+	if err := createVirtualDisk(

+		&defaultType,

+		path,

+		virtualDiskAccessNONE,

+		nil,

+		createVirtualDiskFlagNone,

+		0,

+		&parameters,

+		nil,

+		&handle); err != nil {

+		return err

+	}

+

+	if err := syscall.CloseHandle(handle); err != nil {

+		return err

+	}

+

+	return nil

+}

new file mode 100644

@@ -0,0 +1,64 @@

+// MACHINE GENERATED BY 'go generate' COMMAND; DO NOT EDIT

+

+package vhd

+

+import (

+	"syscall"

+	"unsafe"

+

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

+)

+

+var _ unsafe.Pointer

+

+// Do the interface allocations only once for common

+// Errno values.

+const (

+	errnoERROR_IO_PENDING = 997

+)

+

+var (

+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)

+)

+

+// errnoErr returns common boxed Errno values, to prevent

+// allocations at runtime.

+func errnoErr(e syscall.Errno) error {

+	switch e {

+	case 0:

+		return nil

+	case errnoERROR_IO_PENDING:

+		return errERROR_IO_PENDING

+	}

+	// TODO: add more here, after collecting data on the common

+	// error values see on Windows. (perhaps when running

+	// all.bat?)

+	return e

+}

+

+var (

+	modVirtDisk = windows.NewLazySystemDLL("VirtDisk.dll")

+

+	procCreateVirtualDisk = modVirtDisk.NewProc("CreateVirtualDisk")

+)

+

+func createVirtualDisk(virtualStorageType *virtualStorageType, path string, virtualDiskAccessMask uint32, securityDescriptor *uintptr, flags uint32, providerSpecificFlags uint32, parameters *createVirtualDiskParameters, o *syscall.Overlapped, handle *syscall.Handle) (err error) {

+	var _p0 *uint16

+	_p0, err = syscall.UTF16PtrFromString(path)

+	if err != nil {

+		return

+	}

+	return _createVirtualDisk(virtualStorageType, _p0, virtualDiskAccessMask, securityDescriptor, flags, providerSpecificFlags, parameters, o, handle)

+}

+

+func _createVirtualDisk(virtualStorageType *virtualStorageType, path *uint16, virtualDiskAccessMask uint32, securityDescriptor *uintptr, flags uint32, providerSpecificFlags uint32, parameters *createVirtualDiskParameters, o *syscall.Overlapped, handle *syscall.Handle) (err error) {

+	r1, _, e1 := syscall.Syscall9(procCreateVirtualDisk.Addr(), 9, uintptr(unsafe.Pointer(virtualStorageType)), uintptr(unsafe.Pointer(path)), uintptr(virtualDiskAccessMask), uintptr(unsafe.Pointer(securityDescriptor)), uintptr(flags), uintptr(providerSpecificFlags), uintptr(unsafe.Pointer(parameters)), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(handle)))

+	if r1 != 0 {

+		if e1 != 0 {

+			err = errnoErr(e1)

+		} else {

+			err = syscall.EINVAL

+		}

+	}

+	return

+}