1 files changed, 124 insertions, 44 deletions

diff --git a/winsup/cygwin/include/cygwin/cygserver_process.h b/winsup/cygwin/include/cygwin/cygserver_process.h
index 4a49212b2..25c634e9e 100755
--- a/winsup/cygwin/include/cygwin/cygserver_process.h
+++ b/winsup/cygwin/include/cygwin/cygserver_process.h
@@ -1,84 +1,164 @@
 /* cygserver_process.h
 
-   Copyright 2001 Red Hat Inc.
+   Copyright 2001, 2002 Red Hat Inc.
 
    Written by Robert Collins <rbtcollins@hotmail.com>
 
-   This file is part of Cygwin.
+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. */
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
 
 #ifndef _CYGSERVER_PROCESS_
 #define _CYGSERVER_PROCESS_
 
-/* needs threaded_queue.h */
+#include <assert.h>
 
-class process_cleanup:public queue_request
+#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 ();
-  process_cleanup (class process *nprocess) : theprocess (nprocess) {};
+
 private:
-  class process * theprocess;
+  class process *const _process;
 };
 
-class process_process_param:public queue_process_param
-{
-  class process_cache *cache;
-public:
-  DWORD request_loop ();
-  process_process_param ():queue_process_param (true) {};
-};
+class process;
 
 class cleanup_routine
 {
+  friend class process;
+
 public:
-  cleanup_routine () : next (NULL) {};
-  class cleanup_routine * next;
+  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 (long winpid);
+  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:
-  HANDLE handle ();
-  long winpid;
-  process (long);
+  process (pid_t cygpid, DWORD winpid);
   ~process ();
-  DWORD exit_code ();
-  class process * next;
-  long refcount;
-  bool add_cleanup_routine (class cleanup_routine *);
-  void cleanup ();
+
+  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;
-  volatile long cleaning_up;
-  class cleanup_routine *head;
-  HANDLE thehandle;
-  DWORD _exit_status;
+  CRITICAL_SECTION _access;
+  class process *_next;
+
+  DWORD check_exit_code ();
+  void cleanup ();
 };
 
-class process_cache:public threaded_queue
+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);
-  virtual ~ process_cache ();
-  class process *process (long);
-  /* remove a process from the cache */
-  int handle_snapshot (HANDLE *, class process **, ssize_t, int);
-  void remove_process (class process *);
-  /* threaded_queue methods */
-  void process_requests ();
-  HANDLE cache_add_trigger;
+  ~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:
-  virtual void add_task (class process *);
-  class process *head;
-  CRITICAL_SECTION cache_write_access;
+  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 /* _CYGSERVER_PROCESS_ */