newlib-cygwin/winsup/cygwin/cygserver_process.cc

390 lines
10 KiB
C++
Raw Normal View History

2002-02-28 Robert Collins <rbtcollins@hotmail.com> * Merged cygwin_daemon into head minus the new shm and ipc exports. 2002-02-28 Robert Collins <rbtcollins@hotmail.com> * fhandler_tty.cc (fhandler_tty_slave::open): More debugging. (fhandler_tty_slave::read): Fix printf type for the handle. * tty.cc (tty::common_init): Add a FIXME for security. 2002-01-29 Robert Collins <rbtcollins@hotmail.com> * Makefile.in (OBJS): Remove duplicate localtime.o. 2002-01-17 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (check_and_dup_handle): Consolidate the two variants for simplicity. Add Some basic debug output. (client_request_attach_tty::serve): Use the new debug_printf for clarity. Mark the duplicated handles as inheritable - fixup_after_fork() doesn't reopen tty's. 2002-01-16 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (transport): Correct scope. (client_request_attach_tty::serve): Add more debug information. Fix erroneous use of transport instead of conn. * cygserver_transport_pipes.cc (transport_layer_pipes::close): More debug. (transport_layer_pipes::read): Ditto. (transport_layer_pipes::write): Ditto. (transport_layer_pipes::impersonate_client): Ditto. Mon Oct 8 7:41:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (server_request::process): Rename client_request_shm_get to client_request_shm. * cygserver_process.cc (process_cache::add): Rename to add_task. Use process_cleanup instead of process_request. (process_cache::remove_process): New method. (process::process): Initialize new members. (process::~process): New member. (process::cleanup): New method. (process::add_cleanup_routine): New method. (process_request::process): Rename to process_cleanup. Call the process object's cleanup method and then delete it. (process_process_param::request_loop): Remove the signalling process. * cygserver_shm.cc: Globally rename client_request_shm_get to client_request_shm. (client_request_shm_get::serve): Handle attach request counting. * cygserver_shm.h: Globally rename client_request_shm_get to client_request_shm. (class shm_cleanup): New class. * shm.cc: Globally rename client_request_shm_get to client_request_shm. (client_request_shm::client_request_shm): New constructor for attach requests. (shmat): Use it. * include/cygwin/cygserver_process.h (class process_request): Rename to process_cleanup. (class cleanup_routine): New class. (class process): New members and methods to allow calling back when the process terminates. Thu Oct 4 14:12:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (request_loop): Make static. (main): Use new cache constructor syntax. Start cache worker threads. Cleanup the cache at shutdown. * cygserver_process.cc: Run indent. (process_cache::process_cache): Add a trigger to use when adding a process. (process_cache::process): Move process_entry to process. Insert at the end of the list. Trigger the request loop when new process's inserted. (process_cache::process_requests): Do it. (process_cache::add): New method. (process_cache::handle_snapshot): New method. (process::process): Merge in the process_entry fields. (process::handle): Make a stub function. (process::exit_code): New method. (process_request::process): New method. (process_process_param::request_loop): New method. * cygserver_shm.cc: New header dependency - threaded_queue.h. * threaded_queue.cc (threaded_queue::cleanup): Clearer messages. (queue_process_param::stop): Short spinlock on interruptible threads. * threaded_queue.h (class threaded_queue): New constructor. * include/cygwin/cygserver_process.h (process_request): New class. (process_entry): Remove. (process): Merge in process_entry. (process_cache): Inherit from threaded_queue. Tue Oct 2 23:24:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (class server_process_param): Use new constructor syntax. * cygserver_process.cc (process_cache::~process_cache): New function. * threaded_queue.cc: Define condition debug_printf. Run indent. (threaded_queue::cleanup): Move queue_process_param guts to a method. (threaded_queue::process_requests): Ditto. (queue_process_param::queue_process_param): New method. (queue_process_param::~queue_process_param): Ditto. (queue_process_param::start): Ditto. (queue_process_param::stop): Ditto. * threaded_queue.h (class queue_process_param): Add support for interruptible request loops. * cygwin/include/cygwin/cygserver_process.h (class process_cache): Add destructor. Tue Oct 2 23:24:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver_client.cc: New flag allow_daemon to disable the daemon completely. (cygserver_request): Check it. (cygserver_init): Ditto. * environ.cc (parse_thing): Add (no)daemon option. Tue Oct 2 23:00:00 2001 Robert Collins <rbtcollins@hotmail.com> * shm.cc: Update to handle include changes from HEAD. Tue Oct 2 16:06:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: Remove cygserver_shm.o from cygwin1.dll. Rename cygserver_shm_outside.o to cygserver_shm.o. * cygserver.cc (server_request::process): Use the new client_request constructor. * cygserver_client.cc: Remove the #ifdef's stubs for the server method within cygwin. (client_request_attach_tty::client_request_attach_tty): Use the new client_request constructor. (client_request_shutdown::client_request_shutdown): Ditto. (client_request::client_request): Ditto. * cygserver_shm.cc (client_request_shm_get::serve): Remove the #ifdef'd stub for in-cygwin builds. (client_request_shm_get::client_request_shm_get): Use the new client_request constructor, and remove the in-cygwin variants. * cygserver_shm.h (class client_request_shm_get): #ifndef test the serve method - it's only used in cygserver. * shm.cc (client_request_shm_get::client_request_shm_get): New function. * include/cygwin/cygserver.h (request_header): New constructor. (class client_request): Use it. New constructor accepting the header size. #ifndef test the server method - it's only used within cygserver. (client_request_get_version): #ifdef test the server method. (client_request_shutdown): Ditto. (client_request_attach_tty): Ditto. Tue Oct 2 9:57:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: add threaded_queue.o to cygserver.exe. * cygserver.cc: Include threaded_queue.h (class server_request): Inherit from queue_request. (class server_process_param): Inherit from queue_process_param. (class server_request_queue): Inherit from threaded_queue. (request_loop): Adjust for new types. (server_request_queue::process_requests): Remove guts to threaded_queue::process_requests. (server_request::server_request): Adjust for new types. (worker_function): Delete. (server_request_queue::create_workers): Delete. (server_request_queue::cleanup): Delete. (server_request_queue::add): Move guts to threaded_queue::add. * threaded_queue.cc: New file. * threaded_queue.h: New file. Mon Oct 1 12:38:00 2001 Robert Collins <rbtcollins@hotmail.com> * cygserver.cc (client_request::serve): New function. * cygserver_process.cc: Inlude <pthread.h> for pthread_once. (process_cache::process_cache): Initialise a crtiical section for write access. (process_cache::process): Use the critical section. Also add missing entries to the cache. (do_process_init): New function to initalise class process static variables. (process::process): Ensure that the process access critical section is initialised. (process::handle): Close the handle of old process's when they have terminated and we are returning the handle for a process with the same pid. * cygserver_shm.cc: Run indent. Include cygserver_process.h to allow process cache functionality. (client_request_shm_get::serve): New parameter for process cache support. Use the process cache, not OpenProcess to get a handle to the originating process. Fix a handle leak with token_handle. * cygserver_shm.h (class client_request_shm_get): Update ::serve for process cache support. * cygserver_transport_pipes.cc: Redefine debug_printf to be conditional on DEBUG. * include/cygwin/cygserver.h: Do not implement client_request::serve in the header. * include/cygwin/cygserver_process.h (class process_cache): Add a write access critical section to prevent races when requests from a multithreaded application arrive. Sun Sep 30 23:41:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: Add cygserver_process.o to cygserver.exe. * cygserver.cc: Include signal.h and cygwin_version.h. Define debug_printf as a macro. Define DEBUG to a value. (client_request_attach_tty::serve): Add beginning of process cache support. Change from #ifdef DEBUG to work with new DEBUG style. (client_request_get_version::serve): Add beginning of process cache support. (class server_request): New prototype for support of process cache. (class queue_process_param): New class to allow request loop threading. (class server_request_queue): Add beginning of process cache support. Allow request loop threading. (request_loop): Thread function for request loops. (server_request_queue::process_requests): Initiator for threaded request loops. (client_request_shutdown::serve): Add beginning of process cache support. (server_request::server_request): Ditto. (server_request::process): Use debug_printf. Add beginning of process cache support. (server_request_queue::cleanup): Kill off any request loop threads. (server_request_queue::add): Add beginning of process cache support. (handle_signal): Trigger a shutdown. (main): Print out some useful info at startup - version, date time. Add process cache support. Spawn a separate thread for the transport request loop, thus allowing concurrent support for multiple transports. * cygserver_client.cc (client_request_get_version::serve): Add process cache support. (client_request_attach_tty::serve): Add process cache support. (client_request_shutdown::serve): Add process cache support. * cygsserver_process.cc: New file with the process cache support. * cygserver_shm.cc: Redefine debug_printf to allow conditional output. * cygwin.din: Export shmdt(). * shm.cc: Run indent. Update FIXME's. (shmdt): New function. * include/cygwin/cygserver.h (class client_request): Add process cache support. (class client_request_get_version): Ditto. (class client_request_shutdown): Ditto. (class client_request_attach_tty): Ditto. * include/cygwin/cygserver_process.h: New header for process cache support. Sun Sep 30 8:52:00 2001 Robert Collins <rbtcollins@hotmail.com> * include/cygwin/cygserver_transport.h: Add copyright header. * include/cygwin/cygserver_transport_pipes.h: Ditto. * include/cygwin/cygserver_transport_sockets.h: Ditto. Sat Sep 29 20:40:00 2001 Robert Collins <rbtcollins@hotmail.com> * Makefile.in: Add cygserver_transport_sockets.o to DLL_OFILES. Add cygserver_transport_sockets_outside.o to cygserver.exe. * cygserver.cc: Include new include files. * cygserver_client.cc: Ditto. * cygserver_shm.h: No need to include <sys/socket.h> now. * cygerver_transport.cc: Include new include files. (transport_layer_base::transport_layer_base): Strip back to a stub. (transport_layer_base::listen): Ditto. (transport_layer_base::accept): Ditto. (transport_layer_base::close): Ditto. (transport_layer_base::read): Ditto. (transport_layer_base::write): Ditto. (transport_layer_base::connect): Ditto. * cygserver_transport_pipes.cc: Include new header "cygwin/cygserver_transport_pipes.h". * cygserver_transport_sockets.cc: New file. * dcrt0.cc: No need to include <sys/socket.h> now. * fhandler_tty.cc: Ditto. * tty.cc: Ditto. * include/cygwin/cygserver_transport.h: Strip the base class to a stub. Remove the cygserver_transport_pipes class. * include/cygwin/cygserver_transport_pipes.h: New file. * include/cygwin/cygserver_transport_sockets.h: New file. Tue Sep 25 16:22:00 2001 Robert Collins <rbtcollins@hotmail.com> * autoload.cc: Add dynamic load statement for 'ImpersonateNamedPipeClient'. * Makefile.in: Add new object files, and build instructions for cygserver.exe. * cygwin.din: Export ftok, shmat, shmctl and shmget. * dcrt0.cc: Additional includes for cygserver support. (dll_crt0_1): Initialise the cygserver client. * fhandler.h (fhandler_tty): New method cygserver_attach_tty. * fhandler_tty.cc: Additional includes for cygserver support. (fhandler_tty_slave::open): Attempt to use the cygserver when obtaining handles from the parent process. On failure or 9x use the current method. (fhandler_tty_slave::cygserver_attach_tty): New function. * fork.cc (fork_child): Fixup shm memory mapped areas. * pinfo.h: Declare fixup_shms_after_fork(). * security.h: Declare alloc_sd(). * tty.cc: Additonal includes to support cygserver. (tty::common_init): Don't allow others to open us if the cygserver is running. * winsup.h: Declare cygserver_running. * cygserver.cc: New file. * cygserver_client.cc: New file. * cygserver_shm.cc: New file. * cygserver_shm.h: New file. * cygserver_transport.cc: New file. * cygserver_transport_pipes.cc: New file. * ipc.cc: New file. * shm.cc: New file. * include/cygwin/cygserver.h: New file. * include/cygwin/cygserver_transport.h: New file. * include/sys/ipc.h: New file. * include/sys/shm.h: New file. 2002-02-28 Robert Collins <rbtcollins@hotmail.com> * thread.cc (semaphore::TryWait): Set errno as required by posix 1003.1. (__sem_wait): Ditto. (__sem_trywait): Ditto.
2002-02-28 22:30:38 +08:00
/* cygserver_process.cc
Copyright 2001 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. */
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <windows.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include "wincap.h"
#include <pthread.h>
#include <threaded_queue.h>
#include <cygwin/cygserver_process.h>
#define debug_printf if (DEBUG) printf
#define DEBUG 1
/* the cache structures and classes are designed for one cache per server process.
* To make multiple process caches, a redesign will be needed
*/
/* process cache */
process_cache::process_cache (unsigned int num_initial_workers):
head (NULL)
{
/* there can only be one */
InitializeCriticalSection (&cache_write_access);
if ((cache_add_trigger = CreateEvent (NULL, FALSE, FALSE, NULL)) == NULL)
{
printf ("Failed to create cache add trigger (%lu), terminating\n",
GetLastError ());
exit (1);
}
initial_workers = num_initial_workers;
}
process_cache::~process_cache ()
{
}
class process *
process_cache::process (long pid)
{
class process *entry = head;
/* TODO: make this more granular, so a search doesn't involve the write lock */
EnterCriticalSection (&cache_write_access);
if (!entry)
{
entry = new class process (pid);
entry->next =
(class process *) InterlockedExchangePointer (&head, entry);
PulseEvent (cache_add_trigger);
}
else
{
while (entry->winpid != pid && entry->next)
entry = entry->next;
if (entry->winpid != pid)
{
class process *new_entry = new class process (pid);
new_entry->next =
(class process *) InterlockedExchangePointer (&entry->next,
new_entry);
entry = new_entry;
PulseEvent (cache_add_trigger);
}
}
LeaveCriticalSection (&cache_write_access);
return entry;
}
static DWORD WINAPI
request_loop (LPVOID LpParam)
{
class process_process_param *params = (process_process_param *) LpParam;
return params->request_loop ();
}
void
process_cache::process_requests ()
{
class process_process_param *params = new process_process_param;
threaded_queue::process_requests (params, request_loop);
}
void
process_cache::add_task (class process * theprocess)
{
/* safe to not "Try" because workers don't hog this, they wait on the event
*/
/* every derived ::add must enter the section! */
EnterCriticalSection (&queuelock);
queue_request *listrequest = new process_cleanup (theprocess);
threaded_queue::add (listrequest);
LeaveCriticalSection (&queuelock);
}
/* NOT fully MT SAFE: must be called by only one thread in a program */
void
process_cache::remove_process (class process *theprocess)
{
class process *entry = head;
/* unlink */
EnterCriticalSection (&cache_write_access);
if (entry == theprocess)
{
entry = (class process *) InterlockedExchangePointer (&head, theprocess->next);
if (entry != theprocess)
{
printf ("Bug encountered, process cache corrupted\n");
exit (1);
}
}
else
{
while (entry->next && entry->next != theprocess)
entry = entry->next;
class process *temp = (class process *) InterlockedExchangePointer (&entry->next, theprocess->next);
if (temp != theprocess)
{
printf ("Bug encountered, process cache corrupted\n");
exit (1);
}
}
LeaveCriticalSection (&cache_write_access);
/* Process any cleanup tasks */
add_task (theprocess);
}
/* copy <= max_copy HANDLEs to dest[], starting at an offset into _our list_ of
* begin_at. (Ie begin_at = 5, the first copied handle is still written to dest[0]
* NOTE: Thread safe, but not thread guaranteed - a newly added process may be missed.
* Who cares - It'll get caught the next time.
*/
int
process_cache::handle_snapshot (HANDLE * hdest, class process ** edest,
ssize_t max_copy, int begin_at)
{
/* TODO:? grab a delete-lock, to prevent deletes during this process ? */
class process *entry = head;
int count = begin_at;
/* skip begin_at entries */
while (entry && count)
{
if (entry->exit_code () == STILL_ACTIVE)
count--;
entry = entry->next;
}
/* hit the end of the list within begin_at entries */
if (count)
return 0;
HANDLE *hto = hdest;
class process **eto = edest;
while (entry && count < max_copy)
{
/* hack */
if (entry->exit_code () == STILL_ACTIVE)
{
*hto = entry->handle ();
*eto = entry;
count++;
hto++;
eto++;
}
entry = entry->next;
}
return count;
}
/* process's */
/* global process crit section */
static CRITICAL_SECTION process_access;
static pthread_once_t process_init;
void
do_process_init (void)
{
InitializeCriticalSection (&process_access);
/* we don't have a cache shutdown capability today */
}
process::process (long pid):
winpid (pid), next (NULL), cleaning_up (0), head (NULL), _exit_status (STILL_ACTIVE)
{
pthread_once (&process_init, do_process_init);
EnterCriticalSection (&process_access);
thehandle = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid);
if (!thehandle)
{
printf ("unable to obtain handle for new cache process %ld\n", pid);
thehandle = INVALID_HANDLE_VALUE;
}
debug_printf ("Got handle %p for new cache process %ld\n", thehandle, pid);
InitializeCriticalSection (&access);
LeaveCriticalSection (&process_access);
}
process::~process ()
{
DeleteCriticalSection (&access);
}
HANDLE
process::handle ()
{
// DWORD exitstate = exit_code ();
// if (exitstate == STILL_ACTIVE)
return thehandle;
/* FIXME: call the cleanup list ? */
// CloseHandle (thehandle);
// debug_printf ("Process id %ld has terminated, attempting to open a new handle\n",
// winpid);
// thehandle = OpenProcess (PROCESS_ALL_ACCESS, FALSE, winpid);
// debug_printf ("Got handle %p when refreshing cache process %ld\n", thehandle, winpid);
// /* FIXME: what if OpenProcess fails ? */
// if (thehandle)
// {
// _exit_status = STILL_ACTIVE;
// exit_code ();
// }
// else
// thehandle = INVALID_HANDLE_VALUE;
// return thehandle;
}
DWORD process::exit_code ()
{
if (_exit_status != STILL_ACTIVE)
return _exit_status;
bool
err = GetExitCodeProcess (thehandle, &_exit_status);
if (!err)
{
debug_printf ("Failed to retrieve exit code (%ld)\n", GetLastError ());
thehandle = INVALID_HANDLE_VALUE;
return _exit_status;
}
else if (_exit_status == STILL_ACTIVE)
return _exit_status;
/* add new cleanup task etc etc ? */
return _exit_status;
}
/* this is single threaded. It's called after the process is removed from the cache,
* but inserts may be attemped by worker threads that have a pointer to it */
void
process::cleanup ()
{
/* Serialize this */
EnterCriticalSection (&access);
InterlockedIncrement (&(long)cleaning_up);
class cleanup_routine *entry = head;
while (entry)
{
class cleanup_routine *temp;
entry->cleanup (winpid);
temp = entry->next;
delete entry;
entry = temp;
}
LeaveCriticalSection (&access);
}
bool
process::add_cleanup_routine (class cleanup_routine *new_cleanup)
{
if (cleaning_up)
return false;
EnterCriticalSection (&access);
/* check that we didn't block with ::cleanup ()
* This rigmarole is to get around win9x's glaring missing TryEnterCriticalSection call
* which would be a whole lot easier
*/
if (cleaning_up)
{
LeaveCriticalSection (&access);
return false;
}
new_cleanup->next = head;
head = new_cleanup;
LeaveCriticalSection (&access);
return true;
}
/* process_cleanup */
void
process_cleanup::process ()
{
theprocess->cleanup ();
delete theprocess;
}
/* process_process_param */
DWORD
process_process_param::request_loop ()
{
process_cache *cache = (process_cache *) queue;
/* always malloc one, so there is no special case in the loop */
ssize_t HandlesSize = 2;
HANDLE *Handles = (HANDLE *) malloc (sizeof (HANDLE) * HandlesSize);
process **Entries = (process **) malloc (sizeof (LPVOID) * HandlesSize);
/* TODO: put [1] at the end as it will also get done if a process dies? */
Handles[0] = interrupt;
Handles[1] = cache->cache_add_trigger;
while (cache->active && !shutdown)
{
int copied;
copied = -1;
int offset;
offset = 1;
int count;
count = 2;
while ((copied == HandlesSize - 2 - offset) || copied < 0)
{
/* we need more storage to cope with all the HANDLES */
if (copied == HandlesSize - 2 - offset)
{
HANDLE *temp = (HANDLE *) realloc (Handles,
sizeof (HANDLE) *
HandlesSize + 10);
if (!temp)
{
printf
("cannot allocate more storage for the handle array!\n");
exit (1);
}
Handles = temp;
process **ptemp = (process **) realloc (Entries,
sizeof (LPVOID) *
HandlesSize + 10);
if (!ptemp)
{
printf
("cannot allocate more storage for the handle array!\n");
exit (1);
}
Entries = ptemp;
HandlesSize += 10;
}
offset += copied;
copied =
cache->handle_snapshot (&Handles[2], &Entries[2],
HandlesSize - 2 - offset, offset);
count += copied;
}
debug_printf ("waiting on %u objects\n", count);
DWORD rc = WaitForMultipleObjects (count, Handles, FALSE, INFINITE);
if (rc == WAIT_FAILED)
{
printf ("Could not wait on the process handles (%ld)!\n",
GetLastError ());
exit (1);
}
int objindex = rc - WAIT_OBJECT_0;
if (objindex > 1 && objindex < count)
{
debug_printf ("Process %ld has left the building\n",
Entries[objindex]->winpid);
/* fire off the termination routines */
cache->remove_process (Entries[objindex]);
}
else if (objindex >= 0 && objindex < 2)
{
/* 0 is shutdown - do nothing */
/* 1 is a cache add event - just rebuild the object list */
}
else
{
printf
("unexpected return code from WaitForMultiple objects in process_process_param::request_loop\n");
}
}
running = false;
return 0;
}