/* * @implemented */ PVOID NTAPI IoAllocateErrorLogEntry(IN PVOID IoObject, IN UCHAR EntrySize) { PERROR_LOG_ENTRY LogEntry; ULONG LogEntrySize; PDEVICE_OBJECT DeviceObject; PDRIVER_OBJECT DriverObject; /* Make sure we have an object */ if (!IoObject) return NULL; /* Check if we're past our buffer */ if (IopTotalLogSize > PAGE_SIZE) return NULL; /* Check if this is a device object or driver object */ if (((PDEVICE_OBJECT)IoObject)->Type == IO_TYPE_DEVICE) { /* It's a device, get the driver */ DeviceObject = (PDEVICE_OBJECT)IoObject; DriverObject = DeviceObject->DriverObject; } else if (((PDEVICE_OBJECT)IoObject)->Type == IO_TYPE_DRIVER) { /* It's a driver, so we don't have a device */ DeviceObject = NULL; DriverObject = (PDRIVER_OBJECT)IoObject; } else { /* Fail */ return NULL; } /* Calculate the total size and allocate it */ LogEntrySize = sizeof(ERROR_LOG_ENTRY) + EntrySize; LogEntry = ExAllocatePoolWithTag(NonPagedPool, LogEntrySize, TAG_ERROR_LOG); if (!LogEntry) return NULL; /* Reference the Objects */ if (DeviceObject) ObReferenceObject(DeviceObject); if (DriverObject) ObReferenceObject(DriverObject); /* Update log size */ InterlockedExchangeAdd(&IopTotalLogSize, EntrySize); /* Clear the entry and set it up */ RtlZeroMemory(LogEntry, EntrySize); LogEntry->Type = IO_TYPE_ERROR_LOG; LogEntry->Size = EntrySize; LogEntry->DeviceObject = DeviceObject; LogEntry->DriverObject = DriverObject; /* Return the entry data */ return (PVOID)((ULONG_PTR)LogEntry + sizeof(ERROR_LOG_ENTRY)); }
static PDEVICE_OBJECT IopTraverseDeviceNode(PDEVICE_NODE Node, PUNICODE_STRING DeviceInstance) { PDEVICE_OBJECT DeviceObject; PDEVICE_NODE ChildNode; if (RtlEqualUnicodeString(&Node->InstancePath, DeviceInstance, TRUE)) { ObReferenceObject(Node->PhysicalDeviceObject); return Node->PhysicalDeviceObject; } /* Traversal of all children nodes */ for (ChildNode = Node->Child; ChildNode != NULL; ChildNode = ChildNode->Sibling) { DeviceObject = IopTraverseDeviceNode(ChildNode, DeviceInstance); if (DeviceObject != NULL) { return DeviceObject; } } return NULL; }
NTSTATUS PPJoyBus_JoyDevRelations (IN PJOY_DEVICE_DATA JoyDeviceData, IN PIRP Irp) { PDEVICE_RELATIONS DeviceRelations; NTSTATUS ntStatus; PAGED_CODE (); switch (IoGetCurrentIrpStackLocation(Irp)->Parameters.QueryDeviceRelations.Type) { case TargetDeviceRelation: DeviceRelations= (PDEVICE_RELATIONS) ExAllocatePoolWithTag (PagedPool,sizeof(DEVICE_RELATIONS),PPJOYBUS_POOL_TAG); if (!DeviceRelations) { ntStatus= STATUS_INSUFFICIENT_RESOURCES; break; } DeviceRelations->Count= 1; DeviceRelations->Objects[0]= JoyDeviceData->Self; ObReferenceObject (JoyDeviceData->Self); ntStatus = STATUS_SUCCESS; Irp->IoStatus.Information= (ULONG_PTR) DeviceRelations; break; case BusRelations: case EjectionRelations: case RemovalRelations: default: ntStatus= Irp->IoStatus.Status; } return ntStatus; }
static NTSTATUS XenM2BPdoQueryDeviceRelations(PXENM2B_PDO_EXTENSION pPdoExt, PIRP pIrp) { PIO_STACK_LOCATION pIrpStack; PDEVICE_RELATIONS pRelations; DEVICE_RELATION_TYPE Type; pIrpStack = IoGetCurrentIrpStackLocation(pIrp); Type = pIrpStack->Parameters.QueryDeviceRelations.Type; if (Type != TargetDeviceRelation) { TraceDebug(("%s: Relations Type: %d\n", __FUNCTION__, Type)); return STATUS_SUCCESS; } if (XenM2BGetPnPState(&pPdoExt->DevicePnPState) == PnPStateDeleted) { TraceDebug(("%s: Target deleted\n", __FUNCTION__)); return STATUS_NO_SUCH_DEVICE; } pRelations = ExAllocatePoolWithTag(PagedPool, sizeof(DEVICE_RELATIONS), XENM2B_POOL_TAG); if (pRelations == NULL) { TraceDebug(("%s: Relations alloc failed\n", __FUNCTION__)); return STATUS_INSUFFICIENT_RESOURCES; } pRelations->Count = 1; pRelations->Objects[0] = pPdoExt->pDevice; ObReferenceObject(pPdoExt->pDevice); pIrp->IoStatus.Information = (ULONG_PTR)pRelations; return STATUS_SUCCESS; }
NTKERNELAPI PVOID FASTCALL ObFastReferenceObjectLocked ( IN PEX_FAST_REF FastRef ) /*++ Routine Description: This routine does a slow object reference. This must be called while holding a lock. Arguments: FastRef - Rundown block to be used to reference the object Return Value: PVOID - Object that was referenced or NULL if there was no object. --*/ { PVOID Object; EX_FAST_REF OldRef; OldRef = *FastRef; Object = ExFastRefGetObject (OldRef); if (Object != NULL) { ObReferenceObject (Object); } return Object; }
//载自ReactOS-0.3.4-REL-src PETHREAD NTAPI GetNextProcessThread(IN PEPROCESS Process, IN PETHREAD Thread OPTIONAL) { PETHREAD FoundThread = NULL; PLIST_ENTRY ListHead, Entry; PAGED_CODE(); if (Thread) { // Entry = Thread->ThreadListEntry.Flink;;// +0x22c ThreadListEntry : _LIST_ENTRY Entry = (PLIST_ENTRY)((ULONG)(Thread)+0x224); Entry=Entry->Flink; } else { Entry = (PLIST_ENTRY)((ULONG)(Process)+0x180);//+0x190 ThreadListHead : _LIST_ENTRY Entry = Entry->Flink; } // ListHead = &Process->ThreadListHead; ListHead = (PLIST_ENTRY)((ULONG)Process + 0x180); while (ListHead != Entry) { // FoundThread = CONTAINING_RECORD(Entry, ETHREAD, ThreadListEntry); FoundThread = (PETHREAD)((ULONG)Entry - 0x224); // if (ObReferenceObjectSafe(FoundThread)) break; if (ObReferenceObject(FoundThread)) break; FoundThread = NULL; Entry = Entry->Flink; } if (Thread) ObDereferenceObject(Thread); return FoundThread; }
void STDCALL flush_thread(void* context) { DEVICE_OBJECT* devobj = context; device_extension* Vcb = devobj->DeviceExtension; LARGE_INTEGER due_time; ObReferenceObject(devobj); KeInitializeTimer(&Vcb->flush_thread_timer); due_time.QuadPart = -INTERVAL * 10000; KeSetTimer(&Vcb->flush_thread_timer, due_time, NULL); while (TRUE) { KeWaitForSingleObject(&Vcb->flush_thread_timer, Executive, KernelMode, FALSE, NULL); if (!(devobj->Vpb->Flags & VPB_MOUNTED) || Vcb->removing) break; do_flush(Vcb); KeSetTimer(&Vcb->flush_thread_timer, due_time, NULL); } ObDereferenceObject(devobj); KeCancelTimer(&Vcb->flush_thread_timer); KeSetEvent(&Vcb->flush_thread_finished, 0, FALSE); PsTerminateSystemThread(STATUS_SUCCESS); }
// // Increment the reference count to a PDO. // PPDO_DEVICE_DATA LookupPdoData( PFDO_DEVICE_DATA FdoData, ULONG SystemIoBusNumber ) { PPDO_DEVICE_DATA pdoData = NULL; PLIST_ENTRY entry; PAGED_CODE (); KeEnterCriticalRegion(); ExAcquireFastMutex (&FdoData->Mutex); for (entry = FdoData->ListOfPDOs.Flink; entry != &FdoData->ListOfPDOs; entry = entry->Flink) { pdoData = CONTAINING_RECORD (entry, PDO_DEVICE_DATA, Link); if(pdoData->SlotNo == SystemIoBusNumber) break; pdoData = NULL; } if(pdoData) { // // increment the reference count to the PDO. // ObReferenceObject(pdoData->Self); } ExReleaseFastMutex (&FdoData->Mutex); KeLeaveCriticalRegion(); return pdoData; }
NTSTATUS NTAPI IntVideoPortChildQueryRelations( IN PVIDEO_PORT_CHILD_EXTENSION ChildExtension, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp) { PDEVICE_RELATIONS DeviceRelations; if (IrpSp->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation) { WARN_(VIDEOPRT, "Unsupported device relations type\n"); return Irp->IoStatus.Status; } DeviceRelations = ExAllocatePool(NonPagedPool, sizeof(DEVICE_RELATIONS)); if (!DeviceRelations) return STATUS_NO_MEMORY; DeviceRelations->Count = 1; DeviceRelations->Objects[0] = ChildExtension->PhysicalDeviceObject; ObReferenceObject(DeviceRelations->Objects[0]); Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations; return STATUS_SUCCESS; }
VOID NTAPI CcScheduleReadAhead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length) { PWORK_QUEUE_WITH_READ_AHEAD WorkItem; DPRINT("Schedule read ahead %08x%08x:%x %wZ\n", FileOffset->HighPart, FileOffset->LowPart, Length, &FileObject->FileName); WorkItem = ExAllocatePool(NonPagedPool, sizeof(*WorkItem)); if (!WorkItem) KeBugCheck(0); ObReferenceObject(FileObject); WorkItem->FileObject = FileObject; WorkItem->FileOffset = *FileOffset; WorkItem->Length = Length; ExInitializeWorkItem(((PWORK_QUEUE_ITEM)WorkItem), (PWORKER_THREAD_ROUTINE)CcpReadAhead, WorkItem); ExQueueWorkItem((PWORK_QUEUE_ITEM)WorkItem, DelayedWorkQueue); DPRINT("Done\n"); }
static NTSTATUS vboxNewProtDeviceRemoved(PVBOXMOUSE_DEVEXT pDevExt) { if (!vboxNewProtIsEnabled()) { WARN(("New Protocol is disabled")); return STATUS_UNSUCCESSFUL; } KIRQL Irql; NTSTATUS Status = STATUS_SUCCESS; KeAcquireSpinLock(&g_ctx.SyncLock, &Irql); RemoveEntryList(&pDevExt->ListEntry); if (g_ctx.pCurrentDevExt == pDevExt) { ObDereferenceObject(pDevExt->pdoSelf); g_ctx.pCurrentDevExt = NULL; for (PLIST_ENTRY pCur = g_ctx.DevExtList.Flink; pCur != &g_ctx.DevExtList; pCur = pCur->Flink) { PVBOXMOUSE_DEVEXT pNewCurDevExt = PVBOXMOUSE_DEVEXT_FROM_LE(pCur); ASMAtomicWritePtr(&g_ctx.pCurrentDevExt, pNewCurDevExt); /* ensure the object is not deleted while it is being used by a poller thread */ ObReferenceObject(pNewCurDevExt->pdoSelf); break; } } KeReleaseSpinLock(&g_ctx.SyncLock, Irql); return Status; }
NTSTATUS CIoControlIrp::Create(PDEVICE_OBJECT TargetDevice, ULONG IoControlCode, bool IsInternal, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength) { m_Irp = IoBuildDeviceIoControlRequest(IoControlCode, TargetDevice, InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, IsInternal ? TRUE : FALSE, m_Event, &m_IoControlStatus); if (m_Irp == nullptr) { return STATUS_INSUFFICIENT_RESOURCES; } ObReferenceObject(TargetDevice); m_TargetDevice = TargetDevice; return STATUS_SUCCESS; }
VOID GetDosDeviceName(PDEVICE_OBJECT pDeviceObject, PUNICODE_STRING pShareName, PUNICODE_STRING pDosName) { NTSTATUS status; UNICODE_STRING tempDosDrive; ObReferenceObject(pDeviceObject); status = IoVolumeDeviceToDosName( (PVOID)pDeviceObject, &tempDosDrive); pDosName->Length = 0; if(NT_SUCCESS(status)) { int i = 0; int wchars = tempDosDrive.Length/2; int pos = 0; pDosName->MaximumLength = tempDosDrive.MaximumLength + 2; pDosName->Buffer = ExAllocatePoolWithTag(NonPagedPool, pDosName->MaximumLength, FILE_POOL_TAG); if(pDosName->Buffer != NULL) { pDosName->Buffer[pos++] = '\\'; pDosName->Length += sizeof(WCHAR); for(i = 0; i < wchars; i++) { if(tempDosDrive.Buffer[i] != 0x003A) { pDosName->Buffer[pos++] = tempDosDrive.Buffer[i]; pDosName->Length += sizeof(WCHAR); // Unicode is 2-bytes } } ExFreePool(tempDosDrive.Buffer); } } else { if(pShareName != NULL) { pDosName->MaximumLength = pShareName->MaximumLength; pDosName->Buffer = ExAllocatePoolWithTag(NonPagedPool, pDosName->MaximumLength, FILE_POOL_TAG); if(pDosName->Buffer != NULL) { RtlUnicodeStringCopy(pDosName, pShareName); } } else { pDosName->MaximumLength = 30; // Dont change this pDosName->Buffer = ExAllocatePoolWithTag(NonPagedPool, pDosName->MaximumLength, FILE_POOL_TAG); if(pDosName->Buffer != NULL) { RtlUnicodeStringCatString(pDosName, L"\\UNKNOWN DRIVE"); } } } ObDereferenceObject(pDeviceObject); }
VOID InitCsrProcess(VOID /*IN PEPROCESS CsrProcess*/) { /* Save the EPROCESS of CSRSS */ gpepCSRSS = PsGetCurrentProcess(); // gpepCSRSS = CsrProcess; ObReferenceObject(gpepCSRSS); }
VOID ExpShutdownWorker ( IN PVOID Parameter ) { PETHREAD CurrentThread; PSHUTDOWN_WORK_ITEM ShutdownItem; ShutdownItem = (PSHUTDOWN_WORK_ITEM) Parameter; ASSERT (ShutdownItem != NULL); if (ShutdownItem->PrevThread != NULL) { // // Wait for the previous thread to exit -- if it's in the same // queue, it probably has already, but we need to make sure // (and if it's not, we *definitely* need to make sure). // KeWaitForSingleObject (ShutdownItem->PrevThread, Executive, KernelMode, FALSE, NULL); ObDereferenceObject (ShutdownItem->PrevThread); ShutdownItem->PrevThread = NULL; } // // Decrement the worker count. // InterlockedDecrement (&ExWorkerQueue[ShutdownItem->QueueType].Info.QueueWorkerInfo); CurrentThread = PsGetCurrentThread(); if ((!ExpCheckQueueShutdown(DelayedWorkQueue, ShutdownItem)) && (!ExpCheckQueueShutdown(CriticalWorkQueue, ShutdownItem))) { // // We're the last worker to exit // ASSERT (!ExpLastWorkerThread); ExpLastWorkerThread = CurrentThread; ObReferenceObject (ExpLastWorkerThread); KeSetEvent (&ExpThreadSetManagerShutdownEvent, 0, FALSE); } KeSetKernelStackSwapEnable (TRUE); CurrentThread->ActiveExWorker = 0; PsTerminateSystemThread (STATUS_SYSTEM_SHUTDOWN); }
NTSTATUS HidClassFDO_CopyDeviceRelations( IN PDEVICE_OBJECT DeviceObject, OUT PDEVICE_RELATIONS *OutRelations) { PDEVICE_RELATIONS DeviceRelations; PHIDCLASS_FDO_EXTENSION FDODeviceExtension; ULONG Index; // // get device extension // FDODeviceExtension = DeviceObject->DeviceExtension; ASSERT(FDODeviceExtension->Common.IsFDO); // // allocate result // DeviceRelations = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_RELATIONS) + (FDODeviceExtension->DeviceRelations->Count - 1) * sizeof(PDEVICE_OBJECT), HIDCLASS_TAG); if (!DeviceRelations) { // // no memory // *OutRelations = NULL; return STATUS_INSUFFICIENT_RESOURCES; } // // copy device objects // for (Index = 0; Index < FDODeviceExtension->DeviceRelations->Count; Index++) { // // reference pdo // ObReferenceObject(FDODeviceExtension->DeviceRelations->Objects[Index]); // // store object // DeviceRelations->Objects[Index] = FDODeviceExtension->DeviceRelations->Objects[Index]; } // // set object count // DeviceRelations->Count = FDODeviceExtension->DeviceRelations->Count; // // store result // *OutRelations = DeviceRelations; return STATUS_SUCCESS; }
/* * @implemented */ VOID NTAPI IopShutdownBaseFileSystems(IN PLIST_ENTRY ListHead) { PLIST_ENTRY ListEntry; PDEVICE_OBJECT DeviceObject; IO_STATUS_BLOCK StatusBlock; PIRP Irp; KEVENT Event; NTSTATUS Status; KeInitializeEvent(&Event, NotificationEvent, FALSE); /* Get the first entry and start looping */ ListEntry = ListHead->Flink; while (ListEntry != ListHead) { /* Get the device object */ DeviceObject = CONTAINING_RECORD(ListEntry, DEVICE_OBJECT, Queue.ListEntry); ObReferenceObject(DeviceObject); IopInterlockedIncrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount); /* Check if we're attached */ if (DeviceObject->AttachedDevice) { /* Get the attached device */ DeviceObject = IoGetAttachedDevice(DeviceObject); } /* Build the shutdown IRP and call the driver */ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN, DeviceObject, NULL, 0, NULL, &Event, &StatusBlock); Status = IoCallDriver(DeviceObject, Irp); if (Status == STATUS_PENDING) { /* Wait on the driver */ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); } /* Reset the event */ KeClearEvent(&Event); IopDecrementDeviceObjectRef(DeviceObject, FALSE); ObDereferenceObject(DeviceObject); /* Go to the next entry */ ListEntry = ListEntry->Flink; } }
NTSTATUS ImScsiGetControllerObject() { PDEVICE_OBJECT dev_obj; if (pMPDrvInfoGlobal->ControllerObject != NULL) { return STATUS_SUCCESS; } KdBreakPoint(); for (dev_obj = pMPDrvInfoGlobal->pDriverObj->DeviceObject; dev_obj != NULL; #pragma warning(suppress: 28175) dev_obj = dev_obj->NextDevice) { if (dev_obj->DeviceType == FILE_DEVICE_CONTROLLER) { ObReferenceObject(dev_obj); pMPDrvInfoGlobal->ControllerObject = dev_obj; #if DBG { POBJECT_NAME_INFORMATION objstr = (POBJECT_NAME_INFORMATION) ExAllocatePoolWithTag(NonPagedPool, 1024, MP_TAG_GENERAL); if (objstr != NULL) { ULONG retl; NTSTATUS status; status = ObQueryNameString(pMPDrvInfoGlobal->ControllerObject, objstr, 1024, &retl); if (NT_SUCCESS(status)) { DbgPrint("PhDskMnt::ImScsiGetControllerObject: Successfully opened '%wZ'.\n", &objstr->Name); } ExFreePoolWithTag(objstr, MP_TAG_GENERAL); } } #endif return STATUS_SUCCESS; } } DbgPrint("PhDskMnt::ImScsiGetControllerObject: Could not locate SCSI adapter device object by name.\n"); return STATUS_DEVICE_DOES_NOT_EXIST; }
static NTSTATUS create_part0(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT DeviceObject, PUNICODE_STRING pardir, PUNICODE_STRING nameus, BTRFS_UUID* uuid) { PDEVICE_OBJECT newdevobj; UNICODE_STRING name; NTSTATUS Status; part0_device_extension* p0de; static const WCHAR btrfs_partition[] = L"\\BtrfsPartition"; name.Length = name.MaximumLength = pardir->Length + (wcslen(btrfs_partition) * sizeof(WCHAR)); name.Buffer = ExAllocatePoolWithTag(PagedPool, name.Length, ALLOC_TAG); if (!name.Buffer) { ERR("out of memory\n"); return STATUS_INSUFFICIENT_RESOURCES; } RtlCopyMemory(name.Buffer, pardir->Buffer, pardir->Length); RtlCopyMemory(&name.Buffer[pardir->Length / sizeof(WCHAR)], btrfs_partition, wcslen(btrfs_partition) * sizeof(WCHAR)); Status = IoCreateDevice(DriverObject, sizeof(part0_device_extension), &name, FILE_DEVICE_DISK, FILE_DEVICE_SECURE_OPEN, FALSE, &newdevobj); if (!NT_SUCCESS(Status)) { ERR("IoCreateDevice returned %08x\n", Status); ExFreePool(name.Buffer); return Status; } p0de = newdevobj->DeviceExtension; p0de->type = VCB_TYPE_PARTITION0; p0de->devobj = DeviceObject; RtlCopyMemory(&p0de->uuid, uuid, sizeof(BTRFS_UUID)); p0de->name.Length = name.Length; p0de->name.MaximumLength = name.MaximumLength; p0de->name.Buffer = ExAllocatePoolWithTag(PagedPool, p0de->name.MaximumLength, ALLOC_TAG); if (!p0de->name.Buffer) { ERR("out of memory\b"); ExFreePool(name.Buffer); ExFreePool(p0de->name.Buffer); IoDeleteDevice(newdevobj); return STATUS_INSUFFICIENT_RESOURCES; } RtlCopyMemory(p0de->name.Buffer, name.Buffer, name.Length); ObReferenceObject(DeviceObject); newdevobj->StackSize = DeviceObject->StackSize + 1; newdevobj->Flags |= DO_DIRECT_IO; newdevobj->Flags &= ~DO_DEVICE_INITIALIZING; *nameus = name; return STATUS_SUCCESS; }
static PROSSYM_KM_OWN_CONTEXT KdbpCaptureFileForSymbols(PFILE_OBJECT FileObject) { PROSSYM_KM_OWN_CONTEXT Context = ExAllocatePool(NonPagedPool, sizeof(*Context)); if (!Context) return NULL; ObReferenceObject(FileObject); Context->FileOffset.QuadPart = 0; Context->FileObject = FileObject; return Context; }
NTSTATUS DokanCreateGlobalDiskDevice( __in PDRIVER_OBJECT DriverObject, __out PDOKAN_GLOBAL* DokanGlobal ) { WCHAR deviceNameBuf[] = DOKAN_GLOBAL_DEVICE_NAME; WCHAR symbolicLinkBuf[] = DOKAN_GLOBAL_SYMBOLIC_LINK_NAME; NTSTATUS status; UNICODE_STRING deviceName; UNICODE_STRING symbolicLinkName; PDEVICE_OBJECT deviceObject; PDOKAN_GLOBAL dokanGlobal; RtlInitUnicodeString(&deviceName, deviceNameBuf); RtlInitUnicodeString(&symbolicLinkName, symbolicLinkBuf); status = IoCreateDeviceSecure( DriverObject, // DriverObject sizeof(DOKAN_GLOBAL),// DeviceExtensionSize &deviceName, // DeviceName FILE_DEVICE_UNKNOWN,// DeviceType 0, // DeviceCharacteristics FALSE, // Not Exclusive &sddl, // Default SDDL String NULL, // Device Class GUID &deviceObject); // DeviceObject if (!NT_SUCCESS(status)) { DDbgPrint(" IoCreateDevice returned 0x%x\n", status); return status; } DDbgPrint("DokanGlobalDevice: %wZ created\n", &deviceName); ObReferenceObject(deviceObject); status = IoCreateSymbolicLink(&symbolicLinkName, &deviceName); if (!NT_SUCCESS(status)) { DDbgPrint(" IoCreateSymbolicLink returned 0x%x\n", status); IoDeleteDevice(deviceObject); return status; } DDbgPrint("SymbolicLink: %wZ -> %wZ created\n", &deviceName, &symbolicLinkName); dokanGlobal = deviceObject->DeviceExtension; dokanGlobal->DeviceObject = deviceObject; RtlZeroMemory(dokanGlobal, sizeof(DOKAN_GLOBAL)); DokanInitIrpList(&dokanGlobal->PendingService); DokanInitIrpList(&dokanGlobal->NotifyService); dokanGlobal->Identifier.Type = DGL; dokanGlobal->Identifier.Size = sizeof(DOKAN_GLOBAL); *DokanGlobal = dokanGlobal; return STATUS_SUCCESS; }
NTSTATUS USBSTOR_PdoHandleDeviceRelations( IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp) { PDEVICE_RELATIONS DeviceRelations; PIO_STACK_LOCATION IoStack; DPRINT("USBSTOR_PdoHandleDeviceRelations\n"); // // get current irp stack location // IoStack = IoGetCurrentIrpStackLocation(Irp); // // check if relation type is BusRelations // if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation) { // // PDO handles only target device relation // return Irp->IoStatus.Status; } // // allocate device relations // DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS)); if (!DeviceRelations) { // // no memory // return STATUS_INSUFFICIENT_RESOURCES; } // // initialize device relations // DeviceRelations->Count = 1; DeviceRelations->Objects[0] = DeviceObject; ObReferenceObject(DeviceObject); // // store result // Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations; // // completed successfully // return STATUS_SUCCESS; }
NTSTATUS DriverEntry( __in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath ) { UNICODE_STRING CfixkrName = RTL_CONSTANT_STRING( CFIXKR_DEVICE_NT_NAME ); PFILE_OBJECT File; PDEVICE_OBJECT CfixkrObject; NTSTATUS Status; UNREFERENCED_PARAMETER( RegistryPath ); KdPrint( ( "CFIXDRV: DriverEntry of test driver\n" ) ); // // Install dispatch routines. // DriverObject->MajorFunction[ IRP_MJ_CREATE ] = CfixkDrvNotImplemented; DriverObject->MajorFunction[ IRP_MJ_CLOSE ] = CfixkDrvNotImplemented; DriverObject->DriverUnload = CfixkDrvUnload; // // Lookup cfixkr and obtain interface. // Status = IoGetDeviceObjectPointer( &CfixkrName, FILE_WRITE_DATA, &File, &CfixkrObject ); if ( ! NT_SUCCESS( Status ) ) { KdPrint( ( "CFIX: Failed to obtain pointer to cfixkr device\n" ) ); return Status; } Status = CfixkDrvQueryReporter( CfixkrObject ); if ( NT_SUCCESS( Status ) ) { // // Keep a reference to the device to lock the driver in // memory until we have released the interface. // ObReferenceObject( CfixkrObject ); CfixkDrvCfixkrDevice = CfixkrObject; } // // We have obtained the interface, which is referenced. We can thus // release File while having locked the DO through the interface. // ObDereferenceObject( File ); return Status; }
NTSTATUS NTAPI IsaFdoQueryDeviceRelations( IN PISAPNP_FDO_EXTENSION FdoExt, IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp) { NTSTATUS Status; PLIST_ENTRY CurrentEntry; PISAPNP_LOGICAL_DEVICE IsaDevice; PDEVICE_RELATIONS DeviceRelations; KIRQL OldIrql; ULONG i = 0; if (IrpSp->Parameters.QueryDeviceRelations.Type != BusRelations) return Irp->IoStatus.Status; KeAcquireSpinLock(&FdoExt->Lock, &OldIrql); Status = IsaHwFillDeviceList(FdoExt); if (!NT_SUCCESS(Status)) { KeReleaseSpinLock(&FdoExt->Lock, OldIrql); return Status; } DeviceRelations = ExAllocatePool(NonPagedPool, sizeof(DEVICE_RELATIONS) + sizeof(DEVICE_OBJECT) * (FdoExt->DeviceCount - 1)); if (!DeviceRelations) { KeReleaseSpinLock(&FdoExt->Lock, OldIrql); return STATUS_INSUFFICIENT_RESOURCES; } CurrentEntry = FdoExt->DeviceListHead.Flink; while (CurrentEntry != &FdoExt->DeviceListHead) { IsaDevice = CONTAINING_RECORD(CurrentEntry, ISAPNP_LOGICAL_DEVICE, ListEntry); DeviceRelations->Objects[i++] = IsaDevice->Common.Self; ObReferenceObject(IsaDevice->Common.Self); CurrentEntry = CurrentEntry->Flink; } DeviceRelations->Count = FdoExt->DeviceCount; KeReleaseSpinLock(&FdoExt->Lock, OldIrql); Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations; return STATUS_SUCCESS; }
NTSTATUS PsReferenceProcessFilePointer ( IN PEPROCESS Process, OUT PVOID *OutFileObject ) /*++ Routine Description: This routine returns a referenced pointer to the FilePointer of Process. This is a rundown protected wrapper around MmGetFileObjectForSection. Arguments: Process - Supplies the process to query. OutFileObject - Returns the file object backing the requested section if success is returned. Return Value: NTSTATUS. Environment: Kernel mode, PASSIVE_LEVEL. --*/ { PFILE_OBJECT FileObject; PAGED_CODE(); if (!ExAcquireRundownProtection (&Process->RundownProtect)) { return STATUS_UNSUCCESSFUL; } if (Process->SectionObject == NULL) { ExReleaseRundownProtection (&Process->RundownProtect); return STATUS_UNSUCCESSFUL; } FileObject = MmGetFileObjectForSection ((PVOID)Process->SectionObject); *OutFileObject = FileObject; ObReferenceObject (FileObject); ExReleaseRundownProtection (&Process->RundownProtect); return STATUS_SUCCESS; }
static NTSTATUS bus_query_device_relations(PIRP Irp) { NTSTATUS Status; ULONG num_children; LIST_ENTRY* le; ULONG drsize, i; DEVICE_RELATIONS* dr; ExAcquireResourceSharedLite(&pdo_list_lock, TRUE); num_children = 0; le = pdo_list.Flink; while (le != &pdo_list) { num_children++; le = le->Flink; } drsize = offsetof(DEVICE_RELATIONS, Objects[0]) + (num_children * sizeof(PDEVICE_OBJECT)); dr = ExAllocatePoolWithTag(PagedPool, drsize, ALLOC_TAG); if (!dr) { ERR("out of memory\n"); Status = STATUS_INSUFFICIENT_RESOURCES; goto end; } dr->Count = num_children; i = 0; le = pdo_list.Flink; while (le != &pdo_list) { pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry); ObReferenceObject(pdode->pdo); dr->Objects[i] = pdode->pdo; i++; le = le->Flink; } Irp->IoStatus.Information = (ULONG_PTR)dr; Status = STATUS_SUCCESS; end: ExReleaseResourceLite(&pdo_list_lock); Irp->IoStatus.Status = Status; IoCompleteRequest(Irp, IO_NO_INCREMENT); return Status; }
NTSTATUS UsbhubFdoQueryBusRelations(IN PDEVICE_OBJECT DeviceObject, OUT PDEVICE_RELATIONS* pDeviceRelations) { PHUB_DEVICE_EXTENSION DeviceExtension; PDEVICE_RELATIONS DeviceRelations; ULONG i; ULONG Children = 0; ULONG NeededSize; DeviceExtension = (PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension; DPRINT1("USBHUB: Query Bus Relations\n"); /* Create PDOs that are missing */ for (i = 0; i < USB_MAXCHILDREN; i++) { if (DeviceExtension->UsbChildren[i] == NULL) { continue; } Children++; } /* Fill returned structure */ NeededSize = sizeof(DEVICE_RELATIONS); if (Children > 1) NeededSize += (Children - 1) * sizeof(PDEVICE_OBJECT); DeviceRelations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, NeededSize); if (!DeviceRelations) return STATUS_INSUFFICIENT_RESOURCES; DeviceRelations->Count = Children; Children = 0; for (i = 0; i < USB_MAXCHILDREN; i++) { if (DeviceExtension->Children[i]) { ObReferenceObject(DeviceExtension->Children[i]); DeviceRelations->Objects[Children++] = DeviceExtension->Children[i]; } } ASSERT(Children == DeviceRelations->Count); *pDeviceRelations = DeviceRelations; WaitForUsbDeviceArrivalNotification(DeviceObject); return STATUS_SUCCESS; }
/* * @implemented */ NTSTATUS NTAPI IoEnumerateRegisteredFiltersList(OUT PDRIVER_OBJECT *DriverObjectList, IN ULONG DriverObjectListSize, OUT PULONG ActualNumberDriverObjects) { PLIST_ENTRY ListEntry; NTSTATUS Status = STATUS_SUCCESS; PFS_CHANGE_NOTIFY_ENTRY ChangeEntry; ULONG ListSize = 0, MaximumSize = DriverObjectListSize / sizeof(PDRIVER_OBJECT); /* Acquire the FS lock */ KeEnterCriticalRegion(); ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE); /* Browse the whole list */ ListEntry = IopFsNotifyChangeQueueHead.Flink; while (ListEntry != &IopFsNotifyChangeQueueHead) { ChangeEntry = CONTAINING_RECORD(ListEntry, FS_CHANGE_NOTIFY_ENTRY, FsChangeNotifyList); /* If buffer is still big enough */ if (ListSize < MaximumSize) { /* Reference the driver object */ ObReferenceObject(ChangeEntry->DriverObject); /* And pass it to the caller */ DriverObjectList[ListSize] = ChangeEntry->DriverObject; } else { Status = STATUS_BUFFER_TOO_SMALL; } /* Increase size counter */ ListSize++; /* Go to the next entry */ ListEntry = ListEntry->Flink; } /* Return list size */ *ActualNumberDriverObjects = ListSize; /* Release the FS lock */ ExReleaseResourceLite(&IopDatabaseResource); KeLeaveCriticalRegion(); return Status; }
/** * Add a PDO node to a bus' list of children. Internal. * * @v bus The bus to add the node to. * @v new_node The PDO node to add to the bus. * * Don't call this function yourself. It doesn't perform any error-checking. */ static VOID STDCALL WvlBusAddNode_(WVL_SP_BUS_T bus, WVL_SP_BUS_NODE new_node) { PLIST_ENTRY walker; KIRQL irql; DBG( "Adding PDO %p to bus %p.\n", (PVOID) new_node->BusPrivate_.Pdo, (PVOID) bus ); ObReferenceObject(new_node->BusPrivate_.Pdo); /* It's too bad about having both linked list and bus ref. */ new_node->BusPrivate_.Bus = bus; /* Find a slot for the new child. */ walker = &bus->BusPrivate_.Nodes; new_node->BusPrivate_.Num = 0; KeAcquireSpinLock(&bus->BusPrivate_.NodeLock, &irql); while ((walker = walker->Flink) != &bus->BusPrivate_.Nodes) { WVL_SP_BUS_NODE node = CONTAINING_RECORD( walker, WVL_S_BUS_NODE, BusPrivate_.Link ); if ( node->BusPrivate_.Num && (node->BusPrivate_.Link.Blink == &bus->BusPrivate_.Nodes) ) { /* The first node's unit number is != 0. Insert here. */ break; } if (node->BusPrivate_.Num > new_node->BusPrivate_.Num) { /* There is a gap so insert here. */ break; } /* Continue trying to find a slot. */ new_node->BusPrivate_.Num++; } /* while */ /* Insert before walker. */ InsertTailList(walker, &new_node->BusPrivate_.Link); bus->BusPrivate_.NodeCount++; KeReleaseSpinLock(&bus->BusPrivate_.NodeLock, irql); new_node->Linked = TRUE; /* We might be floating. */ if (bus->Pdo) IoInvalidateDeviceRelations(bus->Pdo, BusRelations); /* Hack: Use the new method for the main bus */ if (bus == &WvBus) WvlAddDeviceToMainBus(new_node->BusPrivate_.Pdo); return; }
NTSTATUS QueryDeviceRelations(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp) { NTSTATUS status = STATUS_SUCCESS; PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp); DEVICE_RELATION_TYPE type = irpSp->Parameters.QueryDeviceRelations.Type; PDEVICE_RELATIONS DeviceRelations; PDokanVCB vcb; // QueryDeviceRelations is currently not used // because it does not return proper informations and verifier complained // We keep it for futur support of pnp vcb = DeviceObject->DeviceExtension; switch (type) { case RemovalRelations: DDbgPrint(" QueryDeviceRelations - RemovalRelations\n"); break; case TargetDeviceRelation: DDbgPrint(" QueryDeviceRelations - TargetDeviceRelation\n"); DeviceRelations = (PDEVICE_RELATIONS)ExAllocatePool(sizeof(DEVICE_RELATIONS)); if (!DeviceRelations) { DDbgPrint(" can't allocate DeviceRelations\n"); return STATUS_INSUFFICIENT_RESOURCES; } /* The PnP manager will remove this when it is done with device */ ObReferenceObject(DeviceObject); DeviceRelations->Count = 1; DeviceRelations->Objects[0] = DeviceObject; Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations; return STATUS_SUCCESS; case EjectionRelations: DDbgPrint(" QueryDeviceRelations - EjectionRelations\n"); break; case BusRelations: DDbgPrint(" QueryDeviceRelations - BusRelations\n"); break; default: break; } return status; }