|
| client* | client_create() override |
| | a client for an open of the driver itself: none where the platform gives the driver no access point of its own
|
| virtual os_result | ioctl(unsigned int ioctl, const void* in, size_t size_in, void* out, size_t size_out, size_t& size) |
| | driver-wide control I/O: the version, and the log mask - the input sets it, the output reads it back
|
| | operator const ::HANDLE() const |
| | power(::DRIVER_OBJECT* wdm_driver, ::UNICODE_STRING* registry, const dxd::guid& guid= 0) |
| | the driver's dispatch, its power IRPs this policy's
|
| | power(::IOService* service) |
| template<typename type_t> |
| os_result | query(const ::UNICODE_STRING& key, type_t& value) |
| template<typename key_t, typename type_t> |
| os_result | query(key_t* key, type_t& value) |
| os_result | remove() |
| os_result | set(const ::UNICODE_STRING& key, const ::GUID& value) |
| os_result | set(const ::UNICODE_STRING& key, const ::UNICODE_STRING& value, unsigned long type= REG_SZ) |
| os_result | set(const ::UNICODE_STRING& key, const char* value) |
| os_result | set(const ::UNICODE_STRING& key, const wchar_t* value) |
| os_result | set(const ::UNICODE_STRING& key, unsigned int value) |
| template<typename key_t, typename type_t> |
| os_result | set(key_t* key, const type_t& value) |
| device* | start(::IOService* shell, ::IOService* provider) |
| | a device's shell starts on its provider: the device of the pending request, or of the hardware the OS matched, launched
|
| void | stop(::IOService* shell) |
| | a device's shell stops: it leaves the driver's devices
|
| template<typename type_t> |
| unsigned long | type() |
|
| virtual device* | create(::DEVICE_OBJECT* wdm_device, ::DEVICE_OBJECT* wdm_pdo, ::DEVICE_OBJECT* wdm_bus)= 0 |
| | device factory, on the OS's arrival of a device - the plain form's AddDevice, a form's own start
|
| os_result | create(const void* request, size_t size) |
| os_result | destroy(const char* id) |
| void | dispatch(::DRIVER_OBJECT* wdm_driver) |
| | installs the clients' dispatch and the removal over what the form's registration wrote
|
| ::IOService* | find(const char* id) const |
| | the shell hosting the device of the given id
|
| virtual::NTSTATUS | forward(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| | an IRP that is not a control client's: down the stack
|
| virtual os_result | started(device &) |
| | a device started, in every form: what a driver binds per device (dxd::power) binds here
|
|
| ::NTSTATUS | __cleanup(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| | IRP_MJ_CLEANUP concludes the client, IRP_MJ_CLOSE deletes it and lets its device go.
|
| ::NTSTATUS | __close(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| ::NTSTATUS | __create(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| | control opens carry no file name; a KS filter open carries its reference string
|
| ::NTSTATUS | __device_add(::DRIVER_OBJECT* wdm_driver, ::DEVICE_OBJECT* wdm_pdo) |
| | the plain form's arrival: an FDO on the PDO's stack and its device at once, which the resource filter and the start reach
|
| ::NTSTATUS | __forward(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| ::NTSTATUS | __ioctl(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| | METHOD_BUFFERED: SystemBuffer carries input and output.
|
| ::NTSTATUS | __plain(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| | the plain form's PnP around the forms' own (__pnp) The start launches the device with its resources once the bus started it. A stop - a rebalance - retires the device as its clients see a removal: unplugged(), conclude(), removed; a successor takes its place, which the next start launches on the new resources, and the retired one goes with its last client. The resource requirements pass the device's filter on their way up, the capabilities state a surprise removal expected, the device object goes behind the remove.
|
| ::NTSTATUS | __pnp(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
| static void | __unload(::DRIVER_OBJECT* wdm_driver) |
| ::NTSTATUS | complete(::IRP* irp, os_result status, size_t information= 0) |
| static device *& | context(::DEVICE_OBJECT* wdm_device) |
| static driver& | context(::DRIVER_OBJECT* wdm_driver) |
| static device::client *& | context(::FILE_OBJECT* wdm_file) |
| static bool | ours(::FILE_OBJECT* wdm_file) |
| | a control open: no file name, the device it opened in FsContext2 - which a rebalance may have retired since
|
DriverKit power policy: the device shell's SetPowerState tells its device.
plain WDM power policy: the FDO owns it
A dext whose devices the OS matches on their hardware makes it each shell's driver (platform::driver::owned()).
An S-IRP passes down, its completion requests the D-IRP of the system state - D0 for the working state, D3 otherwise - and the D-IRP's completion completes it. A D-IRP to D0 passes down first, the device wakes on its way back at passive level; one leaving D0 puts the device to sleep before it passes.
| ::NTSTATUS dxd::platform::driver::__plain(::DEVICE_OBJECT* wdm_device, ::IRP* irp) |
|
inlinestaticprotectedinherited |
the plain form's PnP around the forms' own (__pnp) The start launches the device with its resources once the bus started it. A stop - a rebalance - retires the device as its clients see a removal: unplugged(), conclude(), removed; a successor takes its place, which the next start launches on the new resources, and the retired one goes with its last client. The resource requirements pass the device's filter on their way up, the capabilities state a surprise removal expected, the device object goes behind the remove.