NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
// Initialize WPP tracing.
WPP_INIT_TRACING(DriverObject, RegistryPath);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT, "--> %!FUNC!");
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = PVPanicEvtDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT(&config, PVPanicEvtDeviceAdd);
status = WdfDriverCreate(DriverObject, RegistryPath, &attributes,
&config, WDF_NO_HANDLE);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDriverCreate failed: %!STATUS!", status);
WPP_CLEANUP(DriverObject);
}
else
{
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT, "<-- %!FUNC!");
}
return status;
}
NTSTATUS DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
DebugPrint(("Mouse Filter Driver Sample - Driver Framework Edition.\n"));
DebugPrint(("Built %s %s\n", __DATE__, __TIME__));
WDF_DRIVER_CONFIG_INIT(&config, MouFilter_EvtDeviceAdd);
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES,
&config, WDF_NO_HANDLE);
if (!NT_SUCCESS(status)) {
DebugPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
KdPrint((__DRIVER_NAME "--> DriverEntry of LedsCtrl\n"));
WDF_DRIVER_CONFIG_INIT(&config, EvtDeviceAdd);
status = WdfDriverCreate(
DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE);
if(!NT_SUCCESS(status))
{
KdPrint((__DRIVER_NAME "WdfDriverCreate failed with status 0x%08x\n", status));
}
return status;
}
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
PSDrv_DbgPrint(3, ("Prime Sensor Driver v%s - DebEgg Edition.\n", PSDRV_BRIEF_VERSION_STRING));
PSDrv_DbgPrint(3, ("Built %s %s\n", __DATE__, __TIME__));
// Initialize driver config to control the attributes that
// are global to the driver. Note that framework by default
// provides a driver unload routine. If you create any resources
// in the DriverEntry and want to be cleaned in driver unload,
// you can override that by manually setting the EvtDriverUnload in the
// config structure. In general xxx_CONFIG_INIT macros are provided to
// initialize most commonly used members.
WDF_DRIVER_CONFIG_INIT(&config, PSDrv_EvtDeviceAdd);
// Create a framework driver object to represent our driver.
status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(1, ("WdfDriverCreate failed! (Status = %x)\n", status));
}
return status;
}
///////////////////////////////////////////////////////////////////////////////
//
// DriverEntry
//
// This routine is called by Windows when the driver is first loaded. It
// is the responsibility of this routine to create the WDFDRIVER
//
// INPUTS:
//
// DriverObject - Address of the DRIVER_OBJECT created by Windows for this
// driver.
//
// RegistryPath - UNICODE_STRING which represents this driver's key in the
// Registry.
//
// OUTPUTS:
//
// None.
//
// RETURNS:
//
// STATUS_SUCCESS, otherwise an error indicating why the driver could not
// load.
//
// IRQL:
//
// This routine is called at IRQL == PASSIVE_LEVEL.
//
// NOTES:
//
//
///////////////////////////////////////////////////////////////////////////////
extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
#if DBG
DbgPrint("\nOSR BasicUsb Driver -- Compiled %s %s\n",__DATE__, __TIME__);
#endif
//
// Provide pointer to our EvtDeviceAdd event processing callback
// function
//
WDF_DRIVER_CONFIG_INIT(&config, BasicUsbEvtDeviceAdd);
//
// Create our WDFDriver instance
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDriverCreate failed 0x%0x\n", status);
#endif
}
return(status);
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
NTSTATUS status;
WDF_DRIVER_CONFIG driverConfig;
WDF_DRIVER_CONFIG_INIT(&driverConfig,
EvtDeviceAdd);
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&driverConfig,
WDF_NO_HANDLE);
if (!NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"Error: WdfDriverCreate failed 0x%x", status);
return status;
}
return status;
}
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject,PUNICODE_STRING RegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
PAGED_CODE();
KdPrintEx((DPFLTR_PNPMEM_ID, DPFLTR_INFO_LEVEL,
"TPM Driver - using Windows Driver Frame"));
ProcessNameOffset = GetProcessNameOffset();
//
// Initialize the Driver Config structure.
//
WDF_DRIVER_CONFIG_INIT( &config, TpmEvtDeviceAdd );
//
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
//
status = WdfDriverCreate( DriverObject,
RegistryPath,
NULL,
&config,
WDF_NO_HANDLE);
if (!NT_SUCCESS(status)) {
KdPrintEx((DPFLTR_PNPMEM_ID, DPFLTR_INFO_LEVEL,
"WdfDriverCreate failed with status %!STATUS!", status));
}
return status;
}
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
WPP_INIT_TRACING(DriverObject, RegistryPath);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT,
"Virtio-Serial driver started...built on %s %s\n", __DATE__, __TIME__);
WDF_DRIVER_CONFIG_INIT(&config,VIOSerialEvtDeviceAdd);
config.DriverPoolTag = VIOSERIAL_DRIVER_MEMORY_TAG;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = VIOSerialEvtDriverContextCleanup;
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
WDF_NO_HANDLE);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDriverCreate failed - 0x%x\n", status);
WPP_CLEANUP(DriverObject);
return status;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
return status;
}
NTSTATUS AndroidUsbDriverObject::OnDriverEntry(PDRIVER_OBJECT drv_object,
PUNICODE_STRING reg_path) {
ASSERT_IRQL_PASSIVE();
ASSERT(driver_object() == drv_object);
// Initiialize driver config, specifying our unload callback and default
// pool tag for memory allocations that KMDF does on our behalf.
WDF_DRIVER_CONFIG config;
WDF_DRIVER_CONFIG_INIT(&config, EvtDeviceAddEntry);
config.EvtDriverUnload = EvtDriverUnloadEntry;
config.DriverPoolTag = GANDR_POOL_TAG_DEFAULT;
// Create a framework driver object to represent our driver.
NTSTATUS status = WdfDriverCreate(drv_object,
reg_path,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
&wdf_driver_);
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status))
return status;
GoogleDbgPrint("\n>>>>>>>>>> Android USB driver has started >>>>>>>>>>");
return STATUS_SUCCESS;
}
EXTERN_C INIT NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING registryPath)
{
auto registration = TraceLoggingRegistration(KtlTestTracing);
LogEntry();
WDF_OBJECT_ATTRIBUTES driverAttributes;
WDF_OBJECT_ATTRIBUTES_INIT(&driverAttributes);
WDX_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&driverAttributes, DriverContext);
WDF_DRIVER_CONFIG driverConfig;
WDF_DRIVER_CONFIG_INIT(&driverConfig, nullptr);
driverConfig.DriverInitFlags = WdfDriverInitNonPnpDriver;
driverConfig.EvtDriverUnload = [](WDFDRIVER) PAGED {
// do nothing, just to allow driver to be stopped
// all cleanup is done via DriverContext's destructor
};
WDFDRIVER wdfDriver;
RETURN_IF_NOT_NT_SUCCESS(WdfDriverCreate(driver, registryPath, &driverAttributes, &driverConfig, &wdfDriver));
WDX_INIT_CONTEXT(wdfDriver, DriverContext, std::move(registration));
RETURN_IF_NOT_NT_SUCCESS(CreateTestDevice(wdfDriver));
SuccessExit();
}
NTSTATUS
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
#if DBG
DbgPrint("CDFilter: OSR CDFILTER Filter Driver...Compiled %s %s\n" ,__DATE__, __TIME__);
#endif
//
// Initialize our driver config structure, specifying our
// EvtDeviceAdd event processing callback.
//
WDF_DRIVER_CONFIG_INIT(&config,
CDFilterEvtDeviceAdd);
//
// Create the framework driver object...
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
NULL);
if (!NT_SUCCESS(status)) {
#if DBG
DbgPrint("WdfDriverCreate failed - 0x%x\n", status);
#endif
return status;
}
return STATUS_SUCCESS;
}
//Installable driver initialization entry point. This entry point is called directly by the I/O system.
//
NTSTATUS DriverEntry (_In_ PDRIVER_OBJECT pDriverObject, _In_ PUNICODE_STRING pszRegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
// Initialize WPP Tracing
WPP_INIT_TRACING(pDriverObject, pszRegistryPath);
TraceInfo(DBG_INIT, "(%!FUNC!) Enter -Sample Built %s %s\n", __DATE__, __TIME__);
WDF_DRIVER_CONFIG_INIT(&config, HidFx2EvtDeviceAdd);
// Register a cleanup callback so that we can call WPP_CLEANUP when the framework driver object is deleted during driver unload.
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = HidFx2EvtDriverContextCleanup;
// Create a framework driver object to represent our driver.
status = WdfDriverCreate(pDriverObject,
pszRegistryPath,
&attributes, // Driver Attributes
&config, // Driver Config Info
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status))
{
TraceErr(DBG_INIT, "(%!FUNC!)WdfDriverCreate failed with status %!STATUS!\n", status);
WPP_CLEANUP(pDriverObject);
}
TraceVerbose(DBG_INIT, "(%!FUNC!) Exit\n");
return status;
}
NTSTATUS
DriverEntry(
/*IN*/PDRIVER_OBJECT DriverObject,
/*IN*/PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Installable driver initialization entry point.
This entry point is called directly by the I/O system.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path,
to driver-specific key in the registry.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
NTSTATUS ntStatus = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
//ENTER("DriverEntry");
// //TRACE(TL_TRACE, ("1394VDev Sample - Driver Framework Edition \n"));
// TRACE(TL_TRACE, ("Built %s %s\n", __DATE__, __TIME__));
//
// Initialize the Driver Config structure..
//
WDF_DRIVER_CONFIG_INIT(
&config,
t1394_EvtDeviceAdd
);
//
// Create a WDFDRIVER object.
//
ntStatus = WdfDriverCreate(
DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE
);
if (!NT_SUCCESS(ntStatus)) {
// TRACE(TL_ERROR, ("WdfDriverCreate failed with status %x\n", ntStatus));
}
//EXIT("DriverEntry", ntStatus);
return(ntStatus);
} // DriverEntry
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
// Initialize the WPP tracing.
WPP_INIT_TRACING(DriverObject, RegistryPath);
Trace(TRACE_LEVEL_VERBOSE, "[%s] -->", __FUNCTION__);
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = VioCryptDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT(&config, VioCryptDeviceAdd);
status = WdfDriverCreate(DriverObject, RegistryPath, &attributes,
&config, WDF_NO_HANDLE);
if (!NT_SUCCESS(status))
{
Trace(TRACE_LEVEL_ERROR, "[%s] WdfDriverCreate failed: status %X", __FUNCTION__, status);
WPP_CLEANUP(DriverObject);
}
Trace(TRACE_LEVEL_VERBOSE, "[%s] -->", __FUNCTION__);
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Initialize the call backs structure of Driver Framework.
Arguments:
DriverObject - pointer to the driver object
RegistryPath - pointer to a unicode string representing the path,
to driver-specific key in the registry.
Return Value:
NT Status Code
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDFDRIVER driver;
KdPrint(("WDF Toaster Bus Driver Sample Dynamic Version.\n"));
KdPrint(("Built %s %s\n", __DATE__, __TIME__));
//
// Initiialize driver config to control the attributes that
// are global to the driver. Note that framework by default
// provides a driver unload routine. If you create any resources
// in the DriverEntry and want to be cleaned in driver unload,
// you can override that by specifing one in the Config structure.
//
WDF_DRIVER_CONFIG_INIT(
&config,
Bus_EvtDeviceAdd
);
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
&driver);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
/*函数入口*/
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG config;
/*设置添加设备的函数地址*/
WDF_DRIVER_CONFIG_INIT(&config,RamDiskEvtDeviceAdd);
return WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES,&config,WDF_NO_HANDLE);
}
_Use_decl_annotations_
NTSTATUS
DriverEntry(
PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the device driver. This routine
creates the driver object for the TrEE miniport.
Arguments:
DriverObject - Supplies a pointer to driver object created by the
system.
RegistryPath - Supplies a unicode string indentifying where the
parameters for this driver are located in the registry.
Return Value:
NTSTATUS code.
--*/
{
WDFDRIVER Driver;
WDF_DRIVER_CONFIG DriverConfig;
NTSTATUS Status;
Driver = NULL;
//
// Create the WDF driver object
//
WDF_DRIVER_CONFIG_INIT(&DriverConfig, TreeSampleEvtAddDevice);
DriverConfig.EvtDriverUnload = DriverUnload;
Status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&DriverConfig,
&Driver);
if (!NT_SUCCESS(Status)) {
goto DriverEntryEnd;
}
DriverEntryEnd:
return Status;
}
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
WDF_OBJECT_ATTRIBUTES attributes;
WDFDRIVER Driver;
PDRIVER_CONTEXT Context;
#if (NTDDI_VERSION > NTDDI_WIN7)
ExInitializeDriverRuntime(DrvRtPoolNxOptIn);
#endif
WPP_INIT_TRACING(DriverObject, RegistryPath);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT,
"Virtio-Serial driver started...built on %s %s\n", __DATE__, __TIME__);
WDF_DRIVER_CONFIG_INIT(&config,VIOSerialEvtDeviceAdd);
config.DriverPoolTag = VIOSERIAL_DRIVER_MEMORY_TAG;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DRIVER_CONTEXT);
attributes.EvtCleanupCallback = VIOSerialEvtDriverContextCleanup;
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
&Driver);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDriverCreate failed - 0x%x\n", status);
WPP_CLEANUP(DriverObject);
return status;
}
Context = GetDriverContext(Driver);
// create a lookaside list used for allocating WRITE_BUFFER_ENTRY
// structures by all devices
status = WdfLookasideListCreate(WDF_NO_OBJECT_ATTRIBUTES,
sizeof(WRITE_BUFFER_ENTRY),
NonPagedPool,
WDF_NO_OBJECT_ATTRIBUTES,
VIOSERIAL_DRIVER_MEMORY_TAG,
&Context->WriteBufferLookaside);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfLookasideListCreate failed - 0x%x\n", status);
return status;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as FmAddDevice and FmUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG config;
KdPrint(("Fakemode Function Driver Sample - Driver Framework Edition.\n"));
KdPrint(("Built %s %s\n", __DATE__, __TIME__));
WDF_DRIVER_CONFIG_INIT( &config, FmEvtDeviceAdd );
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(
DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config, // Driver Config Info
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status)) {
KdPrint( ("WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as EvtDevice and DriverUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
//
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = CVWindowsInternalsEvtDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT(&config,
CVWindowsInternalsEvtDeviceAdd
);
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
WDF_NO_HANDLE
);
return status;
}
NTSTATUS
#pragma prefast(suppress:__WARNING_DRIVER_FUNCTION_TYPE, "thanks, i know this already")
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
/*WDF_DRIVER_CONFIG_INIT(&driverConfig, OnDeviceAdd);*/
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG driverConfig;
WDF_OBJECT_ATTRIBUTES driverAttributes;
WDFDRIVER fxDriver;
WPP_INIT_TRACING(DriverObject, RegistryPath);
FuncEntry(TRACE_FLAG_WDFLOADING);
WDF_DRIVER_CONFIG_INIT(&driverConfig, OnDeviceAdd);
driverConfig.DriverPoolTag = SPBT_POOL_TAG;
WDF_OBJECT_ATTRIBUTES_INIT(&driverAttributes);
driverAttributes.EvtCleanupCallback = OnDriverCleanup;
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
&driverAttributes,
&driverConfig,
&fxDriver
);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating WDF driver object - %!STATUS!",
status);
goto exit;
}
Trace(
TRACE_LEVEL_VERBOSE,
TRACE_FLAG_WDFLOADING,
"Created WDF driver object");
exit:
FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as EvtDevice and DriverUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = RoboDeviceEvtDriverContextCleanup;
WDF_DRIVER_CONFIG_INIT( &config, RoboDeviceEvtDeviceAdd );
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
WDF_NO_HANDLE
);
if (!NT_SUCCESS(status)) {
return status;
}
DbgPrintEx( DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "DriverEntry Exit %x", status );
return status;
}
NTSTATUS DriverEntry(DRIVER_OBJECT* driverObject, UNICODE_STRING* registryPath) {
WDF_DRIVER_CONFIG config;
WDF_DRIVER_CONFIG_INIT(&config, MouseTrapEvtDeviceAdd);
NTSTATUS status = WdfDriverCreate(driverObject, registryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE);
if(!NT_SUCCESS(status)) {
DebugPrint(("[MouseTrap] WdfDriverCreate failed with status 0x%x\n", status));
}
return status;
}
NTSTATUS
StreamEditInitDriverObjects(
_Inout_ DRIVER_OBJECT* driverObject,
const UNICODE_STRING* registryPath,
_Out_ WDFDRIVER* pDriver,
_Out_ WDFDEVICE* pDevice
)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
PWDFDEVICE_INIT pInit = NULL;
WDF_DRIVER_CONFIG_INIT(&config, WDF_NO_EVENT_CALLBACK);
config.DriverInitFlags |= WdfDriverInitNonPnpDriver;
config.EvtDriverUnload = StreamEditEvtDriverUnload;
status = WdfDriverCreate(
driverObject,
registryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
pDriver
);
if (!NT_SUCCESS(status))
{
goto Exit;
}
pInit = WdfControlDeviceInitAllocate(*pDriver, &SDDL_DEVOBJ_KERNEL_ONLY);
if (!pInit)
{
status = STATUS_INSUFFICIENT_RESOURCES;
goto Exit;
}
WdfDeviceInitSetCharacteristics(pInit, FILE_AUTOGENERATED_DEVICE_NAME, TRUE);
WdfDeviceInitSetDeviceType(pInit, FILE_DEVICE_NETWORK);
WdfDeviceInitSetCharacteristics(pInit, FILE_DEVICE_SECURE_OPEN, TRUE);
status = WdfDeviceCreate(&pInit, WDF_NO_OBJECT_ATTRIBUTES, pDevice);
if (!NT_SUCCESS(status))
{
WdfDeviceInitFree(pInit);
goto Exit;
}
WdfControlFinishInitializing(*pDevice);
Exit:
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
DriverEntry initializes the driver and is the first routine called by the
system after the driver is loaded. DriverEntry specifies the other entry
points in the function driver, such as EvtDevice and DriverUnload.
Parameters Description:
DriverObject - represents the instance of the function driver that is loaded
into memory. DriverEntry must initialize members of DriverObject before it
returns to the caller. DriverObject is allocated by the system before the
driver is loaded, and it is released by the system after the system unloads
the function driver from memory.
RegistryPath - represents the driver specific path in the Registry.
The function driver can use the path to store driver related data between
reboots. The path does not store hardware instance specific data.
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise.
--*/
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_DRIVER_CONFIG_INIT(&config,
EchoEvtDeviceAdd
);
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
WDF_NO_HANDLE);
if (!NT_SUCCESS(status)) {
KdPrint(("Error: WdfDriverCreate failed 0x%x\n", status));
return status;
}
#if DBG
EchoPrintDriverVersion();
#endif
return status;
}
NTSTATUS
DriverEntry (
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine is the driver initialization entry point.
Arguments:
DriverObject - Pointer to the driver object created by the I/O manager.
RegistryPath - Pointer to the driver specific registry key.
Return Value:
NTSTATUS code.
--*/
{
WDFDRIVER Driver;
WDF_DRIVER_CONFIG DriverConfig;
NTSTATUS Status;
//
// Initialize the driver configuration structure.
//
WDF_DRIVER_CONFIG_INIT(&DriverConfig, SampleDrvEvtDeviceAdd);
//
// Create a framework driver object to represent our driver.
//
Status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&DriverConfig,
&Driver);
if (!NT_SUCCESS(Status)) {
goto DriverEntryEnd;
}
DriverEntryEnd:
return Status;
}
NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
{
WDF_DRIVER_CONFIG config;
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
WDF_DRIVER_CONFIG_INIT(&config, IVSHMEMEvtDeviceAdd);
status = WdfDriverCreate(DriverObject, RegistryPath, &attributes, &config, WDF_NO_HANDLE);
return status;
}
NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath )
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
// 注册EvtDriverDeviceAdd回调函数
WDF_DRIVER_CONFIG_INIT(&config, EvtDriverDeviceAdd);
// 创建驱动对象
status = WdfDriverCreate(DriverObject, RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE );
return status;
}
_Use_decl_annotations_
NTSTATUS DriverEntry (
DRIVER_OBJECT* DriverObjectPtr,
UNICODE_STRING* RegistryPathPtr
)
{
PAGED_CODE();
//
// Initialize logging
//
{
WPP_INIT_TRACING(DriverObjectPtr, RegistryPathPtr);
RECORDER_CONFIGURE_PARAMS recorderConfigureParams;
RECORDER_CONFIGURE_PARAMS_INIT(&recorderConfigureParams);
WppRecorderConfigure(&recorderConfigureParams);
#if DBG
WPP_RECORDER_LEVEL_FILTER(BSC_TRACING_VERBOSE) = TRUE;
#endif // DBG
}
NTSTATUS status;
WDFDRIVER wdfDriver;
{
WDF_DRIVER_CONFIG wdfDriverConfig;
WDF_DRIVER_CONFIG_INIT(&wdfDriverConfig, OnDeviceAdd);
wdfDriverConfig.DriverPoolTag = BCM_I2C_POOL_TAG;
wdfDriverConfig.EvtDriverUnload = OnDriverUnload;
status = WdfDriverCreate(
DriverObjectPtr,
RegistryPathPtr,
WDF_NO_OBJECT_ATTRIBUTES,
&wdfDriverConfig,
&wdfDriver);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"Failed to create WDF driver object. (DriverObjectPtr = %p, RegistryPathPtr = %p)",
DriverObjectPtr,
RegistryPathPtr);
return status;
}
}
NT_ASSERT(NT_SUCCESS(status));
return STATUS_SUCCESS;
}
NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "Driver Loaded\n"));
// Initialize the driver config structure
WDF_DRIVER_CONFIG_INIT(&config, NULL);
// Indicate that this is a non-PNP driver
config.DriverInitFlags = WdfDriverInitNonPnpDriver;
// Specify the callout driver's Unload function
config.EvtDriverUnload = EvtDriverUnload;
status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE);
ExploreEPROCESS();
return status;
}
