Windows驱动的IOCTL

最新推荐文章于 2024-06-20 09:42:15 发布
最新推荐文章于 2024-06-20 09:42:15 发布
阅读量4.2k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenhuan20123/article/details/78939877
版权

虽然目前，没有具体的项目，但是Direct3D学习还是会继续。其实很多东西，虽然看起来现在没多大用处，说不定将来有很大的用处。这个无法衡量，多学点，总是有好处的。后面，断断续续，会把另外的几个方向，WDDM 驱动，数据结构算法，也开始捡起来继续。现在需要的是，将知识变成体系。所以，需要大量的总结。

我们今天看一下Windows驱动中的IOCTL，IOCTL顾名思义，就是IO控制码。也就是输入输出控制码。Window驱动中大量充斥着这样的控制码。前面的文章，我们知道，所有在驱动中的流都是以IRP的形式进行的。而用来标识IRP的就是这些IOCTL码。回忆一下MSDN中的IRP的结构。

typedef struct _IRP {
    .
    .
    PMDL  MdlAddress;
    ULONG  Flags;
    union {
      struct _IRP  *MasterIrp;
       .
       .
       PVOID  SystemBuffer;
     } AssociatedIrp;
     .
     .
     IO_STATUS_BLOCK  IoStatus;
     KPROCESSOR_MODE  RequestorMode;
     BOOLEAN PendingReturned;
     .
     .
     BOOLEAN  Cancel;
     KIRQL  CancelIrql;
     .
     .
     PDRIVER_CANCEL  CancelRoutine;
     PVOID UserBuffer;
     union {
        struct {
         .
         .
         union {
            KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
            struct {
              PVOID  DriverContext[4];
             };
          };
         .
         .
         PETHREAD  Thread;
         .
         .
         LIST_ENTRY  ListEntry;
         .
         .
         } Overlay;
      .
      .
      } Tail;
  } IRP, *PIRP;

我们知道IRP的一些信息都是存储在IO的堆栈中的：

