NTSTATUS RegisterPowerStateChangeCallback(_Inout_ DEVICE_EXTENSION* pDeviceExtension) { #if DBG DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_INFO_LEVEL, " ---> RegisterPowerStateChangeCallback()\n"); #endif /// DBG NT_ASSERT(pDeviceExtension); NTSTATUS status = STATUS_SUCCESS; OBJECT_ATTRIBUTES objectAttributes = {0}; UNICODE_STRING unicodeString = {0}; RtlInitUnicodeString(&unicodeString, L"\\Callback\\PowerState"); InitializeObjectAttributes(&objectAttributes, &unicodeString, OBJ_CASE_INSENSITIVE, 0, 0); status = ExCreateCallback(&(pDeviceExtension->pCallbackObject), &objectAttributes, FALSE, /// Do not create as the system should already have done this TRUE); /// Allow multiple callbacks if(status != STATUS_SUCCESS) { DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL, " !!!! RegisterPowerStateChangeCallback : ExCreateCallback() [status: %#x]\n", status); HLPR_BAIL; } pDeviceExtension->pRegistration = ExRegisterCallback(pDeviceExtension->pCallbackObject, PowerStateCallback, pDeviceExtension); HLPR_BAIL_LABEL: #if DBG DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_INFO_LEVEL, " <--- RegisterPowerStateChangeCallback() [status: %#x]\n", status); #endif /// DBG return status; }
// Registers power callback _Use_decl_annotations_ NTSTATUS PowerCallbackInitialization() { PAGED_CODE(); UNICODE_STRING name = RTL_CONSTANT_STRING(L"\\Callback\\PowerState"); OBJECT_ATTRIBUTES oa = RTL_CONSTANT_OBJECT_ATTRIBUTES(&name, OBJ_CASE_INSENSITIVE); auto status = ExCreateCallback(&g_pcp_callback_object, &oa, FALSE, TRUE); if (!NT_SUCCESS(status)) { return status; } g_pcp_registration = ExRegisterCallback( g_pcp_callback_object, PowerCallbackpCallbackRoutine, nullptr); if (!g_pcp_registration) { ObDereferenceObject(g_pcp_callback_object); g_pcp_callback_object = nullptr; return STATUS_UNSUCCESSFUL; } return status; }
NTSTATUS register_power_callback(PDEV_EXT ext) { OBJECT_ATTRIBUTES obj; UNICODE_STRING name; NTSTATUS status; RtlInitUnicodeString(&name, L"\\Callback\\PowerState"); InitializeObjectAttributes(&obj, &name, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ExCreateCallback(&ext->CbObject, &obj, FALSE, TRUE); if (!NT_SUCCESS(status)) return status; ext->CbRegistration = ExRegisterCallback(ext->CbObject, power_callback, ext); if (!ext->CbRegistration) { ObDereferenceObject(ext->CbObject); return STATUS_UNSUCCESSFUL; } return STATUS_SUCCESS; }
NTSTATUS drbdlockStartupCallback( VOID ) /*++ Routine Description: Initializes callback object to be notified. Arguments: None. Return Value: NtStatus values. --*/ { NTSTATUS status = STATUS_UNSUCCESSFUL; OBJECT_ATTRIBUTES oa = { 0, }; UNICODE_STRING usCallbackName; RtlInitUnicodeString(&usCallbackName, DRBDLOCK_CALLBACK_NAME); InitializeObjectAttributes(&oa, &usCallbackName, OBJ_CASE_INSENSITIVE | OBJ_PERMANENT, 0, 0); status = ExCreateCallback(&g_pCallbackObj, &oa, TRUE, TRUE); if (!NT_SUCCESS(status)) { drbdlock_print_log("ExCreateCallback failed, status : 0x%x\n", status); return status; } g_pCallbackReg = ExRegisterCallback(g_pCallbackObj, drbdlockCallbackFunc, NULL); return status; }
RT_C_DECLS_END /** * Driver entry point. * * @returns appropriate status code. * @param pDrvObj Pointer to driver object. * @param pRegPath Registry base path. */ ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath) { NTSTATUS rc; /* * Create device. * (That means creating a device object and a symbolic link so the DOS * subsystems (OS/2, win32, ++) can access the device.) */ UNICODE_STRING DevName; RtlInitUnicodeString(&DevName, DEVICE_NAME_NT); PDEVICE_OBJECT pDevObj; rc = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXT), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevObj); if (NT_SUCCESS(rc)) { UNICODE_STRING DosName; RtlInitUnicodeString(&DosName, DEVICE_NAME_DOS); rc = IoCreateSymbolicLink(&DosName, &DevName); if (NT_SUCCESS(rc)) { int vrc = RTR0Init(0); if (RT_SUCCESS(vrc)) { Log(("VBoxDrv::DriverEntry\n")); /* * Initialize the device extension. */ PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension; memset(pDevExt, 0, sizeof(*pDevExt)); vrc = supdrvInitDevExt(pDevExt, sizeof(SUPDRVSESSION)); if (!vrc) { /* * Setup the driver entry points in pDrvObj. */ pDrvObj->DriverUnload = VBoxDrvNtUnload; pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxDrvNtCreate; pDrvObj->MajorFunction[IRP_MJ_CLEANUP] = VBoxDrvNtCleanup; pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxDrvNtClose; pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxDrvNtDeviceControl; pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxDrvNtInternalDeviceControl; pDrvObj->MajorFunction[IRP_MJ_READ] = VBoxDrvNtNotSupportedStub; pDrvObj->MajorFunction[IRP_MJ_WRITE] = VBoxDrvNtNotSupportedStub; /* more? */ /* Register ourselves for power state changes. */ UNICODE_STRING CallbackName; OBJECT_ATTRIBUTES Attr; RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState"); InitializeObjectAttributes(&Attr, &CallbackName, OBJ_CASE_INSENSITIVE, NULL, NULL); rc = ExCreateCallback(&pDevExt->pObjPowerCallback, &Attr, TRUE, TRUE); if (rc == STATUS_SUCCESS) pDevExt->hPowerCallback = ExRegisterCallback(pDevExt->pObjPowerCallback, VBoxPowerDispatchCallback, pDevObj); Log(("VBoxDrv::DriverEntry returning STATUS_SUCCESS\n")); return STATUS_SUCCESS; } Log(("supdrvInitDevExit failed with vrc=%d!\n", vrc)); rc = VBoxDrvNtErr2NtStatus(vrc); IoDeleteSymbolicLink(&DosName); RTR0Term(); } else { Log(("RTR0Init failed with vrc=%d!\n", vrc)); rc = VBoxDrvNtErr2NtStatus(vrc); } } else Log(("IoCreateSymbolicLink failed with rc=%#x!\n", rc)); IoDeleteDevice(pDevObj); } else Log(("IoCreateDevice failed with rc=%#x!\n", rc)); if (NT_SUCCESS(rc)) rc = STATUS_INVALID_PARAMETER; Log(("VBoxDrv::DriverEntry returning %#x\n", rc)); return rc; }
BOOLEAN ndisprotRegisterExCallBack() { OBJECT_ATTRIBUTES ObjectAttr; UNICODE_STRING CallBackObjectName; NTSTATUS Status; BOOLEAN bResult = TRUE; DEBUGP(DL_LOUD, ("--> ndisprotRegisterExCallBack\n")); PAGED_CODE(); do { RtlInitUnicodeString(&CallBackObjectName, NDISPROT_CALLBACK_NAME); InitializeObjectAttributes(&ObjectAttr, &CallBackObjectName, OBJ_CASE_INSENSITIVE | OBJ_PERMANENT, NULL, NULL); Status = ExCreateCallback(&CallbackObject, &ObjectAttr, TRUE, TRUE); if (!NT_SUCCESS(Status)) { DEBUGP(DL_ERROR, ("RegisterExCallBack: failed to create callback %lx\n", Status)); bResult = FALSE; break; } CallbackRegisterationHandle = ExRegisterCallback(CallbackObject, ndisprotCallback, (PVOID)NULL); if (CallbackRegisterationHandle == NULL) { DEBUGP(DL_ERROR,("RegisterExCallBack: failed to register a Callback routine%lx\n", Status)); bResult = FALSE; break; } ExNotifyCallback(CallbackObject, (PVOID)CALLBACK_SOURCE_NDISPROT, (PVOID)NULL); }while(FALSE); if(!bResult) { if (CallbackRegisterationHandle) { ExUnregisterCallback(CallbackRegisterationHandle); CallbackRegisterationHandle = NULL; } if (CallbackObject) { ObDereferenceObject(CallbackObject); CallbackObject = NULL; } } DEBUGP(DL_LOUD, ("<-- ndisprotRegisterExCallBack\n")); return bResult; }
/** * Driver entry point. * * @returns appropriate status code. * @param pDrvObj Pointer to driver object. * @param pRegPath Registry base path. */ ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath) { /* * Create device. * (That means creating a device object and a symbolic link so the DOS * subsystems (OS/2, win32, ++) can access the device.) */ NTSTATUS rcNt = vboxdrvNtCreateDevices(pDrvObj); if (NT_SUCCESS(rcNt)) { int vrc = RTR0Init(0); if (RT_SUCCESS(vrc)) { Log(("VBoxDrv::DriverEntry\n")); /* * Initialize the device extension. */ PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension; memset(pDevExt, 0, sizeof(*pDevExt)); vrc = supdrvInitDevExt(pDevExt, sizeof(SUPDRVSESSION)); if (!vrc) { /* * Setup the driver entry points in pDrvObj. */ pDrvObj->DriverUnload = VBoxDrvNtUnload; pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxDrvNtCreate; pDrvObj->MajorFunction[IRP_MJ_CLEANUP] = VBoxDrvNtCleanup; pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxDrvNtClose; pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxDrvNtDeviceControl; pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxDrvNtInternalDeviceControl; pDrvObj->MajorFunction[IRP_MJ_READ] = VBoxDrvNtNotSupportedStub; pDrvObj->MajorFunction[IRP_MJ_WRITE] = VBoxDrvNtNotSupportedStub; /* more? */ /* Register ourselves for power state changes. */ UNICODE_STRING CallbackName; OBJECT_ATTRIBUTES Attr; RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState"); InitializeObjectAttributes(&Attr, &CallbackName, OBJ_CASE_INSENSITIVE, NULL, NULL); rcNt = ExCreateCallback(&pDevExt->pObjPowerCallback, &Attr, TRUE, TRUE); if (rcNt == STATUS_SUCCESS) pDevExt->hPowerCallback = ExRegisterCallback(pDevExt->pObjPowerCallback, VBoxPowerDispatchCallback, g_pDevObjSys); Log(("VBoxDrv::DriverEntry returning STATUS_SUCCESS\n")); return STATUS_SUCCESS; } Log(("supdrvInitDevExit failed with vrc=%d!\n", vrc)); rcNt = VBoxDrvNtErr2NtStatus(vrc); RTR0Term(); } else { Log(("RTR0Init failed with vrc=%d!\n", vrc)); rcNt = VBoxDrvNtErr2NtStatus(vrc); } vboxdrvNtDestroyDevices(); } if (NT_SUCCESS(rcNt)) rcNt = STATUS_INVALID_PARAMETER; return rcNt; }
NTSTATUS NTAPI DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath) { NTSTATUS Status; PDRIVER_EXTENSION DriverExtension; OBJECT_ATTRIBUTES ObjectAttributes; UNICODE_STRING CallbackName; /* Allocate registry path */ GlobalRegistryPath.MaximumLength = RegistryPath->Length + sizeof(UNICODE_NULL); GlobalRegistryPath.Length = RegistryPath->Length; GlobalRegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool, GlobalRegistryPath.MaximumLength, 'MtaB'); if (!GlobalRegistryPath.Buffer) { /* Fail if we're out of memory this early */ if (CmBattDebug & CMBATT_GENERIC_WARNING) DbgPrint("CmBatt: Couldn't allocate pool for registry path."); return STATUS_INSUFFICIENT_RESOURCES; } /* Buffer allocated, copy the string */ RtlCopyUnicodeString(&GlobalRegistryPath, RegistryPath); if (CmBattDebug & CMBATT_GENERIC_INFO) DbgPrint("CmBatt DriverEntry - Obj (%08x) Path \"%ws\"\n", DriverObject, RegistryPath->Buffer); /* Setup the major dispatchers */ DriverObject->MajorFunction[IRP_MJ_CREATE] = CmBattOpenClose; DriverObject->MajorFunction[IRP_MJ_CLOSE] = CmBattOpenClose; DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = CmBattIoctl; DriverObject->MajorFunction[IRP_MJ_POWER] = CmBattPowerDispatch; DriverObject->MajorFunction[IRP_MJ_PNP] = CmBattPnpDispatch; DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = CmBattSystemControl; /* And the unload routine */ DriverObject->DriverUnload = CmBattUnload; /* And the add device routine */ DriverExtension = DriverObject->DriverExtension; DriverExtension->AddDevice = CmBattAddDevice; /* Create a power callback */ RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState"); InitializeObjectAttributes(&ObjectAttributes, &CallbackName, OBJ_KERNEL_HANDLE, NULL, NULL); Status = ExCreateCallback(&CmBattPowerCallBackObject, &ObjectAttributes, 0, TRUE); if (!NT_SUCCESS(Status)) { /* No callback, fail */ CmBattPowerCallBackObject = 0; if (CmBattDebug & CMBATT_GENERIC_WARNING) DbgPrint("CmBattRegisterPowerCallBack: failed status=0x%08x\n", Status); } else { /* Register the power callback now */ CmBattPowerCallBackRegistration = ExRegisterCallback(CmBattPowerCallBackObject, (PVOID)CmBattPowerCallBack, DriverObject); if (CmBattPowerCallBackRegistration) { /* Last thing: setup our DPC and timer for battery wake */ KeInitializeDpc(&CmBattWakeDpcObject, (PVOID)CmBattWakeDpc, DriverObject); KeInitializeTimer(&CmBattWakeDpcTimerObject); } else { ObDereferenceObject(CmBattPowerCallBackObject); if (CmBattDebug & CMBATT_GENERIC_WARNING) DbgPrint("CmBattRegisterPowerCallBack: ExRegisterCallback failed.\n"); } /* All good */ Status = STATUS_SUCCESS; } /* Return failure or success */ return Status; }