wd_dev.h

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

_inline wd_void wd_fio_disp_set_query_basic(
							wd_drv *driver,
							wd_fio_query_basic_func func)
{
    driver->FastIoDispatch->FastIoQueryBasicInfo = func;
}

_inline wd_void wd_fio_disp_set_query_standard(
							wd_drv *driver,
							wd_fio_query_standard_func func)
{
    driver->FastIoDispatch->FastIoQueryStandardInfo = func;
}

_inline wd_void wd_fio_disp_set_io_lock(
							wd_drv *driver,
							wd_fio_io_lock_func func)
{
    driver->FastIoDispatch->FastIoLock = func;
}

_inline wd_void wd_fio_disp_set_io_unlock_s(
							wd_drv *driver,
							wd_fio_unlock_single_func func)
{
    driver->FastIoDispatch->FastIoUnlockSingle = func;
}

_inline wd_void wd_fio_disp_set_io_unlock_a(
							wd_drv *driver,
							wd_fio_unlock_all_func func)
{
    driver->FastIoDispatch->FastIoUnlockAll = func;
}

_inline wd_void wd_fio_disp_set_io_unlock_a_by_key(
							wd_drv *driver,
							wd_fio_unlock_all_by_key_func func)
{
    driver->FastIoDispatch->FastIoUnlockAllByKey = func;
}

_inline wd_void wd_fio_disp_set_io_dev_ctl(
							wd_drv *driver,
							wd_fio_device_control_func func)
{
    driver->FastIoDispatch->FastIoDeviceControl = func;
}

_inline wd_void wd_fio_disp_set_io_query_network_open(
							wd_drv *driver,
							wd_fio_query_network_open_func func)
{
    driver->FastIoDispatch->FastIoQueryNetworkOpenInfo = func;
}

_inline wd_void wd_fio_disp_set_mdl_read(
							wd_drv *driver,
							wd_fio_mdl_read_func func)
{
	driver->FastIoDispatch->MdlRead = func;
}

_inline wd_void wd_fio_disp_set_mdl_read_complete(
							wd_drv *driver,
							wd_fio_mdl_read_complete_func func)
{
    driver->FastIoDispatch->MdlReadComplete = func;
}

_inline wd_void wd_fio_disp_set_prepare_mdl_write(
							wd_drv *driver,
							wd_fio_prepare_mdl_write_func func)
{
    driver->FastIoDispatch->PrepareMdlWrite = func;
}

_inline wd_void wd_fio_disp_set_mdl_write_complete(
							wd_drv *driver,
							wd_fio_mdl_write_complete_func func)
{
    driver->FastIoDispatch->MdlWriteComplete = func;
}

_inline wd_void wd_fio_disp_set_read_compressed(
							wd_drv *driver,
							wd_fio_read_compressed_func func)
{
    driver->FastIoDispatch->FastIoReadCompressed = func;
}

_inline wd_void wd_fio_disp_set_write_compressed(
							wd_drv *driver,
							wd_fio_write_compressed_func func)
{
    driver->FastIoDispatch->FastIoWriteCompressed = func;
}

_inline wd_void wd_fio_disp_set_detach_device(wd_drv *driver,
									  wd_fio_detach_device_func func)
{
	driver->FastIoDispatch->FastIoDetachDevice = func;
}

_inline wd_void wd_fio_disp_set_read_compressed_complete(
							wd_drv *driver,
							wd_fio_mdl_read_complete_compressed_func func)
{
    driver->FastIoDispatch->MdlReadCompleteCompressed = func;
}

_inline wd_void wd_fio_disp_set_write_compressed_complete(
							wd_drv *driver,
							wd_fio_mdl_write_complete_compressed_func func)
{
    driver->FastIoDispatch->MdlWriteCompleteCompressed = func;
}

_inline wd_void wd_fio_disp_set_query_open(wd_drv *driver,
								   wd_fio_query_open_func func)
{
    driver->FastIoDispatch->FastIoQueryOpen = func;
}

/// old 常数的重新定义意义不大，我们以后不再定义新的常数名。
/// 旧的保留起兼容代码的作用。
enum {wd_file_opt_dir = FILE_DIRECTORY_FILE};
enum {wd_file_attr_dir = FILE_ATTRIBUTE_DIRECTORY};