typedef struct _IO_STACK_LOCATION {
       UCHAR  MajorFunction;
       UCHAR  MinorFunction;
       UCHAR  Flags;
       UCHAR  Control;
        union {
              //
              // Parameters for IRP_MJ_CREATE 
              //
              struct {
                   PIO_SECURITY_CONTEXT SecurityContext;
                   ULONG Options;
                   USHORT POINTER_ALIGNMENT FileAttributes;
                   USHORT ShareAccess;
                   ULONG POINTER_ALIGNMENT EaLength;
               } Create;
              //
              // Parameters for IRP_MJ_READ 
              //
              struct {
                   ULONG Length;
                   ULONG POINTER_ALIGNMENT Key;
                   LARGE_INTEGER ByteOffset;
               } Read;
              //
              // Parameters for IRP_MJ_WRITE 
              //
              struct {
                   ULONG Length;
                   ULONG POINTER_ALIGNMENT Key;
                   LARGE_INTEGER ByteOffset;
               } Write;
              //
              // Parameters for IRP_MJ_QUERY_INFORMATION 
              //
              struct {
                   ULONG Length;
                   FILE_INFORMATION_CLASS POINTER_ALIGNMENT   
      FileInformationClass;
               } QueryFile;
              //
              // Parameters for IRP_MJ_SET_INFORMATION 
              //
              struct {
                   ULONG Length;
                   FILE_INFORMATION_CLASS POINTER_ALIGNMENT   
      FileInformationClass;
                   PFILE_OBJECT FileObject;
                   union {
                        struct {
                            BOOLEAN ReplaceIfExists;
                            BOOLEAN AdvanceOnly;
                        };
                        ULONG ClusterCount;
                        HANDLE DeleteHandle;
                         };
               } SetFile;
              //
              // Parameters for IRP_MJ_QUERY_VOLUME_INFORMATION 
              //
              struct {
                   ULONG Length;
                   FS_INFORMATION_CLASS POINTER_ALIGNMENT    
     FsInformationClass;
               } QueryVolume;
              //
              // Parameters for IRP_MJ_DEVICE_CONTROL and    
     IRP_MJ_INTERNAL_DEVICE_CONTROL 
              //
              struct {
                   ULONG OutputBufferLength;
                   ULONG POINTER_ALIGNMENT InputBufferLength;
                   ULONG POINTER_ALIGNMENT IoControlCode;
                   PVOID Type3InputBuffer;
               } DeviceIoControl;
              //
              // Nonsystem service parameters.
              //
              // Parameters for IRP_MN_MOUNT_VOLUME 
              //
              struct {
                   PVOID DoNotUse1;
                   PDEVICE_OBJECT DeviceObject;
               } MountVolume;
              //
              // Parameters for IRP_MN_VERIFY_VOLUME 
              //
              struct {
                   PVOID DoNotUse1;
                   PDEVICE_OBJECT DeviceObject;
               } VerifyVolume;
              //
              // Parameters for Scsi using IRP_MJ_INTERNAL_DEVICE_CONTROL 
              //
              struct {
                   struct _SCSI_REQUEST_BLOCK *Srb;
               } Scsi;
              //
              // Parameters for IRP_MN_QUERY_DEVICE_RELATIONS 
              //
              struct {
                   DEVICE_RELATION_TYPE Type;
               } QueryDeviceRelations;
              //
              // Parameters for IRP_MN_QUERY_INTERFACE 
              //
              struct {
                   CONST GUID *InterfaceType;
                  USHORT Size;
                   USHORT Version;
                   PINTERFACE Interface;
                   PVOID InterfaceSpecificData;
               } QueryInterface;
              //
              // Parameters for IRP_MN_QUERY_CAPABILITIES 
              //
              struct {
                   PDEVICE_CAPABILITIES Capabilities;
               } DeviceCapabilities;
              //
              // Parameters for IRP_MN_FILTER_RESOURCE_REQUIREMENTS 
              //
              struct {
                   PIO_RESOURCE_REQUIREMENTS_LIST     
    IoResourceRequirementList;
               } FilterResourceRequirements;
              //
              // Parameters for IRP_MN_READ_CONFIG and IRP_MN_WRITE_CONFIG 
              //
              struct {
                   ULONG WhichSpace;
                   PVOID Buffer;
                   ULONG Offset;
                   ULONG POINTER_ALIGNMENT Length;
               } ReadWriteConfig;
              //
              // Parameters for IRP_MN_SET_LOCK 
              //
              struct {
                   BOOLEAN Lock;
               } SetLock;
              //
              // Parameters for IRP_MN_QUERY_ID 
              //
              struct {
                   BUS_QUERY_ID_TYPE IdType;
               } QueryId;
              //
              // Parameters for IRP_MN_QUERY_DEVICE_TEXT 
              //
              struct {
                   DEVICE_TEXT_TYPE DeviceTextType;
                   LCID POINTER_ALIGNMENT LocaleId;
                } QueryDeviceText;
              //
              // Parameters for IRP_MN_DEVICE_USAGE_NOTIFICATION 
              //
              struct {
                   BOOLEAN InPath;
                    BOOLEAN Reserved[3];
                    DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT  
         Type;
               } UsageNotification;
              //
              // Parameters for IRP_MN_WAIT_WAKE 
              //
              struct {
                   SYSTEM_POWER_STATE PowerState;
              } WaitWake;
              //
              // Parameter for IRP_MN_POWER_SEQUENCE 
              //
              struct {
                   PPOWER_SEQUENCE PowerSequence;
               } PowerSequence;
              //
              // Parameters for IRP_MN_SET_POWER and IRP_MN_QUERY_POWER 
              //
              struct {
                   ULONG SystemContext;
                   POWER_STATE_TYPE POINTER_ALIGNMENT Type;
                   POWER_STATE POINTER_ALIGNMENT State;
                   POWER_ACTION POINTER_ALIGNMENT ShutdownType;
               } Power;
              //
              // Parameters for IRP_MN_START_DEVICE 
              //
              struct {
                   PCM_RESOURCE_LIST AllocatedResources;
                   PCM_RESOURCE_LIST AllocatedResourcesTranslated;
                } StartDevice;
              //
              // Parameters for WMI Minor IRPs 
              //
              struct {
                   ULONG_PTR ProviderId;
                   PVOID DataPath;
                   ULONG BufferSize;
                   PVOID Buffer;
              } WMI;
              //
              // Others - driver-specific
              //
              struct {
                   PVOID Argument1;
                   PVOID Argument2;
                   PVOID Argument3;
                   PVOID Argument4;
               } Others;
         } Parameters;
     PDEVICE_OBJECT  DeviceObject;
     PFILE_OBJECT  FileObject;
     .
     .
  } IO_STACK_LOCATION, *PIO_STACK_LOCATION;

