内核事件KEVENT（同步）

最新推荐文章于 2022-01-16 11:53:32 发布
最新推荐文章于 2022-01-16 11:53:32 发布
阅读量376 收藏
点赞数
本文介绍Windows内核驱动间及驱动与应用间的事件交互方法。包括使用IoCreateNotificationEvent创建命名事件，不同驱动通过名字获取事件进行通信；驱动与应用通过OpenEvent及DeviceIoControl进行事件交互；应用创建事件并通过DeviceIoControl传递给驱动。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转载请您注明出处：http://www.cnblogs.com/lsh123/p/7358702.html

 

一.驱动程序与驱动程序的事件交互    IoCreateNotificationEvent ———> IoCreateNotificationEvent

　　

　　在内核驱动中可以通过给某个内核对象创建一个命名对象，然后在另一个驱动中通过名字来获取这个对象，然后操作它来实现两个驱动之间的内核对象的通讯，针对事件对象来说，要实现两个驱动交互事件对象，通过这样几步： 


1. 在驱动Server中调用IoCreateNotificationEvent或者IoCreateSynchronizationEvent来创建一个通知事件对象或者同步事件对象 
2. 在驱动Client中调用 IoCreateNotificationEvent或者IoCreateSynchronizationEvent获取已经有名字的内核对象的句柄 ,设置事件的激发状态
(3. 在驱动B中调用ObReferenceObjectByHandle根据上面两个函数返回的句柄来获取A中的事件对象，并操作它) 

 

源代码：

Server.c

#include <ntifs.h>
#define EVENT_NAME  L"\\BaseNamedObjects\\ServerKernelEvent"

void ThreadProcedure(PVOID ParameterData);
VOID DriverUnload(PDRIVER_OBJECT DriverObject);

PKEVENT __Event;
HANDLE __EventHandle;

NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
{
	NTSTATUS Status = STATUS_SUCCESS;
	UNICODE_STRING  EventName;
	PDEVICE_OBJECT  DeviceObject = NULL;
	HANDLE   ThreadHandle = NULL;
	CLIENT_ID       ClientID = { 0 };



	DriverObject->DriverUnload = DriverUnload;
	

	RtlInitUnicodeString(&EventName, EVENT_NAME);
	DriverObject->DriverUnload = DriverUnload;


	__Event = IoCreateNotificationEvent(
		&EventName,                    //自定义事件名
		&__EventHandle);               //返回的事件句柄
	KeResetEvent(__Event);


	Status = PsCreateSystemThread(&ThreadHandle, 0, NULL, NtCurrentProcess(), &ClientID,
		(PKSTART_ROUTINE)ThreadProcedure,NULL);



	return Status;
}

void ThreadProcedure(PVOID ParameterData)
{
	NTSTATUS Status;
	KeWaitForSingleObject(__Event, Executive, KernelMode, FALSE, NULL);
	DbgPrint("ThreadProcedure() Exit\r\n");
	PsTerminateSystemThread(STATUS_SUCCESS);
}

VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
	DbgPrint("DriverUnload()\r\n");
	if (__EventHandle != NULL)
	{
		KeClearEvent(__Event);

		ZwClose(__EventHandle);

		__EventHandle = NULL;
		__Event = NULL;
	}

}

 

Client.c

#include <ntifs.h>

#define EVENT_NAME  L"\\BaseNamedObjects\\ServerKernelEvent"
VOID DriverUnload(PDRIVER_OBJECT DriverObject);

PKEVENT __Event;
HANDLE __EventHandle;
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
{
	NTSTATUS Status = STATUS_SUCCESS;
	UNICODE_STRING  EventName;
	PDEVICE_OBJECT  DeviceObject = NULL;
	DriverObject->DriverUnload = DriverUnload;
	RtlInitUnicodeString(&EventName, EVENT_NAME);
	__Event = IoCreateNotificationEvent(&EventName, &__EventHandle);    //获取已经有名字的内核对象的句柄
	KeSetEvent(__Event, IO_NO_INCREMENT, FALSE);                        //设置激发态
	return Status;
}


VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
	DbgPrint("DriverUnload()\r\n");
	if (__EventHandle != NULL)
	{
		KeClearEvent(__Event);
		ZwClose(__EventHandle);
		__EventHandle = NULL;
		__Event = NULL;
	}

}

　　

二.驱动程序与应用程序的事件交互（驱动程序创建事件——>应用程序设置事件）IoCreateNotificationEvent ——> OpenEvent

　　应用程序中创建的事件和在内核模式下创建的事件对象，本质上是同一个东西。在用户模式下，它用句柄代表，在内核模式下，它用KEVENT数据结构代表。
在应用程序中，所有内核对象都不会被用户看到，用户看到的只是代表内核对象的对象句柄。

　　__Event = IoCreateNotificationEvent(&EventName, &__EventHandle); //DriverEntry 进程回调通知


　　EventHandle = OpenEvent(
　　　　SYNCHRONIZE, //请求访问权限
　　　　FALSE, // 不继承
　　　　L"Global\\Ring0KernelEvent"); //事件对象名称

　　1.驱动程序IoCreateNotificationEvent创建事件
　　2.应用程序OpenEvent得到事件句柄

 

Ring3.cpp

 

// Ring3(设置).cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
	
	HANDLE EventHandle = NULL;


	while (TRUE)
	{
		EventHandle = OpenEvent(
			SYNCHRONIZE,          //请求访问权限
			FALSE,                // 不继承
			L"Global\\Ring0KernelEvent"); //事件对象名称


		if (EventHandle == NULL)
		{
			continue;
		}

		break;
	}

	cout << "Ring3等待" << endl;
	while (TRUE)
	{

		int Index = WaitForSingleObject(EventHandle, 3000);

		Index = Index - WAIT_OBJECT_0;

		if (Index == WAIT_TIMEOUT)
		{

			//注意这里当驱动卸载并关闭事件时事件对象是不能够得到及时的销毁 因为应用层占用了该对象 
			//所以我们长时间等待不到授信 就关闭并重新打开
			if (EventHandle != NULL)
			{
				CloseHandle(EventHandle);
				EventHandle = NULL;
				EventHandle = OpenEvent(SYNCHRONIZE, FALSE, L"Global\\Ring0KernelEvent");

				if (EventHandle == NULL)
				{
					cout << "对象已经不存在" << endl;
					break;
				}
			}



			continue;
		}

		if (Index == 0)            //有信号状态
		{
			cout << "Ring0触发Ring3" << endl;
		}


		if (Index == WAIT_FAILED)
		{
			break;
		}

		Sleep(1);
	}


	cout << "Input AnyKey To Exit" << endl;

	getchar();
	if (EventHandle != NULL)
	{
		CloseHandle(EventHandle);
		EventHandle = NULL;

	}
	return 0;
}

　　

Ring0.c

#include <ntifs.h>

#define EVENT_NAME  L"\\BaseNamedObjects\\Ring0KernelEvent"
VOID DriverUnload(PDRIVER_OBJECT DriverObject);

PKEVENT __Event;
HANDLE __EventHandle;

NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
{
	NTSTATUS Status = STATUS_SUCCESS;
	PDEVICE_OBJECT  DeviceObject = NULL;	
	UNICODE_STRING  EventName;

	RtlInitUnicodeString(&EventName, EVENT_NAME);
	DriverObject->DriverUnload = DriverUnload;


	__Event = IoCreateNotificationEvent(&EventName, &__EventHandle);    //DriverEntry     进程回调通知

	return Status;
}

VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
	DbgPrint("DriverUnload()\r\n");

	if (__EventHandle != NULL)
	{
		KeClearEvent(__Event);

		ZwClose(__EventHandle);

		__EventHandle = NULL;
		__Event = NULL;
	}

}

　　

 

