1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
From ed7ed5c7b3ce4db8abd0219b12ff17ad9074f1cb Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" <Jason@zx2c4.com>
Date: Sun, 31 Jan 2021 17:37:20 +0100
Subject: [PATCH 2/6] syscall: add support for proc thread attribute lists
This will allow us to pass additional attributes when starting
processes.
Updates #44011.
Change-Id: I4af365c5544a6d421830f247593ec970200e5e03
---
src/syscall/syscall_windows.go | 28 ++++++++++++++++++++++++++++
src/syscall/types_windows.go | 14 ++++++++++++++
src/syscall/zsyscall_windows.go | 24 ++++++++++++++++++++++++
3 files changed, 66 insertions(+)
diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go
index ba69133d81..d892cc110d 100644
--- a/src/syscall/syscall_windows.go
+++ b/src/syscall/syscall_windows.go
@@ -284,6 +284,9 @@ func NewCallbackCDecl(fn interface{}) uintptr {
// This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
//sys CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) [failretval&0xff==0] = CreateSymbolicLinkW
//sys CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
+//sys initializeProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, attrcount uint32, flags uint32, size *uintptr) (err error) = InitializeProcThreadAttributeList
+//sys deleteProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST) = DeleteProcThreadAttributeList
+//sys updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value uintptr, size uintptr, prevvalue uintptr, returnedsize *uintptr) (err error) = UpdateProcThreadAttribute
// syscall interface implementation for other packages
@@ -1209,3 +1212,28 @@ func Readlink(path string, buf []byte) (n int, err error) {
return n, nil
}
+
+// newProcThreadAttributeList allocates new PROC_THREAD_ATTRIBUTE_LIST, with a have maximum of maxattrcount attributes.
+func newProcThreadAttributeList(maxattrcount uint32) (*_PROC_THREAD_ATTRIBUTE_LIST, error) {
+ var size uintptr
+ err := initializeProcThreadAttributeList(nil, maxattrcount, 0, &size)
+ if err != ERROR_INSUFFICIENT_BUFFER {
+ if err == nil {
+ return nil, errorspkg.New("InitializeProcThreadAttributeList returned no error")
+ }
+ return nil, err
+ }
+ al := (*_PROC_THREAD_ATTRIBUTE_LIST)(unsafe.Pointer(&make([]byte, size)[0]))
+ runtime.SetFinalizer(al, func(al *_PROC_THREAD_ATTRIBUTE_LIST) {
+ deleteProcThreadAttributeList(al)
+ })
+ err = initializeProcThreadAttributeList(al, maxattrcount, 0, &size)
+ if err != nil {
+ return nil, err
+ }
+ return al, err
+}
+
+func (al *_PROC_THREAD_ATTRIBUTE_LIST) Add(attribute uintptr, value unsafe.Pointer, size uintptr) error {
+ return updateProcThreadAttribute(al, 0, attribute, uintptr(value), size, 0, nil)
+}
diff --git a/src/syscall/types_windows.go b/src/syscall/types_windows.go
index 0349f3b180..59231bdb83 100644
--- a/src/syscall/types_windows.go
+++ b/src/syscall/types_windows.go
@@ -482,6 +482,20 @@ type StartupInfo struct {
StdErr Handle
}
+type _PROC_THREAD_ATTRIBUTE_LIST [1]byte
+
+const (
+ _PROC_THREAD_ATTRIBUTE_PARENT_PROCESS = 0x00020000
+ _PROC_THREAD_ATTRIBUTE_HANDLE_LIST = 0x00020002
+)
+
+type _STARTUPINFOEXW struct {
+ StartupInfo
+ ProcThreadAttributeList *_PROC_THREAD_ATTRIBUTE_LIST
+}
+
+const _EXTENDED_STARTUPINFO_PRESENT = 0x00080000
+
type ProcessInformation struct {
Process Handle
Thread Handle
diff --git a/src/syscall/zsyscall_windows.go b/src/syscall/zsyscall_windows.go
index 2166be595b..db9e6e10ea 100644
--- a/src/syscall/zsyscall_windows.go
+++ b/src/syscall/zsyscall_windows.go
@@ -93,6 +93,7 @@ var (
procCreateSymbolicLinkW = modkernel32.NewProc("CreateSymbolicLinkW")
procCreateToolhelp32Snapshot = modkernel32.NewProc("CreateToolhelp32Snapshot")
procDeleteFileW = modkernel32.NewProc("DeleteFileW")
+ procDeleteProcThreadAttributeList = modkernel32.NewProc("DeleteProcThreadAttributeList")
procDeviceIoControl = modkernel32.NewProc("DeviceIoControl")
procDuplicateHandle = modkernel32.NewProc("DuplicateHandle")
procExitProcess = modkernel32.NewProc("ExitProcess")
@@ -131,6 +132,7 @@ var (
procGetTempPathW = modkernel32.NewProc("GetTempPathW")
procGetTimeZoneInformation = modkernel32.NewProc("GetTimeZoneInformation")
procGetVersion = modkernel32.NewProc("GetVersion")
+ procInitializeProcThreadAttributeList = modkernel32.NewProc("InitializeProcThreadAttributeList")
procLoadLibraryW = modkernel32.NewProc("LoadLibraryW")
procLocalFree = modkernel32.NewProc("LocalFree")
procMapViewOfFile = modkernel32.NewProc("MapViewOfFile")
@@ -153,6 +155,7 @@ var (
procSetHandleInformation = modkernel32.NewProc("SetHandleInformation")
procTerminateProcess = modkernel32.NewProc("TerminateProcess")
procUnmapViewOfFile = modkernel32.NewProc("UnmapViewOfFile")
+ procUpdateProcThreadAttribute = modkernel32.NewProc("UpdateProcThreadAttribute")
procVirtualLock = modkernel32.NewProc("VirtualLock")
procVirtualUnlock = modkernel32.NewProc("VirtualUnlock")
procWaitForSingleObject = modkernel32.NewProc("WaitForSingleObject")
@@ -569,6 +572,11 @@ func DeleteFile(path *uint16) (err error) {
return
}
+func deleteProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST) {
+ Syscall(procDeleteProcThreadAttributeList.Addr(), 1, uintptr(unsafe.Pointer(attrlist)), 0, 0)
+ return
+}
+
func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error) {
r1, _, e1 := Syscall9(procDeviceIoControl.Addr(), 8, uintptr(handle), uintptr(ioControlCode), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferSize), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferSize), uintptr(unsafe.Pointer(bytesReturned)), uintptr(unsafe.Pointer(overlapped)), 0)
if r1 == 0 {
@@ -897,6 +905,14 @@ func GetVersion() (ver uint32, err error) {
return
}
+func initializeProcThreadAttributeList(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, attrcount uint32, flags uint32, size *uintptr) (err error) {
+ r1, _, e1 := Syscall6(procInitializeProcThreadAttributeList.Addr(), 4, uintptr(unsafe.Pointer(attrlist)), uintptr(attrcount), uintptr(flags), uintptr(unsafe.Pointer(size)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func LoadLibrary(libname string) (handle Handle, err error) {
var _p0 *uint16
_p0, err = UTF16PtrFromString(libname)
@@ -1099,6 +1115,14 @@ func UnmapViewOfFile(addr uintptr) (err error) {
return
}
+func updateProcThreadAttribute(attrlist *_PROC_THREAD_ATTRIBUTE_LIST, flags uint32, attr uintptr, value uintptr, size uintptr, prevvalue uintptr, returnedsize *uintptr) (err error) {
+ r1, _, e1 := Syscall9(procUpdateProcThreadAttribute.Addr(), 7, uintptr(unsafe.Pointer(attrlist)), uintptr(flags), uintptr(attr), uintptr(value), uintptr(size), uintptr(prevvalue), uintptr(unsafe.Pointer(returnedsize)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
func VirtualLock(addr uintptr, length uintptr) (err error) {
r1, _, e1 := Syscall(procVirtualLock.Addr(), 2, uintptr(addr), uintptr(length), 0)
if r1 == 0 {
--
2.30.0
|
