The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_proc.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: kern_proc.c,v 1.75 2004/03/14 01:08:47 cl Exp $        */
    2 
    3 /*-
    4  * Copyright (c) 1999 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.
   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.75 2004/03/14 01:08:47 cl Exp $");
   73 
   74 #include "opt_kstack.h"
   75 
   76 #include <sys/param.h>
   77 #include <sys/systm.h>
   78 #include <sys/kernel.h>
   79 #include <sys/proc.h>
   80 #include <sys/resourcevar.h>
   81 #include <sys/buf.h>
   82 #include <sys/acct.h>
   83 #include <sys/wait.h>
   84 #include <sys/file.h>
   85 #include <ufs/ufs/quota.h>
   86 #include <sys/uio.h>
   87 #include <sys/malloc.h>
   88 #include <sys/pool.h>
   89 #include <sys/mbuf.h>
   90 #include <sys/ioctl.h>
   91 #include <sys/tty.h>
   92 #include <sys/signalvar.h>
   93 #include <sys/ras.h>
   94 #include <sys/sa.h>
   95 #include <sys/savar.h>
   96 
   97 /*
   98  * Structure associated with user caching.
   99  */
  100 struct uidinfo {
  101         LIST_ENTRY(uidinfo) ui_hash;
  102         uid_t   ui_uid;
  103         long    ui_proccnt;
  104 };
  105 #define UIHASH(uid)     (&uihashtbl[(uid) & uihash])
  106 LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
  107 u_long uihash;          /* size of hash table - 1 */
  108 
  109 /*
  110  * Other process lists
  111  */
  112 
  113 struct proclist allproc;
  114 struct proclist zombproc;       /* resources have been freed */
  115 
  116 
  117 /*
  118  * Process list locking:
  119  *
  120  * We have two types of locks on the proclists: read locks and write
  121  * locks.  Read locks can be used in interrupt context, so while we
  122  * hold the write lock, we must also block clock interrupts to
  123  * lock out any scheduling changes that may happen in interrupt
  124  * context.
  125  *
  126  * The proclist lock locks the following structures:
  127  *
  128  *      allproc
  129  *      zombproc
  130  *      pid_table
  131  */
  132 struct lock proclist_lock;
  133 
  134 /*
  135  * pid to proc lookup is done by indexing the pid_table array.
  136  * Since pid numbers are only allocated when an empty slot
  137  * has been found, there is no need to search any lists ever.
  138  * (an orphaned pgrp will lock the slot, a session will lock
  139  * the pgrp with the same number.)
  140  * If the table is too small it is reallocated with twice the
  141  * previous size and the entries 'unzipped' into the two halves.
  142  * A linked list of free entries is passed through the pt_proc
  143  * field of 'free' items - set odd to be an invalid ptr.
  144  */
  145 
  146 struct pid_table {
  147         struct proc     *pt_proc;
  148         struct pgrp     *pt_pgrp;
  149 };
  150 #if 1   /* strongly typed cast - should be a noop */
  151 static __inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; }
  152 #else
  153 #define p2u(p) ((uint)p)
  154 #endif
  155 #define P_VALID(p) (!(p2u(p) & 1))
  156 #define P_NEXT(p) (p2u(p) >> 1)
  157 #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1))
  158 
  159 #define INITIAL_PID_TABLE_SIZE  (1 << 5)
  160 static struct pid_table *pid_table;
  161 static uint pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1;
  162 static uint pid_alloc_lim;      /* max we allocate before growing table */
  163 static uint pid_alloc_cnt;      /* number of allocated pids */
  164 
  165 /* links through free slots - never empty! */
  166 static uint next_free_pt, last_free_pt;
  167 static pid_t pid_max = PID_MAX;         /* largest value we allocate */
  168 
  169 struct pool proc_pool;
  170 struct pool lwp_pool;
  171 struct pool lwp_uc_pool;
  172 struct pool pcred_pool;
  173 struct pool plimit_pool;
  174 struct pool pstats_pool;
  175 struct pool pgrp_pool;
  176 struct pool rusage_pool;
  177 struct pool ras_pool;
  178 struct pool sadata_pool;
  179 struct pool saupcall_pool;
  180 struct pool sastack_pool;
  181 struct pool savp_pool;
  182 struct pool ptimer_pool;
  183 
  184 MALLOC_DEFINE(M_EMULDATA, "emuldata", "Per-process emulation data");
  185 MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
  186 MALLOC_DEFINE(M_SESSION, "session", "session header");
  187 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
  188 
  189 /*
  190  * The process list descriptors, used during pid allocation and
  191  * by sysctl.  No locking on this data structure is needed since
  192  * it is completely static.
  193  */
  194 const struct proclist_desc proclists[] = {
  195         { &allproc      },
  196         { &zombproc     },
  197         { NULL          },
  198 };
  199 
  200 static void orphanpg(struct pgrp *);
  201 static void pg_delete(pid_t);
  202 
  203 /*
  204  * Initialize global process hashing structures.
  205  */
  206 void
  207 procinit(void)
  208 {
  209         const struct proclist_desc *pd;
  210         int i;
  211 #define LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1))
  212 
  213         for (pd = proclists; pd->pd_list != NULL; pd++)
  214                 LIST_INIT(pd->pd_list);
  215 
  216         spinlockinit(&proclist_lock, "proclk", 0);
  217 
  218         pid_table = malloc(INITIAL_PID_TABLE_SIZE * sizeof *pid_table,
  219                             M_PROC, M_WAITOK);
  220         /* Set free list running through table...
  221            Preset 'use count' above PID_MAX so we allocate pid 1 next. */
  222         for (i = 0; i <= pid_tbl_mask; i++) {
  223                 pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1);
  224                 pid_table[i].pt_pgrp = 0;
  225         }
  226         /* slot 0 is just grabbed */
  227         next_free_pt = 1;
  228         /* Need to fix last entry. */
  229         last_free_pt = pid_tbl_mask;
  230         pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY);
  231         /* point at which we grow table - to avoid reusing pids too often */
  232         pid_alloc_lim = pid_tbl_mask - 1;
  233 #undef LINK_EMPTY
  234 
  235         LIST_INIT(&alllwp);
  236 
  237         uihashtbl =
  238             hashinit(maxproc / 16, HASH_LIST, M_PROC, M_WAITOK, &uihash);
  239 
  240         pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
  241             &pool_allocator_nointr);
  242         pool_init(&lwp_pool, sizeof(struct lwp), 0, 0, 0, "lwppl",
  243             &pool_allocator_nointr);
  244         pool_init(&lwp_uc_pool, sizeof(ucontext_t), 0, 0, 0, "lwpucpl",
  245             &pool_allocator_nointr);
  246         pool_init(&pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
  247             &pool_allocator_nointr);
  248         pool_init(&pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl",
  249             &pool_allocator_nointr);
  250         pool_init(&plimit_pool, sizeof(struct plimit), 0, 0, 0, "plimitpl",
  251             &pool_allocator_nointr);
  252         pool_init(&pstats_pool, sizeof(struct pstats), 0, 0, 0, "pstatspl",
  253             &pool_allocator_nointr);
  254         pool_init(&rusage_pool, sizeof(struct rusage), 0, 0, 0, "rusgepl",
  255             &pool_allocator_nointr);
  256         pool_init(&ras_pool, sizeof(struct ras), 0, 0, 0, "raspl",
  257             &pool_allocator_nointr);
  258         pool_init(&sadata_pool, sizeof(struct sadata), 0, 0, 0, "sadatapl",
  259             &pool_allocator_nointr);
  260         pool_init(&saupcall_pool, sizeof(struct sadata_upcall), 0, 0, 0,
  261             "saupcpl", &pool_allocator_nointr);
  262         pool_init(&sastack_pool, sizeof(struct sastack), 0, 0, 0, "sastackpl",
  263             &pool_allocator_nointr);
  264         pool_init(&savp_pool, sizeof(struct sadata_vp), 0, 0, 0, "savppl",
  265             &pool_allocator_nointr);
  266         pool_init(&ptimer_pool, sizeof(struct ptimer), 0, 0, 0, "ptimerpl",
  267             &pool_allocator_nointr);
  268 }
  269 
  270 /*
  271  * Acquire a read lock on the proclist.
  272  */
  273 void
  274 proclist_lock_read(void)
  275 {
  276         int error;
  277 
  278         error = spinlockmgr(&proclist_lock, LK_SHARED, NULL);
  279 #ifdef DIAGNOSTIC
  280         if (__predict_false(error != 0))
  281                 panic("proclist_lock_read: failed to acquire lock");
  282 #endif
  283 }
  284 
  285 /*
  286  * Release a read lock on the proclist.
  287  */
  288 void
  289 proclist_unlock_read(void)
  290 {
  291 
  292         (void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
  293 }
  294 
  295 /*
  296  * Acquire a write lock on the proclist.
  297  */
  298 int
  299 proclist_lock_write(void)
  300 {
  301         int s, error;
  302 
  303         s = splclock();
  304         error = spinlockmgr(&proclist_lock, LK_EXCLUSIVE, NULL);
  305 #ifdef DIAGNOSTIC
  306         if (__predict_false(error != 0))
  307                 panic("proclist_lock: failed to acquire lock");
  308 #endif
  309         return (s);
  310 }
  311 
  312 /*
  313  * Release a write lock on the proclist.
  314  */
  315 void
  316 proclist_unlock_write(int s)
  317 {
  318 
  319         (void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
  320         splx(s);
  321 }
  322 
  323 /*
  324  * Change the count associated with number of processes
  325  * a given user is using.
  326  */
  327 int
  328 chgproccnt(uid_t uid, int diff)
  329 {
  330         struct uidinfo *uip;
  331         struct uihashhead *uipp;
  332 
  333         uipp = UIHASH(uid);
  334 
  335         LIST_FOREACH(uip, uipp, ui_hash)
  336                 if (uip->ui_uid == uid)
  337                         break;
  338 
  339         if (uip) {
  340                 uip->ui_proccnt += diff;
  341                 if (uip->ui_proccnt > 0)
  342                         return (uip->ui_proccnt);
  343                 if (uip->ui_proccnt < 0)
  344                         panic("chgproccnt: procs < 0");
  345                 LIST_REMOVE(uip, ui_hash);
  346                 FREE(uip, M_PROC);
  347                 return (0);
  348         }
  349         if (diff <= 0) {
  350                 if (diff == 0)
  351                         return(0);
  352                 panic("chgproccnt: lost user");
  353         }
  354         MALLOC(uip, struct uidinfo *, sizeof(*uip), M_PROC, M_WAITOK);
  355         LIST_INSERT_HEAD(uipp, uip, ui_hash);
  356         uip->ui_uid = uid;
  357         uip->ui_proccnt = diff;
  358         return (diff);
  359 }
  360 
  361 /*
  362  * Check that the specified process group is in the session of the
  363  * specified process.
  364  * Treats -ve ids as process ids.
  365  * Used to validate TIOCSPGRP requests.
  366  */
  367 int
  368 pgid_in_session(struct proc *p, pid_t pg_id)
  369 {
  370         struct pgrp *pgrp;
  371 
  372         if (pg_id < 0) {
  373                 struct proc *p1 = pfind(-pg_id);
  374                 if (p1 == NULL)
  375                         return EINVAL;
  376                 pgrp = p1->p_pgrp;
  377         } else {
  378                 pgrp = pgfind(pg_id);
  379                 if (pgrp == NULL)
  380                         return EINVAL;
  381         }
  382         if (pgrp->pg_session != p->p_pgrp->pg_session)
  383                 return EPERM;
  384         return 0;
  385 }
  386 
  387 /*
  388  * Is p an inferior of q?
  389  */
  390 int
  391 inferior(struct proc *p, struct proc *q)
  392 {
  393 
  394         for (; p != q; p = p->p_pptr)
  395                 if (p->p_pid == 0)
  396                         return (0);
  397         return (1);
  398 }
  399 
  400 /*
  401  * Locate a process by number
  402  */
  403 struct proc *
  404 p_find(pid_t pid, uint flags)
  405 {
  406         struct proc *p;
  407         char stat;
  408 
  409         if (!(flags & PFIND_LOCKED))
  410                 proclist_lock_read();
  411         p = pid_table[pid & pid_tbl_mask].pt_proc;
  412         /* Only allow live processes to be found by pid. */
  413         if (P_VALID(p) && p->p_pid == pid &&
  414             ((stat = p->p_stat) == SACTIVE || stat == SSTOP
  415                     || (stat == SZOMB && (flags & PFIND_ZOMBIE)))) {
  416                 if (flags & PFIND_UNLOCK_OK)
  417                          proclist_unlock_read();
  418                 return p;
  419         }
  420         if (flags & PFIND_UNLOCK_FAIL)
  421                  proclist_unlock_read();
  422         return NULL;
  423 }
  424 
  425 
  426 /*
  427  * Locate a process group by number
  428  */
  429 struct pgrp *
  430 pg_find(pid_t pgid, uint flags)
  431 {
  432         struct pgrp *pg;
  433 
  434         if (!(flags & PFIND_LOCKED))
  435                 proclist_lock_read();
  436         pg = pid_table[pgid & pid_tbl_mask].pt_pgrp;
  437         /*
  438          * Can't look up a pgrp that only exists because the session
  439          * hasn't died yet (traditional)
  440          */
  441         if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) {
  442                 if (flags & PFIND_UNLOCK_FAIL)
  443                          proclist_unlock_read();
  444                 return NULL;
  445         }
  446 
  447         if (flags & PFIND_UNLOCK_OK)
  448                 proclist_unlock_read();
  449         return pg;
  450 }
  451 
  452 /*
  453  * Set entry for process 0
  454  */
  455 void
  456 proc0_insert(struct proc *p, struct lwp *l, struct pgrp *pgrp,
  457         struct session *sess)
  458 {
  459         int s;
  460 
  461         simple_lock_init(&p->p_lock);
  462         LIST_INIT(&p->p_lwps);
  463         LIST_INSERT_HEAD(&p->p_lwps, l, l_sibling);
  464         p->p_nlwps = 1;
  465         simple_lock_init(&p->p_sigctx.ps_silock);
  466         CIRCLEQ_INIT(&p->p_sigctx.ps_siginfo);
  467 
  468         s = proclist_lock_write();
  469 
  470         pid_table[0].pt_proc = p;
  471         LIST_INSERT_HEAD(&allproc, p, p_list);
  472         LIST_INSERT_HEAD(&alllwp, l, l_list);
  473 
  474         p->p_pgrp = pgrp;
  475         pid_table[0].pt_pgrp = pgrp;
  476         LIST_INIT(&pgrp->pg_members);
  477         LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
  478 
  479         pgrp->pg_session = sess;
  480         sess->s_count = 1;
  481         sess->s_sid = 0;
  482         sess->s_leader = p;
  483 
  484         proclist_unlock_write(s);
  485 }
  486 
  487 static void
  488 expand_pid_table(void)
  489 {
  490         uint pt_size = pid_tbl_mask + 1;
  491         struct pid_table *n_pt, *new_pt;
  492         struct proc *proc;
  493         struct pgrp *pgrp;
  494         int i;
  495         int s;
  496         pid_t pid;
  497 
  498         new_pt = malloc(pt_size * 2 * sizeof *new_pt, M_PROC, M_WAITOK);
  499 
  500         s = proclist_lock_write();
  501         if (pt_size != pid_tbl_mask + 1) {
  502                 /* Another process beat us to it... */
  503                 proclist_unlock_write(s);
  504                 FREE(new_pt, M_PROC);
  505                 return;
  506         }
  507 
  508         /*
  509          * Copy entries from old table into new one.
  510          * If 'pid' is 'odd' we need to place in the upper half,
  511          * even pid's to the lower half.
  512          * Free items stay in the low half so we don't have to
  513          * fixup the reference to them.
  514          * We stuff free items on the front of the freelist
  515          * because we can't write to unmodified entries.
  516          * Processing the table backwards maintains a semblance
  517          * of issueing pid numbers that increase with time.
  518          */
  519         i = pt_size - 1;
  520         n_pt = new_pt + i;
  521         for (; ; i--, n_pt--) {
  522                 proc = pid_table[i].pt_proc;
  523                 pgrp = pid_table[i].pt_pgrp;
  524                 if (!P_VALID(proc)) {
  525                         /* Up 'use count' so that link is valid */
  526                         pid = (P_NEXT(proc) + pt_size) & ~pt_size;
  527                         proc = P_FREE(pid);
  528                         if (pgrp)
  529                                 pid = pgrp->pg_id;
  530                 } else
  531                         pid = proc->p_pid;
  532 
  533                 /* Save entry in appropriate half of table */
  534                 n_pt[pid & pt_size].pt_proc = proc;
  535                 n_pt[pid & pt_size].pt_pgrp = pgrp;
  536 
  537                 /* Put other piece on start of free list */
  538                 pid = (pid ^ pt_size) & ~pid_tbl_mask;
  539                 n_pt[pid & pt_size].pt_proc =
  540                                     P_FREE((pid & ~pt_size) | next_free_pt);
  541                 n_pt[pid & pt_size].pt_pgrp = 0;
  542                 next_free_pt = i | (pid & pt_size);
  543                 if (i == 0)
  544                         break;
  545         }
  546 
  547         /* Switch tables */
  548         n_pt = pid_table;
  549         pid_table = new_pt;
  550         pid_tbl_mask = pt_size * 2 - 1;
  551 
  552         /*
  553          * pid_max starts as PID_MAX (= 30000), once we have 16384
  554          * allocated pids we need it to be larger!
  555          */
  556         if (pid_tbl_mask > PID_MAX) {
  557                 pid_max = pid_tbl_mask * 2 + 1;
  558                 pid_alloc_lim |= pid_alloc_lim << 1;
  559         } else
  560                 pid_alloc_lim <<= 1;    /* doubles number of free slots... */
  561 
  562         proclist_unlock_write(s);
  563         FREE(n_pt, M_PROC);
  564 }
  565 
  566 struct proc *
  567 proc_alloc(void)
  568 {
  569         struct proc *p;
  570         int s;
  571         int nxt;
  572         pid_t pid;
  573         struct pid_table *pt;
  574 
  575         p = pool_get(&proc_pool, PR_WAITOK);
  576         p->p_stat = SIDL;                       /* protect against others */
  577 
  578         /* allocate next free pid */
  579 
  580         for (;;expand_pid_table()) {
  581                 if (__predict_false(pid_alloc_cnt >= pid_alloc_lim))
  582                         /* ensure pids cycle through 2000+ values */
  583                         continue;
  584                 s = proclist_lock_write();
  585                 pt = &pid_table[next_free_pt];
  586 #ifdef DIAGNOSTIC
  587                 if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp))
  588                         panic("proc_alloc: slot busy");
  589 #endif
  590                 nxt = P_NEXT(pt->pt_proc);
  591                 if (nxt & pid_tbl_mask)
  592                         break;
  593                 /* Table full - expand (NB last entry not used....) */
  594                 proclist_unlock_write(s);
  595         }
  596 
  597         /* pid is 'saved use count' + 'size' + entry */
  598         pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt;
  599         if ((uint)pid > (uint)pid_max)
  600                 pid &= pid_tbl_mask;
  601         p->p_pid = pid;
  602         next_free_pt = nxt & pid_tbl_mask;
  603 
  604         /* Grab table slot */
  605         pt->pt_proc = p;
  606         pid_alloc_cnt++;
  607 
  608         proclist_unlock_write(s);
  609 
  610         return p;
  611 }
  612 
  613 /*
  614  * Free last resources of a process - called from proc_free (in kern_exit.c)
  615  */
  616 void
  617 proc_free_mem(struct proc *p)
  618 {
  619         int s;
  620         pid_t pid = p->p_pid;
  621         struct pid_table *pt;
  622 
  623         s = proclist_lock_write();
  624 
  625         pt = &pid_table[pid & pid_tbl_mask];
  626 #ifdef DIAGNOSTIC
  627         if (__predict_false(pt->pt_proc != p))
  628                 panic("proc_free: pid_table mismatch, pid %x, proc %p",
  629                         pid, p);
  630 #endif
  631         /* save pid use count in slot */
  632         pt->pt_proc = P_FREE(pid & ~pid_tbl_mask);
  633 
  634         if (pt->pt_pgrp == NULL) {
  635                 /* link last freed entry onto ours */
  636                 pid &= pid_tbl_mask;
  637                 pt = &pid_table[last_free_pt];
  638                 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid);
  639                 last_free_pt = pid;
  640                 pid_alloc_cnt--;
  641         }
  642 
  643         nprocs--;
  644         proclist_unlock_write(s);
  645 
  646         pool_put(&proc_pool, p);
  647 }
  648 
  649 /*
  650  * Move p to a new or existing process group (and session)
  651  *
  652  * If we are creating a new pgrp, the pgid should equal
  653  * the calling process' pid.
  654  * If is only valid to enter a process group that is in the session
  655  * of the process.
  656  * Also mksess should only be set if we are creating a process group
  657  *
  658  * Only called from sys_setsid, sys_setpgid/sys_setpgrp and the
  659  * SYSV setpgrp support for hpux == enterpgrp(curproc, curproc->p_pid)
  660  */
  661 int
  662 enterpgrp(struct proc *p, pid_t pgid, int mksess)
  663 {
  664         struct pgrp *new_pgrp, *pgrp;
  665         struct session *sess;
  666         struct proc *curp = curproc;
  667         pid_t pid = p->p_pid;
  668         int rval;
  669         int s;
  670         pid_t pg_id = NO_PGID;
  671 
  672         /* Allocate data areas we might need before doing any validity checks */
  673         proclist_lock_read();           /* Because pid_table might change */
  674         if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) {
  675                 proclist_unlock_read();
  676                 new_pgrp = pool_get(&pgrp_pool, PR_WAITOK);
  677         } else {
  678                 proclist_unlock_read();
  679                 new_pgrp = NULL;
  680         }
  681         if (mksess)
  682                 MALLOC(sess, struct session *, sizeof(struct session),
  683                             M_SESSION, M_WAITOK);
  684         else
  685                 sess = NULL;
  686 
  687         s = proclist_lock_write();
  688         rval = EPERM;   /* most common error (to save typing) */
  689 
  690         /* Check pgrp exists or can be created */
  691         pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
  692         if (pgrp != NULL && pgrp->pg_id != pgid)
  693                 goto done;
  694 
  695         /* Can only set another process under restricted circumstances. */
  696         if (p != curp) {
  697                 /* must exist and be one of our children... */
  698                 if (p != pid_table[pid & pid_tbl_mask].pt_proc
  699                     || !inferior(p, curp)) {
  700                         rval = ESRCH;
  701                         goto done;
  702                 }
  703                 /* ... in the same session... */
  704                 if (sess != NULL || p->p_session != curp->p_session)
  705                         goto done;
  706                 /* ... existing pgid must be in same session ... */
  707                 if (pgrp != NULL && pgrp->pg_session != p->p_session)
  708                         goto done;
  709                 /* ... and not done an exec. */
  710                 if (p->p_flag & P_EXEC) {
  711                         rval = EACCES;
  712                         goto done;
  713                 }
  714         }
  715 
  716         /* Changing the process group/session of a session
  717            leader is definitely off limits. */
  718         if (SESS_LEADER(p)) {
  719                 if (sess == NULL && p->p_pgrp == pgrp)
  720                         /* unless it's a definite noop */
  721                         rval = 0;
  722                 goto done;
  723         }
  724 
  725         /* Can only create a process group with id of process */
  726         if (pgrp == NULL && pgid != pid)
  727                 goto done;
  728 
  729         /* Can only create a session if creating pgrp */
  730         if (sess != NULL && pgrp != NULL)
  731                 goto done;
  732 
  733         /* Check we allocated memory for a pgrp... */
  734         if (pgrp == NULL && new_pgrp == NULL)
  735                 goto done;
  736 
  737         /* Don't attach to 'zombie' pgrp */
  738         if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members))
  739                 goto done;
  740 
  741         /* Expect to succeed now */
  742         rval = 0;
  743 
  744         if (pgrp == p->p_pgrp)
  745                 /* nothing to do */
  746                 goto done;
  747 
  748         /* Ok all setup, link up required structures */
  749         if (pgrp == NULL) {
  750                 pgrp = new_pgrp;
  751                 new_pgrp = 0;
  752                 if (sess != NULL) {
  753                         sess->s_sid = p->p_pid;
  754                         sess->s_leader = p;
  755                         sess->s_count = 1;
  756                         sess->s_ttyvp = NULL;
  757                         sess->s_ttyp = NULL;
  758                         sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET;
  759                         memcpy(sess->s_login, p->p_session->s_login,
  760                             sizeof(sess->s_login));
  761                         p->p_flag &= ~P_CONTROLT;
  762                 } else {
  763                         sess = p->p_pgrp->pg_session;
  764                         SESSHOLD(sess);
  765                 }
  766                 pgrp->pg_session = sess;
  767                 sess = 0;
  768 
  769                 pgrp->pg_id = pgid;
  770                 LIST_INIT(&pgrp->pg_members);
  771 #ifdef DIAGNOSTIC
  772                 if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp))
  773                         panic("enterpgrp: pgrp table slot in use");
  774                 if (__predict_false(mksess && p != curp))
  775                         panic("enterpgrp: mksession and p != curproc");
  776 #endif
  777                 pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp;
  778                 pgrp->pg_jobc = 0;
  779         }
  780 
  781         /*
  782          * Adjust eligibility of affected pgrps to participate in job control.
  783          * Increment eligibility counts before decrementing, otherwise we
  784          * could reach 0 spuriously during the first call.
  785          */
  786         fixjobc(p, pgrp, 1);
  787         fixjobc(p, p->p_pgrp, 0);
  788 
  789         /* Move process to requested group */
  790         LIST_REMOVE(p, p_pglist);
  791         if (LIST_EMPTY(&p->p_pgrp->pg_members))
  792                 /* defer delete until we've dumped the lock */
  793                 pg_id = p->p_pgrp->pg_id;
  794         p->p_pgrp = pgrp;
  795         LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
  796 
  797     done:
  798         proclist_unlock_write(s);
  799         if (sess != NULL)
  800                 free(sess, M_SESSION);
  801         if (new_pgrp != NULL)
  802                 pool_put(&pgrp_pool, new_pgrp);
  803         if (pg_id != NO_PGID)
  804                 pg_delete(pg_id);
  805 #ifdef DEBUG_PGRP
  806         if (__predict_false(rval))
  807                 printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n",
  808                         pid, pgid, mksess, curp->p_pid, rval);
  809 #endif
  810         return rval;
  811 }
  812 
  813 /*
  814  * remove process from process group
  815  */
  816 int
  817 leavepgrp(struct proc *p)
  818 {
  819         int s;
  820         struct pgrp *pgrp;
  821         pid_t pg_id;
  822 
  823         s = proclist_lock_write();
  824         pgrp = p->p_pgrp;
  825         LIST_REMOVE(p, p_pglist);
  826         p->p_pgrp = 0;
  827         pg_id = LIST_EMPTY(&pgrp->pg_members) ? pgrp->pg_id : NO_PGID;
  828         proclist_unlock_write(s);
  829 
  830         if (pg_id != NO_PGID)
  831                 pg_delete(pg_id);
  832         return 0;
  833 }
  834 
  835 static void
  836 pg_free(pid_t pg_id)
  837 {
  838         struct pgrp *pgrp;
  839         struct pid_table *pt;
  840         int s;
  841 
  842         s = proclist_lock_write();
  843         pt = &pid_table[pg_id & pid_tbl_mask];
  844         pgrp = pt->pt_pgrp;
  845 #ifdef DIAGNOSTIC
  846         if (__predict_false(!pgrp || pgrp->pg_id != pg_id
  847             || !LIST_EMPTY(&pgrp->pg_members)))
  848                 panic("pg_free: process group absent or has members");
  849 #endif
  850         pt->pt_pgrp = 0;
  851 
  852         if (!P_VALID(pt->pt_proc)) {
  853                 /* orphaned pgrp, put slot onto free list */
  854 #ifdef DIAGNOSTIC
  855                 if (__predict_false(P_NEXT(pt->pt_proc) & pid_tbl_mask))
  856                         panic("pg_free: process slot on free list");
  857 #endif
  858 
  859                 pg_id &= pid_tbl_mask;
  860                 pt = &pid_table[last_free_pt];
  861                 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id);
  862                 last_free_pt = pg_id;
  863                 pid_alloc_cnt--;
  864         }
  865         proclist_unlock_write(s);
  866 
  867         pool_put(&pgrp_pool, pgrp);
  868 }
  869 
  870 /*
  871  * delete a process group
  872  */
  873 static void
  874 pg_delete(pid_t pg_id)
  875 {
  876         struct pgrp *pgrp;
  877         struct tty *ttyp;
  878         struct session *ss;
  879         int s, is_pgrp_leader;
  880 
  881         s = proclist_lock_write();
  882         pgrp = pid_table[pg_id & pid_tbl_mask].pt_pgrp;
  883         if (pgrp == NULL || pgrp->pg_id != pg_id ||
  884             !LIST_EMPTY(&pgrp->pg_members)) {
  885                 proclist_unlock_write(s);
  886                 return;
  887         }
  888 
  889         ss = pgrp->pg_session;
  890 
  891         /* Remove reference (if any) from tty to this process group */
  892         ttyp = ss->s_ttyp;
  893         if (ttyp != NULL && ttyp->t_pgrp == pgrp) {
  894                 ttyp->t_pgrp = NULL;
  895 #ifdef DIAGNOSTIC
  896                 if (ttyp->t_session != ss)
  897                         panic("pg_delete: wrong session on terminal");
  898 #endif
  899         }
  900 
  901         /*
  902          * The leading process group in a session is freed
  903          * by sessdelete() if last reference.
  904          */
  905         is_pgrp_leader = (ss->s_sid == pgrp->pg_id);
  906         proclist_unlock_write(s);
  907         SESSRELE(ss);
  908 
  909         if (is_pgrp_leader)
  910                 return;
  911 
  912         pg_free(pg_id);
  913 }
  914 
  915 /*
  916  * Delete session - called from SESSRELE when s_count becomes zero.
  917  */
  918 void
  919 sessdelete(struct session *ss)
  920 {
  921         /*
  922          * We keep the pgrp with the same id as the session in
  923          * order to stop a process being given the same pid.
  924          * Since the pgrp holds a reference to the session, it
  925          * must be a 'zombie' pgrp by now.
  926          */
  927 
  928         pg_free(ss->s_sid);
  929 
  930         FREE(ss, M_SESSION);
  931 }
  932 
  933 /*
  934  * Adjust pgrp jobc counters when specified process changes process group.
  935  * We count the number of processes in each process group that "qualify"
  936  * the group for terminal job control (those with a parent in a different
  937  * process group of the same session).  If that count reaches zero, the
  938  * process group becomes orphaned.  Check both the specified process'
  939  * process group and that of its children.
  940  * entering == 0 => p is leaving specified group.
  941  * entering == 1 => p is entering specified group.
  942  *
  943  * Call with proclist_lock held.
  944  */
  945 void
  946 fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
  947 {
  948         struct pgrp *hispgrp;
  949         struct session *mysession = pgrp->pg_session;
  950         struct proc *child;
  951 
  952         /*
  953          * Check p's parent to see whether p qualifies its own process
  954          * group; if so, adjust count for p's process group.
  955          */
  956         hispgrp = p->p_pptr->p_pgrp;
  957         if (hispgrp != pgrp && hispgrp->pg_session == mysession) {
  958                 if (entering)
  959                         pgrp->pg_jobc++;
  960                 else if (--pgrp->pg_jobc == 0)
  961                         orphanpg(pgrp);
  962         }
  963 
  964         /*
  965          * Check this process' children to see whether they qualify
  966          * their process groups; if so, adjust counts for children's
  967          * process groups.
  968          */
  969         LIST_FOREACH(child, &p->p_children, p_sibling) {
  970                 hispgrp = child->p_pgrp;
  971                 if (hispgrp != pgrp && hispgrp->pg_session == mysession &&
  972                     !P_ZOMBIE(child)) {
  973                         if (entering)
  974                                 hispgrp->pg_jobc++;
  975                         else if (--hispgrp->pg_jobc == 0)
  976                                 orphanpg(hispgrp);
  977                 }
  978         }
  979 }
  980 
  981 /*
  982  * A process group has become orphaned;
  983  * if there are any stopped processes in the group,
  984  * hang-up all process in that group.
  985  *
  986  * Call with proclist_lock held.
  987  */
  988 static void
  989 orphanpg(struct pgrp *pg)
  990 {
  991         struct proc *p;
  992 
  993         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
  994                 if (p->p_stat == SSTOP) {
  995                         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
  996                                 psignal(p, SIGHUP);
  997                                 psignal(p, SIGCONT);
  998                         }
  999                         return;
 1000                 }
 1001         }
 1002 }
 1003 
 1004 /* mark process as suid/sgid, reset some values to defaults */
 1005 void
 1006 p_sugid(struct proc *p)
 1007 {
 1008         struct plimit *newlim;
 1009 
 1010         p->p_flag |= P_SUGID;
 1011         /* reset what needs to be reset in plimit */
 1012         if (p->p_limit->pl_corename != defcorename) {
 1013                 if (p->p_limit->p_refcnt > 1 &&
 1014                     (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
 1015                         newlim = limcopy(p->p_limit);
 1016                         limfree(p->p_limit);
 1017                         p->p_limit = newlim;
 1018                 }
 1019                 free(p->p_limit->pl_corename, M_TEMP);
 1020                 p->p_limit->pl_corename = defcorename;
 1021         }
 1022 }
 1023 
 1024 #ifdef DDB
 1025 #include <ddb/db_output.h>
 1026 void pidtbl_dump(void);
 1027 void
 1028 pidtbl_dump(void)
 1029 {
 1030         struct pid_table *pt;
 1031         struct proc *p;
 1032         struct pgrp *pgrp;
 1033         int id;
 1034 
 1035         db_printf("pid table %p size %x, next %x, last %x\n",
 1036                 pid_table, pid_tbl_mask+1,
 1037                 next_free_pt, last_free_pt);
 1038         for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) {
 1039                 p = pt->pt_proc;
 1040                 if (!P_VALID(p) && !pt->pt_pgrp)
 1041                         continue;
 1042                 db_printf("  id %x: ", id);
 1043                 if (P_VALID(p))
 1044                         db_printf("proc %p id %d (0x%x) %s\n",
 1045                                 p, p->p_pid, p->p_pid, p->p_comm);
 1046                 else
 1047                         db_printf("next %x use %x\n",
 1048                                 P_NEXT(p) & pid_tbl_mask,
 1049                                 P_NEXT(p) & ~pid_tbl_mask);
 1050                 if ((pgrp = pt->pt_pgrp)) {
 1051                         db_printf("\tsession %p, sid %d, count %d, login %s\n",
 1052                             pgrp->pg_session, pgrp->pg_session->s_sid,
 1053                             pgrp->pg_session->s_count,
 1054                             pgrp->pg_session->s_login);
 1055                         db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n",
 1056                             pgrp, pgrp->pg_id, pgrp->pg_jobc,
 1057                             pgrp->pg_members.lh_first);
 1058                         for (p = pgrp->pg_members.lh_first; p != 0;
 1059                             p = p->p_pglist.le_next) {
 1060                                 db_printf("\t\tpid %d addr %p pgrp %p %s\n",
 1061                                     p->p_pid, p, p->p_pgrp, p->p_comm);
 1062                         }
 1063                 }
 1064         }
 1065 }
 1066 #endif /* DDB */
 1067 
 1068 #ifdef KSTACK_CHECK_MAGIC
 1069 #include <sys/user.h>
 1070 
 1071 #define KSTACK_MAGIC    0xdeadbeaf
 1072 
 1073 /* XXX should be per process basis? */
 1074 int kstackleftmin = KSTACK_SIZE;
 1075 int kstackleftthres = KSTACK_SIZE / 8; /* warn if remaining stack is
 1076                                           less than this */
 1077 
 1078 void
 1079 kstack_setup_magic(const struct lwp *l)
 1080 {
 1081         u_int32_t *ip;
 1082         u_int32_t const *end;
 1083 
 1084         KASSERT(l != NULL);
 1085         KASSERT(l != &lwp0);
 1086 
 1087         /*
 1088          * fill all the stack with magic number
 1089          * so that later modification on it can be detected.
 1090          */
 1091         ip = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
 1092         end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
 1093         for (; ip < end; ip++) {
 1094                 *ip = KSTACK_MAGIC;
 1095         }
 1096 }
 1097 
 1098 void
 1099 kstack_check_magic(const struct lwp *l)
 1100 {
 1101         u_int32_t const *ip, *end;
 1102         int stackleft;
 1103 
 1104         KASSERT(l != NULL);
 1105 
 1106         /* don't check proc0 */ /*XXX*/
 1107         if (l == &lwp0)
 1108                 return;
 1109 
 1110 #ifdef __MACHINE_STACK_GROWS_UP
 1111         /* stack grows upwards (eg. hppa) */
 1112         ip = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
 1113         end = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
 1114         for (ip--; ip >= end; ip--)
 1115                 if (*ip != KSTACK_MAGIC)
 1116                         break;
 1117 
 1118         stackleft = (caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (caddr_t)ip;
 1119 #else /* __MACHINE_STACK_GROWS_UP */
 1120         /* stack grows downwards (eg. i386) */
 1121         ip = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
 1122         end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
 1123         for (; ip < end; ip++)
 1124                 if (*ip != KSTACK_MAGIC)
 1125                         break;
 1126 
 1127         stackleft = (caddr_t)ip - KSTACK_LOWEST_ADDR(l);
 1128 #endif /* __MACHINE_STACK_GROWS_UP */
 1129 
 1130         if (kstackleftmin > stackleft) {
 1131                 kstackleftmin = stackleft;
 1132                 if (stackleft < kstackleftthres)
 1133                         printf("warning: kernel stack left %d bytes"
 1134                             "(pid %u:lid %u)\n", stackleft,
 1135                             (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
 1136         }
 1137 
 1138         if (stackleft <= 0) {
 1139                 panic("magic on the top of kernel stack changed for "
 1140                     "pid %u, lid %u: maybe kernel stack overflow",
 1141                     (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
 1142         }
 1143 }
 1144 #endif /* KSTACK_CHECK_MAGIC */

Cache object: a751993dc41d652110f247cea182aaf1


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.