在IO堆栈中，我们看到了大量的IOCTL。这个是在WDM中的，在WDF对其进行了封装。我们在WDF中，一般使用如下的3个函数向其他模块发送这些IRP.我认为REQUEST是WDM中的IRP和IO_STATION_LOCATION的封装。

看一下异步函数：

WdfIoTargetFormatRequestForInternalIoctl,WdfIoTargetFormatRequestForInternalIoctlOthers,WdfIoTargetFormatRequestForIoctl,WdfIoTargetFormatRequestForRead,WdfIoTargetFormatRequestForWrite，这是是异步的，后面需要设置完成例程，和真正发送请求。

再看一下同步的：
WdfIoTargetSendInternalIoctlOthersSynchronously，WdfIoTargetSendInternalIoctlSynchronously，WdfIoTargetSendIoctlSynchronously，WdfIoTargetSendReadSynchronously，WdfIoTargetSendWriteSynchronously，同步需要等待，所以可以直接发。

先看一下异步的例子：

NTSTATUS
NICSendOidRequestToTargetAsync(
    IN WDFIOTARGET  IoTarget,
    IN WDFREQUEST  Request,
    IN PFILE_OBJECT  FileObject,
    IN ULONG  IoctlControlCode,
    IN OUT PVOID  InputBuffer,
    IN ULONG  InputBufferLength,
    IN OUT PVOID  OutputBuffer,
    IN ULONG  OutputBufferLength,
    OUT PULONG  BytesReadOrWritten
    )
{
    NTSTATUS  status;
    PREQUEST_CONTEXT  reqContext;
    WDF_REQUEST_REUSE_PARAMS  params;
    WDFMEMORY  inputMem, outputMem;
    
    WDF_REQUEST_REUSE_PARAMS_INIT(
                                  &params, 
                                  WDF_REQUEST_REUSE_NO_FLAGS, 
                                  STATUS_SUCCESS
                                  );
    status = WdfRequestReuse(Request, &params);
    if (!NT_SUCCESS(status)){
        return status;
    }
    reqContext = GetRequestContext(Request);
    inputMem = outputMem = NULL;
    
    if (InputBuffer != NULL) {
        status = WdfMemoryAssignBuffer(
                                       reqContext->InputMemory,
                                       InputBuffer, 
                                       InputBufferLength
                                       );
        if (!NT_SUCCESS(status)) {
             return status;
        }
        inputMem = reqContext->InputMemory;
    }
    if (OutputBuffer != NULL) {
        status = WdfMemoryAssignBuffer(
                                       reqContext->OutputMemory,
                                       OutputBuffer, 
                                       OutputBufferLength
                                       );
        if (!NT_SUCCESS(status)) {
            return status;
        }
        outputMem = reqContext->OutputMemory;
    }
    status = WdfIoTargetFormatRequestForIoctl(
                                              IoTarget,
                                              Request,
                                              IoctlControlCode,
                                              inputMem,
                                              NULL,
                                              outputMem,
                                              NULL
                                              );
    if (!NT_SUCCESS(status)) {
        return status;
    }
    WdfRequestSetCompletionRoutine(
                                   Request,
                                   NICSendOidRequestToTargetAsyncCompletionRoutine,
                                   BytesReadOrWritten
                                   );
    if (WdfRequestSend(
                       Request,
                       IoTarget,
                       WDF_NO_SEND_OPTIONS
                       ) == FALSE) {
        status = WdfRequestGetStatus(Request);
    }
    return status;
}

再看一下同步的：

WDF_MEMORY_DESCRIPTOR  outputDescriptor;
NTSTATUS  status;
HID_COLLECTION_INFORMATION  collectionInformation;
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
                                  &outputDescriptor,
                                  (PVOID) &collectionInformation,
                                  sizeof(HID_COLLECTION_INFORMATION)
                                  );
status = WdfIoTargetSendIoctlSynchronously(
                                           hidTarget,
                                           NULL,
                                           IOCTL_HID_GET_COLLECTION_INFORMATION,
                                           NULL,
                                           &outputDescriptor,
                                           NULL,
                                           NULL
                                           )

上面是发送，我们在驱动中如何进行处理这些IOCTL了，有些IOCTL，已经被WDF封装了，直接成为了驱动对象的一些域了，比如
IRP_MN_START_DEVICE,IRP_MN_FILTER_RESOURCE_REQUIREMENTS 等。有些我们自己定义的流给应用程序的接口，我们需要在请求对象中获取。调用函数

