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

 # the following lines are in sorted order, FYI

 github.com/Azure/go-ansiterm d6e3b3328b783f23731bc4d058875b0371ff8109

-github.com/Microsoft/hcsshim v0.8.3

+github.com/Microsoft/hcsshim v0.8.6

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

 github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

 github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git

@@ -1,6 +1,8 @@

 package guestrequest

-import "github.com/Microsoft/hcsshim/internal/schema2"

+import (

+	"github.com/Microsoft/hcsshim/internal/schema2"

+)

 // Arguably, many of these (at least CombinedLayers) should have been generated

 // by swagger.

@@ -47,6 +49,19 @@ type LCOWMappedVPMemDevice struct {

 	MountPath    string `json:"MountPath,omitempty"` // /tmp/pN

 }

+type LCOWNetworkAdapter struct {

+	NamespaceID     string `json:",omitempty"`

+	ID              string `json:",omitempty"`

+	MacAddress      string `json:",omitempty"`

+	IPAddress       string `json:",omitempty"`

+	PrefixLength    uint8  `json:",omitempty"`

+	GatewayAddress  string `json:",omitempty"`

+	DNSSuffix       string `json:",omitempty"`

+	DNSServerList   string `json:",omitempty"`

+	EnableLowMetric bool   `json:",omitempty"`

+	EncapOverhead   uint16 `json:",omitempty"`

+}

+

 type ResourceType string

 const (

@@ -16,11 +16,20 @@ var (

 	notificationWatcherCallback = syscall.NewCallback(notificationWatcher)

 	// Notifications for HCS_SYSTEM handles

-	hcsNotificationSystemExited          hcsNotification = 0x00000001

-	hcsNotificationSystemCreateCompleted hcsNotification = 0x00000002

-	hcsNotificationSystemStartCompleted  hcsNotification = 0x00000003

-	hcsNotificationSystemPauseCompleted  hcsNotification = 0x00000004

-	hcsNotificationSystemResumeCompleted hcsNotification = 0x00000005

+	hcsNotificationSystemExited                      hcsNotification = 0x00000001

+	hcsNotificationSystemCreateCompleted             hcsNotification = 0x00000002

+	hcsNotificationSystemStartCompleted              hcsNotification = 0x00000003

+	hcsNotificationSystemPauseCompleted              hcsNotification = 0x00000004

+	hcsNotificationSystemResumeCompleted             hcsNotification = 0x00000005

+	hcsNotificationSystemCrashReport                 hcsNotification = 0x00000006

+	hcsNotificationSystemSiloJobCreated              hcsNotification = 0x00000007

+	hcsNotificationSystemSaveCompleted               hcsNotification = 0x00000008

+	hcsNotificationSystemRdpEnhancedModeStateChanged hcsNotification = 0x00000009

+	hcsNotificationSystemShutdownFailed              hcsNotification = 0x0000000A

+	hcsNotificationSystemGetPropertiesCompleted      hcsNotification = 0x0000000B

+	hcsNotificationSystemModifyCompleted             hcsNotification = 0x0000000C

+	hcsNotificationSystemCrashInitiated              hcsNotification = 0x0000000D

+	hcsNotificationSystemGuestConnectionClosed       hcsNotification = 0x0000000E

 	// Notifications for HCS_PROCESS handles

 	hcsNotificationProcessExited hcsNotification = 0x00010000

@@ -50,16 +59,23 @@ func newChannels() notificationChannels {

 	channels[hcsNotificationSystemResumeCompleted] = make(notificationChannel, 1)

 	channels[hcsNotificationProcessExited] = make(notificationChannel, 1)

 	channels[hcsNotificationServiceDisconnect] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemCrashReport] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemSiloJobCreated] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemSaveCompleted] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemRdpEnhancedModeStateChanged] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemShutdownFailed] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemGetPropertiesCompleted] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemModifyCompleted] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemCrashInitiated] = make(notificationChannel, 1)

+	channels[hcsNotificationSystemGuestConnectionClosed] = make(notificationChannel, 1)

+

 	return channels

 }

