From 282113ba894449ed17e85b296cf0760d5206ac8d Mon Sep 17 00:00:00 2001 From: Corinna Vinschen Date: Wed, 19 Nov 2003 18:49:41 +0000 Subject: Don't use safe_new but new throughout. Fix copyright dates throughout. * Makefile.in: Accomodate all new files and name changes. Add a *.d dependency. (sbindir): Add. (etcdir): Drop in favor of more appropriate sysconfdir definition. (sysconfdir): Add. (CXXFLAGS): Add -MMD flag. Add SYSCONFDIR definition. (.SUFFIXES): Add. (install): Add action items. (libclean): New target. (fullclean): Ditto. * bsd_helper.cc: New file. * bsd_helper.h: Ditto. * bsd_log.cc: Ditto. * bsd_log.h: Ditto. * bsd_mutex.cc: Ditto. * bsd_mutex.h: Ditto. * client.cc: Rearrange to build as less as possible if __INSIDE_CYGWIN__. (client_request::handle_request): Add Message Queue and Semaphore handling. * cygserver.cc: Rearrange to build as less as possible if __INSIDE_CYGWIN__. Use new debug/log/panic logging functions. (DEF_CONFIG_FILE): New definition for configuration file. Use throughout. (getfunc): Remove. (__cygserver__printf): Remove. (client_request_attach_tty::serve): Return error if impersonation fails. (print_usage): Pump up help message. (print_version): Add output of default configuration file. (main): Accommodate new options. Allow overwrite of threading options from config file. Call several new initialization functions. Drop printing dots. Don't define SIGHANDLE inline. * cygserver.conf: New file. * cygserver_process.h: Rename to process.h. * cygserver_transport.h: Rename to transport.h. * cygserver_transport_pipes.h: Rename to transport_pipes.h. * cygserver_transport_sockets.h: Rename to transport_sockets.h. * msg.cc: Rewrite. * sem.cc: Rewrite. * shm.cc: Rewrite. * sysv_msg.cc: New file, derived from FreeBSD version 1.52. * sysv_sem.cc: New file, derived from FreeBSD version 1.66. * sysv_shm.cc: New file, derived from FreeBSD version 1.89. * threaded_queue.cc: Rearrange to build as less as possible if __INSIDE_CYGWIN__. * transport.cc (transport_layer_base::impersonate_client): Define bool. (transport_layer_base::revert_to_self): Ditto. * transport.h (transport_layer_base::impersonate_client): Declare bool. (transport_layer_base::revert_to_self): Ditto. * transport_pipes.cc (transport_layer_pipes::transport_layer_pipes): Don't call init_security. (init_security): Remove. (transport_layer_pipes::accept): Use global sec_all_nih. (transport_layer_pipes::connect): Ditto. (transport_layer_pipes::impersonate_client): Define bool. (transport_layer_pipes::revert_to_self): Ditt. * transport_pipes.h (transport_layer_pipes::impersonate_client): Declare bool. (transport_layer_pipes::revert_to_self): Ditto. * woutsup.h: Include bsd compatibility headers. (SIGHANDLE): Add definition. (__cygserver__printf): Remove definition. (__noop_printf): Ditto. (debug_printf): Define using debug. (syscall_printf): Define using log. (system_printf): Ditto. Drop all other _printf definitions. --- winsup/cygserver/process.h | 164 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 winsup/cygserver/process.h (limited to 'winsup/cygserver/process.h') diff --git a/winsup/cygserver/process.h b/winsup/cygserver/process.h new file mode 100644 index 000000000..142b3634c --- /dev/null +++ b/winsup/cygserver/process.h @@ -0,0 +1,164 @@ +/* process.h + + Copyright 2001, 2002 Red Hat Inc. + + Written by Robert Collins + +This file is part of Cygwin. + +This software is a copyrighted work licensed under the terms of the +Cygwin license. Please consult the file "CYGWIN_LICENSE" for +details. */ + +#ifndef _PROCESS_H +#define _PROCESS_H + +#include + +#include "threaded_queue.h" + +class process_cleanup : public queue_request +{ +public: + process_cleanup (class process *const theprocess) + : _process (theprocess) + { + assert (_process); + } + + virtual ~process_cleanup (); + + virtual void process (); + +private: + class process *const _process; +}; + +class process; + +class cleanup_routine +{ + friend class process; + +public: + cleanup_routine (void *const key) + : _key (key), + _next (NULL) + {} + + virtual ~cleanup_routine (); + + bool operator== (const cleanup_routine &rhs) const + { + return _key == rhs._key; + } + + void *key () const { return _key; } + + /* MUST BE SYNCHRONOUS */ + virtual void cleanup (class process *) = 0; + +private: + void *const _key; + cleanup_routine *_next; +}; + +class process_cache; + +class process +{ + friend class process_cache; + friend class process_cleanup; + +public: + process (pid_t cygpid, DWORD winpid); + ~process (); + + pid_t cygpid () const { return _cygpid; } + DWORD winpid () const { return _winpid; } + HANDLE handle () const { return _hProcess; } + + bool is_active () const { return _exit_status == STILL_ACTIVE; } + + void hold () { EnterCriticalSection (&_access); } + void release () { LeaveCriticalSection (&_access); } + + bool add (cleanup_routine *); + bool remove (const cleanup_routine *); + +private: + const pid_t _cygpid; + const DWORD _winpid; + HANDLE _hProcess; + long _cleaning_up; + DWORD _exit_status; // Set in the constructor and in exit_code (). + cleanup_routine *_routines_head; + /* used to prevent races-on-delete */ + CRITICAL_SECTION _access; + class process *_next; + + DWORD check_exit_code (); + void cleanup (); +}; + +class process_cache +{ + // Number of special (i.e., non-process) handles in _wait_array. + // See wait_for_processes () and sync_wait_array () for details. + enum { + SPECIALS_COUNT = 2 + }; + + class submission_loop : public queue_submission_loop + { + public: + submission_loop (process_cache *const cache, threaded_queue *const queue) + : queue_submission_loop (queue, true), + _cache (cache) + { + assert (_cache); + } + + private: + process_cache *const _cache; + + virtual void request_loop (); + }; + + friend class submission_loop; + +public: + process_cache (unsigned int initial_workers); + ~process_cache (); + + class process *process (pid_t cygpid, DWORD winpid); + + bool running () const { return _queue.running (); } + + bool start () { return _queue.start (); } + bool stop () { return _queue.stop (); } + +private: + threaded_queue _queue; + submission_loop _submitter; + + size_t _processes_count; + class process *_processes_head; // A list sorted by winpid. + + // Access to the _wait_array and related fields is not thread-safe, + // since they are used solely by wait_for_processes () and its callees. + + HANDLE _wait_array[MAXIMUM_WAIT_OBJECTS]; + class process *_process_array[MAXIMUM_WAIT_OBJECTS]; + + HANDLE _cache_add_trigger; // Actually both add and remove. + CRITICAL_SECTION _cache_write_access; // Actually both read and write access. + + void wait_for_processes (HANDLE interrupt); + size_t sync_wait_array (HANDLE interrupt); + void check_and_remove_process (const size_t index); + + class process *find (DWORD winpid, class process **previous = NULL); +}; + +#endif /* _PROCESS_H */ -- cgit v1.2.3