《天书夜读：从汇编语言到windows内核编程》七 内核字符串与内存

1）驱动中的字符串使用如下结构：

 typedef    struct _UNICODE_STRING{
     USHORT Length;            //字符串的长度（字节数）
     USHORT MaximumLength;     //字符串缓冲区长度（字节数）
     PWSTR Buffer;             //字符串缓冲区
 }UNICODE_STRING,*PUNICODE_STRING;

这个为UNICODE字符串，一个字符占用双字节。对应的有Ansi字符串：

 typedef    struct  _STRING{
     USHORT Length;             //字符串的长度（字节数）
     USHORT MaximumLength;      //字符串缓冲区长度（字节数）
     PSTR Buffer;               //字符串缓冲区
 }ANSI_STRING,*PANSI_STRING;

　　内核程序是Unicode编码的，窄字符只在十分罕见的特殊场合使用。UNICODE_STRING不是空结束的，初始化和拷贝要使用指定的函数处理。

2）字符串初始化：UNICODE_STRING中的Buffer只是一个未分配内存的指针。定义常量字符串使用ntdef.h中的一个宏如下：

 #include <ntdef.h>
 UNICODE_STRING　str;
 RtlInitUnicodeString(&str,L”my first string!”);

　　这种方式初始化字符串并不分配内存，不用当心内存释放问题。

3）拷贝字符串：使用RtlCopyUnicodeString进行拷贝，但是目的串必须有足够的缓冲区，否则只能部分拷贝。如：

 UNICODE_STRING dst;            //目的字符串
 WCHAR dst_buf[];            //定义缓冲区
 UNICODE_STRING src = RTL_CONSTANT_STRING(L”My source string!”);
 
 //把目的字符串初始化为拥有缓冲区长度为256的UNICODE_STRING空串，如果不这样初始化，则dst默认长度为0
 RtlInitEmptyString(dst,dst_buf,*sizeof(WCHAR));
 RtlCopyUnicodeString(&dst,&src);        //字符串拷贝

4）链接字符串：RtlAppendUnicodeToString（UNICODE_STRING连接宽字节字符串）或者RtlAppendUnicodeStringToString（UNICODE_STRING连接UNICODE_STRING），如：

 NTSTATUS status = RtlAppendUnicodeToString(&dst,L”my second string!”);
 if ( status != STATUS_SUCCESS )
 {
     //链接失败
 }

　　NTSTATUS是常见返回值，STATUS_SUCCESS代表返回成功；否则返回一个错误码，这个连接函数在目标字符串空间不足时依然可以连接，只不过返回一个警告STATUS_BUFFER_TOO_SMALL。

5）字符串格式化输出：使用RtlStringCbPrintfW（头文件ntstrsafe.h，库文件ntstrsafe.lib）

 #include <ntstrsafe.h>
 WCHAR  dst_buf[] = {};//任何时候都动态分配内存，这里还没讲，暂时用固定长度的缓冲区
 UNICODE_STRING des;
 RtlInitEmptyString(dst,dst_buf,*sizeof(WCHAR));
 NTSTATUS  status = RtlStringCbPrintfW(
 dst->Buffer,*sizeof(WCHAR),L”file path = %wZ file size = %d\r\n”,&file_path,file_size);
 dst->Length = wcslen(dst->Buffer)*sizeof(WCHAR);// RtlStringCbPrintfW以空结束，所以这里可以使用wcslen

　　这个函数在目标缓冲区不足时返回STATUS_BUFFER_OVERFLOW，不能确定缓冲区要多长时，一般采用倍增尝试，直到返回STATUS_SUCCESS为止。

　　UNICODE_STRING类型的指针，用%wZ可以格式化，但是在不能保证字符串以空结束时，必须避免使用%ws或者%s。其它的格式化形式同C语言。

　　使用KdPrint输出格式化的调试信息时要使用下面的形式：

 KdPrint((L”file path = %wZ file size = %d\r\n”,&file_path,file_size));

6）内存分配和释放：ExAllocatePoolWithTag（分配）、ExFreePool（释放）

 //定义一个内存分配标记
 #define  MEM_TAG  ‘MyTt’
 //目标字符串
 UNICODE_STRING dst = {};
 //根据源字符串长度分配空间给目标字符串
 dst.Buffer = (PWCHAR)ExAllocatePoolWithTag(NopagedPool,src->Length,MEM_TAG);
 if(dst.Buffer == NULL)
 {
     //分配失败
     status = STATUS_INSUFFICIENT_RESOURCE;
     ……
 }
 dst.Length = dst.MaximumLength = src->Length;
 status = RtlCopyUnicodeString(&dst,&src);
 ASSERT(status == STATUS_SUCCESS)