+

 func closeChannels(channels notificationChannels) {

-	close(channels[hcsNotificationSystemExited])

-	close(channels[hcsNotificationSystemCreateCompleted])

-	close(channels[hcsNotificationSystemStartCompleted])

-	close(channels[hcsNotificationSystemPauseCompleted])

-	close(channels[hcsNotificationSystemResumeCompleted])

-	close(channels[hcsNotificationProcessExited])

-	close(channels[hcsNotificationServiceDisconnect])

+	for _, c := range channels {

+		close(c)

+	}

 }

 func notificationWatcher(notificationType hcsNotification, callbackNumber uintptr, notificationStatus uintptr, notificationData *uint16) uintptr {

@@ -73,6 +73,9 @@ var (

 	// ErrVmcomputeUnknownMessage is an error encountered guest compute system doesn't support the message

 	ErrVmcomputeUnknownMessage = syscall.Errno(0xc037010b)

+	// ErrVmcomputeUnexpectedExit is an error encountered when the compute system terminates unexpectedly

+	ErrVmcomputeUnexpectedExit = syscall.Errno(0xC0370106)

+

 	// ErrNotSupported is an error encountered when hcs doesn't support the request

 	ErrPlatformNotSupported = errors.New("unsupported platform request")

 )

@@ -7,9 +7,14 @@ func logOperationBegin(ctx logrus.Fields, msg string) {

 }

 func logOperationEnd(ctx logrus.Fields, msg string, err error) {

+	// Copy the log and fields first.

+	log := logrus.WithFields(ctx)

 	if err == nil {

-		logrus.WithFields(ctx).Debug(msg)

+		log.Debug(msg)

 	} else {

-		logrus.WithFields(ctx).WithError(err).Error(msg)

+		// Edit only the copied field data to avoid race conditions on the

+		// write.

+		log.Data[logrus.ErrorKey] = err

+		log.Error(msg)

 	}

 }

@@ -31,9 +31,8 @@ func newProcess(process hcsProcess, processID int, computeSystem *System) *Proce

 		processID: processID,

 		system:    computeSystem,

 		logctx: logrus.Fields{

-			logfields.HCSOperation: "",

-			logfields.ContainerID:  computeSystem.ID(),

-			logfields.ProcessID:    processID,

+			logfields.ContainerID: computeSystem.ID(),

+			logfields.ProcessID:   processID,

 		},

 	}

 }

@@ -88,13 +87,12 @@ func (process *Process) SystemID() string {

 }

 func (process *Process) logOperationBegin(operation string) {

-	process.logctx[logfields.HCSOperation] = operation

 	logOperationBegin(

 		process.logctx,

-		"hcsshim::Process - Begin Operation")

+		operation+" - Begin Operation")

 }

