kernel32.dll: GlobalSize/VirtualLock/VirtualUnlock

win32/dll/kernel32/src/builtin.rs

@@ -3324,6 +3324,29 @@ mod wrappers {
             result.into()
         }
     }
+    pub unsafe fn GlobalSize(sys: &mut dyn System, stack_args: u32) -> ABIReturn {
+        use kernel32::memory::*;
+        unsafe {
+            let mem = sys.mem().detach();
+            let hMem = <u32>::from_stack(mem, stack_args + 0u32);
+            let __trace_record = if trace::enabled("kernel32/memory") {
+                trace::Record::new(
+                    kernel32::memory::GlobalSize_pos,
+                    "kernel32/memory",
+                    "GlobalSize",
+                    &[("hMem", &hMem)],
+                )
+                .enter()
+            } else {
+                None
+            };
+            let result = kernel32::memory::GlobalSize(sys, hMem);
+            if let Some(mut __trace_record) = __trace_record {
+                __trace_record.exit(&result);
+            }
+            result.into()
+        }
+    }
     pub unsafe fn GlobalUnlock(sys: &mut dyn System, stack_args: u32) -> ABIReturn {
         use kernel32::memory::*;
         unsafe {
@@ -6038,6 +6061,30 @@ mod wrappers {
             result.into()
         }
     }
+    pub unsafe fn VirtualLock(sys: &mut dyn System, stack_args: u32) -> ABIReturn {
+        use kernel32::memory::*;
+        unsafe {
+            let mem = sys.mem().detach();
+            let lpAddress = <u32>::from_stack(mem, stack_args + 0u32);
+            let dwSize = <u32>::from_stack(mem, stack_args + 4u32);
+            let __trace_record = if trace::enabled("kernel32/memory") {
+                trace::Record::new(
+                    kernel32::memory::VirtualLock_pos,
+                    "kernel32/memory",
+                    "VirtualLock",
+                    &[("lpAddress", &lpAddress), ("dwSize", &dwSize)],
+                )
+                .enter()
+            } else {
+                None
+            };
+            let result = kernel32::memory::VirtualLock(sys, lpAddress, dwSize);
+            if let Some(mut __trace_record) = __trace_record {
+                __trace_record.exit(&result);
+            }
+            result.into()
+        }
+    }
     pub unsafe fn VirtualProtect(sys: &mut dyn System, stack_args: u32) -> ABIReturn {
         use kernel32::memory::*;
         unsafe {
@@ -6105,6 +6152,30 @@ mod wrappers {
             result.into()
         }
     }
+    pub unsafe fn VirtualUnlock(sys: &mut dyn System, stack_args: u32) -> ABIReturn {
+        use kernel32::memory::*;
+        unsafe {
+            let mem = sys.mem().detach();
+            let lpAddress = <u32>::from_stack(mem, stack_args + 0u32);
+            let dwSize = <u32>::from_stack(mem, stack_args + 4u32);
+            let __trace_record = if trace::enabled("kernel32/memory") {
+                trace::Record::new(
+                    kernel32::memory::VirtualUnlock_pos,
+                    "kernel32/memory",
+                    "VirtualUnlock",
+                    &[("lpAddress", &lpAddress), ("dwSize", &dwSize)],
+                )
+                .enter()
+            } else {
+                None
+            };
+            let result = kernel32::memory::VirtualUnlock(sys, lpAddress, dwSize);
+            if let Some(mut __trace_record) = __trace_record {
+                __trace_record.exit(&result);
+            }
+            result.into()
+        }
+    }
     pub unsafe fn WaitForMultipleObjects(
         sys: &mut dyn System,
         stack_args: u32,
@@ -6785,7 +6856,7 @@ mod wrappers {
         }
     }
 }
-const SHIMS: [Shim; 245usize] = [
+const SHIMS: [Shim; 248usize] = [
     Shim {
         name: "AcquireSRWLockExclusive",
         func: Handler::Sync(wrappers::AcquireSRWLockExclusive),
@@ -7266,6 +7337,10 @@ const SHIMS: [Shim; 245usize] = [
         name: "GlobalReAlloc",
         func: Handler::Sync(wrappers::GlobalReAlloc),
     },
+    Shim {
+        name: "GlobalSize",
+        func: Handler::Sync(wrappers::GlobalSize),
+    },
     Shim {
         name: "GlobalUnlock",
         func: Handler::Sync(wrappers::GlobalUnlock),
@@ -7666,6 +7741,10 @@ const SHIMS: [Shim; 245usize] = [
         name: "VirtualFree",
         func: Handler::Sync(wrappers::VirtualFree),
     },
+    Shim {
+        name: "VirtualLock",
+        func: Handler::Sync(wrappers::VirtualLock),
+    },
     Shim {
         name: "VirtualProtect",
         func: Handler::Sync(wrappers::VirtualProtect),
@@ -7674,6 +7753,10 @@ const SHIMS: [Shim; 245usize] = [
         name: "VirtualQuery",
         func: Handler::Sync(wrappers::VirtualQuery),
     },
+    Shim {
+        name: "VirtualUnlock",
+        func: Handler::Sync(wrappers::VirtualUnlock),
+    },
     Shim {
         name: "WaitForMultipleObjects",
         func: Handler::Async(wrappers::WaitForMultipleObjects),

win32/dll/kernel32/src/memory.rs

@@ -358,6 +358,12 @@ pub fn GlobalFree(sys: &dyn System, hMem: u32) -> u32 {
     free(sys, hMem)
 }
 
+#[win32_derive::dllexport]
+pub fn GlobalSize(sys: &dyn System, hMem: u32) -> u32 {
+    let memory = sys.memory();
+    memory.process_heap.size(memory.mem(), hMem)
+}
+
 #[win32_derive::dllexport]
 pub fn GlobalFlags(sys: &dyn System, hMem: u32) -> u32 {
     0 // stub
@@ -385,6 +391,16 @@ pub fn VirtualProtect(
     true // success
 }
 
+#[win32_derive::dllexport]
+pub fn VirtualLock(sys: &dyn System, lpAddress: u32, dwSize: u32) -> bool {
+    true // success
+}
+
+#[win32_derive::dllexport]
+pub fn VirtualUnlock(sys: &dyn System, lpAddress: u32, dwSize: u32) -> bool {
+    true // success
+}
+
 #[win32_derive::dllexport]
 pub fn GetProcessHeap(sys: &dyn System) -> u32 {
     sys.memory().process_heap.addr