　　ExAllocatePoolWithTag的第一个参数NopagedPool,src指定锁定在物理内存（不被置换到硬盘），第二个参数是要分配的内存的长度，第三个参数是所谓的“内存分配标记”---用于检测内存泄漏。分配的内存如果不释放，则永远泄漏，除非重启（卸载驱动也没用），释放内存如下：

     ExFreePool(dst.Buffer);
     dst.Buffer = NULL;
     dst.Length = dst.MaximumLength = ;

　　ExFreePool不能释放栈空间（临时变量），否则系统立即崩溃，导致蓝屏

7）LIST_ENTRY：一个双向循环链表结构，由内核开发者们开发，内核开发经常使用这个结果。比如说要使用到这样一个结构：

 typedef struct{
     PFILE_OBJECT file_object;
     UNICODE_STRING file_name;
     LARGE_INTEGER file_length;
 }MY_FILE_INFO,*PMY_FILE_INFO;

　　使用LIST_ENTRY可以如下构造该结构：

 typedef struct{
     LIST_ENTRY list_entry;
     PFILE_OBJECT file_object;
     UNICODE_STRING file_name;
     LARGE_INTEGER file_length;
 }MY_FILE_INFO,*PMY_FILE_INFO;

即使用LIST_ENTRY作为链表头，使用流程：

 LIST_ENTRY    my_list_head;//我们的链表头
 InitializeListHead(&my_list_head);//链表头初始化
 //以下为插入操作
 PMY_FILE_INFO my_file_info = (PMY_FILE_INFO)ExAllocatePoolWithTag(PagedPool,sizeof(MY_FILE_INFO),MEM_TAG);//新建一个节点
 if (my_file_info == NULL) return STATUS_INSUFFICIENT_RESOURES;//内存分配失败
 my_file_info->file_object = file_object;
 my_file_info->file_name = file_name;
 my_file_info->file_length = file_length;//赋值，填写数据成员
 InsertHeadList(&my_list_head,(PLIST_ENTRY)&my_file_info);//执行插入
 //以下为遍历操作
 for ( p = my_list_info.Flink ; p != &my_list_head.Flink ; p = p->Flink)
 {
     PMY_FILE_INFO elem = CONTAINING_RECORD(p , MY_FILE_INFO, list_entry)
 }
 /*其中，CONTAINING_RECORD宏是通过LIST_ENTRY结构的指针，找个指定节点目标结构的指针，该宏被定义为：
 #define CONTAINING_RECORD(address,type,field) (\
 (type*)((PCHAR)(adress)-(ULONG_PTR)(&((type*)0)->field)))
 */

8）LARGE_INTEGER：长长整型数据，这是一个共用体：

 typedef union _LARGE_INTEGER{
     struct {
         ULONG LowPart;
         LONG HighPart;
     };
     struct {
         ULONG LowPart;
         LONG HighPart;
     }u;
     LONGLONG QuadPart;
 }

　　它可以方便的得到高32位和低32位，一把用QuadPart即可。实际使用时大部分是PLARGE_INTEGER类型。

9）自旋锁：目的是为了实现多线程同步。使用自旋锁如下：

 KSPIN_LOCK my_spin_lock;
 KeInitializeSpinLock(&my_spin_lock);//初始化
 
 KIRQL irql;//中断级
 KeAcquireSpinLock(&my_spin_lock,&irql);//进入区
 //to do something…//临界区
 KeReleaseSplinLock(&my_spin_lock,irql);//退出区

　　锁要被所有进程共享，所以必须定义为全局变量、静态变量、或者分配在堆中。LIST_ENTRY提供一系列对加锁时的操作，只需要为每个链表定义并且初始化一个锁，然后使用对应提供的函数即可：

 LIST_ENTER my_list_head;//链表头
 KSPIN_LOCK my_list_lock;//链表锁
 InitializeListHead(&my_list_head);//链表头初始化
 KeInitializeSpinLock(&my_list_head);//链表锁初始化
 //加锁时的插入操作
 ExInsertlockedInsertHeadList(&my_list_head,(PLIST_ENTRY)&my_file_info,&my_list_lock);
 //加锁时的移除操作
 my_file_info = ExInsertlockedRemoveHeadList(&my_list_head,&my_list_lock);