3.2 应用层与内核的通信方法 ：访问数据的I/O方式、读写驱动程序、发送I/O控制码、内存共享

最新推荐文章于 2024-09-19 14:56:09 发布
最新推荐文章于 2024-09-19 14:56:09 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： NT-Kernel

3.2.1 访问数据的I/O方式：

1. 缓冲方式I/O

2. 直接方式I/O

3. 非缓冲非直接方式I/O


3.2.2 读写驱动程序

读写驱动程序，即应用程序或者上层驱动程序发送主功能码为IRP_MJ_READ和IRP_MJ_WRITE的I/O请求包(IRP)

//
//驱动入口函数
//
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
    UNICODE_STRING DeviceName,Win32Device;
    PDEVICE_OBJECT DeviceObject = NULL;
    NTSTATUS status;
    unsigned i;


    KdPrint(("[DriverEntry]\n"));


    //设备名
    RtlInitUnicodeString(&DeviceName,L"\\Device\\Demo0");


    //符号链接号
    RtlInitUnicodeString(&Win32Device,L"\\DosDevice\\Demo0");


    //填写默认的IRP处理函数
    for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
    {
        DriverObject->MajorFunction[i] = DemoDefaultHandler;
    }


    //IRP处理函数
    DriverObject->MajorFunction[IRP_MJ_CREATE] = DemoCreateClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = DemoCreateClose;
    DriverObject->MajorFunction[IRP_MJ_READ] = DemoReadWrite;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = DemoReadWrite;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DemoDevControl;




    //驱动卸载函数
    DriverObject->DriverUnload = DemoUnload;


    //创建设备
    status = IoCreateDevice(DriverObject, 10, &DeviceName, FILE_DEVICE_UNKNOWN,
                            0, FALSE, &DeviceObject);


    if (!NT_SUCCESS(status))
    {
        return status;
    }


    if (!DeviceObject)
    {
        return STATUS_UNEXPECTED_IO_ERROR;
    }


    //初始化这个字节的内容
    memset(DeviceObject->DeviceExtension, 'A', 10);


    //设置设备的读写方式
    //DeviceObject->Flags |= DO_BUFFERED_IO;
    //DeviceObject->Flags |= DO_DIRECT_IO;


    //创建符号链接
    status = IoCreateSymbolicLink(&Win32Device, &DeviceName);


    //设备初始化完毕，可以开始工作了
    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;


    return STATUS_SUCCESS;
}


//
//读写请求
//写请求的处理只是简单地向设备自定义扩展中复制数据
//读请假的处理只是简单地从设置自定义扩展中读取数据
//注意，最大支持10字节
//
NTSTATUS DemoReadWrite(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION pSP = IoGetCurrentIrpStackLocation(Irp);
    PVOID pBuffer = NULL;
    BOOLEAN bNeither = FALSE;
    ULONG uLen = 0;


    KdPrint(("[DemoReadWrite]\n"));


    if (DeviceObject->Flags & DO_BUFFERED_IO)
    {
        KdPrint(("Flags: DO_BUFFER_IO\n"));
        pBuffer = Irp->AssociatedIrp.SystemBuffer;
    } 
    else if (DeviceObject->Flags & DO_DIRECT_IO)
    {
        KdPrint(("Flag: DO_DRIECT_IO\n"));
        pBuffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
    } 
    else
    {
        KdPrint(("Flags: Neither\n"));
        bNeither = TRUE;
        pBuffer = Irp->UserBuffer;
    }


    switch (pSP->MajorFunction)
    {
    case IRP_MJ_READ:
        uLen = pSP->Parameters.Read.Length;
        uLen = uLen>10?10:uLen;


        KdPrint(("IRP_MJ_READ Read Len: %d\n", pSP->Parameters.Read.Length));


        if (FALSE == bNeither)
        {
            RtlCopyMemory(pBuffer, DeviceObject->DeviceExtension, uLen);
        } 
        else
        {
            //两者皆不需要验证缓冲区的有效性
            _try
            {
                ProbeForWrite(pBuffer,uLen,4);
                RtlCopyMemory(pBuffer,DeviceObject->DeviceExtension,uLen);
            }
            _except(EXCEPTION_EXECUTE_HANDLER)
            {
                KdPrint(("IRP_MJ_READ exception!\n"));
                status = STATUS_UNSUCCESSFUL;
            }
        }
        break;


    case IRP_MJ_WRITE:
        uLen = pSP->Parameters.Write.Length;
        uLen = uLen>10?10:uLen;


        KdPrint(("IRP_MJ_WRITE WRITE Len: %d\n",pSP->Parameters.Write.Length));


        if (FALSE == bNeither)
        {
            RtlCopyMemory(DeviceObject->DeviceExtension,pBuffer,uLen);
        } 
        else
        {
            _try
            {
                ProbeForRead(pBuffer,uLen,4);
                RtlCopyMemory(DeviceObject->DeviceExtension,pBuffer,uLen);
            }
            _except(EXCEPTION_EXECUTE_HANDLER)
            {
                KdPrint(("IRP_MJ_WRITE exception!\n"));


                status = STATUS_UNSUCCESSFUL;
            }
        }
        break;
    }


    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = uLen;


    IoCompleteRequest(Irp,IO_NO_INCREMENT);


    return status;


}


