add functions for getting vm state

cmd/containerd-shim-runhcs-v1/task_hcs.go

@@ -520,7 +520,7 @@ func (ht *hcsTask) close(ctx context.Context) {
 				werr = ht.c.Wait()
 				close(ch)
 			}()
-			err := ht.c.Shutdown(ctx)
+			err := ht.c.Shutdown(ctx, "")
 			if err != nil {
 				log.G(ctx).WithError(err).Error("failed to shutdown container")
 			} else {

cmd/runhcs/shim.go

@@ -214,7 +214,7 @@ var shimCommand = cli.Command{
 			// Shutdown the container, waiting 5 minutes before terminating is
 			// forcefully.
 			const shutdownTimeout = time.Minute * 5
-			err := c.hc.Shutdown(gcontext.Background())
+			err := c.hc.Shutdown(gcontext.Background(), "")
 			if err != nil {
 				select {
 				case <-containerExitCh:

container.go

@@ -104,7 +104,7 @@ func (container *container) Start() error {
 
 // Shutdown requests a container shutdown, but it may not actually be shutdown until Wait() succeeds.
 func (container *container) Shutdown() error {
-	err := container.system.Shutdown(context.Background())
+	err := container.system.Shutdown(context.Background(), "")
 	if err != nil {
 		return convertSystemError(err, container)
 	}

hcn/hcn.go

@@ -27,6 +27,8 @@ import (
 //sys hcnQueryNetworkProperties(network hcnNetwork, query string, properties **uint16, result **uint16) (hr error) = computenetwork.HcnQueryNetworkProperties?
 //sys hcnDeleteNetwork(id *_guid, result **uint16) (hr error) = computenetwork.HcnDeleteNetwork?
 //sys hcnCloseNetwork(network hcnNetwork) (hr error) = computenetwork.HcnCloseNetwork?
+//sys hcsRegisterNetworkCallback(network hcnNetwork, callback uintptr, context uintptr, callbackHandle *hcnCallbackHandle) (hr error) = computenetwork.HcnRegisterNetworkCallback?
+//sys hcsUnregisterNetworkCallback(callbackHandle hcnCallbackHandle) (hr error) = computenetwork.HcnUnregisterNetworkCallback?
 
 // Endpoint
 //sys hcnEnumerateEndpoints(query string, endpoints **uint16, result **uint16) (hr error) = computenetwork.HcnEnumerateEndpoints?
@@ -57,7 +59,7 @@ import (
 
 // Service
 //sys hcnOpenService(service *hcnService, result **uint16) (hr error) = computenetwork.HcnOpenService?
-//sys hcnRegisterServiceCallback(service hcnService, callback int32, context int32, callbackHandle *hcnCallbackHandle) (hr error) = computenetwork.HcnRegisterServiceCallback?
+//sys hcnRegisterServiceCallback(callback uintptr, context uintptr, callbackHandle *hcnCallbackHandle) (hr error) = computenetwork.HcnRegisterServiceCallback?
 //sys hcnUnregisterServiceCallback(callbackHandle hcnCallbackHandle) (hr error) = computenetwork.HcnUnregisterServiceCallback?
 //sys hcnCloseService(service hcnService) (hr error) = computenetwork.HcnCloseService?
 

hcn/hcncallback.go

@@ -0,0 +1,125 @@
+package hcn
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+	"syscall"
+	"unsafe"
+
+	"github.com/Microsoft/hcsshim/internal/interop"
+)
+
+var (
+	nextCallback    uintptr
+	callbackMap     = map[uintptr]*notifcationWatcherContext{}
+	callbackMapLock = sync.RWMutex{}
+
+	notificationWatcherCallback = syscall.NewCallback(notificationWatcher)
+
+	// Notifications for HCN_SERVICE handles
+	HcnNotificationNetworkPreCreate HcnNotification = 0x00000001
+	HcnNotificationNetworkCreate    HcnNotification = 0x00000002
+	HcnNotificationNetworkPreDelete HcnNotification = 0x00000003
+	HcnNotificationNetworkDelete    HcnNotification = 0x00000004
+
+	// Namespace Notifications
+	HcnNotificationNamespaceCreate HcnNotification = 0x00000005
+	HcnNotificationNamespaceDelete HcnNotification = 0x00000006
+
+	// Notifications for HCN_SERVICE handles
+	HcnNotificationGuestNetworkServiceCreate HcnNotification = 0x00000007
+	HcnNotificationGuestNetworkServiceDelete HcnNotification = 0x00000008
+
+	// Notifications for HCN_NETWORK handles
+	HcnNotificationNetworkEndpointAttached HcnNotification = 0x00000009
+	HcnNotificationNetworkEndpointDetached HcnNotification = 0x00000010
+
+	// Notifications for HCN_GUESTNETWORKSERVICE handles
+	HcnNotificationGuestNetworkServiceStateChanged          HcnNotification = 0x00000011
+	HcnNotificationGuestNetworkServiceInterfaceStateChanged HcnNotification = 0x00000012
+
+	// Common notifications
+	HcnNotificationServiceDisconnect HcnNotification = 0x01000000
+)
+
+type HcnNotification uint32
+
+func (hn HcnNotification) String() string {
+	switch hn {
+	case HcnNotificationNetworkPreCreate:
+		return "NetworkPreCreate"
+	case HcnNotificationNetworkCreate:
+		return "NetworkCreate"
+	case HcnNotificationNetworkPreDelete:
+		return "NetworkPreDelete"
+	case HcnNotificationNetworkDelete:
+		return "NetworkDelete"
+	case HcnNotificationNamespaceCreate:
+		return "NamespaceCreate"
+	case HcnNotificationNamespaceDelete:
+		return "NamespaceDelete"
+	case HcnNotificationGuestNetworkServiceCreate:
+		return "GuestNetworkServiceCreate"
+	case HcnNotificationGuestNetworkServiceDelete:
+		return "GuestNetworkServiceDelete"
+	case HcnNotificationNetworkEndpointAttached:
+		return "NetworkEndpointAttached"
+	case HcnNotificationNetworkEndpointDetached:
+		return "NetworkEndpointDetached"
+	case HcnNotificationGuestNetworkServiceStateChanged:
+		return "GuestNetworkServiceStateChanged"
+	case HcnNotificationGuestNetworkServiceInterfaceStateChanged:
+		return "GuestNetworkServiceInterfaceStateChanged"
+	case HcnNotificationServiceDisconnect:
+		return "ServiceDisconnect"
+	default:
+		return fmt.Sprintf("Unknown: %d", hn)
+	}
+}
+
+type HcnNotificationData struct {
+	Type   HcnNotification
+	Status error
+	Data   NotificationBase
+}
+
+type notificationChannel chan HcnNotificationData
+
+type notifcationWatcherContext struct {
+	channel notificationChannel
+	handle  hcnCallbackHandle
+}
+
+func notificationWatcher(notificationType HcnNotification, callbackNumber uintptr, notificationStatus uintptr, notificationData *uint16) uintptr {
+	var result error
+	if int32(notificationStatus) < 0 {
+		result = interop.Win32FromHresult(notificationStatus)
+	}
+
+	callbackMapLock.RLock()
+	context := callbackMap[callbackNumber]
+	callbackMapLock.RUnlock()
+
+	if context == nil {
+		return 0
+	}
+
+	if notificationData == nil {
+		return 0
+	}
+
+	tmpString := syscall.UTF16ToString((*[1 << 29]uint16)(unsafe.Pointer(notificationData))[:])
+
+	var notifData NotificationBase
+	err := json.Unmarshal([]byte(tmpString), &notifData)
+	if err == nil {
+		context.channel <- HcnNotificationData{
+			Type:   notificationType,
+			Status: result,
+			Data:   notifData,
+		}
+	}
+
+	return 0
+}

hcn/hcnerrors.go

@@ -49,7 +49,7 @@ type NetworkNotFoundError struct {
 }
 
 func (e NetworkNotFoundError) Error() string {
-	if e.NetworkName == "" {
+	if e.NetworkName != "" {
 		return fmt.Sprintf("Network Name %s not found", e.NetworkName)
 	}
 	return fmt.Sprintf("Network Id %s not found", e.NetworkID)
@@ -62,7 +62,7 @@ type EndpointNotFoundError struct {
 }
 
 func (e EndpointNotFoundError) Error() string {
-	if e.EndpointName == "" {
+	if e.EndpointName != "" {
 		return fmt.Sprintf("Endpoint Name %s not found", e.EndpointName)
 	}
 	return fmt.Sprintf("Endpoint Id %s not found", e.EndpointID)