wd_dev.h

国内文件驱动编程知名人物蔡大侠的教程源代码

///
///	@file	wd_dev.h
///	@brief	设备和驱动相关.如果你直接包含这个头文件,
///			在包含之前必须包含DDK相关头文件.(你可以
///			选择WDM或者IFS或者NDIS相关头文件.)
///	@author tan wen 谭文
///	@date	2005-12-20
///

#ifndef _WD_DEV_HEADER_
#define _WD_DEV_HEADER_

#include "wdf.h"			//< 依赖wdf.h
#include "wd_mem.h"	//< 依赖mem.h
#include "wd_ustr.h"		//< 依赖ustr.h

typedef OBJECT_NAME_INFORMATION wd_obj_name;
typedef DEVICE_TYPE wd_dev_type;
typedef HANDLE wd_handle;
typedef ACCESS_MASK wd_mask;

// 你必须定义一个g_cdo,如果你为你的驱动定义了一个
// 控制设备的话.如果你没有控制设备,你可以定义一个
// g_cdo.并设置为空.其他几个函数也是类似的.如果全
// 局变量没有定义,不能通过编译连接.如果没有正确赋
// 值,调用以下函数会得到错误结果.
extern wd_dev *g_cdo;
_inline wd_bool wd_is_my_cdo(wd_dev *dev)
{
	return (dev == g_cdo);
}
extern wd_drv *g_drv;
_inline wd_bool wd_is_my_drv(wd_drv *drv)
{
	return (g_drv == drv);
}

// old
enum {
	wdf_dev_secure_open = FILE_DEVICE_SECURE_OPEN
};

// old
enum {
	wd_dev_disk_fs = FILE_DEVICE_DISK_FILE_SYSTEM,
	wd_dev_cdrom_fs = FILE_DEVICE_CD_ROM_FILE_SYSTEM,
	wd_dev_network_fs = FILE_DEVICE_NETWORK_FILE_SYSTEM
};

_inline wd_void wd_obj_ref(wd_void *obj)
{	ObReferenceObject(obj);	}

_inline wd_void wd_obj_deref(wd_void *obj)
{	ObDereferenceObject(obj);	}

_inline wd_void * wd_dev_ext(wd_dev *dev) 
{	return (dev->DeviceExtension);	}

_inline wd_dev * wd_dev_attached(wd_dev *dev)
{	return dev->AttachedDevice;	}

typedef VPB wd_vpb;
_inline wd_vpb * wd_dev_vbp(wd_dev *dev)
{	return dev->Vpb;	}

_inline wd_dev * wd_vbp_dev(wd_vpb *vpb)
{	return vpb->DeviceObject;	}

_inline wd_stat wd_dev_create(in wd_drv *drv,
							  in wd_size ext_size,
							  in wd_ustr *name optional,
							  in wd_dev_type type,
							  in wd_ulong dev_chars,
							  in wd_bool exclusive,
							  out wd_dev **dev)
{
	wd_stat status = 
		IoCreateDevice(
				drv,
				ext_size,
				name,
				type,
				dev_chars,
				exclusive,
				dev);
	if(wd_suc(status) && ext_size != 0)
	{
		wd_memzero(wd_dev_ext(*dev),ext_size);
	}
	return status;
}

_inline wd_dev_type wd_dev_get_type(in wd_dev *dev)
{
	return dev->DeviceType;
}

_inline wd_drv * wd_dev_drv(in wd_dev *dev)
{
	return dev->DriverObject;
}

_inline wd_void wd_dev_del(in wd_dev *device)
{
	IoDeleteDevice(device);
}

_inline wd_void wd_dev_detach(in_ out_ wd_dev *device)
{
	IoDetachDevice(device);
}

_inline wd_void wd_dev_clr_init_flag(wd_dev *dev)
{
	dev->Flags &= ~DO_DEVICE_INITIALIZING;
}

_inline wd_void wd_dev_copy_buffer_flag(wd_dev *new_dev,
										wd_dev *old_dev)
{
    if(old_dev->Flags & DO_BUFFERED_IO)
        new_dev->Flags &= DO_BUFFERED_IO;
    if(old_dev->Flags & DO_DIRECT_IO)
        new_dev->Flags &= DO_DIRECT_IO;
}

_inline wd_void wd_dev_copy_flag(wd_dev *new_dev,
								 wd_dev *old_dev)
{
    if(old_dev->Flags & DO_BUFFERED_IO)
        new_dev->Flags &= DO_BUFFERED_IO;
    if(old_dev->Flags & DO_DIRECT_IO)
        new_dev->Flags &= DO_DIRECT_IO;
    if (old_dev->Characteristics & FILE_DEVICE_SECURE_OPEN)
        new_dev->Characteristics &= FILE_DEVICE_SECURE_OPEN;
}

_inline wd_stat wd_dev_attach(in wd_dev *src,
							  in wd_dev *dst,
							  in out wd_dev **attached)
{
	*attached = dst;
	*attached = IoAttachDeviceToDeviceStack(src,dst);
	if(*attached == NULL)
		return wd_stat_no_such_dev;
	return wd_stat_suc;
}

_inline wd_void wd_dev_dettach(in wd_dev *dst)
{
	IoDetachDevice(dst);
}

_inline wd_void wd_drv_set_unload(
			in wd_drv* driver,
			wd_void (*unload)(in wd_drv *driver))
{	driver->DriverUnload = unload;	};