三.应用程序与驱动程序的事件交互（应用程序创建事件——>驱动程序设置事件） DeviceIoControl ——> ObReferenceObjectByHandle

　　要将用户模式下创建的事件传递给驱动程序，可以用DeviceIoControl API函数。DDK提供了内核函数将句柄转化为指针，该函数如下：
　　NTSTATUS 
  　  ObReferenceObjectByHandle(
   　　 IN HANDLE  Handle,
　　    IN ACCESS_MASK  DesiredAccess,
   　　 IN POBJECT_TYPE  ObjectType  OPTIONAL,
  　　  IN KPROCESSOR_MODE  AccessMode,
 　　   OUT PVOID  *Object,
 　　   OUT POBJECT_HANDLE_INFORMATION  HandleInformation  OPTIONAL
   　　 );

　　ObReferenceObjectByHandle函数在得到指针的同时，会为对象的指针维护一个计数。每次调用ObReferenceObjectByHandle函数时会使计数加1.因此为了计数平衡，在使用完 ObReferenceObjectByHandle函数后，需要调用如下函数：　　　　　　       
　　VOID 
  　　ObDereferenceObject(
   　　 IN PVOID  Object
   　　 );
　　ObDereferenceObject函数使计数减一。

　　1.应用程序通过符号链接名由CreateFile函数得到设备句柄

　　HANDLE DeviceHandle = CreateFile(DeviceLinkName,
　　　　GENERIC_READ | GENERIC_WRITE,
　　　　FILE_SHARE_READ | FILE_SHARE_WRITE,
　　　　NULL,
　　　　OPEN_EXISTING,
　　　　FILE_ATTRIBUTE_NORMAL,
　　　　NULL);
　　2.应用程序CreateEvent创建事件

　　　　//创建自动重置的，初始为未激发的事件对象
　　　　EventHandle[i] = CreateEvent(NULL, FALSE, FALSE, NULL);

　　3.应用程序通过DeviceIoControl 函数将用户模式下创建的事件传递给驱动程序

　　　　//调用DeviceIoControl把事件句柄传进内核
　　　　IsOk = DeviceIoControl(DeviceHandle, CTL_EVENT,
　　　　　　EventHandle,
　　　　　　sizeof(HANDLE) * 2,
　　　　　　NULL,
　　　　　　0,
　　　　　　&ReturnLength,
　　　　　　NULL);

　　　　//调用DeviceIoControl,通知驱动程序设置事件激发状态
　　　　IsOk = DeviceIoControl(DeviceHandle, CTL_SET_EVENT,
　　　　　　NULL,
　　　　　　0,
　　　　　　NULL,
　　　　　　0,
　　　　　　&ReturnLength,
　　　　　　NULL);

　　4.驱动程序通过ObReferenceObjectByHandle将句柄转化为PKEVENT指针

　　　　/把句柄转化为KEvent结构
　　　　Status = ObReferenceObjectByHandle(
　　　　　　(HANDLE)EventHandle[i], //Irp->AssociatedIrp.SystemBuffer 句柄
　　　　　　SYNCHRONIZE, //权限
　　　　　　*ExEventObjectType, //对象类型，对象类型
　　　　　　KernelMode, //访问模式分KernelMode
　　　　　　&__KernelEvent[i], //指向映射句柄对象的指针
　　　　　　NULL);

Ring3.cpp

#include "stdafx.h"
#include <windows.h>
#include <iostream>
using namespace std;

#define CTL_EVENT \
	CTL_CODE(FILE_DEVICE_UNKNOWN,0x830,METHOD_BUFFERED,FILE_ANY_ACCESS)

#define CTL_SET_EVENT \
	CTL_CODE(FILE_DEVICE_UNKNOWN,0x831,METHOD_BUFFERED,FILE_ANY_ACCESS)


