Second Lecture: My first drive

Original: http://blog.csdn.net/caperingrabbit/article/details/5285288

Once the development environment has been configured, it is necessary to understand the development of the driver through specific procedures. Below we use a WDM -driven framework to implement the HelloWorld of Windows drivers.

As a driver, the first thing to write is its entry function, which is the same as MFC 's Winmain or C + + main function, the driven entry function uses DriverEntry. The main functionality implemented in the Ingress function is the registration of some distribution routines and other transactions that need to be initialized.

the prototype of DriverEntry is Ntstatus driverentry (in Pdriver_object pdriverobject,in punicode_string pregistrypath), in ,out This is just a macro that represents the input and output type of the parameter, and it has no substantive meaning and does not occupy space. Pdriverobject is the driver object that we want to create, and Pregistrypath is the address of the driver in the registry. As for their type, Pdriver_object is an important data structure in the driver development, this is the driving object, the specific we will discuss later, and Punicode_string is a wide-character pointer, in the kernel development, the general use of strings are wide characters, that is  A Unicode string. Here's an example:

[CPP]View PlainCopy

2. extern"C" //is generally used in C + + for Windows Driver development, in front of the entry function to add this keyword, mainly in order to be able to call C function in the driver
4. NTSTATUS DriverEntry (in Pdriver_object pdriverobject,
6. In Punicode_string Pregistrypath
8. )
10. {
12. Kdprint (("hello!welcome to the Driver entry!/n")); Kdprint is a macro, similar to the Trace in MFC
14. //For common routines, this is also used to register with a common handler function
16. For (ULONG i = 0; I <= irp_mj_maximum_function; i++)
18. {
20. Pdriverobject->majorfunction[i] = Dispatchroutine;
22. }
26. //Driver function routine registration, which is a few more special routines that we register separately,
28. //And the main task of driving development is to complete their implementation functions of these routines, for simple and convenient to explain, used here and above the same
30. Pdriverobject->driverextension->adddevice = Mydeviceadd;
32. Pdriverobject->driverunload = Driverunload;
34. Pdriverobject->majorfunction[irp_mj_create] = Dispatchroutine;
36. Pdriverobject->majorfunction[irp_mj_close] = Dispatchroutine;
38. Pdriverobject->majorfunction[irp_mj_read] = Dispatchroutine;
40. Pdriverobject->majorfunction[irp_mj_write] = Dispatchroutine;
44. return status_success;
46. }

After the entry function is completed, the next step is to implement the function functions of the distribution routines registered above. As a WDM driver, you first need to create the device object, this task is given to the AddDevice routine, through the above registration, the implementation part of the Mydeviceadd.

[CPP]View PlainCopy

2. NTSTATUS Mydeviceadd (in Pdriver_object DriverObject,
4. In Pdevice_object Physicaldeviceobject)
6. {
8. Paged_code (); a macro provided by//DDK
10. Kdprint (("Enter mydrivers/n"));
14. NTSTATUS status;
16. Pdevice_object Fdo;
18. Unicode_string Devname;
20. Rtlinitunicodestring (&devname,l"//device//mydevice");
22. //Create a Device object
24. Status = IoCreateDevice (
26. DriverObject,
28. sizeof (device_extension),
30. & (unicode_string) Devname,
32. File_device_unknown,
34. 0,
36. FALSE,
38. &FDO);
40. if (! Nt_success (status))
42. return status;
44. //Get the data structure of the device extension. This data structure is generally defined by the user, saving some device-related information
46. Pdevice_extension PDX = (pdevice_extension) fdo->deviceextension;
48. //Configure the contents of the device extension
50. Pdx->fdo = FDO;
52. //Device Mount
54. Pdx->nextstackdevice = IoAttachDeviceToDeviceStack (FDO, physicaldeviceobject);
56. Unicode_string Symlinkname;
58. Rtlinitunicodestring (&symlinkname,l"//dosdevices//mydriver");
62. Pdx->ustrdevicename = Devname;
64. Pdx->ustrsymlinkname = Symlinkname;
66. Status = Iocreatesymboliclink (& (unicode_string) symlinkname,& (unicode_string) devname);
70. if (! Nt_success (status))
72. {
74. Iodeletesymboliclink (&pdx->ustrsymlinkname);
76. Status = Iocreatesymboliclink (&symlinkname,&devname);
78. if (! Nt_success (status))
80. {
82. return status;
84. }
86. }
88. //Set the IO status of the device
90. Fdo->flags |= Do_buffered_io | do_power_pagable;
92. Fdo->flags &= ~do_device_initializing;
96. Kdprint (("leavemydrivers/n"));
98. return status_success;
100. }

