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

Made the server listen for new clients on a Unix socket in 

$HOME/.wine. Newly started wine processes now attach to an existing
server if one is running.
This commit is contained in:
Alexandre Julliard 2000-01-25 01:40:27 +00:00 committed by Alexandre Julliard
parent 647876e598
commit 2fe57779fb
20 changed files with 690 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Makefile.in
View File

@ -100,7 +100,6 @@ LIBSUBDIRS = \
relay32 \
resources \
scheduler \
server \
win32 \
windows \
windows/ttydrv
@ -112,7 +111,8 @@ X11SUBDIRS = \
EMUSUBDIRS = \
debugger \
miscemu
miscemu \
server
PROGSUBDIRS = libtest programs
@ -213,7 +213,6 @@ LIBOBJS = \
relay32/relay32.o \
resources/resources.o \
scheduler/scheduler.o \
server/server.o \
win32/win32.o \
windows/windows.o \
windows/ttydrv/ttydrv.o
@ -231,7 +230,7 @@ LIB_TARGET = @LIB_TARGET@
ALT_LINK = @ALT_LINK@
all: Makefile Make.rules $(MAIN_TARGET)
all: Makefile Make.rules server $(MAIN_TARGET)
@echo "Wine build complete."
LIBLINTS = $(LIBOBJS:.o=.ln)

17
include/server.h
View File

@ -121,7 +121,9 @@ struct new_process_request
IN int cmd_show; /* main window show mode */
IN void* env_ptr; /* pointer to environment (FIXME: hack) */
OUT void* pid; /* process id */
OUT int handle; /* process handle (in the current process) */
OUT int phandle; /* process handle (in the current process) */
OUT void* tid; /* thread id */
OUT int thandle; /* thread handle (in the current process) */
IN char cmdline[1]; /* command line */
};
@ -129,7 +131,6 @@ struct new_process_request
/* Create a new thread from the context of the parent */
struct new_thread_request
{
IN void* pid; /* process id for the new thread */
IN int suspend; /* new thread should be suspended on creation */
IN int inherit; /* inherit flag */
OUT void* tid; /* thread id */
@ -137,10 +138,10 @@ struct new_thread_request
};
/* Set the server debug level */
struct set_debug_request
/* Signal that we are finished booting on the client side */
struct boot_done_request
{
IN int level; /* New debug level */
IN int debug_level; /* new debug level */
};
@ -171,6 +172,7 @@ struct init_thread_request
IN void* teb; /* TEB of new thread (in thread address space) */
OUT void* pid; /* process id of the new thread's process */
OUT void* tid; /* thread id of the new thread */
OUT int boot; /* is this the boot thread? */
};
@ -1036,7 +1038,7 @@ enum request
{
REQ_NEW_PROCESS,
REQ_NEW_THREAD,
REQ_SET_DEBUG,
REQ_BOOT_DONE,
REQ_INIT_PROCESS,
REQ_INIT_PROCESS_DONE,
REQ_INIT_THREAD,
@ -1189,7 +1191,8 @@ static inline void server_strcpyAtoW( WCHAR *dst, const char *src )
}
extern int CLIENT_InitServer(void);
extern int CLIENT_SetDebug( int level );
extern int CLIENT_BootDone( int debug_level );
extern int CLIENT_IsBootThread(void);
extern int CLIENT_DebuggerRequest( int op );
extern int CLIENT_InitThread(void);
#endif /* __WINE_SERVER__ */

2
include/thread.h
View File

