1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00

Vendor Microsoft/go-winio v0.4.11

Signed-off-by: John Howard <jhoward@microsoft.com>
This commit is contained in:
John Howard 2018-08-23 15:12:13 -07:00
parent 7129bebe0a
commit 66966941f9
4 changed files with 281 additions and 220 deletions

View file

@ -1,7 +1,7 @@
# the following lines are in sorted order, FYI # the following lines are in sorted order, FYI
github.com/Azure/go-ansiterm d6e3b3328b783f23731bc4d058875b0371ff8109 github.com/Azure/go-ansiterm d6e3b3328b783f23731bc4d058875b0371ff8109
github.com/Microsoft/hcsshim 44c060121b68e8bdc40b411beba551f3b4ee9e55 github.com/Microsoft/hcsshim 44c060121b68e8bdc40b411beba551f3b4ee9e55
github.com/Microsoft/go-winio v0.4.10 github.com/Microsoft/go-winio v0.4.11
github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a
github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git
github.com/golang/gddo 9b12a26f3fbd7397dee4e20939ddca719d840d2a github.com/golang/gddo 9b12a26f3fbd7397dee4e20939ddca719d840d2a

View file

@ -1,137 +1,137 @@
package winio package winio
import ( import (
"bytes" "bytes"
"encoding/binary" "encoding/binary"
"errors" "errors"
) )
type fileFullEaInformation struct { type fileFullEaInformation struct {
NextEntryOffset uint32 NextEntryOffset uint32
Flags uint8 Flags uint8
NameLength uint8 NameLength uint8
ValueLength uint16 ValueLength uint16
} }
var ( var (
fileFullEaInformationSize = binary.Size(&fileFullEaInformation{}) fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
errInvalidEaBuffer = errors.New("invalid extended attribute buffer") errInvalidEaBuffer = errors.New("invalid extended attribute buffer")
errEaNameTooLarge = errors.New("extended attribute name too large") errEaNameTooLarge = errors.New("extended attribute name too large")
errEaValueTooLarge = errors.New("extended attribute value too large") errEaValueTooLarge = errors.New("extended attribute value too large")
) )
// ExtendedAttribute represents a single Windows EA. // ExtendedAttribute represents a single Windows EA.
type ExtendedAttribute struct { type ExtendedAttribute struct {
Name string Name string
Value []byte Value []byte
Flags uint8 Flags uint8
} }
func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) { func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) {
var info fileFullEaInformation var info fileFullEaInformation
err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info) err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
if err != nil { if err != nil {
err = errInvalidEaBuffer err = errInvalidEaBuffer
return return
} }
nameOffset := fileFullEaInformationSize nameOffset := fileFullEaInformationSize
nameLen := int(info.NameLength) nameLen := int(info.NameLength)
valueOffset := nameOffset + int(info.NameLength) + 1 valueOffset := nameOffset + int(info.NameLength) + 1
valueLen := int(info.ValueLength) valueLen := int(info.ValueLength)
nextOffset := int(info.NextEntryOffset) nextOffset := int(info.NextEntryOffset)
if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) { if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
err = errInvalidEaBuffer err = errInvalidEaBuffer
return return
} }
ea.Name = string(b[nameOffset : nameOffset+nameLen]) ea.Name = string(b[nameOffset : nameOffset+nameLen])
ea.Value = b[valueOffset : valueOffset+valueLen] ea.Value = b[valueOffset : valueOffset+valueLen]
ea.Flags = info.Flags ea.Flags = info.Flags
if info.NextEntryOffset != 0 { if info.NextEntryOffset != 0 {
nb = b[info.NextEntryOffset:] nb = b[info.NextEntryOffset:]
} }
return return
} }
// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION // DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
// buffer retrieved from BackupRead, ZwQueryEaFile, etc. // buffer retrieved from BackupRead, ZwQueryEaFile, etc.
func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) { func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 { for len(b) != 0 {
ea, nb, err := parseEa(b) ea, nb, err := parseEa(b)
if err != nil { if err != nil {
return nil, err return nil, err
} }
eas = append(eas, ea) eas = append(eas, ea)
b = nb b = nb
} }
return return
} }
func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error { func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
if int(uint8(len(ea.Name))) != len(ea.Name) { if int(uint8(len(ea.Name))) != len(ea.Name) {
return errEaNameTooLarge return errEaNameTooLarge
} }
if int(uint16(len(ea.Value))) != len(ea.Value) { if int(uint16(len(ea.Value))) != len(ea.Value) {
return errEaValueTooLarge return errEaValueTooLarge
} }
entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value)) entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
withPadding := (entrySize + 3) &^ 3 withPadding := (entrySize + 3) &^ 3
nextOffset := uint32(0) nextOffset := uint32(0)
if !last { if !last {
nextOffset = withPadding nextOffset = withPadding
} }
info := fileFullEaInformation{ info := fileFullEaInformation{
NextEntryOffset: nextOffset, NextEntryOffset: nextOffset,
Flags: ea.Flags, Flags: ea.Flags,
NameLength: uint8(len(ea.Name)), NameLength: uint8(len(ea.Name)),
ValueLength: uint16(len(ea.Value)), ValueLength: uint16(len(ea.Value)),
} }
err := binary.Write(buf, binary.LittleEndian, &info) err := binary.Write(buf, binary.LittleEndian, &info)
if err != nil { if err != nil {
return err return err
} }
_, err = buf.Write([]byte(ea.Name)) _, err = buf.Write([]byte(ea.Name))
if err != nil { if err != nil {
return err return err
} }
err = buf.WriteByte(0) err = buf.WriteByte(0)
if err != nil { if err != nil {
return err return err
} }
_, err = buf.Write(ea.Value) _, err = buf.Write(ea.Value)
if err != nil { if err != nil {
return err return err
} }
_, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize]) _, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
if err != nil { if err != nil {
return err return err
} }
return nil return nil
} }
// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION // EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
// buffer for use with BackupWrite, ZwSetEaFile, etc. // buffer for use with BackupWrite, ZwSetEaFile, etc.
func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) { func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer var buf bytes.Buffer
for i := range eas { for i := range eas {
last := false last := false
if i == len(eas)-1 { if i == len(eas)-1 {
last = true last = true
} }
err := writeEa(&buf, &eas[i], last) err := writeEa(&buf, &eas[i], last)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} }
return buf.Bytes(), nil return buf.Bytes(), nil
} }

