| // MACHINE GENERATED BY 'go generate' COMMAND; DO NOT EDIT |
| |
| package hcsshim |
| |
| import "github.com/Microsoft/go-winio" |
| import "unsafe" |
| import "syscall" |
| |
| var _ unsafe.Pointer |
| |
| var ( |
| modole32 = syscall.NewLazyDLL("ole32.dll") |
| modvmcompute = syscall.NewLazyDLL("vmcompute.dll") |
| |
| procCoTaskMemFree = modole32.NewProc("CoTaskMemFree") |
| procActivateLayer = modvmcompute.NewProc("ActivateLayer") |
| procCopyLayer = modvmcompute.NewProc("CopyLayer") |
| procCreateLayer = modvmcompute.NewProc("CreateLayer") |
| procCreateSandboxLayer = modvmcompute.NewProc("CreateSandboxLayer") |
| procExpandSandboxSize = modvmcompute.NewProc("ExpandSandboxSize") |
| procDeactivateLayer = modvmcompute.NewProc("DeactivateLayer") |
| procDestroyLayer = modvmcompute.NewProc("DestroyLayer") |
| procExportLayer = modvmcompute.NewProc("ExportLayer") |
| procGetLayerMountPath = modvmcompute.NewProc("GetLayerMountPath") |
| procGetBaseImages = modvmcompute.NewProc("GetBaseImages") |
| procImportLayer = modvmcompute.NewProc("ImportLayer") |
| procLayerExists = modvmcompute.NewProc("LayerExists") |
| procNameToGuid = modvmcompute.NewProc("NameToGuid") |
| procPrepareLayer = modvmcompute.NewProc("PrepareLayer") |
| procUnprepareLayer = modvmcompute.NewProc("UnprepareLayer") |
| procProcessBaseImage = modvmcompute.NewProc("ProcessBaseImage") |
| procProcessUtilityImage = modvmcompute.NewProc("ProcessUtilityImage") |
| procImportLayerBegin = modvmcompute.NewProc("ImportLayerBegin") |
| procImportLayerNext = modvmcompute.NewProc("ImportLayerNext") |
| procImportLayerWrite = modvmcompute.NewProc("ImportLayerWrite") |
| procImportLayerEnd = modvmcompute.NewProc("ImportLayerEnd") |
| procExportLayerBegin = modvmcompute.NewProc("ExportLayerBegin") |
| procExportLayerNext = modvmcompute.NewProc("ExportLayerNext") |
| procExportLayerRead = modvmcompute.NewProc("ExportLayerRead") |
| procExportLayerEnd = modvmcompute.NewProc("ExportLayerEnd") |
| procCreateComputeSystem = modvmcompute.NewProc("CreateComputeSystem") |
| procCreateProcessWithStdHandlesInComputeSystem = modvmcompute.NewProc("CreateProcessWithStdHandlesInComputeSystem") |
| procResizeConsoleInComputeSystem = modvmcompute.NewProc("ResizeConsoleInComputeSystem") |
| procShutdownComputeSystem = modvmcompute.NewProc("ShutdownComputeSystem") |
| procStartComputeSystem = modvmcompute.NewProc("StartComputeSystem") |
| procTerminateComputeSystem = modvmcompute.NewProc("TerminateComputeSystem") |
| procTerminateProcessInComputeSystem = modvmcompute.NewProc("TerminateProcessInComputeSystem") |
| procWaitForProcessInComputeSystem = modvmcompute.NewProc("WaitForProcessInComputeSystem") |
| procGetComputeSystemProperties = modvmcompute.NewProc("GetComputeSystemProperties") |
| procHcsEnumerateComputeSystems = modvmcompute.NewProc("HcsEnumerateComputeSystems") |
| procHcsCreateComputeSystem = modvmcompute.NewProc("HcsCreateComputeSystem") |
| procHcsOpenComputeSystem = modvmcompute.NewProc("HcsOpenComputeSystem") |
| procHcsCloseComputeSystem = modvmcompute.NewProc("HcsCloseComputeSystem") |
| procHcsStartComputeSystem = modvmcompute.NewProc("HcsStartComputeSystem") |
| procHcsShutdownComputeSystem = modvmcompute.NewProc("HcsShutdownComputeSystem") |
| procHcsTerminateComputeSystem = modvmcompute.NewProc("HcsTerminateComputeSystem") |
| procHcsPauseComputeSystem = modvmcompute.NewProc("HcsPauseComputeSystem") |
| procHcsResumeComputeSystem = modvmcompute.NewProc("HcsResumeComputeSystem") |
| procHcsGetComputeSystemProperties = modvmcompute.NewProc("HcsGetComputeSystemProperties") |
| procHcsModifyComputeSystem = modvmcompute.NewProc("HcsModifyComputeSystem") |
| procHcsCreateComputeSystemWait = modvmcompute.NewProc("HcsCreateComputeSystemWait") |
| procHcsCreateProcess = modvmcompute.NewProc("HcsCreateProcess") |
| procHcsOpenProcess = modvmcompute.NewProc("HcsOpenProcess") |
| procHcsCloseProcess = modvmcompute.NewProc("HcsCloseProcess") |
| procHcsTerminateProcess = modvmcompute.NewProc("HcsTerminateProcess") |
| procHcsGetProcessInfo = modvmcompute.NewProc("HcsGetProcessInfo") |
| procHcsGetProcessProperties = modvmcompute.NewProc("HcsGetProcessProperties") |
| procHcsModifyProcess = modvmcompute.NewProc("HcsModifyProcess") |
| procHcsCreateProcessWait = modvmcompute.NewProc("HcsCreateProcessWait") |
| procHcsGetServiceProperties = modvmcompute.NewProc("HcsGetServiceProperties") |
| procHcsModifyServiceSettings = modvmcompute.NewProc("HcsModifyServiceSettings") |
| |
| procHcsRegisterComputeSystemCallback = modvmcompute.NewProc("HcsRegisterComputeSystemCallback") |
| procHcsUnregisterComputeSystemCallback = modvmcompute.NewProc("HcsUnregisterComputeSystemCallback") |
| procHcsRegisterProcessCallback = modvmcompute.NewProc("HcsRegisterProcessCallback") |
| procHcsUnregisterProcessCallback = modvmcompute.NewProc("HcsUnregisterProcessCallback") |
| procHNSCall = modvmcompute.NewProc("HNSCall") |
| ) |
| |
| func coTaskMemFree(buffer unsafe.Pointer) { |
| syscall.Syscall(procCoTaskMemFree.Addr(), 1, uintptr(buffer), 0, 0) |
| return |
| } |
| |
| func activateLayer(info *driverInfo, id string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _activateLayer(info, _p0) |
| } |
| |
| func _activateLayer(info *driverInfo, id *uint16) (hr error) { |
| if hr = procActivateLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procActivateLayer.Addr(), 2, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func copyLayer(info *driverInfo, srcId string, dstId string, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(srcId) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(dstId) |
| if hr != nil { |
| return |
| } |
| return _copyLayer(info, _p0, _p1, descriptors) |
| } |
| |
| func _copyLayer(info *driverInfo, srcId *uint16, dstId *uint16, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p2 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p2 = &descriptors[0] |
| } |
| if hr = procCopyLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procCopyLayer.Addr(), 5, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(srcId)), uintptr(unsafe.Pointer(dstId)), uintptr(unsafe.Pointer(_p2)), uintptr(len(descriptors)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func createLayer(info *driverInfo, id string, parent string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(parent) |
| if hr != nil { |
| return |
| } |
| return _createLayer(info, _p0, _p1) |
| } |
| |
| func _createLayer(info *driverInfo, id *uint16, parent *uint16) (hr error) { |
| if hr = procCreateLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procCreateLayer.Addr(), 3, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(parent))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func createSandboxLayer(info *driverInfo, id string, parent string, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(parent) |
| if hr != nil { |
| return |
| } |
| return _createSandboxLayer(info, _p0, _p1, descriptors) |
| } |
| |
| func _createSandboxLayer(info *driverInfo, id *uint16, parent *uint16, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p2 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p2 = &descriptors[0] |
| } |
| if hr = procCreateSandboxLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procCreateSandboxLayer.Addr(), 5, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(parent)), uintptr(unsafe.Pointer(_p2)), uintptr(len(descriptors)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func expandSandboxSize(info *driverInfo, id string, size uint64) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _expandSandboxSize(info, _p0, size) |
| } |
| |
| func _expandSandboxSize(info *driverInfo, id *uint16, size uint64) (hr error) { |
| if hr = procExpandSandboxSize.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procExpandSandboxSize.Addr(), 3, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(size)) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func deactivateLayer(info *driverInfo, id string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _deactivateLayer(info, _p0) |
| } |
| |
| func _deactivateLayer(info *driverInfo, id *uint16) (hr error) { |
| if hr = procDeactivateLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procDeactivateLayer.Addr(), 2, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func destroyLayer(info *driverInfo, id string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _destroyLayer(info, _p0) |
| } |
| |
| func _destroyLayer(info *driverInfo, id *uint16) (hr error) { |
| if hr = procDestroyLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procDestroyLayer.Addr(), 2, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func exportLayer(info *driverInfo, id string, path string, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(path) |
| if hr != nil { |
| return |
| } |
| return _exportLayer(info, _p0, _p1, descriptors) |
| } |
| |
| func _exportLayer(info *driverInfo, id *uint16, path *uint16, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p2 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p2 = &descriptors[0] |
| } |
| if hr = procExportLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procExportLayer.Addr(), 5, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(_p2)), uintptr(len(descriptors)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func getLayerMountPath(info *driverInfo, id string, length *uintptr, buffer *uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _getLayerMountPath(info, _p0, length, buffer) |
| } |
| |
| func _getLayerMountPath(info *driverInfo, id *uint16, length *uintptr, buffer *uint16) (hr error) { |
| if hr = procGetLayerMountPath.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procGetLayerMountPath.Addr(), 4, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(length)), uintptr(unsafe.Pointer(buffer)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func getBaseImages(buffer **uint16) (hr error) { |
| if hr = procGetBaseImages.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procGetBaseImages.Addr(), 1, uintptr(unsafe.Pointer(buffer)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func importLayer(info *driverInfo, id string, path string, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(path) |
| if hr != nil { |
| return |
| } |
| return _importLayer(info, _p0, _p1, descriptors) |
| } |
| |
| func _importLayer(info *driverInfo, id *uint16, path *uint16, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p2 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p2 = &descriptors[0] |
| } |
| if hr = procImportLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procImportLayer.Addr(), 5, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(_p2)), uintptr(len(descriptors)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func layerExists(info *driverInfo, id string, exists *uint32) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _layerExists(info, _p0, exists) |
| } |
| |
| func _layerExists(info *driverInfo, id *uint16, exists *uint32) (hr error) { |
| if hr = procLayerExists.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procLayerExists.Addr(), 3, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(exists))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func nameToGuid(name string, guid *GUID) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(name) |
| if hr != nil { |
| return |
| } |
| return _nameToGuid(_p0, guid) |
| } |
| |
| func _nameToGuid(name *uint16, guid *GUID) (hr error) { |
| if hr = procNameToGuid.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procNameToGuid.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(guid)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func prepareLayer(info *driverInfo, id string, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _prepareLayer(info, _p0, descriptors) |
| } |
| |
| func _prepareLayer(info *driverInfo, id *uint16, descriptors []WC_LAYER_DESCRIPTOR) (hr error) { |
| var _p1 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p1 = &descriptors[0] |
| } |
| if hr = procPrepareLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procPrepareLayer.Addr(), 4, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(_p1)), uintptr(len(descriptors)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func unprepareLayer(info *driverInfo, id string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _unprepareLayer(info, _p0) |
| } |
| |
| func _unprepareLayer(info *driverInfo, id *uint16) (hr error) { |
| if hr = procUnprepareLayer.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procUnprepareLayer.Addr(), 2, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func processBaseImage(path string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(path) |
| if hr != nil { |
| return |
| } |
| return _processBaseImage(_p0) |
| } |
| |
| func _processBaseImage(path *uint16) (hr error) { |
| if hr = procProcessBaseImage.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procProcessBaseImage.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func processUtilityImage(path string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(path) |
| if hr != nil { |
| return |
| } |
| return _processUtilityImage(_p0) |
| } |
| |
| func _processUtilityImage(path *uint16) (hr error) { |
| if hr = procProcessUtilityImage.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procProcessUtilityImage.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func importLayerBegin(info *driverInfo, id string, descriptors []WC_LAYER_DESCRIPTOR, context *uintptr) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _importLayerBegin(info, _p0, descriptors, context) |
| } |
| |
| func _importLayerBegin(info *driverInfo, id *uint16, descriptors []WC_LAYER_DESCRIPTOR, context *uintptr) (hr error) { |
| var _p1 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p1 = &descriptors[0] |
| } |
| if hr = procImportLayerBegin.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procImportLayerBegin.Addr(), 5, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(_p1)), uintptr(len(descriptors)), uintptr(unsafe.Pointer(context)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func importLayerNext(context uintptr, fileName string, fileInfo *winio.FileBasicInfo) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(fileName) |
| if hr != nil { |
| return |
| } |
| return _importLayerNext(context, _p0, fileInfo) |
| } |
| |
| func _importLayerNext(context uintptr, fileName *uint16, fileInfo *winio.FileBasicInfo) (hr error) { |
| if hr = procImportLayerNext.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procImportLayerNext.Addr(), 3, uintptr(context), uintptr(unsafe.Pointer(fileName)), uintptr(unsafe.Pointer(fileInfo))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func importLayerWrite(context uintptr, buffer []byte) (hr error) { |
| var _p0 *byte |
| if len(buffer) > 0 { |
| _p0 = &buffer[0] |
| } |
| if hr = procImportLayerWrite.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procImportLayerWrite.Addr(), 3, uintptr(context), uintptr(unsafe.Pointer(_p0)), uintptr(len(buffer))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func importLayerEnd(context uintptr) (hr error) { |
| if hr = procImportLayerEnd.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procImportLayerEnd.Addr(), 1, uintptr(context), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func exportLayerBegin(info *driverInfo, id string, descriptors []WC_LAYER_DESCRIPTOR, context *uintptr) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _exportLayerBegin(info, _p0, descriptors, context) |
| } |
| |
| func _exportLayerBegin(info *driverInfo, id *uint16, descriptors []WC_LAYER_DESCRIPTOR, context *uintptr) (hr error) { |
| var _p1 *WC_LAYER_DESCRIPTOR |
| if len(descriptors) > 0 { |
| _p1 = &descriptors[0] |
| } |
| if hr = procExportLayerBegin.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procExportLayerBegin.Addr(), 5, uintptr(unsafe.Pointer(info)), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(_p1)), uintptr(len(descriptors)), uintptr(unsafe.Pointer(context)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func exportLayerNext(context uintptr, fileName **uint16, fileInfo *winio.FileBasicInfo, fileSize *int64, deleted *uint32) (hr error) { |
| if hr = procExportLayerNext.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procExportLayerNext.Addr(), 5, uintptr(context), uintptr(unsafe.Pointer(fileName)), uintptr(unsafe.Pointer(fileInfo)), uintptr(unsafe.Pointer(fileSize)), uintptr(unsafe.Pointer(deleted)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func exportLayerRead(context uintptr, buffer []byte, bytesRead *uint32) (hr error) { |
| var _p0 *byte |
| if len(buffer) > 0 { |
| _p0 = &buffer[0] |
| } |
| if hr = procExportLayerRead.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procExportLayerRead.Addr(), 4, uintptr(context), uintptr(unsafe.Pointer(_p0)), uintptr(len(buffer)), uintptr(unsafe.Pointer(bytesRead)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func exportLayerEnd(context uintptr) (hr error) { |
| if hr = procExportLayerEnd.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procExportLayerEnd.Addr(), 1, uintptr(context), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func createComputeSystem(id string, configuration string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(configuration) |
| if hr != nil { |
| return |
| } |
| return _createComputeSystem(_p0, _p1) |
| } |
| |
| func _createComputeSystem(id *uint16, configuration *uint16) (hr error) { |
| if hr = procCreateComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procCreateComputeSystem.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(configuration)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func createProcessWithStdHandlesInComputeSystem(id string, paramsJson string, pid *uint32, stdin *syscall.Handle, stdout *syscall.Handle, stderr *syscall.Handle) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(paramsJson) |
| if hr != nil { |
| return |
| } |
| return _createProcessWithStdHandlesInComputeSystem(_p0, _p1, pid, stdin, stdout, stderr) |
| } |
| |
| func _createProcessWithStdHandlesInComputeSystem(id *uint16, paramsJson *uint16, pid *uint32, stdin *syscall.Handle, stdout *syscall.Handle, stderr *syscall.Handle) (hr error) { |
| if hr = procCreateProcessWithStdHandlesInComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procCreateProcessWithStdHandlesInComputeSystem.Addr(), 6, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(paramsJson)), uintptr(unsafe.Pointer(pid)), uintptr(unsafe.Pointer(stdin)), uintptr(unsafe.Pointer(stdout)), uintptr(unsafe.Pointer(stderr))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func resizeConsoleInComputeSystem(id string, pid uint32, height uint16, width uint16, flags uint32) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _resizeConsoleInComputeSystem(_p0, pid, height, width, flags) |
| } |
| |
| func _resizeConsoleInComputeSystem(id *uint16, pid uint32, height uint16, width uint16, flags uint32) (hr error) { |
| if hr = procResizeConsoleInComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procResizeConsoleInComputeSystem.Addr(), 5, uintptr(unsafe.Pointer(id)), uintptr(pid), uintptr(height), uintptr(width), uintptr(flags), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func shutdownComputeSystem(id string, timeout uint32) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _shutdownComputeSystem(_p0, timeout) |
| } |
| |
| func _shutdownComputeSystem(id *uint16, timeout uint32) (hr error) { |
| if hr = procShutdownComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procShutdownComputeSystem.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(timeout), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func startComputeSystem(id string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _startComputeSystem(_p0) |
| } |
| |
| func _startComputeSystem(id *uint16) (hr error) { |
| if hr = procStartComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procStartComputeSystem.Addr(), 1, uintptr(unsafe.Pointer(id)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func terminateComputeSystem(id string) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _terminateComputeSystem(_p0) |
| } |
| |
| func _terminateComputeSystem(id *uint16) (hr error) { |
| if hr = procTerminateComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procTerminateComputeSystem.Addr(), 1, uintptr(unsafe.Pointer(id)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func terminateProcessInComputeSystem(id string, pid uint32) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _terminateProcessInComputeSystem(_p0, pid) |
| } |
| |
| func _terminateProcessInComputeSystem(id *uint16, pid uint32) (hr error) { |
| if hr = procTerminateProcessInComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procTerminateProcessInComputeSystem.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(pid), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func waitForProcessInComputeSystem(id string, pid uint32, timeout uint32, exitCode *uint32) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _waitForProcessInComputeSystem(_p0, pid, timeout, exitCode) |
| } |
| |
| func _waitForProcessInComputeSystem(id *uint16, pid uint32, timeout uint32, exitCode *uint32) (hr error) { |
| if hr = procWaitForProcessInComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procWaitForProcessInComputeSystem.Addr(), 4, uintptr(unsafe.Pointer(id)), uintptr(pid), uintptr(timeout), uintptr(unsafe.Pointer(exitCode)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func getComputeSystemProperties(id string, flags uint32, properties **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _getComputeSystemProperties(_p0, flags, properties) |
| } |
| |
| func _getComputeSystemProperties(id *uint16, flags uint32, properties **uint16) (hr error) { |
| if hr = procGetComputeSystemProperties.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procGetComputeSystemProperties.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(flags), uintptr(unsafe.Pointer(properties))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsEnumerateComputeSystems(query string, computeSystems **uint16, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(query) |
| if hr != nil { |
| return |
| } |
| return _hcsEnumerateComputeSystems(_p0, computeSystems, result) |
| } |
| |
| func _hcsEnumerateComputeSystems(query *uint16, computeSystems **uint16, result **uint16) (hr error) { |
| if hr = procHcsEnumerateComputeSystems.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsEnumerateComputeSystems.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(computeSystems)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCreateComputeSystem(id string, configuration string, identity syscall.Handle, computeSystem *hcsSystem, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(configuration) |
| if hr != nil { |
| return |
| } |
| return _hcsCreateComputeSystem(_p0, _p1, identity, computeSystem, result) |
| } |
| |
| func _hcsCreateComputeSystem(id *uint16, configuration *uint16, identity syscall.Handle, computeSystem *hcsSystem, result **uint16) (hr error) { |
| if hr = procHcsCreateComputeSystem.Find(); hr != nil { |
| return |
| } |
| 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 = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsOpenComputeSystem(id string, computeSystem *hcsSystem, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| return _hcsOpenComputeSystem(_p0, computeSystem, result) |
| } |
| |
| func _hcsOpenComputeSystem(id *uint16, computeSystem *hcsSystem, result **uint16) (hr error) { |
| if hr = procHcsOpenComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsOpenComputeSystem.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(computeSystem)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCloseComputeSystem(computeSystem hcsSystem) (hr error) { |
| if hr = procHcsCloseComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsCloseComputeSystem.Addr(), 1, uintptr(computeSystem), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsStartComputeSystem(computeSystem hcsSystem, options string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(options) |
| if hr != nil { |
| return |
| } |
| return _hcsStartComputeSystem(computeSystem, _p0, result) |
| } |
| |
| func _hcsStartComputeSystem(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsStartComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsStartComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsShutdownComputeSystem(computeSystem hcsSystem, options string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(options) |
| if hr != nil { |
| return |
| } |
| return _hcsShutdownComputeSystem(computeSystem, _p0, result) |
| } |
| |
| func _hcsShutdownComputeSystem(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsShutdownComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsShutdownComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsTerminateComputeSystem(computeSystem hcsSystem, options string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(options) |
| if hr != nil { |
| return |
| } |
| return _hcsTerminateComputeSystem(computeSystem, _p0, result) |
| } |
| |
| func _hcsTerminateComputeSystem(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsTerminateComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsTerminateComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsPauseComputeSystem(computeSystem hcsSystem, options string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(options) |
| if hr != nil { |
| return |
| } |
| return _hcsPauseComputeSystem(computeSystem, _p0, result) |
| } |
| |
| func _hcsPauseComputeSystem(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsPauseComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsPauseComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsResumeComputeSystem(computeSystem hcsSystem, options string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(options) |
| if hr != nil { |
| return |
| } |
| return _hcsResumeComputeSystem(computeSystem, _p0, result) |
| } |
| |
| func _hcsResumeComputeSystem(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsResumeComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsResumeComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsGetComputeSystemProperties(computeSystem hcsSystem, propertyQuery string, properties **uint16, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(propertyQuery) |
| if hr != nil { |
| return |
| } |
| return _hcsGetComputeSystemProperties(computeSystem, _p0, properties, result) |
| } |
| |
| func _hcsGetComputeSystemProperties(computeSystem hcsSystem, propertyQuery *uint16, properties **uint16, result **uint16) (hr error) { |
| if hr = procHcsGetComputeSystemProperties.Find(); hr != nil { |
| return |
| } |
| 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 = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsModifyComputeSystem(computeSystem hcsSystem, configuration string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(configuration) |
| if hr != nil { |
| return |
| } |
| return _hcsModifyComputeSystem(computeSystem, _p0, result) |
| } |
| |
| func _hcsModifyComputeSystem(computeSystem hcsSystem, configuration *uint16, result **uint16) (hr error) { |
| if hr = procHcsModifyComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsModifyComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(configuration)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCreateComputeSystemWait(computeSystem hcsSystem, exitEvent *syscall.Handle, result **uint16) (hr error) { |
| if hr = procHcsCreateComputeSystemWait.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsCreateComputeSystemWait.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(exitEvent)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCreateProcess(computeSystem hcsSystem, processParameters string, processInformation *hcsProcessInformation, process *hcsProcess, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(processParameters) |
| if hr != nil { |
| return |
| } |
| return _hcsCreateProcess(computeSystem, _p0, processInformation, process, result) |
| } |
| |
| func _hcsCreateProcess(computeSystem hcsSystem, processParameters *uint16, processInformation *hcsProcessInformation, process *hcsProcess, result **uint16) (hr error) { |
| if hr = procHcsCreateProcess.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procHcsCreateProcess.Addr(), 5, uintptr(computeSystem), uintptr(unsafe.Pointer(processParameters)), uintptr(unsafe.Pointer(processInformation)), uintptr(unsafe.Pointer(process)), uintptr(unsafe.Pointer(result)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsOpenProcess(computeSystem hcsSystem, pid uint32, process *hcsProcess, result **uint16) (hr error) { |
| if hr = procHcsOpenProcess.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procHcsOpenProcess.Addr(), 4, uintptr(computeSystem), uintptr(pid), uintptr(unsafe.Pointer(process)), uintptr(unsafe.Pointer(result)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCloseProcess(process hcsProcess) (hr error) { |
| if hr = procHcsCloseProcess.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsCloseProcess.Addr(), 1, uintptr(process), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsTerminateProcess(process hcsProcess, result **uint16) (hr error) { |
| if hr = procHcsTerminateProcess.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsTerminateProcess.Addr(), 2, uintptr(process), uintptr(unsafe.Pointer(result)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsGetProcessInfo(process hcsProcess, processInformation *hcsProcessInformation, result **uint16) (hr error) { |
| if hr = procHcsGetProcessInfo.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsGetProcessInfo.Addr(), 3, uintptr(process), uintptr(unsafe.Pointer(processInformation)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsGetProcessProperties(process hcsProcess, processProperties **uint16, result **uint16) (hr error) { |
| if hr = procHcsGetProcessProperties.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsGetProcessProperties.Addr(), 3, uintptr(process), uintptr(unsafe.Pointer(processProperties)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsModifyProcess(process hcsProcess, settings string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(settings) |
| if hr != nil { |
| return |
| } |
| return _hcsModifyProcess(process, _p0, result) |
| } |
| |
| func _hcsModifyProcess(process hcsProcess, settings *uint16, result **uint16) (hr error) { |
| if hr = procHcsModifyProcess.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsModifyProcess.Addr(), 3, uintptr(process), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCreateProcessWait(process hcsProcess, settings *syscall.Handle, result **uint16) (hr error) { |
| if hr = procHcsCreateProcessWait.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsCreateProcessWait.Addr(), 3, uintptr(process), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsGetServiceProperties(propertyQuery string, properties **uint16, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(propertyQuery) |
| if hr != nil { |
| return |
| } |
| return _hcsGetServiceProperties(_p0, properties, result) |
| } |
| |
| func _hcsGetServiceProperties(propertyQuery *uint16, properties **uint16, result **uint16) (hr error) { |
| if hr = procHcsGetServiceProperties.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsGetServiceProperties.Addr(), 3, uintptr(unsafe.Pointer(propertyQuery)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsModifyServiceSettings(settings string, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(settings) |
| if hr != nil { |
| return |
| } |
| return _hcsModifyServiceSettings(_p0, result) |
| } |
| |
| func _hcsModifyServiceSettings(settings *uint16, result **uint16) (hr error) { |
| if hr = procHcsModifyServiceSettings.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsModifyServiceSettings.Addr(), 2, uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result)), 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsCreateComputeSystemTP5(id string, configuration string, computeSystem *hcsSystem, result **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(id) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(configuration) |
| if hr != nil { |
| return |
| } |
| return _hcsCreateComputeSystemTP5(_p0, _p1, computeSystem, result) |
| } |
| |
| func _hcsCreateComputeSystemTP5(id *uint16, configuration *uint16, computeSystem *hcsSystem, result **uint16) (hr error) { |
| if hr = procHcsCreateComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procHcsCreateComputeSystem.Addr(), 4, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(configuration)), uintptr(unsafe.Pointer(computeSystem)), uintptr(unsafe.Pointer(result)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsStartComputeSystemTP5(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsStartComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsStartComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsShutdownComputeSystemTP5(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsShutdownComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsShutdownComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsTerminateComputeSystemTP5(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsTerminateComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsTerminateComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsPauseComputeSystemTP5(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsPauseComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsPauseComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsResumeComputeSystemTP5(computeSystem hcsSystem, options *uint16, result **uint16) (hr error) { |
| if hr = procHcsResumeComputeSystem.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsResumeComputeSystem.Addr(), 3, uintptr(computeSystem), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result))) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsRegisterComputeSystemCallback(computeSystem hcsSystem, callback uintptr, context uintptr, callbackHandle *hcsCallback) (hr error) { |
| if hr = procHcsRegisterComputeSystemCallback.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procHcsRegisterComputeSystemCallback.Addr(), 4, uintptr(computeSystem), uintptr(callback), uintptr(context), uintptr(unsafe.Pointer(callbackHandle)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsUnregisterComputeSystemCallback(callbackHandle hcsCallback) (hr error) { |
| if hr = procHcsUnregisterComputeSystemCallback.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsUnregisterComputeSystemCallback.Addr(), 1, uintptr(callbackHandle), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsRegisterProcessCallback(process hcsProcess, callback uintptr, context uintptr, callbackHandle *hcsCallback) (hr error) { |
| if hr = procHcsRegisterProcessCallback.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procHcsRegisterProcessCallback.Addr(), 4, uintptr(process), uintptr(callback), uintptr(context), uintptr(unsafe.Pointer(callbackHandle)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func hcsUnregisterProcessCallback(callbackHandle hcsCallback) (hr error) { |
| if hr = procHcsUnregisterProcessCallback.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall(procHcsUnregisterProcessCallback.Addr(), 1, uintptr(callbackHandle), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
| |
| func _hnsCall(method string, path string, object string, response **uint16) (hr error) { |
| var _p0 *uint16 |
| _p0, hr = syscall.UTF16PtrFromString(method) |
| if hr != nil { |
| return |
| } |
| var _p1 *uint16 |
| _p1, hr = syscall.UTF16PtrFromString(path) |
| if hr != nil { |
| return |
| } |
| var _p2 *uint16 |
| _p2, hr = syscall.UTF16PtrFromString(object) |
| if hr != nil { |
| return |
| } |
| return __hnsCall(_p0, _p1, _p2, response) |
| } |
| |
| func __hnsCall(method *uint16, path *uint16, object *uint16, response **uint16) (hr error) { |
| if hr = procHNSCall.Find(); hr != nil { |
| return |
| } |
| r0, _, _ := syscall.Syscall6(procHNSCall.Addr(), 4, uintptr(unsafe.Pointer(method)), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(object)), uintptr(unsafe.Pointer(response)), 0, 0) |
| if int32(r0) < 0 { |
| hr = syscall.Errno(win32FromHresult(r0)) |
| } |
| return |
| } |