3.2.3 发送I/O控制码

应用程序或者上层的驱动程序可以通过发送I/O控制码和目标设备驱动程序交互，由驱动程序的IRP(主功能码为IRP_MJ_DEVICE_CONTROL)处理函数提供支持处理

I/O控制码的布局包含：设备类型(Device Type)、请求权限(RequiredAccess)、功能码(FunctionCode)、传输类型(TransferType)

设备类型：必须和打开设备的设备类型相匹配，设备类型包括FILE_DEVICE_DISK、FILE_DEVICE_UNKNOWN等

请求权限：包括FILE_ANY_ACCESS、FILE_READ_DATA和FILE_WRITE_DATA

功能码：用于区分不同的控制权限，所有小于0x800的功能保留给微软、0x800以及更大值的功能码提供给供应商使用

传输类型：指定了不同的I/O访问方式：METHOD_BUFFERED、METHOD_IN_DIRCET、METHOD_OUT_DIRECT或者METHOD_NEITHER

I/O控制码可以使用系统提供的CTL_CODE宏定义，宏如下：

#define IOCTL_DEVICE_Function CTL_CODE(DeviceType, Function, Method, Access)


//
//define
//
#define IOCTL_BUFFERED_IO\
    CTL_CODE(FILE_DEVICE_UNKNOWN,0x8000,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define IOCTL_INDIRECT_IO\
    CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_IN_DIRECT,FILE_ANY_ACCESS)
#define IOCTL_NEITHER_IO\
    CTL_CODE(FILE_DEVICE_UNKNOWN,0x802,METHOD_NEITHER,FILE_ANY_ACCESS)


