mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-18 15:53:37 +00:00
A modest collection of various and sundry style, spelling, and whitespace
fixes. Submitted by: bde (mostly)
This commit is contained in:
John Baldwin
parent
e0370a187c
commit
6111dcd2ef
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=135688
|
|
@ -144,24 +144,24 @@ exit1(struct thread *td, int rv)
|
|||
|
||||
/*
|
||||
* Kill off the other threads. This requires
|
||||
* Some co-operation from other parts of the kernel
|
||||
* so it may not be instant.
|
||||
* With this state set:
|
||||
* Any thread entering the kernel from userspace will
|
||||
* some co-operation from other parts of the kernel
|
||||
* so it may not be instantaneous. With this state set
|
||||
* any thread entering the kernel from userspace will
|
||||
* thread_exit() in trap(). Any thread attempting to
|
||||
* sleep will return immediatly with EINTR or EWOULDBLOCK,
|
||||
* which will hopefully force them to back out to userland,
|
||||
* freeing resources as they go, and anything attempting
|
||||
* sleep will return immediately with EINTR or EWOULDBLOCK
|
||||
* which will hopefully force them to back out to userland
|
||||
* freeing resources as they go. Any thread attempting
|
||||
* to return to userland will thread_exit() from userret().
|
||||
* thread_exit() will unsuspend us when the last other
|
||||
* thread exits.
|
||||
* thread_exit() will unsuspend us when the last of the
|
||||
* other threads exits.
|
||||
* If there is already a thread singler after resumption,
|
||||
* calling thread_single will fail, in the case, we just
|
||||
* calling thread_single will fail; in that case, we just
|
||||
* re-check all suspension request, the thread should
|
||||
* either be suspended there or exit.
|
||||
*/
|
||||
if (thread_single(SINGLE_EXIT))
|
||||
goto retry;
|
||||
|
||||
/*
|
||||
* All other activity in this process is now stopped.
|
||||
* Threading support has been turned off.
|
||||
|
|
@ -193,7 +193,7 @@ exit1(struct thread *td, int rv)
|
|||
|
||||
/*
|
||||
* Check if any loadable modules need anything done at process exit.
|
||||
* e.g. SYSV IPC stuff
|
||||
* E.g. SYSV IPC stuff
|
||||
* XXX what if one of these generates an error?
|
||||
*/
|
||||
EVENTHANDLER_INVOKE(process_exit, p);
|
||||
|
|
|
|||
|
|
@ -59,7 +59,6 @@ __FBSDID("$FreeBSD$");
|
|||
#include <vm/pmap.h>
|
||||
#include <vm/vm_map.h>
|
||||
|
||||
static int donice(struct thread *td, struct proc *chgp, int n);
|
||||
|
||||
static MALLOC_DEFINE(M_PLIMIT, "plimit", "plimit structures");
|
||||
static MALLOC_DEFINE(M_UIDINFO, "uidinfo", "uidinfo structures");
|
||||
|
|
@ -68,7 +67,8 @@ static struct mtx uihashtbl_mtx;
|
|||
static LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
|
||||
static u_long uihash; /* size of hash table - 1 */
|
||||
|
||||
static struct uidinfo *uilookup(uid_t uid);
|
||||
static int donice(struct thread *td, struct proc *chgp, int n);
|
||||
static struct uidinfo *uilookup(uid_t uid);
|
||||
|
||||
/*
|
||||
* Resource controls and accounting.
|
||||
|
|
@ -89,6 +89,7 @@ getpriority(td, uap)
|
|||
register struct getpriority_args *uap;
|
||||
{
|
||||
struct proc *p;
|
||||
struct pgrp *pg;
|
||||
int error, low;
|
||||
|
||||
error = 0;
|
||||
|
|
@ -102,16 +103,13 @@ getpriority(td, uap)
|
|||
p = pfind(uap->who);
|
||||
if (p == NULL)
|
||||
break;
|
||||
if (p_cansee(td, p) == 0) {
|
||||
if (p_cansee(td, p) == 0)
|
||||
low = p->p_nice;
|
||||
}
|
||||
PROC_UNLOCK(p);
|
||||
}
|
||||
break;
|
||||
|
||||
case PRIO_PGRP: {
|
||||
register struct pgrp *pg;
|
||||
|
||||
case PRIO_PGRP:
|
||||
sx_slock(&proctree_lock);
|
||||
if (uap->who == 0) {
|
||||
pg = td->td_proc->p_pgrp;
|
||||
|
|
@ -134,7 +132,6 @@ getpriority(td, uap)
|
|||
}
|
||||
PGRP_UNLOCK(pg);
|
||||
break;
|
||||
}
|
||||
|
||||
case PRIO_USER:
|
||||
if (uap->who == 0)
|
||||
|
|
@ -175,10 +172,10 @@ struct setpriority_args {
|
|||
int
|
||||
setpriority(td, uap)
|
||||
struct thread *td;
|
||||
register struct setpriority_args *uap;
|
||||
struct setpriority_args *uap;
|
||||
{
|
||||
struct proc *curp;
|
||||
register struct proc *p;
|
||||
struct proc *curp, *p;
|
||||
struct pgrp *pg;
|
||||
int found = 0, error = 0;
|
||||
|
||||
curp = td->td_proc;
|
||||
|
|
@ -199,9 +196,7 @@ setpriority(td, uap)
|
|||
found++;
|
||||
break;
|
||||
|
||||
case PRIO_PGRP: {
|
||||
register struct pgrp *pg;
|
||||
|
||||
case PRIO_PGRP:
|
||||
sx_slock(&proctree_lock);
|
||||
if (uap->who == 0) {
|
||||
pg = curp->p_pgrp;
|
||||
|
|
@ -224,7 +219,6 @@ setpriority(td, uap)
|
|||
}
|
||||
PGRP_UNLOCK(pg);
|
||||
break;
|
||||
}
|
||||
|
||||
case PRIO_USER:
|
||||
if (uap->who == 0)
|
||||
|
|
@ -251,7 +245,7 @@ setpriority(td, uap)
|
|||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
* Set "nice" for a (whole) process.
|
||||
*/
|
||||
static int
|
||||
|
|
@ -266,7 +260,7 @@ donice(struct thread *td, struct proc *p, int n)
|
|||
n = PRIO_MAX;
|
||||
if (n < PRIO_MIN)
|
||||
n = PRIO_MIN;
|
||||
if (n < p->p_nice && suser(td) != 0)
|
||||
if (n < p->p_nice && suser(td) != 0)
|
||||
return (EACCES);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
sched_nice(p, n);
|
||||
|
|
@ -275,7 +269,7 @@ donice(struct thread *td, struct proc *p, int n)
|
|||
}
|
||||
|
||||
/*
|
||||
* Set realtime priority
|
||||
* Set realtime priority.
|
||||
*
|
||||
* MPSAFE
|
||||
*/
|
||||
|
|
@ -322,9 +316,9 @@ rtprio(td, uap)
|
|||
/*
|
||||
* Return OUR priority if no pid specified,
|
||||
* or if one is, report the highest priority
|
||||
* in the process. There isn't much more you can do as
|
||||
* in the process. There isn't much more you can do as
|
||||
* there is only room to return a single priority.
|
||||
* XXXKSE Maybe need a new interface to report
|
||||
* XXXKSE: maybe need a new interface to report
|
||||
* priorities of multiple system scope threads.
|
||||
* Note: specifying our own pid is not the same
|
||||
* as leaving it zero.
|
||||
|
|
@ -338,9 +332,9 @@ rtprio(td, uap)
|
|||
rtp.prio = RTP_PRIO_MAX;
|
||||
FOREACH_KSEGRP_IN_PROC(p, kg) {
|
||||
pri_to_rtp(kg, &rtp2);
|
||||
if ((rtp2.type < rtp.type) ||
|
||||
((rtp2.type == rtp.type) &&
|
||||
(rtp2.prio < rtp.prio))) {
|
||||
if (rtp2.type < rtp.type ||
|
||||
(rtp2.type == rtp.type &&
|
||||
rtp2.prio < rtp.prio)) {
|
||||
rtp.type = rtp2.type;
|
||||
rtp.prio = rtp2.prio;
|
||||
}
|
||||
|
|
@ -352,7 +346,8 @@ rtprio(td, uap)
|
|||
case RTP_SET:
|
||||
if ((error = p_cansched(td, p)) || (error = cierror))
|
||||
break;
|
||||
/* disallow setting rtprio in most cases if not superuser */
|
||||
|
||||
/* Disallow setting rtprio in most cases if not superuser. */
|
||||
if (suser(td) != 0) {
|
||||
/* can't set someone else's */
|
||||
if (uap->pid) {
|
||||
|
|
@ -362,26 +357,28 @@ rtprio(td, uap)
|
|||
/* can't set realtime priority */
|
||||
/*
|
||||
* Realtime priority has to be restricted for reasons which should be
|
||||
* obvious. However, for idle priority, there is a potential for
|
||||
* obvious. However, for idle priority, there is a potential for
|
||||
* system deadlock if an idleprio process gains a lock on a resource
|
||||
* that other processes need (and the idleprio process can't run
|
||||
* due to a CPU-bound normal process). Fix me! XXX
|
||||
* due to a CPU-bound normal process). Fix me! XXX
|
||||
*/
|
||||
#if 0
|
||||
if (RTP_PRIO_IS_REALTIME(rtp.type))
|
||||
#endif
|
||||
if (RTP_PRIO_IS_REALTIME(rtp.type)) {
|
||||
#else
|
||||
if (rtp.type != RTP_PRIO_NORMAL) {
|
||||
#endif
|
||||
error = EPERM;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mtx_lock_spin(&sched_lock);
|
||||
|
||||
/*
|
||||
* If we are setting our own priority, set just our
|
||||
* KSEGRP but if we are doing another process,
|
||||
* do all the groups on that process. If we
|
||||
* specify our own pid we do the latter.
|
||||
*/
|
||||
mtx_lock_spin(&sched_lock);
|
||||
if (uap->pid == 0) {
|
||||
error = rtp_to_pri(&rtp, td->td_ksegrp);
|
||||
} else {
|
||||
|
|
@ -577,7 +574,7 @@ kern_setrlimit(td, which, limp)
|
|||
PROC_UNLOCK(p);
|
||||
lim_free(newlim);
|
||||
return (error);
|
||||
}
|
||||
}
|
||||
if (limp->rlim_cur > limp->rlim_max)
|
||||
limp->rlim_cur = limp->rlim_max;
|
||||
lim_copy(newlim, oldlim);
|
||||
|
|
@ -648,13 +645,12 @@ kern_setrlimit(td, which, limp)
|
|||
} else {
|
||||
prot = VM_PROT_NONE;
|
||||
size = oldssiz - limp->rlim_cur;
|
||||
addr = p->p_sysent->sv_usrstack -
|
||||
oldssiz;
|
||||
addr = p->p_sysent->sv_usrstack - oldssiz;
|
||||
}
|
||||
addr = trunc_page(addr);
|
||||
size = round_page(size);
|
||||
(void) vm_map_protect(&p->p_vmspace->vm_map,
|
||||
addr, addr+size, prot, FALSE);
|
||||
(void)vm_map_protect(&p->p_vmspace->vm_map,
|
||||
addr, addr + size, prot, FALSE);
|
||||
mtx_unlock(&Giant);
|
||||
}
|
||||
}
|
||||
|
|
@ -687,7 +683,7 @@ getrlimit(td, uap)
|
|||
lim_rlimit(p, uap->which, &rlim);
|
||||
PROC_UNLOCK(p);
|
||||
error = copyout(&rlim, uap->rlp, sizeof(struct rlimit));
|
||||
return(error);
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -873,8 +869,7 @@ lim_alloc()
|
|||
{
|
||||
struct plimit *limp;
|
||||
|
||||
limp = (struct plimit *)malloc(sizeof(struct plimit), M_PLIMIT,
|
||||
M_WAITOK);
|
||||
limp = malloc(sizeof(struct plimit), M_PLIMIT, M_WAITOK);
|
||||
limp->pl_refcnt = 1;
|
||||
limp->pl_mtx = mtx_pool_alloc(mtxpool_sleep);
|
||||
return (limp);
|
||||
|
|
@ -1138,7 +1133,7 @@ chgsbsize(uip, hiwat, to, max)
|
|||
|
||||
UIDINFO_LOCK(uip);
|
||||
new = uip->ui_sbsize + to - *hiwat;
|
||||
/* Don't allow them to exceed max, but allow subtraction */
|
||||
/* Don't allow them to exceed max, but allow subtraction. */
|
||||
if (to > *hiwat && new > max) {
|
||||
UIDINFO_UNLOCK(uip);
|
||||
return (0);
|
||||
|
|
|
|||
122
sys/sys/proc.h
122
sys/sys/proc.h
|
|
@ -92,9 +92,9 @@ struct pgrp {
|
|||
LIST_HEAD(, proc) pg_members; /* (m + e) Pointer to pgrp members. */
|
||||
struct session *pg_session; /* (c) Pointer to session. */
|
||||
struct sigiolst pg_sigiolst; /* (m) List of sigio sources. */
|
||||
pid_t pg_id; /* (c) Pgrp id. */
|
||||
int pg_jobc; /* (m) job cntl proc count */
|
||||
struct mtx pg_mtx; /* Mutex to protect members */
|
||||
pid_t pg_id; /* (c) Process group id. */
|
||||
int pg_jobc; /* (m) Job control process count. */
|
||||
struct mtx pg_mtx; /* Mutex to protect members */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -178,7 +178,7 @@ struct turnstile;
|
|||
* they will all rewind their stacks to the user boundary, report their
|
||||
* completion state, and all but one will be freed. That last one will
|
||||
* be kept to provide a kernel stack and pcb for the NEXT syscall or kernel
|
||||
* entrance. (basically to save freeing and then re-allocating it) The existing
|
||||
* entrance (basically to save freeing and then re-allocating it). The existing
|
||||
* thread keeps a cached spare thread available to allow it to quickly
|
||||
* get one when it needs a new one. There is also a system
|
||||
* cache of free threads. Threads have priority and partake in priority
|
||||
|
|
@ -232,7 +232,7 @@ They would be given priorities calculated from the KSEG.
|
|||
* The first KSE available in the correct group will run this thread.
|
||||
* If several are available, use the one on the same CPU as last time.
|
||||
* When waiting to be run, threads are hung off the KSEGRP in priority order.
|
||||
* with N runnable and queued KSEs in the KSEGRP, the first N threads
|
||||
* With N runnable and queued KSEs in the KSEGRP, the first N threads
|
||||
* are linked to them. Other threads are not yet assigned.
|
||||
*/
|
||||
struct thread {
|
||||
|
|
@ -274,21 +274,20 @@ struct thread {
|
|||
struct thread *td_standin; /* (k + a) Use this for an upcall. */
|
||||
struct kse_upcall *td_upcall; /* (k + j) Upcall structure. */
|
||||
u_int64_t td_sticks; /* (k) Statclock hits in system mode. */
|
||||
u_int td_uuticks; /* (k) Statclock in user, for UTS. */
|
||||
u_int td_usticks; /* (k) Statclock in kernel, for UTS. */
|
||||
u_int td_uuticks; /* (k) Statclock hits (usr), for UTS. */
|
||||
u_int td_usticks; /* (k) Statclock hits (sys), for UTS. */
|
||||
int td_intrval; /* (j) Return value of TDF_INTERRUPT. */
|
||||
sigset_t td_oldsigmask; /* (k) Saved mask from pre sigpause. */
|
||||
sigset_t td_sigmask; /* (c) Current signal mask. */
|
||||
sigset_t td_siglist; /* (c) Sigs arrived, not delivered. */
|
||||
sigset_t *td_waitset; /* (c) Wait set for sigwait. */
|
||||
TAILQ_ENTRY(thread) td_umtx; /* (c?) Link for when we're blocked. */
|
||||
volatile u_int td_generation; /* (k) Enable detection of preemption */
|
||||
volatile u_int td_generation; /* (k) For detection of preemption */
|
||||
stack_t td_sigstk; /* (k) Stack ptr and on-stack flag. */
|
||||
int td_kflags; /* (c) Flags for KSE threading. */
|
||||
int td_xsig; /* (c) Signal for ptrace */
|
||||
u_long td_profil_addr; /* (k) Temporary addr until AST. */
|
||||
u_int td_profil_ticks; /* (k) Temporary ticks until AST. */
|
||||
|
||||
#define td_endzero td_base_pri
|
||||
|
||||
/* Copied during fork1() or thread_sched_upcall(). */
|
||||
|
|
@ -298,8 +297,8 @@ struct thread {
|
|||
#define td_endcopy td_pcb
|
||||
|
||||
/*
|
||||
* fields that must be manually set in fork1() or thread_sched_upcall()
|
||||
* or already have been set in the allocator, contstructor, etc..
|
||||
* Fields that must be manually set in fork1() or thread_sched_upcall()
|
||||
* or already have been set in the allocator, constructor, etc.
|
||||
*/
|
||||
struct pcb *td_pcb; /* (k) Kernel VA of pcb and kstack. */
|
||||
enum {
|
||||
|
|
@ -382,7 +381,7 @@ struct thread {
|
|||
*/
|
||||
#define TDI_SUSPENDED 0x0001 /* On suspension queue. */
|
||||
#define TDI_SLEEPING 0x0002 /* Actually asleep! (tricky). */
|
||||
#define TDI_SWAPPED 0x0004 /* Stack not in mem.. bad juju if run. */
|
||||
#define TDI_SWAPPED 0x0004 /* Stack not in mem. Bad juju if run. */
|
||||
#define TDI_LOCK 0x0008 /* Stopped on a lock. */
|
||||
#define TDI_IWAIT 0x0010 /* Awaiting interrupt. */
|
||||
|
||||
|
|
@ -437,22 +436,21 @@ struct thread {
|
|||
#define TD_SET_CAN_RUN(td) (td)->td_state = TDS_CAN_RUN
|
||||
|
||||
/*
|
||||
* The upcall management structure.
|
||||
* The upcall is used when returning to userland. If a thread does not have
|
||||
* An upcall is used when returning to userland. If a thread does not have
|
||||
* an upcall on return to userland the thread exports its context and exits.
|
||||
*/
|
||||
struct kse_upcall {
|
||||
TAILQ_ENTRY(kse_upcall) ku_link; /* List of upcalls in KSEG. */
|
||||
struct ksegrp *ku_ksegrp; /* Associated KSEG. */
|
||||
struct thread *ku_owner; /* owning thread */
|
||||
struct thread *ku_owner; /* Owning thread. */
|
||||
int ku_flags; /* KUF_* flags. */
|
||||
struct kse_mailbox *ku_mailbox; /* userland mailbox address. */
|
||||
stack_t ku_stack; /* userland upcall stack. */
|
||||
void *ku_func; /* userland upcall function. */
|
||||
unsigned int ku_mflags; /* cached upcall mailbox flags */
|
||||
struct kse_mailbox *ku_mailbox; /* Userland mailbox address. */
|
||||
stack_t ku_stack; /* Userland upcall stack. */
|
||||
void *ku_func; /* Userland upcall function. */
|
||||
unsigned int ku_mflags; /* Cached upcall mbox flags. */
|
||||
};
|
||||
|
||||
#define KUF_DOUPCALL 0x00001 /* Do upcall now, don't wait. */
|
||||
#define KUF_DOUPCALL 0x00001 /* Do upcall now; don't wait. */
|
||||
#define KUF_EXITING 0x00002 /* Upcall structure is exiting. */
|
||||
|
||||
/*
|
||||
|
|
@ -461,12 +459,13 @@ struct kse_upcall {
|
|||
* contain multiple KSEs.
|
||||
*/
|
||||
struct ksegrp {
|
||||
struct proc *kg_proc; /* (*) Process that contains this KSEG. */
|
||||
struct proc *kg_proc; /* (*) Proc that contains this KSEG. */
|
||||
TAILQ_ENTRY(ksegrp) kg_ksegrp; /* (*) Queue of KSEGs in kg_proc. */
|
||||
TAILQ_HEAD(, thread) kg_threads;/* (td_kglist) All threads. */
|
||||
TAILQ_HEAD(, thread) kg_runq; /* (td_runq) waiting RUNNABLE threads */
|
||||
TAILQ_HEAD(, thread) kg_slpq; /* (td_runq) NONRUNNABLE threads. */
|
||||
TAILQ_HEAD(, kse_upcall) kg_upcalls; /* All upcalls in the group. */
|
||||
|
||||
#define kg_startzero kg_estcpu
|
||||
u_int kg_estcpu; /* (j) Sum of the same field in KSEs. */
|
||||
u_int kg_slptime; /* (j) How long completely blocked. */
|
||||
|
|
@ -496,16 +495,17 @@ struct proc {
|
|||
TAILQ_HEAD(, thread) p_threads; /* (j)(td_plist) Threads. (shortcut) */
|
||||
TAILQ_HEAD(, thread) p_suspended; /* (td_runq) Suspended threads. */
|
||||
struct ucred *p_ucred; /* (c) Process owner's identity. */
|
||||
struct filedesc *p_fd; /* (b) Ptr to open files structure. */
|
||||
struct filedesc_to_leader *p_fdtol; /* (b) Ptr to tracking node */
|
||||
struct filedesc *p_fd; /* (b) Open files. */
|
||||
struct filedesc_to_leader *p_fdtol; /* (b) Tracking node */
|
||||
/* Accumulated stats for all threads? */
|
||||
struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */
|
||||
struct plimit *p_limit; /* (c) Process limits. */
|
||||
struct vm_object *p_upages_obj; /* (a) Upages object. */
|
||||
struct sigacts *p_sigacts; /* (x) Signal actions, state (CPU). */
|
||||
|
||||
/*
|
||||
* The following don't make too much sense..
|
||||
* See the td_ or ke_ versions of the same flags
|
||||
* The following don't make too much sense.
|
||||
* See the td_ or ke_ versions of the same flags.
|
||||
*/
|
||||
int p_flag; /* (c) P_* flags. */
|
||||
int p_sflag; /* (j) PS_* flags. */
|
||||
|
|
@ -514,6 +514,7 @@ struct proc {
|
|||
PRS_NORMAL, /* threads can be run. */
|
||||
PRS_ZOMBIE
|
||||
} p_state; /* (j/c) S* process status. */
|
||||
|
||||
pid_t p_pid; /* (b) Process identifier. */
|
||||
LIST_ENTRY(proc) p_hash; /* (d) Hash chain. */
|
||||
LIST_ENTRY(proc) p_pglist; /* (g + e) List of processes in pgrp. */
|
||||
|
|
@ -554,7 +555,7 @@ struct proc {
|
|||
struct nlminfo *p_nlminfo; /* (?) Only used by/for lockd. */
|
||||
void *p_aioinfo; /* (?) ASYNC I/O info. */
|
||||
struct thread *p_singlethread;/* (c + j) If single threading this is it */
|
||||
int p_suspcount; /* (c) # threads in suspended mode */
|
||||
int p_suspcount; /* (c) Num threads in suspended mode. */
|
||||
struct thread *p_xthread; /* (c) Trap thread */
|
||||
/* End area that is zeroed on creation. */
|
||||
#define p_endzero p_magic
|
||||
|
|
@ -574,7 +575,7 @@ struct proc {
|
|||
u_short p_xstat; /* (c) Exit status; also stop sig. */
|
||||
struct knlist p_klist; /* (c) Knotes attached to this proc. */
|
||||
int p_numthreads; /* (j) Number of threads. */
|
||||
int p_numksegrps; /* (c) number of ksegrps */
|
||||
int p_numksegrps; /* (c) Number of ksegrps. */
|
||||
struct mdproc p_md; /* Any machine-dependent fields. */
|
||||
struct callout p_itcallout; /* (h + c) Interval timer callout. */
|
||||
struct user *p_uarea; /* (k) Kernel VA of u-area (CPU). */
|
||||
|
|
@ -590,18 +591,17 @@ struct proc {
|
|||
#define p_session p_pgrp->pg_session
|
||||
#define p_pgid p_pgrp->pg_id
|
||||
|
||||
#define NOCPU 0xff /* For when we aren't on a CPU. (SMP) */
|
||||
#define NOCPU 0xff /* For when we aren't on a CPU. */
|
||||
|
||||
/* Status values (p_stat). */
|
||||
|
||||
/* 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_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_PROFIL 0x00020 /* Has started profiling. */
|
||||
#define P_STOPPROF 0x00040 /* Has thread in requesting to stop prof */
|
||||
#define P_STOPPROF 0x00040 /* Has thread requesting to stop profiling. */
|
||||
#define P_HADTHREADS 0x00080 /* Has had threads (no cleanup shortcuts) */
|
||||
#define P_SUGID 0x00100 /* Had set id privileges since last exec. */
|
||||
#define P_SYSTEM 0x00200 /* System proc: no sigs, stats or swapping. */
|
||||
|
|
@ -614,16 +614,15 @@ struct proc {
|
|||
#define P_CONTINUED 0x10000 /* Proc has continued from a stopped state. */
|
||||
#define P_STOPPED_SIG 0x20000 /* Stopped due to SIGSTOP/SIGTSTP. */
|
||||
#define P_STOPPED_TRACE 0x40000 /* Stopped because of tracing. */
|
||||
#define P_STOPPED_SINGLE 0x80000 /* Only one thread can continue */
|
||||
/* (not to user) */
|
||||
#define P_STOPPED_SINGLE 0x80000 /* Only 1 thread can continue (not to user). */
|
||||
#define P_PROTECTED 0x100000 /* Do not kill on memory overcommit. */
|
||||
#define P_SIGEVENT 0x200000 /* Process pending signals changed. */
|
||||
|
||||
#define P_JAILED 0x1000000 /* Process is in jail. */
|
||||
#define P_INEXEC 0x4000000 /* Process is in execve(). */
|
||||
|
||||
#define P_STOPPED (P_STOPPED_SIG|P_STOPPED_SINGLE|P_STOPPED_TRACE)
|
||||
#define P_SHOULDSTOP(p) ((p)->p_flag & P_STOPPED)
|
||||
#define P_STOPPED (P_STOPPED_SIG|P_STOPPED_SINGLE|P_STOPPED_TRACE)
|
||||
#define P_SHOULDSTOP(p) ((p)->p_flag & P_STOPPED)
|
||||
|
||||
/* These flags are kept in p_sflag and are protected with sched_lock. */
|
||||
#define PS_INMEM 0x00001 /* Loaded into memory. */
|
||||
|
|
@ -633,9 +632,12 @@ struct proc {
|
|||
#define PS_SWAPINREQ 0x00100 /* Swapin request due to wakeup. */
|
||||
#define PS_SWAPPINGOUT 0x00200 /* Process is being swapped out. */
|
||||
#define PS_SWAPPINGIN 0x04000 /* Process is being swapped in. */
|
||||
#define PS_MACPEND 0x08000 /* Ast()-based MAC event pending. */
|
||||
#define PS_MACPEND 0x08000 /* AST-based MAC event pending. */
|
||||
|
||||
/* used only in legacy conversion code */
|
||||
/*
|
||||
* These were process status values (p_stat), now they are only used in
|
||||
* legacy conversion code.
|
||||
*/
|
||||
#define SIDL 1 /* Process being created by fork. */
|
||||
#define SRUN 2 /* Currently runnable. */
|
||||
#define SSLEEP 3 /* Sleeping on an address. */
|
||||
|
|
@ -652,11 +654,11 @@ struct proc {
|
|||
#define SW_VOL 0x0001 /* Voluntary switch. */
|
||||
#define SW_INVOL 0x0002 /* Involuntary switch. */
|
||||
|
||||
/* flags for setrunqueue(). Why are we setting this thread on the run queue? */
|
||||
#define SRQ_BORING 0x0000 /* No special circumstances */
|
||||
#define SRQ_YIELDING 0x0001 /* we are yielding (from mi_switch) */
|
||||
#define SRQ_OURSELF 0x0002 /* it is ourself (from mi_switch) */
|
||||
#define SRQ_INTR 0x0004 /* it is probably urgent */
|
||||
/* Flags for setrunqueue(). Why are we setting this thread on the run queue? */
|
||||
#define SRQ_BORING 0x0000 /* No special circumstances. */
|
||||
#define SRQ_YIELDING 0x0001 /* We are yielding (from mi_switch). */
|
||||
#define SRQ_OURSELF 0x0002 /* It is ourself (from mi_switch). */
|
||||
#define SRQ_INTR 0x0004 /* It is probably urgent. */
|
||||
|
||||
/* How values for thread_single(). */
|
||||
#define SINGLE_NO_EXIT 0
|
||||
|
|
@ -683,7 +685,7 @@ MALLOC_DECLARE(M_ZOMBIE);
|
|||
#define FOREACH_THREAD_IN_PROC(p, td) \
|
||||
TAILQ_FOREACH((td), &(p)->p_threads, td_plist)
|
||||
|
||||
/* XXXKSE the lines below should probably only be used in 1:1 code */
|
||||
/* XXXKSE the following lines should probably only be used in 1:1 code: */
|
||||
#define FIRST_THREAD_IN_PROC(p) TAILQ_FIRST(&(p)->p_threads)
|
||||
#define FIRST_KSEGRP_IN_PROC(p) TAILQ_FIRST(&(p)->p_ksegrps)
|
||||
|
||||
|
|
@ -784,11 +786,12 @@ extern struct sx allproc_lock;
|
|||
extern struct sx proctree_lock;
|
||||
extern struct mtx pargs_ref_lock;
|
||||
extern struct mtx ppeers_lock;
|
||||
extern struct ksegrp ksegrp0; /* Primary ksegrp in proc0. */
|
||||
extern struct proc proc0; /* Process slot for swapper. */
|
||||
extern struct thread thread0; /* Primary thread in proc0. */
|
||||
extern struct ksegrp ksegrp0; /* Primary ksegrp in proc0. */
|
||||
extern struct vmspace vmspace0; /* VM space for proc0. */
|
||||
extern int hogticks; /* Limit on kernel cpu hogs. */
|
||||
extern int lastpid;
|
||||
extern int nprocs, maxproc; /* Current and max number of procs. */
|
||||
extern int maxprocperuid; /* Max procs per uid. */
|
||||
extern u_long ps_arg_cache_limit;
|
||||
|
|
@ -804,17 +807,16 @@ extern struct proc *updateproc; /* Process slot for syncer (sic). */
|
|||
|
||||
extern struct uma_zone *proc_zone;
|
||||
|
||||
extern int lastpid;
|
||||
|
||||
struct proc *pfind(pid_t); /* Find process by id. */
|
||||
struct pgrp *pgfind(pid_t); /* Find process group by id. */
|
||||
struct proc *zpfind(pid_t); /* Find zombie process by id. */
|
||||
struct proc *pfind(pid_t); /* Find process by id. */
|
||||
struct pgrp *pgfind(pid_t); /* Find process group by id. */
|
||||
struct proc *zpfind(pid_t); /* Find zombie process by id. */
|
||||
|
||||
void adjustrunqueue(struct thread *, int newpri);
|
||||
void ast(struct trapframe *framep);
|
||||
struct thread *choosethread(void);
|
||||
int cr_cansignal(struct ucred *cred, struct proc *proc, int signum);
|
||||
int enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess);
|
||||
int enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp,
|
||||
struct session *sess);
|
||||
int enterthispgrp(struct proc *p, struct pgrp *pgrp);
|
||||
void faultin(struct proc *p);
|
||||
void fixjobc(struct proc *p, struct pgrp *pgrp, int entering);
|
||||
|
|
@ -835,7 +837,6 @@ void pargs_drop(struct pargs *pa);
|
|||
void pargs_free(struct pargs *pa);
|
||||
void pargs_hold(struct pargs *pa);
|
||||
void procinit(void);
|
||||
void threadinit(void);
|
||||
void proc_linkup(struct proc *p, struct ksegrp *kg, struct thread *td);
|
||||
void proc_reparent(struct proc *child, struct proc *newparent);
|
||||
int securelevel_ge(struct ucred *cr, int level);
|
||||
|
|
@ -846,6 +847,7 @@ void setsugid(struct proc *p);
|
|||
int sigonstack(size_t sp);
|
||||
void sleepinit(void);
|
||||
void stopevent(struct proc *, u_int, u_int);
|
||||
void threadinit(void);
|
||||
void cpu_idle(void);
|
||||
extern void (*cpu_idle_hook)(void); /* Hook to machdep CPU idler. */
|
||||
void cpu_switch(struct thread *old, struct thread *new);
|
||||
|
|
@ -874,40 +876,40 @@ void cpu_thread_swapin(struct thread *);
|
|||
void cpu_thread_swapout(struct thread *);
|
||||
void ksegrp_link(struct ksegrp *kg, struct proc *p);
|
||||
void ksegrp_unlink(struct ksegrp *kg);
|
||||
void thread_signal_add(struct thread *td, int sig);
|
||||
struct thread *thread_alloc(void);
|
||||
void thread_continued(struct proc *p);
|
||||
void thread_exit(void) __dead2;
|
||||
int thread_export_context(struct thread *td, int willexit);
|
||||
void thread_free(struct thread *td);
|
||||
void thread_link(struct thread *td, struct ksegrp *kg);
|
||||
void thread_reap(void);
|
||||
struct thread *thread_schedule_upcall(struct thread *td, struct kse_upcall *ku);
|
||||
void thread_signal_add(struct thread *td, int sig);
|
||||
int thread_single(int how);
|
||||
void thread_single_end(void);
|
||||
int thread_sleep_check(struct thread *td);
|
||||
void thread_stash(struct thread *td);
|
||||
int thread_statclock(int user);
|
||||
void thread_stopped(struct proc *p);
|
||||
int thread_suspend_check(int how);
|
||||
void thread_suspend_one(struct thread *td);
|
||||
struct thread *thread_switchout(struct thread *td, int flags,
|
||||
struct thread *newtd);
|
||||
void thread_unlink(struct thread *td);
|
||||
void thread_unsuspend(struct proc *p);
|
||||
void thread_unsuspend_one(struct thread *td);
|
||||
int thread_userret(struct thread *td, struct trapframe *frame);
|
||||
int thread_upcall_check(struct thread *td);
|
||||
int thread_userret(struct thread *td, struct trapframe *frame);
|
||||
void thread_user_enter(struct thread *td);
|
||||
void thread_wait(struct proc *p);
|
||||
int thread_statclock(int user);
|
||||
void thr_exit1(void);
|
||||
struct kse_upcall *upcall_alloc(void);
|
||||
void upcall_free(struct kse_upcall *ku);
|
||||
void upcall_link(struct kse_upcall *ku, struct ksegrp *kg);
|
||||
void upcall_unlink(struct kse_upcall *ku);
|
||||
void upcall_remove(struct thread *td);
|
||||
void upcall_stash(struct kse_upcall *ke);
|
||||
void thread_sanity_check(struct thread *td, char *);
|
||||
void thread_stopped(struct proc *p);
|
||||
struct thread *thread_switchout(struct thread *td, int flags,
|
||||
struct thread *newtd);
|
||||
void thread_continued(struct proc *p);
|
||||
void thr_exit1(void);
|
||||
|
||||
#endif /* _KERNEL */
|
||||
|
||||
#endif /* !_SYS_PROC_H_ */
|
||||
|
|
|
|||
Loading…
Reference in a new issue