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