//
//自定义控制请求
//同样也是在应用程序和设备扩展之间复制数据
//数据最多为10字节
//
NTSTATUS DemoDevControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION pSP = IoGetCurrentIrpStackLocation(Irp);
    ULONG uControlCode = pSP->Parameters.DeviceIoControl.IoControlCode;
    PVOID pInBuf = NULL, pOutBuf = NULL;
    ULONG uInLen = 0, uOutLen = 0;


    KdPrint(("[DemoDevControl]\n"));


    uInLen = pSP->Parameters.DeviceIoControl.InputBufferLength;
    uInLen = uInLen>10?10:uOutLen;


    uOutLen = pSP->Parameters.DeviceIoControl.OutputBufferLength;
    uOutLen = uOutLen>10?10:uOutLen;


    KdPrint(("uInLen: %d uOutLen: %d\n",
        pSP->Parameters.DeviceIoControl.InputBufferLength,
        pSP->Parameters.DeviceIoControl.OutputBufferLength));


    switch(uControlCode)
    {
    case IOCTL_BUFFERED_IO:
        KdPrint(("IOCTL_BUFFER_IO\n"));


        pInBuf = pOutBuf = Irp->AssociatedIrp.SystemBuffer;
        
        if (uInLen)
        {
            RtlCopyMemory(DeviceObject->DeviceExtension,pInBuf,uInLen);
        }
        if (uOutLen)
        {
            RtlCopyMemory(pOutBuf,DeviceObject->DeviceExtension,uOutLen);
        }
        break;


    case IOCTL_INDIRECT_IO:
        KdPrint(("IOCTL_INDIRECT_IO\n"));


        pInBuf = Irp->AssociatedIrp.SystemBuffer;
        pOutBuf = MmGetSystemAddressForMdl(Irp->MdlAddress);


        if (uInLen)
        {
            RtlCopyMemory(DeviceObject->DeviceExtension,pInBuf,uInLen);
        }
        if (uOutLen)
        {
            RtlCopyMemory(pOutBuf,DeviceObject->DeviceExtension,uOutLen);
        }
        break;


    case IOCTL_NEITHER_IO:
        KdPrint(("IOCTL_NEITHER_IO\n"));


        pInBuf = pSP->Parameters.DeviceIoControl.Type3InputBuffer;
        pOutBuf = Irp->UserBuffer;


        _try
        {
            if (uInLen)
            {
                ProbeForRead(pInBuf,uInLen,4);
                RtlCopyMemory(DeviceObject->DeviceExtension,pInBuf,uInLen);
            }
            if (uOutLen)
            {
                ProbeForWrite(pOutBuf,uOutLen,4);
                RtlCopyMemory(pOutBuf,DeviceObject->DeviceExtension,uOutLen);
            }
        }
        _except(EXCEPTION_EXECUTE_HANDLER)
        {
            KdPrint(("exception!\n"));
            
            status = STATUS_UNSUCCESSFUL;
        }
        break;


    default:
        status = STATUS_UNSUCCESSFUL;
        break;
    }


    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = uOutLen;


    IoCompleteRequest(Irp, IO_NO_INCREMENT);


    return status;
}


3.2.4 内存共享

应用程序和驱动程序可以共享内存。共享内存有两种实现方式：应用程序分配内存，提供给驱动程序，由驱动程序映射并锁定该内存；驱动程序分配内存，然后映射到应用程序地址范围内。

后一种方式：

1. 驱动程序分配一块内核空间

2. 使用MDL描述这片内存并锁定内存，映射到用户空间

3. 将映射到用户空间的地址提交给应用程序，此后，应用程序即可使用该地址操作这片共享内存了

#define IOCTL_SHARE_MEMORY\
    CTL_CODE(FILE_DEVICE_UNKNOWN,0x803,IOCTL_SHARE_MEMORY,FILE_ANY_ACCESS)

case IOCTL_SHARE_MEMORY:
        pOutBuf = Irp->AssociatedIrp.SystemBuffer;


        //将设备扩展作为共享内存地址，大小为10字节
        pSysAddr = DeviceObject->DeviceExtension;


        pMdl = IoAllocateMdl(pSysAddr,10,FALSE,FALSE,NULL)
        if (NULL == pMdl)
        {
            KdPrint(("IOCTL_SHARE_MEMORY IoAllocateMdl Failure!\n"));


            status = STATUS_UNSUCCESSFUL;


            break;
        }


        MmBuildMdlForNonPagedPool(pMdl);


        *(ULONG*)pOutBuf = MmMapLockedPagesSpecifyCache(
            pMdl, UserMode, MmNonCached, NULL, FALSE, NormalPagePriority);
        if (NULL == *(ULONG)*pOutBuf)
        {
            KdPrint(("IOCTL_SHARE_MEMORY MmMaoLockedPagesSpecifyCache Failure\n"));


            status = STATUS_UNSUCCESSFUL;


            IoFreeMdl(pMdl);


            break;
        }


        KdPrint(("IOCTL_SHARE_MEMORY SysBuf:0x%08x UserBuf:0x%08x\n",pSysAddr,*(ULONG*)pOutBuf));
        break;




