BSD 4_4_Lite2 release
[unix-history] / usr / src / sys / sys / proc.h
index 4d47531..6e2b1ff 100644 (file)
-/*
- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+/*-
+ * Copyright (c) 1986, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  *
  *
- *     @(#)proc.h      7.5 (Berkeley) %G%
+ *     @(#)proc.h      8.15 (Berkeley) 5/19/95
  */
 
  */
 
+#ifndef _SYS_PROC_H_
+#define        _SYS_PROC_H_
+
+#include <machine/proc.h>              /* Machine-dependent proc substruct. */
+#include <sys/select.h>                        /* For struct selinfo. */
+#include <sys/queue.h>
+
 /*
  * One structure allocated per session.
  */
 struct session {
 /*
  * One structure allocated per session.
  */
 struct session {
-       struct  proc *s_leader; /* pointer to session leader */
-       int     s_count;        /* number of pgrps in session */
+       int     s_count;                /* Ref cnt; pgrps in session. */
+       struct  proc *s_leader;         /* Session leader. */
+       struct  vnode *s_ttyvp;         /* Vnode of controlling terminal. */
+       struct  tty *s_ttyp;            /* Controlling terminal. */
+       char    s_login[MAXLOGNAME];    /* Setlogin() name. */
 };
 
 /*
  * One structure allocated per process group.
  */
 struct pgrp {
 };
 
 /*
  * One structure allocated per process group.
  */
 struct pgrp {
-       struct  pgrp *pg_hforw; /* forward link in hash bucket */
-       struct  proc *pg_mem;   /* pointer to pgrp members */
-       struct  session *pg_session;    /* pointer to session */
-       pid_t   pg_id;          /* pgrp id */
-       short   pg_jobc;        /* # procs qualifying pgrp for job control */
+       LIST_ENTRY(pgrp) pg_hash;       /* Hash chain. */
+       LIST_HEAD(, proc) pg_members;   /* Pointer to pgrp members. */
+       struct  session *pg_session;    /* Pointer to session. */
+       pid_t   pg_id;                  /* Pgrp id. */
+       int     pg_jobc;        /* # procs qualifying pgrp for job control */
 };
 
 /*
 };
 
 /*
- * One structure allocated per active
- * process. It contains all data needed
- * about the process while the
- * process may be swapped out.
- * Other per process data (user.h)
- * is swapped with the process.
+ * Description of a process.
+ *
+ * This structure contains the information needed to manage a thread of
+ * control, known in UN*X as a process; it has references to substructures
+ * containing descriptions of things that the process uses, but may share
+ * with related processes.  The process structure and the substructures
+ * are always addressible except for those marked "(PROC ONLY)" below,
+ * which might be addressible only on a processor on which the process
+ * is running.
  */
 struct proc {
  */
 struct proc {
-       struct  proc *p_link;   /* linked list of running processes */
-       struct  proc *p_rlink;
-       struct  proc *p_nxt;    /* linked list of allocated proc slots */
-       struct  proc **p_prev;          /* also zombies, and free proc's */
-       struct  pte *p_addr;    /* u-area kernel map address */
-       char    p_usrpri;       /* user-priority based on p_cpu and p_nice */
-       char    p_pri;          /* priority, negative is high */
-       char    p_cpu;          /* cpu usage for scheduling */
-       char    p_stat;
-       char    p_time;         /* resident time for scheduling */
-       char    p_nice;         /* nice for cpu usage */
-       char    p_slptime;      /* time since last block */
-       char    p_cursig;
-       int     p_sig;          /* signals pending to this process */
-       int     p_sigmask;      /* current signal mask */
-       int     p_sigignore;    /* signals being ignored */
-       int     p_sigcatch;     /* signals being caught by user */
-       int     p_flag;
-       uid_t   p_uid;          /* user id, used to direct tty signals */
-       pid_t   p_pid;          /* unique process id */
-       pid_t   p_ppid;         /* process id of parent */
-       u_short p_xstat;        /* Exit status for wait */
-       struct  rusage *p_ru;   /* mbuf holding exit information */
-       short   p_poip;         /* page outs in progress */
-       short   p_szpt;         /* copy of page table size */
-       size_t  p_tsize;        /* size of text (clicks) */
-       size_t  p_dsize;        /* size of data space (clicks) */
-       size_t  p_ssize;        /* copy of stack size (clicks) */
-       size_t  p_rssize;       /* current resident set size in clicks */
-       size_t  p_maxrss;       /* copy of u.u_limit[MAXRSS] */
-       size_t  p_swrss;        /* resident set size before last swap */
-       swblk_t p_swaddr;       /* disk address of u area when swapped */
-       caddr_t p_wchan;        /* event process is awaiting */
-       struct  text *p_textp;  /* pointer to text structure */
-       struct  pte *p_p0br;    /* page table base P0BR */
-       struct  proc *p_xlink;  /* linked list of procs sharing same text */
-       short   p_cpticks;      /* ticks of cpu time */
-       float   p_pctcpu;       /* %cpu for this process during p_time */
-       short   p_ndx;          /* proc index for memall (because of vfork) */
-       short   p_idhash;       /* hashed based on p_pid for kill+exit+... */
-       struct  proc *p_pptr;   /* pointer to process structure of parent */
-       struct  proc *p_cptr;   /* pointer to youngest living child */
-       struct  proc *p_osptr;  /* pointer to older sibling processes */
-       struct  proc *p_ysptr;  /* pointer to younger siblings */
-       struct  pgrp *p_pgrp;   /* pointer to process group */
-#define p_session p_pgrp->pg_session
-#define p_pgid p_pgrp->pg_id
-       struct  proc *p_pgrpnxt; /* pointer to next process in process group */
-       struct  itimerval p_realtimer;
-       struct  quota *p_quota; /* quotas for this process */
-       int     p_traceflag;    /* kernel tracing flags (facilities) */
-       struct  vnode *p_tracep;/* trace to vnode */
-#if defined(tahoe)
-       int     p_ckey;         /* code cache key */
-       int     p_dkey;         /* data cache key */
-#endif
+       struct  proc *p_forw;           /* Doubly-linked run/sleep queue. */
+       struct  proc *p_back;
+       LIST_ENTRY(proc) p_list;        /* List of all processes. */
+
+       /* substructures: */
+       struct  pcred *p_cred;          /* Process owner's identity. */
+       struct  filedesc *p_fd;         /* Ptr to open files structure. */
+       struct  pstats *p_stats;        /* Accounting/statistics (PROC ONLY). */
+       struct  plimit *p_limit;        /* Process limits. */
+       struct  vmspace *p_vmspace;     /* Address space. */
+       struct  sigacts *p_sigacts;     /* Signal actions, state (PROC ONLY). */
+
+#define        p_ucred         p_cred->pc_ucred
+#define        p_rlimit        p_limit->pl_rlimit
+
+       int     p_flag;                 /* P_* flags. */
+       char    p_stat;                 /* S* process status. */
+       char    p_pad1[3];
+
+       pid_t   p_pid;                  /* Process identifier. */
+       LIST_ENTRY(proc) p_pglist;      /* List of processes in pgrp. */
+       struct  proc *p_pptr;           /* Pointer to parent process. */
+       LIST_ENTRY(proc) p_sibling;     /* List of sibling processes. */
+       LIST_HEAD(, proc) p_children;   /* Pointer to list of children. */
+
+/* The following fields are all zeroed upon creation in fork. */
+#define        p_startzero     p_oppid
+
+       pid_t   p_oppid;         /* Save parent pid during ptrace. XXX */
+       int     p_dupfd;         /* Sideways return value from fdopen. XXX */
+
+       /* scheduling */
+       u_int   p_estcpu;        /* Time averaged value of p_cpticks. */
+       int     p_cpticks;       /* Ticks of cpu time. */
+       fixpt_t p_pctcpu;        /* %cpu for this process during p_swtime */
+       void    *p_wchan;        /* Sleep address. */
+       char    *p_wmesg;        /* Reason for sleep. */
+       u_int   p_swtime;        /* Time swapped in or out. */
+       u_int   p_slptime;       /* Time since last blocked. */
+
+       struct  itimerval p_realtimer;  /* Alarm timer. */
+       struct  timeval p_rtime;        /* Real time. */
+       u_quad_t p_uticks;              /* Statclock hits in user mode. */
+       u_quad_t p_sticks;              /* Statclock hits in system mode. */
+       u_quad_t p_iticks;              /* Statclock hits processing intr. */
+
+       int     p_traceflag;            /* Kernel trace points. */
+       struct  vnode *p_tracep;        /* Trace to vnode. */
+
+       int     p_siglist;              /* Signals arrived but not delivered. */
+
+       struct  vnode *p_textvp;        /* Vnode of executable. */
+
+       short   p_locks;                /* DEBUG: lockmgr count of held locks */
+       short   p_simple_locks;         /* DEBUG: count of held simple locks */
+       long    p_spare[2];             /* pad to 256, avoid shifting eproc. */
+
+/* End area that is zeroed on creation. */
+#define        p_endzero       p_hash.le_next
+
+       /*
+        * Not copied, not zero'ed.
+        * Belongs after p_pid, but here to avoid shifting proc elements.
+        */
+       LIST_ENTRY(proc) p_hash;        /* Hash chain. */
+
+/* The following fields are all copied upon creation in fork. */
+#define        p_startcopy     p_sigmask
+
+       sigset_t p_sigmask;     /* Current signal mask. */
+       sigset_t p_sigignore;   /* Signals being ignored. */
+       sigset_t p_sigcatch;    /* Signals being caught by user. */
+
+       u_char  p_priority;     /* Process priority. */
+       u_char  p_usrpri;       /* User-priority based on p_cpu and p_nice. */
+       char    p_nice;         /* Process "nice" value. */
+       char    p_comm[MAXCOMLEN+1];
+
+       struct  pgrp *p_pgrp;   /* Pointer to process group. */
+
+/* End area that is copied on creation. */
+#define        p_endcopy       p_thread
+
+       void    *p_thread;      /* Id for this "thread"; Mach glue. XXX */
+       struct  user *p_addr;   /* Kernel virtual addr of u-area (PROC ONLY). */
+       struct  mdproc p_md;    /* Any machine-dependent fields. */
+
+       u_short p_xstat;        /* Exit status for wait; also stop signal. */
+       u_short p_acflag;       /* Accounting flags. */
+       struct  rusage *p_ru;   /* Exit information. XXX */
 };
 
 };
 
-#define        PIDHSZ          64
-#define        PIDHASH(pid)    ((pid) & (PIDHSZ - 1))
+#define        p_session       p_pgrp->pg_session
+#define        p_pgid          p_pgrp->pg_id
+
+/* Status values. */
+#define        SIDL    1               /* Process being created by fork. */
+#define        SRUN    2               /* Currently runnable. */
+#define        SSLEEP  3               /* Sleeping on an address. */
+#define        SSTOP   4               /* Process debugging or suspension. */
+#define        SZOMB   5               /* Awaiting collection by parent. */
+
+/* These flags are kept in p_flags. */
+#define        P_ADVLOCK       0x00001 /* Process may hold a POSIX advisory lock. */
+#define        P_CONTROLT      0x00002 /* Has a controlling terminal. */
+#define        P_INMEM         0x00004 /* Loaded into memory. */
+#define        P_NOCLDSTOP     0x00008 /* No SIGCHLD when children stop. */
+#define        P_PPWAIT        0x00010 /* Parent is waiting for child to exec/exit. */
+#define        P_PROFIL        0x00020 /* Has started profiling. */
+#define        P_SELECT        0x00040 /* Selecting; wakeup/waiting danger. */
+#define        P_SINTR         0x00080 /* Sleep is interruptible. */
+#define        P_SUGID         0x00100 /* Had set id privileges since last exec. */
+#define        P_SYSTEM        0x00200 /* System proc: no sigs, stats or swapping. */
+#define        P_TIMEOUT       0x00400 /* Timing out during sleep. */
+#define        P_TRACED        0x00800 /* Debugged process being traced. */
+#define        P_WAITED        0x01000 /* Debugging process has waited for child. */
+#define        P_WEXIT         0x02000 /* Working on exiting. */
+#define        P_EXEC          0x04000 /* Process called exec. */
+
+/* Should probably be changed into a hold count. */
+#define        P_NOSWAP        0x08000 /* Another flag to prevent swap out. */
+#define        P_PHYSIO        0x10000 /* Doing physical I/O. */
+
+/* Should be moved to machine-dependent areas. */
+#define        P_OWEUPC        0x20000 /* Owe process an addupc() call at next ast. */
+
+/*
+ * MOVE TO ucred.h?
+ *
+ * Shareable process credentials (always resident).  This includes a reference
+ * to the current user credentials as well as real and saved ids that may be
+ * used to change ids.
+ */
+struct pcred {
+       struct  ucred *pc_ucred;        /* Current credentials. */
+       uid_t   p_ruid;                 /* Real user id. */
+       uid_t   p_svuid;                /* Saved effective user id. */
+       gid_t   p_rgid;                 /* Real group id. */
+       gid_t   p_svgid;                /* Saved effective group id. */
+       int     p_refcnt;               /* Number of references. */
+};
 
 #ifdef KERNEL
 
 #ifdef KERNEL
-pid_t  pidhash[PIDHSZ];
-struct proc *pfind();
-struct pgrp *pgrphash[PIDHSZ];
-struct         pgrp *pgfind();         /* find process group by id */
-struct proc *proc, *procNPROC; /* the proc table itself */
-struct proc *freeproc, *zombproc, *allproc;
-                       /* lists of procs in various states */
-int    nproc;
-
-#define        NQS     32              /* 32 run queues */
+/*
+ * We use process IDs <= PID_MAX; PID_MAX + 1 must also fit in a pid_t,
+ * as it is used to represent "no process group".
+ */
+#define        PID_MAX         30000
+#define        NO_PID          30001
+
+#define SESS_LEADER(p) ((p)->p_session->s_leader == (p))
+#define        SESSHOLD(s)     ((s)->s_count++)
+#define        SESSRELE(s) {                                                   \
+       if (--(s)->s_count == 0)                                        \
+               FREE(s, M_SESSION);                                     \
+}
+
+#define        PIDHASH(pid)    (&pidhashtbl[(pid) & pidhash])
+extern LIST_HEAD(pidhashhead, proc) *pidhashtbl;
+extern u_long pidhash;
+
+#define        PGRPHASH(pgid)  (&pgrphashtbl[(pgid) & pgrphash])
+extern LIST_HEAD(pgrphashhead, pgrp) *pgrphashtbl;
+extern u_long pgrphash;
+
+extern struct proc *curproc;           /* Current running proc. */
+extern struct proc proc0;              /* Process slot for swapper. */
+extern int nprocs, maxproc;            /* Current and max number of procs. */
+
+LIST_HEAD(proclist, proc);
+extern struct proclist allproc;                /* List of all processes. */
+extern struct proclist zombproc;       /* List of zombie processes. */
+struct proc *initproc, *pageproc;      /* Process slots for init, pager. */
+
+#define        NQS     32                      /* 32 run queues. */
+int    whichqs;                        /* Bit mask summary of non-empty Q's. */
 struct prochd {
 struct prochd {
-       struct  proc *ph_link;  /* linked list of running processes */
+       struct  proc *ph_link;          /* Linked list of running processes. */
        struct  proc *ph_rlink;
 } qs[NQS];
        struct  proc *ph_rlink;
 } qs[NQS];