HANDLE SeOpenDeviceObject(WCHAR* DeviceLinkName);
DWORD WINAPI ThreadProcedure(LPVOID ParameterData);
int main()
{
	HANDLE DeviceHandle = SeOpenDeviceObject(L"\\\\.\\Ring0DeviceLinkName");
	if (DeviceHandle == NULL)
	{
		return 0;
	}

	ULONG i = 0;
	HANDLE EventHandle[3] = { 0 };
	for (i = 0; i < 3; i++)
	{
		//创建自动重置的，初始为未激发的事件对象
		EventHandle[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
	}
	BOOL IsOk = 0;
	DWORD ReturnLength = 0;
	//调用DeviceIoControl把事件句柄传进内核
	IsOk = DeviceIoControl(DeviceHandle, CTL_EVENT,
		EventHandle,
		sizeof(HANDLE) * 2,
		NULL,
		0,
		&ReturnLength,
		NULL);


	if (IsOk == FALSE)
	{
		goto Exit;
	}


	HANDLE  ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProcedure, 
		(PVOID)EventHandle, 0, NULL);
	//调用DeviceIoControl,通知驱动程序设置事件激发状态
	IsOk = DeviceIoControl(DeviceHandle, CTL_SET_EVENT,
		NULL,
		0,
		NULL,
		0,
		&ReturnLength,
		NULL);

	if (IsOk == FALSE)
	{
		cout << "Send IoCode Error" << endl;
		SetEvent(EventHandle[2]);
		WaitForSingleObject(ThreadHandle, INFINITE);
		goto Exit;
	}


	WaitForSingleObject(ThreadHandle, INFINITE);


Exit:
	{
		for (i = 0; i < 3; i++)
		{
			if (EventHandle[i] != NULL)
			{
				CloseHandle(EventHandle[i]);
				EventHandle[i] = NULL;
			}
		}
		if (ThreadHandle != NULL)
		{
			CloseHandle(ThreadHandle);
			ThreadHandle = NULL;
		}
		if (DeviceHandle != NULL)
		{
			CloseHandle(DeviceHandle);
			DeviceHandle = NULL;
		}
	}

	printf("卸载驱动后 Input AnyKey To Exit\r\n");
	getchar();
	getchar();


	return 0;

}

DWORD WINAPI ThreadProcedure(LPVOID ParameterData)
{

	cout << "Ring3等待" << endl;
	//等待三个之中有激发状态的信号
	DWORD Index = WaitForMultipleObjects(3, (HANDLE*)ParameterData, FALSE, INFINITE);
	Index = Index - WAIT_OBJECT_0;
	if (Index == 2)  //0 1 2
	{
		printf("ThreadProcedure() Exit\r\n");
		return 0;
	}
	cout << "Ring0触发Ring3" << endl;
	cout << "输入任意键Ring3触发Ring0" << endl;

	getchar();
	getchar();

	SetEvent(((HANDLE*)ParameterData)[1]);  //Ring0中KeWaitForSingleObject响应
	printf("ThreadProcedure() Exit\r\n");
	return 0;
}


HANDLE SeOpenDeviceObject(WCHAR* DeviceLinkName)
{
	HANDLE DeviceHandle = CreateFile(DeviceLinkName,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);

	if (DeviceHandle == INVALID_HANDLE_VALUE)
	{
		return NULL;
	}

	return DeviceHandle;

}

　　

Ring0.c

#include <ntifs.h>

