err_t
LibTCPShutdown(PCONNECTION_ENDPOINT Connection, const int shut_rx, const int shut_tx)
{
struct lwip_callback_msg *msg;
err_t ret;
msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
if (msg)
{
KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
msg->Input.Shutdown.Connection = Connection;
msg->Input.Shutdown.shut_rx = shut_rx;
msg->Input.Shutdown.shut_tx = shut_tx;
tcpip_callback_with_block(LibTCPShutdownCallback, msg, 1);
if (WaitForEventSafely(&msg->Event))
ret = msg->Output.Shutdown.Error;
else
ret = ERR_CLSD;
ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
return ret;
}
return ERR_MEM;
}
/* KphProtectAddEntry
*
* Protects the specified process.
*
* Thread safety: Full
* IRQL: <= DISPATCH_LEVEL
*/
PKPH_PROCESS_ENTRY KphProtectAddEntry(
__in PEPROCESS Process,
__in HANDLE Tag,
__in LOGICAL AllowKernelMode,
__in ACCESS_MASK ProcessAllowMask,
__in ACCESS_MASK ThreadAllowMask
)
{
KIRQL oldIrql;
PKPH_PROCESS_ENTRY entry;
/* Prevent the lookaside list from being freed. */
if (!ExAcquireRundownProtection(&ProtectedProcessRundownProtect))
return NULL;
entry = ExAllocateFromNPagedLookasideList(&ProtectedProcessLookasideList);
/* Lookaside list no longer needed. */
ExReleaseRundownProtection(&ProtectedProcessRundownProtect);
if (!entry)
return NULL;
entry->Process = Process;
entry->CreatorProcess = PsGetCurrentProcess();
entry->Tag = Tag;
entry->AllowKernelMode = AllowKernelMode;
entry->ProcessAllowMask = ProcessAllowMask;
entry->ThreadAllowMask = ThreadAllowMask;
KeAcquireSpinLock(&ProtectedProcessListLock, &oldIrql);
InsertHeadList(&ProtectedProcessListHead, &entry->ListEntry);
KeReleaseSpinLock(&ProtectedProcessListLock, oldIrql);
return entry;
}
err_t
LibTCPClose(PCONNECTION_ENDPOINT Connection, const int safe, const int callback)
{
err_t ret;
struct lwip_callback_msg *msg;
msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
if (msg)
{
KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
msg->Input.Close.Connection = Connection;
msg->Input.Close.Callback = callback;
if (safe)
LibTCPCloseCallback(msg);
else
tcpip_callback_with_block(LibTCPCloseCallback, msg, 1);
if (WaitForEventSafely(&msg->Event))
ret = msg->Output.Close.Error;
else
ret = ERR_CLSD;
ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
return ret;
}
return ERR_MEM;
}
struct tcp_pcb *
LibTCPSocket(void *arg)
{
struct lwip_callback_msg *msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
struct tcp_pcb *ret;
if (msg)
{
KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
msg->Input.Socket.Arg = arg;
tcpip_callback_with_block(LibTCPSocketCallback, msg, 1);
if (WaitForEventSafely(&msg->Event))
ret = msg->Output.Socket.NewPcb;
else
ret = NULL;
ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
return ret;
}
return NULL;
}
VOID __stdcall Filter(ULONG ServiceId, ULONG TableBase, ULONG Argc, ULONG StackAddr) {
ULONG pid = (ULONG)PsGetCurrentProcessId();
if (pid == g_nPid) {
ULONG i;
PXBoxData pData=(PXBoxData)ExAllocateFromNPagedLookasideList(&g_nPageList);
if(!pData)
return;
if (StackAddr < MmUserProbeAddress)
pData->bFromUser = 1;
else
pData->bFromUser = 0;
if (TableBase == (ULONG)KeServiceDescriptorTable.ServiceTableBase)
pData->bFromSSDT = 1;
else
pData->bFromSSDT = 0;
if (Argc > 16)
Argc = 16;
pData->argc = (UCHAR)Argc;
for (i = 0; i < Argc; ++i)
pData->args[i] = ((PULONG)StackAddr)[i];
pData->pid = (ULONG)pid;
pData->tid = (ULONG)PsGetCurrentThreadId();
pData->sid = ServiceId;
KeQuerySystemTime(&pData->time);
ExInterlockedInsertTailList(&g_linkListHead, &pData->ListEntry, &g_lock);
KeReleaseSemaphore( &g_keySemaphore, 0, 1, FALSE );
}
}
PTCP_PCB
LibTCPListen(PCONNECTION_ENDPOINT Connection, const u8_t backlog)
{
struct lwip_callback_msg *msg;
PTCP_PCB ret;
msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
if (msg)
{
KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
msg->Input.Listen.Connection = Connection;
msg->Input.Listen.Backlog = backlog;
tcpip_callback_with_block(LibTCPListenCallback, msg, 1);
if (WaitForEventSafely(&msg->Event))
ret = msg->Output.Listen.NewPcb;
else
ret = NULL;
ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
return ret;
}
return NULL;
}
void *mm_alloc(size_t size, int flags)
{
alloc_block *block;
char *p_mem = NULL;
int i;
if (flags & MEM_FAST)
{
for (i = 0; i < NUM_MEM_LISTS; i++) {
if ((512u << i) < size) continue;
p_mem = ExAllocateFromNPagedLookasideList(&mem_lists[i]);
break;
}
}
if (p_mem == NULL) /* if memory not allocated, allocate from pool */
{
if (flags & MEM_SUCCESS)
p_mem = mm_alloc_success(APOOL_TYPE(flags), ALLOC_SIZE(size), '1_cd'); else
p_mem = ExAllocatePoolWithTag(APOOL_TYPE(flags), ALLOC_SIZE(size), '1_cd');
if (p_mem == NULL) return NULL;
flags &= ~MEM_FAST;
}
/* memory block must be 16byte aligned */
if (dSZ(p_mem) & (16-1)) p_mem += 8, flags |= MEM_PADDED;
/* initialize alloc_block struct */
block = pv(p_mem);
block->size = size;
block->flags = flags;
block->index = i;
/* zero memory if needed */
if (flags & MEM_ZEROED) memset(block->data, 0, size);
return &block->data;
}
err_t
LibTCPConnect(PCONNECTION_ENDPOINT Connection, struct ip_addr *const ipaddr, const u16_t port)
{
struct lwip_callback_msg *msg;
err_t ret;
msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
if (msg)
{
KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
msg->Input.Connect.Connection = Connection;
msg->Input.Connect.IpAddress = ipaddr;
msg->Input.Connect.Port = port;
tcpip_callback_with_block(LibTCPConnectCallback, msg, 1);
if (WaitForEventSafely(&msg->Event))
{
ret = msg->Output.Connect.Error;
}
else
ret = ERR_CLSD;
ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
return ret;
}
return ERR_MEM;
}
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;
}
}
INLINE
PNON_PAGED_FCB
LfsAllocateNonPagedFcb (
)
{
return (PNON_PAGED_FCB) ExAllocateFromNPagedLookasideList( &GlobalLfs.NonPagedFcbLookasideList );
}
BOOLEAN SympAddSymbol(IN PCHAR pszSymbolName, IN ULONG64 uSymbolAddress, IN ULONG uOffset, IN ULONG uBitPosition, IN ULONG uBitLength)
{
ASSERTMSG("Cannot add symbol with NULL name", pszSymbolName != NULL);
ASSERTMSG("SymbolEngine must be initialized prior to this call", bIsSymEngineInitialized == TRUE);
// it is possible that we got symbol with zero address, offset -1, bit position -1, and length -1 if the symbol was not found during
// enumeration in user mode. In that case, and only in that case, we return error!
// NOTE: uSymbolAddress of -1 is used when symbols are initialized in order to send the array of wanted symbols to the user mode
if(uSymbolAddress == 0 && uOffset == -1 && uBitPosition == -1 && uBitLength == -1)
{
KdPrint(("[DEBUG] WARNING - Symbol was probably not found in user mode, cannot add symbol with unknown address and unknown offset\n"));
return FALSE;
}
// if symbol with this name already exists
if(SympFindSymbol(pszSymbolName) != NULL)
{
// don't want to "update" the address -- use SymUpdateSymbol function instead
KdPrint(("[DEBUG] WARNING - Symbol %s with address 0x%x already exists -- use SymUpdateFunction() to update the address\n", pszSymbolName, uSymbolAddress));
return TRUE;
}
// get memory from lookaside list
PSYMBOL_ENTRY pSymbolEntry = (PSYMBOL_ENTRY) ExAllocateFromNPagedLookasideList(&SymbolsLookasideList);
if(pSymbolEntry == NULL)
{
KdPrint(("[DEBUG] ERROR - Not enough memory in lookaside list to allocate new symbol entry\n"));
return FALSE;
}
// copy string from passed parameter
if(RtlStringCbCopyA(pSymbolEntry->Symbol.name, MAX_SYM_NAME, pszSymbolName) == STATUS_INVALID_PARAMETER)
{
KdPrint(("[DEBUG] ERROR - Error while copying symbol name to SYMBOL_ENTRY structure\n"));
return FALSE;
}
// copy address from the passed parameter
pSymbolEntry->Symbol.u64address = uSymbolAddress;
// copy offset from the passed parameter
pSymbolEntry->Symbol.uOffset = uOffset;
// copy bit position from the passed parameter
pSymbolEntry->Symbol.uBitPosition = uBitPosition;
// copy bit length from the passed parameter
pSymbolEntry->Symbol.uBitLength = uBitLength;
// insert it to list (thread safe)
ASSERTMSG("Fast mutex acquire must occur at or below APC_LEVEL", KeGetCurrentIrql() <= APC_LEVEL);
ExAcquireFastMutex(&SymbolsListMutex);
InsertHeadList(&SymbolsListHead, &pSymbolEntry->ListEntry);
++uSymbolCount;
ASSERTMSG("Fast mutex release must occur at APC_LEVEL", KeGetCurrentIrql() == APC_LEVEL);
ExReleaseFastMutex(&SymbolsListMutex);
return TRUE;
}
void *kmem_cache_alloc(struct kmem_cache *kmc, int flags)
{
void *buf = NULL;
buf = ExAllocateFromNPagedLookasideList(&(kmc->npll));
return buf;
}
void LibTCPEnqueuePacket(PCONNECTION_ENDPOINT Connection, struct pbuf *p)
{
PQUEUE_ENTRY qp;
qp = (PQUEUE_ENTRY)ExAllocateFromNPagedLookasideList(&QueueEntryLookasideList);
qp->p = p;
qp->Offset = 0;
ExInterlockedInsertTailList(&Connection->PacketQueue, &qp->ListEntry, &Connection->Lock);
}
FLT_PKT*
AllocateFltPacket()
{
FLT_PKT* pFltPkt = (FLT_PKT*)ExAllocateFromNPagedLookasideList(&g_PktLookaside);
if (pFltPkt)
RtlZeroMemory(pFltPkt, sizeof(*pFltPkt));
return pFltPkt;
}
NTSTATUS TCPSendData
( PCONNECTION_ENDPOINT Connection,
PCHAR BufferData,
ULONG SendLength,
PULONG BytesSent,
ULONG Flags,
PTCP_COMPLETION_ROUTINE Complete,
PVOID Context )
{
NTSTATUS Status;
PTDI_BUCKET Bucket;
KIRQL OldIrql;
LockObject(Connection, &OldIrql);
TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Called for %d bytes (on socket %x)\n",
SendLength, Connection->SocketContext));
TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Connection = %x\n", Connection));
TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Connection->SocketContext = %x\n",
Connection->SocketContext));
Status = TCPTranslateError(LibTCPSend(Connection,
BufferData,
SendLength,
BytesSent,
FALSE));
TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Send: %x, %d\n", Status, SendLength));
/* Keep this request around ... there was no data yet */
if (Status == STATUS_PENDING)
{
/* Freed in TCPSocketState */
Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
if (!Bucket)
{
UnlockObject(Connection, OldIrql);
TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Failed to allocate bucket\n"));
return STATUS_NO_MEMORY;
}
Bucket->Request.RequestNotifyObject = Complete;
Bucket->Request.RequestContext = Context;
InsertTailList( &Connection->SendRequest, &Bucket->Entry );
TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Queued write irp\n"));
}
UnlockObject(Connection, OldIrql);
TI_DbgPrint(DEBUG_TCP, ("[IP, TCPSendData] Leaving. Status = %x\n", Status));
return Status;
}
/*
* 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;
}
INLINE
PERESOURCE
LfsAllocateResource (
)
{
PERESOURCE Resource;
Resource = (PERESOURCE) ExAllocateFromNPagedLookasideList( &GlobalLfs.EResourceLookasideList );
ExInitializeResourceLite( Resource );
return Resource;
}
NTSTATUS TCPReceiveData
( PCONNECTION_ENDPOINT Connection,
PNDIS_BUFFER Buffer,
ULONG ReceiveLength,
PULONG BytesReceived,
ULONG ReceiveFlags,
PTCP_COMPLETION_ROUTINE Complete,
PVOID Context )
{
PTDI_BUCKET Bucket;
PUCHAR DataBuffer;
UINT DataLen, Received;
NTSTATUS Status;
TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Called for %d bytes (on socket %x)\n",
ReceiveLength, Connection->SocketContext));
NdisQueryBuffer(Buffer, &DataBuffer, &DataLen);
Status = LibTCPGetDataFromConnectionQueue(Connection, DataBuffer, DataLen, &Received);
if (Status == STATUS_PENDING)
{
Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
if (!Bucket)
{
TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Failed to allocate bucket\n"));
return STATUS_NO_MEMORY;
}
Bucket->Request.RequestNotifyObject = Complete;
Bucket->Request.RequestContext = Context;
ExInterlockedInsertTailList( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Queued read irp\n"));
TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Leaving. Status = STATUS_PENDING\n"));
(*BytesReceived) = 0;
}
else
{
(*BytesReceived) = Received;
}
return Status;
}
PXIFS_CCB
XixFsdAllocateCCB(VOID)
{
BOOLEAN IsFromLookasideList = FALSE;
PXIFS_CCB CCB = NULL;
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_CCB),
("Enter XixFsdAllocateCCB\n"));
// allocate memory
CCB = ExAllocateFromNPagedLookasideList(&(XifsCcbLookasideList));
if(!CCB)
{
CCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(XIFS_CCB),TAG_CCB);
if(!CCB)
{
//debug message
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_CREATE|DEBUG_TARGET_CCB),
("ERROR XixFsdAllocateCCB Can't allocate\n"));
return NULL;
}
IsFromLookasideList = FALSE;
} else {
IsFromLookasideList = TRUE;
}
RtlZeroMemory(CCB,sizeof(XIFS_CCB));
CCB->NodeTypeCode = XIFS_NODE_CCB;
CCB->NodeByteSize = sizeof(sizeof(XIFS_CCB));
InitializeListHead(&CCB->LinkToFCB);
if (!IsFromLookasideList) {
XifsdSetFlag(CCB->CCBFlags, XIFSD_CCB_NOT_FROM_POOL);
DebugTrace(DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_CREATE|DEBUG_TARGET_CCB),
("XixFsdAllocateCCB CCBFlags(0x%x)\n",CCB->CCBFlags));
}
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_CCB),
("Exit XixFsdAllocateCCB(%p)\n",CCB));
return CCB;
}
__drv_mustHoldCriticalRegion
PFFS_CCB
FFSAllocateCcb(
VOID)
{
PFFS_CCB Ccb;
PAGED_CODE();
ExAcquireResourceExclusiveLite(
&FFSGlobal->LAResource,
TRUE);
Ccb = (PFFS_CCB)(ExAllocateFromNPagedLookasideList(&(FFSGlobal->FFSCcbLookasideList)));
ExReleaseResourceForThreadLite(
&FFSGlobal->LAResource,
ExGetCurrentResourceThread());
if (Ccb == NULL)
{
Ccb = (PFFS_CCB)ExAllocatePoolWithTag(NonPagedPool, sizeof(FFS_CCB), FFS_POOL_TAG);
RtlZeroMemory(Ccb, sizeof(FFS_CCB));
SetFlag(Ccb->Flags, CCB_FROM_POOL);
}
else
{
RtlZeroMemory(Ccb, sizeof(FFS_CCB));
}
if (!Ccb)
{
return NULL;
}
Ccb->Identifier.Type = FFSCCB;
Ccb->Identifier.Size = sizeof(FFS_CCB);
Ccb->CurrentByteOffset = 0;
Ccb->DirectorySearchPattern.Length = 0;
Ccb->DirectorySearchPattern.MaximumLength = 0;
Ccb->DirectorySearchPattern.Buffer = 0;
return Ccb;
}
VOID
ExDeleteNPagedLookasideList (
IN PNPAGED_LOOKASIDE_LIST Lookaside
)
/*++
Routine Description:
This function removes a paged lookaside structure from the system paged
lookaside list and frees any entries specified by the lookaside structure.
Arguments:
Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
Return Value:
None.
--*/
{
PVOID Entry;
KIRQL OldIrql;
//
// Acquire the nonpaged system lookaside list lock and remove the
// specified lookaside list structure from the list.
//
ExAcquireSpinLock(&ExNPagedLookasideLock, &OldIrql);
RemoveEntryList(&Lookaside->L.ListEntry);
ExReleaseSpinLock(&ExNPagedLookasideLock, OldIrql);
//
// Remove all pool entries from the specified lookaside structure
// and free them.
//
Lookaside->L.Allocate = ExpDummyAllocate;
while ((Entry = ExAllocateFromNPagedLookasideList(Lookaside)) != NULL) {
(Lookaside->L.Free)(Entry);
}
return;
}
PFAT_IRP_CONTEXT
NTAPI
FatBuildIrpContext(PIRP Irp,
BOOLEAN CanWait)
{
PIO_STACK_LOCATION IrpSp;
PFAT_IRP_CONTEXT IrpContext;
PVOLUME_DEVICE_OBJECT VolumeObject;
/* Get current IRP stack location */
IrpSp = IoGetCurrentIrpStackLocation(Irp);
/* Allocate memory for the Irp context */
IrpContext = ExAllocateFromNPagedLookasideList(&FatGlobalData.IrpContextList);
/* Zero init memory */
RtlZeroMemory(IrpContext, sizeof(FAT_IRP_CONTEXT));
/* Save IRP, MJ and MN */
IrpContext->Irp = Irp;
IrpContext->Stack = IrpSp;
IrpContext->MajorFunction = IrpSp->MajorFunction;
IrpContext->MinorFunction = IrpSp->MinorFunction;
/* Set DeviceObject */
if (IrpSp->FileObject)
{
IrpContext->DeviceObject = IrpSp->FileObject->DeviceObject;
/* Save VCB pointer */
VolumeObject = (PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject;
IrpContext->Vcb = &VolumeObject->Vcb;
/* TODO: Handle write-through */
}
else if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL)
{
/* Handle FSCTRL case */
IrpContext->DeviceObject = IrpSp->Parameters.MountVolume.Vpb->RealDevice;
}
/* Set Wait flag */
if (CanWait) IrpContext->Flags |= IRPCONTEXT_CANWAIT;
/* Return prepared context */
return IrpContext;
}
PNTFS_FCB
NtfsCreateFCB(PCWSTR FileName,
PCWSTR Stream,
PNTFS_VCB Vcb)
{
PNTFS_FCB Fcb;
ASSERT(Vcb);
ASSERT(Vcb->Identifier.Type == NTFS_TYPE_VCB);
Fcb = ExAllocateFromNPagedLookasideList(&NtfsGlobalData->FcbLookasideList);
RtlZeroMemory(Fcb, sizeof(NTFS_FCB));
Fcb->Identifier.Type = NTFS_TYPE_FCB;
Fcb->Identifier.Size = sizeof(NTFS_TYPE_FCB);
Fcb->Vcb = Vcb;
if (FileName)
{
wcscpy(Fcb->PathName, FileName);
if (wcsrchr(Fcb->PathName, '\\') != 0)
{
Fcb->ObjectName = wcsrchr(Fcb->PathName, '\\');
}
else
{
Fcb->ObjectName = Fcb->PathName;
}
}
if (Stream)
{
wcscpy(Fcb->Stream, Stream);
}
else
{
Fcb->Stream[0] = UNICODE_NULL;
}
ExInitializeResourceLite(&Fcb->MainResource);
Fcb->RFCB.Resource = &(Fcb->MainResource);
return Fcb;
}
static NTSTATUS
DefaultDispatch(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
)
{
NTSTATUS status;
PIO_STACK_LOCATION IrpStack;
PMYCONTEXT MyContext;
PDRIVER_ENTRY DrvEntry;
PDEVICE_ENTRY DevEntry;
IrpStack = IoGetCurrentIrpStackLocation(Irp);
DevEntry = LookupEntryByDevObj(DeviceObject);
if ( DevEntry )
{
MyContext = ExAllocateFromNPagedLookasideList(&ContextLookaside);
if ( MyContext )
{
MyContext->Context = IrpStack->Context;
MyContext->Control = IrpStack->Control;
MyContext->MajorFunction = IrpStack->MajorFunction;
MyContext->CompletionRoutine = IrpStack->CompletionRoutine;
IrpStack->CompletionRoutine = MyCompletionRoutine;
IrpStack->Context = MyContext;
IrpStack->Control = SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR | SL_INVOKE_ON_CANCEL;
}
status = (DevEntry->DrvEntry->DriverDispatch[IrpStack->MajorFunction])(DeviceObject, Irp);
}
else
{
DrvEntry = LookupEntryByDrvObj(DeviceObject->DriverObject);
if ( !DrvEntry )
{
DbgPrint("***** UH-OH\n");
return STATUS_DEVICE_NOT_READY;
}
status = (DrvEntry->DriverDispatch[IrpStack->MajorFunction])(DeviceObject, Irp);
}
return status;
}
void Insert(DWORD key, PDATA pData, PHASHTABLE pHashTable)
{
PTWOWAY pNode = NULL;
PTWOWAY pNewNode = NULL;
PLIST_ENTRY pListHead = NULL;
pNode = Find(key, pHashTable);
// The node with the given key was not found.
if (pNode == NULL)
{
pNewNode = ExAllocateFromNPagedLookasideList(pLookasideList_TWOWAY);
if (pNewNode == NULL)
{
DbgPrint("ExAllocateFromNPagedLookasideList returned NULL!\n");
return;
}
// Insert the data to the node.
pNewNode->key = key;
pNewNode->data.threadID = pData->threadID;
pNewNode->data.processID = pData->processID;
if (STATUS_SUCCESS != RtlStringCbCopyA(pNewNode->data.imageName, 16, pData->imageName))
{
DbgPrint("RtlStringCbCopyA failed!\n");
}
// Insert the node to the doubly-linked list.
pListHead = pHashTable->pListHeads[Hash(key, pHashTable->tableSize)];
InsertTailList(pListHead, &pNewNode->linkfield);
#ifdef MY_DEBUG
DbgPrint("INSERT: thread ID = 0x%x process ID = 0x%x image = %s\n", pData->threadID, pData->processID, pData->imageName);
#endif
}
#ifdef MY_DEBUG
else
{
if (pNode->data.processID != pData->processID)
{
DbgPrint("Node with key = 0x%x already in list\n", key);
DbgPrint("OLD: thread ID = 0x%x process ID = 0x%x image = %s\n", pNode->data.threadID, pNode->data.processID, pNode->data.imageName);
DbgPrint("NEW: thread ID = 0x%x process ID = 0x%x image = %s\n", pData->threadID, pData->processID, pData->imageName);
}
}
#endif
}
// Create a node event handler for the specified node
NodeEventHandler* CreateNodeEventHandler(EventHandlerManager* event_handler_manager, PFILE_OBJECT node)
{
NodeEventHandler* node_event_handler = NULL;
node_event_handler = (NodeEventHandler*)ExAllocateFromNPagedLookasideList(&event_handler_manager->event_handlers_pool);
if(node_event_handler == NULL)
return NULL;
node_event_handler->node = node;
node_event_handler->num_handlers = 0;
RtlZeroMemory(node_event_handler->handlers, sizeof(EventHandler) * TDI_EVENT_HANDLERS_MAX);
InsertHashMap(&event_handler_manager->event_handlers, (UINT)node, node_event_handler);
return node_event_handler;
}
FLT_PKT*
CreateFltPacketWithBuffer()
{
FLT_PKT* pFltPkt;
pFltPkt = AllocateFltPacket();
if (NULL == pFltPkt)
return NULL;
pFltPkt->pBuf = ExAllocateFromNPagedLookasideList(&g_DataLookaside);
if (NULL == pFltPkt->pBuf) {
FreeFltPkt(pFltPkt);
return NULL;
}
RtlZeroMemory(pFltPkt->pBuf, MAX_ETHER_SIZE);
return pFltPkt;
}
PXIFS_FCB
XixFsdAllocateFCB(VOID)
{
BOOLEAN IsFromLookasideList = FALSE;
PXIFS_FCB FCB = NULL;
uint32 i = 0;
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_FCB),
("Enter XixFsdAllocateFCB\n"));
// allocate memory
FCB = ExAllocateFromNPagedLookasideList(&(XifsFcbLookasideList));
if(!FCB)
{
FCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(XIFS_FCB),TAG_FCB);
if(!FCB)
{
//debug message
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_CREATE|DEBUG_TARGET_FCB),
("ERROR XixFsAllocateFCB Can't allocate\n"));
return NULL;
}
IsFromLookasideList = FALSE;
} else {
IsFromLookasideList = TRUE;
}
RtlZeroMemory(FCB,sizeof(XIFS_FCB));
if (!IsFromLookasideList) {
XifsdSetFlag(FCB->FCBFlags, XIFSD_FCB_NOT_FROM_POOL);
DebugTrace(DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_CREATE|DEBUG_TARGET_FCB),
("XixFsdAllocateFCB FCBFlags(0x%x)\n",FCB->FCBFlags));
}
FCB->NodeTypeCode = XIFS_NODE_FCB;
FCB->NodeByteSize = sizeof(sizeof(XIFS_FCB));
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CREATE|DEBUG_TARGET_FCB),
("Exit XixFsdAllocateFCB(%p)\n",FCB));
return FCB;
}
void cp_parallelized_crypt(
int is_encrypt, xts_key *key, fc_callback on_complete,
void *param, const unsigned char *in, unsigned char *out, u32 len, u64 offset)
{
req_item *item;
req_part *part;
u32 part_sz;
u32 part_of;
if ( (len < F_OP_THRESOLD) ||
((item = ExAllocateFromNPagedLookasideList(&pool_req_mem)) == NULL) )
{
if (is_encrypt != 0) {
xts_encrypt(in, out, len, offset, key);
} else {
xts_decrypt(in, out, len, offset, key);
}
on_complete(param); return;
}
item->is_encrypt = is_encrypt;
item->length = len;
item->in = in;
item->out = out;
item->offset = offset;
item->on_complete = on_complete;
item->param = param;
item->key = key;
part_sz = _align(len / dc_cpu_count, F_MIN_REQ);
part_of = 0; part = &item->parts[0];
do
{
part_sz = min(part_sz, len);
part->item = item;
part->offset = part_of;
part->length = part_sz;
InterlockedPushEntrySList(&pool_head, &part->entry);
part_of += part_sz; len -= part_sz; part++;
} while (len != 0);
KeSetEvent(&pool_signal_event, IO_NO_INCREMENT, FALSE);
}
PXIFS_CLOSE_FCB_CTX
XixFsdAllocateCloseFcbCtx(VOID)
{
BOOLEAN IsFromLookasideList = FALSE;
PXIFS_CLOSE_FCB_CTX Ctx = NULL;
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CLOSE),
("Enter XixFsdAllocateCloseFcbCtx \n"));
// allocate memory
Ctx = ExAllocateFromNPagedLookasideList(&(XifsCloseFcbCtxList));
if(!Ctx)
{
Ctx = ExAllocatePoolWithTag(PagedPool, sizeof(XIFS_CLOSE_FCB_CTX),TAG_CLOSEFCBCTX);
if(!Ctx)
{
DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_CLOSE),
("ERROR XixFsdAllocateCloseFcbCtx Can't allocate\n"));
//debug message
return NULL;
}
IsFromLookasideList = FALSE;
} else {
IsFromLookasideList = TRUE;
}
RtlZeroMemory(Ctx,sizeof(XIFS_CLOSE_FCB_CTX));
InitializeListHead(&(Ctx->DelayedCloseLink));
if (!IsFromLookasideList) {
XifsdSetFlag(Ctx->CtxFlags, XIFSD_CTX_FLAGS_NOT_FROM_POOL);
DebugTrace(DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_CLOSE),
(" XixFsdAllocateCloseFcbCtx CtxFlags(0x%x)\n",Ctx->CtxFlags));
}
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CLOSE),
("Exit XixFsdAllocateCloseFcbCtx (%p)\n", Ctx));
return Ctx;
}