-func (process *Process) logOperationEnd(err error) {

+func (process *Process) logOperationEnd(operation string, err error) {

 	var result string

 	if err == nil {

 		result = "Success"

@@ -104,9 +102,8 @@ func (process *Process) logOperationEnd(err error) {

 	logOperationEnd(

 		process.logctx,

-		"hcsshim::Process - End Operation - "+result,

+		operation+" - End Operation - "+result,

 		err)

-	process.logctx[logfields.HCSOperation] = ""

 }

 // Signal signals the process with `options`.

@@ -116,7 +113,7 @@ func (process *Process) Signal(options guestrequest.SignalProcessOptions) (err e

 	operation := "hcsshim::Process::Signal"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	if process.handle == 0 {

 		return makeProcessError(process, operation, ErrAlreadyClosed, nil)

@@ -130,10 +127,9 @@ func (process *Process) Signal(options guestrequest.SignalProcessOptions) (err e

 	optionsStr := string(optionsb)

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(process.logctx, &completed)

-	err = hcsSignalProcess(process.handle, optionsStr, &resultp)

-	completed = true

+	syscallWatcher(process.logctx, func() {

+		err = hcsSignalProcess(process.handle, optionsStr, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return makeProcessError(process, operation, err, events)

@@ -149,17 +145,16 @@ func (process *Process) Kill() (err error) {

 	operation := "hcsshim::Process::Kill"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	if process.handle == 0 {

 		return makeProcessError(process, operation, ErrAlreadyClosed, nil)

 	}

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(process.logctx, &completed)

-	err = hcsTerminateProcess(process.handle, &resultp)

-	completed = true

+	syscallWatcher(process.logctx, func() {

+		err = hcsTerminateProcess(process.handle, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return makeProcessError(process, operation, err, events)

@@ -172,7 +167,7 @@ func (process *Process) Kill() (err error) {

 func (process *Process) Wait() (err error) {

 	operation := "hcsshim::Process::Wait"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	err = waitForNotification(process.callbackNumber, hcsNotificationProcessExited, nil)

 	if err != nil {

@@ -187,7 +182,7 @@ func (process *Process) Wait() (err error) {

 func (process *Process) WaitTimeout(timeout time.Duration) (err error) {

 	operation := "hcssshim::Process::WaitTimeout"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	err = waitForNotification(process.callbackNumber, hcsNotificationProcessExited, &timeout)

 	if err != nil {

@@ -204,7 +199,7 @@ func (process *Process) ResizeConsole(width, height uint16) (err error) {

 	operation := "hcsshim::Process::ResizeConsole"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	if process.handle == 0 {

 		return makeProcessError(process, operation, ErrAlreadyClosed, nil)

@@ -241,7 +236,7 @@ func (process *Process) Properties() (_ *ProcessStatus, err error) {

 	operation := "hcsshim::Process::Properties"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	if process.handle == 0 {

 		return nil, makeProcessError(process, operation, ErrAlreadyClosed, nil)

@@ -251,10 +246,9 @@ func (process *Process) Properties() (_ *ProcessStatus, err error) {

 		resultp     *uint16

 		propertiesp *uint16

 	)

-	completed := false

-	go syscallWatcher(process.logctx, &completed)

-	err = hcsGetProcessProperties(process.handle, &propertiesp, &resultp)

-	completed = true

+	syscallWatcher(process.logctx, func() {

+		err = hcsGetProcessProperties(process.handle, &propertiesp, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return nil, makeProcessError(process, operation, err, events)

@@ -278,7 +272,7 @@ func (process *Process) Properties() (_ *ProcessStatus, err error) {

 func (process *Process) ExitCode() (_ int, err error) {

 	operation := "hcsshim::Process::ExitCode"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	properties, err := process.Properties()

 	if err != nil {

@@ -305,7 +299,7 @@ func (process *Process) Stdio() (_ io.WriteCloser, _ io.ReadCloser, _ io.ReadClo

 	operation := "hcsshim::Process::Stdio"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	if process.handle == 0 {

 		return nil, nil, nil, makeProcessError(process, operation, ErrAlreadyClosed, nil)

@@ -349,7 +343,7 @@ func (process *Process) CloseStdin() (err error) {

 	operation := "hcsshim::Process::CloseStdin"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	if process.handle == 0 {

 		return makeProcessError(process, operation, ErrAlreadyClosed, nil)

@@ -387,7 +381,7 @@ func (process *Process) Close() (err error) {

 	operation := "hcsshim::Process::Close"

 	process.logOperationBegin(operation)

-	defer process.logOperationEnd(err)

+	defer func() { process.logOperationEnd(operation, err) }()

 	// Don't double free this

 	if process.handle == 0 {

@@ -49,20 +49,18 @@ func newSystem(id string) *System {

 	return &System{

 		id: id,

 		logctx: logrus.Fields{

-			logfields.HCSOperation: "",

-			logfields.ContainerID:  id,

+			logfields.ContainerID: id,

 		},

 	}

 }

 func (computeSystem *System) logOperationBegin(operation string) {

-	computeSystem.logctx[logfields.HCSOperation] = operation

 	logOperationBegin(

 		computeSystem.logctx,

-		"hcsshim::ComputeSystem - Begin Operation")

+		operation+" - Begin Operation")

 }

-func (computeSystem *System) logOperationEnd(err error) {

+func (computeSystem *System) logOperationEnd(operation string, err error) {

 	var result string

 	if err == nil {

 		result = "Success"

@@ -72,9 +70,8 @@ func (computeSystem *System) logOperationEnd(err error) {

 	logOperationEnd(

 		computeSystem.logctx,

-		"hcsshim::ComputeSystem - End Operation - "+result,

+		operation+" - End Operation - "+result,

 		err)

-	computeSystem.logctx[logfields.HCSOperation] = ""

 }

 // CreateComputeSystem creates a new compute system with the given configuration but does not start it.

@@ -83,7 +80,7 @@ func CreateComputeSystem(id string, hcsDocumentInterface interface{}) (_ *System

 	computeSystem := newSystem(id)

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	hcsDocumentB, err := json.Marshal(hcsDocumentInterface)

 	if err != nil {

@@ -97,13 +94,13 @@ func CreateComputeSystem(id string, hcsDocumentInterface interface{}) (_ *System

 		Debug("HCS ComputeSystem Document")

 	var (

-		resultp  *uint16

-		identity syscall.Handle

+		resultp     *uint16

+		identity    syscall.Handle

+		createError error

 	)

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	createError := hcsCreateComputeSystem(id, hcsDocument, identity, &computeSystem.handle, &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		createError = hcsCreateComputeSystem(id, hcsDocument, identity, &computeSystem.handle, &resultp)

+	})

 	if createError == nil || IsPending(createError) {

 		if err = computeSystem.registerCallback(); err != nil {

@@ -133,7 +130,13 @@ func OpenComputeSystem(id string) (_ *System, err error) {

 	computeSystem := newSystem(id)

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() {

+		if IsNotExist(err) {

+			computeSystem.logOperationEnd(operation, nil)

+		} else {

+			computeSystem.logOperationEnd(operation, err)

+		}

+	}()

 	var (

 		handle  hcsSystem

@@ -157,12 +160,10 @@ func OpenComputeSystem(id string) (_ *System, err error) {

 // GetComputeSystems gets a list of the compute systems on the system that match the query

 func GetComputeSystems(q schema1.ComputeSystemQuery) (_ []schema1.ContainerProperties, err error) {

 	operation := "hcsshim::GetComputeSystems"

-	fields := logrus.Fields{

-		logfields.HCSOperation: operation,

-	}

+	fields := logrus.Fields{}

 	logOperationBegin(

 		fields,

-		"hcsshim::ComputeSystem - Begin Operation")

+		operation+" - Begin Operation")

 	defer func() {

 		var result string

@@ -174,7 +175,7 @@ func GetComputeSystems(q schema1.ComputeSystemQuery) (_ []schema1.ContainerPrope

 		logOperationEnd(

 			fields,

-			"hcsshim::ComputeSystem - End Operation - "+result,

+			operation+" - End Operation - "+result,

 			err)

 	}()

@@ -193,10 +194,10 @@ func GetComputeSystems(q schema1.ComputeSystemQuery) (_ []schema1.ContainerPrope

 		resultp         *uint16

 		computeSystemsp *uint16

 	)

-	completed := false

-	go syscallWatcher(fields, &completed)

-	err = hcsEnumerateComputeSystems(query, &computeSystemsp, &resultp)

-	completed = true

+

+	syscallWatcher(fields, func() {

+		err = hcsEnumerateComputeSystems(query, &computeSystemsp, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return nil, &HcsError{Op: operation, Err: err, Events: events}

@@ -221,7 +222,7 @@ func (computeSystem *System) Start() (err error) {

 	operation := "hcsshim::ComputeSystem::Start"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	if computeSystem.handle == 0 {

 		return makeSystemError(computeSystem, "Start", "", ErrAlreadyClosed, nil)

@@ -254,10 +255,9 @@ func (computeSystem *System) Start() (err error) {

 	}

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsStartComputeSystem(computeSystem.handle, "", &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsStartComputeSystem(computeSystem.handle, "", &resultp)

+	})

 	events, err := processAsyncHcsResult(err, resultp, computeSystem.callbackNumber, hcsNotificationSystemStartCompleted, &timeout.SystemStart)

 	if err != nil {

 		return makeSystemError(computeSystem, "Start", "", err, events)

@@ -279,17 +279,22 @@ func (computeSystem *System) Shutdown() (err error) {

 	operation := "hcsshim::ComputeSystem::Shutdown"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() {

+		if IsAlreadyStopped(err) {

+			computeSystem.logOperationEnd(operation, nil)

+		} else {

+			computeSystem.logOperationEnd(operation, err)

+		}

+	}()

 	if computeSystem.handle == 0 {

 		return makeSystemError(computeSystem, "Shutdown", "", ErrAlreadyClosed, nil)

 	}

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsShutdownComputeSystem(computeSystem.handle, "", &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsShutdownComputeSystem(computeSystem.handle, "", &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return makeSystemError(computeSystem, "Shutdown", "", err, events)

@@ -306,19 +311,24 @@ func (computeSystem *System) Terminate() (err error) {

 	operation := "hcsshim::ComputeSystem::Terminate"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() {

+		if IsPending(err) {

+			computeSystem.logOperationEnd(operation, nil)

+		} else {

+			computeSystem.logOperationEnd(operation, err)

+		}

+	}()

 	if computeSystem.handle == 0 {

 		return makeSystemError(computeSystem, "Terminate", "", ErrAlreadyClosed, nil)

 	}

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsTerminateComputeSystem(computeSystem.handle, "", &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsTerminateComputeSystem(computeSystem.handle, "", &resultp)

+	})

 	events := processHcsResult(resultp)

-	if err != nil {

+	if err != nil && err != ErrVmcomputeAlreadyStopped {

 		return makeSystemError(computeSystem, "Terminate", "", err, events)

 	}

@@ -329,7 +339,7 @@ func (computeSystem *System) Terminate() (err error) {

 func (computeSystem *System) Wait() (err error) {

 	operation := "hcsshim::ComputeSystem::Wait"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	err = waitForNotification(computeSystem.callbackNumber, hcsNotificationSystemExited, nil)

 	if err != nil {

@@ -339,12 +349,27 @@ func (computeSystem *System) Wait() (err error) {

 	return nil

 }

+// WaitExpectedError synchronously waits for the compute system to shutdown or

+// terminate, and ignores the passed error if it occurs.

+func (computeSystem *System) WaitExpectedError(expected error) (err error) {

+	operation := "hcsshim::ComputeSystem::WaitExpectedError"

+	computeSystem.logOperationBegin(operation)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

+

+	err = waitForNotification(computeSystem.callbackNumber, hcsNotificationSystemExited, nil)

+	if err != nil && getInnerError(err) != expected {

+		return makeSystemError(computeSystem, "WaitExpectedError", "", err, nil)

+	}

+

+	return nil

+}

+

 // WaitTimeout synchronously waits for the compute system to terminate or the duration to elapse.

 // If the timeout expires, IsTimeout(err) == true

 func (computeSystem *System) WaitTimeout(timeout time.Duration) (err error) {

 	operation := "hcsshim::ComputeSystem::WaitTimeout"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	err = waitForNotification(computeSystem.callbackNumber, hcsNotificationSystemExited, &timeout)

 	if err != nil {

@@ -360,7 +385,7 @@ func (computeSystem *System) Properties(types ...schema1.PropertyType) (_ *schem

 	operation := "hcsshim::ComputeSystem::Properties"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	queryj, err := json.Marshal(schema1.PropertyQuery{types})

 	if err != nil {

@@ -372,10 +397,9 @@ func (computeSystem *System) Properties(types ...schema1.PropertyType) (_ *schem

 		Debug("HCS ComputeSystem Properties Query")

 	var resultp, propertiesp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsGetComputeSystemProperties(computeSystem.handle, string(queryj), &propertiesp, &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsGetComputeSystemProperties(computeSystem.handle, string(queryj), &propertiesp, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return nil, makeSystemError(computeSystem, "Properties", "", err, events)

@@ -400,17 +424,16 @@ func (computeSystem *System) Pause() (err error) {

 	operation := "hcsshim::ComputeSystem::Pause"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	if computeSystem.handle == 0 {

 		return makeSystemError(computeSystem, "Pause", "", ErrAlreadyClosed, nil)

 	}

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsPauseComputeSystem(computeSystem.handle, "", &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsPauseComputeSystem(computeSystem.handle, "", &resultp)

+	})

 	events, err := processAsyncHcsResult(err, resultp, computeSystem.callbackNumber, hcsNotificationSystemPauseCompleted, &timeout.SystemPause)

 	if err != nil {

 		return makeSystemError(computeSystem, "Pause", "", err, events)

@@ -426,17 +449,16 @@ func (computeSystem *System) Resume() (err error) {

 	operation := "hcsshim::ComputeSystem::Resume"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	if computeSystem.handle == 0 {

 		return makeSystemError(computeSystem, "Resume", "", ErrAlreadyClosed, nil)

 	}

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsResumeComputeSystem(computeSystem.handle, "", &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsResumeComputeSystem(computeSystem.handle, "", &resultp)

+	})

 	events, err := processAsyncHcsResult(err, resultp, computeSystem.callbackNumber, hcsNotificationSystemResumeCompleted, &timeout.SystemResume)

 	if err != nil {

 		return makeSystemError(computeSystem, "Resume", "", err, events)

@@ -452,7 +474,7 @@ func (computeSystem *System) CreateProcess(c interface{}) (_ *Process, err error

 	operation := "hcsshim::ComputeSystem::CreateProcess"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	var (

 		processInfo   hcsProcessInformation

@@ -475,10 +497,9 @@ func (computeSystem *System) CreateProcess(c interface{}) (_ *Process, err error

 		WithField(logfields.JSON, configuration).

 		Debug("HCS ComputeSystem Process Document")

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsCreateProcess(computeSystem.handle, configuration, &processInfo, &processHandle, &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsCreateProcess(computeSystem.handle, configuration, &processInfo, &processHandle, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return nil, makeSystemError(computeSystem, "CreateProcess", configuration, err, events)

@@ -513,7 +534,7 @@ func (computeSystem *System) OpenProcess(pid int) (_ *Process, err error) {

 	operation := "hcsshim::ComputeSystem::OpenProcess"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	var (

 		processHandle hcsProcess

@@ -524,10 +545,9 @@ func (computeSystem *System) OpenProcess(pid int) (_ *Process, err error) {

 		return nil, makeSystemError(computeSystem, "OpenProcess", "", ErrAlreadyClosed, nil)

 	}

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsOpenProcess(computeSystem.handle, uint32(pid), &processHandle, &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsOpenProcess(computeSystem.handle, uint32(pid), &processHandle, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return nil, makeSystemError(computeSystem, "OpenProcess", "", err, events)

@@ -548,7 +568,7 @@ func (computeSystem *System) Close() (err error) {

 	operation := "hcsshim::ComputeSystem::Close"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	// Don't double free this

 	if computeSystem.handle == 0 {

@@ -559,10 +579,9 @@ func (computeSystem *System) Close() (err error) {

 		return makeSystemError(computeSystem, "Close", "", err, nil)

 	}

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsCloseComputeSystem(computeSystem.handle)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsCloseComputeSystem(computeSystem.handle)

+	})

 	if err != nil {

 		return makeSystemError(computeSystem, "Close", "", err, nil)

 	}

@@ -636,7 +655,7 @@ func (computeSystem *System) Modify(config interface{}) (err error) {

 	operation := "hcsshim::ComputeSystem::Modify"

 	computeSystem.logOperationBegin(operation)

-	defer computeSystem.logOperationEnd(err)

+	defer func() { computeSystem.logOperationEnd(operation, err) }()

 	if computeSystem.handle == 0 {

 		return makeSystemError(computeSystem, "Modify", "", ErrAlreadyClosed, nil)

@@ -654,10 +673,9 @@ func (computeSystem *System) Modify(config interface{}) (err error) {

 		Debug("HCS ComputeSystem Modify Document")

 	var resultp *uint16

-	completed := false

-	go syscallWatcher(computeSystem.logctx, &completed)

-	err = hcsModifyComputeSystem(computeSystem.handle, requestString, &resultp)

-	completed = true

+	syscallWatcher(computeSystem.logctx, func() {

+		err = hcsModifyComputeSystem(computeSystem.handle, requestString, &resultp)

+	})

 	events := processHcsResult(resultp)

 	if err != nil {

 		return makeSystemError(computeSystem, "Modify", requestString, err, events)

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

 package hcs

 import (

-	"time"

+	"context"

 	"github.com/Microsoft/hcsshim/internal/logfields"

 	"github.com/Microsoft/hcsshim/internal/timeout"

@@ -17,17 +17,25 @@ import (

 //

 // Usage is:

 //

-// completed := false

-// go syscallWatcher(context, &completed)

-// <syscall>

-// completed = true

+// syscallWatcher(logContext, func() {

+//    err = <syscall>(args...)

+// })

 //

-func syscallWatcher(context logrus.Fields, syscallCompleted *bool) {

-	time.Sleep(timeout.SyscallWatcher)

-	if *syscallCompleted {

-		return

+

+func syscallWatcher(logContext logrus.Fields, syscallLambda func()) {

+	ctx, cancel := context.WithTimeout(context.Background(), timeout.SyscallWatcher)

+	defer cancel()

+	go watchFunc(ctx, logContext)

+	syscallLambda()

+}

+

+func watchFunc(ctx context.Context, logContext logrus.Fields) {

+	select {

+	case <-ctx.Done():

+		if ctx.Err() != context.Canceled {

+			logrus.WithFields(logContext).

+				WithField(logfields.Timeout, timeout.SyscallWatcher).

+				Warning("Syscall did not complete within operation timeout. This may indicate a platform issue. If it appears to be making no forward progress, obtain the stacks and see if there is a syscall stuck in the platform API for a significant length of time.")

+		}

 	}

-	logrus.WithFields(context).

-		WithField(logfields.Timeout, timeout.SyscallWatcher).

-		Warning("Syscall did not complete within operation timeout. This may indicate a platform issue. If it appears to be making no forward progress, obtain the stacks and see if there is a syscall stuck in the platform API for a significant length of time.")

 }

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

 	"syscall"

 	"unsafe"

-	"github.com/Microsoft/hcsshim/internal/interop"

 	"golang.org/x/sys/windows"

 )

@@ -81,7 +80,10 @@ func _hcsEnumerateComputeSystems(query *uint16, computeSystems **uint16, result

 	}

 	r0, _, _ := syscall.Syscall(procHcsEnumerateComputeSystems.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(computeSystems)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -106,7 +108,10 @@ func _hcsCreateComputeSystem(id *uint16, configuration *uint16, identity syscall

 	}

 	r0, _, _ := syscall.Syscall6(procHcsCreateComputeSystem.Addr(), 5, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(configuration)), uintptr(identity), uintptr(unsafe.Pointer(computeSystem)), uintptr(unsafe.Pointer(result)), 0)

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -126,7 +131,10 @@ func _hcsOpenComputeSystem(id *uint16, computeSystem *hcsSystem, result **uint16

 	}

 	r0, _, _ := syscall.Syscall(procHcsOpenComputeSystem.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(computeSystem)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -137,7 +145,10 @@ func hcsCloseComputeSystem(computeSystem hcsSystem) (hr error) {

 	}

 	r0, _, _ := syscall.Syscall(procHcsCloseComputeSystem.Addr(), 1, uintptr(computeSystem), 0, 0)

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -157,7 +168,10 @@ func _hcsStartComputeSystem(computeSystem hcsSystem, options *uint16, result **u

 	}

 	r0, _, _ := syscall.Syscall(procHcsStartComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -177,7 +191,10 @@ func _hcsShutdownComputeSystem(computeSystem hcsSystem, options *uint16, result

 	}

 	r0, _, _ := syscall.Syscall(procHcsShutdownComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -197,7 +214,10 @@ func _hcsTerminateComputeSystem(computeSystem hcsSystem, options *uint16, result

 	}

 	r0, _, _ := syscall.Syscall(procHcsTerminateComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -217,7 +237,10 @@ func _hcsPauseComputeSystem(computeSystem hcsSystem, options *uint16, result **u

 	}

 	r0, _, _ := syscall.Syscall(procHcsPauseComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -237,7 +260,10 @@ func _hcsResumeComputeSystem(computeSystem hcsSystem, options *uint16, result **

 	}

 	r0, _, _ := syscall.Syscall(procHcsResumeComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -257,7 +283,10 @@ func _hcsGetComputeSystemProperties(computeSystem hcsSystem, propertyQuery *uint

 	}

 	r0, _, _ := syscall.Syscall6(procHcsGetComputeSystemProperties.Addr(), 4, uintptr(computeSystem), uintptr(unsafe.Pointer(propertyQuery)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result)), 0, 0)

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -277,7 +306,10 @@ func _hcsModifyComputeSystem(computeSystem hcsSystem, configuration *uint16, res

 	}

 	r0, _, _ := syscall.Syscall(procHcsModifyComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(configuration)), uintptr(unsafe.Pointer(result)))

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff

+		}

+		hr = syscall.Errno(r0)

 	}

 	return

 }

@@ -288,7 +320,10 @@ func hcsRegisterComputeSystemCallback(computeSystem hcsSystem, callback uintptr,

 	}

 	r0, _, _ := syscall.Syscall6(procHcsRegisterComputeSystemCallback.Addr(), 4, uintptr(computeSystem), uintptr(callback), uintptr(context), uintptr(unsafe.Pointer(callbackHandle)), 0, 0)

 	if int32(r0) < 0 {

-		hr = interop.Win32FromHresult(r0)

+		if r0&0x1fff0000 == 0x00070000 {

+			r0 &= 0xffff