_inline wd_void wd_drv_set_dispatch(in wd_drv* driver,
							in wd_disp_fuc disp)
{
	wd_size i;
    for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) 
        driver->MajorFunction[i] = disp;
}

_inline wd_void wd_drv_set_create(in wd_drv* driver,
						  in wd_disp_fuc create)
{
    driver->MajorFunction[IRP_MJ_CREATE] = create;
    driver->MajorFunction[IRP_MJ_CREATE_NAMED_PIPE] = create;
    driver->MajorFunction[IRP_MJ_CREATE_MAILSLOT] = create;
}

_inline wd_void wd_drv_set_file_sys_control(in wd_drv* driver,
									in wd_disp_fuc control)
{
	driver->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = control;
}

_inline wd_void wd_drv_set_clean_up(in wd_drv* driver,
							in wd_disp_fuc clean_up)
{
	driver->MajorFunction[IRP_MJ_CLEANUP] = clean_up;
}

_inline wd_void wd_drv_set_close(in wd_drv* driver,
						 in wd_disp_fuc close)
{
	driver->MajorFunction[IRP_MJ_CLOSE] = close; 
}

_inline wd_drv_set_write(in_ wd_drv* driver,
						 in_ wd_disp_fuc write)
{
	driver->MajorFunction[IRP_MJ_WRITE] = write;
}

_inline wd_drv_set_device_io_ctrl(in_ wd_drv* driver,
								  in_ wd_disp_fuc device_io_ctrl)
{
	driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = device_io_ctrl;
}

_inline wd_drv_set_read(in_ wd_drv* driver,
						in_	wd_disp_fuc read)
{
	driver->MajorFunction[IRP_MJ_READ] = read; 
}

typedef PFAST_IO_CHECK_IF_POSSIBLE	wd_fio_check_func;
typedef PFAST_IO_READ				wd_fio_read_func;
typedef PFAST_IO_WRITE				wd_fio_write_func;
typedef PFAST_IO_QUERY_BASIC_INFO		wd_fio_query_basic_func;
typedef PFAST_IO_QUERY_STANDARD_INFO	wd_fio_query_standard_func;
typedef PFAST_IO_LOCK					wd_fio_io_lock_func;
typedef PFAST_IO_UNLOCK_SINGLE			wd_fio_unlock_single_func;
typedef PFAST_IO_UNLOCK_ALL				wd_fio_unlock_all_func;
typedef PFAST_IO_UNLOCK_ALL_BY_KEY		wd_fio_unlock_all_by_key_func;
typedef PFAST_IO_DEVICE_CONTROL			wd_fio_device_control_func;
typedef PFAST_IO_ACQUIRE_FILE			wd_fio_acquire_file_func;
typedef PFAST_IO_RELEASE_FILE			wd_fio_release_file_func;
typedef PFAST_IO_DETACH_DEVICE			wd_fio_detach_device_func;
typedef PFAST_IO_QUERY_NETWORK_OPEN_INFO	wd_fio_query_network_open_func;
typedef PFAST_IO_ACQUIRE_FOR_MOD_WRITE		wd_fio_acquire_for_mod_write_func;
typedef PFAST_IO_MDL_READ					wd_fio_mdl_read_func;
typedef PFAST_IO_MDL_READ_COMPLETE		wd_fio_mdl_read_complete_func;
typedef PFAST_IO_PREPARE_MDL_WRITE		wd_fio_prepare_mdl_write_func;
typedef PFAST_IO_MDL_WRITE_COMPLETE		wd_fio_mdl_write_complete_func;
typedef PFAST_IO_READ_COMPRESSED		wd_fio_read_compressed_func;
typedef PFAST_IO_WRITE_COMPRESSED		wd_fio_write_compressed_func;
typedef PFAST_IO_MDL_READ_COMPLETE_COMPRESSED	wd_fio_mdl_read_complete_compressed_func;
typedef PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED	wd_fio_mdl_write_complete_compressed_func;
typedef PFAST_IO_QUERY_OPEN				wd_fio_query_open_func;
typedef PFAST_IO_RELEASE_FOR_MOD_WRITE	wd_fio_release_for_mod_write_func;
typedef PFAST_IO_ACQUIRE_FOR_CCFLUSH	wd_fio_acquire_for_ccflush_func;
typedef PFAST_IO_RELEASE_FOR_CCFLUSH	wd_fio_release_for_ccflush_func;


_inline wd_bool wd_fio_disp_init(wd_drv *driver,wd_ulong size)
{
	wd_fio_disp *disp = wd_malloc(wd_false,size);
	if(disp == wd_null)
		return wd_false;
	wd_memzero((wd_pvoid)disp,size);
	driver->FastIoDispatch = disp;
	driver->FastIoDispatch->SizeOfFastIoDispatch = size;
	return wd_true;
}

_inline wd_void wd_fio_disp_release(wd_drv *driver)
{
	if(driver->FastIoDispatch)
	{
		wd_free(driver->FastIoDispatch);
		driver->FastIoDispatch = NULL;
	}
}

_inline wd_void wd_fio_disp_set_check(wd_drv *driver,wd_fio_check_func func)
{
    driver->FastIoDispatch->FastIoCheckIfPossible = func;
}

_inline wd_void wd_fio_disp_set_read(wd_drv *driver,wd_fio_read_func func)
{
    driver->FastIoDispatch->FastIoRead = func;
}

_inline wd_void wd_fio_disp_set_write(
							wd_drv *driver,
							wd_fio_write_func func)
{
    driver->FastIoDispatch->FastIoWrite = func;
}