zhou191954
关注
专栏目录
AUTOSAR从入门到精通-【应用篇】基于 AUTOSAR 的四轮驱动客车整车控制器应用层软件开发研究
getusushu的博客
07-09 924
系统，提出了一种基于纳什均衡的方法，采用固定优先级调度的方式，结合博弈论，最。运行实体到任务的映射方法，一种传统的映射方法则是将每个可运行实体都单独映射。切换调度任务，不仅会增加系统的调度开销，还没有考虑各个可运行实体之间的触发。来说，可运行实体到任务的映射主要由那些具有丰富经验的工程师来手动完成，目前。比如将具有相同发送和接收的可运行实体映射到相同的任务，将具有相同周期。的可运行实体映射到相同的任务，从而解决任务的频繁切换问题。评价方法，将六条映射准则各分配一定的权重系数，根据最终指标的大小来衡量映射。
驱动通信读写等等一个模块
03-17
通信读写驱动
Linux设备驱动程序之阻塞非阻塞IO----轮询操作
csu_yang的专栏
11-15 856
<br />http://www.newwhy.com/2010/1014/22218.html<br />“小王，来聊聊，今天面试的情况怎么样，应该挺顺利的吧..”看着小王平淡的眉头，我问道。<br />“唉，别提了，你说，我的运气咋这差呢，面试前你不是给我讲了有关阻塞的问题吗，我见了面试官是吧，还跟他好好的用今天排队的例子说了有关阻塞的问题，但是..”小王哀声叹气地说到。<br />“别但是了，怎么啦..”<br />“可问题是面试官压根就没打算问我有关阻塞的问题及解决方案，但是问我说：这样吧，你给我说
派遣函数 - 缓冲区设备模拟文件读写
最新发布
wendyWJGU的博客
09-19 593
派遣函数 - 缓冲区设备模拟文件读写
驱动读写进程内存R3,R0通信
dengjiatao9832的博客
09-21 1472
1 stdafx.h 头文件代码 2 3 #ifndef _WIN32_WINNT // Allow use of features specific to Windows XP or later. 4 #define _WIN32_WINNT 0x0501 // Change this to the appr...
驱动程序与应用程序之间共享内存
Tommy(凌飞)的专栏
06-27 4186
   随手写点自己碰到的问题。在写内核模式的驱动程序时，经常需要做的就是驱动程序和应用程序之间的通信。如应层程序和驱动程序之间共享事件来完成同步，事件可以有应用程序来创建然后将其句柄下发到驱动程序中，驱动程序进行引用等操作，就可以实现共享事件了。这里就不说这个了，主要说说驱动和应用程序之间的共享。   共享的方式有很多，我们在应用层编程时，也经常需要进程之间共享内存。可以用过SendMessage
