ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Open a real file handle for drive devices, and get rid of the server 

device hacks (based on a patch by Eric Pouech).
This commit is contained in:
Alexandre Julliard 2004-03-04 23:00:18 +00:00
parent 05df86a38f
commit db692c8f39
13 changed files with 129 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
dlls/ntdll/cdrom.c
View File

@ -2,7 +2,7 @@
/* Main file for CD-ROM support
*
* Copyright 1994 Martin Ayotte
* Copyright 1999, 2001 Eric Pouech
* Copyright 1999, 2001, 2003 Eric Pouech
* Copyright 2000 Andreas Mohr
*
* This library is free software; you can redistribute it and/or
@ -83,6 +83,9 @@
#include "ntddstor.h"
#include "ntddcdrm.h"
#include "ntddscsi.h"
#include "ntdll_misc.h"
#include "wine/server.h"
#include "wine/library.h"
#include "wine/debug.h"
/* Non-Linux systems do not have linux/cdrom.h and the like, and thus
@ -182,14 +185,19 @@ struct linux_cdrom_generic_command
* for toc inquiries.
*/
struct cdrom_cache {
int fd;
int count;
char toc_good; /* if false, will reread TOC from disk */
CDROM_TOC toc;
int fd;
dev_t device;
ino_t inode;
char toc_good; /* if false, will reread TOC from disk */
CDROM_TOC toc;
SUB_Q_CURRENT_POSITION CurrentPosition;
const char *device;
};
static struct cdrom_cache cdrom_cache[26];
/* who has more than 5 cdroms on his/her machine ?? */
/* FIXME: this should grow depending on the number of cdroms we install/configure
* at startup
*/
#define MAX_CACHE_ENTRIES 5
static struct cdrom_cache cdrom_cache[MAX_CACHE_ENTRIES];
/* Proposed media change function: not really needed at this time */
/* This is a 1 or 0 type of function */
@ -201,7 +209,7 @@ static int CDROM_MediaChanged(int dev)
struct cdrom_tochdr hdr;
struct cdrom_tocentry entry;
if (dev < 0 || dev >= 26)
if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
return 0;
if ( ioctl(cdrom_cache[dev].fd, CDROMREADTOCHDR, &hdr) == -1 )
return 0;
@ -365,71 +373,70 @@ static void CDROM_ClearCacheEntry(int dev)
static int CDROM_GetInterfaceInfo(int fd, int* port, int* iface, int* device,int* lun)
{
#if defined(linux)
struct stat st;
if ( fstat(fd, &st) == -1 || ! S_ISBLK(st.st_mode))
{
struct stat st;
if ( fstat(fd, &st) == -1 || ! S_ISBLK(st.st_mode)) {
FIXME("cdrom not a block device!!!\n");
FIXME("cdrom not a block device!!!\n");
return 0;
}
*port = 0;
*iface = 0;
*device = 0;
*lun = 0;
switch (major(st.st_rdev)) {
case IDE0_MAJOR: *iface = 0; break;
case IDE1_MAJOR: *iface = 1; break;
case IDE2_MAJOR: *iface = 2; break;
case IDE3_MAJOR: *iface = 3; break;
case IDE4_MAJOR: *iface = 4; break;
case IDE5_MAJOR: *iface = 5; break;
case IDE6_MAJOR: *iface = 6; break;
case IDE7_MAJOR: *iface = 7; break;
default: *port = 1; break;
}
if (*port == 0)
*device = (minor(st.st_rdev) >> 6);
else
{
#ifdef SCSI_IOCTL_GET_IDLUN
UINT32 idlun[2];
if (ioctl(fd, SCSI_IOCTL_GET_IDLUN, &idlun) != -1)
{
*port = ((idlun[0] >> 24) & 0xff) + 1;
*iface = (idlun[0] >> 16) & 0xff;
*device = idlun[0] & 0xff;
*lun = (idlun[0] >> 8) & 0xff;
}
else
#endif
{
FIXME("CD-ROM device (%d, %d) not supported\n",
major(st.st_rdev), minor(st.st_rdev));
return 0;
}
*port = 0;
*iface = 0;
*device = 0;
*lun = 0;
switch (major(st.st_rdev)) {
case IDE0_MAJOR: *iface = 0; break;
case IDE1_MAJOR: *iface = 1; break;
case IDE2_MAJOR: *iface = 2; break;
case IDE3_MAJOR: *iface = 3; break;
case IDE4_MAJOR: *iface = 4; break;
case IDE5_MAJOR: *iface = 5; break;
case IDE6_MAJOR: *iface = 6; break;
case IDE7_MAJOR: *iface = 7; break;
default: *port = 1; break;
}
if (*port == 0)
*device = (minor(st.st_rdev) >> 6);
else
}
return 1;
#elif defined(__NetBSD__)
struct scsi_addr addr;
if (ioctl(fd, SCIOCIDENTIFY, &addr) != -1)
{
switch (addr.type)
{
#ifdef SCSI_IOCTL_GET_IDLUN
UINT32 idlun[2];
if (ioctl(fd, SCSI_IOCTL_GET_IDLUN, &idlun) != -1)
{
*port = ((idlun[0] >> 24) & 0xff) + 1;
*iface = (idlun[0] >> 16) & 0xff;
*device = idlun[0] & 0xff;
*lun = (idlun[0] >> 8) & 0xff;
}
else
#endif
{
FIXME("CD-ROM device (%d, %d) not supported\n",
major(st.st_rdev), minor(st.st_rdev));
return 0;
}
case TYPE_SCSI: *port = 1;
*iface = addr.addr.scsi.scbus;
*device = addr.addr.scsi.target;
*lun = addr.addr.scsi.lun;
break;
case TYPE_ATAPI: *port = 0;
*iface = addr.addr.atapi.atbus;
*device = addr.addr.atapi.drive;
*lun = 0;
break;
}
return 1;
}
#elif defined(__NetBSD__)
{
struct scsi_addr addr;
if (ioctl(fd, SCIOCIDENTIFY, &addr) != -1) {
switch (addr.type) {
case TYPE_SCSI: *port = 1;
*iface = addr.addr.scsi.scbus;
*device = addr.addr.scsi.target;
*lun = addr.addr.scsi.lun;
break;
case TYPE_ATAPI: *port = 0;
*iface = addr.addr.atapi.atbus;
*device = addr.addr.atapi.drive;
*lun = 0;
break;
}
return 1;
}
return 0;
}
return 0;
#elif defined(__FreeBSD__)
FIXME("not implemented for BSD\n");
return 0;
@ -449,7 +456,7 @@ static int CDROM_GetInterfaceInfo(int fd, int* port, int* iface, int* device,int
* NOTE: programs usually read these registry entries after sending the
* IOCTL_SCSI_GET_ADDRESS ioctl to the cdrom
*/
void CDROM_InitRegistry(int fd, int device_id, const char *device )
void CDROM_InitRegistry(int fd)
{
int portnum, busid, targetid, lun;
OBJECT_ATTRIBUTES attr;
@ -465,8 +472,6 @@ void CDROM_InitRegistry(int fd, int device_id, const char *device )
HKEY targetKey;
DWORD disp;
cdrom_cache[device_id].device = device;
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
@ -474,7 +479,7 @@ void CDROM_InitRegistry(int fd, int device_id, const char *device )
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
if ( ! CDROM_GetInterfaceInfo(fd, &portnum, &busid, &targetid, &lun))
if (!CDROM_GetInterfaceInfo(fd, &portnum, &busid, &targetid, &lun))
return;
/* Ensure there is Scsi key */
@ -583,47 +588,35 @@ void CDROM_InitRegistry(int fd, int device_id, const char *device )
* CDROM_Open
*
*/
static NTSTATUS CDROM_Open(HANDLE hDevice, DWORD clientID, int* dev)
static NTSTATUS CDROM_Open(int fd, int* dev)
{
*dev = LOWORD(clientID);
struct stat st;
int empty = -1;
if (*dev >= 26) return STATUS_NO_SUCH_DEVICE;
fstat(fd, &st);
if (!cdrom_cache[*dev].count)
for (*dev = 0; *dev < MAX_CACHE_ENTRIES; (*dev)++)
{
const char *device;
if (!(device = cdrom_cache[*dev].device)) return STATUS_NO_SUCH_DEVICE;
cdrom_cache[*dev].fd = open(device, O_RDONLY|O_NONBLOCK);
if (cdrom_cache[*dev].fd == -1)
{
FIXME("Can't open configured CD-ROM drive %c: (device %s): %s\n",
'A' + *dev, device, strerror(errno));
return STATUS_NO_SUCH_DEVICE;
}
if (empty == -1 &&
cdrom_cache[*dev].device == 0 &&
cdrom_cache[*dev].inode == 0)
empty = *dev;
else if (cdrom_cache[*dev].device == st.st_dev &&
cdrom_cache[*dev].inode == st.st_ino)
break;
}
cdrom_cache[*dev].count++;
TRACE("%d, %d, %d\n", *dev, cdrom_cache[*dev].fd, cdrom_cache[*dev].count);
if (*dev == MAX_CACHE_ENTRIES)
{
if (empty == -1) return STATUS_NOT_IMPLEMENTED;
*dev = empty;
cdrom_cache[*dev].device = st.st_dev;
cdrom_cache[*dev].inode = st.st_ino;
}
cdrom_cache[*dev].fd = fd;
TRACE("%d, %d\n", *dev, cdrom_cache[*dev].fd);
return STATUS_SUCCESS;
}
/******************************************************************
* CDROM_Close
*
*
*/
static void CDROM_Close(DWORD clientID)
{
int dev = LOWORD(clientID);
if (dev >= 26 /*|| fd != cdrom_cache[dev].fd*/) FIXME("how come\n");
if (--cdrom_cache[dev].count == 0)
{
close(cdrom_cache[dev].fd);
cdrom_cache[dev].fd = -1;
}
}
/******************************************************************
* CDROM_GetStatusCode
*
@ -752,13 +745,11 @@ static NTSTATUS CDROM_ReadTOC(int dev, CDROM_TOC* toc)
{
NTSTATUS ret = STATUS_NOT_SUPPORTED;
if (dev < 0 || dev >= 26)
return STATUS_INVALID_PARAMETER;
if ( !cdrom_cache[dev].toc_good ) {
ret = CDROM_SyncCache(dev);
if ( ret )
return ret;
}
if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
return STATUS_INVALID_PARAMETER;
if ( !cdrom_cache[dev].toc_good && (ret = CDROM_SyncCache(dev)))
return ret;
*toc = cdrom_cache[dev].toc;
return STATUS_SUCCESS;
}
@ -1686,7 +1677,7 @@ static NTSTATUS CDROM_GetAddress(int dev, SCSI_ADDRESS* address)
*
*
*/
NTSTATUS CDROM_DeviceIoControl(DWORD clientID, HANDLE hDevice,
NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
PVOID UserApcContext,
PIO_STATUS_BLOCK piosb,
@ -1696,15 +1687,20 @@ NTSTATUS CDROM_DeviceIoControl(DWORD clientID, HANDLE hDevice,
{
DWORD sz = 0;
NTSTATUS status = STATUS_SUCCESS;
int dev;
int fd, dev;
TRACE("%lx[%c] %s %lx %ld %lx %ld %p\n",
(DWORD)hDevice, 'A' + LOWORD(clientID), iocodex(dwIoControlCode), (DWORD)lpInBuffer, nInBufferSize,
TRACE("%lx %s %lx %ld %lx %ld %p\n",
(DWORD)hDevice, iocodex(dwIoControlCode), (DWORD)lpInBuffer, nInBufferSize,
(DWORD)lpOutBuffer, nOutBufferSize, piosb);
piosb->Information = 0;
if ((status = CDROM_Open(hDevice, clientID, &dev))) goto error;
if ((status = wine_server_handle_to_fd( hDevice, GENERIC_READ, &fd, NULL, NULL ))) goto error;
if ((status = CDROM_Open(fd, &dev)))
{
wine_server_release_fd( hDevice, fd );
goto error;
}
switch (dwIoControlCode)
{
@ -1893,7 +1889,7 @@ NTSTATUS CDROM_DeviceIoControl(DWORD clientID, HANDLE hDevice,
status = STATUS_INVALID_PARAMETER;
break;
}
CDROM_Close(clientID);
wine_server_release_fd( hDevice, fd );
error:
piosb->u.Status = status;
piosb->Information = sz;

14
dlls/ntdll/file.c
View File

@ -665,24 +665,12 @@ NTSTATUS WINAPI NtDeviceIoControlFile(HANDLE DeviceHandle, HANDLE hEvent,
PVOID OutputBuffer,
ULONG OutputBufferSize)
{
DWORD clientID = 0;
TRACE("(%p,%p,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx)\n",
DeviceHandle, hEvent, UserApcRoutine, UserApcContext,
IoStatusBlock, IoControlCode,
InputBuffer, InputBufferSize, OutputBuffer, OutputBufferSize);
/* FIXME: clientID hack should disappear */
SERVER_START_REQ( get_device_id )
{
req->handle = DeviceHandle;
if (!wine_server_call( req )) clientID = reply->id;
}
SERVER_END_REQ;
if (!clientID) return STATUS_INVALID_PARAMETER;
if (CDROM_DeviceIoControl(clientID, DeviceHandle, hEvent,
if (CDROM_DeviceIoControl(DeviceHandle, hEvent,
UserApcRoutine, UserApcContext,
IoStatusBlock, IoControlCode,
InputBuffer, InputBufferSize,

2
dlls/ntdll/ntdll.spec
View File

@ -1084,7 +1084,7 @@
################################################################
# Wine dll separation hacks, these will go away, don't use them
#
@ cdecl CDROM_InitRegistry(long long str)
@ cdecl CDROM_InitRegistry(long)
@ cdecl MODULE_DllThreadAttach(ptr)
@ cdecl MODULE_GetLoadOrderW(ptr wstr wstr)
@ cdecl VERSION_Init(wstr)

2
dlls/ntdll/ntdll_misc.h
View File

@ -89,7 +89,7 @@ extern HANDLE (WINAPI *pCreateFileW)( LPCWSTR filename, DWORD access, DWORD shar
/* Device IO */
/* ntdll/cdrom.c.c */
extern NTSTATUS CDROM_DeviceIoControl(DWORD clientID, HANDLE hDevice,
extern NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
PVOID UserApcContext,
PIO_STATUS_BLOCK piosb,

4
files/drive.c
View File

@ -141,7 +141,7 @@ inline static char *heap_strdup( const char *str )
#define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
extern void CDROM_InitRegistry(int dev, int id, const char *device);
extern void CDROM_InitRegistry(int dev);
/***********************************************************************
* DRIVE_GetDriveType
@ -334,7 +334,7 @@ int DRIVE_Init(void)
int cd_fd;
if ((cd_fd = open(drive->device, O_RDONLY|O_NONBLOCK)) != -1)
{
CDROM_InitRegistry(cd_fd, i, drive->device);
CDROM_InitRegistry(cd_fd);
close(cd_fd);
}
}

34
files/file.c
View File

@ -264,28 +264,6 @@ HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
}
/***********************************************************************
* FILE_CreateDevice
*
* Same as FILE_CreateFile but for a device
* Returns 0 on failure.
*/
HANDLE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
{
HANDLE ret;
SERVER_START_REQ( create_device )
{
req->access = access;
req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
req->id = client_id;
SetLastError(0);
wine_server_call_err( req );
ret = reply->handle;
}
SERVER_END_REQ;
return ret;
}
static HANDLE FILE_OpenPipe(LPCWSTR name, DWORD access, LPSECURITY_ATTRIBUTES sa )
{
HANDLE ret;
@ -392,7 +370,17 @@ HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
}
else if (isalphaW(filename[4]) && filename[5] == ':' && filename[6] == '\0')
{
ret = FILE_CreateDevice( (toupperW(filename[4]) - 'A') | 0x20000, access, sa );
const char *device = DRIVE_GetDevice( toupperW(filename[4]) - 'A' );
if (device)
{
ret = FILE_CreateFile( device, access, sharing, sa, creation,
attributes, template, TRUE, DRIVE_FIXED );
}
else
{
SetLastError( ERROR_ACCESS_DENIED );
ret = INVALID_HANDLE_VALUE;
}
goto done;
}
else if (!RtlIsDosDeviceName_U( filename ))

2
include/file.h
View File

@ -63,12 +63,10 @@ extern int FILE_strcasecmp( const char *str1, const char *str2 );
extern int FILE_strncasecmp( const char *str1, const char *str2, int len );
extern void FILE_SetDosError(void);
extern BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info, BOOL *is_symlink );
extern HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 );
extern HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
LPSECURITY_ATTRIBUTES sa, DWORD creation,
DWORD attributes, HANDLE template, BOOL fail_read_only,
UINT drive_type );
extern HANDLE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa );
extern LONG WINAPI WIN16_hread(HFILE16,SEGPTR,LONG);

36
include/wine/server_protocol.h
View File

@ -1504,34 +1504,6 @@ struct get_mapping_info_reply
};
struct create_device_request
{
struct request_header __header;
unsigned int access;
int inherit;
int id;
};
struct create_device_reply
{
struct reply_header __header;
obj_handle_t handle;
};
struct get_device_id_request
{
struct request_header __header;
obj_handle_t handle;
};
struct get_device_id_reply
{
struct reply_header __header;
int id;
};
#define SNAP_HEAPLIST 0x00000001
#define SNAP_PROCESS 0x00000002
#define SNAP_THREAD 0x00000004
@ -3278,8 +3250,6 @@ enum request
REQ_create_mapping,
REQ_open_mapping,
REQ_get_mapping_info,
REQ_create_device,
REQ_get_device_id,
REQ_create_snapshot,
REQ_next_process,
REQ_next_thread,
@ -3468,8 +3438,6 @@ union generic_request
struct create_mapping_request create_mapping_request;
struct open_mapping_request open_mapping_request;
struct get_mapping_info_request get_mapping_info_request;
struct create_device_request create_device_request;
struct get_device_id_request get_device_id_request;
struct create_snapshot_request create_snapshot_request;
struct next_process_request next_process_request;
struct next_thread_request next_thread_request;
@ -3656,8 +3624,6 @@ union generic_reply
struct create_mapping_reply create_mapping_reply;
struct open_mapping_reply open_mapping_reply;
struct get_mapping_info_reply get_mapping_info_reply;
struct create_device_reply create_device_reply;
struct get_device_id_reply get_device_id_reply;
struct create_snapshot_reply create_snapshot_reply;
struct next_process_reply next_process_reply;
struct next_thread_reply next_thread_reply;
@ -3763,6 +3729,6 @@ union generic_reply
struct set_global_windows_reply set_global_windows_reply;
};
#define SERVER_PROTOCOL_VERSION 132
#define SERVER_PROTOCOL_VERSION 133
#endif /* __WINE_WINE_SERVER_PROTOCOL_H */

1
server/Makefile.in
View File

@ -16,7 +16,6 @@ C_SRCS = \
context_powerpc.c \
context_sparc.c \
debugger.c \
device.c \
event.c \
fd.c \
file.c \

102
server/device.c
View File

@ -1,102 +0,0 @@
/*
* Server-side device management
*
* Copyright (C) 1999 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* FIXME:
* all this stuff is a simple hack to avoid breaking
* client-side device support.
*/
#include <assert.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "handle.h"
#include "thread.h"
#include "request.h"
struct device
{
struct object obj; /* object header */
int id; /* client identifier */
};
static void device_dump( struct object *obj, int verbose );
static const struct object_ops device_ops =
{
sizeof(struct device), /* size */
device_dump, /* dump */
no_add_queue, /* add_queue */
NULL, /* remove_queue */
NULL, /* signaled */
NULL, /* satisfied */
no_get_fd, /* get_fd */
no_destroy /* destroy */
};
static struct device *create_device( int id )
{
struct device *dev;
if ((dev = alloc_object( &device_ops )))
{
dev->id = id;
}
return dev;
}
static void device_dump( struct object *obj, int verbose )
{
struct device *dev = (struct device *)obj;
assert( obj->ops == &device_ops );
fprintf( stderr, "Device id=%08x\n", dev->id );
}
/* create a device */
DECL_HANDLER(create_device)
{
struct device *dev;
reply->handle = 0;
if ((dev = create_device( req->id )))
{
reply->handle = alloc_handle( current->process, dev, req->access, req->inherit );
release_object( dev );
}
}
/* Retrieve the client private id for a device */
DECL_HANDLER(get_device_id)
{
struct device *dev;
if ((dev = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
{
reply->id = dev->id;
release_object( dev );
}
}

18
server/protocol.def
View File

@ -1106,24 +1106,6 @@ enum char_info_mode
@END
/* Create a device */
@REQ(create_device)
unsigned int access; /* wanted access rights */
int inherit; /* inherit flag */
int id; /* client private id */
@REPLY
obj_handle_t handle; /* handle to the device */
@END
/* Retrieve the client private id for a device */
@REQ(get_device_id)
obj_handle_t handle; /* handle to the device */
@REPLY
int id; /* client private id */
@END
#define SNAP_HEAPLIST 0x00000001
#define SNAP_PROCESS 0x00000002
#define SNAP_THREAD 0x00000004

4
server/request.h
View File

@ -181,8 +181,6 @@ DECL_HANDLER(next_change_notification);
DECL_HANDLER(create_mapping);
DECL_HANDLER(open_mapping);
DECL_HANDLER(get_mapping_info);
DECL_HANDLER(create_device);
DECL_HANDLER(get_device_id);
DECL_HANDLER(create_snapshot);
DECL_HANDLER(next_process);
DECL_HANDLER(next_thread);
@ -370,8 +368,6 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] =
(req_handler)req_create_mapping,
(req_handler)req_open_mapping,
(req_handler)req_get_mapping_info,
(req_handler)req_create_device,
(req_handler)req_get_device_id,
(req_handler)req_create_snapshot,
(req_handler)req_next_process,
(req_handler)req_next_thread,

28
server/trace.c
View File

@ -1346,28 +1346,6 @@ static void dump_get_mapping_info_reply( const struct get_mapping_info_reply *re
fprintf( stderr, " removable=%d", req->removable );
}
static void dump_create_device_request( const struct create_device_request *req )
{
fprintf( stderr, " access=%08x,", req->access );
fprintf( stderr, " inherit=%d,", req->inherit );
fprintf( stderr, " id=%d", req->id );
}
static void dump_create_device_reply( const struct create_device_reply *req )
{
fprintf( stderr, " handle=%p", req->handle );
}
static void dump_get_device_id_request( const struct get_device_id_request *req )
{
fprintf( stderr, " handle=%p", req->handle );
}
static void dump_get_device_id_reply( const struct get_device_id_reply *req )
{
fprintf( stderr, " id=%d", req->id );
}
static void dump_create_snapshot_request( const struct create_snapshot_request *req )
{
fprintf( stderr, " inherit=%d,", req->inherit );
@ -2681,8 +2659,6 @@ static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_create_mapping_request,
(dump_func)dump_open_mapping_request,
(dump_func)dump_get_mapping_info_request,
(dump_func)dump_create_device_request,
(dump_func)dump_get_device_id_request,
(dump_func)dump_create_snapshot_request,
(dump_func)dump_next_process_request,
(dump_func)dump_next_thread_request,
@ -2867,8 +2843,6 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_create_mapping_reply,
(dump_func)dump_open_mapping_reply,
(dump_func)dump_get_mapping_info_reply,
(dump_func)dump_create_device_reply,
(dump_func)dump_get_device_id_reply,
(dump_func)dump_create_snapshot_reply,
(dump_func)dump_next_process_reply,
(dump_func)dump_next_thread_reply,
@ -3053,8 +3027,6 @@ static const char * const req_names[REQ_NB_REQUESTS] = {
"create_mapping",
"open_mapping",
"get_mapping_info",
"create_device",
"get_device_id",
"create_snapshot",
"next_process",
"next_thread",