View file

@ -1,82 +1,108 @@
// +build windows // +build windows
package vhd package vhd
import "syscall" import "syscall"
//go:generate go run mksyscall_windows.go -output zvhd.go vhd.go //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 //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
//sys openVirtualDisk(virtualStorageType *virtualStorageType, path string, virtualDiskAccessMask uint32, flags uint32, parameters *uintptr, handle *syscall.Handle) (err error) [failretval != 0] = VirtDisk.OpenVirtualDisk
type virtualStorageType struct { //sys detachVirtualDisk(handle syscall.Handle, flags uint32, providerSpecificFlags uint32) (err error) [failretval != 0] = VirtDisk.DetachVirtualDisk
DeviceID uint32
VendorID [16]byte type virtualStorageType struct {
} DeviceID uint32
VendorID [16]byte
const virtualDiskAccessNONE uint32 = 0 }
const virtualDiskAccessATTACHRO uint32 = 65536
const virtualDiskAccessATTACHRW uint32 = 131072 const virtualDiskAccessNONE uint32 = 0
const virtualDiskAccessDETACH uint32 = 262144 const virtualDiskAccessATTACHRO uint32 = 65536
const virtualDiskAccessGETINFO uint32 = 524288 const virtualDiskAccessATTACHRW uint32 = 131072
const virtualDiskAccessCREATE uint32 = 1048576 const virtualDiskAccessDETACH uint32 = 262144
const virtualDiskAccessMETAOPS uint32 = 2097152 const virtualDiskAccessGETINFO uint32 = 524288
const virtualDiskAccessREAD uint32 = 851968 const virtualDiskAccessCREATE uint32 = 1048576
const virtualDiskAccessALL uint32 = 4128768 const virtualDiskAccessMETAOPS uint32 = 2097152
const virtualDiskAccessWRITABLE uint32 = 3276800 const virtualDiskAccessREAD uint32 = 851968
const virtualDiskAccessALL uint32 = 4128768
const createVirtualDiskFlagNone uint32 = 0 const virtualDiskAccessWRITABLE uint32 = 3276800
const createVirtualDiskFlagFullPhysicalAllocation uint32 = 1
const createVirtualDiskFlagPreventWritesToSourceDisk uint32 = 2 const createVirtualDiskFlagNone uint32 = 0
const createVirtualDiskFlagDoNotCopyMetadataFromParent uint32 = 4 const createVirtualDiskFlagFullPhysicalAllocation uint32 = 1
const createVirtualDiskFlagPreventWritesToSourceDisk uint32 = 2
type version2 struct { const createVirtualDiskFlagDoNotCopyMetadataFromParent uint32 = 4
UniqueID [16]byte // GUID
MaximumSize uint64 type version2 struct {
BlockSizeInBytes uint32 UniqueID [16]byte // GUID
SectorSizeInBytes uint32 MaximumSize uint64
ParentPath *uint16 // string BlockSizeInBytes uint32
SourcePath *uint16 // string SectorSizeInBytes uint32
OpenFlags uint32 ParentPath *uint16 // string
ParentVirtualStorageType virtualStorageType SourcePath *uint16 // string
SourceVirtualStorageType virtualStorageType OpenFlags uint32
ResiliencyGUID [16]byte // GUID ParentVirtualStorageType virtualStorageType
} SourceVirtualStorageType virtualStorageType
ResiliencyGUID [16]byte // GUID
type createVirtualDiskParameters struct { }
Version uint32 // Must always be set to 2
Version2 version2 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 // CreateVhdx will create a simple vhdx file at the given path using default values.
func CreateVhdx(path string, maxSizeInGb, blockSizeInMb uint32) error {
parameters := createVirtualDiskParameters{ var defaultType virtualStorageType
Version: 2,
Version2: version2{ parameters := createVirtualDiskParameters{
MaximumSize: uint64(maxSizeInGb) * 1024 * 1024 * 1024, Version: 2,
BlockSizeInBytes: blockSizeInMb * 1024 * 1024, Version2: version2{
}, MaximumSize: uint64(maxSizeInGb) * 1024 * 1024 * 1024,
} BlockSizeInBytes: blockSizeInMb * 1024 * 1024,
},
var handle syscall.Handle }
if err := createVirtualDisk( var handle syscall.Handle
&defaultType,
path, if err := createVirtualDisk(
virtualDiskAccessNONE, &defaultType,
nil, path,
createVirtualDiskFlagNone, virtualDiskAccessNONE,
0, nil,
&parameters, createVirtualDiskFlagNone,
nil, 0,
&handle); err != nil { &parameters,
return err nil,
} &handle); err != nil {
return err
if err := syscall.CloseHandle(handle); err != nil { }
return err
} if err := syscall.CloseHandle(handle); err != nil {
return err
return nil }
}
return nil
}
// DetachVhd detaches a VHD attached at the given path.
func DetachVhd(path string) error {
var (
defaultType virtualStorageType
handle syscall.Handle
)
if err := openVirtualDisk(
&defaultType,
path,
virtualDiskAccessDETACH,
0,
nil,
&handle); err != nil {
return err
}
defer syscall.CloseHandle(handle)
if err := detachVirtualDisk(handle, 0, 0); err != nil {
return err
}
return nil
}

