本文整理汇总了C++中ExFreePool函数的典型用法代码示例。如果您正苦于以下问题：C++ ExFreePool函数的具体用法？C++ ExFreePool怎么用？C++ ExFreePool使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了ExFreePool函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: TapeGetDriveParameters
//.........这里部分代码省略.........
cdb->MODE_SENSE.Pc = 0x0B;
buffer = ExAllocatePool(NonPagedPoolCacheAligned,
sizeof(NINE_TRACKSENSE_DATA));
if (!buffer) {
return STATUS_INSUFFICIENT_RESOURCES;
}
status = ScsiClassSendSrbSynchronous(DeviceObject,
&srb,
buffer,
sizeof(NINE_TRACKSENSE_DATA),
FALSE);
if (NT_SUCCESS(status)) {
Irp->IoStatus.Information = sizeof(TAPE_GET_DRIVE_PARAMETERS);
//
// Indicate support of following:
//
tapeGetDriveParams->ECC = FALSE;
tapeGetDriveParams->Compression = FALSE;
tapeGetDriveParams->DataPadding = FALSE;
tapeGetDriveParams->ReportSetmarks = FALSE;
tapeGetDriveParams->FeaturesLow =
TAPE_DRIVE_ERASE_SHORT |
TAPE_DRIVE_FIXED_BLOCK |
TAPE_DRIVE_VARIABLE_BLOCK |
TAPE_DRIVE_WRITE_PROTECT |
TAPE_DRIVE_GET_ABSOLUTE_BLK |
TAPE_DRIVE_GET_LOGICAL_BLK;
tapeGetDriveParams->FeaturesHigh =
TAPE_DRIVE_LOAD_UNLOAD |
TAPE_DRIVE_LOCK_UNLOCK |
TAPE_DRIVE_SET_BLOCK_SIZE |
TAPE_DRIVE_ABSOLUTE_BLK |
TAPE_DRIVE_ABS_BLK_IMMED |
TAPE_DRIVE_LOGICAL_BLK |
TAPE_DRIVE_END_OF_DATA |
TAPE_DRIVE_FILEMARKS |
TAPE_DRIVE_SEQUENTIAL_FMKS |
TAPE_DRIVE_REVERSE_POSITION |
TAPE_DRIVE_WRITE_FILEMARKS;
}
ExFreePool(buffer);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Zero CDB in SRB on stack.
//
RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
srb.CdbLength = CDB6GENERIC_LENGTH;
cdb->CDB6GENERIC.OperationCode = SCSIOP_READ_BLOCK_LIMITS;
//
// Set timeout value.
//
srb.TimeOutValue = deviceExtension->TimeOutValue;
blockLimits = ExAllocatePool(NonPagedPoolCacheAligned,
sizeof(READ_BLOCK_LIMITS_DATA));
if (!blockLimits) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(blockLimits, sizeof(READ_BLOCK_LIMITS_DATA));
status = ScsiClassSendSrbSynchronous(DeviceObject,
&srb,
blockLimits,
sizeof(READ_BLOCK_LIMITS_DATA),
FALSE);
if (NT_SUCCESS(status)) {
tapeGetDriveParams->MaximumBlockSize = blockLimits->BlockMaximumSize[2];
tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[1] << 8);
tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[0] << 16);
tapeGetDriveParams->MinimumBlockSize = blockLimits->BlockMinimumSize[1];
tapeGetDriveParams->MinimumBlockSize += (blockLimits->BlockMinimumSize[0] << 8);
}
ExFreePool(blockLimits);
return status;
} // end TapeGetDriveParameters()示例2: MsfsCreate
/* Creates the client side */
NTSTATUS DEFAULTAPI
MsfsCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject;
PMSFS_DEVICE_EXTENSION DeviceExtension;
PMSFS_FCB Fcb;
PMSFS_CCB Ccb;
PMSFS_FCB current = NULL;
PLIST_ENTRY current_entry;
KIRQL oldIrql;
DPRINT("MsfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
IoStack = IoGetCurrentIrpStackLocation(Irp);
DeviceExtension = DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject;
DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
Ccb = ExAllocatePool(NonPagedPool, sizeof(MSFS_CCB));
if (Ccb == NULL)
{
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY;
}
KeLockMutex(&DeviceExtension->FcbListLock);
current_entry = DeviceExtension->FcbListHead.Flink;
while (current_entry != &DeviceExtension->FcbListHead)
{
current = CONTAINING_RECORD(current_entry,
MSFS_FCB,
FcbListEntry);
if (!RtlCompareUnicodeString(&FileObject->FileName, ¤t->Name, TRUE))
break;
current_entry = current_entry->Flink;
}
if (current_entry == &DeviceExtension->FcbListHead)
{
ExFreePool(Ccb);
KeUnlockMutex(&DeviceExtension->FcbListLock);
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
Fcb = current;
KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
InsertTailList(&Fcb->CcbListHead, &Ccb->CcbListEntry);
KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
Fcb->ReferenceCount++;
Ccb->Fcb = Fcb;
KeUnlockMutex(&DeviceExtension->FcbListLock);
FileObject->FsContext = Fcb;
FileObject->FsContext2 = Ccb;
FileObject->Flags |= FO_MAILSLOT;
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}示例3: SeLocateProcessImageName
NTSTATUS
NTAPI
SeLocateProcessImageName(IN PEPROCESS Process,
OUT PUNICODE_STRING *ProcessImageName)
{
POBJECT_NAME_INFORMATION AuditName;
PUNICODE_STRING ImageName;
PFILE_OBJECT FileObject;
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Assume failure */
*ProcessImageName = NULL;
/* Check if we have audit info */
AuditName = Process->SeAuditProcessCreationInfo.ImageFileName;
if (!AuditName)
{
/* Get the file object */
Status = PsReferenceProcessFilePointer(Process, &FileObject);
if (!NT_SUCCESS(Status)) return Status;
/* Initialize the audit structure */
Status = SeInitializeProcessAuditName(FileObject, TRUE, &AuditName);
if (NT_SUCCESS(Status))
{
/* Set it */
if (InterlockedCompareExchangePointer((PVOID*)&Process->
SeAuditProcessCreationInfo.ImageFileName,
AuditName,
NULL))
{
/* Someone beat us to it, deallocate our copy */
ExFreePool(AuditName);
}
}
/* Dereference the file object */
ObDereferenceObject(FileObject);
if (!NT_SUCCESS(Status)) return Status;
}
/* Get audit info again, now we have it for sure */
AuditName = Process->SeAuditProcessCreationInfo.ImageFileName;
/* Allocate the output string */
ImageName = ExAllocatePoolWithTag(NonPagedPool,
AuditName->Name.MaximumLength +
sizeof(UNICODE_STRING),
TAG_SEPA);
if (!ImageName) return STATUS_NO_MEMORY;
/* Make a copy of it */
RtlCopyMemory(ImageName,
&AuditName->Name,
AuditName->Name.MaximumLength + sizeof(UNICODE_STRING));
/* Fix up the buffer */
ImageName->Buffer = (PWSTR)(ImageName + 1);
/* Return it */
*ProcessImageName = ImageName;
/* Return status */
return Status;
}示例4: FsRtlGetTunnelParameterValue
NTSTATUS
FsRtlGetTunnelParameterValue (
IN PUNICODE_STRING ValueName,
IN OUT PULONG Value
)
/*++
Routine Description:
Given a unicode value name this routine will go into the registry
location for the Tunnel parameter information and get the
value.
Arguments:
ValueName - the unicode name for the registry value located in the
double space configuration location of the registry.
Value - a pointer to the ULONG for the result.
Return Value:
NTSTATUS
If STATUS_SUCCESSFUL is returned, the location *Value will be
updated with the DWORD value from the registry. If any failing
status is returned, this value is untouched.
--*/
{
HANDLE Handle;
NTSTATUS Status;
ULONG RequestLength;
ULONG ResultLength;
UCHAR Buffer[KEY_WORK_AREA];
UNICODE_STRING KeyName;
OBJECT_ATTRIBUTES ObjectAttributes;
PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
KeyName.Buffer = TUNNEL_KEY_NAME;
KeyName.Length = sizeof(TUNNEL_KEY_NAME) - sizeof(WCHAR);
KeyName.MaximumLength = sizeof(TUNNEL_KEY_NAME);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = ZwOpenKey(&Handle,
KEY_READ,
&ObjectAttributes);
if (!NT_SUCCESS(Status)) {
return Status;
}
RequestLength = KEY_WORK_AREA;
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)Buffer;
while (1) {
Status = ZwQueryValueKey(Handle,
ValueName,
KeyValueFullInformation,
KeyValueInformation,
RequestLength,
&ResultLength);
ASSERT( Status != STATUS_BUFFER_OVERFLOW );
if (Status == STATUS_BUFFER_OVERFLOW) {
//
// Try to get a buffer big enough.
//
if (KeyValueInformation != (PKEY_VALUE_FULL_INFORMATION)Buffer) {
ExFreePool(KeyValueInformation);
}
RequestLength += 256;
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)
ExAllocatePoolWithTag(PagedPool,
RequestLength,
'KnuT');
if (!KeyValueInformation) {
return STATUS_NO_MEMORY;
}
} else {
break;
}
//.........这里部分代码省略.........
示例5: DiskDeviceControl
//.........这里部分代码省略.........
status = STATUS_BUFFER_OVERFLOW;
}
} else {
DDbgPrint(" MountPoint %wZ is not a drive\n", dcb->MountPoint);
status = STATUS_NOT_FOUND;
}
} else {
DDbgPrint(" MountPoint is NULL or undefined\n");
status = STATUS_NOT_FOUND;
}
} break;
case IOCTL_MOUNTDEV_LINK_CREATED: {
PMOUNTDEV_NAME mountdevName = Irp->AssociatedIrp.SystemBuffer;
DDbgPrint(" IOCTL_MOUNTDEV_LINK_CREATED\n");
status = STATUS_SUCCESS;
if (!IsUnmountPending(DeviceObject) && mountdevName != NULL &&
mountdevName->NameLength > 0) {
WCHAR *symbolicLinkNameBuf =
ExAllocatePool((mountdevName->NameLength + 1) * sizeof(WCHAR));
if (symbolicLinkNameBuf == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory(symbolicLinkNameBuf,
(mountdevName->NameLength + 1) * sizeof(WCHAR));
RtlCopyMemory(symbolicLinkNameBuf, mountdevName->Name,
mountdevName->NameLength);
DDbgPrint(" MountDev Name: %ws\n", symbolicLinkNameBuf);
if (wcsncmp(symbolicLinkNameBuf, L"\\DosDevices\\", 12) == 0) {
if (dcb->MountPoint != NULL && dcb->MountPoint->Length == 0) {
ExFreePool(dcb->MountPoint);
dcb->MountPoint = NULL;
}
if (dcb->MountPoint == NULL) {
DDbgPrint(" Not current MountPoint. MountDev set as MountPoint\n");
dcb->MountPoint = DokanAllocateUnicodeString(symbolicLinkNameBuf);
if (dcb->DiskDeviceName != NULL) {
PMOUNT_ENTRY mountEntry;
PDOKAN_CONTROL dokanControl = ExAllocatePool(sizeof(DOKAN_CONTROL));
if (dokanControl == NULL) {
ExFreePool(symbolicLinkNameBuf);
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory(dokanControl, sizeof(*dokanControl));
RtlCopyMemory(dokanControl->DeviceName, dcb->DiskDeviceName->Buffer,
dcb->DiskDeviceName->Length);
if (dcb->UNCName->Buffer != NULL && dcb->UNCName->Length > 0) {
RtlCopyMemory(dokanControl->UNCName, dcb->UNCName->Buffer,
dcb->UNCName->Length);
}
mountEntry = FindMountEntry(dcb->Global, dokanControl, TRUE);
ExFreePool(dokanControl);
if (mountEntry != NULL) {
RtlStringCchCopyW(mountEntry->MountControl.MountPoint,
MAXIMUM_FILENAME_LENGTH, symbolicLinkNameBuf);
} else {
DDbgPrint(" Cannot found associated MountEntry.\n");
}
} else {
DDbgPrint(
" DiskDeviceName is null. Is device currently unmounted?\n");
}示例6: KDispatchIoctl
NTSTATUS KDispatchIoctl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
PPROCESS_EVENT pProcessEvent;
PCHAR pOutputBuffer;
PPROCESS_INFORMATION pInputBuffer;
UINT dwDataWritten = 0;
PCAPTURE_PROCESS_MANAGER pProcessManager;
/* Get the process manager from the device extension */
pProcessManager = gpDeviceObject->DeviceExtension;
switch(irpStack->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_CAPTURE_GET_PROCINFO:
/* Update the time the user space program last sent an IOCTL */
//UpdateLastContactTime();
/* Return some of the process events that are queued */
if(irpStack->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(PROCESS_EVENT))
{
ULONG left = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
ULONG done = 0;
pOutputBuffer = Irp->UserBuffer;
__try {
ProbeForWrite(pOutputBuffer,
irpStack->Parameters.DeviceIoControl.OutputBufferLength,
__alignof (PROCESS_EVENT));
//ExAcquireFastMutex(&pProcessManager->mProcessWaitingSpinLock);
//if(pProcessManager->pCurrentProcessEvent != NULL)
//{
// RtlCopyMemory(pOutputBuffer+done, pProcessManager->pCurrentProcessEvent, sizeof(PROCESS_EVENT));
// done += sizeof(PROCESS_EVENT);
// ExFreePoolWithTag(pProcessManager->pCurrentProcessEvent, PROCESS_POOL_TAG);
// pProcessManager->pCurrentProcessEvent = NULL;
//}
//ExReleaseFastMutex(&pProcessManager->mProcessWaitingSpinLock);
if(!IsListEmpty(&pProcessManager->lQueuedProcessEvents))
{
PLIST_ENTRY head;
PPROCESS_EVENT_PACKET pProcessEventPacket;
head = ExInterlockedRemoveHeadList(&pProcessManager->lQueuedProcessEvents, &pProcessManager->lQueuedProcessEventsSpinLock);
pProcessManager->nQueuedProcessEvents--;
pProcessEventPacket = CONTAINING_RECORD(head, PROCESS_EVENT_PACKET, Link);
RtlCopyMemory(pOutputBuffer, &pProcessEventPacket->processEvent, sizeof(PROCESS_EVENT));
done = sizeof(PROCESS_EVENT);
ExFreePool(pProcessEventPacket);
// Notify that we still have process events queued
if( pProcessManager->nQueuedProcessEvents )
{
KeSetEvent(pProcessManager->eNewProcessEvent, 0, FALSE);
KeClearEvent(pProcessManager->eNewProcessEvent);
}
}
dwDataWritten = done;
status = STATUS_SUCCESS;
} __except( EXCEPTION_EXECUTE_HANDLER ) {
DbgPrint("CaptureProcessMonitor: EXCEPTION IOCTL_CAPTURE_GET_PROCINFO - %08x\n", GetExceptionCode());
status = GetExceptionCode();
}
}
break;
default:
break;
}示例7: LfsReadNextLogRecord
//.........这里部分代码省略.........
Buffer );
FoundNextLsn = TRUE;
}
} __finally {
DebugUnwind( LfsReadNextLogRecord );
//
// If we exited due to an error, we have to restore the context
// block.
//
if (UnwindRememberLcbFields) {
if (AbnormalTermination()) {
//
// If the record header in the context block is not
// the same as we started with. Then we unpin that
// data.
//
if (Lcb->RecordHeaderBcb != NULL) {
CcUnpinData( Lcb->RecordHeaderBcb );
}
if (Lcb->CurrentLogRecord != NULL
&& Lcb->AuxilaryBuffer == TRUE) {
ExFreePool( Lcb->CurrentLogRecord );
}
Lcb->RecordHeaderBcb = UnwindRecordHeaderBcb;
Lcb->RecordHeader = UnwindRecordHeader;
Lcb->CurrentLogRecord = UnwindCurrentLogRecord;
Lcb->AuxilaryBuffer = UnwindAuxilaryBuffer;
//
// Otherwise, if we have successfully found the next Lsn,
// we free up any resources being held from the previous search.
//
} else if (FoundNextLsn ) {
if (UnwindRecordHeaderBcb != NULL) {
CcUnpinData( UnwindRecordHeaderBcb );
}
if (UnwindCurrentLogRecord != NULL
&& UnwindAuxilaryBuffer == TRUE) {
ExFreePool( UnwindCurrentLogRecord );
}
//
// Restore the Bcb and auxilary buffer field for the final
// cleanup.
//
} else {
示例8: ReleaseTimeoutPendingIrp
NTSTATUS
ReleaseTimeoutPendingIrp(
PDEVICE_EXTENSION DeviceExtension
)
{
KIRQL oldIrql;
PLIST_ENTRY thisEntry, nextEntry, listHead;
PIRP_ENTRY irpEntry;
LARGE_INTEGER tickCount;
LIST_ENTRY completeList;
PIRP irp;
DDbgPrint("==> ReleaseTimeoutPendingIRP\n");
InitializeListHead(&completeList);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
KeAcquireSpinLock(&DeviceExtension->PendingIrp.ListLock, &oldIrql);
// when IRP queue is empty, there is nothing to do
if (IsListEmpty(&DeviceExtension->PendingIrp.ListHead)) {
KeReleaseSpinLock(&DeviceExtension->PendingIrp.ListLock, oldIrql);
DDbgPrint(" IrpQueue is Empty\n");
return STATUS_SUCCESS;
}
KeQueryTickCount(&tickCount);
// search timeout IRP through pending IRP list
listHead = &DeviceExtension->PendingIrp.ListHead;
for (thisEntry = listHead->Flink;
thisEntry != listHead;
thisEntry = nextEntry) {
nextEntry = thisEntry->Flink;
irpEntry = CONTAINING_RECORD(thisEntry, IRP_ENTRY, ListEntry);
// this IRP is NOT timeout yet
if ( (tickCount.QuadPart - irpEntry->TickCount.QuadPart) * KeQueryTimeIncrement()
< DOKAN_IPR_PENDING_TIMEOUT * 10000 * 1000) {
break;
}
RemoveEntryList(thisEntry);
DDbgPrint(" timeout Irp #%X\n", irpEntry->SerialNumber);
irp = irpEntry->Irp;
if (irp == NULL) {
// this IRP has already been canceled
ASSERT(irpEntry->CancelRoutineFreeMemory == FALSE);
ExFreePool(irpEntry);
continue;
}
// this IRP is not canceled yet
if (IoSetCancelRoutine(irp, NULL) == NULL) {
// Cancel routine will run as soon as we release the lock
InitializeListHead(&irpEntry->ListEntry);
irpEntry->CancelRoutineFreeMemory = TRUE;
continue;
}
// IrpEntry is saved here for CancelRoutine
// Clear it to prevent to be completed by CancelRoutine twice
irp->Tail.Overlay.DriverContext[DRIVER_CONTEXT_IRP_ENTRY] = NULL;
InsertTailList(&completeList, &irpEntry->ListEntry);
}
if (IsListEmpty(&DeviceExtension->PendingIrp.ListHead)) {
KeClearEvent(&DeviceExtension->PendingIrp.NotEmpty);
}
KeReleaseSpinLock(&DeviceExtension->PendingIrp.ListLock, oldIrql);
while (!IsListEmpty(&completeList)) {
listHead = RemoveHeadList(&completeList);
irpEntry = CONTAINING_RECORD(listHead, IRP_ENTRY, ListEntry);
irp = irpEntry->Irp;
irp->IoStatus.Information = 0;
irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
ExFreePool(irpEntry);
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
DDbgPrint("<== ReleaseTimeoutPendingIRP\n");
return STATUS_SUCCESS;
}示例9: NduDispatchRead
//.........这里部分代码省略.........
if (OpenEntry->WriteOnly)
{
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INVALID_PARAMETER;
}
/* Make the read cancellable */
IoAcquireCancelSpinLock(&OldCancelIrql);
IoSetCancelRoutine(Irp, ReadIrpCancel);
if (Irp->Cancel)
{
IoReleaseCancelSpinLock(OldCancelIrql);
/* Indicate a 0 byte read */
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
IoReleaseCancelSpinLock(OldCancelIrql);
while (TRUE)
{
KeAcquireSpinLock(&AdapterContext->Spinlock, &OldIrql);
/* Check if we have a packet */
if (IsListEmpty(&AdapterContext->PacketList))
{
KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
/* Wait for a packet (in the context of the calling user thread) */
Status = KeWaitForSingleObject(&AdapterContext->PacketReadEvent,
UserRequest,
UserMode,
TRUE,
NULL);
if (Status != STATUS_SUCCESS)
{
/* Remove the cancel routine */
IoAcquireCancelSpinLock(&OldCancelIrql);
IoSetCancelRoutine(Irp, NULL);
IoReleaseCancelSpinLock(OldCancelIrql);
break;
}
}
else
{
/* Remove the cancel routine */
IoAcquireCancelSpinLock(&OldCancelIrql);
IoSetCancelRoutine(Irp, NULL);
IoReleaseCancelSpinLock(OldCancelIrql);
/* Remove the first packet in the list */
ListEntry = RemoveHeadList(&AdapterContext->PacketList);
PacketEntry = CONTAINING_RECORD(ListEntry, NDISUIO_PACKET_ENTRY, ListEntry);
/* Release the adapter lock */
KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
/* And we're done with this loop */
Status = STATUS_SUCCESS;
break;
}
}
/* Check if we got a packet */
if (PacketEntry != NULL)
{
/* Find the right amount of bytes to copy */
BytesCopied = PacketEntry->PacketLength;
if (BytesCopied > IrpSp->Parameters.Read.Length)
BytesCopied = IrpSp->Parameters.Read.Length;
/* Copy the packet */
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
&PacketEntry->PacketData[0],
BytesCopied);
/* Free the packet entry */
ExFreePool(PacketEntry);
}
else
{
/* Something failed */
BytesCopied = 0;
}
/* Complete the IRP */
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = BytesCopied;
IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
return Status;
}示例10: EnumProcessModuleByVM
//.........这里部分代码省略.........
//ReLoadNtosCALL((PVOID)(&RExAllocatePool),L"ExAllocatePool",SystemKernelModuleBase,(ULONG)ImageModuleBase);
//ReLoadNtosCALL((PVOID)(&RExFreePool),L"ExFreePool",SystemKernelModuleBase,(ULONG)ImageModuleBase);
//ReLoadNtosCALL((PVOID)(&RZwClose),L"ZwClose",SystemKernelModuleBase,(ULONG)ImageModuleBase);
//if (ZwQueryVirtualMemory &&
// RObOpenObjectByPointer &&
// RExAllocatePool &&
// RExFreePool &&
// RZwClose)
//{
// bInit = TRUE;
//}
//if (!bInit)
// return ;
////进程已经退出鸟
//if (!IsExitProcess((PEPROCESS)EProcess)){
// return ;
//}
status = ObOpenObjectByPointer(
(PVOID)pEProcess, // Object
OBJ_KERNEL_HANDLE, // HandleAttributes
NULL, // PassedAccessState OPTIONAL
(ACCESS_MASK)0, // DesiredAccess
*PsProcessType, // ObjectType
KernelMode, // AccessMode
&hProcess);
if (!NT_SUCCESS(status))
{
//if (DebugOn)
//KdPrint(("ObOpenObjectByPointer failed:%d",RtlNtStatusToDosError(status)));
return ;
}
pSectionNam = (PUNICODE_STRING)ExAllocatePool(NonPagedPool, MAX_PATH * sizeof(WCHAR));
if (!pSectionNam)
{
ZwClose(hProcess);
return;
}
RtlZeroMemory(pSectionNam->Buffer, MAX_PATH * sizeof(WCHAR));
pSectionNam->MaximumLength = MAX_PATH;
__try
{
for (dwStartAddr = 0; dwStartAddr < 0x7fffffff; dwStartAddr = dwStartAddr + 0x10000)
{
status = ZwQueryVirtualMemory(
hProcess,
(PVOID)dwStartAddr,
MemoryBasicInformation,
&mbi,
sizeof(MEMORY_BASIC_INFORMATION),
0
);
if (NT_SUCCESS(status) && mbi.Type == MEM_IMAGE)
{
status = ZwQueryVirtualMemory(
hProcess,
(PVOID)dwStartAddr,
MemorySectionName,
pSectionNam,
MAX_PATH*sizeof(WCHAR),
0
);
if (NT_SUCCESS(status) && !MmIsAddressValid(pSectionNam->Buffer))
{
//如果当前的DLL模块路径 不等于前一个，则说明是开始了下一个DLL的枚举了，首先判断第一个字节是否是'\'
if (((PCHAR)pSectionNam->Buffer)[0] == 0x5c)
{
if (count == -1 ||\
RtlCompareMemory(pAllModuleInf->vModuleInf[count].ImagePathName, pSectionNam->Buffer, pSectionNam->Length)\
!= pSectionNam->Length)
{
RtlCopyMemory(pAllModuleInf->vModuleInf[++count].ImagePathName, pSectionNam->Buffer, pSectionNam->Length);
for (ulDllSize = dwStartAddr+mbi.RegionSize; ulDllSize < 0x7fffffff; ulDllSize += mbi.RegionSize)
{
status = ZwQueryVirtualMemory(
hProcess,
(PVOID)ulDllSize,
MemoryBasicInformation,
&mbi,
sizeof(MEMORY_BASIC_INFORMATION),
0
);
if (NT_SUCCESS(status) && mbi.Type != MEM_IMAGE)
{
pAllModuleInf->vModuleInf[count].size = ulDllSize - dwStartAddr;
}
}
}
}
}
}
}
}__except(EXCEPTION_EXECUTE_HANDLER){}
_FunctionRet:
pAllModuleInf->uCount = count;
ExFreePool(pSectionNam);
ZwClose(hProcess);
}示例11: CreateSdpRecord
//.........这里部分代码省略.........
goto exit;
}
nodeName = NULL; //transferred owenership to tree
nodeDesc = SdpNodeInterface->SdpCreateNodeString(
ansiStrName.Buffer,
ansiStrName.Length,
POOLTAG_BTHECHOSAMPLE
);
if(NULL == nodeDesc)
{
status = STATUS_INSUFFICIENT_RESOURCES;
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"Creating node for service desc failed, Status code %!STATUS!\n", status);
goto exit;
}
status = SdpNodeInterface->SdpAddAttributeToTree(
tree,
LANG_DEFAULT_ID+STRING_DESCRIPTION_OFFSET,
nodeDesc,
POOLTAG_BTHECHOSAMPLE
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"SdpAddAttributeToTree for service desc failed, Status code %!STATUS!\n", status);
goto exit;
}
nodeDesc = NULL;
//
// Create stream from tree
//
status = SdpParseInterface->SdpConvertTreeToStream(tree, &stream, &size, POOLTAG_BTHECHOSAMPLE);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"Failed to get stream from tree for SDP record, Status code %!STATUS!\n", status);
goto exit;
}
status = SdpParseInterface->SdpValidateStream(
stream,
size,
&errorByte
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"Validate stream failed for SDP record, first failure at address %p\n", (PVOID)errorByte);
goto exit;
}
*Stream = stream;
*Size = size;
exit:
if (NULL != tree)
{
SdpNodeInterface->SdpFreeTree(tree);
}
if (NULL != nodeName)
{
//
// If we failed to add attribute to tree use ExFreePool to free it
//
ExFreePool(nodeName);
}
if (NULL != nodeDesc)
{
//
// If we failed to add attribute to tree use ExFreePool to free it
//
ExFreePool(nodeDesc);
}
RtlFreeAnsiString(&ansiStrName);
if (!NT_SUCCESS(status))
{
if (stream != NULL)
{
ExFreePoolWithTag(stream, POOLTAG_BTHECHOSAMPLE);
}
}
return status;
}示例12: free_cache
void STDCALL free_cache() {
ExFreePool(cache_callbacks);
}示例13: TapeSetMediaParameters
NTSTATUS
TapeSetMediaParameters(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine sets the fixed-length logical block size or variable-length
block mode (if the block size is 0).
Arguments:
DeviceObject
Irp
Return Value:
NTSTATUS
--*/
{
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
PTAPE_SET_MEDIA_PARAMETERS tapeSetMediaParams = Irp->AssociatedIrp.SystemBuffer;
PMODE_PARM_READ_WRITE_DATA buffer;
SCSI_REQUEST_BLOCK srb;
PCDB cdb = (PCDB)srb.Cdb;
NTSTATUS status;
DebugPrint((3,"TapeIoControl: Set Tape Media Parameters \n"));
//
// Zero CDB in SRB on stack.
//
RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
srb.CdbLength = CDB6GENERIC_LENGTH;
cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
//
// Set timeout value.
//
srb.TimeOutValue = deviceExtension->TimeOutValue;
cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_PARM_READ_WRITE_DATA);
cdb->MODE_SELECT.Reserved1 = MODE_SELECT_PFBIT;
buffer = ExAllocatePool(NonPagedPoolCacheAligned,
sizeof(MODE_PARM_READ_WRITE_DATA));
if (!buffer) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(buffer, sizeof(MODE_PARM_READ_WRITE_DATA));
buffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
buffer->ParameterListHeader.BlockDescriptorLength = MODE_BLOCK_DESC_LENGTH;
buffer->ParameterListBlock.BlockLength[0] =
(UCHAR)((tapeSetMediaParams->BlockSize >> 16) & 0xFF);
buffer->ParameterListBlock.BlockLength[1] =
(UCHAR)((tapeSetMediaParams->BlockSize >> 8) & 0xFF);
buffer->ParameterListBlock.BlockLength[2] =
(UCHAR)(tapeSetMediaParams->BlockSize & 0xFF);
status = ScsiClassSendSrbSynchronous(DeviceObject,
&srb,
buffer,
sizeof( MODE_PARM_READ_WRITE_DATA ),
TRUE);
ExFreePool(buffer);
return status;
} // end TapeSetMediaParameters()示例14: TapeGetMediaParameters
NTSTATUS
TapeGetMediaParameters(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
The OVERLAND 9-track tape device can return whether media is
write-protected.
Arguments:
DeviceObject
Irp
Return Value:
NTSTATUS
--*/
{
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
PTAPE_GET_MEDIA_PARAMETERS tapeGetMediaParams = Irp->AssociatedIrp.SystemBuffer;
PNINE_TRACKSENSE_DATA buffer;
SCSI_REQUEST_BLOCK srb;
PCDB cdb = (PCDB)srb.Cdb;
NTSTATUS status;
DebugPrint((3,"TapeGetMediaParameters: Get Tape Media Parameters\n"));
//
// Zero SRB on stack.
//
RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
srb.CdbLength = CDB6GENERIC_LENGTH;
cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
//
// Set timeout value.
//
srb.TimeOutValue = deviceExtension->TimeOutValue;
cdb->MODE_SENSE.AllocationLength = sizeof(NINE_TRACKSENSE_DATA);
cdb->MODE_SENSE.PageCode = MODE_SENSE_CURRENT_VALUES;
cdb->MODE_SENSE.Pc = 0x0B;
buffer = ExAllocatePool(NonPagedPoolCacheAligned,
sizeof(NINE_TRACKSENSE_DATA));
if (!buffer) {
return STATUS_INSUFFICIENT_RESOURCES;
}
status = ScsiClassSendSrbSynchronous(DeviceObject,
&srb,
buffer,
sizeof(NINE_TRACKSENSE_DATA),
FALSE);
if (status == STATUS_DATA_OVERRUN) {
status = STATUS_SUCCESS;
}
if (NT_SUCCESS(status)) {
Irp->IoStatus.Information = sizeof(TAPE_GET_MEDIA_PARAMETERS);
tapeGetMediaParams->BlockSize = buffer->BlockLength[2];
tapeGetMediaParams->BlockSize += buffer->BlockLength[1] << 8;
tapeGetMediaParams->BlockSize += buffer->BlockLength[0] << 16;
tapeGetMediaParams->WriteProtected = buffer->WriteProtected;
tapeGetMediaParams->PartitionCount = 0;
}
ExFreePool(buffer);
return status;
return status;
} // end TapeGetMediaParameters()示例15: FatPostStackOverflowRead
NTSTATUS
FatPostStackOverflowRead (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp,
IN PFCB Fcb
)
/*++
Routine Description:
This routine posts a read request that could not be processed by
the fsp thread because of stack overflow potential.
Arguments:
Irp - Supplies the request to process.
Fcb - Supplies the file.
Return Value:
STATUS_PENDING.
--*/
{
PKEVENT Event;
PERESOURCE Resource;
DebugTrace(0, Dbg, "Getting too close to stack limit pass request to Fsp\n", 0 );
//
// Allocate an event and get shared on the resource we will
// be later using the common read.
//
Event = FsRtlAllocatePool( NonPagedPool, sizeof(KEVENT) );
KeInitializeEvent( Event, NotificationEvent, FALSE );
if (FlagOn(Irp->Flags, IRP_PAGING_IO) && (Fcb->Header.PagingIoResource != NULL)) {
Resource = Fcb->Header.PagingIoResource;
} else {
Resource = Fcb->Header.Resource;
}
ExAcquireResourceShared( Resource, TRUE );
try {
//
// Make the Irp just like a regular post request and
// then send the Irp to the special overflow thread.
// After the post we will wait for the stack overflow
// read routine to set the event that indicates we can
// now release the scb resource and return.
//
FatPrePostIrp( IrpContext, Irp );
//
// If this read is the result of a verify, we have to
// tell the overflow read routne to temporarily
// hijack the Vcb->VerifyThread field so that reads
// can go through.
//
if (Fcb->Vcb->VerifyThread == KeGetCurrentThread()) {
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_VERIFY_READ);
}
FsRtlPostStackOverflow( IrpContext, Event, FatStackOverflowRead );
//
// And wait for the worker thread to complete the item
//
(VOID) KeWaitForSingleObject( Event, Executive, KernelMode, FALSE, NULL );
}
finally {
ExReleaseResource( Resource );
ExFreePool( Event );
}
return STATUS_PENDING;
}