Server reorganization:
- moved request handlers to the specific C files
- moved handle management to handle.c
- moved server private includes to server/ instead of include/server/
diff --git a/server/process.c b/server/process.c
index 61273f0..6d435aa 100644
--- a/server/process.c
+++ b/server/process.c
@@ -17,37 +17,19 @@
#include "winnt.h"
#include "server.h"
-#include "server/process.h"
-#include "server/thread.h"
-
-/* reserved handle access rights */
-#define RESERVED_SHIFT 25
-#define RESERVED_INHERIT (HANDLE_FLAG_INHERIT << RESERVED_SHIFT)
-#define RESERVED_CLOSE_PROTECT (HANDLE_FLAG_PROTECT_FROM_CLOSE << RESERVED_SHIFT)
-#define RESERVED_ALL (RESERVED_INHERIT | RESERVED_CLOSE_PROTECT)
-
-/* global handle macros */
-#define HANDLE_OBFUSCATOR 0x544a4def
-#define HANDLE_IS_GLOBAL(h) (((h) ^ HANDLE_OBFUSCATOR) < 0x10000)
-#define HANDLE_LOCAL_TO_GLOBAL(h) ((h) ^ HANDLE_OBFUSCATOR)
-#define HANDLE_GLOBAL_TO_LOCAL(h) ((h) ^ HANDLE_OBFUSCATOR)
-
-struct handle_entry
-{
- struct object *ptr;
- unsigned int access;
-};
+#include "handle.h"
+#include "process.h"
+#include "thread.h"
/* process structure */
+
struct process
{
struct object obj; /* object header */
struct process *next; /* system-wide process list */
struct process *prev;
struct thread *thread_list; /* head of the thread list */
- struct handle_entry *entries; /* handle entry table */
- int handle_count; /* nb of allocated handle entries */
- int handle_last; /* last used handle entry */
+ struct handle_table handles; /* handle table */
int exit_code; /* process exit code */
int running_threads; /* number of threads running in this process */
struct timeval start_time; /* absolute time at process start */
@@ -59,20 +41,15 @@
struct new_process_request *info; /* startup info (freed after startup) */
};
-
static struct process initial_process;
static struct process *first_process = &initial_process;
static int running_processes;
-#define MIN_HANDLE_ENTRIES 32
-
/* process operations */
static void process_dump( struct object *obj, int verbose );
static int process_signaled( struct object *obj, struct thread *thread );
static void process_destroy( struct object *obj );
-static void free_handles( struct process *process );
-static int copy_handle_table( struct process *process, struct process *parent );
static const struct object_ops process_ops =
{
@@ -133,7 +110,7 @@
}
/* create a new process */
-struct process *create_process( struct new_process_request *req )
+static struct process *create_process( struct new_process_request *req )
{
struct process *process = NULL;
struct process *parent = current->process;
@@ -223,8 +200,14 @@
access, &process_ops );
}
+/* get a pointer to the process handle table */
+struct handle_table *get_process_handles( struct process *process )
+{
+ return &process->handles;
+}
+
/* retrieve the initialization info for a new process */
-int get_process_init_info( struct process *process, struct init_process_reply *reply )
+static int get_process_init_info( struct process *process, struct init_process_reply *reply )
{
struct new_process_request *info;
if (!(info = process->info)) return 0;
@@ -248,25 +231,6 @@
free_handles( process );
}
-/* free the process handle entries */
-static void free_handles( struct process *process )
-{
- struct handle_entry *entry;
- int handle;
-
- if (!(entry = process->entries)) return;
- for (handle = 0; handle <= process->handle_last; handle++, entry++)
- {
- struct object *obj = entry->ptr;
- entry->ptr = NULL;
- if (obj) release_object( obj );
- }
- free( process->entries );
- process->handle_count = 0;
- process->handle_last = -1;
- process->entries = NULL;
-}
-
/* add a thread to a process running threads list */
void add_process_thread( struct process *process, struct thread *thread )
{
@@ -297,268 +261,16 @@
release_object( thread );
}
-/* grow a handle table */
-/* return 1 if OK, 0 on error */
-static int grow_handle_table( struct process *process )
-{
- struct handle_entry *new_entries;
- int count = process->handle_count;
-
- if (count >= INT_MAX / 2) return 0;
- count *= 2;
- if (!(new_entries = realloc( process->entries, count * sizeof(struct handle_entry) )))
- {
- SET_ERROR( ERROR_OUTOFMEMORY );
- return 0;
- }
- process->handle_count = count;
- process->entries = new_entries;
- return 1;
-}
-
-/* allocate a handle for an object, incrementing its refcount */
-/* return the handle, or -1 on error */
-int alloc_handle( struct process *process, void *obj, unsigned int access,
- int inherit )
-{
- struct handle_entry *entry;
- int handle;
-
- assert( !(access & RESERVED_ALL) );
- if (inherit) access |= RESERVED_INHERIT;
-
- /* find the first free entry */
-
- if (!(entry = process->entries)) return -1;
- for (handle = 0; handle <= process->handle_last; handle++, entry++)
- if (!entry->ptr) goto found;
-
- if (handle >= process->handle_count)
- {
- if (!grow_handle_table( process )) return -1;
- entry = process->entries + handle; /* the table may have moved */
- }
- process->handle_last = handle;
-
- found:
- entry->ptr = grab_object( obj );
- entry->access = access;
- return handle + 1; /* avoid handle 0 */
-}
-
-/* return an handle entry, or NULL if the handle is invalid */
-static struct handle_entry *get_handle( struct process *process, int handle )
-{
- struct handle_entry *entry;
-
- if (HANDLE_IS_GLOBAL(handle))
- {
- handle = HANDLE_GLOBAL_TO_LOCAL(handle);
- process = &initial_process;
- }
- handle--; /* handles start at 1 */
- if ((handle < 0) || (handle > process->handle_last)) goto error;
- entry = process->entries + handle;
- if (!entry->ptr) goto error;
- return entry;
-
- error:
- SET_ERROR( ERROR_INVALID_HANDLE );
- return NULL;
-}
-
-/* attempt to shrink a table */
-/* return 1 if OK, 0 on error */
-static int shrink_handle_table( struct process *process )
-{
- struct handle_entry *new_entries;
- struct handle_entry *entry = process->entries + process->handle_last;
- int count = process->handle_count;
-
- while (process->handle_last >= 0)
- {
- if (entry->ptr) break;
- process->handle_last--;
- entry--;
- }
- if (process->handle_last >= count / 4) return 1; /* no need to shrink */
- if (count < MIN_HANDLE_ENTRIES * 2) return 1; /* too small to shrink */
- count /= 2;
- if (!(new_entries = realloc( process->entries,
- count * sizeof(struct handle_entry) )))
- return 0;
- process->handle_count = count;
- process->entries = new_entries;
- return 1;
-}
-
-/* copy the handle table of the parent process */
-/* return 1 if OK, 0 on error */
-static int copy_handle_table( struct process *process, struct process *parent )
-{
- struct handle_entry *ptr;
- int i, count, last;
-
- if (!parent) /* first process */
- {
- count = MIN_HANDLE_ENTRIES;
- last = -1;
- }
- else
- {
- assert( parent->entries );
- count = parent->handle_count;
- last = parent->handle_last;
- }
-
- if (!(ptr = mem_alloc( count * sizeof(struct handle_entry)))) return 0;
- process->entries = ptr;
- process->handle_count = count;
- process->handle_last = last;
-
- if (last >= 0)
- {
- memcpy( ptr, parent->entries, (last + 1) * sizeof(struct handle_entry) );
- for (i = 0; i <= last; i++, ptr++)
- {
- if (!ptr->ptr) continue;
- if (ptr->access & RESERVED_INHERIT) grab_object( ptr->ptr );
- else ptr->ptr = NULL; /* don't inherit this entry */
- }
- }
- /* attempt to shrink the table */
- shrink_handle_table( process );
- return 1;
-}
-
-/* close a handle and decrement the refcount of the associated object */
-/* return 1 if OK, 0 on error */
-int close_handle( struct process *process, int handle )
-{
- struct handle_entry *entry;
- struct object *obj;
-
- if (HANDLE_IS_GLOBAL(handle))
- {
- handle = HANDLE_GLOBAL_TO_LOCAL(handle);
- process = &initial_process;
- }
- if (!(entry = get_handle( process, handle ))) return 0;
- if (entry->access & RESERVED_CLOSE_PROTECT) return 0; /* FIXME: error code */
- obj = entry->ptr;
- entry->ptr = NULL;
- if (handle-1 == process->handle_last) shrink_handle_table( process );
- release_object( obj );
- return 1;
-}
-
-/* retrieve the object corresponding to a handle, incrementing its refcount */
-struct object *get_handle_obj( struct process *process, int handle,
- unsigned int access, const struct object_ops *ops )
-{
- struct handle_entry *entry;
- struct object *obj;
-
- switch( handle )
- {
- case 0xfffffffe: /* current thread pseudo-handle */
- obj = ¤t->obj;
- break;
- case 0x7fffffff: /* current process pseudo-handle */
- obj = (struct object *)current->process;
- break;
- default:
- if (!(entry = get_handle( process, handle ))) return NULL;
- if ((entry->access & access) != access)
- {
- SET_ERROR( ERROR_ACCESS_DENIED );
- return NULL;
- }
- obj = entry->ptr;
- break;
- }
- if (ops && (obj->ops != ops))
- {
- SET_ERROR( ERROR_INVALID_HANDLE ); /* not the right type */
- return NULL;
- }
- return grab_object( obj );
-}
-
-/* get/set the handle reserved flags */
-/* return the new flags (or -1 on error) */
-int set_handle_info( struct process *process, int handle, int mask, int flags )
-{
- struct handle_entry *entry;
-
- if (!(entry = get_handle( process, handle ))) return -1;
- mask = (mask << RESERVED_SHIFT) & RESERVED_ALL;
- flags = (flags << RESERVED_SHIFT) & mask;
- entry->access = (entry->access & ~mask) | flags;
- return (entry->access & RESERVED_ALL) >> RESERVED_SHIFT;
-}
-
-/* duplicate a handle */
-int duplicate_handle( struct process *src, int src_handle, struct process *dst,
- unsigned int access, int inherit, int options )
-{
- int res;
- struct handle_entry *entry = get_handle( src, src_handle );
- if (!entry) return -1;
-
- if (options & DUP_HANDLE_SAME_ACCESS) access = entry->access;
- if (options & DUP_HANDLE_MAKE_GLOBAL) dst = &initial_process;
- access &= ~RESERVED_ALL;
- res = alloc_handle( dst, entry->ptr, access, inherit );
- if (options & DUP_HANDLE_MAKE_GLOBAL) res = HANDLE_LOCAL_TO_GLOBAL(res);
- return res;
-}
-
-/* open a new handle to an existing object */
-int open_object( const char *name, const struct object_ops *ops,
- unsigned int access, int inherit )
-{
- struct object *obj = find_object( name );
- if (!obj)
- {
- SET_ERROR( ERROR_FILE_NOT_FOUND );
- return -1;
- }
- if (ops && obj->ops != ops)
- {
- release_object( obj );
- SET_ERROR( ERROR_INVALID_HANDLE ); /* FIXME: not the right type */
- return -1;
- }
- return alloc_handle( current->process, obj, access, inherit );
-}
-
-/* dump a handle table on stdout */
-void dump_handles( struct process *process )
-{
- struct handle_entry *entry;
- int i;
-
- if (!process->entries) return;
- entry = process->entries;
- for (i = 0; i <= process->handle_last; i++, entry++)
- {
- if (!entry->ptr) continue;
- printf( "%5d: %p %08x ", i + 1, entry->ptr, entry->access );
- entry->ptr->ops->dump( entry->ptr, 0 );
- }
-}
-
/* kill a process on the spot */
-void kill_process( struct process *process, int exit_code )
+static void kill_process( struct process *process, int exit_code )
{
while (process->thread_list)
kill_thread( process->thread_list, exit_code );
}
/* get all information about a process */
-void get_process_info( struct process *process,
- struct get_process_info_reply *reply )
+static void get_process_info( struct process *process,
+ struct get_process_info_reply *reply )
{
reply->pid = process;
reply->exit_code = process->exit_code;
@@ -568,8 +280,8 @@
}
/* set all information about a process */
-void set_process_info( struct process *process,
- struct set_process_info_request *req )
+static void set_process_info( struct process *process,
+ struct set_process_info_request *req )
{
if (req->mask & SET_PROCESS_INFO_PRIORITY)
process->priority = req->priority;
@@ -634,3 +346,95 @@
*count = running_processes;
return snapshot;
}
+
+/* create a new process */
+DECL_HANDLER(new_process)
+{
+ struct new_process_reply reply;
+ struct process *process;
+
+ if ((process = create_process( req )))
+ {
+ reply.pid = process;
+ reply.handle = alloc_handle( current->process, process,
+ PROCESS_ALL_ACCESS, req->inherit );
+ release_object( process );
+ }
+ else
+ {
+ reply.handle = -1;
+ reply.pid = NULL;
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* initialize a new process */
+DECL_HANDLER(init_process)
+{
+ struct init_process_reply reply;
+ if (current->state != RUNNING)
+ {
+ fatal_protocol_error( "init_process: init_thread not called yet\n" );
+ return;
+ }
+ if (!get_process_init_info( current->process, &reply ))
+ {
+ fatal_protocol_error( "init_process: called twice\n" );
+ return;
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* open a handle to a process */
+DECL_HANDLER(open_process)
+{
+ struct open_process_reply reply = { -1 };
+ struct process *process = get_process_from_id( req->pid );
+ if (process)
+ {
+ reply.handle = alloc_handle( current->process, process,
+ req->access, req->inherit );
+ release_object( process );
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* terminate a process */
+DECL_HANDLER(terminate_process)
+{
+ struct process *process;
+
+ if ((process = get_process_from_handle( req->handle, PROCESS_TERMINATE )))
+ {
+ kill_process( process, req->exit_code );
+ release_object( process );
+ }
+ if (current) send_reply( current, -1, 0 );
+}
+
+/* fetch information about a process */
+DECL_HANDLER(get_process_info)
+{
+ struct process *process;
+ struct get_process_info_reply reply = { 0, 0, 0 };
+
+ if ((process = get_process_from_handle( req->handle, PROCESS_QUERY_INFORMATION )))
+ {
+ get_process_info( process, &reply );
+ release_object( process );
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* set information about a process */
+DECL_HANDLER(set_process_info)
+{
+ struct process *process;
+
+ if ((process = get_process_from_handle( req->handle, PROCESS_SET_INFORMATION )))
+ {
+ set_process_info( process, req );
+ release_object( process );
+ }
+ send_reply( current, -1, 0 );
+}