View file

@ -40,6 +40,8 @@ var (
modVirtDisk = windows.NewLazySystemDLL("VirtDisk.dll") modVirtDisk = windows.NewLazySystemDLL("VirtDisk.dll")
procCreateVirtualDisk = modVirtDisk.NewProc("CreateVirtualDisk") procCreateVirtualDisk = modVirtDisk.NewProc("CreateVirtualDisk")
procOpenVirtualDisk = modVirtDisk.NewProc("OpenVirtualDisk")
procDetachVirtualDisk = modVirtDisk.NewProc("DetachVirtualDisk")
) )
func createVirtualDisk(virtualStorageType *virtualStorageType, path string, virtualDiskAccessMask uint32, securityDescriptor *uintptr, flags uint32, providerSpecificFlags uint32, parameters *createVirtualDiskParameters, o *syscall.Overlapped, handle *syscall.Handle) (err error) { func createVirtualDisk(virtualStorageType *virtualStorageType, path string, virtualDiskAccessMask uint32, securityDescriptor *uintptr, flags uint32, providerSpecificFlags uint32, parameters *createVirtualDiskParameters, o *syscall.Overlapped, handle *syscall.Handle) (err error) {
@ -62,3 +64,36 @@ func _createVirtualDisk(virtualStorageType *virtualStorageType, path *uint16, vi
} }
return return
} }
func openVirtualDisk(virtualStorageType *virtualStorageType, path string, virtualDiskAccessMask uint32, flags uint32, parameters *uintptr, handle *syscall.Handle) (err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(path)
if err != nil {
return
}
return _openVirtualDisk(virtualStorageType, _p0, virtualDiskAccessMask, flags, parameters, handle)
}
func _openVirtualDisk(virtualStorageType *virtualStorageType, path *uint16, virtualDiskAccessMask uint32, flags uint32, parameters *uintptr, handle *syscall.Handle) (err error) {
r1, _, e1 := syscall.Syscall6(procOpenVirtualDisk.Addr(), 6, uintptr(unsafe.Pointer(virtualStorageType)), uintptr(unsafe.Pointer(path)), uintptr(virtualDiskAccessMask), uintptr(flags), uintptr(unsafe.Pointer(parameters)), uintptr(unsafe.Pointer(handle)))
if r1 != 0 {
if e1 != 0 {
err = errnoErr(e1)
} else {
err = syscall.EINVAL
}
}
return
}
func detachVirtualDisk(handle syscall.Handle, flags uint32, providerSpecificFlags uint32) (err error) {
r1, _, e1 := syscall.Syscall(procDetachVirtualDisk.Addr(), 3, uintptr(handle), uintptr(flags), uintptr(providerSpecificFlags))
if r1 != 0 {
if e1 != 0 {
err = errnoErr(e1)
} else {
err = syscall.EINVAL
}
}
return
}