After the device object is generated, the next step is to process the various requests to the device. Here is a generic processing example to demonstrate. In fact, this handler function simply transfers these requests to the real device, with no actual functionality.

[CPP]View PlainCopy

2. NTSTATUS hellowdmdispatchroutine (in Pdevice_object FDO,
4. In Pirp IRP)
6. {
8. Paged_code ();
10. Kdprint (("Enter hellowdmdispatchroutine/n"));
12. Irp->iostatus.status = status_success;
14. irp->iostatus.information = 0; //   
16. IoCompleteRequest (IRP, io_no_increment);
18. Kdprint (("Leave hellowdmdispatchroutine/n"));
20. return status_success;
22. }
24. After all the requests are executed, the driver is uninstalled at the end. For WDM drivers, the standard programs actually unload routines with no real content, usually with PnP inside the Removedevice to deal with, here is just a demo, demonstrate the function and content of this routine.
26. VOID driverunload (in Pdriver_object pdriverobject)
28. {
30. Pdevice_object Pnextobj;
32. Kdprint (("Enter driverunload/n"));
34. Pnextobj = pdriverobject->deviceobject;
36. While (pnextobj! = NULL)
38. {
40. Pdevice_extension Pdevext = (pdevice_extension)
42. pnextobj->deviceextension;
46. //Remove Symbolic Links
48. Unicode_string Plinkname = pdevext->ustrsymlinkname;
50. Iodeletesymboliclink (&plinkname);
52. Pnextobj = pnextobj->nextdevice;
54. Iodeletedevice (Pdevext->pdevice);
56. }
58. }

In this way, the main part of a drive is completed. Then complete some fine work, compile, a driver appears.

Header file

[CPP]View PlainCopy

2. #ifdef __cplusplus
4. extern "C"
6. {
8. #endif
10. #include <wdm.h>
12. #ifdef __cplusplus
14. }
16. #endif
20. typedef struct _device_extension
22. {
24. Pdevice_object Fdo;
26. Pdevice_object Nextstackdevice;
28. Unicode_string Ustrdevicename; //Device name
30. Unicode_string Ustrsymlinkname; //Symbolic Link name
32. } device_extension, *pdevice_extension;
36. #define Pagedcode code_seg ("page")
38. #define Lockedcode code_seg ()
40. #define Initcode code_seg ("INIT")
44. #define PAGEDDATA data_seg ("page")
46. #define LOCKEDDATA data_seg ()
48. #define InitData data_seg ("INIT")
52. #define ARRAYSIZE (P) (sizeof (P)/sizeof ((p) [0])
56. NTSTATUS Mydeviceadd (in Pdriver_object DriverObject,
58. in Pdevice_object Physicaldeviceobject);
60. NTSTATUS dispatchroutine (in Pdevice_object FDO,
62. in Pirp IRP);
64. void Driverunload (in Pdriver_object driverobject);
68. extern "C"
70. NTSTATUS DriverEntry (in Pdriver_object DriverObject,
72. In punicode_string Registrypath);

Create a new text file with the following contents:

[CPP]View PlainCopy

1. #
2. # do not EDIT the This FILE!!! Edit./sources. If you want to add a new source
3. # file to this component. This file merely indirects to the real make file
4. # That's shared by all the driver components of the Windows NT DDK
5. #
7. ! INCLUDE $ (ntmakeenv)/makefile.def

Rename file, change to Makefile, suffix not. Then re-create a text file, write the following content:

[CPP]View PlainCopy

1. Targetname=helloworld
2. Targettype=driver
3. Drivertype=wdm
4. Targetpath=obj
6. includes=$ (BASEDIR)/inc;/
7. $ (BASEDIR)/inc/ddk;/
9. sources=mydrivers.cpp/

Save, change the file name to Sources, the suffix does not, so enter the DDK compilation environment, compiled, a driver file with a suffix of. sys appears.

Well, a simple drive was born.

http://blog.csdn.net/chence19871/article/details/50697439

Second Lecture: My first drive