-int    whichqs;                /* bit mask summarizing non-empty qs's */
 
 
-#define SESS_LEADER(p) ((p)->p_session->s_leader == (p))
-#define PGRP_JOBC(p)   (((p)->p_pgrp != (p)->p_pptr->p_pgrp) && \
-                       ((p)->p_session == (p)->p_pptr->p_session))
-#endif
-
-/* stat codes */
-#define        SSLEEP  1               /* awaiting an event */
-#define        SWAIT   2               /* (abandoned state) */
-#define        SRUN    3               /* running */
-#define        SIDL    4               /* intermediate state in process creation */
-#define        SZOMB   5               /* intermediate state in process termination */
-#define        SSTOP   6               /* process being traced */
-
-/* flag codes */
-#define        SLOAD   0x0000001       /* in core */
-#define        SSYS    0x0000002       /* swapper or pager process */
-#define        SLOCK   0x0000004       /* process being swapped out */
-#define        SSWAP   0x0000008       /* save area flag */
-#define        STRC    0x0000010       /* process is being traced */
-#define        SWTED   0x0000020       /* another tracing flag */
-#define        SULOCK  0x0000040       /* user settable lock in core */
-#define        SPAGE   0x0000080       /* process in page wait state */
-#define        SKEEP   0x0000100       /* another flag to prevent swap out */
-#define        SOMASK  0x0000200       /* restore old mask after taking signal */
-#define        SWEXIT  0x0000400       /* working on exiting */
-#define        SPHYSIO 0x0000800       /* doing physical i/o (bio.c) */
-#define        SVFORK  0x0001000       /* process resulted from vfork() */
-#define        SVFDONE 0x0002000       /* another vfork flag */
-#define        SNOVM   0x0004000       /* no vm, parent in a vfork() */
-#define        SPAGV   0x0008000       /* init data space on demand, from vnode */
-#define        SSEQL   0x0010000       /* user warned of sequential vm behavior */
-#define        SUANOM  0x0020000       /* user warned of random vm behavior */
-#define        STIMO   0x0040000       /* timing out during sleep */
-/* was SDETACH */
-#define        SOUSIG  0x0100000       /* using old signal mechanism */
-#define        SOWEUPC 0x0200000       /* owe process an addupc() call at next ast */
-#define        SSEL    0x0400000       /* selecting; wakeup/waiting danger */
-#define        SLOGIN  0x0800000       /* a login process (legit child of init) */
-#define        SPTECHG 0x1000000       /* pte's for process have changed */
-#define SKTR   0x2000000       /* pass kernel tracing flags to children */
-#define SEXEC  0x8000000       /* process called exec */
+struct proc *pfind __P((pid_t));       /* Find process by id. */
+struct pgrp *pgfind __P((pid_t));      /* Find process group by id. */
+
+int    chgproccnt __P((uid_t uid, int diff));
+int    enterpgrp __P((struct proc *p, pid_t pgid, int mksess));
+void   fixjobc __P((struct proc *p, struct pgrp *pgrp, int entering));
+int    inferior __P((struct proc *p));
+int    leavepgrp __P((struct proc *p));
+void   mi_switch __P((void));
+void   pgdelete __P((struct pgrp *pgrp));
+void   procinit __P((void));
+void   resetpriority __P((struct proc *));
+void   setrunnable __P((struct proc *));
+void   setrunqueue __P((struct proc *));
+void   sleep __P((void *chan, int pri));
+int    tsleep __P((void *chan, int pri, char *wmesg, int timo));
+void   unsleep __P((struct proc *));
+void   wakeup __P((void *chan));
+#endif /* KERNEL */
+#endif /* !_SYS_PROC_H_ */