diff options
| author | Christopher Faylor <me@cgf.cx> | 2000-07-29 16:24:59 +0000 |
|---|---|---|
| committer | Christopher Faylor <me@cgf.cx> | 2000-07-29 16:24:59 +0000 |
| commit | 84c7d4093270dc07de4531ab6648a12daaff77c3 (patch) | |
| tree | 067ed4cf0bffd057a63b2f472bcab39854f86c17 /winsup/cygwin/pinfo.h | |
| parent | 53211514a0466b7e29f6f53c11b769befddfdfa6 (diff) | |
| download | newlib-84c7d4093270dc07de4531ab6648a12daaff77c3.zip newlib-84c7d4093270dc07de4531ab6648a12daaff77c3.tar.gz newlib-84c7d4093270dc07de4531ab6648a12daaff77c3.tar.bz2 | |
* 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.
Diffstat (limited to 'winsup/cygwin/pinfo.h')
| -rw-r--r-- | winsup/cygwin/pinfo.h | 168 |
1 files changed, 168 insertions, 0 deletions
diff --git a/winsup/cygwin/pinfo.h b/winsup/cygwin/pinfo.h new file mode 100644 index 0000000..4d9d71a --- /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); |