加载驱动遍历驱动模块(使用控制码通讯)
Hades的博客
04-26 2157
加载驱动遍历驱动模块测试环境系统:虚拟机Windows 7 32bit工具:VS2015+Windbg等各种调试工具说明此demo只是内核编程的小小练习,只是遍历了驱动模块全路径,通过Ring3和Ring0通讯(使用比较复杂的控制码+MDL直接方式通讯),显示在了用户界面上.想要做其他功能,根据这个思路,遍历进程信息,模块信息等等都很容易做到.如果以后有机会再发其他功能的实现主要思路1.程序启动的...
java offset函数的使用方法_Java I/O体系从原理到应用，这一篇全说清楚了
weixin_30580403的博客
02-24 1160
本文介绍操作系统I/O工作原理，Java I/O设计，基本使用，开源项目中实现高性能I/O常见方法和实现，彻底搞懂高性能I/O之道基础概念在介绍I/O原理之前，先重温几个基础概念：(1) 操作系统与内核操作系统：管理计算机硬件与软件资源的系统软件内核：操作系统的核心软件，负责管理系统的进程、内存、设备驱动程序、文件和网络系统等等，为应用程序提供对计算机硬件的安全访问服务2 内核空间和用户空间为了避...
集群计算I_O瓶颈破解术：深入剖析与优化策略
![集群计算I_O瓶颈破解术：深入剖析与优化策略]...I/O（Input/Output）瓶颈指的是在数据输入输出过程中，由于硬件设备、网络带宽或软件处理能力的限制，
【C#线程通信宝典】：深入理解共享内存、信号量与事件的使用
![线程通信](https://img-blog.csdnimg.cn/559eb98fea234dacba45d26309d0cd53.png) ...线程通信是多线程程序中协调不同线程动作和数据交换的一种机制。有效的线程通信可以避免资源冲突、竞态条件和死锁
Linux应用层开发（4）：串口通讯与终端设备
lishing6的博客
07-23 861
串口通讯(Serial Communication)是一种设备间非常常用的串行通讯方式， 因为它简单便捷，大部分电子设备都支持，电子工程师在调试设备时也经常使用串口来输出调试信息， 在计算机的上古时代，键盘、鼠标、MODEM以及终端都是使用串口通讯的。另外，为了方便使用，开发板上常常添加了USB转串口芯片， 使得我们可以直接用USB线连接主机和开发板的串口。串口在旧式的台式计算机中一般会以RS-232标准的COM口出现(也称DB9接口)，见下图。
x64读写驱动源码
05-12
x64读写驱动源码 对于想学习64位驱动 研究内核的人有一定参考价值``````````````
驱动_读写3类V2.8
10-05
基于通信驱动的读写方式，可读写任何进程，包括游戏，例如D N F等游戏，均可正常读写。而且支持所有系统，不非法！
内核读写进程
ChinaPrc
04-20 490
//#include <ntddk.h> #include <ntifs.h> DRIVER_INITIALIZE FxDriverEntry; #pragma alloc_text(INIT, FxDriverEntry) #define IOCTL_COOKIE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x0301, METHOD_BUFFER...
[Windows 驱动开发] MDL 共享内存，实现 r0 和 r3 通信
LYSM
08-31 2106
背景 默认情况下，进程内存有一半为内核所有，一半为进程本身所有。但是因为 r3 的进程在不断的切换，所以不能在 r0 直接分配一个低位的内存（你不知道现在正在哪个进程的高位中）。 当然，使用 KeStackAttachProcess 附加到指定的进程上操作内存（读/写），最后再使用 KeUnstackDetachProcess 脱离进程，这样也可以实现 r0 和 r3 通信，但更推荐使用 MDL 的方式对将同一块物理内存同时映射到 r0 和 r3，这样我们只需要使用 DeviceIoControl 向驱动发
Windows 磁盘设备操作控制码大全
Biao
04-30 2377
Windows 磁盘操作，通过DeviceIoControl 函数传递不同的控制码实现磁盘的各种不同的操作。下面表格翻译自Windows官方文档：Disk Management Control Codes 下表列出了在磁盘管理中使用的控制代码。 Control Code Description IOCTL_DISK_ARE_VOLUMES_READY 等待指定磁盘............
windows 驱动开发 MDL 内核层 用户层共享内存
11-01 311
参考资料 https://blog.csdn.net/wdykanq/article/details/7752909 http://blog.51cto.com/laokaddk/404584 内核层创建内存映射用户层 PVOID pShareMM_SYS; PMDL pShareMM_MDL; PVOID pShareMM_User; PKUANGKEEP...
驱动程序异步通知应用程序，数据是否可读
ADC0809608的专栏
03-19 2042
当我们驱动程序当中有数据可读的时候，可以通过驱动程序中的异步通知机制来通知应用程序数据是否可读，从而提高读取数据的效率。 主要实现思路是：设备I/O驱动如果准备好数据（用户可读或者可写），向用户进程发送信号，用户进程收到信号后调用相关的信号处理函数对设备的数据进行访问。 实现上述的思路需要两方面的实现：用户程序的实现、设备驱动程序的实现。   用户程序的实现需要：
178_驱动_一个简单的点亮小灯，基于内核文件 【makefile制作】
HanLongXia的博客
11-10 588
mytext.c–内核文件基础下，驱动的创建 #include<linux/module.h> #include<asm/io.h> //是因为 ioremap iounmap #include<linux/fs.h>//register_chrdev unregister_chrdev #include<linux/device.h>// class_create int __iomem * beeaddr=NULL; unsigned in.
同步与异步I/O：系统内核I/O处理详解
同步I/O是一种阻塞式操作，应用程序在数据传输期间会暂停，直到I/O完成并返回状态码，然后程序才能继续执行并访问数据。例如，在Windows系统中，使用ReadFile和WriteFile等函数的简单模式就是同步I/O。这种方式虽然...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值