#define CTL_EVENT \
	CTL_CODE(FILE_DEVICE_UNKNOWN,0x830,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define CTL_SET_EVENT \
	CTL_CODE(FILE_DEVICE_UNKNOWN,0x831,METHOD_BUFFERED,FILE_ANY_ACCESS)


#define DEVICE_OBJECT_NAME  L"\\Device\\Ring0DeviceObjectName"
//设备与设备之间通信
#define DEVICE_LINK_NAME    L"\\DosDevices\\Ring0DeviceLinkName"
NTSTATUS PassThroughDispatch(PDEVICE_OBJECT  DeviceObject, PIRP Irp);
NTSTATUS ControlThroughDispatch(PDEVICE_OBJECT  DeviceObject, PIRP Irp);
VOID DriverUnload(PDRIVER_OBJECT DriverObject);
NTSTATUS Ring3EventHandleToRing0KernelEvent(HANDLE* EventHandle, ULONG_PTR EventHandleCount);

PKEVENT  __KernelEvent[20] = { 0 };
ULONG_PTR __KernelEventCount = 0;

extern
POBJECT_TYPE* ExEventObjectType;

NTSTATUS DriverEntry(PDRIVER_OBJECT  DriverObject, PUNICODE_STRING  RegisterPath)
{
	UNREFERENCED_PARAMETER(RegisterPath);
	NTSTATUS Status = STATUS_SUCCESS;
	PDEVICE_OBJECT  DeviceObject = NULL;
	UNICODE_STRING  DeviceObjectName;
	UNICODE_STRING  DeviceLinkName;
	ULONG			i;
	DriverObject->DriverUnload = DriverUnload;

	//创建设备对象名称
	RtlInitUnicodeString(&DeviceObjectName, DEVICE_OBJECT_NAME);

	//创建设备对象
	Status = IoCreateDevice(DriverObject, NULL,
		&DeviceObjectName,
		FILE_DEVICE_UNKNOWN,
		0, FALSE,
		&DeviceObject);
	if (!NT_SUCCESS(Status))
	{
		return Status;
	}
	//创建设备连接名称
	RtlInitUnicodeString(&DeviceLinkName, DEVICE_LINK_NAME);

	//将设备连接名称与设备名称关联 
	Status = IoCreateSymbolicLink(&DeviceLinkName, &DeviceObjectName);

	if (!NT_SUCCESS(Status))
	{
		IoDeleteDevice(DeviceObject);
		return Status;
	}
	//设计符合我们代码的派遣历程	
	for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
	{
		DriverObject->MajorFunction[i] = PassThroughDispatch;   //函数指针
	}
	DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ControlThroughDispatch;

	return STATUS_SUCCESS;
}



NTSTATUS ControlThroughDispatch(PDEVICE_OBJECT  DeviceObject, PIRP Irp)
{

	NTSTATUS Status = STATUS_UNSUCCESSFUL;
	ULONG_PTR Information = 0;
	PVOID InputData = NULL;
	ULONG InputDataLength = 0;
	PVOID OutputData = NULL;
	ULONG OutputDataLength = 0;
	ULONG IoControlCode = 0;
	PEPROCESS EProcess = NULL;
	PIO_STACK_LOCATION  IoStackLocation = IoGetCurrentIrpStackLocation(Irp);  //Irp堆栈	
	IoControlCode = IoStackLocation->Parameters.DeviceIoControl.IoControlCode;
	InputData = Irp->AssociatedIrp.SystemBuffer;
	OutputData = Irp->AssociatedIrp.SystemBuffer;
	InputDataLength = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;
	OutputDataLength = IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength;
	switch (IoControlCode)
	{
	case CTL_EVENT:
	{

		if (InputData != NULL&&InputDataLength == sizeof(HANDLE)*2)
		{

			Status = Ring3EventHandleToRing0KernelEvent((HANDLE*)InputData, InputDataLength / sizeof(HANDLE));

		}

	
		Information = 0;

		break;

	}

	case CTL_SET_EVENT:
	{

		DbgPrint("Ring0触发Ring3\r\n");
		KeSetEvent(__KernelEvent[0], IO_NO_INCREMENT, FALSE);  //Ring3层线程中WaitForMultipleObjects响应

		DbgPrint("Ring0等待\r\n");
		Status = KeWaitForSingleObject(__KernelEvent[1],
			Executive, KernelMode, FALSE, NULL);    //注意这里的最后一个参数NULL 是永久等待

		DbgPrint("Ring3触发Ring0\r\n");
	
		Information = 0;
		break;

	}

	default:
	{

		Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
		Irp->IoStatus.Information = 0;



		break;
	}
	}

	Irp->IoStatus.Status = Status;
	Irp->IoStatus.Information = Information;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return Status;
}


NTSTATUS Ring3EventHandleToRing0KernelEvent(HANDLE* EventHandle, ULONG_PTR EventHandleCount)
{
	NTSTATUS   Status = STATUS_SUCCESS;
	PULONG_PTR HandleArray = NULL;
	ULONG i = 0;
	
	if (EventHandle==NULL)
	{
		return STATUS_UNSUCCESSFUL;
	}
	__KernelEventCount = EventHandleCount;
	for (i = 0; i < EventHandleCount; i++)
	{
		//把句柄转化为KEvent结构
		Status = ObReferenceObjectByHandle(
			(HANDLE)EventHandle[i],           //Irp->AssociatedIrp.SystemBuffer   句柄
			SYNCHRONIZE,                      //权限
			*ExEventObjectType,               //对象类型，对象类型
			KernelMode,                       //访问模式分KernelMode
			&__KernelEvent[i],                //指向映射句柄对象的指针
			NULL);
		if (!NT_SUCCESS(Status))
		{
			break;
		}
	}

	if (Status != STATUS_SUCCESS)
	{
		for (i = 0; i < EventHandleCount; i++)
		{
			if (__KernelEvent[i] != NULL)
			{
				//递减计数
				ObDereferenceObject(__KernelEvent[i]);

				__KernelEvent[i] = NULL;
			}
		}
	}
	return Status;
}


NTSTATUS PassThroughDispatch(PDEVICE_OBJECT  DeviceObject, PIRP Irp)
{
	Irp->IoStatus.Status = STATUS_SUCCESS;     //LastError()
	Irp->IoStatus.Information = 0;             //ReturnLength 
	IoCompleteRequest(Irp, IO_NO_INCREMENT);   //将Irp返回给Io管理器
	return STATUS_SUCCESS;
}

VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
	int i = 0;
	UNICODE_STRING  DeviceLinkName;
	PDEVICE_OBJECT	v1 = NULL;
	PDEVICE_OBJECT  DeleteDeviceObject = NULL;

	RtlInitUnicodeString(&DeviceLinkName, DEVICE_LINK_NAME);
	IoDeleteSymbolicLink(&DeviceLinkName);

	DeleteDeviceObject = DriverObject->DeviceObject;
	while (DeleteDeviceObject != NULL)
	{
		v1 = DeleteDeviceObject->NextDevice;
		IoDeleteDevice(DeleteDeviceObject);
		DeleteDeviceObject = v1;
	}
	for (i = 0; i < __KernelEventCount; i++)
	{
		if (__KernelEvent[i] != NULL)
		{
			ObDereferenceObject(__KernelEvent[i]);

			__KernelEvent[i] = NULL;
		}
	}
}

　　

 

