1 /* $OpenBSD: proc.h,v 1.378 2025/01/25 19:21:40 claudio Exp $ */ 2 /* $NetBSD: proc.h,v 1.44 1996/04/22 01:23:21 christos Exp $ */ 3 4 /*- 5 * Copyright (c) 1986, 1989, 1991, 1993 6 * The Regents of the University of California. All rights reserved. 7 * (c) UNIX System Laboratories, Inc. 8 * All or some portions of this file are derived from material licensed 9 * to the University of California by American Telephone and Telegraph 10 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 11 * the permission of UNIX System Laboratories, Inc. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 * @(#)proc.h 8.8 (Berkeley) 1/21/94 38 */ 39 40 #ifndef _SYS_PROC_H_ 41 #define _SYS_PROC_H_ 42 43 #include <machine/proc.h> /* Machine-dependent proc substruct. */ 44 #include <sys/selinfo.h> /* For struct selinfo */ 45 #include <sys/syslimits.h> /* For LOGIN_NAME_MAX */ 46 #include <sys/queue.h> 47 #include <sys/timeout.h> /* For struct timeout */ 48 #include <sys/event.h> /* For struct klist */ 49 #include <sys/mutex.h> /* For struct mutex */ 50 #include <sys/resource.h> /* For struct rusage */ 51 #include <sys/rwlock.h> /* For struct rwlock */ 52 #include <sys/sigio.h> /* For struct sigio */ 53 #include <sys/refcnt.h> /* For struct refcnt */ 54 55 #ifdef _KERNEL 56 #include <sys/atomic.h> 57 #define __need_process 58 #endif 59 60 /* 61 * One structure allocated per session. 62 */ 63 struct process; 64 struct session { 65 int s_count; /* Ref cnt; pgrps in session. */ 66 struct process *s_leader; /* Session leader. */ 67 struct vnode *s_ttyvp; /* Vnode of controlling terminal. */ 68 struct tty *s_ttyp; /* Controlling terminal. */ 69 char s_login[LOGIN_NAME_MAX]; /* Setlogin() name. */ 70 pid_t s_verauthppid; 71 uid_t s_verauthuid; 72 struct timeout s_verauthto; 73 }; 74 75 void zapverauth(/* struct session */ void *); 76 77 /* 78 * One structure allocated per process group. 79 */ 80 struct pgrp { 81 LIST_ENTRY(pgrp) pg_hash; /* Hash chain. */ 82 LIST_HEAD(, process) pg_members;/* Pointer to pgrp members. */ 83 struct session *pg_session; /* Pointer to session. */ 84 struct sigiolst pg_sigiolst; /* List of sigio structures. */ 85 pid_t pg_id; /* Pgrp id. */ 86 int pg_jobc; /* # procs qualifying pgrp for job control */ 87 }; 88 89 /* 90 * time usage: accumulated times in ticks 91 * Each thread is immediately accumulated here. For processes only the 92 * time of exited threads is accumulated and to get the proper process 93 * time usage tuagg_get_process() needs to be called. 94 * Accounting of threads is done lockless by curproc using the tu_gen 95 * generation counter. Code should use tu_enter() and tu_leave() for this. 96 * The process ps_tu structure is locked by the ps_mtx. 97 */ 98 struct tusage { 99 uint64_t tu_gen; /* generation counter */ 100 uint64_t tu_uticks; /* Statclock hits in user mode. */ 101 uint64_t tu_sticks; /* Statclock hits in system mode. */ 102 uint64_t tu_iticks; /* Statclock hits processing intr. */ 103 struct timespec tu_runtime; /* Realtime. */ 104 }; 105 106 /* 107 * Description of a process. 108 * 109 * These structures contain the information needed to manage a thread of 110 * control, known in UN*X as a process; it has references to substructures 111 * containing descriptions of things that the process uses, but may share 112 * with related processes. 113 * 114 * struct process is the higher level process containing information 115 * shared by all threads in a process, while struct proc contains the 116 * run-time information needed by threads. 117 */ 118 #ifdef __need_process 119 struct futex; 120 LIST_HEAD(futex_list, futex); 121 struct proc; 122 struct tslpentry; 123 TAILQ_HEAD(tslpqueue, tslpentry); 124 struct unveil; 125 126 struct pinsyscall { 127 vaddr_t pn_start; 128 vaddr_t pn_end; 129 u_int *pn_pins; /* array of offsets indexed by syscall# */ 130 int pn_npins; /* number of entries in table */ 131 }; 132 133 /* 134 * Locks used to protect struct members in this file: 135 * I immutable after creation 136 * a atomic operations 137 * K kernel lock 138 * m this process' `ps_mtx' 139 * p this process' `ps_lock' 140 * Q kqueue_ps_list_lock 141 * R rlimit_lock 142 * S scheduler lock 143 * T itimer_mtx 144 */ 145 struct process { 146 struct refcnt ps_refcnt; 147 148 /* 149 * ps_mainproc is the original thread in the process. 150 * It's only still special for the handling of 151 * some signal and ptrace behaviors that need to be fixed. 152 */ 153 struct proc *ps_mainproc; 154 struct ucred *ps_ucred; /* Process owner's identity. */ 155 156 LIST_ENTRY(process) ps_list; /* List of all processes. */ 157 TAILQ_HEAD(,proc) ps_threads; /* [K|m] Threads in this process. */ 158 159 LIST_ENTRY(process) ps_pglist; /* List of processes in pgrp. */ 160 struct process *ps_pptr; /* [K|m] Pointer to parent process. */ 161 LIST_ENTRY(process) ps_sibling; /* List of sibling processes. */ 162 LIST_HEAD(, process) ps_children;/* Pointer to list of children. */ 163 LIST_ENTRY(process) ps_hash; /* Hash chain. */ 164 165 /* 166 * An orphan is the child that has been re-parented to the 167 * debugger as a result of attaching to it. Need to keep 168 * track of them for parent to be able to collect the exit 169 * status of what used to be children. 170 */ 171 LIST_ENTRY(process) ps_orphan; /* List of orphan processes. */ 172 LIST_HEAD(, process) ps_orphans;/* Pointer to list of orphans. */ 173 174 struct sigiolst ps_sigiolst; /* List of sigio structures. */ 175 struct sigacts *ps_sigacts; /* [I] Signal actions, state */ 176 struct vnode *ps_textvp; /* Vnode of executable. */ 177 struct filedesc *ps_fd; /* Ptr to open files structure */ 178 struct vmspace *ps_vmspace; /* Address space */ 179 pid_t ps_pid; /* [I] Process identifier. */ 180 181 struct futex_list ps_ftlist; /* futexes attached to this process */ 182 struct tslpqueue ps_tslpqueue; /* [p] queue of threads in thrsleep */ 183 struct rwlock ps_lock; /* per-process rwlock */ 184 struct mutex ps_mtx; /* per-process mutex */ 185 186 /* The following fields are all zeroed upon creation in process_new. */ 187 #define ps_startzero ps_klist 188 struct klist ps_klist; /* [Q,m] knotes attached to process */ 189 u_int ps_flags; /* [a] PS_* flags. */ 190 int ps_siglist; /* Signals pending for the process. */ 191 192 struct proc *ps_single; /* [m] Thread for single-threading. */ 193 u_int ps_singlecnt; /* [m] Number of threads to suspend. */ 194 u_int ps_exitcnt; /* [m] Number of threads in exit1. */ 195 196 int ps_traceflag; /* Kernel trace points. */ 197 struct vnode *ps_tracevp; /* Trace to vnode. */ 198 struct ucred *ps_tracecred; /* Creds for writing trace */ 199 200 u_int ps_xexit; /* Exit status for wait */ 201 int ps_xsig; /* Stopping or killing signal */ 202 203 pid_t ps_ppid; /* [K|m] Cached parent pid */ 204 int ps_ptmask; /* Ptrace event mask */ 205 struct ptrace_state *ps_ptstat;/* Ptrace state */ 206 struct process *ps_opptr; /* [K|m] Old parent during ptrace. */ 207 208 struct rusage *ps_ru; /* sum of stats for dead threads. */ 209 struct tusage ps_tu; /* [m] accumul times of dead threads. */ 210 struct rusage ps_cru; /* sum of stats for reaped children */ 211 struct itimerspec ps_timer[3]; /* [m] ITIMER_REAL timer */ 212 /* [T] ITIMER_{VIRTUAL,PROF} timers */ 213 struct timeout ps_rucheck_to; /* [] resource limit check timer */ 214 time_t ps_nextxcpu; /* when to send next SIGXCPU, */ 215 /* in seconds of process runtime */ 216 217 u_int64_t ps_wxcounter; 218 219 struct unveil *ps_uvpaths; /* unveil vnodes and names */ 220 ssize_t ps_uvvcount; /* count of unveil vnodes held */ 221 size_t ps_uvncount; /* count of unveil names allocated */ 222 int ps_uvdone; /* no more unveil is permitted */ 223 224 /* End area that is zeroed on creation. */ 225 #define ps_endzero ps_startcopy 226 227 /* The following fields are all copied upon creation in process_new. */ 228 #define ps_startcopy ps_limit 229 struct plimit *ps_limit; /* [m,R] Process limits. */ 230 struct pgrp *ps_pgrp; /* [K|m] Pointer to process group. */ 231 232 char ps_comm[_MAXCOMLEN]; /* command name, incl NUL */ 233 234 vaddr_t ps_strings; /* User pointers to argv/env */ 235 vaddr_t ps_auxinfo; /* User pointer to auxinfo */ 236 vaddr_t ps_timekeep; /* User pointer to timekeep */ 237 vaddr_t ps_sigcode; /* [I] User pointer to signal code */ 238 vaddr_t ps_sigcoderet; /* [I] User ptr to sigreturn retPC */ 239 u_long ps_sigcookie; /* [I] */ 240 u_int ps_rtableid; /* [a] Process routing table/domain. */ 241 char ps_nice; /* Process "nice" value. */ 242 243 struct uprof { /* profile arguments */ 244 caddr_t pr_base; /* buffer base */ 245 size_t pr_size; /* buffer size */ 246 u_long pr_off; /* pc offset */ 247 u_int pr_scale; /* pc scaling */ 248 } ps_prof; 249 250 u_int32_t ps_acflag; /* Accounting flags. */ 251 252 uint64_t ps_pledge; /* [m] pledge promises */ 253 uint64_t ps_execpledge; /* [m] execpledge promises */ 254 255 int64_t ps_kbind_cookie; /* [m] */ 256 u_long ps_kbind_addr; /* [m] */ 257 /* an address that can't be in userspace or kernelspace */ 258 #define BOGO_PC (u_long)-1 259 260 struct pinsyscall ps_pin; /* static or ld.so */ 261 struct pinsyscall ps_libcpin; /* libc.so, from pinsyscalls(2) */ 262 263 /* End area that is copied on creation. */ 264 #define ps_endcopy ps_threadcnt 265 u_int ps_threadcnt; /* [m] Number of threads. */ 266 267 struct timespec ps_start; /* starting uptime. */ 268 struct timeout ps_realit_to; /* [m] ITIMER_REAL timeout */ 269 }; 270 271 #define ps_session ps_pgrp->pg_session 272 #define ps_pgid ps_pgrp->pg_id 273 274 #endif /* __need_process */ 275 276 /* 277 * These flags are kept in ps_flags. 278 */ 279 #define PS_CONTROLT 0x00000001 /* Has a controlling terminal. */ 280 #define PS_EXEC 0x00000002 /* Process called exec. */ 281 #define PS_INEXEC 0x00000004 /* Process is doing an exec right now */ 282 #define PS_EXITING 0x00000008 /* Process is exiting. */ 283 #define PS_SUGID 0x00000010 /* Had set id privs since last exec. */ 284 #define PS_SUGIDEXEC 0x00000020 /* last execve() was set[ug]id */ 285 #define PS_PPWAIT 0x00000040 /* Parent waits for exec/exit. */ 286 #define PS_ISPWAIT 0x00000080 /* Is parent of PPWAIT child. */ 287 #define PS_PROFIL 0x00000100 /* Has started profiling. */ 288 #define PS_TRACED 0x00000200 /* Being ptraced. */ 289 #define PS_WAITED 0x00000400 /* Stopped proc was waited for. */ 290 #define PS_COREDUMP 0x00000800 /* Busy coredumping */ 291 #define PS_SINGLEEXIT 0x00001000 /* Other threads must die. */ 292 #define PS_SINGLEUNWIND 0x00002000 /* Other threads must unwind. */ 293 #define PS_NOZOMBIE 0x00004000 /* No signal or zombie at exit. */ 294 #define PS_STOPPING 0x00008000 /* Just stopped, need sig to parent. */ 295 #define PS_SYSTEM 0x00010000 /* No sigs, stats or swapping. */ 296 #define PS_EMBRYO 0x00020000 /* New process, not yet fledged */ 297 #define PS_ZOMBIE 0x00040000 /* Dead and ready to be waited for */ 298 #define PS_NOBROADCASTKILL 0x00080000 /* Process excluded from kill -1. */ 299 #define PS_PLEDGE 0x00100000 /* Has called pledge(2) */ 300 #define PS_WXNEEDED 0x00200000 /* Process allowed to violate W^X */ 301 #define PS_EXECPLEDGE 0x00400000 /* Has exec pledges */ 302 #define PS_ORPHAN 0x00800000 /* Process is on an orphan list */ 303 #define PS_CHROOT 0x01000000 /* Process is chrooted */ 304 #define PS_NOBTCFI 0x02000000 /* No Branch Target CFI */ 305 #define PS_ITIMER 0x04000000 /* Virtual interval timers running */ 306 #define PS_CONTINUED 0x20000000 /* Continued proc not yet waited for */ 307 #define PS_STOPPED 0x40000000 /* Stopped process */ 308 #define PS_TRAPPED 0x80000000 /* Stopped due to tracing event */ 309 310 #define PS_BITS \ 311 ("\20" "\01CONTROLT" "\02EXEC" "\03INEXEC" "\04EXITING" "\05SUGID" \ 312 "\06SUGIDEXEC" "\07PPWAIT" "\010ISPWAIT" "\011PROFIL" "\012TRACED" \ 313 "\013WAITED" "\014COREDUMP" "\015SINGLEEXIT" "\016SINGLEUNWIND" \ 314 "\017NOZOMBIE" "\020STOPPING" "\021SYSTEM" "\022EMBRYO" "\023ZOMBIE" \ 315 "\024NOBROADCASTKILL" "\025PLEDGE" "\026WXNEEDED" "\027EXECPLEDGE" \ 316 "\030ORPHAN" "\031CHROOT" "\032NOBTCFI" "\033ITIMER" "\036CONTINUED" \ 317 "\037STOPPED" "\040TRAPPED") 318 319 struct kcov_dev; 320 struct lock_list_entry; 321 struct kqueue; 322 323 struct p_inentry { 324 u_long ie_serial; 325 vaddr_t ie_start; 326 vaddr_t ie_end; 327 }; 328 329 /* 330 * Locks used to protect struct members in this file: 331 * I immutable after creation 332 * S scheduler lock 333 * U uidinfolk 334 * l read only reference, see lim_read_enter() 335 * o owned (modified only) by this thread 336 * m this proc's' `p->p_p->ps_mtx' 337 */ 338 struct proc { 339 TAILQ_ENTRY(proc) p_runq; /* [S] current run/sleep queue */ 340 LIST_ENTRY(proc) p_list; /* List of all threads. */ 341 342 struct process *p_p; /* [I] The process of this thread. */ 343 TAILQ_ENTRY(proc) p_thr_link; /* [K|m] Threads in a process linkage. */ 344 345 TAILQ_ENTRY(proc) p_fut_link; /* Threads in a futex linkage. */ 346 struct futex *p_futex; /* Current sleeping futex. */ 347 348 /* substructures: */ 349 struct filedesc *p_fd; /* copy of p_p->ps_fd */ 350 struct vmspace *p_vmspace; /* [I] copy of p_p->ps_vmspace */ 351 struct p_inentry p_spinentry; /* [o] cache for SP check */ 352 353 int p_flag; /* P_* flags. */ 354 u_char p_spare; /* unused */ 355 char p_stat; /* [S] S* process status. */ 356 u_char p_runpri; /* [S] Runqueue priority */ 357 u_char p_descfd; /* if not 255, fdesc permits this fd */ 358 359 pid_t p_tid; /* Thread identifier. */ 360 LIST_ENTRY(proc) p_hash; /* Hash chain. */ 361 362 /* The following fields are all zeroed upon creation in fork. */ 363 #define p_startzero p_dupfd 364 int p_dupfd; /* Sideways return value from filedescopen. XXX */ 365 366 /* scheduling */ 367 int p_cpticks; /* Ticks of cpu time. */ 368 const volatile void *p_wchan; /* [S] Sleep address. */ 369 struct timeout p_sleep_to;/* timeout for tsleep() */ 370 const char *p_wmesg; /* [S] Reason for sleep. */ 371 fixpt_t p_pctcpu; /* [S] %cpu for this thread */ 372 u_int p_slptime; /* [S] Time since last blocked. */ 373 struct cpu_info * volatile p_cpu; /* [S] CPU we're running on. */ 374 375 struct rusage p_ru; /* Statistics */ 376 struct tusage p_tu; /* [o] accumulated times. */ 377 378 struct plimit *p_limit; /* [l] read ref. of p_p->ps_limit */ 379 struct kcov_dev *p_kd; /* kcov device handle */ 380 struct lock_list_entry *p_sleeplocks; /* WITNESS lock tracking */ 381 struct kqueue *p_kq; /* [o] select/poll queue of evts */ 382 unsigned long p_kq_serial; /* [o] to check against enqueued evts */ 383 384 int p_siglist; /* [a] Signals arrived & not delivered*/ 385 386 /* End area that is zeroed on creation. */ 387 #define p_endzero p_startcopy 388 389 /* The following fields are all copied upon creation in fork. */ 390 #define p_startcopy p_sigmask 391 sigset_t p_sigmask; /* [o] Current signal mask */ 392 393 char p_name[_MAXCOMLEN]; /* thread name, incl NUL */ 394 u_char p_slppri; /* [S] Sleeping priority */ 395 u_char p_usrpri; /* [S] Priority based on p_estcpu & ps_nice */ 396 u_int p_estcpu; /* [S] Time averaged val of p_cpticks */ 397 int p_pledge_syscall; /* Cache of current syscall */ 398 399 struct ucred *p_ucred; /* [o] cached credentials */ 400 struct sigaltstack p_sigstk; /* sp & on stack state variable */ 401 402 u_long p_prof_addr; /* tmp storage for profiling addr until AST */ 403 u_long p_prof_ticks; /* tmp storage for profiling ticks until AST */ 404 405 /* End area that is copied on creation. */ 406 #define p_endcopy p_addr 407 struct user *p_addr; /* Kernel virtual addr of u-area */ 408 struct mdproc p_md; /* Any machine-dependent fields. */ 409 410 sigset_t p_oldmask; /* [o] Saved mask from before sigpause */ 411 int p_sisig; /* For core dump/debugger XXX */ 412 union sigval p_sigval; /* For core dump/debugger XXX */ 413 long p_sitrapno; /* For core dump/debugger XXX */ 414 int p_sicode; /* For core dump/debugger XXX */ 415 }; 416 417 /* Status values. */ 418 #define SIDL 1 /* Thread being created by fork. */ 419 #define SRUN 2 /* Currently runnable. */ 420 #define SSLEEP 3 /* Sleeping on an address. */ 421 #define SSTOP 4 /* Debugging or suspension. */ 422 #define SZOMB 5 /* unused */ 423 #define SDEAD 6 /* Thread is almost gone */ 424 #define SONPROC 7 /* Thread is currently on a CPU. */ 425 426 #define P_ZOMBIE(p) ((p)->p_stat == SDEAD) 427 #define P_HASSIBLING(p) ((p)->p_p->ps_threadcnt > 1) 428 429 /* 430 * These flags are per-thread and kept in p_flag 431 */ 432 #define P_INKTR 0x00000001 /* In a ktrace op, don't recurse */ 433 #define P_PROFPEND 0x00000002 /* SIGPROF needs to be posted */ 434 #define P_ALRMPEND 0x00000004 /* SIGVTALRM needs to be posted */ 435 #define P_SIGSUSPEND 0x00000008 /* Need to restore before-suspend mask*/ 436 #define P_CANTSLEEP 0x00000010 /* insomniac thread */ 437 #define P_WSLEEP 0x00000020 /* Working on going to sleep. */ 438 #define P_SINTR 0x00000080 /* Sleep is interruptible. */ 439 #define P_SYSTEM 0x00000200 /* No sigs, stats or swapping. */ 440 #define P_TIMEOUT 0x00000400 /* Timing out during sleep. */ 441 #define P_TRACESINGLE 0x00001000 /* Ptrace: keep single threaded. */ 442 #define P_WEXIT 0x00002000 /* Working on exiting. */ 443 #define P_OWEUPC 0x00008000 /* Owe proc an addupc() at next ast. */ 444 #define P_SUSPSINGLE 0x00080000 /* Need to stop for single threading. */ 445 #define P_THREAD 0x04000000 /* Only a thread, not a real process */ 446 #define P_SUSPSIG 0x08000000 /* Stopped from signal. */ 447 #define P_CPUPEG 0x40000000 /* Do not move to another cpu. */ 448 449 #define P_BITS \ 450 ("\20" "\01INKTR" "\02PROFPEND" "\03ALRMPEND" "\04SIGSUSPEND" \ 451 "\05CANTSLEEP" "\06WSLEEP" "\010SINTR" "\012SYSTEM" "\013TIMEOUT" \ 452 "\015TRACESINGLE" "\016WEXIT" "\020OWEUPC" "\024SUSPSINGLE" \ 453 "\033THREAD" "\034SUSPSIG" "\037CPUPEG") 454 455 #define THREAD_PID_OFFSET 100000 456 457 #ifdef _KERNEL 458 459 struct uidinfo { 460 LIST_ENTRY(uidinfo) ui_hash; /* [U] */ 461 uid_t ui_uid; /* [I] */ 462 long ui_proccnt; /* [U] proc structs */ 463 long ui_lockcnt; /* [U] lockf structs */ 464 }; 465 466 struct uidinfo *uid_find(uid_t); 467 void uid_release(struct uidinfo *); 468 469 /* 470 * We use process IDs <= PID_MAX; PID_MAX + 1 must also fit in a pid_t, 471 * as it is used to represent "no process group". 472 * We set PID_MAX to 99999 to keep it in 5 columns in ps 473 * When exposed to userspace, thread IDs have THREAD_PID_OFFSET 474 * added to keep them from overlapping the PID range. For them, 475 * we use a * a (0 .. 2^n] range for cheapness, picking 'n' such 476 * that 2^n + THREAD_PID_OFFSET and THREAD_PID_OFFSET have 477 * the same number of columns when printed. 478 */ 479 #define PID_MAX 99999 480 #define TID_MASK 0x7ffff 481 482 #define NO_PID (PID_MAX+1) 483 484 #define SESS_LEADER(pr) ((pr)->ps_session->s_leader == (pr)) 485 #define SESSHOLD(s) ((s)->s_count++) 486 #define SESSRELE(s) do { \ 487 if (--(s)->s_count == 0) { \ 488 timeout_del(&(s)->s_verauthto); \ 489 pool_put(&session_pool, (s)); \ 490 } \ 491 } while (/* CONSTCOND */ 0) 492 493 /* 494 * Flags to fork1(). 495 */ 496 #define FORK_FORK 0x00000001 497 #define FORK_VFORK 0x00000002 498 #define FORK_IDLE 0x00000004 499 #define FORK_PPWAIT 0x00000008 500 #define FORK_SHAREFILES 0x00000010 501 #define FORK_SYSTEM 0x00000020 502 #define FORK_NOZOMBIE 0x00000040 503 #define FORK_SHAREVM 0x00000080 504 #define FORK_PTRACE 0x00000400 505 506 #define EXIT_NORMAL 0x00000001 507 #define EXIT_THREAD 0x00000002 508 #define EXIT_THREAD_NOCHECK 0x00000003 509 510 #define TIDHASH(tid) (&tidhashtbl[(tid) & tidhash]) 511 extern LIST_HEAD(tidhashhead, proc) *tidhashtbl; 512 extern u_long tidhash; 513 514 #define PIDHASH(pid) (&pidhashtbl[(pid) & pidhash]) 515 extern LIST_HEAD(pidhashhead, process) *pidhashtbl; 516 extern u_long pidhash; 517 518 #define PGRPHASH(pgid) (&pgrphashtbl[(pgid) & pgrphash]) 519 extern LIST_HEAD(pgrphashhead, pgrp) *pgrphashtbl; 520 extern u_long pgrphash; 521 522 extern struct proc proc0; /* Process slot for swapper. */ 523 extern struct process process0; /* Process slot for kernel threads. */ 524 extern int nprocesses, maxprocess; /* Cur and max number of processes. */ 525 extern int nthreads, maxthread; /* Cur and max number of threads. */ 526 527 LIST_HEAD(proclist, proc); 528 LIST_HEAD(processlist, process); 529 extern struct processlist allprocess; /* List of all processes. */ 530 extern struct processlist zombprocess; /* List of zombie processes. */ 531 extern struct proclist allproc; /* List of all threads. */ 532 533 extern struct process *initprocess; /* Process slot for init. */ 534 extern struct proc *reaperproc; /* Thread slot for reaper. */ 535 extern struct proc *syncerproc; /* filesystem syncer daemon */ 536 537 extern struct pool process_pool; /* memory pool for processes */ 538 extern struct pool proc_pool; /* memory pool for procs */ 539 extern struct pool rusage_pool; /* memory pool for zombies */ 540 extern struct pool ucred_pool; /* memory pool for ucreds */ 541 extern struct pool session_pool; /* memory pool for sessions */ 542 extern struct pool pgrp_pool; /* memory pool for pgrps */ 543 544 void freepid(pid_t); 545 546 struct process *prfind(pid_t); /* Find process by id. */ 547 struct process *zombiefind(pid_t); /* Find zombie process by id. */ 548 struct proc *tfind(pid_t); /* Find thread by id. */ 549 struct pgrp *pgfind(pid_t); /* Find process group by id. */ 550 struct proc *tfind_user(pid_t, struct process *); 551 /* Find thread by userspace id. */ 552 void proc_printit(struct proc *p, const char *modif, 553 int (*pr)(const char *, ...)); 554 555 int chgproccnt(uid_t uid, int diff); 556 void enternewpgrp(struct process *, struct pgrp *, struct session *); 557 void enterthispgrp(struct process *, struct pgrp *); 558 int inferior(struct process *, struct process *); 559 void leavepgrp(struct process *); 560 void killjobc(struct process *); 561 void preempt(void); 562 void procinit(void); 563 void setpriority(struct proc *, uint32_t, uint8_t); 564 void setrunnable(struct proc *); 565 void endtsleep(void *); 566 int wakeup_proc(struct proc *, int); 567 void unsleep(struct proc *); 568 void reaper(void *); 569 __dead void exit1(struct proc *, int, int, int); 570 void exit2(struct proc *); 571 void cpu_fork(struct proc *_curp, struct proc *_child, void *_stack, 572 void *_tcb, void (*_func)(void *), void *_arg); 573 void cpu_exit(struct proc *); 574 void process_initialize(struct process *, struct proc *); 575 int fork1(struct proc *_curp, int _flags, void (*_func)(void *), 576 void *_arg, register_t *_retval, struct proc **_newprocp); 577 int thread_fork(struct proc *_curp, void *_stack, void *_tcb, 578 pid_t *_tidptr, register_t *_retval); 579 int groupmember(gid_t, struct ucred *); 580 void dorefreshcreds(struct process *, struct proc *); 581 void dosigsuspend(struct proc *, sigset_t); 582 583 static inline void 584 refreshcreds(struct proc *p) 585 { 586 struct process *pr = p->p_p; 587 588 /* this is an unlocked access to ps_ucred, but the result is benign */ 589 if (pr->ps_ucred != p->p_ucred) 590 dorefreshcreds(pr, p); 591 } 592 593 #define SINGLE_SUSPEND 0x01 /* other threads to stop wherever they are */ 594 #define SINGLE_UNWIND 0x02 /* other threads to unwind and stop */ 595 #define SINGLE_EXIT 0x03 /* other threads to unwind and then exit */ 596 #define SINGLE_MASK 0x0f 597 /* extra flags for single_thread_set */ 598 #define SINGLE_DEEP 0x10 /* call is in deep */ 599 #define SINGLE_NOWAIT 0x20 /* do not wait for other threads to stop */ 600 601 int single_thread_set(struct proc *, int); 602 int single_thread_wait(struct process *, int); 603 void single_thread_clear(struct proc *); 604 int single_thread_check(struct proc *, int); 605 606 void child_return(void *); 607 608 int proc_cansugid(struct proc *); 609 610 struct cond { 611 unsigned int c_wait; /* [a] initialized and waiting */ 612 }; 613 614 #define COND_INITIALIZER() { .c_wait = 1 } 615 616 void proc_trampoline_mi(void); 617 618 /* 619 * functions to handle sets of cpus. 620 * 621 * For now we keep the cpus in ints so that we can use the generic 622 * atomic ops. 623 */ 624 #define CPUSET_ASIZE(x) (((x) - 1)/32 + 1) 625 #define CPUSET_SSIZE CPUSET_ASIZE(MAXCPUS) 626 struct cpuset { 627 int cs_set[CPUSET_SSIZE]; 628 }; 629 630 void cpuset_init_cpu(struct cpu_info *); 631 632 void cpuset_clear(struct cpuset *); 633 void cpuset_add(struct cpuset *, struct cpu_info *); 634 void cpuset_del(struct cpuset *, struct cpu_info *); 635 int cpuset_isset(struct cpuset *, struct cpu_info *); 636 void cpuset_add_all(struct cpuset *); 637 void cpuset_copy(struct cpuset *, struct cpuset *); 638 void cpuset_union(struct cpuset *, struct cpuset *, struct cpuset *); 639 void cpuset_intersection(struct cpuset *t, struct cpuset *, struct cpuset *); 640 void cpuset_complement(struct cpuset *, struct cpuset *, struct cpuset *); 641 int cpuset_cardinality(struct cpuset *); 642 struct cpu_info *cpuset_first(struct cpuset *); 643 644 static inline void 645 tu_enter(struct tusage *tu) 646 { 647 ++tu->tu_gen; /* make the generation number odd */ 648 membar_producer(); 649 } 650 651 static inline void 652 tu_leave(struct tusage *tu) 653 { 654 membar_producer(); 655 ++tu->tu_gen; /* make the generation number even again */ 656 } 657 658 #endif /* _KERNEL */ 659 #endif /* !_SYS_PROC_H_ */ 660 661