@ -121,7 +121,7 @@ typedef struct _TEB
/* scheduler/thread.c */
extern TEB *THREAD_CreateInitialThread( struct _PDB *pdb, int server_fd );
extern TEB *THREAD_Create( struct _PDB *pdb, DWORD flags,
extern TEB *THREAD_Create( struct _PDB *pdb, int fd, DWORD flags,
DWORD stack_size, BOOL alloc_stack16,
LPSECURITY_ATTRIBUTES sa, int *server_handle );
extern BOOL THREAD_IsWin16( TEB *thdb );

24
loader/main.c
View File

@ -67,24 +67,27 @@ BOOL MAIN_MainInit( int *argc, char *argv[] )
/* Parse command line arguments */
MAIN_WineInit( argc, argv );
/* Set server debug level */
CLIENT_SetDebug( TRACE_ON(server) );
/* Load the configuration file */
if (!PROFILE_LoadWineIni()) return FALSE;
/* Initialize module loadorder */
if (!MODULE_InitLoadOrder()) return FALSE;
/* Initialize DOS memory */
if (!DOSMEM_Init(0)) return FALSE;
/* Initialise DOS drives */
if (!DRIVE_Init()) return FALSE;
/* Initialise DOS directories */
if (!DIR_Init()) return FALSE;
/* Registry initialisation */
SHELL_LoadRegistry();
/* Global boot finished, the rest is process-local */
CLIENT_BootDone( TRACE_ON(server) );
/* Initialize module loadorder */
if (!MODULE_InitLoadOrder()) return FALSE;
/* Initialize DOS memory */
if (!DOSMEM_Init(0)) return FALSE;
/* Initialize event handling */
if (!EVENT_Init()) return FALSE;
@ -94,9 +97,6 @@ BOOL MAIN_MainInit( int *argc, char *argv[] )
/* Initialize IO-port permissions */
IO_port_init();
/* registry initialisation */
SHELL_LoadRegistry();
/* Read DOS config.sys */
if (!DOSCONF_ReadConfig()) return FALSE;

2
misc/registry.c
View File

@ -1486,6 +1486,8 @@ void SHELL_LoadRegistry( void )
TRACE("(void)\n");
if (!CLIENT_IsBootThread()) return; /* already loaded */
REGISTRY_Init();
SetLoadLevel(0);

203
scheduler/client.c
View File

@ -7,6 +7,7 @@
#include "config.h"
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
@ -15,9 +16,11 @@
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#include <sys/un.h>
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include <sys/stat.h>
#include <sys/uio.h>
#include <unistd.h>
#include <stdarg.h>
@ -26,12 +29,17 @@
#include "thread.h"
#include "server.h"
#include "winerror.h"
#include "options.h"
#include "xmalloc.h"
/* Some versions of glibc don't define this */
#ifndef SCM_RIGHTS
#define SCM_RIGHTS 1
#endif
#define SERVERDIR "/wineserver-" /* server socket directory (hostname appended) */
#define SOCKETNAME "socket" /* name of the socket file */
/* data structure used to pass an fd with sendmsg/recvmsg */
struct cmsg_fd
{
@ -41,6 +49,34 @@ struct cmsg_fd
int fd; /* fd to pass */
};
static void *boot_thread_id;
/* die on a fatal error; use only during initialization */
static void fatal_error( const char *err, ... )
{
va_list args;
va_start( args, err );
fprintf( stderr, "wine: " );
vfprintf( stderr, err, args );
va_end( args );
exit(1);
}
/* die on a fatal error; use only during initialization */
static void fatal_perror( const char *err, ... )
{
va_list args;
va_start( args, err );
fprintf( stderr, "wine: " );
vfprintf( stderr, err, args );
perror( " " );
va_end( args );
exit(1);
}
/***********************************************************************
* CLIENT_Die
*
@ -257,6 +293,76 @@ unsigned int server_call_fd( enum request req, int fd_out, int *fd_in )
}
/***********************************************************************
* start_server
*
* Start a new wine server.
*/
static void start_server( const char *oldcwd )
{
static int started; /* we only try once */
if (!started)
{
int pid = fork();
if (pid == -1) fatal_perror( "fork" );
if (!pid)
{
execl( BINDIR "/wineserver", "wineserver", NULL );
if (oldcwd) chdir( oldcwd );
execlp( "wineserver", "wineserver", NULL );
execl( "./server/wineserver", "wineserver", NULL );
fatal_error( "could not exec wineserver\n" );
}
started = 1;
}
}
/***********************************************************************
* server_connect
*
* Attempt to connect to an existing server socket.
* We need to be in the server directory already.
*/
static int server_connect( const char *oldcwd, const char *serverdir )
{
struct sockaddr_un addr;
struct stat st;
int s;
if (chdir( serverdir ) == -1)
{
if (errno != ENOENT) fatal_perror( "chdir to %s", serverdir );
start_server( NULL );
return -1;
}
if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
if (st.st_uid != getuid()) fatal_error( "'%s' is not owned by you\n", serverdir );
if (st.st_mode & 077) fatal_error( "'%s' must not be accessible by other users\n", serverdir );
if (lstat( SOCKETNAME, &st ) == -1)
{
if (errno != ENOENT) fatal_perror( "lstat %s/%s", serverdir, SOCKETNAME );
start_server( oldcwd );
return -1;
}
if (!S_ISSOCK(st.st_mode))
fatal_error( "'%s/%s' is not a socket\n", serverdir, SOCKETNAME );
if (st.st_uid != getuid())
fatal_error( "'%s/%s' is not owned by you\n", serverdir, SOCKETNAME );
if ((s = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
addr.sun_family = AF_UNIX;
strcpy( addr.sun_path, SOCKETNAME );
if (connect( s, &addr, sizeof(addr.sun_family) + strlen(addr.sun_path) ) == -1)
{
close( s );
return -2;
}
fcntl( s, F_SETFD, 1 ); /* set close on exec flag */
return s;
}
/***********************************************************************
* CLIENT_InitServer
*
@ -264,34 +370,62 @@ unsigned int server_call_fd( enum request req, int fd_out, int *fd_in )
*/
int CLIENT_InitServer(void)
{
int fd[2];
char buffer[16];
extern void create_initial_thread( int fd );
int delay, fd, size;
const char *env_fd;
char hostname[64];
char *oldcwd, *serverdir;
const char *configdir;
if (socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) == -1)
/* first check if we inherited the socket fd */
if ((env_fd = getenv( "__WINE_FD" )) && isdigit(env_fd[0]))
{
perror("socketpair");
exit(1);
fd = atoi( env_fd );
if (fcntl( fd, F_GETFL, 0 ) != -1) return fd;
}
switch(fork())
/* retrieve the current directory */
for (size = 512; ; size *= 2)
{
case -1: /* error */
perror("fork");
exit(1);
case 0: /* child */
close( fd[1] );
fcntl( fd[0], F_SETFD, 1 ); /* set close on exec flag */
oldcwd = xmalloc( size );
if (getcwd( oldcwd, size )) break;
free( oldcwd );
if (errno == ERANGE) continue;
oldcwd = NULL;
break;
default: /* parent */
close( fd[0] );
sprintf( buffer, "%d", fd[1] );
execl( BINDIR "/wineserver", "wineserver", buffer, NULL );
execlp( "wineserver", "wineserver", buffer, NULL );
execl( "./server/wineserver", "wineserver", buffer, NULL );
create_initial_thread( fd[1] );
exit(0);
}
return fd[0];
/* get the server directory name */
if (gethostname( hostname, sizeof(hostname) ) == -1) fatal_perror( "gethostname" );
configdir = PROFILE_GetConfigDir();
serverdir = xmalloc( strlen(configdir) + strlen(SERVERDIR) + strlen(hostname) + 1 );
strcpy( serverdir, configdir );
strcat( serverdir, SERVERDIR );
strcat( serverdir, hostname );
/* try to connect, leaving some time for the server to start up */
for (delay = 10000; delay < 500000; delay += delay / 2)
{
if ((fd = server_connect( oldcwd, serverdir )) >= 0) goto done;
usleep( delay );
}
if (fd == -2)
{
fatal_error( "'%s/%s' exists,\n"
" but I cannot connect to it; maybe the server has crashed?\n"
" If this is the case, you should remove the socket file and try again.\n",
serverdir, SOCKETNAME );
}
fatal_error( "could not start wineserver, giving up\n" );
done:
/* switch back to the starting directory */
if (oldcwd)
{
chdir( oldcwd );
free( oldcwd );
}
return fd;
}
@ -319,20 +453,32 @@ int CLIENT_InitThread(void)
if (server_call( REQ_INIT_THREAD )) return -1;
teb->process->server_pid = req->pid;
teb->tid = req->tid;
if (req->boot) boot_thread_id = req->tid;
else if (boot_thread_id == req->tid) boot_thread_id = 0;
return 0;
}
/***********************************************************************
* CLIENT_BootDone
*
* Signal that we have finished booting, and set debug level.
*/
int CLIENT_BootDone( int debug_level )
{
struct boot_done_request *req = get_req_buffer();
req->debug_level = debug_level;
return server_call( REQ_BOOT_DONE );
}
/***********************************************************************
* CLIENT_SetDebug
* CLIENT_IsBootThread
*
* Send a set debug level request. Return 0 if OK.
* Return TRUE if current thread is the boot thread.
*/
int CLIENT_SetDebug( int level )
int CLIENT_IsBootThread(void)
{
struct set_debug_request *req = get_req_buffer();
req->level = level;
return server_call( REQ_SET_DEBUG );
return (GetCurrentThreadId() == (DWORD)boot_thread_id);
}
/***********************************************************************
@ -346,4 +492,3 @@ int CLIENT_DebuggerRequest( int op )
req->op = op;
return server_call( REQ_DEBUGGER );
}

72
scheduler/process.c
View File

@ -5,6 +5,7 @@
*/
#include <assert.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -241,13 +242,13 @@ static BOOL PROCESS_CreateEnvDB(void)
/* Allocate the env DB */
if (!(env_db = HeapAlloc( pdb->heap, HEAP_ZERO_MEMORY, sizeof(ENVDB) )))
if (!(env_db = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ENVDB) )))
return FALSE;
pdb->env_db = env_db;
InitializeCriticalSection( &env_db->section );
/* Allocate and fill the startup info */
if (!(startup = HeapAlloc( pdb->heap, HEAP_ZERO_MEMORY, sizeof(STARTUPINFOA) )))
if (!(startup = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTUPINFOA) )))
return FALSE;
env_db->startup_info = startup;
@ -263,11 +264,11 @@ static BOOL PROCESS_CreateEnvDB(void)
/* Copy the parent environment */
if (!ENV_InheritEnvironment( pdb, req->env_ptr )) return FALSE;
if (!ENV_InheritEnvironment( req->env_ptr )) return FALSE;
/* Copy the command line */
if (!(pdb->env_db->cmd_line = HEAP_strdupA( pdb->heap, 0, cmd_line )))
if (!(pdb->env_db->cmd_line = HEAP_strdupA( GetProcessHeap(), 0, cmd_line )))
return FALSE;
return TRUE;
@ -286,7 +287,6 @@ void PROCESS_FreePDB( PDB *pdb )
ENV_FreeEnvironment( pdb );
while (*pptr && (*pptr != pdb)) pptr = &(*pptr)->next;
if (*pptr) *pptr = pdb->next;
if (pdb->heap && (pdb->heap != pdb->system_heap)) HeapDestroy( pdb->heap );
HeapFree( SystemHeap, 0, pdb );
}
@ -306,11 +306,9 @@ static PDB *PROCESS_CreatePDB( PDB *parent, BOOL inherit )
pdb->threads = 1;
pdb->running_threads = 1;
pdb->ring0_threads = 1;
pdb->system_heap = SystemHeap;
pdb->parent = parent;
pdb->group = pdb;
pdb->priority = 8; /* Normal */
pdb->heap = pdb->system_heap; /* will be changed later on */
pdb->next = PROCESS_First;
pdb->winver = 0xffff; /* to be determined */
pdb->main_queue = INVALID_HANDLE_VALUE16;
@ -350,9 +348,9 @@ BOOL PROCESS_Init(void)
/* Remember TEB selector of initial process for emergency use */
SYSLEVEL_EmergencyTeb = teb->teb_sel;
/* Create the system heap */
if (!(SystemHeap = HeapCreate( HEAP_GROWABLE, 0x10000, 0 ))) return FALSE;
initial_pdb.system_heap = initial_pdb.heap = SystemHeap;
/* Create the system and process heaps */
if (!HEAP_CreateSystemHeap()) return FALSE;
initial_pdb.heap = HeapCreate( HEAP_GROWABLE, 0, 0 );
/* Create the idle event for the initial process
FIXME 1: Shouldn't we call UserSignalProc for the initial process too?
@ -406,11 +404,13 @@ void PROCESS_Start(void)
InitializeCriticalSection( &pdb->crit_section );
/* Create the heap */
if (!(pdb->heap = GetProcessHeap()))
{
if (!(pdb->heap = HeapCreate( HEAP_GROWABLE,
header? header->SizeOfHeapReserve : 0x10000,
header? header->SizeOfHeapCommit : 0 )))
goto error;
pdb->heap_list = pdb->heap;
}
/* Create the environment db */
if (!PROCESS_CreateEnvDB()) goto error;
@ -492,7 +492,8 @@ void PROCESS_Start(void)
}
/* If requested, add entry point breakpoint */
if ( Options.debug && TASK_AddTaskEntryBreakpoint )
if ( (Options.debug && TASK_AddTaskEntryBreakpoint) ||
(pdb->flags & PDB32_DEBUGGED))
TASK_AddTaskEntryBreakpoint( pdb->task );
/* Call UserSignalProc ( USIG_PROCESS_RUNNING ... ) only for non-GUI win32 apps */
@ -515,6 +516,7 @@ void PROCESS_Start(void)
case PROC_WIN32:
TRACE_(relay)( "Starting Win32 process (entryproc=%p)\n", entry );
if (pdb->flags & PDB32_DEBUGGED) DebugBreak();
ExitProcess( entry(NULL) );
}
@ -536,7 +538,7 @@ PDB *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
HANDLE handles[2], load_done_evt = 0;
DWORD exitcode, size;
BOOL alloc_stack16;
int server_thandle;
int server_thandle, fd = -1;
struct new_process_request *req = get_req_buffer();
TEB *teb = NULL;
PDB *parent = PROCESS_Current();
@ -568,12 +570,15 @@ PDB *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
req->cmd_show = startup->wShowWindow;
req->env_ptr = (void*)env; /* FIXME: hack */
lstrcpynA( req->cmdline, cmd_line, server_remaining(req->cmdline) );
if (server_call( REQ_NEW_PROCESS )) goto error;
if (server_call_fd( REQ_NEW_PROCESS, -1, &fd )) goto error;
fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
pdb->server_pid = req->pid;
info->hProcess = req->handle;
info->dwProcessId = (DWORD)pdb->server_pid;
info->hProcess = req->phandle;
info->dwProcessId = (DWORD)req->pid;
info->hThread = req->thandle;
info->dwThreadId = (DWORD)req->tid;
if ((flags & DEBUG_PROCESS) ||
if ((flags & (DEBUG_PROCESS|DEBUG_ONLY_THIS_PROCESS)) ||
((parent->flags & PDB32_DEBUGGED) && !(flags & DEBUG_ONLY_THIS_PROCESS)))
pdb->flags |= PDB32_DEBUGGED;
@ -600,11 +605,11 @@ PDB *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
/* Create the main thread */
if (!(teb = THREAD_Create( pdb, flags & CREATE_SUSPENDED, size,
if (!(teb = THREAD_Create( pdb, fd, flags & CREATE_SUSPENDED, size,
alloc_stack16, tsa, &server_thandle ))) goto error;
info->hThread = server_thandle;
info->dwThreadId = (DWORD)teb->tid;
teb->tid = (void *)info->dwThreadId;
teb->startup = PROCESS_Start;
fd = -1; /* don't close it */
/* Pass module to new process (FIXME: hack) */
pdb->module = pModule->self;
@ -650,6 +655,7 @@ error:
if (info->hThread != INVALID_HANDLE_VALUE) CloseHandle( info->hThread );
if (info->hProcess != INVALID_HANDLE_VALUE) CloseHandle( info->hProcess );
PROCESS_FreePDB( pdb );
if (fd != -1) close( fd );
return NULL;
}
@ -852,16 +858,6 @@ DWORD WINAPI GetCurrentProcessId(void)
}
/***********************************************************************
* GetProcessHeap (KERNEL32.259)
*/
HANDLE WINAPI GetProcessHeap(void)
{
PDB *pdb = PROCESS_Current();
return pdb->heap ? pdb->heap : SystemHeap;
}
/***********************************************************************
* GetThreadLocale (KERNEL32.295)
*/
@ -1236,22 +1232,6 @@ BOOL WINAPI GetExitCodeProcess(
}
/***********************************************************************
* GetProcessHeaps [KERNEL32.376]
*/
DWORD WINAPI GetProcessHeaps(DWORD nrofheaps,HANDLE *heaps) {
FIXME_(win32)("(%ld,%p), incomplete implementation.\n",nrofheaps,heaps);
if (nrofheaps) {
heaps[0] = GetProcessHeap();
/* ... probably SystemHeap too ? */
return 1;
}
/* number of available heaps */
return 1;
}
/***********************************************************************
* SetErrorMode (KERNEL32.486)
*/

10
scheduler/thread.c
View File

@ -212,7 +212,7 @@ TEB *THREAD_CreateInitialThread( PDB *pdb, int server_fd )
* allocate in this area and don't support a granularity of 4kb
* yet we leave it to VirtualAlloc to choose an address.
*/
TEB *THREAD_Create( PDB *pdb, DWORD flags, DWORD stack_size, BOOL alloc_stack16,
TEB *THREAD_Create( PDB *pdb, int fd, DWORD flags, DWORD stack_size, BOOL alloc_stack16,
LPSECURITY_ATTRIBUTES sa, int *server_handle )
{
struct new_thread_request *req = get_req_buffer();
@ -227,7 +227,7 @@ TEB *THREAD_Create( PDB *pdb, DWORD flags, DWORD stack_size, BOOL alloc_stack16,
teb->tls_ptr = teb->tls_array;
teb->process = pdb;
teb->exit_code = 0x103; /* STILL_ACTIVE */
teb->socket = -1;
teb->socket = fd;
/* Allocate the TEB selector (%fs register) */
@ -237,13 +237,15 @@ TEB *THREAD_Create( PDB *pdb, DWORD flags, DWORD stack_size, BOOL alloc_stack16,
/* Create the thread on the server side */
req->pid = teb->process->server_pid;
if (teb->socket == -1)
{
req->suspend = ((flags & CREATE_SUSPENDED) != 0);
req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
if (server_call_fd( REQ_NEW_THREAD, -1, &teb->socket )) goto error;
teb->tid = req->tid;
*server_handle = req->handle;
fcntl( teb->socket, F_SETFD, 1 ); /* set close on exec flag */
}
/* Do the rest of the initialization */
@ -295,7 +297,7 @@ HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
DWORD flags, LPDWORD id )
{
int handle = -1;
TEB *teb = THREAD_Create( PROCESS_Current(), flags, stack, TRUE, sa, &handle );
TEB *teb = THREAD_Create( PROCESS_Current(), -1, flags, stack, TRUE, sa, &handle );
if (!teb) return 0;
teb->flags |= TEBF_WIN32;
teb->entry_point = start;

14
server/Makefile.in
View File

@ -1,9 +1,9 @@
DEFS = @DLLFLAGS@ -D__WINE__ -D__WINE_SERVER__
DEFS = -D__WINE__ -D__WINE_SERVER__
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = server
MODULE = none
C_SRCS = \
change.c \
@ -14,6 +14,7 @@ C_SRCS = \
event.c \
file.c \
handle.c \
main.c \
mapping.c \
mutex.c \
object.c \
@ -31,16 +32,13 @@ C_SRCS = \
trace.c \
unicode.c
EXTRA_SRCS = main.c
MAIN_OBJS = main.o
PROGRAMS = wineserver
all: $(MODULE).o $(PROGRAMS)
all: $(PROGRAMS)
@MAKE_RULES@
wineserver: $(OBJS) $(MAIN_OBJS)
$(CC) -o $(PROGRAMS) $(OBJS) $(MAIN_OBJS) $(LIBS)
wineserver: $(OBJS)
$(CC) -o $(PROGRAMS) $(OBJS) $(LIBS)
### Dependencies:

91
server/main.c
View File

@ -4,39 +4,98 @@
* Copyright (C) 1998 Alexandre Julliard
*/
#include <assert.h>
#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include "object.h"
#include "thread.h"
#include "request.h"
/* command-line options */
int debug_level = 0;
int persistent_server = 0;
/* parse-line args */
/* FIXME: should probably use getopt, and add a help option */
static void parse_args( int argc, char *argv[] )
{
int i;
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
{
switch(argv[i][1])
{
case 'd':
if (isdigit(argv[i][2])) debug_level = atoi( argv[i] + 2 );
else debug_level++;
break;
case 'p':
persistent_server = 1;
break;
default:
fprintf( stderr, "Unknown option '%s'\n", argv[i] );
exit(1);
}
}
else
{
fprintf( stderr, "Unknown argument '%s'\n", argv[i] );
exit(1);
}
}
}
static void sigterm_handler()
{
exit(1); /* make sure atexit functions get called */
}
/* initialize signal handling */
static void signal_init(void)
{
#if 0
if (!debug_level)
{
switch(fork())
{
case -1:
break;
case 0:
setsid();
break;
default:
exit(0);
}
}
#endif
signal( SIGPIPE, SIG_IGN );
signal( SIGHUP, sigterm_handler );
signal( SIGINT, sigterm_handler );
signal( SIGQUIT, sigterm_handler );
signal( SIGTERM, sigterm_handler );
signal( SIGABRT, sigterm_handler );
}
int main( int argc, char *argv[] )
{
int fd;
if (argc != 2) goto error;
if (!isdigit( *argv[1] )) goto error;
fd = atoi( argv[1] );
/* make sure the fd is valid */
if (fcntl( fd, F_GETFL, 0 ) == -1) goto error;
/* debug_level = 1; */
parse_args( argc, argv );
signal_init();
open_master_socket();
if (debug_level) fprintf( stderr, "Server: starting (pid=%ld)\n", (long) getpid() );
create_initial_thread( fd );
select_loop();
if (debug_level) fprintf( stderr, "Server: exiting (pid=%ld)\n", (long) getpid() );
close_registry();
#ifdef DEBUG_OBJECTS
close_registry();
dump_objects(); /* dump any remaining objects */
#endif
exit(0);
error:
fprintf( stderr, "%s: must be run from Wine.\n", argv[0] );
exit(1);
}

1
server/object.c
View File

@ -15,7 +15,6 @@
#include "thread.h"
#include "unicode.h"
int debug_level = 0;
struct object_name
{

3
server/object.h
View File

@ -165,6 +165,9 @@ extern int get_page_size(void);
extern void close_registry(void);
/* global variables (command-line options) */
extern int debug_level;
extern int persistent_server;
#endif /* __WINE_SERVER_OBJECT_H */

193
server/process.c
View File

@ -12,6 +12,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <unistd.h>
#include "winbase.h"
@ -50,14 +51,89 @@ static const struct object_ops process_ops =
process_destroy /* destroy */
};
/* set the process creation info */
static int set_creation_info( struct process *process, struct new_process_request *req,
const char *cmd_line, size_t len )
{
if (!(process->info = mem_alloc( sizeof(*process->info) + len ))) return 0;
if (req)
{
/* copy the request structure */
memcpy( process->info, req, sizeof(*req) );
}
else /* no request, use defaults */
{
req = process->info;
req->inherit = 0;
req->inherit_all = 0;
req->create_flags = CREATE_NEW_CONSOLE;
req->start_flags = STARTF_USESTDHANDLES;
req->hstdin = -1;
req->hstdout = -1;
req->hstderr = -1;
req->event = -1;
req->cmd_show = 0;
req->env_ptr = NULL;
}
memcpy( process->info->cmdline, cmd_line, len );
process->info->cmdline[len] = 0;
process->create_flags = process->info->create_flags;
return 1;
}
/* create a new process */
static struct process *create_process( struct process *parent, struct new_process_request *req,
/* set the console and stdio handles for a newly created process */
static int set_process_console( struct process *process, struct process *parent )
{
struct new_process_request *info = process->info;
if (process->create_flags & CREATE_NEW_CONSOLE)
{
if (!alloc_console( process )) return 0;
}
else if (!(process->create_flags & DETACHED_PROCESS))
{
if (parent->console_in) process->console_in = grab_object( parent->console_in );
if (parent->console_out) process->console_out = grab_object( parent->console_out );
}
if (parent)
{
if (!info->inherit_all && !(info->start_flags & STARTF_USESTDHANDLES))
{
/* duplicate the handle from the parent into this process */
info->hstdin = duplicate_handle( parent, info->hstdin, process,
0, TRUE, DUPLICATE_SAME_ACCESS );
info->hstdout = duplicate_handle( parent, info->hstdout, process,
0, TRUE, DUPLICATE_SAME_ACCESS );
info->hstderr = duplicate_handle( parent, info->hstderr, process,
0, TRUE, DUPLICATE_SAME_ACCESS );
}
}
else
{
/* no parent, use handles to the console for stdio */
info->hstdin = alloc_handle( process, process->console_in,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
info->hstdout = alloc_handle( process, process->console_out,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
info->hstderr = alloc_handle( process, process->console_out,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
}
return 1;
}
/* create a new process and its main thread */
struct thread *create_process( int fd, struct process *parent,
struct new_process_request *req,
const char *cmd_line, size_t len )
{
struct process *process;
struct thread *thread = NULL;
if (!(process = alloc_object( &process_ops, -1 ))) return NULL;
if (!(process = alloc_object( &process_ops, -1 )))
{
close( fd );
return NULL;
}
process->next = NULL;
process->prev = NULL;
process->thread_list = NULL;
@ -74,16 +150,13 @@ static struct process *create_process( struct process *parent, struct new_proces
process->init_event = NULL;
process->info = NULL;
gettimeofday( &process->start_time, NULL );
if ((process->next = first_process) != NULL) process->next->prev = process;
first_process = process;
/* copy the request structure */
if (!(process->info = mem_alloc( sizeof(*process->info) + len ))) goto error;
memcpy( process->info, req, sizeof(*req) );
memcpy( process->info->cmdline, cmd_line, len );
process->info->cmdline[len] = 0;
req = process->info; /* use the copy now */
process->create_flags = req->create_flags;
if (!set_creation_info( process, req, cmd_line, len )) goto error;
if (req->inherit_all)
if (process->info->inherit_all)
process->handles = copy_handle_table( process, parent );
else
process->handles = alloc_handle_table( process, 0 );
@ -93,32 +166,18 @@ static struct process *create_process( struct process *parent, struct new_proces
alloc_handle( process, process, PROCESS_ALL_ACCESS, 0 );
/* get the init done event */
if (req->event != -1)
if (process->info->event != -1)
{
if (!(process->init_event = get_event_obj( parent, req->event, EVENT_MODIFY_STATE )))
goto error;
if (!(process->init_event = get_event_obj( parent, process->info->event,
EVENT_MODIFY_STATE ))) goto error;
}
/* set the process console */
if (process->create_flags & CREATE_NEW_CONSOLE)
{
if (!alloc_console( process )) goto error;
}
else if (!(process->create_flags & DETACHED_PROCESS))
{
if (parent->console_in) process->console_in = grab_object( parent->console_in );
if (parent->console_out) process->console_out = grab_object( parent->console_out );
}
if (!set_process_console( process, parent )) goto error;
if (!req->inherit_all && !(req->start_flags & STARTF_USESTDHANDLES))
{
process->info->hstdin = duplicate_handle( parent, req->hstdin, process,
0, TRUE, DUPLICATE_SAME_ACCESS );
process->info->hstdout = duplicate_handle( parent, req->hstdout, process,
0, TRUE, DUPLICATE_SAME_ACCESS );
process->info->hstderr = duplicate_handle( parent, req->hstderr, process,
0, TRUE, DUPLICATE_SAME_ACCESS );
}
/* create the main thread */
if (!(thread = create_thread( fd, process, (process->create_flags & CREATE_SUSPENDED) != 0)))
goto error;
/* attach to the debugger if requested */
if (process->create_flags & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS))
@ -126,45 +185,17 @@ static struct process *create_process( struct process *parent, struct new_proces
else if (parent && parent->debugger && !(parent->create_flags & DEBUG_ONLY_THIS_PROCESS))
debugger_attach( process, parent->debugger );
if ((process->next = first_process) != NULL) process->next->prev = process;
first_process = process;
return process;
release_object( process );
return thread;
error:
close( fd );
free_console( process );
if (process->handles) release_object( process->handles );
release_object( process );
return NULL;
}
/* create the initial process */
struct process *create_initial_process(void)
{
struct process *process;
struct new_process_request req;
req.inherit = 0;
req.inherit_all = 0;
req.create_flags = CREATE_NEW_CONSOLE;
req.start_flags = STARTF_USESTDHANDLES;
req.hstdin = -1;
req.hstdout = -1;
req.hstderr = -1;
req.event = -1;
req.cmd_show = 0;
req.env_ptr = NULL;
if ((process = create_process( NULL, &req, "", 1 )))
{
process->info->hstdin = alloc_handle( process, process->console_in,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
process->info->hstdout = alloc_handle( process, process->console_out,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
process->info->hstderr = alloc_handle( process, process->console_out,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
}
return process;
}
/* destroy a process when its refcount is 0 */
static void process_destroy( struct object *obj )
{
@ -229,6 +260,8 @@ static void process_killed( struct process *process, int exit_code )
{
/* last process died, close global handles */
close_global_handles();
/* this will cause the select loop to terminate */
if (!persistent_server) close_master_socket();
}
}
@ -455,16 +488,40 @@ struct process_snapshot *process_snap( int *count )
DECL_HANDLER(new_process)
{
size_t len = get_req_strlen( req->cmdline );
struct process *process;
struct thread *thread;
int sock[2];
req->handle = -1;
req->phandle = -1;
req->thandle = -1;
req->pid = NULL;
if ((process = create_process( current->process, req, req->cmdline, len )))
req->tid = NULL;
if (socketpair( AF_UNIX, SOCK_STREAM, 0, sock ) == -1)
{
req->handle = alloc_handle( current->process, process, PROCESS_ALL_ACCESS, req->inherit );
req->pid = process;
release_object( process );
file_set_error();
return;
}
if ((thread = create_process( sock[0], current->process, req, req->cmdline, len )))
{
int phandle = alloc_handle( current->process, thread->process,
PROCESS_ALL_ACCESS, req->inherit );
if ((req->phandle = phandle) != -1)
{
if ((req->thandle = alloc_handle( current->process, thread,
THREAD_ALL_ACCESS, req->inherit )) != -1)
{
/* thread object will be released when the thread gets killed */
set_reply_fd( current, sock[1] );
req->pid = thread->process;
req->tid = thread;
return;
}
close_handle( current->process, phandle );
}
release_object( thread );
}
close( sock[1] );
}
/* initialize a new process */

4
server/process.h
View File

@ -47,7 +47,9 @@ struct process_snapshot
/* process functions */
extern struct process *create_initial_process(void);
extern struct thread *create_process( int fd, struct process *parent,
struct new_process_request *req,
const char *cmd_line, size_t len );
extern struct process *get_process_from_id( void *id );
extern struct process *get_process_from_handle( int handle, unsigned int access );
extern int process_set_debugger( struct process *process, struct thread *thread );

195
server/request.c
View File

@ -9,22 +9,27 @@
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#include <sys/uio.h>
#include <sys/un.h>
#include <unistd.h>
#include "winnt.h"
#include "winbase.h"
#include "wincon.h"
#include "thread.h"
#include "process.h"
#include "server.h"
#define WANT_REQUEST_HANDLERS
#include "request.h"
@ -34,9 +39,41 @@
#define SCM_RIGHTS 1
#endif
/* path names for server master Unix socket */
#define CONFDIR "/.wine" /* directory for Wine config relative to $HOME */
#define SERVERDIR "/wineserver-" /* server socket directory (hostname appended) */
#define SOCKETNAME "socket" /* name of the socket file */
struct master_socket
{
struct object obj; /* object header */
};
static void master_socket_dump( struct object *obj, int verbose );
static void master_socket_poll_event( struct object *obj, int event );
static void master_socket_destroy( struct object *obj );
static const struct object_ops master_socket_ops =
{
sizeof(struct master_socket), /* size */
master_socket_dump, /* dump */
no_add_queue, /* add_queue */
NULL, /* remove_queue */
NULL, /* signaled */
NULL, /* satisfied */
NULL, /* get_poll_events */
master_socket_poll_event, /* poll_event */
no_read_fd, /* get_read_fd */
no_write_fd, /* get_write_fd */
no_flush, /* flush */
no_get_file_info, /* get_file_info */
master_socket_destroy /* destroy */
};
struct thread *current = NULL; /* thread handling the current request */
static struct master_socket *master_socket; /* the master socket object */
/* socket communication static structures */
static struct iovec myiovec;
@ -64,6 +101,31 @@ void fatal_protocol_error( struct thread *thread, const char *err, ... )
kill_thread( thread, PROTOCOL_ERROR );
}
/* die on a fatal error */
static void fatal_error( const char *err, ... )
{
va_list args;
va_start( args, err );
fprintf( stderr, "wineserver: " );
vfprintf( stderr, err, args );
va_end( args );
exit(1);
}
/* die on a fatal error */
static void fatal_perror( const char *err, ... )
{
va_list args;
va_start( args, err );
fprintf( stderr, "wineserver: " );
vfprintf( stderr, err, args );
perror( " " );
va_end( args );
exit(1);
}
/* call a request handler */
static void call_req_handler( struct thread *thread, enum request req, int fd )
{
@ -187,12 +249,135 @@ int write_request( struct thread *thread )
return 1;
}
/* set the debug level */
DECL_HANDLER(set_debug)
static void master_socket_dump( struct object *obj, int verbose )
{
debug_level = req->level;
/* Make sure last_req is initialized */
current->last_req = REQ_SET_DEBUG;
struct master_socket *sock = (struct master_socket *)obj;
assert( obj->ops == &master_socket_ops );
fprintf( stderr, "Master socket fd=%d\n", sock->obj.fd );
}
/* handle a socket event */
static void master_socket_poll_event( struct object *obj, int event )
{
struct master_socket *sock = (struct master_socket *)obj;
assert( obj->ops == &master_socket_ops );
assert( sock == master_socket ); /* there is only one master socket */
if (event & (POLLERR | POLLHUP))
{
/* this is not supposed to happen */
fprintf( stderr, "wineserver: Error on master socket\n" );
release_object( obj );
}
else if (event & POLLIN)
{
struct sockaddr_un dummy;
int len = sizeof(dummy);
int client = accept( master_socket->obj.fd, &dummy, &len );
if (client != -1) create_process( client, NULL, NULL, "", 1 );
}
}
/* remove the socket upon exit */
static void socket_cleanup(void)
{
unlink( SOCKETNAME );
}
static void master_socket_destroy( struct object *obj )
{
socket_cleanup();
}
/* return the configuration directory ($HOME/.wine) */
static const char *get_config_dir(void)
{
static char *confdir;
if (!confdir)
{
const char *home = getenv( "HOME" );
if (!home)
{
struct passwd *pwd = getpwuid( getuid() );
if (!pwd) fatal_error( "could not find your home directory\n" );
home = pwd->pw_dir;
}
if (!(confdir = malloc( strlen(home) + strlen(CONFDIR) + 1 )))
fatal_error( "out of memory\n" );
strcpy( confdir, home );
strcat( confdir, CONFDIR );
mkdir( confdir, 0755 ); /* just in case */
}
return confdir;
}
/* create the server directory and chdir to it */
static void create_server_dir(void)
{
char hostname[64];
char *serverdir;
const char *confdir = get_config_dir();
struct stat st;
if (gethostname( hostname, sizeof(hostname) ) == -1) fatal_perror( "gethostname" );
if (!(serverdir = malloc( strlen(confdir) + strlen(SERVERDIR) + strlen(hostname) + 1 )))
fatal_error( "out of memory\n" );
strcpy( serverdir, confdir );
strcat( serverdir, SERVERDIR );
strcat( serverdir, hostname );
if (chdir( serverdir ) == -1)
{
if (errno != ENOENT) fatal_perror( "chdir %s", serverdir );
if (mkdir( serverdir, 0700 ) == -1) fatal_perror( "mkdir %s", serverdir );
if (chdir( serverdir ) == -1) fatal_perror( "chdir %s", serverdir );
}
if (stat( ".", &st ) == -1) fatal_perror( "stat %s", serverdir );
if (!S_ISDIR(st.st_mode)) fatal_error( "%s is not a directory\n", serverdir );
if (st.st_uid != getuid()) fatal_error( "%s is not owned by you\n", serverdir );
if (st.st_mode & 077) fatal_error( "%s must not be accessible by other users\n", serverdir );
}
/* open the master server socket and start waiting for new clients */
void open_master_socket(void)
{
struct sockaddr_un addr;
int fd;
create_server_dir();
if ((fd = socket( AF_UNIX, SOCK_STREAM, 0 )) == -1) fatal_perror( "socket" );
addr.sun_family = AF_UNIX;
strcpy( addr.sun_path, "socket" );
if (bind( fd, &addr, sizeof(addr.sun_family) + strlen(addr.sun_path) ) == -1)
{
if ((errno == EEXIST) || (errno == EADDRINUSE))
fatal_error( "another server is already running\n" );
else
fatal_perror( "bind" );
}
atexit( socket_cleanup );
chmod( "socket", 0600 ); /* make sure no other user can connect */
if (listen( fd, 5 ) == -1) fatal_perror( "listen" );
if (!(master_socket = alloc_object( &master_socket_ops, fd )))
fatal_error( "out of memory\n" );
set_select_events( &master_socket->obj, POLLIN );
}
/* close the master socket and stop waiting for new clients */
void close_master_socket(void)
{
release_object( master_socket );
}
/* lock/unlock the master socket to stop accepting new clients */
void lock_master_socket( int locked )
{
set_select_events( &master_socket->obj, locked ? 0 : POLLIN );
}
/* debugger support operations */

7
server/request.h
View File

@ -31,6 +31,9 @@ extern int write_request( struct thread *thread );
extern void fatal_protocol_error( struct thread *thread, const char *err, ... );
extern void set_reply_fd( struct thread *thread, int pass_fd );
extern void send_reply( struct thread *thread );
extern void open_master_socket(void);
extern void close_master_socket(void);
extern void lock_master_socket( int locked );
extern void trace_request( enum request req, int fd );
extern void trace_kill( struct thread *thread );
@ -69,7 +72,7 @@ static inline size_t get_req_strlenW( const WCHAR *str )
DECL_HANDLER(new_process);
DECL_HANDLER(new_thread);
DECL_HANDLER(set_debug);
DECL_HANDLER(boot_done);
DECL_HANDLER(init_process);
DECL_HANDLER(init_process_done);
DECL_HANDLER(init_thread);
@ -168,7 +171,7 @@ static const struct handler {
} req_handlers[REQ_NB_REQUESTS] = {
{ (void(*)())req_new_process, sizeof(struct new_process_request) },
{ (void(*)())req_new_thread, sizeof(struct new_thread_request) },
{ (void(*)())req_set_debug, sizeof(struct set_debug_request) },
{ (void(*)())req_boot_done, sizeof(struct boot_done_request) },
{ (void(*)())req_init_process, sizeof(struct init_process_request) },
{ (void(*)())req_init_process_done, sizeof(struct init_process_done_request) },
{ (void(*)())req_init_thread, sizeof(struct init_thread_request) },

3
server/select.c
View File

@ -210,9 +210,6 @@ void select_loop(void)
sigset_t sigset;
struct sigaction action;
setsid();
signal( SIGPIPE, SIG_IGN );
/* block the signals we use */
sigemptyset( &sigset );
sigaddset( &sigset, SIGCHLD );

42
server/thread.c
View File

@ -87,6 +87,7 @@ static const struct object_ops thread_ops =
};
static struct thread *first_thread;
static struct thread *booting_thread;
/* allocate the buffer for the communication with the client */
static int alloc_client_buffer( struct thread *thread )
@ -106,7 +107,7 @@ static int alloc_client_buffer( struct thread *thread )
}
/* create a new thread */
static struct thread *create_thread( int fd, struct process *process, int suspend )
struct thread *create_thread( int fd, struct process *process, int suspend )
{
struct thread *thread;
int buf_fd;
@ -135,14 +136,15 @@ static struct thread *create_thread( int fd, struct process *process, int suspen
thread->suspend = (suspend != 0);
thread->buffer = (void *)-1;
thread->last_req = REQ_GET_THREAD_BUFFER;
thread->process = (struct process *)grab_object( process );
if (!first_thread) /* creating the first thread */
if (!current) current = thread;
if (!booting_thread) /* first thread ever */
{
current = thread;
thread->process = process = create_initial_process();
assert( process );
booting_thread = thread;
lock_master_socket(1);
}
else thread->process = (struct process *)grab_object( process );
if ((thread->next = first_thread) != NULL) thread->next->prev = thread;
first_thread = thread;
@ -161,13 +163,6 @@ static struct thread *create_thread( int fd, struct process *process, int suspen
return NULL;
}
/* create the initial thread and start the main server loop */
void create_initial_thread( int fd )
{
create_thread( fd, NULL, 0 );
select_loop();
}
/* handle a client event */
void thread_poll_event( struct object *obj, int event )
{
@ -543,25 +538,34 @@ void kill_thread( struct thread *thread, int exit_code )
release_object( thread );
}
/* signal that we are finished booting on the client side */
DECL_HANDLER(boot_done)
{
debug_level = req->debug_level;
/* Make sure last_req is initialized */
current->last_req = REQ_BOOT_DONE;
if (current == booting_thread)
{
booting_thread = (struct thread *)~0UL; /* make sure it doesn't match other threads */
lock_master_socket(0); /* allow other clients now */
}
}
/* create a new thread */
DECL_HANDLER(new_thread)
{
struct thread *thread;
struct process *process;
int sock[2];
if (!(process = get_process_from_id( req->pid ))) return;
if (socketpair( AF_UNIX, SOCK_STREAM, 0, sock ) != -1)
{
if ((thread = create_thread( sock[0], process, req->suspend )))
if ((thread = create_thread( sock[0], current->process, req->suspend )))
{
req->tid = thread;
if ((req->handle = alloc_handle( current->process, thread,
THREAD_ALL_ACCESS, req->inherit )) != -1)
{
set_reply_fd( current, sock[1] );
release_object( process );
/* thread object will be released when the thread gets killed */
return;
}
@ -570,7 +574,6 @@ DECL_HANDLER(new_thread)
close( sock[1] );
}
else file_set_error();
release_object( process );
}
/* retrieve the thread buffer file descriptor */
@ -592,6 +595,7 @@ DECL_HANDLER(init_thread)
if (current->suspend + current->process->suspend > 0) stop_thread( current );
req->pid = current->process;
req->tid = current;
req->boot = (current == booting_thread);
}
/* terminate a thread */

2
server/thread.h
View File

@ -62,7 +62,7 @@ extern struct thread *current;
/* thread functions */
extern void create_initial_thread( int fd );
extern struct thread *create_thread( int fd, struct process *process, int suspend );
extern struct thread *get_thread_from_id( void *id );
extern struct thread *get_thread_from_handle( int handle, unsigned int access );
extern struct thread *get_thread_from_pid( int pid );

16
server/trace.c
View File

@ -215,12 +215,13 @@ static void dump_new_process_request( const struct new_process_request *req )
static void dump_new_process_reply( const struct new_process_request *req )
{
fprintf( stderr, " pid=%p,", req->pid );
fprintf( stderr, " handle=%d", req->handle );
fprintf( stderr, " phandle=%d,", req->phandle );
fprintf( stderr, " tid=%p,", req->tid );
fprintf( stderr, " thandle=%d", req->thandle );
}
static void dump_new_thread_request( const struct new_thread_request *req )
{
fprintf( stderr, " pid=%p,", req->pid );
fprintf( stderr, " suspend=%d,", req->suspend );
fprintf( stderr, " inherit=%d", req->inherit );
}
@ -231,9 +232,9 @@ static void dump_new_thread_reply( const struct new_thread_request *req )
fprintf( stderr, " handle=%d", req->handle );
}
static void dump_set_debug_request( const struct set_debug_request *req )
static void dump_boot_done_request( const struct boot_done_request *req )
{
fprintf( stderr, " level=%d", req->level );
fprintf( stderr, " debug_level=%d", req->debug_level );
}
static void dump_init_process_request( const struct init_process_request *req )
@ -265,7 +266,8 @@ static void dump_init_thread_request( const struct init_thread_request *req )
static void dump_init_thread_reply( const struct init_thread_request *req )
{
fprintf( stderr, " pid=%p,", req->pid );
fprintf( stderr, " tid=%p", req->tid );
fprintf( stderr, " tid=%p,", req->tid );
fprintf( stderr, " boot=%d", req->boot );
}
static void dump_get_thread_buffer_request( const struct get_thread_buffer_request *req )
@ -1168,7 +1170,7 @@ static void dump_set_thread_context_request( const struct set_thread_context_req
static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_new_process_request,
(dump_func)dump_new_thread_request,
(dump_func)dump_set_debug_request,
(dump_func)dump_boot_done_request,
(dump_func)dump_init_process_request,
(dump_func)dump_init_process_done_request,
(dump_func)dump_init_thread_request,
@ -1358,7 +1360,7 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
static const char * const req_names[REQ_NB_REQUESTS] = {
"new_process",
"new_thread",
"set_debug",
"boot_done",
"init_process",
"init_process_done",
"init_thread",