* include/cygwin/version.h: Bump DLL minor version number to 5 due to all of

the changes below.  Redefine process structure to avoid a fixed size table.
Redefine pinfo/_pinfo classes.  Use these throughout.
* dcrt0.cc (dll_crt0_1): Accomodate set_myself argument change.
(__api_fatal): Accomodate _pinfo::record_death argument change.
* exceptions.cc (really_exit): Ditto.
(sig_handle_tty_stop): Use pinfo constructor to access process info.
(events_init): Don't create pinfo_mutex since it is no longer required.
* external.cc (fillout_pinfo): Use winpids class to iterate over all system
pids.
(cygwin_internal): lock_pinfo_for_update and unlock_pinfo are now noops.
* fhandler_termios.cc (fhandler_termios::set_ctty): Use pinfo constructor to
access process info.
* fork.cc (fork): Reorganize to initialize child info after the child has
started since that is when we know the child's winpid, which is necessary to
allocate the pinfo shared memory.
* mmap.cc (recreate_mmaps_after_fork): Change arg type to _pinfo.
* pinfo.cc: Rename pinfo methods to _pinfo throughout.  Eliminate pinfo_list
stuff.
(set_myself): Accept a pid argument now.  Call pinfo initializer to initialize
myself.  Detect when this is an "execed" process and create an "indirect" pid
block.
(pinfo_init): Accomodate set_myself arg change.
(procinfo): Remove.
(pinfo::lock_pinfo): Remove.
(pinfo::unlock_pinfo): Remove.
(pinfo::init): New method.  Allocates shared memory space for process pinfo
structure.
(pinfo::record_death): Don't call locking functions.
(cygwin_winpid_to_pid): Simplify by using new pinfo constructor.
(EnumProcessesW95): New function for iterating over processes on Windows 95.
(winpids::winpids): New constructor for winpids class.  Sets up a list of
process ids.
(enum_init): Initialize w95/wnt pid enumerators.
* shared.cc (shared-info::initialize): Remove pid initialization.
* shared.h: Move pinfo stuff into pinfo.h.
(class shared_info): Remove pinfo_list element.
* signal.cc (kill_worker): Use pinfo constructor to access process info.
(kill_pgrp): Ditto.  Use winpids methods to access list of processes.
* sigproc.cc: Throughout, modify to use _pinfo where appropriate.
(proc_exists (pid_t)): New function.  Determines if a process exists based on
the pid.
(proc_exists (_pinfo *p): Use new proc_exists function above.
(proc_subproc): Copy pinfo stuff around rather than _pinfo pointers.  Try to be
careful about releasing shared memory when we don't need it anymore.  Remove
pinfo locks.
(remove_zombies): Remove pinfo memory when zombie is going away.
* sigproc.h: Reflect _pinfo/pinfo changes in sigproc.cc.
* spawn.cc (spawn_guts): Eliminate pinfo *child argument.  Reorganize to only
initialize child pinfo after process has been started and we know the windows
pid.
(_spawnve): Reflect spawn_guts changes.
* syscalls.cc (setpgid): Use pinfo constructor to access process info.
(getpgid): Ditto.
(internal_getlogin): Use _pinfo.
* winsup.h: Eliminate pinfo_mutex.  Eliminate spawn_guts declaration since it
is static now.  Reflect set_myself argument change.
* include/sys/cygwin.h: Add some PID_* enums to accomodate new pinfo stuff.
* include/cygwin/version.h: Update minor version for cygdrive changes below.

1 files changed, 168 insertions, 0 deletions

diff --git a/winsup/cygwin/pinfo.h b/winsup/cygwin/pinfo.h
new file mode 100644
index 000000000..4d9d71afd
--- /dev/null
+++ b/winsup/cygwin/pinfo.h
@@ -0,0 +1,168 @@
+/******** Process Table ********/
+
+/* Signal constants (have to define them here, unfortunately) */
+
+enum
+{
+  __SIGFLUSH	    = -2,
+  __SIGSTRACE	    = -1,
+  __SIGCHILDSTOPPED =  0,
+  __SIGOFFSET	    =  3
+};
+
+#define PSIZE 1024
+class _pinfo
+{
+public:
+  /* Cygwin pid */
+  pid_t pid;
+
+  /* Various flags indicating the state of the process.  See PID_
+     constants below. */
+  DWORD process_state;
+
+  /* If hProcess is set, it's because it came from a
+     CreateProcess call.  This means it's process relative
+     to the thing which created the process.  That's ok because
+     we only use this handle from the parent. */
+  HANDLE hProcess;
+
+#define PINFO_REDIR_SIZE ((DWORD) &(((_pinfo *)NULL)->hProcess) + sizeof (DWORD))
+
+  /* Parent process id.  */
+  pid_t ppid;
+
+  /* dwProcessId contains the processid used for sending signals.  It
+   * will be reset in a child process when it is capable of receiving
+   * signals.
+   */
+  DWORD dwProcessId;
+
+  /* Used to spawn a child for fork(), among other things. */
+  char progname[MAX_PATH];
+
+  HANDLE parent_alive;
+
+  /* User information.
+     The information is derived from the GetUserName system call,
+     with the name looked up in /etc/passwd and assigned a default value
+     if not found.  This data resides in the shared data area (allowing
+     tasks to store whatever they want here) so it's for informational
+     purposes only. */
+  uid_t uid;	    /* User ID */
+  gid_t gid;	    /* Group ID */
+  pid_t pgid;	    /* Process group ID */
+  pid_t sid;	    /* Session ID */
+  int ctty;	    /* Control tty */
+  mode_t umask;
+  char username[MAX_USER_NAME]; /* user's name */
+
+  /* Extendend user information.
+     The information is derived from the internal_getlogin call
+     when on a NT system. */
+  PSID psid;        /* user's SID */
+  char sidbuf[MAX_SID_LEN];  /* buffer for user's SID */
+  char logsrv[MAX_HOST_NAME]; /* Logon server, may be FQDN */
+  char domain[MAX_COMPUTERNAME_LENGTH+1]; /* Logon domain of the user */
+
+  /* token is needed if sexec should be called. It can be set by a call
+     to `set_impersonation_token()'. */
+  HANDLE token;
+  BOOL impersonated;
+  uid_t orig_uid;        /* Remains intact also after impersonation */
+  uid_t orig_gid;        /* Ditto */
+  uid_t real_uid;        /* Remains intact on seteuid, replaced by setuid */
+  gid_t real_gid;	 /* Ditto */
+
+  /* Filled when chroot() is called by the process or one of it's parents.
+     Saved without trailing backslash. */
+  char root[MAX_PATH+1];
+  size_t rootlen;
+
+  /* Non-zero if process was stopped by a signal. */
+  char stopsig;
+
+  struct sigaction& getsig (int);
+  void copysigs (_pinfo* );
+  sigset_t& getsigmask ();
+  void setsigmask (sigset_t);
+  LONG* getsigtodo (int);
+  HANDLE getthread2signal ();
+  void setthread2signal (void *);
+
+  /* Resources used by process. */
+  long start_time;
+  struct rusage rusage_self;
+  struct rusage rusage_children;
+
+private:
+  struct sigaction sigs[NSIG];
+  sigset_t sig_mask;		/* one set for everything to ignore. */
+  LONG _sigtodo[NSIG + __SIGOFFSET];
+  ThreadItem* thread2signal;  // NULL means means thread any other means a pthread
+
+public:
+  /* Pointer to mmap'ed areas for this process.  Set up by fork. */
+  void *mmap_ptr;
+
+  void record_death ();
+};
+
+class pinfo
+{
+  HANDLE h;
+  _pinfo *child;
+  int destroy;
+public:
+  void init (pid_t n, DWORD create = 0);
+  pinfo () {}
+  pinfo (_pinfo *x): child (x) {}
+  pinfo (pid_t n) {init (n);}
+  pinfo (pid_t n, int create) {init (n, create);}
+  void release ()
+  {
+    if (h)
+      {
+	UnmapViewOfFile (child);
+	CloseHandle (h);
+	h = NULL;
+      }
+  }
+  ~pinfo ()
+  {
+    if (destroy && child)
+      release ();
+  }
+    
+  _pinfo *operator -> () const {return child;}
+  int operator == (pinfo *x) const {return x->child == child;}
+  int operator == (pinfo &x) const {return x.child == child;}
+  int operator == (void *x) const {return child == x;}
+  int operator == (int x) const {return (int) child == (int) x;}
+  int operator == (char *x) const {return (char *) child == x;}
+  _pinfo *operator * () const {return child;}
+  operator _pinfo * () const {return child;}
+  void remember () {destroy = 0; proc_subproc (PROC_ADDCHILD, (DWORD) this);}
+};
+
+#define ISSTATE(p, f)	(!!((p)->process_state & f))
+#define NOTSTATE(p, f)	(!((p)->process_state & f))
+
+class winpids
+{
+  DWORD pidlist[16384];
+public:
+  DWORD npids;
+  void reset () { npids = 0; }
+  winpids (int) { reset (); }
+  winpids () { init (); };
+  void init ();
+  int operator [] (int i) const {return pidlist[i];}
+};
+
+extern __inline pid_t
+cygwin_pid (pid_t pid)
+{
+  return (pid_t) (os_being_run == winNT) ? pid : -(int) pid;
+}
+void __stdcall pinfo_init (PBYTE);