Trait winsafe::prelude::kernel_Hheap
source · pub trait kernel_Hheap: Handle {
// Provided methods
fn GetProcessHeap() -> SysResult<HHEAP> { ... }
fn GetProcessHeaps() -> SysResult<Vec<HHEAP>> { ... }
fn HeapCreate(
options: Option<HEAP_CREATE>,
initial_size: usize,
maximum_size: usize
) -> SysResult<HeapDestroyGuard> { ... }
fn HeapAlloc(
&self,
flags: Option<HEAP_ALLOC>,
num_bytes: usize
) -> SysResult<HeapFreeGuard<'_, Self>> { ... }
fn HeapCompact(&self, flags: Option<HEAP_SIZE>) -> SysResult<usize> { ... }
fn HeapLock(&self) -> SysResult<HeapUnlockGuard<'_, Self>> { ... }
fn HeapReAlloc<'a>(
&'a self,
flags: Option<HEAP_REALLOC>,
mem: &mut HeapFreeGuard<'a, Self>,
num_bytes: usize
) -> SysResult<()> { ... }
fn HeapSetInformation(
&self,
information_class: HEAP_INFORMATION,
information: Option<&[u8]>
) -> SysResult<()> { ... }
fn HeapSize(
&self,
flags: Option<HEAP_SIZE>,
mem: &HeapFreeGuard<'_, Self>
) -> SysResult<usize> { ... }
fn HeapValidate(
&self,
flags: Option<HEAP_SIZE>,
mem: Option<&HeapFreeGuard<'_, Self>>
) -> bool { ... }
fn HeapWalk(
&self
) -> impl Iterator<Item = SysResult<&PROCESS_HEAP_ENTRY>> + '_ { ... }
}
kernel
only.Expand description
This trait is enabled with the kernel
feature, and provides methods for
HHEAP
.
Prefer importing this trait through the prelude:
use winsafe::prelude::*;
Provided Methods§
sourcefn GetProcessHeap() -> SysResult<HHEAP>
fn GetProcessHeap() -> SysResult<HHEAP>
GetProcessHeap
function.
sourcefn GetProcessHeaps() -> SysResult<Vec<HHEAP>>
fn GetProcessHeaps() -> SysResult<Vec<HHEAP>>
GetProcessHeaps
function.
sourcefn HeapCreate(
options: Option<HEAP_CREATE>,
initial_size: usize,
maximum_size: usize
) -> SysResult<HeapDestroyGuard>
fn HeapCreate( options: Option<HEAP_CREATE>, initial_size: usize, maximum_size: usize ) -> SysResult<HeapDestroyGuard>
HeapCreate
function.
sourcefn HeapAlloc(
&self,
flags: Option<HEAP_ALLOC>,
num_bytes: usize
) -> SysResult<HeapFreeGuard<'_, Self>>
fn HeapAlloc( &self, flags: Option<HEAP_ALLOC>, num_bytes: usize ) -> SysResult<HeapFreeGuard<'_, Self>>
HeapAlloc
function.
§Examples
use winsafe::{self as w, prelude::*, co};
let heap = w::HHEAP::GetProcessHeap()?;
let mut block = heap.HeapAlloc(Some(co::HEAP_ALLOC::ZERO_MEMORY), 40)?;
block.as_mut_slice()[0] = 10;
block.as_mut_slice()[1] = 12;
for byte in block.as_slice().iter() {
println!("{} ", byte);
}
// HeapFree() automatically called
sourcefn HeapCompact(&self, flags: Option<HEAP_SIZE>) -> SysResult<usize>
fn HeapCompact(&self, flags: Option<HEAP_SIZE>) -> SysResult<usize>
HeapCompact
function.
sourcefn HeapLock(&self) -> SysResult<HeapUnlockGuard<'_, Self>>
fn HeapLock(&self) -> SysResult<HeapUnlockGuard<'_, Self>>
HeapLock
function.
You only need to call this method if the HHEAP
was
created with
co::HEAP_CREATE::NO_SERIALIZE
.
Otherwise, the heap is already protected against concurrent thread
access.
In the original C implementation, you must call
HeapUnlock
as a cleanup operation; here, the cleanup is performed automatically,
because HeapLock
returns a
HeapUnlockGuard
, which automatically
calls HeapUnlock
when the guard goes out of scope. You must, however,
keep the guard alive, otherwise the cleanup will be performed right
away.
§Examples
use winsafe::{self as w, prelude::*, co};
let heap = w::HHEAP::HeapCreate(
Some(co::HEAP_CREATE::NO_SERIALIZE), 0, 0)?;
let _lock = heap.HeapLock()?;
// heap operations...
// HeapUnlock() automatically called
// HeapDestroy() automatically called
sourcefn HeapReAlloc<'a>(
&'a self,
flags: Option<HEAP_REALLOC>,
mem: &mut HeapFreeGuard<'a, Self>,
num_bytes: usize
) -> SysResult<()>
fn HeapReAlloc<'a>( &'a self, flags: Option<HEAP_REALLOC>, mem: &mut HeapFreeGuard<'a, Self>, num_bytes: usize ) -> SysResult<()>
HeapReAlloc
function.
Originally this method returns the handle to the reallocated memory
object; here the original handle, present inside
HeapFreeGuard
, is automatically
updated.
§Examples
use winsafe::{self as w, prelude::*, co};
let heap = w::HHEAP::GetProcessHeap()?;
let mut array = heap.HeapAlloc(Some(co::HEAP_ALLOC::ZERO_MEMORY), 40)?;
heap.HeapReAlloc(Some(co::HEAP_REALLOC::ZERO_MEMORY), &mut array, 65)?;
// HeapFree() automatically called
sourcefn HeapSetInformation(
&self,
information_class: HEAP_INFORMATION,
information: Option<&[u8]>
) -> SysResult<()>
fn HeapSetInformation( &self, information_class: HEAP_INFORMATION, information: Option<&[u8]> ) -> SysResult<()>
HeapSetInformation
function.
sourcefn HeapSize(
&self,
flags: Option<HEAP_SIZE>,
mem: &HeapFreeGuard<'_, Self>
) -> SysResult<usize>
fn HeapSize( &self, flags: Option<HEAP_SIZE>, mem: &HeapFreeGuard<'_, Self> ) -> SysResult<usize>
HeapSize
function.
sourcefn HeapValidate(
&self,
flags: Option<HEAP_SIZE>,
mem: Option<&HeapFreeGuard<'_, Self>>
) -> bool
fn HeapValidate( &self, flags: Option<HEAP_SIZE>, mem: Option<&HeapFreeGuard<'_, Self>> ) -> bool
HeapValidate
function.
§Examples
use winsafe::{self as w, prelude::*, co};
let heap = w::HHEAP::GetProcessHeap()?;
let mut array = heap.HeapAlloc(Some(co::HEAP_ALLOC::ZERO_MEMORY), 40)?;
let is_ok = heap.HeapValidate(None, Some(&array));
// HeapFree() automatically called
sourcefn HeapWalk(&self) -> impl Iterator<Item = SysResult<&PROCESS_HEAP_ENTRY>> + '_
fn HeapWalk(&self) -> impl Iterator<Item = SysResult<&PROCESS_HEAP_ENTRY>> + '_
HeapWalk
function.
Returns an iterator over the heap memory blocks, exposing
PROCESS_HEAP_ENTRY
structs.
§Examples
use winsafe::{self as w, prelude::*, co};
let heap = w::HHEAP::GetProcessHeap()?;
for block in heap.HeapWalk() {
let block = block?;
println!("Size: {}, overhead? {}",
block.cbData, block.cbOverhead);
}