/// 以下是一组接口用来读写结构FileObject中的部分信息。由于FileObject
/// 这个结构过于复杂，随意读写其中的结构将给使我们的大部分
/// 代码失去通用性。因此采用了函数来进行接口简化。
_inline wd_dev *wd_file_dev(in_ wd_file *file)
{
	if(file == NULL)
		return NULL;
	return file->DeviceObject;
}
_inline wd_ustr *wd_file_filename(in_ wd_file *file)
{
	if(file == NULL)
		return NULL;
	return &file->FileName;
}
_inline wd_void wd_file_dev_set(wd_file *file, wd_dev *dev)
{	file->DeviceObject = dev;	}
_inline wd_void wd_file_offset_add(wd_file *file,wd_ulong len)
{	file->CurrentByteOffset.QuadPart += len;	}
_inline wd_void wd_file_offset_set(wd_file *file,wd_lgint offset)
{	file->CurrentByteOffset = offset;	}
_inline wd_ulong wd_file_flags(wd_file *file)
{	return file->Flags;	}
_inline wd_void wd_file_flags_set(wd_file *file,wd_ulong flags)
{	file->Flags = flags;	}
_inline wd_lgint wd_file_offset(wd_file *file)
{	return file->CurrentByteOffset;	}
_inline wd_bool wd_file_syn_io(wd_file *file)
{	return (file->Flags&FO_SYNCHRONOUS_IO)?wd_true:wd_false;	}

/// ZwCreateFile的变体.Zw的不方便之处在于不能直接传递文件名。
/// 必须填写ObjectAttributes.很多情况下我仅仅想简单的打开文件，
/// 可以调用这个函数。
_inline wd_handle wd_zw_file_create(
						const wd_wchar *file_name,
						wd_ulong desired_access,
						wd_ulong file_attr,
						wd_ulong share_access,
						wd_ulong create_disposition,
						wd_ulong create_option)
{
	OBJECT_ATTRIBUTES obj_attr;
	HANDLE handle;
	NTSTATUS status;
	IO_STATUS_BLOCK stat_block;
	UNICODE_STRING my_path;

	RtlInitUnicodeString(&my_path, file_name);

	InitializeObjectAttributes(
		&obj_attr,&my_path,
		OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE,NULL,NULL);

	status = ZwCreateFile(
		&handle,desired_access,
		&obj_attr,&stat_block,
		NULL,file_attr,
		share_access,
		create_disposition,
        create_option,NULL,0);

	if(NT_SUCCESS(status))
		return handle;
	return NULL;
}

/// ZwClose的变体。这个变体存在的意义在于和上面的wd_zw_file_create
/// 其他没有存在的意义。
_inline wd_stat wd_zw_file_close(wd_handle handle)
{
	return ZwClose(handle);
}

_inline wd_stat wd_dev_by_name(in_ wd_ustr *name, 
											  in_ wd_mask access_mask,
											  out_ wd_file **file,
											  out_ wd_dev **dev)
{
	return IoGetDeviceObjectPointer(name, access_mask, file, dev);
}

// old 陈旧函数，保留兼容用。
// 这个函数仅仅在create过滤之前调用有效，而且仅仅限于在卷设备
// 上生成的文件。
_inline wd_void wd_obj_get_name(in wd_void *obj,
								in out wd_ustr *name)
{
    wd_stat status;
    wd_char nibuf[512];        
    wd_obj_name * name_infor = (wd_obj_name *)nibuf;
    wd_ulong ret;
    status = ObQueryNameString(obj,name_infor,512,&ret);
    if (wd_suc(status)) 
	{
        wd_ustr_copy(name,&name_infor->Name);
    }
	else
	{
		name->Length = 0;
	}
}

// old 陈旧函数，保留兼容用。
// 这个函数仅仅在create过滤之后调用有效，而且仅仅限于在卷设备
// 上生成的文件。传入的name的长度至少应该是WD_MAX_PATH否则
// 可能非法操作.
_inline wd_bool wd_file_get_name(
					in wd_file *file,
					in out wd_ustr *name)
{
	// 新的取得法,适用于生成文件之后,总是长名
	wd_wchar *p;
	wd_wchar buf[260];
	wd_ustr temp;
	int len;

	wd_ustr_init_em( &temp, buf, 260*sizeof(wd_wchar) );

	// 尝试获得名字
	wd_obj_get_name( (wd_void *)file, &temp);

	wd_printf0( "FSFE: WDF: QueryFileName: [%wZ]\r\n",&temp );

	if( temp.Length == 0 )
		return wd_false;
	len = temp.Length/sizeof( wd_wchar );
	p = temp.Buffer;

	// 尝试找到第三个'\\'以便去掉前面的卷设备名
	p = wcschr( wd_ustr_buf( &temp ), L'\\' );
	if( p == NULL || ++p >= wd_ustr_buf( &temp ) + len )
		return wd_false;
	p = wcschr( p, L'\\' );
	if( p == NULL || ++p >= wd_ustr_buf( &temp ) + len )
		return wd_false;
	p = wcschr( p, L'\\' );
	if( p == NULL || (p+1) >= wd_ustr_buf( &temp ) + len )
		return wd_false;
	if( name->MaximumLength <= wcslen( p ) * sizeof( wd_wchar ) )
		return wd_false;

	name->Length = wcslen( p ) * sizeof( wd_wchar );
	wcscpy( name->Buffer, p );
	return wd_true;
}

#endif // _WD_SYN_HEADER_