WdfRequestGetParameters(
       IN WDFREQUEST  Request,
      OUT PWDF_REQUEST_PARAMETERS  Parameters
     );

请求对象会在队列处理函数中，以参数的形式传给你，所以，你可以得到请求的参数，以确定IOCTL，而做不同的操作。
回忆一下请求参数：

typedef struct _WDF_REQUEST_PARAMETERS {
    USHORT Size;
    UCHAR MinorFunction;
    WDF_REQUEST_TYPE Type;
    union {
        //
        // Parameters for IRP_MJ_CREATE
        //
        struct {
            PIO_SECURITY_CONTEXT SecurityContext;
            ULONG Options;
            USHORT POINTER_ALIGNMENT FileAttributes;
            USHORT ShareAccess;
            ULONG POINTER_ALIGNMENT EaLength;
        } Create;
        //
        // Parameters for IRP_MJ_READ
        //
        struct {
            size_t Length;
            ULONG POINTER_ALIGNMENT Key;
            LONGLONG DeviceOffset;
        } Read;
        //
        // Parameters for IRP_MJ_WRITE 
        //
        struct {
            size_t Length;
            ULONG POINTER_ALIGNMENT Key;
            LONGLONG DeviceOffset;
        } Write;
        //
        // Parameters for IRP_MJ_DEVICE_CONTROL and IRP_MJ_INTERNAL_DEVICE_CONTROL 
        //
        struct {
            size_t OutputBufferLength;
            size_t POINTER_ALIGNMENT InputBufferLength;
            ULONG POINTER_ALIGNMENT IoControlCode;
            PVOID Type3InputBuffer;
        } DeviceIoControl;
        struct {
            PVOID Arg1;
            PVOID  Arg2;
            ULONG POINTER_ALIGNMENT IoControlCode;
            PVOID Arg4;
        } Others;
    } Parameters;
} WDF_REQUEST_PARAMETERS, *PWDF_REQUEST_PARAMETERS;

这里，我们就可以很方便的得到控制码进行操作了。

http://blog.youkuaiyun.com/z18_28_19/article/details/8892552
转载自其博客，因为排版较乱，所以重新编辑后发到自己博客记录。