dadahahaha
关注
windows内核编程基础篇之使用同步事件
知其所以然
09-11 1489
内核中的事件是一个数据结构，这个结构的指针可以当作一个参数传入一个等待函数中。若这个事件不被“设置”，则这个等待函数不会返回。这个线程被阻塞，若这个事件被“设置”，则等待结束，可以继续下去。        这个常常用于多线程之间的同步，若一个线程需要等待另外一个线程完成某事后才能做某事，则可以使用事件等待，另一个线程完成后设置事件即可。        该数据结构是KEVENT， 器被  K
内核线程之间的同步，R3线程和内核线程的同步
lygl35的博客
01-21 534
作用 当线程1需要等待线程2处理一些事情的时候就用到这种线程同步机制 知识点 1、事件，信号灯，互斥体都是线程之间通讯的方式，事件的通讯能满足大部分需求。 2、休眠函数 LARGE_INTEGER sleeptime = {0};//定义一个休眠的时间 sleeptime.QuadPart = -100 * 10 * 100 * 3;//这里是3秒时间 while (1) { //这个函数相当于R3程序的 Sleep 让线程休眠 KeDelayExecutionThread(Kernel
深入分析 Kqueue & Kevent 原理及应用
weixin_38387929的博客
07-08 4210
转载者注：此篇转载内容是两篇博文的汇总，Kqueue用例部分增加csdn 《春夜喜雨》的demo用例分析，转者认为更容易让读者理解和认知。 常见IO复用技术对比 Wiki上的解释： kqueue 是一种可扩展的事件通知接口。2000 年 7 月发布的 FreeBSD 4.1 中首次引入了 kqueue，随后也被 NetBSD、OpenBSD、macOS 等操作系统支持。 kqueue 在内核与用户空间之间充当输入输出事件的管线。因此在事件循环的迭代中，进行一次 kevent(2) 系统调用不仅可以接收未决
可扩展的事件复用技术：epoll和kqueue
diansu5840的博客
08-18 385
通常来说我喜欢Linux更甚于BSD系统，但是我真的想在Linux上拥有BSD的kqueue功能。 什么是事件复用技术 假设你有一个简单的web服务器，并且那里已经打开了两个socket连接。当服务器从两个连接那里都收到Http请求的时候，它应该返回一个Http响应给客户端。但是你没法知道那个客户端先发送的消息和什么时候发送的。BSD套接字接口的阻塞行为意味着，如果你在一个连接...
kqueue介绍
08-29 1万+
转自 : http://ray.bsdart.org/archives/304.raymond 这篇文章我从第一次接触kqueue到目前的理解，一直放在我的mempad中，最近有朋友对kqueue的一些疑问，所以我就把这个发出来。 首先需要简单的说明几个概念, struct event, kevent()和kqueue。 struct event就是kevent()操作的最基本的事件结构
搜索驱动程序分配的内存和查看KEVENT状态
lixiangminghate的专栏
12-03 893
上周调驱动，总觉得有个线程一直被阻塞在某个KEVENT上，最后费了很大劲才定位。由于代码是公司某个程序的一部分，不能拿出来演示，所以这里借用WinDDK\generate\event来模拟我定位的过程。当然，你可能会觉得这不就是定位有多线程同步引起的死锁吗，有什么难的？用调试器中断调试目标，然后回溯所有线程(类似windbg ~*kb命令)的调用栈不就行了。没错，对于应用程序而言，这样做十有八九已
驱动程序使用 EVENT 主动和应用程序通信
LYSM
06-24 2629
背景 用户层程序使用 DeviceIoControl 将 IOCTL 控制码、输入缓冲区、输出缓冲区传入到内核；内核响应 IRP_MJ_DEVICE_CONTRL 消息，并从 IRP 中获取传入的 IOCTL 控制码、输入缓冲区、输出缓冲区，以此实现数据的交互。 但是，当内核层想主动传递数据到用户层，用户层又怎样才能知道呢？因为只有用户层知道内核层有数据输出的时候，它才会调用 DeviceIoControl 函数去获取数据。所以，本文要介绍的就是基于事件 EVENT 实现的同步框架，可以解决这个的问题。 函
理解Windows内核驱动的事件和同步机制
# 第一章：Windows内核驱动简介 ## 1.1 Windows操作系统内核概述 Windows操作系统的内核是操作系统的核心部分，负责管理系统资源、进程调度、内存管理等核心功能。...在Windows内核驱动中，事件是
利用同步事件实现驱动主动通知应用
Hooooxz的博客
04-24 1523
一、同步事件 对数据结构 KEVENT 进行初始化、等待和设置，实现多个线程之间的同步。例如，希望主线程 A 在等待线程 B 完成某事后才能做某事，可在主线程 A 中配置KEVENT事件等待，在线程B中完成操作后，对正在等待的KEVENT事件进行设置即可。 实例如下： // 定义一个事件 KEVENT event; // 事件初始化 KeInitializeEvent(&amp;even...
Linux内核学习9——内核多任务并发实例（上）
weixin_45730790的博客
01-16 685
这里我们来看看Linux中是如何使用同步机制来实现复杂的多任务同步的 首先来介绍一下这个例子 有一个内核共享资源（链表），同时有三种不同类型的内核任务会访问该链表，并对其进行插入或者删除节点的操作，内核线程负责向链表加入新节点，内核定时器负责定时/删除节点，而系统调用负责在某个时刻销毁整个链表。这三种内核任务并发执行时，有可能会破坏链表数据的完整性，所以我们必须对链表进同步访问保护，以确保数据的一致性。在这样一个多任务并发访问的模型中，我们需要选用合适的内核同步机制来管理这些任务，使得它们能够有条不紊的执
c语言socket网络通信-kevent的io复用
muerbingsha的博客
07-03 2003
github上代码地址：点击打开链接直接上代码：Server端#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt;   #include &lt;arpa/inet.h&gt; #include &lt;netinet/in.h&gt; #include &lt;sys/event.h&gt; #i...
Zw 系列函数
huanongying131的博客
11-19 3920
转：http://blog.sina.com.cn/s/blog_4a1acc7f0100cfud.html      896  37F 0000D379 ZwAcceptConnectPort         897  380 0000D38E ZwAccessCheck         898  381 0000D3A3 ZwAccessCheckAndAuditAlarm         ...
kqueue用法简介
zdy0_2004的专栏
07-02 1万+
http://www.cnblogs.com/luminocean/p/5631336.html 1.什么是kqueue和IO复用 kueue是在UNIX上比较高效的IO复用技术。 所谓的IO复用，就是同时等待多个文件描述符就绪，以系统调用的形式提供。如果所有文件描述符都没有就绪的话，该系统调用阻塞，否则调用返回，允许用户进行后续的操作。 常见的IO复用技术有select, poll,
epoll详解_Linux下的I/O复用与epoll详解
weixin_39874881的博客
11-30 633
前言 I/O多路复用有很多种实现。在linux上，2.4内核前主要是select和poll，自Linux 2.6内核正式引入epoll以来，epoll已经成为了目前实现高性能网络服务器的必备技术。尽管他们的使用方法不尽相同，但是本质上却没有什么区别。本文将重点探讨将放在EPOLL的实现与使用详解。参考资料：嵌入式网络编程 - linux下的IO模型嵌入式应用层开发 - Linux开发必备...
当usbnet打印 kevent * may have been dropped
linken_yue的博客
09-08 5582
Every once in a while when my system is under a bit of stress I see some spammy messages show up in my logs that say: kevent X may have been dropped As far as I can tell these messages aren't ter...
【nginx】kevent() reported that connect() failed (61: Connection refused)
热门推荐
coding tree
12-25 1万+
访问php页面时，nginx报如下错误 2014/12/25 12:36:13 [error] 3846#0: *3 kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request
总结应用和驱动之间用事件通讯的办法（转）
我的编程之旅
05-13 2716
总结应用和驱动之间用事件通讯的办法1. 驱动中IoCreateNotificationEvent，KeClearEvent 应用中OpenEvent(SYNCHRONIZE, FALSE, EVENT_NAME) 这样，只能在应用中WaitForSingleObject，而不能SetEvent,ResetEvent 驱动中可以KeSetEvent，（而且必须紧接着KeClearEvent，因为
windows event 总结
tifentan的专栏
12-29 1247
1.官方demo：https://msdn.microsoft.com/en-us/library/windows/desktop/ms686915(v=vs.85).aspx 2.关于pulseEvent,官方建议是不要用了，因为不能确保到达。这里有篇文章说的很清楚了。 关于线程同步 PulseEvent() 3.关于setEvent，手动event可以激活所有等待的线程，并保持se
Windows内核编程：探索基本数据结构
在Windows内核中，还有一些其他重要的数据结构，如IRP（I/O请求包）用于传递I/O请求，以及KEVENT和KMUTANT等同步对象，用于线程同步和资源管理。IRP包含了关于I/O请求的所有信息，包括请求的类型、目标设备、缓冲区...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值