f504530d9f
real uid, saved uid, real gid, and saved gid to ucred, as well as the
pcred->pc_uidinfo, which was associated with the real uid, only rename
it to cr_ruidinfo so as not to conflict with cr_uidinfo, which
corresponds to the effective uid.
o Remove p_cred from struct proc; add p_ucred to struct proc, replacing
original macro that pointed.
p->p_ucred to p->p_cred->pc_ucred.
o Universally update code so that it makes use of ucred instead of pcred,
p->p_ucred instead of p->p_pcred, cr_ruidinfo instead of p_uidinfo,
cr_{r,sv}{u,g}id instead of p_*, etc.
o Remove pcred0 and its initialization from init_main.c; initialize
cr_ruidinfo there.
o Restruction many credential modification chunks to always crdup while
we figure out locking and optimizations; generally speaking, this
means moving to a structure like this:
newcred = crdup(oldcred);
...
p->p_ucred = newcred;
crfree(oldcred);
It's not race-free, but better than nothing. There are also races
in sys_process.c, all inter-process authorization, fork, exec, and
exit.
o Remove sigio->sio_ruid since sigio->sio_ucred now contains the ruid;
remove comments indicating that the old arrangement was a problem.
o Restructure exec1() a little to use newcred/oldcred arrangement, and
use improved uid management primitives.
o Clean up exit1() so as to do less work in credential cleanup due to
pcred removal.
o Clean up fork1() so as to do less work in credential cleanup and
allocation.
o Clean up ktrcanset() to take into account changes, and move to using
suser_xxx() instead of performing a direct uid==0 comparision.
o Improve commenting in various kern_prot.c credential modification
calls to better document current behavior. In a couple of places,
current behavior is a little questionable and we need to check
POSIX.1 to make sure it's "right". More commenting work still
remains to be done.
o Update credential management calls, such as crfree(), to take into
account new ruidinfo reference.
o Modify or add the following uid and gid helper routines:
change_euid()
change_egid()
change_ruid()
change_rgid()
change_svuid()
change_svgid()
In each case, the call now acts on a credential not a process, and as
such no longer requires more complicated process locking/etc. They
now assume the caller will do any necessary allocation of an
exclusive credential reference. Each is commented to document its
reference requirements.
o CANSIGIO() is simplified to require only credentials, not processes
and pcreds.
o Remove lots of (p_pcred==NULL) checks.
o Add an XXX to authorization code in nfs_lock.c, since it's
questionable, and needs to be considered carefully.
o Simplify posix4 authorization code to require only credentials, not
processes and pcreds. Note that this authorization, as well as
CANSIGIO(), needs to be updated to use the p_cansignal() and
p_cansched() centralized authorization routines, as they currently
do not take into account some desirable restrictions that are handled
by the centralized routines, as well as being inconsistent with other
similar authorization instances.
o Update libkvm to take these changes into account.
Obtained from: TrustedBSD Project
Reviewed by: green, bde, jhb, freebsd-arch, freebsd-audit
553 lines
20 KiB
C
553 lines
20 KiB
C
/*-
|
|
* 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 8.15 (Berkeley) 5/19/95
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#ifndef _SYS_PROC_H_
|
|
#define _SYS_PROC_H_
|
|
|
|
#include <sys/callout.h> /* For struct callout. */
|
|
#include <sys/event.h> /* For struct klist. */
|
|
#include <sys/filedesc.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/priority.h>
|
|
#include <sys/rtprio.h> /* XXX */
|
|
#include <sys/runq.h>
|
|
#include <sys/signal.h>
|
|
#ifndef _KERNEL
|
|
#include <sys/time.h> /* For structs itimerval, timeval. */
|
|
#endif
|
|
#include <sys/ucred.h>
|
|
#include <machine/proc.h> /* Machine-dependent proc substruct. */
|
|
|
|
/*
|
|
* One structure allocated per session.
|
|
*/
|
|
struct 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. */
|
|
pid_t s_sid; /* Session ID. */
|
|
/* Setlogin() name: */
|
|
char s_login[roundup(MAXLOGNAME, sizeof(long))];
|
|
};
|
|
|
|
/*
|
|
* One structure allocated per process group.
|
|
*/
|
|
struct pgrp {
|
|
LIST_ENTRY(pgrp) pg_hash; /* Hash chain. */
|
|
LIST_HEAD(, proc) pg_members; /* Pointer to pgrp members. */
|
|
struct session *pg_session; /* Pointer to session. */
|
|
struct sigiolst pg_sigiolst; /* List of sigio sources. */
|
|
pid_t pg_id; /* Pgrp id. */
|
|
int pg_jobc; /* # procs qualifying pgrp for job control */
|
|
};
|
|
|
|
struct procsig {
|
|
sigset_t ps_sigignore; /* Signals being ignored. */
|
|
sigset_t ps_sigcatch; /* Signals being caught by user. */
|
|
int ps_flag;
|
|
struct sigacts *ps_sigacts; /* Signal actions, state. */
|
|
int ps_refcnt;
|
|
};
|
|
|
|
#define PS_NOCLDWAIT 0x0001 /* No zombies if child dies */
|
|
#define PS_NOCLDSTOP 0x0002 /* No SIGCHLD when children stop. */
|
|
|
|
/*
|
|
* pasleep structure, used by asleep() syscall to hold requested priority
|
|
* and timeout values for await().
|
|
*/
|
|
struct pasleep {
|
|
int as_priority; /* Async priority. */
|
|
int as_timo; /* Async timeout. */
|
|
};
|
|
|
|
/*
|
|
* pargs, used to hold a copy of the command line, if it had a sane length.
|
|
*/
|
|
struct pargs {
|
|
u_int ar_ref; /* Reference count. */
|
|
u_int ar_length; /* Length. */
|
|
u_char ar_args[0]; /* Arguments. */
|
|
};
|
|
|
|
/*-
|
|
* 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 addressable except for those marked "(CPU)" below,
|
|
* which might be addressable only on a processor on which the process
|
|
* is running.
|
|
*
|
|
* Below is a key of locks used to protect each member of struct proc. The
|
|
* lock is indicated by a reference to a specific character in parens in the
|
|
* associated comment.
|
|
* * - not yet protected
|
|
* a - only touched by curproc or parent during fork/wait
|
|
* b - created at fork, never changes
|
|
* (exception aiods switch vmspaces, but they are also
|
|
* marked 'P_SYSTEM' so hopefully it will be left alone)
|
|
* c - locked by proc mtx
|
|
* d - locked by allproc_lock lock
|
|
* e - locked by proctree_lock lock
|
|
* f - session mtx
|
|
* g - process group mtx
|
|
* h - callout_lock mtx
|
|
* i - by curproc or the master session mtx
|
|
* j - locked by sched_lock mtx
|
|
* k - either by curproc or a lock which prevents the lock from
|
|
* going away, such as (d,e)
|
|
* l - the attaching proc or attaching proc parent
|
|
* m - Giant
|
|
* n - not locked, lazy
|
|
*
|
|
* If the locking key specifies two identifiers (for example, p_pptr) then
|
|
* either lock is sufficient for read access, but both locks must be held
|
|
* for write access.
|
|
*/
|
|
struct ithd;
|
|
struct nlminfo;
|
|
|
|
struct proc {
|
|
TAILQ_ENTRY(proc) p_procq; /* (j) Run/mutex queue. */
|
|
TAILQ_ENTRY(proc) p_slpq; /* (j) Sleep queue. */
|
|
LIST_ENTRY(proc) p_list; /* (d) List of all processes. */
|
|
|
|
/* substructures: */
|
|
struct ucred *p_ucred; /* (c + k) Process owner's identity. */
|
|
struct filedesc *p_fd; /* (b) Ptr to open files structure. */
|
|
struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */
|
|
struct plimit *p_limit; /* (m) Process limits. */
|
|
struct vm_object *p_upages_obj;/* (a) Upages object. */
|
|
struct procsig *p_procsig; /* (c) Signal actions, state (CPU). */
|
|
#define p_sigacts p_procsig->ps_sigacts
|
|
#define p_sigignore p_procsig->ps_sigignore
|
|
#define p_sigcatch p_procsig->ps_sigcatch
|
|
|
|
#define p_rlimit p_limit->pl_rlimit
|
|
|
|
int p_flag; /* (c) P_* flags. */
|
|
int p_sflag; /* (j) PS_* flags. */
|
|
int p_stat; /* (j) S* process status. */
|
|
|
|
pid_t p_pid; /* (b) Process identifier. */
|
|
LIST_ENTRY(proc) p_hash; /* (d) Hash chain. */
|
|
LIST_ENTRY(proc) p_pglist; /* (c) List of processes in pgrp. */
|
|
struct proc *p_pptr; /* (c + e) Pointer to parent process. */
|
|
LIST_ENTRY(proc) p_sibling; /* (e) List of sibling processes. */
|
|
LIST_HEAD(, proc) p_children; /* (e) Pointer to list of children. */
|
|
|
|
/* The following fields are all zeroed upon creation in fork. */
|
|
#define p_startzero p_oppid
|
|
|
|
pid_t p_oppid; /* (c + e) Save parent pid during ptrace. XXX */
|
|
int p_dupfd; /* (c) Sideways ret value from fdopen. XXX */
|
|
struct vmspace *p_vmspace; /* (b) Address space. */
|
|
|
|
/* scheduling */
|
|
u_int p_estcpu; /* (j) Time averaged value of p_cpticks. */
|
|
int p_cpticks; /* (j) Ticks of cpu time. */
|
|
fixpt_t p_pctcpu; /* (j) %cpu during p_swtime. */
|
|
struct callout p_slpcallout; /* (h) Callout for sleep. */
|
|
void *p_wchan; /* (j) Sleep address. */
|
|
const char *p_wmesg; /* (j) Reason for sleep. */
|
|
u_int p_swtime; /* (j) Time swapped in or out. */
|
|
u_int p_slptime; /* (j) Time since last blocked. */
|
|
|
|
struct callout p_itcallout; /* (h) Interval timer callout. */
|
|
struct itimerval p_realtimer; /* (h?/k?) Alarm timer. */
|
|
u_int64_t p_runtime; /* (j) Real time in microsec. */
|
|
u_int64_t p_uu; /* (j) Previous user time in microsec. */
|
|
u_int64_t p_su; /* (j) Previous system time in microsec. */
|
|
u_int64_t p_iu; /* (j) Previous interrupt time in microsec. */
|
|
u_int64_t p_uticks; /* (j) Statclock hits in user mode. */
|
|
u_int64_t p_sticks; /* (j) Statclock hits in system mode. */
|
|
u_int64_t p_iticks; /* (j) Statclock hits processing intr. */
|
|
|
|
int p_traceflag; /* (j?) Kernel trace points. */
|
|
struct vnode *p_tracep; /* (j?) Trace to vnode. */
|
|
|
|
sigset_t p_siglist; /* (c) Signals arrived but not delivered. */
|
|
|
|
struct vnode *p_textvp; /* (b) Vnode of executable. */
|
|
|
|
struct mtx p_mtx; /* (k) Lock for this struct. */
|
|
u_int p_spinlocks; /* (k) Count of held spin locks. */
|
|
char p_lock; /* (c) Process lock (prevent swap) count. */
|
|
u_char p_oncpu; /* (j) Which cpu we are on. */
|
|
u_char p_lastcpu; /* (j) Last cpu we were on. */
|
|
char p_rqindex; /* (j) Run queue index. */
|
|
|
|
short p_locks; /* (*) DEBUG: lockmgr count of held locks */
|
|
u_int p_stops; /* (c) Procfs event bitmask. */
|
|
u_int p_stype; /* (c) Procfs stop event type. */
|
|
char p_step; /* (c) Procfs stop *once* flag. */
|
|
u_char p_pfsflags; /* (c) Procfs flags. */
|
|
char p_pad3[2]; /* Alignment. */
|
|
register_t p_retval[2]; /* (k) Syscall aux returns. */
|
|
struct sigiolst p_sigiolst; /* (c) List of sigio sources. */
|
|
int p_sigparent; /* (c) Signal to parent on exit. */
|
|
sigset_t p_oldsigmask; /* (c) Saved mask from before sigpause. */
|
|
int p_sig; /* (n) For core dump/debugger XXX. */
|
|
u_long p_code; /* (n) For core dump/debugger XXX. */
|
|
struct klist p_klist; /* (c) Knotes attached to this process. */
|
|
struct lock_list_entry *p_sleeplocks; /* (k) Held sleep locks. */
|
|
struct mtx *p_blocked; /* (j) Mutex process is blocked on. */
|
|
const char *p_mtxname; /* (j) Name of mutex blocked on. */
|
|
LIST_HEAD(, mtx) p_contested; /* (j) Contested locks. */
|
|
|
|
struct nlminfo *p_nlminfo; /* (?) only used by/for lockd */
|
|
void *p_aioinfo; /* (c) ASYNC I/O info. */
|
|
struct ithd *p_ithd; /* (b) For interrupt threads only. */
|
|
int p_intr_nesting_level; /* (k) Interrupt recursion. */
|
|
|
|
/* End area that is zeroed on creation. */
|
|
#define p_endzero p_startcopy
|
|
|
|
/* The following fields are all copied upon creation in fork. */
|
|
#define p_startcopy p_sigmask
|
|
|
|
sigset_t p_sigmask; /* (c) Current signal mask. */
|
|
stack_t p_sigstk; /* (c) Stack pointer and on-stack flag. */
|
|
|
|
int p_magic; /* (b) Magic number. */
|
|
struct priority p_pri; /* (j) Process priority. */
|
|
char p_nice; /* (j?/k?) Process "nice" value. */
|
|
char p_comm[MAXCOMLEN + 1]; /* (b) Process name. */
|
|
|
|
struct pgrp *p_pgrp; /* (e?/c?) Pointer to process group. */
|
|
struct sysentvec *p_sysent; /* (b) System call dispatch information. */
|
|
struct pargs *p_args; /* (c + k) Process arguments. */
|
|
|
|
/* End area that is copied on creation. */
|
|
#define p_endcopy p_addr
|
|
|
|
struct user *p_addr; /* (k) Kernel virtual addr of u-area (CPU). */
|
|
struct mdproc p_md; /* (k) Any machine-dependent fields. */
|
|
|
|
u_short p_xstat; /* (c) Exit status for wait; also stop sig. */
|
|
u_short p_acflag; /* (c) Accounting flags. */
|
|
struct rusage *p_ru; /* (a) Exit information. XXX */
|
|
|
|
struct proc *p_peers; /* (c) */
|
|
struct proc *p_leader; /* (c) */
|
|
struct pasleep p_asleep; /* (k) Used by asleep()/await(). */
|
|
void *p_emuldata; /* (c) Emulator state data. */
|
|
};
|
|
|
|
#define p_session p_pgrp->pg_session
|
|
#define p_pgid p_pgrp->pg_id
|
|
|
|
#define NOCPU 0xff /* For p_oncpu when we aren't on a CPU. */
|
|
|
|
/* Status values (p_stat). */
|
|
#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. */
|
|
#define SWAIT 6 /* Waiting for interrupt. */
|
|
#define SMTX 7 /* Blocked on a mutex. */
|
|
|
|
/* These flags are kept in p_flag. */
|
|
#define P_ADVLOCK 0x00001 /* Process may hold a POSIX advisory lock. */
|
|
#define P_CONTROLT 0x00002 /* Has a controlling terminal. */
|
|
#define P_KTHREAD 0x00004 /* Kernel thread. */
|
|
#define P_NOLOAD 0x00008 /* Ignore during load avg calculations. */
|
|
#define P_PPWAIT 0x00010 /* Parent is waiting for child to exec/exit. */
|
|
#define P_SELECT 0x00040 /* Selecting; wakeup/waiting danger. */
|
|
#define P_SUGID 0x00100 /* Had set id privileges since last exec. */
|
|
#define P_SYSTEM 0x00200 /* System proc: no sigs, stats or swapping. */
|
|
#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 be moved to machine-dependent areas. */
|
|
|
|
#define P_BUFEXHAUST 0x100000 /* Dirty buffers flush is in progress. */
|
|
#define P_COWINPROGRESS 0x400000 /* Snapshot copy-on-write in progress. */
|
|
|
|
#define P_DEADLKTREAT 0x800000 /* Lock aquisition - deadlock treatment. */
|
|
|
|
#define P_JAILED 0x1000000 /* Process is in jail. */
|
|
#define P_OLDMASK 0x2000000 /* Need to restore mask after suspend. */
|
|
#define P_ALTSTACK 0x4000000 /* Have alternate signal stack. */
|
|
|
|
/* These flags are kept in p_sflag and are protected with sched_lock. */
|
|
#define PS_INMEM 0x00001 /* Loaded into memory. */
|
|
#define PS_OWEUPC 0x00002 /* Owe process an addupc() call at next ast. */
|
|
#define PS_PROFIL 0x00004 /* Has started profiling. */
|
|
#define PS_SINTR 0x00008 /* Sleep is interruptible. */
|
|
#define PS_TIMEOUT 0x00010 /* Timing out during sleep. */
|
|
#define PS_ALRMPEND 0x00020 /* Pending SIGVTALRM needs to be posted. */
|
|
#define PS_PROFPEND 0x00040 /* Pending SIGPROF needs to be posted. */
|
|
#define PS_CVWAITQ 0x00080 /* Proces is on a cv_waitq (not slpq). */
|
|
#define PS_SWAPINREQ 0x00100 /* Swapin request due to wakeup. */
|
|
#define PS_SWAPPING 0x00200 /* Process is being swapped. */
|
|
#define PS_ASTPENDING 0x00400 /* Process has a pending ast. */
|
|
#define PS_NEEDRESCHED 0x00800 /* Process needs to yield. */
|
|
|
|
#define P_MAGIC 0xbeefface
|
|
|
|
#define P_CAN_SEE 1
|
|
#define P_CAN_SCHED 3
|
|
#define P_CAN_DEBUG 4
|
|
|
|
#ifdef _KERNEL
|
|
|
|
#ifdef MALLOC_DECLARE
|
|
MALLOC_DECLARE(M_PARGS);
|
|
MALLOC_DECLARE(M_SESSION);
|
|
MALLOC_DECLARE(M_SUBPROC);
|
|
MALLOC_DECLARE(M_ZOMBIE);
|
|
#endif
|
|
|
|
static __inline int
|
|
sigonstack(size_t sp)
|
|
{
|
|
register struct proc *p = curproc;
|
|
|
|
return ((p->p_flag & P_ALTSTACK) ?
|
|
#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
|
|
((p->p_sigstk.ss_size == 0) ? (p->p_sigstk.ss_flags & SS_ONSTACK) :
|
|
((sp - (size_t)p->p_sigstk.ss_sp) < p->p_sigstk.ss_size))
|
|
#else
|
|
((sp - (size_t)p->p_sigstk.ss_sp) < p->p_sigstk.ss_size)
|
|
#endif
|
|
: 0);
|
|
}
|
|
|
|
/*
|
|
* Preempt the current process if in interrupt from user mode,
|
|
* or after the current trap/syscall if in system mode.
|
|
*/
|
|
#define need_resched(p) do { \
|
|
mtx_assert(&sched_lock, MA_OWNED); \
|
|
(p)->p_sflag |= PS_NEEDRESCHED; \
|
|
} while (0)
|
|
|
|
#define resched_wanted(p) ((p)->p_sflag & PS_NEEDRESCHED)
|
|
|
|
#define clear_resched(p) do { \
|
|
mtx_assert(&sched_lock, MA_OWNED); \
|
|
(p)->p_sflag &= ~PS_NEEDRESCHED; \
|
|
} while (0)
|
|
|
|
/*
|
|
* Schedule an Asynchronous System Trap (AST) on return to user mode.
|
|
*/
|
|
#define aston(p) do { \
|
|
mtx_assert(&sched_lock, MA_OWNED); \
|
|
(p)->p_sflag |= PS_ASTPENDING; \
|
|
} while (0)
|
|
|
|
#define astpending(p) ((p)->p_sflag & PS_ASTPENDING)
|
|
|
|
#define astoff(p) do { \
|
|
mtx_assert(&sched_lock, MA_OWNED); \
|
|
(p)->p_sflag &= ~PS_ASTPENDING; \
|
|
} while (0)
|
|
|
|
/*
|
|
* Notify the current process (p) that it has a signal pending,
|
|
* process as soon as possible.
|
|
*/
|
|
#define signotify(p) aston(p)
|
|
|
|
/* Handy macro to determine if p1 can mangle p2. */
|
|
#define PRISON_CHECK(p1, p2) \
|
|
((p1)->p_prison == NULL || (p1)->p_prison == (p2)->p_prison)
|
|
|
|
/*
|
|
* 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 99999
|
|
#define NO_PID 100000
|
|
|
|
#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 STOPEVENT(p, e, v) do { \
|
|
PROC_LOCK(p); \
|
|
_STOPEVENT((p), (e), (v)); \
|
|
PROC_UNLOCK(p); \
|
|
} while (0)
|
|
#define _STOPEVENT(p, e, v) do { \
|
|
PROC_LOCK_ASSERT(p, MA_OWNED); \
|
|
if ((p)->p_stops & (e)) { \
|
|
stopevent((p), (e), (v)); \
|
|
} \
|
|
} while (0)
|
|
|
|
/* Lock and unlock a process. */
|
|
#define PROC_LOCK(p) mtx_lock(&(p)->p_mtx)
|
|
#define PROC_TRYLOCK(p) mtx_trylock(&(p)->p_mtx)
|
|
#define PROC_UNLOCK(p) mtx_unlock(&(p)->p_mtx)
|
|
#define PROC_UNLOCK_NOSWITCH(p) \
|
|
mtx_unlock_flags(&(p)->p_mtx, MTX_NOSWITCH)
|
|
#define PROC_LOCKED(p) mtx_owned(&(p)->p_mtx)
|
|
#define PROC_LOCK_ASSERT(p, type) mtx_assert(&(p)->p_mtx, (type))
|
|
|
|
/* Hold process U-area in memory, normally for ptrace/procfs work. */
|
|
#define PHOLD(p) do { \
|
|
PROC_LOCK(p); \
|
|
_PHOLD(p); \
|
|
PROC_UNLOCK(p); \
|
|
} while (0)
|
|
#define _PHOLD(p) do { \
|
|
PROC_LOCK_ASSERT((p), MA_OWNED); \
|
|
if ((p)->p_lock++ == 0) \
|
|
faultin((p)); \
|
|
} while (0)
|
|
|
|
#define PRELE(p) do { \
|
|
PROC_LOCK((p)); \
|
|
_PRELE((p)); \
|
|
PROC_UNLOCK((p)); \
|
|
} while (0)
|
|
#define _PRELE(p) do { \
|
|
PROC_LOCK_ASSERT((p), MA_OWNED); \
|
|
(--(p)->p_lock); \
|
|
} while (0)
|
|
|
|
#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 sx allproc_lock;
|
|
extern struct sx proctree_lock;
|
|
extern struct proc proc0; /* Process slot for swapper. */
|
|
extern int hogticks; /* Limit on kernel cpu hogs. */
|
|
extern int nprocs, maxproc; /* Current and max number of procs. */
|
|
extern int maxprocperuid; /* Max procs per uid. */
|
|
extern u_long ps_arg_cache_limit;
|
|
extern int ps_argsopen;
|
|
extern int ps_showallprocs;
|
|
extern int sched_quantum; /* Scheduling quantum in ticks. */
|
|
|
|
LIST_HEAD(proclist, proc);
|
|
TAILQ_HEAD(procqueue, proc);
|
|
extern struct proclist allproc; /* List of all processes. */
|
|
extern struct proclist zombproc; /* List of zombie processes. */
|
|
extern struct proc *initproc, *pageproc; /* Process slots for init, pager. */
|
|
extern struct proc *updateproc; /* Process slot for syncer (sic). */
|
|
|
|
extern struct vm_zone *proc_zone;
|
|
|
|
/*
|
|
* XXX macros for scheduler. Shouldn't be here, but currently needed for
|
|
* bounding the dubious p_estcpu inheritance in wait1().
|
|
* INVERSE_ESTCPU_WEIGHT is only suitable for statclock() frequencies in
|
|
* the range 100-256 Hz (approximately).
|
|
*/
|
|
#define ESTCPULIM(e) \
|
|
min((e), INVERSE_ESTCPU_WEIGHT * (NICE_WEIGHT * (PRIO_MAX - PRIO_MIN) - \
|
|
RQ_PPQ) + INVERSE_ESTCPU_WEIGHT - 1)
|
|
#define INVERSE_ESTCPU_WEIGHT 8 /* 1 / (priorities per estcpu level). */
|
|
#define NICE_WEIGHT 1 /* Priorities per nice level. */
|
|
|
|
struct mtx;
|
|
struct trapframe;
|
|
|
|
struct proc *pfind __P((pid_t)); /* Find process by id. */
|
|
struct pgrp *pgfind __P((pid_t)); /* Find process group by id. */
|
|
struct proc *zpfind __P((pid_t)); /* Find zombie process by id. */
|
|
|
|
struct proc *chooseproc __P((void));
|
|
int enterpgrp __P((struct proc *p, pid_t pgid, int mksess));
|
|
void faultin __P((struct proc *p));
|
|
void fixjobc __P((struct proc *p, struct pgrp *pgrp, int entering));
|
|
int fork1 __P((struct proc *, int, struct proc **));
|
|
void fork_exit __P((void (*)(void *, struct trapframe *), void *,
|
|
struct trapframe *));
|
|
void fork_return __P((struct proc *, struct trapframe *));
|
|
int inferior __P((struct proc *p));
|
|
int leavepgrp __P((struct proc *p));
|
|
void mi_switch __P((void));
|
|
int p_can __P((struct proc *p1, struct proc *p2, int operation,
|
|
int *privused));
|
|
int p_cansignal __P((struct proc *p1, struct proc *p2, int signum));
|
|
int p_trespass __P((struct proc *p1, struct proc *p2));
|
|
void procinit __P((void));
|
|
void proc_reparent __P((struct proc *child, struct proc *newparent));
|
|
int procrunnable __P((void));
|
|
void remrunqueue __P((struct proc *));
|
|
void resetpriority __P((struct proc *));
|
|
int roundrobin_interval __P((void));
|
|
void schedclock __P((struct proc *));
|
|
void setrunnable __P((struct proc *));
|
|
void setrunqueue __P((struct proc *));
|
|
void setsugid __P((struct proc *p));
|
|
void sleepinit __P((void));
|
|
void stopevent __P((struct proc *, u_int, u_int));
|
|
void cpu_idle __P((void));
|
|
void cpu_switch __P((void));
|
|
void cpu_throw __P((void)) __dead2;
|
|
void unsleep __P((struct proc *));
|
|
void updatepri __P((struct proc *));
|
|
void userret __P((struct proc *, struct trapframe *, u_quad_t));
|
|
void maybe_resched __P((struct proc *));
|
|
|
|
void cpu_exit __P((struct proc *)) __dead2;
|
|
void exit1 __P((struct proc *, int)) __dead2;
|
|
void cpu_fork __P((struct proc *, struct proc *, int));
|
|
void cpu_set_fork_handler __P((struct proc *, void (*)(void *), void *));
|
|
int trace_req __P((struct proc *));
|
|
void cpu_wait __P((struct proc *));
|
|
int cpu_coredump __P((struct proc *, struct vnode *, struct ucred *));
|
|
#endif /* _KERNEL */
|
|
|
|
#endif /* !_SYS_PROC_H_ */
|