1 /* $NetBSD: kern_proc.c,v 1.127 2007/12/05 07:06:53 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2006, 2007 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center, and by Andrew Doran. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Copyright (c) 1982, 1986, 1989, 1991, 1993 42 * The Regents of the University of California. All rights reserved. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 3. Neither the name of the University nor the names of its contributors 53 * may be used to endorse or promote products derived from this software 54 * without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 66 * SUCH DAMAGE. 67 * 68 * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 69 */ 70 71 #include <sys/cdefs.h> 72 __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.127 2007/12/05 07:06:53 ad Exp $"); 73 74 #include "opt_kstack.h" 75 #include "opt_maxuprc.h" 76 #include "opt_multiprocessor.h" 77 #include "opt_lockdebug.h" 78 79 #include <sys/param.h> 80 #include <sys/systm.h> 81 #include <sys/kernel.h> 82 #include <sys/proc.h> 83 #include <sys/resourcevar.h> 84 #include <sys/buf.h> 85 #include <sys/acct.h> 86 #include <sys/wait.h> 87 #include <sys/file.h> 88 #include <ufs/ufs/quota.h> 89 #include <sys/uio.h> 90 #include <sys/malloc.h> 91 #include <sys/pool.h> 92 #include <sys/mbuf.h> 93 #include <sys/ioctl.h> 94 #include <sys/tty.h> 95 #include <sys/signalvar.h> 96 #include <sys/ras.h> 97 #include <sys/filedesc.h> 98 #include "sys/syscall_stats.h" 99 #include <sys/kauth.h> 100 #include <sys/sleepq.h> 101 #include <sys/atomic.h> 102 103 #include <uvm/uvm.h> 104 #include <uvm/uvm_extern.h> 105 106 /* 107 * Other process lists 108 */ 109 110 struct proclist allproc; 111 struct proclist zombproc; /* resources have been freed */ 112 113 /* 114 * There are two locks on global process state. 115 * 116 * 1. proclist_lock is an adaptive mutex and is used when modifying 117 * or examining process state from a process context. It protects 118 * the internal tables, all of the process lists, and a number of 119 * members of struct proc. 120 * 121 * 2. proclist_mutex is used when allproc must be traversed from an 122 * interrupt context, or when changing the state of processes. The 123 * proclist_lock should always be used in preference. In some cases, 124 * both locks need to be held. 125 * 126 * proclist_lock proclist_mutex structure 127 * --------------- --------------- ----------------- 128 * x zombproc 129 * x x pid_table 130 * x proc::p_pptr 131 * x proc::p_sibling 132 * x proc::p_children 133 * x alllwp 134 * x x allproc 135 * x x proc::p_pgrp 136 * x x proc::p_pglist 137 * x x proc::p_session 138 * x x proc::p_list 139 * x lwp::l_list 140 * 141 * The lock order for processes and LWPs is approximately as following: 142 * 143 * kernel_lock 144 * -> proclist_lock 145 * -> proc::p_mutex 146 * -> proclist_mutex 147 * -> proc::p_smutex 148 * -> proc::p_stmutex 149 * 150 * XXX p_smutex can be run at IPL_VM once audio drivers on the x86 151 * platform are made MP safe. Currently it blocks interrupts at 152 * IPL_SCHED and below. 153 * 154 * XXX The two process locks (p_smutex + p_mutex), and the two global 155 * state locks (proclist_lock + proclist_mutex) should be merged 156 * together. However, to do so requires interrupts that interrupts 157 * be run with LWP context. 158 */ 159 kmutex_t proclist_lock; 160 kmutex_t proclist_mutex; 161 162 /* 163 * pid to proc lookup is done by indexing the pid_table array. 164 * Since pid numbers are only allocated when an empty slot 165 * has been found, there is no need to search any lists ever. 166 * (an orphaned pgrp will lock the slot, a session will lock 167 * the pgrp with the same number.) 168 * If the table is too small it is reallocated with twice the 169 * previous size and the entries 'unzipped' into the two halves. 170 * A linked list of free entries is passed through the pt_proc 171 * field of 'free' items - set odd to be an invalid ptr. 172 */ 173 174 struct pid_table { 175 struct proc *pt_proc; 176 struct pgrp *pt_pgrp; 177 }; 178 #if 1 /* strongly typed cast - should be a noop */ 179 static inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; } 180 #else 181 #define p2u(p) ((uint)p) 182 #endif 183 #define P_VALID(p) (!(p2u(p) & 1)) 184 #define P_NEXT(p) (p2u(p) >> 1) 185 #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1)) 186 187 #define INITIAL_PID_TABLE_SIZE (1 << 5) 188 static struct pid_table *pid_table; 189 static uint pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1; 190 static uint pid_alloc_lim; /* max we allocate before growing table */ 191 static uint pid_alloc_cnt; /* number of allocated pids */ 192 193 /* links through free slots - never empty! */ 194 static uint next_free_pt, last_free_pt; 195 static pid_t pid_max = PID_MAX; /* largest value we allocate */ 196 197 /* Components of the first process -- never freed. */ 198 199 extern const struct emul emul_netbsd; /* defined in kern_exec.c */ 200 201 struct session session0 = { 202 .s_count = 1, 203 .s_sid = 0, 204 }; 205 struct pgrp pgrp0 = { 206 .pg_members = LIST_HEAD_INITIALIZER(&pgrp0.pg_members), 207 .pg_session = &session0, 208 }; 209 struct filedesc0 filedesc0; 210 struct cwdinfo cwdi0 = { 211 .cwdi_cmask = CMASK, /* see cmask below */ 212 .cwdi_refcnt = 1, 213 }; 214 struct plimit limit0 = { 215 .pl_corename = defcorename, 216 .pl_refcnt = 1, 217 .pl_rlimit = { 218 [0 ... __arraycount(limit0.pl_rlimit) - 1] = { 219 .rlim_cur = RLIM_INFINITY, 220 .rlim_max = RLIM_INFINITY, 221 }, 222 }, 223 }; 224 struct pstats pstat0; 225 struct vmspace vmspace0; 226 struct sigacts sigacts0; 227 struct turnstile turnstile0; 228 struct proc proc0 = { 229 .p_lwps = LIST_HEAD_INITIALIZER(&proc0.p_lwps), 230 .p_sigwaiters = LIST_HEAD_INITIALIZER(&proc0.p_sigwaiters), 231 .p_nlwps = 1, 232 .p_nrlwps = 1, 233 .p_nlwpid = 1, /* must match lwp0.l_lid */ 234 .p_pgrp = &pgrp0, 235 .p_comm = "system", 236 /* 237 * Set P_NOCLDWAIT so that kernel threads are reparented to init(8) 238 * when they exit. init(8) can easily wait them out for us. 239 */ 240 .p_flag = PK_SYSTEM | PK_NOCLDWAIT, 241 .p_stat = SACTIVE, 242 .p_nice = NZERO, 243 .p_emul = &emul_netbsd, 244 .p_cwdi = &cwdi0, 245 .p_limit = &limit0, 246 .p_fd = &filedesc0.fd_fd, 247 .p_vmspace = &vmspace0, 248 .p_stats = &pstat0, 249 .p_sigacts = &sigacts0, 250 }; 251 struct lwp lwp0 __aligned(MIN_LWP_ALIGNMENT) = { 252 #ifdef LWP0_CPU_INFO 253 .l_cpu = LWP0_CPU_INFO, 254 #endif 255 .l_proc = &proc0, 256 .l_lid = 1, 257 .l_flag = LW_INMEM | LW_SYSTEM, 258 .l_stat = LSONPROC, 259 .l_ts = &turnstile0, 260 .l_syncobj = &sched_syncobj, 261 .l_refcnt = 1, 262 .l_priority = PRI_USER + NPRI_USER - 1, 263 .l_inheritedprio = -1, 264 .l_class = SCHED_OTHER, 265 .l_pi_lenders = SLIST_HEAD_INITIALIZER(&lwp0.l_pi_lenders), 266 .l_name = __UNCONST("swapper"), 267 }; 268 kauth_cred_t cred0; 269 270 extern struct user *proc0paddr; 271 272 int nofile = NOFILE; 273 int maxuprc = MAXUPRC; 274 int cmask = CMASK; 275 276 POOL_INIT(proc_pool, sizeof(struct proc), 0, 0, 0, "procpl", 277 &pool_allocator_nointr, IPL_NONE); 278 POOL_INIT(pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl", 279 &pool_allocator_nointr, IPL_NONE); 280 POOL_INIT(plimit_pool, sizeof(struct plimit), 0, 0, 0, "plimitpl", 281 &pool_allocator_nointr, IPL_NONE); 282 POOL_INIT(pstats_pool, sizeof(struct pstats), 0, 0, 0, "pstatspl", 283 &pool_allocator_nointr, IPL_NONE); 284 POOL_INIT(session_pool, sizeof(struct session), 0, 0, 0, "sessionpl", 285 &pool_allocator_nointr, IPL_NONE); 286 287 MALLOC_DEFINE(M_EMULDATA, "emuldata", "Per-process emulation data"); 288 MALLOC_DEFINE(M_PROC, "proc", "Proc structures"); 289 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); 290 291 /* 292 * The process list descriptors, used during pid allocation and 293 * by sysctl. No locking on this data structure is needed since 294 * it is completely static. 295 */ 296 const struct proclist_desc proclists[] = { 297 { &allproc }, 298 { &zombproc }, 299 { NULL }, 300 }; 301 302 static void orphanpg(struct pgrp *); 303 static void pg_delete(pid_t); 304 305 static specificdata_domain_t proc_specificdata_domain; 306 307 /* 308 * Initialize global process hashing structures. 309 */ 310 void 311 procinit(void) 312 { 313 const struct proclist_desc *pd; 314 int i; 315 #define LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1)) 316 317 for (pd = proclists; pd->pd_list != NULL; pd++) 318 LIST_INIT(pd->pd_list); 319 320 mutex_init(&proclist_lock, MUTEX_DEFAULT, IPL_NONE); 321 mutex_init(&proclist_mutex, MUTEX_DEFAULT, IPL_SCHED); 322 323 pid_table = malloc(INITIAL_PID_TABLE_SIZE * sizeof *pid_table, 324 M_PROC, M_WAITOK); 325 /* Set free list running through table... 326 Preset 'use count' above PID_MAX so we allocate pid 1 next. */ 327 for (i = 0; i <= pid_tbl_mask; i++) { 328 pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1); 329 pid_table[i].pt_pgrp = 0; 330 } 331 /* slot 0 is just grabbed */ 332 next_free_pt = 1; 333 /* Need to fix last entry. */ 334 last_free_pt = pid_tbl_mask; 335 pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY); 336 /* point at which we grow table - to avoid reusing pids too often */ 337 pid_alloc_lim = pid_tbl_mask - 1; 338 #undef LINK_EMPTY 339 340 uihashtbl = 341 hashinit(maxproc / 16, HASH_LIST, M_PROC, M_WAITOK, &uihash); 342 343 proc_specificdata_domain = specificdata_domain_create(); 344 KASSERT(proc_specificdata_domain != NULL); 345 } 346 347 /* 348 * Initialize process 0. 349 */ 350 void 351 proc0_init(void) 352 { 353 struct proc *p; 354 struct pgrp *pg; 355 struct session *sess; 356 struct lwp *l; 357 rlim_t lim; 358 359 p = &proc0; 360 pg = &pgrp0; 361 sess = &session0; 362 l = &lwp0; 363 364 KASSERT(l->l_lid == p->p_nlwpid); 365 366 mutex_init(&p->p_smutex, MUTEX_DEFAULT, IPL_SCHED); 367 mutex_init(&p->p_stmutex, MUTEX_DEFAULT, IPL_HIGH); 368 mutex_init(&p->p_raslock, MUTEX_DEFAULT, IPL_NONE); 369 mutex_init(&p->p_mutex, MUTEX_DEFAULT, IPL_NONE); 370 mutex_init(&l->l_swaplock, MUTEX_DEFAULT, IPL_NONE); 371 372 rw_init(&p->p_reflock); 373 cv_init(&p->p_waitcv, "wait"); 374 cv_init(&p->p_lwpcv, "lwpwait"); 375 376 LIST_INSERT_HEAD(&p->p_lwps, l, l_sibling); 377 378 pid_table[0].pt_proc = p; 379 LIST_INSERT_HEAD(&allproc, p, p_list); 380 LIST_INSERT_HEAD(&alllwp, l, l_list); 381 382 pid_table[0].pt_pgrp = pg; 383 LIST_INSERT_HEAD(&pg->pg_members, p, p_pglist); 384 385 #ifdef __HAVE_SYSCALL_INTERN 386 (*p->p_emul->e_syscall_intern)(p); 387 #endif 388 389 callout_init(&l->l_timeout_ch, CALLOUT_MPSAFE); 390 callout_setfunc(&l->l_timeout_ch, sleepq_timeout, l); 391 cv_init(&l->l_sigcv, "sigwait"); 392 393 /* Create credentials. */ 394 cred0 = kauth_cred_alloc(); 395 p->p_cred = cred0; 396 kauth_cred_hold(cred0); 397 l->l_cred = cred0; 398 399 /* Create the CWD info. */ 400 rw_init(&cwdi0.cwdi_lock); 401 402 /* Create the limits structures. */ 403 mutex_init(&limit0.pl_lock, MUTEX_DEFAULT, IPL_NONE); 404 405 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles; 406 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = 407 maxfiles < nofile ? maxfiles : nofile; 408 409 limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc; 410 limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = 411 maxproc < maxuprc ? maxproc : maxuprc; 412 413 lim = ptoa(uvmexp.free); 414 limit0.pl_rlimit[RLIMIT_RSS].rlim_max = lim; 415 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim; 416 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3; 417 418 /* Configure virtual memory system, set vm rlimits. */ 419 uvm_init_limits(p); 420 421 /* Initialize file descriptor table for proc0. */ 422 fdinit1(&filedesc0); 423 424 /* 425 * Initialize proc0's vmspace, which uses the kernel pmap. 426 * All kernel processes (which never have user space mappings) 427 * share proc0's vmspace, and thus, the kernel pmap. 428 */ 429 uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS), 430 trunc_page(VM_MAX_ADDRESS)); 431 432 l->l_addr = proc0paddr; /* XXX */ 433 434 /* Initialize signal state for proc0. XXX IPL_SCHED */ 435 mutex_init(&p->p_sigacts->sa_mutex, MUTEX_DEFAULT, IPL_SCHED); 436 siginit(p); 437 438 proc_initspecific(p); 439 lwp_initspecific(l); 440 441 SYSCALL_TIME_LWP_INIT(l); 442 } 443 444 /* 445 * Check that the specified process group is in the session of the 446 * specified process. 447 * Treats -ve ids as process ids. 448 * Used to validate TIOCSPGRP requests. 449 */ 450 int 451 pgid_in_session(struct proc *p, pid_t pg_id) 452 { 453 struct pgrp *pgrp; 454 struct session *session; 455 int error; 456 457 mutex_enter(&proclist_lock); 458 if (pg_id < 0) { 459 struct proc *p1 = p_find(-pg_id, PFIND_LOCKED | PFIND_UNLOCK_FAIL); 460 if (p1 == NULL) 461 return EINVAL; 462 pgrp = p1->p_pgrp; 463 } else { 464 pgrp = pg_find(pg_id, PFIND_LOCKED | PFIND_UNLOCK_FAIL); 465 if (pgrp == NULL) 466 return EINVAL; 467 } 468 session = pgrp->pg_session; 469 if (session != p->p_pgrp->pg_session) 470 error = EPERM; 471 else 472 error = 0; 473 mutex_exit(&proclist_lock); 474 475 return error; 476 } 477 478 /* 479 * Is p an inferior of q? 480 * 481 * Call with the proclist_lock held. 482 */ 483 int 484 inferior(struct proc *p, struct proc *q) 485 { 486 487 for (; p != q; p = p->p_pptr) 488 if (p->p_pid == 0) 489 return 0; 490 return 1; 491 } 492 493 /* 494 * Locate a process by number 495 */ 496 struct proc * 497 p_find(pid_t pid, uint flags) 498 { 499 struct proc *p; 500 char stat; 501 502 if (!(flags & PFIND_LOCKED)) 503 mutex_enter(&proclist_lock); 504 505 p = pid_table[pid & pid_tbl_mask].pt_proc; 506 507 /* Only allow live processes to be found by pid. */ 508 /* XXXSMP p_stat */ 509 if (P_VALID(p) && p->p_pid == pid && ((stat = p->p_stat) == SACTIVE || 510 stat == SSTOP || ((flags & PFIND_ZOMBIE) && 511 (stat == SZOMB || stat == SDEAD || stat == SDYING)))) { 512 if (flags & PFIND_UNLOCK_OK) 513 mutex_exit(&proclist_lock); 514 return p; 515 } 516 if (flags & PFIND_UNLOCK_FAIL) 517 mutex_exit(&proclist_lock); 518 return NULL; 519 } 520 521 522 /* 523 * Locate a process group by number 524 */ 525 struct pgrp * 526 pg_find(pid_t pgid, uint flags) 527 { 528 struct pgrp *pg; 529 530 if (!(flags & PFIND_LOCKED)) 531 mutex_enter(&proclist_lock); 532 pg = pid_table[pgid & pid_tbl_mask].pt_pgrp; 533 /* 534 * Can't look up a pgrp that only exists because the session 535 * hasn't died yet (traditional) 536 */ 537 if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) { 538 if (flags & PFIND_UNLOCK_FAIL) 539 mutex_exit(&proclist_lock); 540 return NULL; 541 } 542 543 if (flags & PFIND_UNLOCK_OK) 544 mutex_exit(&proclist_lock); 545 return pg; 546 } 547 548 static void 549 expand_pid_table(void) 550 { 551 uint pt_size = pid_tbl_mask + 1; 552 struct pid_table *n_pt, *new_pt; 553 struct proc *proc; 554 struct pgrp *pgrp; 555 int i; 556 pid_t pid; 557 558 new_pt = malloc(pt_size * 2 * sizeof *new_pt, M_PROC, M_WAITOK); 559 560 mutex_enter(&proclist_lock); 561 if (pt_size != pid_tbl_mask + 1) { 562 /* Another process beat us to it... */ 563 mutex_exit(&proclist_lock); 564 FREE(new_pt, M_PROC); 565 return; 566 } 567 568 /* 569 * Copy entries from old table into new one. 570 * If 'pid' is 'odd' we need to place in the upper half, 571 * even pid's to the lower half. 572 * Free items stay in the low half so we don't have to 573 * fixup the reference to them. 574 * We stuff free items on the front of the freelist 575 * because we can't write to unmodified entries. 576 * Processing the table backwards maintains a semblance 577 * of issueing pid numbers that increase with time. 578 */ 579 i = pt_size - 1; 580 n_pt = new_pt + i; 581 for (; ; i--, n_pt--) { 582 proc = pid_table[i].pt_proc; 583 pgrp = pid_table[i].pt_pgrp; 584 if (!P_VALID(proc)) { 585 /* Up 'use count' so that link is valid */ 586 pid = (P_NEXT(proc) + pt_size) & ~pt_size; 587 proc = P_FREE(pid); 588 if (pgrp) 589 pid = pgrp->pg_id; 590 } else 591 pid = proc->p_pid; 592 593 /* Save entry in appropriate half of table */ 594 n_pt[pid & pt_size].pt_proc = proc; 595 n_pt[pid & pt_size].pt_pgrp = pgrp; 596 597 /* Put other piece on start of free list */ 598 pid = (pid ^ pt_size) & ~pid_tbl_mask; 599 n_pt[pid & pt_size].pt_proc = 600 P_FREE((pid & ~pt_size) | next_free_pt); 601 n_pt[pid & pt_size].pt_pgrp = 0; 602 next_free_pt = i | (pid & pt_size); 603 if (i == 0) 604 break; 605 } 606 607 /* Switch tables */ 608 mutex_enter(&proclist_mutex); 609 n_pt = pid_table; 610 pid_table = new_pt; 611 mutex_exit(&proclist_mutex); 612 pid_tbl_mask = pt_size * 2 - 1; 613 614 /* 615 * pid_max starts as PID_MAX (= 30000), once we have 16384 616 * allocated pids we need it to be larger! 617 */ 618 if (pid_tbl_mask > PID_MAX) { 619 pid_max = pid_tbl_mask * 2 + 1; 620 pid_alloc_lim |= pid_alloc_lim << 1; 621 } else 622 pid_alloc_lim <<= 1; /* doubles number of free slots... */ 623 624 mutex_exit(&proclist_lock); 625 FREE(n_pt, M_PROC); 626 } 627 628 struct proc * 629 proc_alloc(void) 630 { 631 struct proc *p; 632 int nxt; 633 pid_t pid; 634 struct pid_table *pt; 635 636 p = pool_get(&proc_pool, PR_WAITOK); 637 p->p_stat = SIDL; /* protect against others */ 638 639 proc_initspecific(p); 640 /* allocate next free pid */ 641 642 for (;;expand_pid_table()) { 643 if (__predict_false(pid_alloc_cnt >= pid_alloc_lim)) 644 /* ensure pids cycle through 2000+ values */ 645 continue; 646 mutex_enter(&proclist_lock); 647 pt = &pid_table[next_free_pt]; 648 #ifdef DIAGNOSTIC 649 if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp)) 650 panic("proc_alloc: slot busy"); 651 #endif 652 nxt = P_NEXT(pt->pt_proc); 653 if (nxt & pid_tbl_mask) 654 break; 655 /* Table full - expand (NB last entry not used....) */ 656 mutex_exit(&proclist_lock); 657 } 658 659 /* pid is 'saved use count' + 'size' + entry */ 660 pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt; 661 if ((uint)pid > (uint)pid_max) 662 pid &= pid_tbl_mask; 663 p->p_pid = pid; 664 next_free_pt = nxt & pid_tbl_mask; 665 666 /* Grab table slot */ 667 mutex_enter(&proclist_mutex); 668 pt->pt_proc = p; 669 mutex_exit(&proclist_mutex); 670 pid_alloc_cnt++; 671 672 mutex_exit(&proclist_lock); 673 674 return p; 675 } 676 677 /* 678 * Free a process id - called from proc_free (in kern_exit.c) 679 * 680 * Called with the proclist_lock held. 681 */ 682 void 683 proc_free_pid(struct proc *p) 684 { 685 pid_t pid = p->p_pid; 686 struct pid_table *pt; 687 688 KASSERT(mutex_owned(&proclist_lock)); 689 690 pt = &pid_table[pid & pid_tbl_mask]; 691 #ifdef DIAGNOSTIC 692 if (__predict_false(pt->pt_proc != p)) 693 panic("proc_free: pid_table mismatch, pid %x, proc %p", 694 pid, p); 695 #endif 696 mutex_enter(&proclist_mutex); 697 /* save pid use count in slot */ 698 pt->pt_proc = P_FREE(pid & ~pid_tbl_mask); 699 700 if (pt->pt_pgrp == NULL) { 701 /* link last freed entry onto ours */ 702 pid &= pid_tbl_mask; 703 pt = &pid_table[last_free_pt]; 704 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid); 705 last_free_pt = pid; 706 pid_alloc_cnt--; 707 } 708 mutex_exit(&proclist_mutex); 709 710 atomic_dec_uint(&nprocs); 711 } 712 713 /* 714 * Move p to a new or existing process group (and session) 715 * 716 * If we are creating a new pgrp, the pgid should equal 717 * the calling process' pid. 718 * If is only valid to enter a process group that is in the session 719 * of the process. 720 * Also mksess should only be set if we are creating a process group 721 * 722 * Only called from sys_setsid, sys_setpgid/sys_setpgrp and the 723 * SYSV setpgrp support for hpux. 724 */ 725 int 726 enterpgrp(struct proc *curp, pid_t pid, pid_t pgid, int mksess) 727 { 728 struct pgrp *new_pgrp, *pgrp; 729 struct session *sess; 730 struct proc *p; 731 int rval; 732 pid_t pg_id = NO_PGID; 733 734 if (mksess) 735 sess = pool_get(&session_pool, PR_WAITOK); 736 else 737 sess = NULL; 738 739 /* Allocate data areas we might need before doing any validity checks */ 740 mutex_enter(&proclist_lock); /* Because pid_table might change */ 741 if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) { 742 mutex_exit(&proclist_lock); 743 new_pgrp = pool_get(&pgrp_pool, PR_WAITOK); 744 mutex_enter(&proclist_lock); 745 } else 746 new_pgrp = NULL; 747 rval = EPERM; /* most common error (to save typing) */ 748 749 /* Check pgrp exists or can be created */ 750 pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp; 751 if (pgrp != NULL && pgrp->pg_id != pgid) 752 goto done; 753 754 /* Can only set another process under restricted circumstances. */ 755 if (pid != curp->p_pid) { 756 /* must exist and be one of our children... */ 757 if ((p = p_find(pid, PFIND_LOCKED)) == NULL || 758 !inferior(p, curp)) { 759 rval = ESRCH; 760 goto done; 761 } 762 /* ... in the same session... */ 763 if (sess != NULL || p->p_session != curp->p_session) 764 goto done; 765 /* ... existing pgid must be in same session ... */ 766 if (pgrp != NULL && pgrp->pg_session != p->p_session) 767 goto done; 768 /* ... and not done an exec. */ 769 if (p->p_flag & PK_EXEC) { 770 rval = EACCES; 771 goto done; 772 } 773 } else { 774 /* ... setsid() cannot re-enter a pgrp */ 775 if (mksess && (curp->p_pgid == curp->p_pid || 776 pg_find(curp->p_pid, PFIND_LOCKED))) 777 goto done; 778 p = curp; 779 } 780 781 /* Changing the process group/session of a session 782 leader is definitely off limits. */ 783 if (SESS_LEADER(p)) { 784 if (sess == NULL && p->p_pgrp == pgrp) 785 /* unless it's a definite noop */ 786 rval = 0; 787 goto done; 788 } 789 790 /* Can only create a process group with id of process */ 791 if (pgrp == NULL && pgid != pid) 792 goto done; 793 794 /* Can only create a session if creating pgrp */ 795 if (sess != NULL && pgrp != NULL) 796 goto done; 797 798 /* Check we allocated memory for a pgrp... */ 799 if (pgrp == NULL && new_pgrp == NULL) 800 goto done; 801 802 /* Don't attach to 'zombie' pgrp */ 803 if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members)) 804 goto done; 805 806 /* Expect to succeed now */ 807 rval = 0; 808 809 if (pgrp == p->p_pgrp) 810 /* nothing to do */ 811 goto done; 812 813 /* Ok all setup, link up required structures */ 814 815 if (pgrp == NULL) { 816 pgrp = new_pgrp; 817 new_pgrp = 0; 818 if (sess != NULL) { 819 sess->s_sid = p->p_pid; 820 sess->s_leader = p; 821 sess->s_count = 1; 822 sess->s_ttyvp = NULL; 823 sess->s_ttyp = NULL; 824 sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET; 825 memcpy(sess->s_login, p->p_session->s_login, 826 sizeof(sess->s_login)); 827 p->p_lflag &= ~PL_CONTROLT; 828 } else { 829 sess = p->p_pgrp->pg_session; 830 SESSHOLD(sess); 831 } 832 pgrp->pg_session = sess; 833 sess = 0; 834 835 pgrp->pg_id = pgid; 836 LIST_INIT(&pgrp->pg_members); 837 #ifdef DIAGNOSTIC 838 if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp)) 839 panic("enterpgrp: pgrp table slot in use"); 840 if (__predict_false(mksess && p != curp)) 841 panic("enterpgrp: mksession and p != curproc"); 842 #endif 843 mutex_enter(&proclist_mutex); 844 pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp; 845 pgrp->pg_jobc = 0; 846 } else 847 mutex_enter(&proclist_mutex); 848 849 #ifdef notyet 850 /* 851 * If there's a controlling terminal for the current session, we 852 * have to interlock with it. See ttread(). 853 */ 854 if (p->p_session->s_ttyvp != NULL) { 855 tp = p->p_session->s_ttyp; 856 mutex_enter(&tp->t_mutex); 857 } else 858 tp = NULL; 859 #endif 860 861 /* 862 * Adjust eligibility of affected pgrps to participate in job control. 863 * Increment eligibility counts before decrementing, otherwise we 864 * could reach 0 spuriously during the first call. 865 */ 866 fixjobc(p, pgrp, 1); 867 fixjobc(p, p->p_pgrp, 0); 868 869 /* Move process to requested group. */ 870 LIST_REMOVE(p, p_pglist); 871 if (LIST_EMPTY(&p->p_pgrp->pg_members)) 872 /* defer delete until we've dumped the lock */ 873 pg_id = p->p_pgrp->pg_id; 874 p->p_pgrp = pgrp; 875 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); 876 mutex_exit(&proclist_mutex); 877 878 #ifdef notyet 879 /* Done with the swap; we can release the tty mutex. */ 880 if (tp != NULL) 881 mutex_exit(&tp->t_mutex); 882 #endif 883 884 done: 885 if (pg_id != NO_PGID) 886 pg_delete(pg_id); 887 mutex_exit(&proclist_lock); 888 if (sess != NULL) 889 pool_put(&session_pool, sess); 890 if (new_pgrp != NULL) 891 pool_put(&pgrp_pool, new_pgrp); 892 #ifdef DEBUG_PGRP 893 if (__predict_false(rval)) 894 printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n", 895 pid, pgid, mksess, curp->p_pid, rval); 896 #endif 897 return rval; 898 } 899 900 /* 901 * Remove a process from its process group. Must be called with the 902 * proclist_lock held. 903 */ 904 void 905 leavepgrp(struct proc *p) 906 { 907 struct pgrp *pgrp; 908 909 KASSERT(mutex_owned(&proclist_lock)); 910 911 /* 912 * If there's a controlling terminal for the session, we have to 913 * interlock with it. See ttread(). 914 */ 915 mutex_enter(&proclist_mutex); 916 #ifdef notyet 917 if (p_>p_session->s_ttyvp != NULL) { 918 tp = p->p_session->s_ttyp; 919 mutex_enter(&tp->t_mutex); 920 } else 921 tp = NULL; 922 #endif 923 924 pgrp = p->p_pgrp; 925 LIST_REMOVE(p, p_pglist); 926 p->p_pgrp = NULL; 927 928 #ifdef notyet 929 if (tp != NULL) 930 mutex_exit(&tp->t_mutex); 931 #endif 932 mutex_exit(&proclist_mutex); 933 934 if (LIST_EMPTY(&pgrp->pg_members)) 935 pg_delete(pgrp->pg_id); 936 } 937 938 /* 939 * Free a process group. Must be called with the proclist_lock held. 940 */ 941 static void 942 pg_free(pid_t pg_id) 943 { 944 struct pgrp *pgrp; 945 struct pid_table *pt; 946 947 KASSERT(mutex_owned(&proclist_lock)); 948 949 pt = &pid_table[pg_id & pid_tbl_mask]; 950 pgrp = pt->pt_pgrp; 951 #ifdef DIAGNOSTIC 952 if (__predict_false(!pgrp || pgrp->pg_id != pg_id 953 || !LIST_EMPTY(&pgrp->pg_members))) 954 panic("pg_free: process group absent or has members"); 955 #endif 956 pt->pt_pgrp = 0; 957 958 if (!P_VALID(pt->pt_proc)) { 959 /* orphaned pgrp, put slot onto free list */ 960 #ifdef DIAGNOSTIC 961 if (__predict_false(P_NEXT(pt->pt_proc) & pid_tbl_mask)) 962 panic("pg_free: process slot on free list"); 963 #endif 964 mutex_enter(&proclist_mutex); 965 pg_id &= pid_tbl_mask; 966 pt = &pid_table[last_free_pt]; 967 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id); 968 mutex_exit(&proclist_mutex); 969 last_free_pt = pg_id; 970 pid_alloc_cnt--; 971 } 972 pool_put(&pgrp_pool, pgrp); 973 } 974 975 /* 976 * Delete a process group. Must be called with the proclist_lock held. 977 */ 978 static void 979 pg_delete(pid_t pg_id) 980 { 981 struct pgrp *pgrp; 982 struct tty *ttyp; 983 struct session *ss; 984 int is_pgrp_leader; 985 986 KASSERT(mutex_owned(&proclist_lock)); 987 988 pgrp = pid_table[pg_id & pid_tbl_mask].pt_pgrp; 989 if (pgrp == NULL || pgrp->pg_id != pg_id || 990 !LIST_EMPTY(&pgrp->pg_members)) 991 return; 992 993 ss = pgrp->pg_session; 994 995 /* Remove reference (if any) from tty to this process group */ 996 ttyp = ss->s_ttyp; 997 if (ttyp != NULL && ttyp->t_pgrp == pgrp) { 998 ttyp->t_pgrp = NULL; 999 #ifdef DIAGNOSTIC 1000 if (ttyp->t_session != ss) 1001 panic("pg_delete: wrong session on terminal"); 1002 #endif 1003 } 1004 1005 /* 1006 * The leading process group in a session is freed 1007 * by sessdelete() if last reference. 1008 */ 1009 is_pgrp_leader = (ss->s_sid == pgrp->pg_id); 1010 SESSRELE(ss); 1011 1012 if (is_pgrp_leader) 1013 return; 1014 1015 pg_free(pg_id); 1016 } 1017 1018 /* 1019 * Delete session - called from SESSRELE when s_count becomes zero. 1020 * Must be called with the proclist_lock held. 1021 */ 1022 void 1023 sessdelete(struct session *ss) 1024 { 1025 1026 KASSERT(mutex_owned(&proclist_lock)); 1027 1028 /* 1029 * We keep the pgrp with the same id as the session in 1030 * order to stop a process being given the same pid. 1031 * Since the pgrp holds a reference to the session, it 1032 * must be a 'zombie' pgrp by now. 1033 */ 1034 pg_free(ss->s_sid); 1035 pool_put(&session_pool, ss); 1036 } 1037 1038 /* 1039 * Adjust pgrp jobc counters when specified process changes process group. 1040 * We count the number of processes in each process group that "qualify" 1041 * the group for terminal job control (those with a parent in a different 1042 * process group of the same session). If that count reaches zero, the 1043 * process group becomes orphaned. Check both the specified process' 1044 * process group and that of its children. 1045 * entering == 0 => p is leaving specified group. 1046 * entering == 1 => p is entering specified group. 1047 * 1048 * Call with proclist_lock held. 1049 */ 1050 void 1051 fixjobc(struct proc *p, struct pgrp *pgrp, int entering) 1052 { 1053 struct pgrp *hispgrp; 1054 struct session *mysession = pgrp->pg_session; 1055 struct proc *child; 1056 1057 KASSERT(mutex_owned(&proclist_lock)); 1058 KASSERT(mutex_owned(&proclist_mutex)); 1059 1060 /* 1061 * Check p's parent to see whether p qualifies its own process 1062 * group; if so, adjust count for p's process group. 1063 */ 1064 hispgrp = p->p_pptr->p_pgrp; 1065 if (hispgrp != pgrp && hispgrp->pg_session == mysession) { 1066 if (entering) { 1067 mutex_enter(&p->p_smutex); 1068 p->p_sflag &= ~PS_ORPHANPG; 1069 mutex_exit(&p->p_smutex); 1070 pgrp->pg_jobc++; 1071 } else if (--pgrp->pg_jobc == 0) 1072 orphanpg(pgrp); 1073 } 1074 1075 /* 1076 * Check this process' children to see whether they qualify 1077 * their process groups; if so, adjust counts for children's 1078 * process groups. 1079 */ 1080 LIST_FOREACH(child, &p->p_children, p_sibling) { 1081 hispgrp = child->p_pgrp; 1082 if (hispgrp != pgrp && hispgrp->pg_session == mysession && 1083 !P_ZOMBIE(child)) { 1084 if (entering) { 1085 mutex_enter(&child->p_smutex); 1086 child->p_sflag &= ~PS_ORPHANPG; 1087 mutex_exit(&child->p_smutex); 1088 hispgrp->pg_jobc++; 1089 } else if (--hispgrp->pg_jobc == 0) 1090 orphanpg(hispgrp); 1091 } 1092 } 1093 } 1094 1095 /* 1096 * A process group has become orphaned; 1097 * if there are any stopped processes in the group, 1098 * hang-up all process in that group. 1099 * 1100 * Call with proclist_lock held. 1101 */ 1102 static void 1103 orphanpg(struct pgrp *pg) 1104 { 1105 struct proc *p; 1106 int doit; 1107 1108 KASSERT(mutex_owned(&proclist_lock)); 1109 KASSERT(mutex_owned(&proclist_mutex)); 1110 1111 doit = 0; 1112 1113 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 1114 mutex_enter(&p->p_smutex); 1115 if (p->p_stat == SSTOP) { 1116 doit = 1; 1117 p->p_sflag |= PS_ORPHANPG; 1118 } 1119 mutex_exit(&p->p_smutex); 1120 } 1121 1122 if (doit) { 1123 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 1124 psignal(p, SIGHUP); 1125 psignal(p, SIGCONT); 1126 } 1127 } 1128 } 1129 1130 #ifdef DDB 1131 #include <ddb/db_output.h> 1132 void pidtbl_dump(void); 1133 void 1134 pidtbl_dump(void) 1135 { 1136 struct pid_table *pt; 1137 struct proc *p; 1138 struct pgrp *pgrp; 1139 int id; 1140 1141 db_printf("pid table %p size %x, next %x, last %x\n", 1142 pid_table, pid_tbl_mask+1, 1143 next_free_pt, last_free_pt); 1144 for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) { 1145 p = pt->pt_proc; 1146 if (!P_VALID(p) && !pt->pt_pgrp) 1147 continue; 1148 db_printf(" id %x: ", id); 1149 if (P_VALID(p)) 1150 db_printf("proc %p id %d (0x%x) %s\n", 1151 p, p->p_pid, p->p_pid, p->p_comm); 1152 else 1153 db_printf("next %x use %x\n", 1154 P_NEXT(p) & pid_tbl_mask, 1155 P_NEXT(p) & ~pid_tbl_mask); 1156 if ((pgrp = pt->pt_pgrp)) { 1157 db_printf("\tsession %p, sid %d, count %d, login %s\n", 1158 pgrp->pg_session, pgrp->pg_session->s_sid, 1159 pgrp->pg_session->s_count, 1160 pgrp->pg_session->s_login); 1161 db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n", 1162 pgrp, pgrp->pg_id, pgrp->pg_jobc, 1163 pgrp->pg_members.lh_first); 1164 for (p = pgrp->pg_members.lh_first; p != 0; 1165 p = p->p_pglist.le_next) { 1166 db_printf("\t\tpid %d addr %p pgrp %p %s\n", 1167 p->p_pid, p, p->p_pgrp, p->p_comm); 1168 } 1169 } 1170 } 1171 } 1172 #endif /* DDB */ 1173 1174 #ifdef KSTACK_CHECK_MAGIC 1175 #include <sys/user.h> 1176 1177 #define KSTACK_MAGIC 0xdeadbeaf 1178 1179 /* XXX should be per process basis? */ 1180 int kstackleftmin = KSTACK_SIZE; 1181 int kstackleftthres = KSTACK_SIZE / 8; /* warn if remaining stack is 1182 less than this */ 1183 1184 void 1185 kstack_setup_magic(const struct lwp *l) 1186 { 1187 uint32_t *ip; 1188 uint32_t const *end; 1189 1190 KASSERT(l != NULL); 1191 KASSERT(l != &lwp0); 1192 1193 /* 1194 * fill all the stack with magic number 1195 * so that later modification on it can be detected. 1196 */ 1197 ip = (uint32_t *)KSTACK_LOWEST_ADDR(l); 1198 end = (uint32_t *)((char *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE); 1199 for (; ip < end; ip++) { 1200 *ip = KSTACK_MAGIC; 1201 } 1202 } 1203 1204 void 1205 kstack_check_magic(const struct lwp *l) 1206 { 1207 uint32_t const *ip, *end; 1208 int stackleft; 1209 1210 KASSERT(l != NULL); 1211 1212 /* don't check proc0 */ /*XXX*/ 1213 if (l == &lwp0) 1214 return; 1215 1216 #ifdef __MACHINE_STACK_GROWS_UP 1217 /* stack grows upwards (eg. hppa) */ 1218 ip = (uint32_t *)((void *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE); 1219 end = (uint32_t *)KSTACK_LOWEST_ADDR(l); 1220 for (ip--; ip >= end; ip--) 1221 if (*ip != KSTACK_MAGIC) 1222 break; 1223 1224 stackleft = (void *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (void *)ip; 1225 #else /* __MACHINE_STACK_GROWS_UP */ 1226 /* stack grows downwards (eg. i386) */ 1227 ip = (uint32_t *)KSTACK_LOWEST_ADDR(l); 1228 end = (uint32_t *)((char *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE); 1229 for (; ip < end; ip++) 1230 if (*ip != KSTACK_MAGIC) 1231 break; 1232 1233 stackleft = ((const char *)ip) - (const char *)KSTACK_LOWEST_ADDR(l); 1234 #endif /* __MACHINE_STACK_GROWS_UP */ 1235 1236 if (kstackleftmin > stackleft) { 1237 kstackleftmin = stackleft; 1238 if (stackleft < kstackleftthres) 1239 printf("warning: kernel stack left %d bytes" 1240 "(pid %u:lid %u)\n", stackleft, 1241 (u_int)l->l_proc->p_pid, (u_int)l->l_lid); 1242 } 1243 1244 if (stackleft <= 0) { 1245 panic("magic on the top of kernel stack changed for " 1246 "pid %u, lid %u: maybe kernel stack overflow", 1247 (u_int)l->l_proc->p_pid, (u_int)l->l_lid); 1248 } 1249 } 1250 #endif /* KSTACK_CHECK_MAGIC */ 1251 1252 /* 1253 * XXXSMP this is bust, it grabs a read lock and then messes about 1254 * with allproc. 1255 */ 1256 int 1257 proclist_foreach_call(struct proclist *list, 1258 int (*callback)(struct proc *, void *arg), void *arg) 1259 { 1260 struct proc marker; 1261 struct proc *p; 1262 struct lwp * const l = curlwp; 1263 int ret = 0; 1264 1265 marker.p_flag = PK_MARKER; 1266 uvm_lwp_hold(l); 1267 mutex_enter(&proclist_lock); 1268 for (p = LIST_FIRST(list); ret == 0 && p != NULL;) { 1269 if (p->p_flag & PK_MARKER) { 1270 p = LIST_NEXT(p, p_list); 1271 continue; 1272 } 1273 LIST_INSERT_AFTER(p, &marker, p_list); 1274 ret = (*callback)(p, arg); 1275 KASSERT(mutex_owned(&proclist_lock)); 1276 p = LIST_NEXT(&marker, p_list); 1277 LIST_REMOVE(&marker, p_list); 1278 } 1279 mutex_exit(&proclist_lock); 1280 uvm_lwp_rele(l); 1281 1282 return ret; 1283 } 1284 1285 int 1286 proc_vmspace_getref(struct proc *p, struct vmspace **vm) 1287 { 1288 1289 /* XXXCDC: how should locking work here? */ 1290 1291 /* curproc exception is for coredump. */ 1292 1293 if ((p != curproc && (p->p_sflag & PS_WEXIT) != 0) || 1294 (p->p_vmspace->vm_refcnt < 1)) { /* XXX */ 1295 return EFAULT; 1296 } 1297 1298 uvmspace_addref(p->p_vmspace); 1299 *vm = p->p_vmspace; 1300 1301 return 0; 1302 } 1303 1304 /* 1305 * Acquire a write lock on the process credential. 1306 */ 1307 void 1308 proc_crmod_enter(void) 1309 { 1310 struct lwp *l = curlwp; 1311 struct proc *p = l->l_proc; 1312 struct plimit *lim; 1313 kauth_cred_t oc; 1314 char *cn; 1315 1316 /* Reset what needs to be reset in plimit. */ 1317 if (p->p_limit->pl_corename != defcorename) { 1318 lim_privatise(p, false); 1319 lim = p->p_limit; 1320 mutex_enter(&lim->pl_lock); 1321 cn = lim->pl_corename; 1322 lim->pl_corename = defcorename; 1323 mutex_exit(&lim->pl_lock); 1324 if (cn != defcorename) 1325 free(cn, M_TEMP); 1326 } 1327 1328 mutex_enter(&p->p_mutex); 1329 1330 /* Ensure the LWP cached credentials are up to date. */ 1331 if ((oc = l->l_cred) != p->p_cred) { 1332 kauth_cred_hold(p->p_cred); 1333 l->l_cred = p->p_cred; 1334 kauth_cred_free(oc); 1335 } 1336 1337 } 1338 1339 /* 1340 * Set in a new process credential, and drop the write lock. The credential 1341 * must have a reference already. Optionally, free a no-longer required 1342 * credential. The scheduler also needs to inspect p_cred, so we also 1343 * briefly acquire the sched state mutex. 1344 */ 1345 void 1346 proc_crmod_leave(kauth_cred_t scred, kauth_cred_t fcred, bool sugid) 1347 { 1348 struct lwp *l = curlwp; 1349 struct proc *p = l->l_proc; 1350 kauth_cred_t oc; 1351 1352 /* Is there a new credential to set in? */ 1353 if (scred != NULL) { 1354 mutex_enter(&p->p_smutex); 1355 p->p_cred = scred; 1356 mutex_exit(&p->p_smutex); 1357 1358 /* Ensure the LWP cached credentials are up to date. */ 1359 if ((oc = l->l_cred) != scred) { 1360 kauth_cred_hold(scred); 1361 l->l_cred = scred; 1362 } 1363 } else 1364 oc = NULL; /* XXXgcc */ 1365 1366 if (sugid) { 1367 /* 1368 * Mark process as having changed credentials, stops 1369 * tracing etc. 1370 */ 1371 p->p_flag |= PK_SUGID; 1372 } 1373 1374 mutex_exit(&p->p_mutex); 1375 1376 /* If there is a credential to be released, free it now. */ 1377 if (fcred != NULL) { 1378 KASSERT(scred != NULL); 1379 kauth_cred_free(fcred); 1380 if (oc != scred) 1381 kauth_cred_free(oc); 1382 } 1383 } 1384 1385 /* 1386 * proc_specific_key_create -- 1387 * Create a key for subsystem proc-specific data. 1388 */ 1389 int 1390 proc_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor) 1391 { 1392 1393 return (specificdata_key_create(proc_specificdata_domain, keyp, dtor)); 1394 } 1395 1396 /* 1397 * proc_specific_key_delete -- 1398 * Delete a key for subsystem proc-specific data. 1399 */ 1400 void 1401 proc_specific_key_delete(specificdata_key_t key) 1402 { 1403 1404 specificdata_key_delete(proc_specificdata_domain, key); 1405 } 1406 1407 /* 1408 * proc_initspecific -- 1409 * Initialize a proc's specificdata container. 1410 */ 1411 void 1412 proc_initspecific(struct proc *p) 1413 { 1414 int error; 1415 1416 error = specificdata_init(proc_specificdata_domain, &p->p_specdataref); 1417 KASSERT(error == 0); 1418 } 1419 1420 /* 1421 * proc_finispecific -- 1422 * Finalize a proc's specificdata container. 1423 */ 1424 void 1425 proc_finispecific(struct proc *p) 1426 { 1427 1428 specificdata_fini(proc_specificdata_domain, &p->p_specdataref); 1429 } 1430 1431 /* 1432 * proc_getspecific -- 1433 * Return proc-specific data corresponding to the specified key. 1434 */ 1435 void * 1436 proc_getspecific(struct proc *p, specificdata_key_t key) 1437 { 1438 1439 return (specificdata_getspecific(proc_specificdata_domain, 1440 &p->p_specdataref, key)); 1441 } 1442 1443 /* 1444 * proc_setspecific -- 1445 * Set proc-specific data corresponding to the specified key. 1446 */ 1447 void 1448 proc_setspecific(struct proc *p, specificdata_key_t key, void *data) 1449 { 1450 1451 specificdata_setspecific(proc_specificdata_domain, 1452 &p->p_specdataref, key, data); 1453 } 1454