void
XixFsdFreeCCB(
PXIFS_CCB pCCB
)
{
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_CCB),
("Enter XixFsdFreeCCB (%p)\n",pCCB));
ASSERT(pCCB);
if(pCCB->SearchExpression.Buffer != NULL){
ExFreePool(pCCB->SearchExpression.Buffer);
}
/*
if(pCCB->FullPath.Buffer != NULL){
ExFreePool(pCCB->FullPath.Buffer);
}
*/
// give back memory either to the zone or to the VMM
if (!(pCCB->CCBFlags& XIFSD_CCB_NOT_FROM_POOL)) {
ExFreeToNPagedLookasideList(&(XifsCcbLookasideList),pCCB);
} else {
ExFreePool(pCCB);
}
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_CCB),
("Exit XixFsdFreeCCB \n"));
return;
}
NTSTATUS Notification_Recieve(NOTIFICATION_QUEUE *queue, PIRP irp) {
PIO_STACK_LOCATION irpstack = IoGetCurrentIrpStackLocation(irp);
KIRQL irq;
if(irpstack->Parameters.DeviceIoControl.OutputBufferLength != sizeof(PGNOTIFICATION)) {
irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
irp->IoStatus.Information = 0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_BUFFER_TOO_SMALL;
}
KeAcquireSpinLock(&queue->lock, &irq);
if(IsListEmpty(&queue->notification_list)) {
PGIRPNODE *irpnode;
KIRQL crirq;
irpnode = ExAllocateFromNPagedLookasideList(&queue->lookaside);
InitializeListHead(&irpnode->entry);
irpnode->irp = irp;
//irp->Tail.Overlay.DriverContext[0] = irpnode;
InsertTailList(&queue->irp_list, &irpnode->entry);
IoMarkIrpPending(irp);
IoAcquireCancelSpinLock(&crirq);
#pragma warning(push)
#pragma warning(disable:4311 4312)
//IoSetCancelRoutine generates warnings in 32-bit due to silly macroisms.
IoSetCancelRoutine(irp, Notification_OnCancel);
#pragma warning(pop)
IoReleaseCancelSpinLock(crirq);
KeReleaseSpinLock(&queue->lock, irq);
return STATUS_PENDING;
}
else {
PGNOTIFYNODE *notifynode = (PGNOTIFYNODE*)RemoveHeadList(&queue->notification_list);
PGNOTIFICATION *notification = irp->AssociatedIrp.SystemBuffer;
RtlCopyMemory(notification, ¬ifynode->notification, sizeof(PGNOTIFICATION));
ExFreeToNPagedLookasideList(&queue->lookaside, notifynode);
--queue->queued;
KeReleaseSpinLock(&queue->lock, irq);
irp->IoStatus.Status = STATUS_SUCCESS;
irp->IoStatus.Information = sizeof(PGNOTIFICATION);
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
}
VOID
SpyFreeBuffer (
_In_ PVOID Buffer
)
/*++
Routine Description:
Free an allocate buffer.
NOTE: This code must be NON-PAGED because it can be called on the
paging path or at DPC level.
Arguments:
Buffer - The buffer to free.
Return Value:
None.
--*/
{
//
// Free the memory, update the counter
//
InterlockedDecrement( &MiniSpyData.RecordsAllocated );
ExFreeToNPagedLookasideList( &MiniSpyData.FreeBufferList, Buffer );
}
static void Notification_OnCancel(PDEVICE_OBJECT device, PIRP irp)
{
KIRQL irq;
NOTIFICATION_QUEUE *queue = &((PGINTERNAL*)device->DeviceExtension)->queue;
LIST_ENTRY *iter;
int found = 0;
DbgPrint("Canceling IRP...\n");
KeAcquireSpinLock(&queue->lock, &irq);
for(iter = queue->irp_list.Flink; iter != &queue->irp_list; iter = iter->Flink) {
PGIRPNODE *irpnode = (PGIRPNODE*)iter;
if(irpnode->irp == irp) {
RemoveEntryList(iter);
ExFreeToNPagedLookasideList(&queue->lookaside, irpnode);
found = 1;
break;
}
}
KeReleaseSpinLock(&queue->lock, irq);
// if it wasn't found, it has already been dequeued and handled.
if(found) {
DbgPrint("IRP found, completing.\n");
irp->IoStatus.Status = STATUS_CANCELLED;
irp->IoStatus.Information = 0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
IoReleaseCancelSpinLock(irp->CancelIrql);
}
BOOLEAN SymRemoveSymbol(IN PCHAR pszSymbolName)
{
ASSERTMSG("Passed symbol name is NULL", pszSymbolName != NULL);
ASSERTMSG("SymbolEngine must be initialized prior to this call", bIsSymEngineInitialized == TRUE);
// try to find the symbol to remove
PSYMBOL_ENTRY pSymbolEntry = SympFindSymbol(pszSymbolName);
// if symbol not found, return NULL
if(pSymbolEntry == NULL)
{
return FALSE;
}
// symbol found, so we remove it from the list...
ASSERTMSG("Fast mutex acquire must occur at or below APC_LEVEL", KeGetCurrentIrql() <= APC_LEVEL);
ExAcquireFastMutex(&SymbolsListMutex);
RemoveEntryList(&pSymbolEntry->ListEntry);
// decrease symbol count (do it inside guarded block!)
--uSymbolCount;
// and free allocated memory
ExFreeToNPagedLookasideList(&SymbolsLookasideList, pSymbolEntry);
ASSERTMSG("Fast mutex release must occur at APC_LEVEL", KeGetCurrentIrql() == APC_LEVEL);
ExReleaseFastMutex(&SymbolsListMutex);
return TRUE;
}
__drv_mustHoldCriticalRegion
VOID
FFSFreeCcb(
IN PFFS_CCB Ccb)
{
PAGED_CODE();
ASSERT(Ccb != NULL);
ASSERT((Ccb->Identifier.Type == FFSCCB) &&
(Ccb->Identifier.Size == sizeof(FFS_CCB)));
if (Ccb->DirectorySearchPattern.Buffer != NULL)
{
ExFreePool(Ccb->DirectorySearchPattern.Buffer);
}
if (FlagOn(Ccb->Flags, CCB_FROM_POOL))
{
ExFreePool(Ccb);
}
else
{
ExAcquireResourceExclusiveLite(
&FFSGlobal->LAResource,
TRUE);
ExFreeToNPagedLookasideList(&(FFSGlobal->FFSCcbLookasideList), Ccb);
ExReleaseResourceForThreadLite(
&FFSGlobal->LAResource,
ExGetCurrentResourceThread());
}
}
char
SORAAPI
remove_thread_safe_enlist_head(struct thread_safe_enlist* tslist,
void** data,
char lock) {
KIRQL irql;
acquire_spinlock(lock,
tslist->m_sync,
irql);
if (IsListEmpty(&tslist->m_head.m_entry)) {
release_spinlock(lock,
tslist->m_sync,
irql);
return false;
}
struct LIST_ENTRY_EX* entry;
entry = (LIST_ENTRY_EX*)RemoveHeadList(&tslist->m_head.m_entry);
*data = entry->m_value;
ExFreeToNPagedLookasideList(&tslist->m_lookaside,
entry);
InterlockedDecrement(&tslist->m_count);
release_spinlock(lock,
tslist->m_sync,
irql);
return true;
}
void DestroyNotificationQueue(NOTIFICATION_QUEUE *queue) {
while(!IsListEmpty(&queue->notification_list)) {
PGNOTIFYNODE *notifynode = (PGNOTIFYNODE*)RemoveHeadList(&queue->notification_list);
ExFreeToNPagedLookasideList(&queue->lookaside, notifynode);
}
while(!IsListEmpty(&queue->irp_list)) {
PGIRPNODE *irpnode = (PGIRPNODE*)RemoveHeadList(&queue->irp_list);
irpnode->irp->IoStatus.Status = STATUS_CANCELLED;
irpnode->irp->IoStatus.Information = 0;
IoCompleteRequest(irpnode->irp, IO_NO_INCREMENT);
ExFreeToNPagedLookasideList(&queue->lookaside, irpnode);
}
ExDeleteNPagedLookasideList(&queue->lookaside);
}
VOID
NtfsDestroyFCB(PNTFS_FCB Fcb)
{
ASSERT(Fcb);
ASSERT(Fcb->Identifier.Type == NTFS_TYPE_FCB);
ExDeleteResourceLite(&Fcb->MainResource);
ExFreeToNPagedLookasideList(&NtfsGlobalData->FcbLookasideList, Fcb);
}
/*
* @implemented
*/
VOID
NTAPI
FsRtlUninitializeLargeMcb(IN PLARGE_MCB Mcb)
{
if (Mcb->GuardedMutex)
{
ExFreeToNPagedLookasideList(&FsRtlFastMutexLookasideList,
Mcb->GuardedMutex);
FsRtlUninitializeBaseMcb(&(Mcb->BaseMcb));
}
}
INLINE
VOID
LfsFreeNonPagedFcb (
PNON_PAGED_FCB NonPagedFcb
)
{
#if FAT_FILL_FREE
RtlFillMemoryUlong(NonPagedFcb, sizeof(NON_PAGED_FCB), FAT_FILL_FREE);
#endif
ExFreeToNPagedLookasideList( &GlobalLfs.NonPagedFcbLookasideList, (PVOID) NonPagedFcb );
}
INLINE
VOID
LfsFreeResource (
IN PERESOURCE Resource
)
{
ExDeleteResourceLite( Resource );
#if FAT_FILL_FREE
RtlFillMemoryUlong(Resource, sizeof(ERESOURCE), FAT_FILL_FREE);
#endif
ExFreeToNPagedLookasideList( &GlobalLfs.EResourceLookasideList, (PVOID) Resource );
}
void mm_free(void *mem)
{
alloc_block *block = CONTAINING_RECORD(mem, alloc_block, data); /* get the alloc_block struct */
char *p_mem = (block->flags & MEM_PADDED) ? p8(block) - 8 : p8(block); /* get the original memory pointer */
/* zero block to prevent leaks if needed */
if (block->flags & MEM_SECURE) burn(block->data, block->size);
/* free memory */
if (block->flags & MEM_FAST) {
ExFreeToNPagedLookasideList(&mem_lists[block->index], p_mem);
} else {
ExFreePoolWithTag(p_mem, '1_cd');
}
}
void kmem_cache_free (kmem_cache_t *cachep, void *objp)
{
if (cachep->dtor != NULL) cachep->dtor(objp, cachep, 0); // 0 might be wrong --sadyc
#ifdef USE_NONPAGED_MEMORY
ExFreeToNPagedLookasideList(&cachep->lookaside, objp);
#else
ExFreeToPagedLookasideList(&cachep->lookaside, objp);
#endif
#if DBG
cachep->objects_allocated--;
printk("kmem_cache: %s: objects: %d [-]\n", cachep->name, cachep->objects_allocated);
#endif
}
void DestroyTable(PHASHTABLE pHashTable)
{
PTWOWAY pNode = NULL;
PTWOWAY pTmpNode = NULL;
PLIST_ENTRY pListHead = NULL;
PLIST_ENTRY pListLink = NULL;
unsigned int i;
for (i = 0; i < pHashTable->tableSize; i++)
{
pListHead = pListLink = pHashTable->pListHeads[i];
if (pListHead == NULL)
{
DbgPrint("pListHead is NULL!\n");
continue;
}
if (!IsListEmpty(pListHead))
{
do
{
pNode = CONTAINING_RECORD(pListLink, TWOWAY, linkfield);
pListLink = pListLink->Flink;
ExFreeToNPagedLookasideList(pLookasideList_TWOWAY, pNode);
} while (pListLink != pListHead);
}
else
{
pNode = CONTAINING_RECORD(pListHead, TWOWAY, linkfield);
ExFreeToNPagedLookasideList(pLookasideList_TWOWAY, pNode);
}
}
ExDeleteNPagedLookasideList(pLookasideList_TWOWAY);
ExFreePoolWithTag(pLookasideList_TWOWAY, DRIVERTAG1);
ExFreePoolWithTag(pHashTable->pListHeads, DRIVERTAG1);
ExFreePoolWithTag(pHashTable, DRIVERTAG1);
}
void Remove(DWORD key, PHASHTABLE pHashTable)
{
PTWOWAY pNode = NULL;
PLIST_ENTRY pListHead = NULL;
pNode = Find(key, pHashTable);
// The node with the given key was found.
if (pNode != NULL)
{
#ifdef MY_DEBUG
DbgPrint("REMOVE: thread ID = 0x%x process ID = 0x%x image = %s\n", pNode->data.threadID, pNode->data.processID, pNode->data.imageName);
#endif
RemoveEntryList(&pNode->linkfield);
ExFreeToNPagedLookasideList(pLookasideList_TWOWAY, pNode);
}
}
NTSTATUS
MyCompletionRoutine(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context
)
{
NTSTATUS status;
UCHAR Control;
PMYCONTEXT MyContext;
PIO_COMPLETION_ROUTINE CompletionRoutine;
MyContext = (PMYCONTEXT)Context;
Control = MyContext->Control;
Context = MyContext->Context;
CompletionRoutine = MyContext->CompletionRoutine;
ExFreeToNPagedLookasideList(&ContextLookaside, MyContext);
status = Irp->IoStatus.Status;
if( NT_SUCCESS(status) )
{
if(Control & SL_INVOKE_ON_SUCCESS)
{
return CompletionRoutine(DeviceObject, Irp, Context);
}
}
else if(status == STATUS_CANCELLED)
{
if(Control & SL_INVOKE_ON_CANCEL)
{
return CompletionRoutine(DeviceObject, Irp, Context);
}
}
else
{
if(Control & SL_INVOKE_ON_ERROR)
{
return CompletionRoutine(DeviceObject, Irp, Context);
}
}
return status;
}
/* KphpProtectRemoveEntry
*
* Removes and frees process protection data.
*
* Thread safety: Full
* IRQL: <= DISPATCH_LEVEL
*/
VOID KphpProtectRemoveEntry(
__in PKPH_PROCESS_ENTRY Entry
)
{
KIRQL oldIrql;
KeAcquireSpinLock(&ProtectedProcessListLock, &oldIrql);
RemoveEntryList(&Entry->ListEntry);
/* Prevent the lookaside list from being destroyed. */
ExAcquireRundownProtection(&ProtectedProcessRundownProtect);
ExFreeToNPagedLookasideList(
&ProtectedProcessLookasideList,
Entry
);
ExReleaseRundownProtection(&ProtectedProcessRundownProtect);
KeReleaseSpinLock(&ProtectedProcessListLock, oldIrql);
}
void complete_pending_irp(PPDO_DEVICE_DATA pdodata)
{
PIRP irp;
struct urb_req * urb_r;
PLIST_ENTRY le;
KIRQL oldirql;
int count=0;
LARGE_INTEGER interval;
//FIXME
KdPrint(("finish pending irp\n"));
KeRaiseIrql(DISPATCH_LEVEL, &oldirql);
do {
irp=NULL;
le=NULL;
KeAcquireSpinLockAtDpcLevel(&pdodata->q_lock);
if (!IsListEmpty(&pdodata->ioctl_q))
le = RemoveHeadList(&pdodata->ioctl_q);
if(le){
urb_r = CONTAINING_RECORD(le, struct urb_req, list);
/* FIMXE event */
irp = urb_r->irp;
}
if(irp==NULL){
KeReleaseSpinLock(&pdodata->q_lock, oldirql);
break;
}
if(count>2){
KeReleaseSpinLock(&pdodata->q_lock, oldirql);
KdPrint(("sleep 50ms, let pnp manager send irp"));
interval.QuadPart=-500000;
KeDelayExecutionThread(KernelMode, FALSE, &interval);
KeRaiseIrql(DISPATCH_LEVEL, &oldirql);
} else {
KeReleaseSpinLock(&pdodata->q_lock, DISPATCH_LEVEL);
}
ExFreeToNPagedLookasideList(&g_lookaside, urb_r);
irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED;
IoSetCancelRoutine(irp, NULL);
IoCompleteRequest (irp, IO_NO_INCREMENT);
count++;
}while(1);
}
void Notification_Send(NOTIFICATION_QUEUE *queue, const PBNOTIFICATION *notification)
{
KIRQL irq;
KeAcquireSpinLock(&queue->lock, &irq);
if(IsListEmpty(&queue->irp_list))
{
if(queue->queued < 64)
{
PBNOTIFYNODE *notifynode;
notifynode = ExAllocateFromNPagedLookasideList(&queue->lookaside);
InitializeListHead(¬ifynode->entry);
RtlCopyMemory(¬ifynode->notification, notification, sizeof(PBNOTIFICATION));
InsertTailList(&queue->notification_list, ¬ifynode->entry);
++queue->queued;
}
KeReleaseSpinLock(&queue->lock, irq);
}
else
{
PBIRPNODE *irpnode = (PBIRPNODE*)RemoveHeadList(&queue->irp_list);
PBNOTIFICATION *irpnotification = irpnode->irp->AssociatedIrp.SystemBuffer;
PIRP irp;
RtlCopyMemory(irpnotification, notification, sizeof(PBNOTIFICATION));
irp = irpnode->irp;
ExFreeToNPagedLookasideList(&queue->lookaside, irpnode);
KeReleaseSpinLock(&queue->lock, irq);
irp->IoStatus.Status = STATUS_SUCCESS;
irp->IoStatus.Information = sizeof(PBNOTIFICATION);
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
}
//
// Complete the history list.
//
NTSTATUS
CImageHardwareSimulation::
CompleteCloneList()
{
PAGED_CODE();
int i = 0;
while(!IsListEmpty(&m_BurstList))
{
LIST_ENTRY *listEntry = RemoveHeadList(&m_BurstList);
PSCATTER_GATHER_ENTRY SGEntry =
reinterpret_cast <PSCATTER_GATHER_ENTRY> (
CONTAINING_RECORD (
listEntry,
SCATTER_GATHER_ENTRY,
ListEntry
)
);
m_pClone = SGEntry->CloneEntry;
m_PhotoConfirmationInfo = SGEntry->PhotoConfirmationInfo;
m_NumMappingsCompleted++;
m_ScatterGatherBytesQueued -= SGEntry -> ByteCount;
DBG_TRACE( "m_NumMappingsCompleted=%d, m_PhotoConfirmationInfo.isRequired()=%s", m_NumMappingsCompleted, m_PhotoConfirmationInfo.isRequired( )?"TRUE":"FALSE" );
DBG_TRACE( "Frame %p, PresentationTime=0x%016llX",
SGEntry->CloneEntry->StreamHeader,
SGEntry->CloneEntry->StreamHeader->PresentationTime.Time );
m_Sensor -> Interrupt (m_PinID);
ExFreeToNPagedLookasideList (
&m_ScatterGatherLookaside,
reinterpret_cast <PVOID> (SGEntry)
);
i++;
}
return STATUS_SUCCESS;
}
__drv_mustHoldCriticalRegion
VOID
FFSFreeIrpContext(
IN PFFS_IRP_CONTEXT IrpContext)
{
PAGED_CODE();
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == FFSICX) &&
(IrpContext->Identifier.Size == sizeof(FFS_IRP_CONTEXT)));
FFSUnpinRepinnedBcbs(IrpContext);
// Return the Irp context record to the region or to pool depending on
// its flag
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_FROM_POOL))
{
IrpContext->Identifier.Type = 0;
IrpContext->Identifier.Size = 0;
ExFreePool(IrpContext);
}
else
{
IrpContext->Identifier.Type = 0;
IrpContext->Identifier.Size = 0;
ExAcquireResourceExclusiveLite(
&FFSGlobal->LAResource,
TRUE);
ExFreeToNPagedLookasideList(&(FFSGlobal->FFSIrpContextLookasideList), IrpContext);
ExReleaseResourceForThreadLite(
&FFSGlobal->LAResource,
ExGetCurrentResourceThread());
}
}
void
XixFsdReleaseIrpContext(
PXIFS_IRPCONTEXT PtrIrpContext)
{
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_IRPCONTEXT),
("Enter XixFsdReleaseIrpContext(%p)\n", PtrIrpContext));
ASSERT(PtrIrpContext);
// give back memory either to the zone or to the VMM
if (!(PtrIrpContext->IrpContextFlags & XIFSD_IRP_CONTEXT_NOT_FROM_POOL)) {
ExFreeToNPagedLookasideList(&(XifsIrpContextLookasideList),PtrIrpContext);
} else {
ExFreePool(PtrIrpContext);
}
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_IRPCONTEXT),
("Exit XixFsdReleaseIrpContext\n"));
return;
}
/*
* @implemented
*/
VOID
NTAPI
FsRtlInitializeLargeMcb(IN PLARGE_MCB Mcb,
IN POOL_TYPE PoolType)
{
Mcb->GuardedMutex = ExAllocateFromNPagedLookasideList(&FsRtlFastMutexLookasideList);
KeInitializeGuardedMutex(Mcb->GuardedMutex);
_SEH2_TRY
{
FsRtlInitializeBaseMcb(&(Mcb->BaseMcb), PoolType);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExFreeToNPagedLookasideList(&FsRtlFastMutexLookasideList,
Mcb->GuardedMutex);
Mcb->GuardedMutex = NULL;
}
_SEH2_END;
}
/*
* For packets coming from the generic adapter, netmap expects
* an mbuf with a persistent copy of the data.
* For the time being we construct a brand new mbuf and
* pass it to the handler.
* We use this routine also in a way similar to m_getcl(),
* passing a NULL pointer does not initialize the buffer (we need the length).
* We have two pools, one for the mbuf and one for the cluster.
* XXX we could do with a single allocation.
*/
struct mbuf *
win_make_mbuf(struct net_device *ifp, uint32_t length, const char *data)
{
struct mbuf *m = ExAllocateFromNPagedLookasideList(&ifp->mbuf_pool);
//DbgPrint("win_make_mbuf - Data: %p - length: %i", data, length);
if (m == NULL) {
DbgPrint("Netmap.sys: Failed to allocate memory from the mbuf!!!");
return NULL;
}
m->m_len = length;
m->pkt = ExAllocateFromNPagedLookasideList(&ifp->mbuf_packets_pool);
if (m->pkt == NULL) {
DbgPrint("Netmap.sys: Failed to allocate memory from the mbuf packet!!!");
ExFreeToNPagedLookasideList(&ifp->mbuf_pool, m);
return NULL;
}
m->dev = ifp;
if (data) // XXX otherwise zero memory ?
RtlCopyMemory(m->pkt, data, length);
return m;
}
static void dc_worker_thread(void *param)
{
SLIST_ENTRY *entry;
req_part *part;
req_item *item;
const char *in;
char *out;
u64 offset;
u32 length;
do
{
KeWaitForSingleObject(&pool_signal_event, Executive, KernelMode, FALSE, NULL);
KeClearEvent(&pool_signal_event);
while (entry = ExInterlockedPopEntrySList(&pool_head, &pool_lock))
{
part = CONTAINING_RECORD(entry, req_part, entry);
item = part->item;
in = item->in + part->offset;
out = item->out + part->offset;
offset = item->offset + part->offset;
length = part->length;
if (item->is_encrypt != 0) {
xts_encrypt(in, out, length, offset, item->key);
} else {
xts_decrypt(in, out, length, offset, item->key);
}
if (lock_xchg_add(&item->length, 0-length) == length)
{
item->on_complete(item->param1, item->param2);
ExFreeToNPagedLookasideList(&pool_req_mem, item);
}
}
} while (pool_enabled != 0);
PsTerminateSystemThread(STATUS_SUCCESS);
}
void
XixFsdFreeLCB(
PXIFS_LCB pLCB
)
{
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_LCB),
("Enter XixFsdFreeLCB \n"));
ASSERT(pLCB);
if(pLCB->FileName.Buffer){
ExFreePool(pLCB->FileName.Buffer);
pLCB->FileName.Buffer = NULL;
pLCB->FileName.Length = 0;
pLCB->FileName.MaximumLength = 0;
}
if(pLCB->IgnoreCaseFileName.Buffer){
ExFreePool(pLCB->IgnoreCaseFileName.Buffer);
pLCB->IgnoreCaseFileName.Buffer = NULL;
pLCB->IgnoreCaseFileName.Length = 0;
pLCB->IgnoreCaseFileName.MaximumLength = 0;
}
// give back memory either to the zone or to the VMM
if (!(pLCB->LCBFlags& XIFSD_LCB_NOT_FROM_POOL)) {
ExFreeToNPagedLookasideList(&(XifsLcbLookasideList),pLCB);
} else {
ExFreePool(pLCB);
}
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_LCB),
("Exit XixFsdFreeLCB \n"));
return;
}
VOID
BalloonLeak(
IN WDFOBJECT WdfDevice,
IN size_t num
)
{
PPAGE_LIST_ENTRY pPageListEntry;
PMDL pPageMdl;
PDEVICE_CONTEXT devCtx = GetDeviceContext(WdfDevice);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_HW_ACCESS, "--> %s\n", __FUNCTION__);
num = min(num, PAGE_SIZE/sizeof(PFN_NUMBER));
for (devCtx->num_pfns = 0; devCtx->num_pfns < num; devCtx->num_pfns++)
{
pPageListEntry = (PPAGE_LIST_ENTRY)PopEntryList(&devCtx->PageListHead);
if (pPageListEntry == NULL)
{
TraceEvents(TRACE_LEVEL_WARNING, DBG_HW_ACCESS, "PopEntryList=NULL\n");
break;
}
devCtx->pfns_table[devCtx->num_pfns] = pPageListEntry->PagePfn;
pPageMdl = pPageListEntry->PageMdl;
MmFreePagesFromMdl(pPageMdl);
ExFreePool(pPageMdl);
ExFreeToNPagedLookasideList(
&devCtx->LookAsideList,
pPageListEntry
);
devCtx->num_pages--;
}
BalloonTellHost(WdfDevice, devCtx->DefVirtQueue);
}
VOID
BalloonLeak(
IN WDFOBJECT WdfDevice,
IN size_t num
)
{
PDEVICE_CONTEXT ctx = GetDeviceContext(WdfDevice);
PPAGE_LIST_ENTRY pPageListEntry;
PMDL pPageMdl;
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_HW_ACCESS, "--> %s\n", __FUNCTION__);
pPageListEntry = (PPAGE_LIST_ENTRY)PopEntryList(&ctx->PageListHead);
if (pPageListEntry == NULL)
{
TraceEvents(TRACE_LEVEL_WARNING, DBG_HW_ACCESS, "No list entries.\n");
return;
}
pPageMdl = pPageListEntry->PageMdl;
num = MmGetMdlByteCount(pPageMdl) / PAGE_SIZE;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_HW_ACCESS,
"Deflate balloon with %d pages.\n", num);
ctx->num_pfns = num;
ctx->num_pages -= ctx->num_pfns;
RtlCopyMemory(ctx->pfns_table, MmGetMdlPfnArray(pPageMdl),
ctx->num_pfns * sizeof(PFN_NUMBER));
MmFreePagesFromMdl(pPageMdl);
ExFreePool(pPageMdl);
ExFreeToNPagedLookasideList(&ctx->LookAsideList, pPageListEntry);
BalloonTellHost(WdfDevice, ctx->DefVirtQueue);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_HW_ACCESS, "<-- %s\n", __FUNCTION__);
}
static
void
LibTCPEmptyQueue(PCONNECTION_ENDPOINT Connection)
{
PLIST_ENTRY Entry;
PQUEUE_ENTRY qp = NULL;
ReferenceObject(Connection);
while (!IsListEmpty(&Connection->PacketQueue))
{
Entry = RemoveHeadList(&Connection->PacketQueue);
qp = CONTAINING_RECORD(Entry, QUEUE_ENTRY, ListEntry);
/* We're in the tcpip thread here so this is safe */
pbuf_free(qp->p);
ExFreeToNPagedLookasideList(&QueueEntryLookasideList, qp);
}
DereferenceObject(Connection);
}