282113ba89
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.
165 lines
3.5 KiB
C++
165 lines
3.5 KiB
C++
/* process.h
|
|
|
|
Copyright 2001, 2002 Red Hat Inc.
|
|
|
|
Written by Robert Collins <rbtcollins@hotmail.com>
|
|
|
|
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 <assert.h>
|
|
|
|
#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 */
|