chenhuan20123
关注
用户层与驱动层通信
weixin_45566993的博客
04-05 866
Python微信订餐小程序课程视频 https://edu.youkuaiyun.com/course/detail/36074 Python实战量化交易理财系统 https://edu.youkuaiyun.com/course/detail/35475 备注：1.在下面的讨论中，"输入"表示数据从用户模式的应用程序到驱动程序，"输出"表示数据从驱动程序到应用程序。2.IRP 中的 SystemBuffer 字段包含系统地址。UserBuffer 字段包含初始的用户缓冲区地址。 参考文章链接：https://blog.csdn.
内核层和用户层通讯的三种方式
weixin_30954607的博客
08-30 514
内核层#include <ntddk.h>​#define CTRL_CODE1 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_IN_DIRECT, FILE_ANY_ACCESS)#define CTRL_CODE2 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE...
IOCTL 助手（Windows驱动开发工具）
08-12
IOCTL助手。前几次上传，都有问题，因为是使用7-zip解压的。唉，看来还是要用WINRAR或者WinZip比较好啊。
win32 IOCTL学习总结
bcbobo21cn的专栏
04-15 3279
Kernel-win32的系统调用机制 毛德操 正如许多网友所言，要在Linux内核中实现Windows系统调用(或别的系统调用)，最简单的办法莫过于把 这些系统调用“搭载”在Linux系统调用上。具体又有几种不同的方法： 1． 为Linux系统调用ioctl()增加一些“命令码”，每个新的命令码都代表着一个Windows系统调用。 2． 为Linux增加一个新的系统调用、例如w
ioctl函数
codeingdog的专栏
10-14 706
ioctl用于向设备发控制和配置命令，这些命令数据不能用read/write读写的，称为Out-of-band数据。也就是说，read/write读写的数据是in-band数据，是I/O操作的主体，而ioctl命令传送的是控制信息，其中的数据是辅助的数据。例如，在串口线上收发数据通过read/write操作，而串口的波特率、校验位、停止位通过ioctl设置；A/D转换的结果通过read读取，而A/
【深度探索】IOCTLDump：透视Windows驱动交互的神器
最新发布
gitblog_00017的博客
06-20 420
【深度探索】IOCTLDump：透视Windows驱动交互的神器 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在错综复杂的系统底层世界里，每一处IOCTL（Input/Output Control）调用都承载着设备驱动与操作系统之间的秘密对话。而IOCTLDump，正如其名，是一个用于挂钩和转储其他设备驱动程序IOCTL操作的强大内核级工具。它如同一位尽职的侦探，记...
IOCTL_Test.rar_IOCTL__USB 驱动开发 3.2_ioctl_ioctl u_usb ioctl
09-24
在Windows驱动开发中，IOCTL是驱动程序与应用程序通信的主要方式。它由一个控制代码（Control Code）和一个可选的数据缓冲区组成，控制代码定义了要执行的具体操作。 **USB驱动开发** USB驱动通常包括三个层次：...
Windows驱动中IOCTL代码结构详解及其应用
本篇文章主要探讨了Windows操作系统中的设备控制接口（IOCTL）在驱动程序开发中的应用，特别是在NDIS中间层驱动的实现过程中。IOCTL代码结构是一个关键概念，它允许驱动程序通过设备控制代码IoControlCode进行功能的...
Windows驱动开发：IOCTL与应用程序通信详解
本文档深入探讨了Windows驱动程序与应用程序之间的通信机制，特别是通过Input/Output Control (IOCTL)函数进行交互的详细过程。首先，讲解了基本概念，包括内核模式（Ring 0-3）的作用，驱动程序作为内核扩展的重要...
Tsi721 Windows 设备驱动和API用户参考指南（中文版）
03-30
### Tsi721 Windows 设备驱动和API用户参考指南（中文版）知识点解析 #### 一、概览 本文档旨在为熟悉RapidIO规范的软件开发人员提供关于Tsi721 Windows设备驱动程序及其API的详细介绍。文档不仅涵盖了驱动程序的...
ioctl函数详解
12-22
ioctl函数详解
WDM ioctl 缓冲区读写
12-22 747
1 METHOD_BUFFERED Buffered IO中IO管理器会分配一块堆内存然后把用户态缓冲区数据copy进来再传给驱动程序,而输出时IO管理器会把堆内存中的数据copy回用户态缓冲区。 ULONG inputSize = I.IoctlInputBufferSize(); PVOID inputBuffer = I.IoctlBuffer(); ULON
探秘IOCTL：驱动开发者必备的命令行工具
gitblog_00025的博客
06-05 471
探秘IOCTL：驱动开发者必备的命令行工具 ioctlThe missing tool to call arbitrary ioctls on devices项目地址:https://gitcode.com/gh_mirrors/io/ioctl 在软件开发领域，尤其是操作系统和硬件驱动方面，ioctl是一个不可或缺的名字。它允许我们对设备进行特定的低级别操作，而这些操作往往超出了常规的读写操作...
ioctl()简单应用
weixin_43231510的博客
03-28 408
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。 例句：ret = ioctl(fd, GET_PWR_STATUS, current_state); 原句：int ioctl(int fd, ind cmd, …)； fd是用户程序打开设备时使用open函数返回的文件标示符，cmd是用户程序...
ioctl函数详细说明
03-24 984
本函数影响由fd参数引用的一个打开的文件。 #include<unistd.h> intioctl( int fd, int request, .../* void *arg */ ); 返回0：成功 -1：出错 第三个参数总是一个指针，但指针的类型依赖于request参数。 我们可以把和网络相关的请求划分为6类： 套接口操作 文件操作 接口操作 ARP高速缓存操作 路由表操作 流系统 下表列出了网络相关ioctl请求的request参数以...
ioctl()函数详解
qq_33300585的博客
08-04 4327
ioctl()函数详解
Windows驱动开发（二）WDM/WDF的IOControl
o0xwh_93150o的博客
02-09 1741
上一章大概介绍了WDM/WDF的驱动模型， 链接：https://blog.youkuaiyun.com/o0xwh_93150o/article/details/104213348 这一章我们主要来看一下驱动程序中的IO请求是如何处理的。 其实驱动程序的主要功能也就是负责处理IO请求，其中大部分IO请求是在派遣函数中处理的。用户模式下的所有对驱动程序的IO请求，全部由操作系统转化为一个叫做IRP（IO...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值