sys/kern/kern_proc.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include "opt_ddb.h"
  38 #include "opt_ktrace.h"
  39 #include "opt_kstack_pages.h"
  40 #include "opt_stack.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/bitstring.h>
  45 #include <sys/elf.h>
  46 #include <sys/eventhandler.h>
  47 #include <sys/exec.h>
  48 #include <sys/jail.h>
  49 #include <sys/kernel.h>
  50 #include <sys/limits.h>
  51 #include <sys/lock.h>
  52 #include <sys/loginclass.h>
  53 #include <sys/malloc.h>
  54 #include <sys/mman.h>
  55 #include <sys/mount.h>
  56 #include <sys/mutex.h>
  57 #include <sys/proc.h>
  58 #include <sys/ptrace.h>
  59 #include <sys/refcount.h>
  60 #include <sys/resourcevar.h>
  61 #include <sys/rwlock.h>
  62 #include <sys/sbuf.h>
  63 #include <sys/sysent.h>
  64 #include <sys/sched.h>
  65 #include <sys/smp.h>
  66 #include <sys/stack.h>
  67 #include <sys/stat.h>
  68 #include <sys/dtrace_bsd.h>
  69 #include <sys/sysctl.h>
  70 #include <sys/filedesc.h>
  71 #include <sys/tty.h>
  72 #include <sys/signalvar.h>
  73 #include <sys/sdt.h>
  74 #include <sys/sx.h>
  75 #include <sys/user.h>
  76 #include <sys/vnode.h>
  77 #include <sys/wait.h>
  78 #ifdef KTRACE
  79 #include <sys/ktrace.h>
  80 #endif
  81
  82 #ifdef DDB
  83 #include <ddb/ddb.h>
  84 #endif
  85
  86 #include <vm/vm.h>
  87 #include <vm/vm_param.h>
  88 #include <vm/vm_extern.h>
  89 #include <vm/pmap.h>
  90 #include <vm/vm_map.h>
  91 #include <vm/vm_object.h>
  92 #include <vm/vm_page.h>
  93 #include <vm/uma.h>
  94
  95 #include <fs/devfs/devfs.h>
  96
  97 #ifdef COMPAT_FREEBSD32
  98 #include <compat/freebsd32/freebsd32.h>
  99 #include <compat/freebsd32/freebsd32_util.h>
 100 #endif
 101
 102 SDT_PROVIDER_DEFINE(proc);
 103
 104 MALLOC_DEFINE(M_SESSION, "session", "session header");
 105 static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
 106 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
 107
 108 static void doenterpgrp(struct proc *, struct pgrp *);
 109 static void orphanpg(struct pgrp *pg);
 110 static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp);
 111 static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp);
 112 static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp,
 113     int preferthread);
 114 static void pgdelete(struct pgrp *);
 115 static int pgrp_init(void *mem, int size, int flags);
 116 static int proc_ctor(void *mem, int size, void *arg, int flags);
 117 static void proc_dtor(void *mem, int size, void *arg);
 118 static int proc_init(void *mem, int size, int flags);
 119 static void proc_fini(void *mem, int size);
 120 static void pargs_free(struct pargs *pa);
 121
 122 /*
 123  * Other process lists
 124  */
 125 struct pidhashhead *pidhashtbl;
 126 struct sx *pidhashtbl_lock;
 127 u_long pidhash;
 128 u_long pidhashlock;
 129 struct pgrphashhead *pgrphashtbl;
 130 u_long pgrphash;
 131 struct proclist allproc;
 132 struct sx __exclusive_cache_line allproc_lock;
 133 struct sx __exclusive_cache_line proctree_lock;
 134 struct mtx __exclusive_cache_line ppeers_lock;
 135 struct mtx __exclusive_cache_line procid_lock;
 136 uma_zone_t proc_zone;
 137 uma_zone_t pgrp_zone;
 138
 139 /*
 140  * The offset of various fields in struct proc and struct thread.
 141  * These are used by kernel debuggers to enumerate kernel threads and
 142  * processes.
 143  */
 144 const int proc_off_p_pid = offsetof(struct proc, p_pid);
 145 const int proc_off_p_comm = offsetof(struct proc, p_comm);
 146 const int proc_off_p_list = offsetof(struct proc, p_list);
 147 const int proc_off_p_hash = offsetof(struct proc, p_hash);
 148 const int proc_off_p_threads = offsetof(struct proc, p_threads);
 149 const int thread_off_td_tid = offsetof(struct thread, td_tid);
 150 const int thread_off_td_name = offsetof(struct thread, td_name);
 151 const int thread_off_td_oncpu = offsetof(struct thread, td_oncpu);
 152 const int thread_off_td_pcb = offsetof(struct thread, td_pcb);
 153 const int thread_off_td_plist = offsetof(struct thread, td_plist);
 154
 155 EVENTHANDLER_LIST_DEFINE(process_ctor);
 156 EVENTHANDLER_LIST_DEFINE(process_dtor);
 157 EVENTHANDLER_LIST_DEFINE(process_init);
 158 EVENTHANDLER_LIST_DEFINE(process_fini);
 159 EVENTHANDLER_LIST_DEFINE(process_exit);
 160 EVENTHANDLER_LIST_DEFINE(process_fork);
 161 EVENTHANDLER_LIST_DEFINE(process_exec);
 162
 163 int kstack_pages = KSTACK_PAGES;
 164 SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0,
 165     "Kernel stack size in pages");
 166 static int vmmap_skip_res_cnt = 0;
 167 SYSCTL_INT(_kern, OID_AUTO, proc_vmmap_skip_resident_count, CTLFLAG_RW,
 168     &vmmap_skip_res_cnt, 0,
 169     "Skip calculation of the pages resident count in kern.proc.vmmap");
 170
 171 CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
 172 #ifdef COMPAT_FREEBSD32
 173 CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE);
 174 #endif
 175
 176 /*
 177  * Initialize global process hashing structures.
 178  */
 179 void
 180 procinit(void)
 181 {
 182         u_long i;
 183
 184         sx_init(&allproc_lock, "allproc");
 185         sx_init(&proctree_lock, "proctree");
 186         mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF);
 187         mtx_init(&procid_lock, "procid", NULL, MTX_DEF);
 188         LIST_INIT(&allproc);
 189         pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
 190         pidhashlock = (pidhash + 1) / 64;
 191         if (pidhashlock > 0)
 192                 pidhashlock--;
 193         pidhashtbl_lock = malloc(sizeof(*pidhashtbl_lock) * (pidhashlock + 1),
 194             M_PROC, M_WAITOK | M_ZERO);
 195         for (i = 0; i < pidhashlock + 1; i++)
 196                 sx_init_flags(&pidhashtbl_lock[i], "pidhash", SX_DUPOK);
 197         pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
 198         proc_zone = uma_zcreate("PROC", sched_sizeof_proc(),
 199             proc_ctor, proc_dtor, proc_init, proc_fini,
 200             UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
 201         pgrp_zone = uma_zcreate("PGRP", sizeof(struct pgrp), NULL, NULL,
 202             pgrp_init, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
 203         uihashinit();
 204 }
 205
 206 /*
 207  * Prepare a proc for use.
 208  */
 209 static int
 210 proc_ctor(void *mem, int size, void *arg, int flags)
 211 {
 212         struct proc *p;
 213         struct thread *td;
 214
 215         p = (struct proc *)mem;
 216 #ifdef KDTRACE_HOOKS
 217         kdtrace_proc_ctor(p);
 218 #endif
 219         EVENTHANDLER_DIRECT_INVOKE(process_ctor, p);
 220         td = FIRST_THREAD_IN_PROC(p);
 221         if (td != NULL) {
 222                 /* Make sure all thread constructors are executed */
 223                 EVENTHANDLER_DIRECT_INVOKE(thread_ctor, td);
 224         }
 225         return (0);
 226 }
 227
 228 /*
 229  * Reclaim a proc after use.
 230  */
 231 static void
 232 proc_dtor(void *mem, int size, void *arg)
 233 {
 234         struct proc *p;
 235         struct thread *td;
 236
 237         /* INVARIANTS checks go here */
 238         p = (struct proc *)mem;
 239         td = FIRST_THREAD_IN_PROC(p);
 240         if (td != NULL) {
 241 #ifdef INVARIANTS
 242                 KASSERT((p->p_numthreads == 1),
 243                     ("bad number of threads in exiting process"));
 244                 KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr"));
 245 #endif
 246                 /* Free all OSD associated to this thread. */
 247                 osd_thread_exit(td);
 248                 td_softdep_cleanup(td);
 249                 MPASS(td->td_su == NULL);
 250
 251                 /* Make sure all thread destructors are executed */
 252                 EVENTHANDLER_DIRECT_INVOKE(thread_dtor, td);
 253         }
 254         EVENTHANDLER_DIRECT_INVOKE(process_dtor, p);
 255 #ifdef KDTRACE_HOOKS
 256         kdtrace_proc_dtor(p);
 257 #endif
 258         if (p->p_ksi != NULL)
 259                 KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));
 260 }
 261
 262 /*
 263  * Initialize type-stable parts of a proc (when newly created).
 264  */
 265 static int
 266 proc_init(void *mem, int size, int flags)
 267 {
 268         struct proc *p;
 269
 270         p = (struct proc *)mem;
 271         mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK | MTX_NEW);
 272         mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_NEW);
 273         mtx_init(&p->p_statmtx, "pstatl", NULL, MTX_SPIN | MTX_NEW);
 274         mtx_init(&p->p_itimmtx, "pitiml", NULL, MTX_SPIN | MTX_NEW);
 275         mtx_init(&p->p_profmtx, "pprofl", NULL, MTX_SPIN | MTX_NEW);
 276         cv_init(&p->p_pwait, "ppwait");
 277         TAILQ_INIT(&p->p_threads);           /* all threads in proc */
 278         EVENTHANDLER_DIRECT_INVOKE(process_init, p);
 279         p->p_stats = pstats_alloc();
 280         p->p_pgrp = NULL;
 281         return (0);
 282 }
 283
 284 /*
 285  * UMA should ensure that this function is never called.
 286  * Freeing a proc structure would violate type stability.
 287  */
 288 static void
 289 proc_fini(void *mem, int size)
 290 {
 291 #ifdef notnow
 292         struct proc *p;
 293
 294         p = (struct proc *)mem;
 295         EVENTHANDLER_DIRECT_INVOKE(process_fini, p);
 296         pstats_free(p->p_stats);
 297         thread_free(FIRST_THREAD_IN_PROC(p));
 298         mtx_destroy(&p->p_mtx);
 299         if (p->p_ksi != NULL)
 300                 ksiginfo_free(p->p_ksi);
 301 #else
 302         panic("proc reclaimed");
 303 #endif
 304 }
 305
 306 static int
 307 pgrp_init(void *mem, int size, int flags)
 308 {
 309         struct pgrp *pg;
 310
 311         pg = mem;
 312         mtx_init(&pg->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
 313         return (0);
 314 }
 315
 316 /*
 317  * PID space management.
 318  *
 319  * These bitmaps are used by fork_findpid.
 320  */
 321 bitstr_t bit_decl(proc_id_pidmap, PID_MAX);
 322 bitstr_t bit_decl(proc_id_grpidmap, PID_MAX);
 323 bitstr_t bit_decl(proc_id_sessidmap, PID_MAX);
 324 bitstr_t bit_decl(proc_id_reapmap, PID_MAX);
 325
 326 static bitstr_t *proc_id_array[] = {
 327         proc_id_pidmap,
 328         proc_id_grpidmap,
 329         proc_id_sessidmap,
 330         proc_id_reapmap,
 331 };
 332
 333 void
 334 proc_id_set(int type, pid_t id)
 335 {
 336
 337         KASSERT(type >= 0 && type < nitems(proc_id_array),
 338             ("invalid type %d\n", type));
 339         mtx_lock(&procid_lock);
 340         KASSERT(bit_test(proc_id_array[type], id) == 0,
 341             ("bit %d already set in %d\n", id, type));
 342         bit_set(proc_id_array[type], id);
 343         mtx_unlock(&procid_lock);
 344 }
 345
 346 void
 347 proc_id_set_cond(int type, pid_t id)
 348 {
 349
 350         KASSERT(type >= 0 && type < nitems(proc_id_array),
 351             ("invalid type %d\n", type));
 352         if (bit_test(proc_id_array[type], id))
 353                 return;
 354         mtx_lock(&procid_lock);
 355         bit_set(proc_id_array[type], id);
 356         mtx_unlock(&procid_lock);
 357 }
 358
 359 void
 360 proc_id_clear(int type, pid_t id)
 361 {
 362
 363         KASSERT(type >= 0 && type < nitems(proc_id_array),
 364             ("invalid type %d\n", type));
 365         mtx_lock(&procid_lock);
 366         KASSERT(bit_test(proc_id_array[type], id) != 0,
 367             ("bit %d not set in %d\n", id, type));
 368         bit_clear(proc_id_array[type], id);
 369         mtx_unlock(&procid_lock);
 370 }
 371
 372 /*
 373  * Is p an inferior of the current process?
 374  */
 375 int
 376 inferior(struct proc *p)
 377 {
 378
 379         sx_assert(&proctree_lock, SX_LOCKED);
 380         PROC_LOCK_ASSERT(p, MA_OWNED);
 381         for (; p != curproc; p = proc_realparent(p)) {
 382                 if (p->p_pid == 0)
 383                         return (0);
 384         }
 385         return (1);
 386 }
 387
 388 /*
 389  * Shared lock all the pid hash lists.
 390  */
 391 void
 392 pidhash_slockall(void)
 393 {
 394         u_long i;
 395
 396         for (i = 0; i < pidhashlock + 1; i++)
 397                 sx_slock(&pidhashtbl_lock[i]);
 398 }
 399
 400 /*
 401  * Shared unlock all the pid hash lists.
 402  */
 403 void
 404 pidhash_sunlockall(void)
 405 {
 406         u_long i;
 407
 408         for (i = 0; i < pidhashlock + 1; i++)
 409                 sx_sunlock(&pidhashtbl_lock[i]);
 410 }
 411
 412 /*
 413  * Similar to pfind_any(), this function finds zombies.
 414  */
 415 struct proc *
 416 pfind_any_locked(pid_t pid)
 417 {
 418         struct proc *p;
 419
 420         sx_assert(PIDHASHLOCK(pid), SX_LOCKED);
 421         LIST_FOREACH(p, PIDHASH(pid), p_hash) {
 422                 if (p->p_pid == pid) {
 423                         PROC_LOCK(p);
 424                         if (p->p_state == PRS_NEW) {
 425                                 PROC_UNLOCK(p);
 426                                 p = NULL;
 427                         }
 428                         break;
 429                 }
 430         }
 431         return (p);
 432 }
 433
 434 /*
 435  * Locate a process by number.
 436  *
 437  * By not returning processes in the PRS_NEW state, we allow callers to avoid
 438  * testing for that condition to avoid dereferencing p_ucred, et al.
 439  */
 440 static __always_inline struct proc *
 441 _pfind(pid_t pid, bool zombie)
 442 {
 443         struct proc *p;
 444
 445         p = curproc;
 446         if (p->p_pid == pid) {
 447                 PROC_LOCK(p);
 448                 return (p);
 449         }
 450         sx_slock(PIDHASHLOCK(pid));
 451         LIST_FOREACH(p, PIDHASH(pid), p_hash) {
 452                 if (p->p_pid == pid) {
 453                         PROC_LOCK(p);
 454                         if (p->p_state == PRS_NEW ||
 455                             (!zombie && p->p_state == PRS_ZOMBIE)) {
 456                                 PROC_UNLOCK(p);
 457                                 p = NULL;
 458                         }
 459                         break;
 460                 }
 461         }
 462         sx_sunlock(PIDHASHLOCK(pid));
 463         return (p);
 464 }
 465
 466 struct proc *
 467 pfind(pid_t pid)
 468 {
 469
 470         return (_pfind(pid, false));
 471 }
 472
 473 /*
 474  * Same as pfind but allow zombies.
 475  */
 476 struct proc *
 477 pfind_any(pid_t pid)
 478 {
 479
 480         return (_pfind(pid, true));
 481 }
 482
 483 /*
 484  * Locate a process group by number.
 485  * The caller must hold proctree_lock.
 486  */
 487 struct pgrp *
 488 pgfind(pid_t pgid)
 489 {
 490         struct pgrp *pgrp;
 491
 492         sx_assert(&proctree_lock, SX_LOCKED);
 493
 494         LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) {
 495                 if (pgrp->pg_id == pgid) {
 496                         PGRP_LOCK(pgrp);
 497                         return (pgrp);
 498                 }
 499         }
 500         return (NULL);
 501 }
 502
 503 /*
 504  * Locate process and do additional manipulations, depending on flags.
 505  */
 506 int
 507 pget(pid_t pid, int flags, struct proc **pp)
 508 {
 509         struct proc *p;
 510         struct thread *td1;
 511         int error;
 512
 513         p = curproc;
 514         if (p->p_pid == pid) {
 515                 PROC_LOCK(p);
 516         } else {
 517                 p = NULL;
 518                 if (pid <= PID_MAX) {
 519                         if ((flags & PGET_NOTWEXIT) == 0)
 520                                 p = pfind_any(pid);
 521                         else
 522                                 p = pfind(pid);
 523                 } else if ((flags & PGET_NOTID) == 0) {
 524                         td1 = tdfind(pid, -1);
 525                         if (td1 != NULL)
 526                                 p = td1->td_proc;
 527                 }
 528                 if (p == NULL)
 529                         return (ESRCH);
 530                 if ((flags & PGET_CANSEE) != 0) {
 531                         error = p_cansee(curthread, p);
 532                         if (error != 0)
 533                                 goto errout;
 534                 }
 535         }
 536         if ((flags & PGET_CANDEBUG) != 0) {
 537                 error = p_candebug(curthread, p);
 538                 if (error != 0)
 539                         goto errout;
 540         }
 541         if ((flags & PGET_ISCURRENT) != 0 && curproc != p) {
 542                 error = EPERM;
 543                 goto errout;
 544         }
 545         if ((flags & PGET_NOTWEXIT) != 0 && (p->p_flag & P_WEXIT) != 0) {
 546                 error = ESRCH;
 547                 goto errout;
 548         }
 549         if ((flags & PGET_NOTINEXEC) != 0 && (p->p_flag & P_INEXEC) != 0) {
 550                 /*
 551                  * XXXRW: Not clear ESRCH is the right error during proc
 552                  * execve().
 553                  */
 554                 error = ESRCH;
 555                 goto errout;
 556         }
 557         if ((flags & PGET_HOLD) != 0) {
 558                 _PHOLD(p);
 559                 PROC_UNLOCK(p);
 560         }
 561         *pp = p;
 562         return (0);
 563 errout:
 564         PROC_UNLOCK(p);
 565         return (error);
 566 }
 567
 568 /*
 569  * Create a new process group.
 570  * pgid must be equal to the pid of p.
 571  * Begin a new session if required.
 572  */
 573 int
 574 enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess)
 575 {
 576
 577         sx_assert(&proctree_lock, SX_XLOCKED);
 578
 579         KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL"));
 580         KASSERT(p->p_pid == pgid,
 581             ("enterpgrp: new pgrp and pid != pgid"));
 582         KASSERT(pgfind(pgid) == NULL,
 583             ("enterpgrp: pgrp with pgid exists"));
 584         KASSERT(!SESS_LEADER(p),
 585             ("enterpgrp: session leader attempted setpgrp"));
 586
 587         if (sess != NULL) {
 588                 /*
 589                  * new session
 590                  */
 591                 mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF);
 592                 PROC_LOCK(p);
 593                 p->p_flag &= ~P_CONTROLT;
 594                 PROC_UNLOCK(p);
 595                 PGRP_LOCK(pgrp);
 596                 sess->s_leader = p;
 597                 sess->s_sid = p->p_pid;
 598                 proc_id_set(PROC_ID_SESSION, p->p_pid);
 599                 refcount_init(&sess->s_count, 1);
 600                 sess->s_ttyvp = NULL;
 601                 sess->s_ttydp = NULL;
 602                 sess->s_ttyp = NULL;
 603                 bcopy(p->p_session->s_login, sess->s_login,
 604                             sizeof(sess->s_login));
 605                 pgrp->pg_session = sess;
 606                 KASSERT(p == curproc,
 607                     ("enterpgrp: mksession and p != curproc"));
 608         } else {
 609                 pgrp->pg_session = p->p_session;
 610                 sess_hold(pgrp->pg_session);
 611                 PGRP_LOCK(pgrp);
 612         }
 613         pgrp->pg_id = pgid;
 614         proc_id_set(PROC_ID_GROUP, p->p_pid);
 615         LIST_INIT(&pgrp->pg_members);
 616         pgrp->pg_flags = 0;
 617
 618         /*
 619          * As we have an exclusive lock of proctree_lock,
 620          * this should not deadlock.
 621          */
 622         LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
 623         SLIST_INIT(&pgrp->pg_sigiolst);
 624         PGRP_UNLOCK(pgrp);
 625
 626         doenterpgrp(p, pgrp);
 627
 628         return (0);
 629 }
 630
 631 /*
 632  * Move p to an existing process group
 633  */
 634 int
 635 enterthispgrp(struct proc *p, struct pgrp *pgrp)
 636 {
 637
 638         sx_assert(&proctree_lock, SX_XLOCKED);
 639         PROC_LOCK_ASSERT(p, MA_NOTOWNED);
 640         PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
 641         PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
 642         SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
 643         KASSERT(pgrp->pg_session == p->p_session,
 644             ("%s: pgrp's session %p, p->p_session %p proc %p\n",
 645             __func__, pgrp->pg_session, p->p_session, p));
 646         KASSERT(pgrp != p->p_pgrp,
 647             ("%s: p %p belongs to pgrp %p", __func__, p, pgrp));
 648
 649         doenterpgrp(p, pgrp);
 650
 651         return (0);
 652 }
 653
 654 /*
 655  * If true, any child of q which belongs to group pgrp, qualifies the
 656  * process group pgrp as not orphaned.
 657  */
 658 static bool
 659 isjobproc(struct proc *q, struct pgrp *pgrp)
 660 {
 661         sx_assert(&proctree_lock, SX_LOCKED);
 662
 663         return (q->p_pgrp != pgrp &&
 664             q->p_pgrp->pg_session == pgrp->pg_session);
 665 }
 666
 667 static struct proc *
 668 jobc_reaper(struct proc *p)
 669 {
 670         struct proc *pp;
 671
 672         sx_assert(&proctree_lock, SA_LOCKED);
 673
 674         for (pp = p;;) {
 675                 pp = pp->p_reaper;
 676                 if (pp->p_reaper == pp ||
 677                     (pp->p_treeflag & P_TREE_GRPEXITED) == 0)
 678                         return (pp);
 679         }
 680 }
 681
 682 static struct proc *
 683 jobc_parent(struct proc *p, struct proc *p_exiting)
 684 {
 685         struct proc *pp;
 686
 687         sx_assert(&proctree_lock, SA_LOCKED);
 688
 689         pp = proc_realparent(p);
 690         if (pp->p_pptr == NULL || pp == p_exiting ||
 691             (pp->p_treeflag & P_TREE_GRPEXITED) == 0)
 692                 return (pp);
 693         return (jobc_reaper(pp));
 694 }
 695
 696 static int
 697 pgrp_calc_jobc(struct pgrp *pgrp)
 698 {
 699         struct proc *q;
 700         int cnt;
 701
 702 #ifdef INVARIANTS
 703         if (!mtx_owned(&pgrp->pg_mtx))
 704                 sx_assert(&proctree_lock, SA_LOCKED);
 705 #endif
 706
 707         cnt = 0;
 708         LIST_FOREACH(q, &pgrp->pg_members, p_pglist) {
 709                 if ((q->p_treeflag & P_TREE_GRPEXITED) != 0 ||
 710                     q->p_pptr == NULL)
 711                         continue;
 712                 if (isjobproc(jobc_parent(q, NULL), pgrp))
 713                         cnt++;
 714         }
 715         return (cnt);
 716 }
 717
 718 /*
 719  * Move p to a process group
 720  */
 721 static void
 722 doenterpgrp(struct proc *p, struct pgrp *pgrp)
 723 {
 724         struct pgrp *savepgrp;
 725         struct proc *pp;
 726
 727         sx_assert(&proctree_lock, SX_XLOCKED);
 728         PROC_LOCK_ASSERT(p, MA_NOTOWNED);
 729         PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
 730         PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
 731         SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
 732
 733         savepgrp = p->p_pgrp;
 734         pp = jobc_parent(p, NULL);
 735
 736         PGRP_LOCK(pgrp);
 737         PGRP_LOCK(savepgrp);
 738         if (isjobproc(pp, savepgrp) && pgrp_calc_jobc(savepgrp) == 1)
 739                 orphanpg(savepgrp);
 740         PROC_LOCK(p);
 741         LIST_REMOVE(p, p_pglist);
 742         p->p_pgrp = pgrp;
 743         PROC_UNLOCK(p);
 744         LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
 745         if (isjobproc(pp, pgrp))
 746                 pgrp->pg_flags &= ~PGRP_ORPHANED;
 747         PGRP_UNLOCK(savepgrp);
 748         PGRP_UNLOCK(pgrp);
 749         if (LIST_EMPTY(&savepgrp->pg_members))
 750                 pgdelete(savepgrp);
 751 }
 752
 753 /*
 754  * remove process from process group
 755  */
 756 int
 757 leavepgrp(struct proc *p)
 758 {
 759         struct pgrp *savepgrp;
 760
 761         sx_assert(&proctree_lock, SX_XLOCKED);
 762         savepgrp = p->p_pgrp;
 763         PGRP_LOCK(savepgrp);
 764         PROC_LOCK(p);
 765         LIST_REMOVE(p, p_pglist);
 766         p->p_pgrp = NULL;
 767         PROC_UNLOCK(p);
 768         PGRP_UNLOCK(savepgrp);
 769         if (LIST_EMPTY(&savepgrp->pg_members))
 770                 pgdelete(savepgrp);
 771         return (0);
 772 }
 773
 774 /*
 775  * delete a process group
 776  */
 777 static void
 778 pgdelete(struct pgrp *pgrp)
 779 {
 780         struct session *savesess;
 781         struct tty *tp;
 782
 783         sx_assert(&proctree_lock, SX_XLOCKED);
 784         PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
 785         SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
 786
 787         /*
 788          * Reset any sigio structures pointing to us as a result of
 789          * F_SETOWN with our pgid.  The proctree lock ensures that
 790          * new sigio structures will not be added after this point.
 791          */
 792         funsetownlst(&pgrp->pg_sigiolst);
 793
 794         PGRP_LOCK(pgrp);
 795         tp = pgrp->pg_session->s_ttyp;
 796         LIST_REMOVE(pgrp, pg_hash);
 797         savesess = pgrp->pg_session;
 798         PGRP_UNLOCK(pgrp);
 799
 800         /* Remove the reference to the pgrp before deallocating it. */
 801         if (tp != NULL) {
 802                 tty_lock(tp);
 803                 tty_rel_pgrp(tp, pgrp);
 804         }
 805
 806         proc_id_clear(PROC_ID_GROUP, pgrp->pg_id);
 807         uma_zfree(pgrp_zone, pgrp);
 808         sess_release(savesess);
 809 }
 810
 811
 812 static void
 813 fixjobc_kill(struct proc *p)
 814 {
 815         struct proc *q;
 816         struct pgrp *pgrp;
 817
 818         sx_assert(&proctree_lock, SX_LOCKED);
 819         PROC_LOCK_ASSERT(p, MA_NOTOWNED);
 820         pgrp = p->p_pgrp;
 821         PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
 822         SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
 823
 824         /*
 825          * p no longer affects process group orphanage for children.
 826          * It is marked by the flag because p is only physically
 827          * removed from its process group on wait(2).
 828          */
 829         MPASS((p->p_treeflag & P_TREE_GRPEXITED) == 0);
 830         p->p_treeflag |= P_TREE_GRPEXITED;
 831
 832         /*
 833          * Check if exiting p orphans its own group.
 834          */
 835         pgrp = p->p_pgrp;
 836         if (isjobproc(jobc_parent(p, NULL), pgrp)) {
 837                 PGRP_LOCK(pgrp);
 838                 if (pgrp_calc_jobc(pgrp) == 0)
 839                         orphanpg(pgrp);
 840                 PGRP_UNLOCK(pgrp);
 841         }
 842
 843         /*
 844          * Check this process' children to see whether they qualify
 845          * their process groups after reparenting to reaper.
 846          */
 847         LIST_FOREACH(q, &p->p_children, p_sibling) {
 848                 pgrp = q->p_pgrp;
 849                 PGRP_LOCK(pgrp);
 850                 if (pgrp_calc_jobc(pgrp) == 0) {
 851                         /*
 852                          * We want to handle exactly the children that
 853                          * has p as realparent.  Then, when calculating
 854                          * jobc_parent for children, we should ignore
 855                          * P_TREE_GRPEXITED flag already set on p.
 856                          */
 857                         if (jobc_parent(q, p) == p && isjobproc(p, pgrp))
 858                                 orphanpg(pgrp);
 859                 } else
 860                         pgrp->pg_flags &= ~PGRP_ORPHANED;
 861                 PGRP_UNLOCK(pgrp);
 862         }
 863         LIST_FOREACH(q, &p->p_orphans, p_orphan) {
 864                 pgrp = q->p_pgrp;
 865                 PGRP_LOCK(pgrp);
 866                 if (pgrp_calc_jobc(pgrp) == 0) {
 867                         if (isjobproc(p, pgrp))
 868                                 orphanpg(pgrp);
 869                 } else
 870                         pgrp->pg_flags &= ~PGRP_ORPHANED;
 871                 PGRP_UNLOCK(pgrp);
 872         }
 873 }
 874
 875 void
 876 killjobc(void)
 877 {
 878         struct session *sp;
 879         struct tty *tp;
 880         struct proc *p;
 881         struct vnode *ttyvp;
 882
 883         p = curproc;
 884         MPASS(p->p_flag & P_WEXIT);
 885         sx_assert(&proctree_lock, SX_LOCKED);
 886
 887         if (SESS_LEADER(p)) {
 888                 sp = p->p_session;
 889
 890                 /*
 891                  * s_ttyp is not zero'd; we use this to indicate that
 892                  * the session once had a controlling terminal. (for
 893                  * logging and informational purposes)
 894                  */
 895                 SESS_LOCK(sp);
 896                 ttyvp = sp->s_ttyvp;
 897                 tp = sp->s_ttyp;
 898                 sp->s_ttyvp = NULL;
 899                 sp->s_ttydp = NULL;
 900                 sp->s_leader = NULL;
 901                 SESS_UNLOCK(sp);
 902
 903                 /*
 904                  * Signal foreground pgrp and revoke access to
 905                  * controlling terminal if it has not been revoked
 906                  * already.
 907                  *
 908                  * Because the TTY may have been revoked in the mean
 909                  * time and could already have a new session associated
 910                  * with it, make sure we don't send a SIGHUP to a
 911                  * foreground process group that does not belong to this
 912                  * session.
 913                  */
 914
 915                 if (tp != NULL) {
 916                         tty_lock(tp);
 917                         if (tp->t_session == sp)
 918                                 tty_signal_pgrp(tp, SIGHUP);
 919                         tty_unlock(tp);
 920                 }
 921
 922                 if (ttyvp != NULL) {
 923                         sx_xunlock(&proctree_lock);
 924                         if (vn_lock(ttyvp, LK_EXCLUSIVE) == 0) {
 925                                 VOP_REVOKE(ttyvp, REVOKEALL);
 926                                 VOP_UNLOCK(ttyvp);
 927                         }
 928                         devfs_ctty_unref(ttyvp);
 929                         sx_xlock(&proctree_lock);
 930                 }
 931         }
 932         fixjobc_kill(p);
 933 }
 934
 935 /*
 936  * A process group has become orphaned, mark it as such for signal
 937  * delivery code.  If there are any stopped processes in the group,
 938  * hang-up all process in that group.
 939  */
 940 static void
 941 orphanpg(struct pgrp *pg)
 942 {
 943         struct proc *p;
 944
 945         PGRP_LOCK_ASSERT(pg, MA_OWNED);
 946
 947         pg->pg_flags |= PGRP_ORPHANED;
 948
 949         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
 950                 PROC_LOCK(p);
 951                 if (P_SHOULDSTOP(p) == P_STOPPED_SIG) {
 952                         PROC_UNLOCK(p);
 953                         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
 954                                 PROC_LOCK(p);
 955                                 kern_psignal(p, SIGHUP);
 956                                 kern_psignal(p, SIGCONT);
 957                                 PROC_UNLOCK(p);
 958                         }
 959                         return;
 960                 }
 961                 PROC_UNLOCK(p);
 962         }
 963 }
 964
 965 void
 966 sess_hold(struct session *s)
 967 {
 968
 969         refcount_acquire(&s->s_count);
 970 }
 971
 972 void
 973 sess_release(struct session *s)
 974 {
 975
 976         if (refcount_release(&s->s_count)) {
 977                 if (s->s_ttyp != NULL) {
 978                         tty_lock(s->s_ttyp);
 979                         tty_rel_sess(s->s_ttyp, s);
 980                 }
 981                 proc_id_clear(PROC_ID_SESSION, s->s_sid);
 982                 mtx_destroy(&s->s_mtx);
 983                 free(s, M_SESSION);
 984         }
 985 }
 986
 987 #ifdef DDB
 988
 989 static void
 990 db_print_pgrp_one(struct pgrp *pgrp, struct proc *p)
 991 {
 992         db_printf(
 993             "    pid %d at %p pr %d pgrp %p e %d jc %d\n",
 994             p->p_pid, p, p->p_pptr == NULL ? -1 : p->p_pptr->p_pid,
 995             p->p_pgrp, (p->p_treeflag & P_TREE_GRPEXITED) != 0,
 996             p->p_pptr == NULL ? 0 : isjobproc(p->p_pptr, pgrp));
 997 }
 998
 999 DB_SHOW_COMMAND(pgrpdump, pgrpdump)
1000 {
1001         struct pgrp *pgrp;
1002         struct proc *p;
1003         int i;
1004
1005         for (i = 0; i <= pgrphash; i++) {
1006                 if (!LIST_EMPTY(&pgrphashtbl[i])) {
1007                         db_printf("indx %d\n", i);
1008                         LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
1009                                 db_printf(
1010                         "  pgrp %p, pgid %d, sess %p, sesscnt %d, mem %p\n",
1011                                     pgrp, (int)pgrp->pg_id, pgrp->pg_session,
1012                                     pgrp->pg_session->s_count,
1013                                     LIST_FIRST(&pgrp->pg_members));
1014                                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
1015                                         db_print_pgrp_one(pgrp, p);
1016                         }
1017                 }
1018         }
1019 }
1020 #endif /* DDB */
1021
1022 /*
1023  * Calculate the kinfo_proc members which contain process-wide
1024  * informations.
1025  * Must be called with the target process locked.
1026  */
1027 static void
1028 fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp)
1029 {
1030         struct thread *td;
1031
1032         PROC_LOCK_ASSERT(p, MA_OWNED);
1033
1034         kp->ki_estcpu = 0;
1035         kp->ki_pctcpu = 0;
1036         FOREACH_THREAD_IN_PROC(p, td) {
1037                 thread_lock(td);
1038                 kp->ki_pctcpu += sched_pctcpu(td);
1039                 kp->ki_estcpu += sched_estcpu(td);
1040                 thread_unlock(td);
1041         }
1042 }
1043
1044 /*
1045  * Fill in any information that is common to all threads in the process.
1046  * Must be called with the target process locked.
1047  */
1048 static void
1049 fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
1050 {
1051         struct thread *td0;
1052         struct ucred *cred;
1053         struct sigacts *ps;
1054         struct timeval boottime;
1055
1056         PROC_LOCK_ASSERT(p, MA_OWNED);
1057
1058         kp->ki_structsize = sizeof(*kp);
1059         kp->ki_paddr = p;
1060         kp->ki_addr =/* p->p_addr; */0; /* XXX */
1061         kp->ki_args = p->p_args;
1062         kp->ki_textvp = p->p_textvp;
1063 #ifdef KTRACE
1064         kp->ki_tracep = ktr_get_tracevp(p, false);
1065         kp->ki_traceflag = p->p_traceflag;
1066 #endif
1067         kp->ki_fd = p->p_fd;
1068         kp->ki_pd = p->p_pd;
1069         kp->ki_vmspace = p->p_vmspace;
1070         kp->ki_flag = p->p_flag;
1071         kp->ki_flag2 = p->p_flag2;
1072         cred = p->p_ucred;
1073         if (cred) {
1074                 kp->ki_uid = cred->cr_uid;
1075                 kp->ki_ruid = cred->cr_ruid;
1076                 kp->ki_svuid = cred->cr_svuid;
1077                 kp->ki_cr_flags = 0;
1078                 if (cred->cr_flags & CRED_FLAG_CAPMODE)
1079                         kp->ki_cr_flags |= KI_CRF_CAPABILITY_MODE;
1080                 /* XXX bde doesn't like KI_NGROUPS */
1081                 if (cred->cr_ngroups > KI_NGROUPS) {
1082                         kp->ki_ngroups = KI_NGROUPS;
1083                         kp->ki_cr_flags |= KI_CRF_GRP_OVERFLOW;
1084                 } else
1085                         kp->ki_ngroups = cred->cr_ngroups;
1086                 bcopy(cred->cr_groups, kp->ki_groups,
1087                     kp->ki_ngroups * sizeof(gid_t));
1088                 kp->ki_rgid = cred->cr_rgid;
1089                 kp->ki_svgid = cred->cr_svgid;
1090                 /* If jailed(cred), emulate the old P_JAILED flag. */
1091                 if (jailed(cred)) {
1092                         kp->ki_flag |= P_JAILED;
1093                         /* If inside the jail, use 0 as a jail ID. */
1094                         if (cred->cr_prison != curthread->td_ucred->cr_prison)
1095                                 kp->ki_jid = cred->cr_prison->pr_id;
1096                 }
1097                 strlcpy(kp->ki_loginclass, cred->cr_loginclass->lc_name,
1098                     sizeof(kp->ki_loginclass));
1099         }
1100         ps = p->p_sigacts;
1101         if (ps) {
1102                 mtx_lock(&ps->ps_mtx);
1103                 kp->ki_sigignore = ps->ps_sigignore;
1104                 kp->ki_sigcatch = ps->ps_sigcatch;
1105                 mtx_unlock(&ps->ps_mtx);
1106         }
1107         if (p->p_state != PRS_NEW &&
1108             p->p_state != PRS_ZOMBIE &&
1109             p->p_vmspace != NULL) {
1110                 struct vmspace *vm = p->p_vmspace;
1111
1112                 kp->ki_size = vm->vm_map.size;
1113                 kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
1114                 FOREACH_THREAD_IN_PROC(p, td0) {
1115                         if (!TD_IS_SWAPPED(td0))
1116                                 kp->ki_rssize += td0->td_kstack_pages;
1117                 }
1118                 kp->ki_swrss = vm->vm_swrss;
1119                 kp->ki_tsize = vm->vm_tsize;
1120                 kp->ki_dsize = vm->vm_dsize;
1121                 kp->ki_ssize = vm->vm_ssize;
1122         } else if (p->p_state == PRS_ZOMBIE)
1123                 kp->ki_stat = SZOMB;
1124         if (kp->ki_flag & P_INMEM)
1125                 kp->ki_sflag = PS_INMEM;
1126         else
1127                 kp->ki_sflag = 0;
1128         /* Calculate legacy swtime as seconds since 'swtick'. */
1129         kp->ki_swtime = (ticks - p->p_swtick) / hz;
1130         kp->ki_pid = p->p_pid;
1131         kp->ki_nice = p->p_nice;
1132         kp->ki_fibnum = p->p_fibnum;
1133         kp->ki_start = p->p_stats->p_start;
1134         getboottime(&boottime);
1135         timevaladd(&kp->ki_start, &boottime);
1136         PROC_STATLOCK(p);
1137         rufetch(p, &kp->ki_rusage);
1138         kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
1139         calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
1140         PROC_STATUNLOCK(p);
1141         calccru(p, &kp->ki_childutime, &kp->ki_childstime);
1142         /* Some callers want child times in a single value. */
1143         kp->ki_childtime = kp->ki_childstime;
1144         timevaladd(&kp->ki_childtime, &kp->ki_childutime);
1145
1146         FOREACH_THREAD_IN_PROC(p, td0)
1147                 kp->ki_cow += td0->td_cow;
1148
1149         if (p->p_comm[0] != '\0')
1150                 strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
1151         if (p->p_sysent && p->p_sysent->sv_name != NULL &&
1152             p->p_sysent->sv_name[0] != '\0')
1153                 strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul));
1154         kp->ki_siglist = p->p_siglist;
1155         kp->ki_xstat = KW_EXITCODE(p->p_xexit, p->p_xsig);
1156         kp->ki_acflag = p->p_acflag;
1157         kp->ki_lock = p->p_lock;
1158         if (p->p_pptr) {
1159                 kp->ki_ppid = p->p_oppid;
1160                 if (p->p_flag & P_TRACED)
1161                         kp->ki_tracer = p->p_pptr->p_pid;
1162         }
1163 }
1164
1165 /*
1166  * Fill job-related process information.
1167  */
1168 static void
1169 fill_kinfo_proc_pgrp(struct proc *p, struct kinfo_proc *kp)
1170 {
1171         struct tty *tp;
1172         struct session *sp;
1173         struct pgrp *pgrp;
1174
1175         sx_assert(&proctree_lock, SA_LOCKED);
1176         PROC_LOCK_ASSERT(p, MA_OWNED);
1177
1178         pgrp = p->p_pgrp;
1179         if (pgrp == NULL)
1180                 return;
1181
1182         kp->ki_pgid = pgrp->pg_id;
1183         kp->ki_jobc = pgrp_calc_jobc(pgrp);
1184
1185         sp = pgrp->pg_session;
1186         tp = NULL;
1187
1188         if (sp != NULL) {
1189                 kp->ki_sid = sp->s_sid;
1190                 SESS_LOCK(sp);
1191                 strlcpy(kp->ki_login, sp->s_login, sizeof(kp->ki_login));
1192                 if (sp->s_ttyvp)
1193                         kp->ki_kiflag |= KI_CTTY;
1194                 if (SESS_LEADER(p))
1195                         kp->ki_kiflag |= KI_SLEADER;
1196                 tp = sp->s_ttyp;
1197                 SESS_UNLOCK(sp);
1198         }
1199
1200         if ((p->p_flag & P_CONTROLT) && tp != NULL) {
1201                 kp->ki_tdev = tty_udev(tp);
1202                 kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
1203                 kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1204                 if (tp->t_session)
1205                         kp->ki_tsid = tp->t_session->s_sid;
1206         } else {
1207                 kp->ki_tdev = NODEV;
1208                 kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */
1209         }
1210 }
1211
1212 /*
1213  * Fill in information that is thread specific.  Must be called with
1214  * target process locked.  If 'preferthread' is set, overwrite certain
1215  * process-related fields that are maintained for both threads and
1216  * processes.
1217  */
1218 static void
1219 fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
1220 {
1221         struct proc *p;
1222
1223         p = td->td_proc;
1224         kp->ki_tdaddr = td;
1225         PROC_LOCK_ASSERT(p, MA_OWNED);
1226
1227         if (preferthread)
1228                 PROC_STATLOCK(p);
1229         thread_lock(td);
1230         if (td->td_wmesg != NULL)
1231                 strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
1232         else
1233                 bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg));
1234         if (strlcpy(kp->ki_tdname, td->td_name, sizeof(kp->ki_tdname)) >=
1235             sizeof(kp->ki_tdname)) {
1236                 strlcpy(kp->ki_moretdname,
1237                     td->td_name + sizeof(kp->ki_tdname) - 1,
1238                     sizeof(kp->ki_moretdname));
1239         } else {
1240                 bzero(kp->ki_moretdname, sizeof(kp->ki_moretdname));
1241         }
1242         if (TD_ON_LOCK(td)) {
1243                 kp->ki_kiflag |= KI_LOCKBLOCK;
1244                 strlcpy(kp->ki_lockname, td->td_lockname,
1245                     sizeof(kp->ki_lockname));
1246         } else {
1247                 kp->ki_kiflag &= ~KI_LOCKBLOCK;
1248                 bzero(kp->ki_lockname, sizeof(kp->ki_lockname));
1249         }
1250
1251         if (p->p_state == PRS_NORMAL) { /* approximate. */
1252                 if (TD_ON_RUNQ(td) ||
1253                     TD_CAN_RUN(td) ||
1254                     TD_IS_RUNNING(td)) {
1255                         kp->ki_stat = SRUN;
1256                 } else if (P_SHOULDSTOP(p)) {
1257                         kp->ki_stat = SSTOP;
1258                 } else if (TD_IS_SLEEPING(td)) {
1259                         kp->ki_stat = SSLEEP;
1260                 } else if (TD_ON_LOCK(td)) {
1261                         kp->ki_stat = SLOCK;
1262                 } else {
1263                         kp->ki_stat = SWAIT;
1264                 }
1265         } else if (p->p_state == PRS_ZOMBIE) {
1266                 kp->ki_stat = SZOMB;
1267         } else {
1268                 kp->ki_stat = SIDL;
1269         }
1270
1271         /* Things in the thread */
1272         kp->ki_wchan = td->td_wchan;
1273         kp->ki_pri.pri_level = td->td_priority;
1274         kp->ki_pri.pri_native = td->td_base_pri;
1275
1276         /*
1277          * Note: legacy fields; clamp at the old NOCPU value and/or
1278          * the maximum u_char CPU value.
1279          */
1280         if (td->td_lastcpu == NOCPU)
1281                 kp->ki_lastcpu_old = NOCPU_OLD;
1282         else if (td->td_lastcpu > MAXCPU_OLD)
1283                 kp->ki_lastcpu_old = MAXCPU_OLD;
1284         else
1285                 kp->ki_lastcpu_old = td->td_lastcpu;
1286
1287         if (td->td_oncpu == NOCPU)
1288                 kp->ki_oncpu_old = NOCPU_OLD;
1289         else if (td->td_oncpu > MAXCPU_OLD)
1290                 kp->ki_oncpu_old = MAXCPU_OLD;
1291         else
1292                 kp->ki_oncpu_old = td->td_oncpu;
1293
1294         kp->ki_lastcpu = td->td_lastcpu;
1295         kp->ki_oncpu = td->td_oncpu;
1296         kp->ki_tdflags = td->td_flags;
1297         kp->ki_tid = td->td_tid;
1298         kp->ki_numthreads = p->p_numthreads;
1299         kp->ki_pcb = td->td_pcb;
1300         kp->ki_kstack = (void *)td->td_kstack;
1301         kp->ki_slptime = (ticks - td->td_slptick) / hz;
1302         kp->ki_pri.pri_class = td->td_pri_class;
1303         kp->ki_pri.pri_user = td->td_user_pri;
1304
1305         if (preferthread) {
1306                 rufetchtd(td, &kp->ki_rusage);
1307                 kp->ki_runtime = cputick2usec(td->td_rux.rux_runtime);
1308                 kp->ki_pctcpu = sched_pctcpu(td);
1309                 kp->ki_estcpu = sched_estcpu(td);
1310                 kp->ki_cow = td->td_cow;
1311         }
1312
1313         /* We can't get this anymore but ps etc never used it anyway. */
1314         kp->ki_rqindex = 0;
1315
1316         if (preferthread)
1317                 kp->ki_siglist = td->td_siglist;
1318         kp->ki_sigmask = td->td_sigmask;
1319         thread_unlock(td);
1320         if (preferthread)
1321                 PROC_STATUNLOCK(p);
1322 }
1323
1324 /*
1325  * Fill in a kinfo_proc structure for the specified process.
1326  * Must be called with the target process locked.
1327  */
1328 void
1329 fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
1330 {
1331         MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
1332
1333         bzero(kp, sizeof(*kp));
1334
1335         fill_kinfo_proc_pgrp(p,kp);
1336         fill_kinfo_proc_only(p, kp);
1337         fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0);
1338         fill_kinfo_aggregate(p, kp);
1339 }
1340
1341 struct pstats *
1342 pstats_alloc(void)
1343 {
1344
1345         return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK));
1346 }
1347
1348 /*
1349  * Copy parts of p_stats; zero the rest of p_stats (statistics).
1350  */
1351 void
1352 pstats_fork(struct pstats *src, struct pstats *dst)
1353 {
1354
1355         bzero(&dst->pstat_startzero,
1356             __rangeof(struct pstats, pstat_startzero, pstat_endzero));
1357         bcopy(&src->pstat_startcopy, &dst->pstat_startcopy,
1358             __rangeof(struct pstats, pstat_startcopy, pstat_endcopy));
1359 }
1360
1361 void
1362 pstats_free(struct pstats *ps)
1363 {
1364
1365         free(ps, M_SUBPROC);
1366 }
1367
1368 #ifdef COMPAT_FREEBSD32
1369
1370 /*
1371  * This function is typically used to copy out the kernel address, so
1372  * it can be replaced by assignment of zero.
1373  */
1374 static inline uint32_t
1375 ptr32_trim(const void *ptr)
1376 {
1377         uintptr_t uptr;
1378
1379         uptr = (uintptr_t)ptr;
1380         return ((uptr > UINT_MAX) ? 0 : uptr);
1381 }
1382
1383 #define PTRTRIM_CP(src,dst,fld) \
1384         do { (dst).fld = ptr32_trim((src).fld); } while (0)
1385
1386 static void
1387 freebsd32_kinfo_proc_out(const struct kinfo_proc *ki, struct kinfo_proc32 *ki32)
1388 {
1389         int i;
1390
1391         bzero(ki32, sizeof(struct kinfo_proc32));
1392         ki32->ki_structsize = sizeof(struct kinfo_proc32);
1393         CP(*ki, *ki32, ki_layout);
1394         PTRTRIM_CP(*ki, *ki32, ki_args);
1395         PTRTRIM_CP(*ki, *ki32, ki_paddr);
1396         PTRTRIM_CP(*ki, *ki32, ki_addr);
1397         PTRTRIM_CP(*ki, *ki32, ki_tracep);
1398         PTRTRIM_CP(*ki, *ki32, ki_textvp);
1399         PTRTRIM_CP(*ki, *ki32, ki_fd);
1400         PTRTRIM_CP(*ki, *ki32, ki_vmspace);
1401         PTRTRIM_CP(*ki, *ki32, ki_wchan);
1402         CP(*ki, *ki32, ki_pid);
1403         CP(*ki, *ki32, ki_ppid);
1404         CP(*ki, *ki32, ki_pgid);
1405         CP(*ki, *ki32, ki_tpgid);
1406         CP(*ki, *ki32, ki_sid);
1407         CP(*ki, *ki32, ki_tsid);
1408         CP(*ki, *ki32, ki_jobc);
1409         CP(*ki, *ki32, ki_tdev);
1410         CP(*ki, *ki32, ki_tdev_freebsd11);
1411         CP(*ki, *ki32, ki_siglist);
1412         CP(*ki, *ki32, ki_sigmask);
1413         CP(*ki, *ki32, ki_sigignore);
1414         CP(*ki, *ki32, ki_sigcatch);
1415         CP(*ki, *ki32, ki_uid);
1416         CP(*ki, *ki32, ki_ruid);
1417         CP(*ki, *ki32, ki_svuid);
1418         CP(*ki, *ki32, ki_rgid);
1419         CP(*ki, *ki32, ki_svgid);
1420         CP(*ki, *ki32, ki_ngroups);
1421         for (i = 0; i < KI_NGROUPS; i++)
1422                 CP(*ki, *ki32, ki_groups[i]);
1423         CP(*ki, *ki32, ki_size);
1424         CP(*ki, *ki32, ki_rssize);
1425         CP(*ki, *ki32, ki_swrss);
1426         CP(*ki, *ki32, ki_tsize);
1427         CP(*ki, *ki32, ki_dsize);
1428         CP(*ki, *ki32, ki_ssize);
1429         CP(*ki, *ki32, ki_xstat);
1430         CP(*ki, *ki32, ki_acflag);
1431         CP(*ki, *ki32, ki_pctcpu);
1432         CP(*ki, *ki32, ki_estcpu);
1433         CP(*ki, *ki32, ki_slptime);
1434         CP(*ki, *ki32, ki_swtime);
1435         CP(*ki, *ki32, ki_cow);
1436         CP(*ki, *ki32, ki_runtime);
1437         TV_CP(*ki, *ki32, ki_start);
1438         TV_CP(*ki, *ki32, ki_childtime);
1439         CP(*ki, *ki32, ki_flag);
1440         CP(*ki, *ki32, ki_kiflag);
1441         CP(*ki, *ki32, ki_traceflag);
1442         CP(*ki, *ki32, ki_stat);
1443         CP(*ki, *ki32, ki_nice);
1444         CP(*ki, *ki32, ki_lock);
1445         CP(*ki, *ki32, ki_rqindex);
1446         CP(*ki, *ki32, ki_oncpu);
1447         CP(*ki, *ki32, ki_lastcpu);
1448
1449         /* XXX TODO: wrap cpu value as appropriate */
1450         CP(*ki, *ki32, ki_oncpu_old);
1451         CP(*ki, *ki32, ki_lastcpu_old);
1452
1453         bcopy(ki->ki_tdname, ki32->ki_tdname, TDNAMLEN + 1);
1454         bcopy(ki->ki_wmesg, ki32->ki_wmesg, WMESGLEN + 1);
1455         bcopy(ki->ki_login, ki32->ki_login, LOGNAMELEN + 1);
1456         bcopy(ki->ki_lockname, ki32->ki_lockname, LOCKNAMELEN + 1);
1457         bcopy(ki->ki_comm, ki32->ki_comm, COMMLEN + 1);
1458         bcopy(ki->ki_emul, ki32->ki_emul, KI_EMULNAMELEN + 1);
1459         bcopy(ki->ki_loginclass, ki32->ki_loginclass, LOGINCLASSLEN + 1);
1460         bcopy(ki->ki_moretdname, ki32->ki_moretdname, MAXCOMLEN - TDNAMLEN + 1);
1461         CP(*ki, *ki32, ki_tracer);
1462         CP(*ki, *ki32, ki_flag2);
1463         CP(*ki, *ki32, ki_fibnum);
1464         CP(*ki, *ki32, ki_cr_flags);
1465         CP(*ki, *ki32, ki_jid);
1466         CP(*ki, *ki32, ki_numthreads);
1467         CP(*ki, *ki32, ki_tid);
1468         CP(*ki, *ki32, ki_pri);
1469         freebsd32_rusage_out(&ki->ki_rusage, &ki32->ki_rusage);
1470         freebsd32_rusage_out(&ki->ki_rusage_ch, &ki32->ki_rusage_ch);
1471         PTRTRIM_CP(*ki, *ki32, ki_pcb);
1472         PTRTRIM_CP(*ki, *ki32, ki_kstack);
1473         PTRTRIM_CP(*ki, *ki32, ki_udata);
1474         PTRTRIM_CP(*ki, *ki32, ki_tdaddr);
1475         CP(*ki, *ki32, ki_sflag);
1476         CP(*ki, *ki32, ki_tdflags);
1477 }
1478 #endif
1479
1480 static ssize_t
1481 kern_proc_out_size(struct proc *p, int flags)
1482 {
1483         ssize_t size = 0;
1484
1485         PROC_LOCK_ASSERT(p, MA_OWNED);
1486
1487         if ((flags & KERN_PROC_NOTHREADS) != 0) {
1488 #ifdef COMPAT_FREEBSD32
1489                 if ((flags & KERN_PROC_MASK32) != 0) {
1490                         size += sizeof(struct kinfo_proc32);
1491                 } else
1492 #endif
1493                         size += sizeof(struct kinfo_proc);
1494         } else {
1495 #ifdef COMPAT_FREEBSD32
1496                 if ((flags & KERN_PROC_MASK32) != 0)
1497                         size += sizeof(struct kinfo_proc32) * p->p_numthreads;
1498                 else
1499 #endif
1500                         size += sizeof(struct kinfo_proc) * p->p_numthreads;
1501         }
1502         PROC_UNLOCK(p);
1503         return (size);
1504 }
1505
1506 int
1507 kern_proc_out(struct proc *p, struct sbuf *sb, int flags)
1508 {
1509         struct thread *td;
1510         struct kinfo_proc ki;
1511 #ifdef COMPAT_FREEBSD32
1512         struct kinfo_proc32 ki32;
1513 #endif
1514         int error;
1515
1516         PROC_LOCK_ASSERT(p, MA_OWNED);
1517         MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
1518
1519         error = 0;
1520         fill_kinfo_proc(p, &ki);
1521         if ((flags & KERN_PROC_NOTHREADS) != 0) {
1522 #ifdef COMPAT_FREEBSD32
1523                 if ((flags & KERN_PROC_MASK32) != 0) {
1524                         freebsd32_kinfo_proc_out(&ki, &ki32);
1525                         if (sbuf_bcat(sb, &ki32, sizeof(ki32)) != 0)
1526                                 error = ENOMEM;
1527                 } else
1528 #endif
1529                         if (sbuf_bcat(sb, &ki, sizeof(ki)) != 0)
1530                                 error = ENOMEM;
1531         } else {
1532                 FOREACH_THREAD_IN_PROC(p, td) {
1533                         fill_kinfo_thread(td, &ki, 1);
1534 #ifdef COMPAT_FREEBSD32
1535                         if ((flags & KERN_PROC_MASK32) != 0) {
1536                                 freebsd32_kinfo_proc_out(&ki, &ki32);
1537                                 if (sbuf_bcat(sb, &ki32, sizeof(ki32)) != 0)
1538                                         error = ENOMEM;
1539                         } else
1540 #endif
1541                                 if (sbuf_bcat(sb, &ki, sizeof(ki)) != 0)
1542                                         error = ENOMEM;
1543                         if (error != 0)
1544                                 break;
1545                 }
1546         }
1547         PROC_UNLOCK(p);
1548         return (error);
1549 }
1550
1551 static int
1552 sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags)
1553 {
1554         struct sbuf sb;
1555         struct kinfo_proc ki;
1556         int error, error2;
1557
1558         if (req->oldptr == NULL)
1559                 return (SYSCTL_OUT(req, 0, kern_proc_out_size(p, flags)));
1560
1561         sbuf_new_for_sysctl(&sb, (char *)&ki, sizeof(ki), req);
1562         sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
1563         error = kern_proc_out(p, &sb, flags);
1564         error2 = sbuf_finish(&sb);
1565         sbuf_delete(&sb);
1566         if (error != 0)
1567                 return (error);
1568         else if (error2 != 0)
1569                 return (error2);
1570         return (0);
1571 }
1572
1573 int
1574 proc_iterate(int (*cb)(struct proc *, void *), void *cbarg)
1575 {
1576         struct proc *p;
1577         int error, i, j;
1578
1579         for (i = 0; i < pidhashlock + 1; i++) {
1580                 sx_slock(&proctree_lock);
1581                 sx_slock(&pidhashtbl_lock[i]);
1582                 for (j = i; j <= pidhash; j += pidhashlock + 1) {
1583                         LIST_FOREACH(p, &pidhashtbl[j], p_hash) {
1584                                 if (p->p_state == PRS_NEW)
1585                                         continue;
1586                                 error = cb(p, cbarg);
1587                                 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
1588                                 if (error != 0) {
1589                                         sx_sunlock(&pidhashtbl_lock[i]);
1590                                         sx_sunlock(&proctree_lock);
1591                                         return (error);
1592                                 }
1593                         }
1594                 }
1595                 sx_sunlock(&pidhashtbl_lock[i]);
1596                 sx_sunlock(&proctree_lock);
1597         }
1598         return (0);
1599 }
1600
1601 struct kern_proc_out_args {
1602         struct sysctl_req *req;
1603         int flags;
1604         int oid_number;
1605         int *name;
1606 };
1607
1608 static int
1609 sysctl_kern_proc_iterate(struct proc *p, void *origarg)
1610 {
1611         struct kern_proc_out_args *arg = origarg;
1612         int *name = arg->name;
1613         int oid_number = arg->oid_number;
1614         int flags = arg->flags;
1615         struct sysctl_req *req = arg->req;
1616         int error = 0;
1617
1618         PROC_LOCK(p);
1619
1620         KASSERT(p->p_ucred != NULL,
1621             ("process credential is NULL for non-NEW proc"));
1622         /*
1623          * Show a user only appropriate processes.
1624          */
1625         if (p_cansee(curthread, p))
1626                 goto skip;
1627         /*
1628          * TODO - make more efficient (see notes below).
1629          * do by session.
1630          */
1631         switch (oid_number) {
1632         case KERN_PROC_GID:
1633                 if (p->p_ucred->cr_gid != (gid_t)name[0])
1634                         goto skip;
1635                 break;
1636
1637         case KERN_PROC_PGRP:
1638                 /* could do this by traversing pgrp */
1639                 if (p->p_pgrp == NULL ||
1640                     p->p_pgrp->pg_id != (pid_t)name[0])
1641                         goto skip;
1642                 break;
1643
1644         case KERN_PROC_RGID:
1645                 if (p->p_ucred->cr_rgid != (gid_t)name[0])
1646                         goto skip;
1647                 break;
1648
1649         case KERN_PROC_SESSION:
1650                 if (p->p_session == NULL ||
1651                     p->p_session->s_sid != (pid_t)name[0])
1652                         goto skip;
1653                 break;
1654
1655         case KERN_PROC_TTY:
1656                 if ((p->p_flag & P_CONTROLT) == 0 ||
1657                     p->p_session == NULL)
1658                         goto skip;
1659                 /* XXX proctree_lock */
1660                 SESS_LOCK(p->p_session);
1661                 if (p->p_session->s_ttyp == NULL ||
1662                     tty_udev(p->p_session->s_ttyp) !=
1663                     (dev_t)name[0]) {
1664                         SESS_UNLOCK(p->p_session);
1665                         goto skip;
1666                 }
1667                 SESS_UNLOCK(p->p_session);
1668                 break;
1669
1670         case KERN_PROC_UID:
1671                 if (p->p_ucred->cr_uid != (uid_t)name[0])
1672                         goto skip;
1673                 break;
1674
1675         case KERN_PROC_RUID:
1676                 if (p->p_ucred->cr_ruid != (uid_t)name[0])
1677                         goto skip;
1678                 break;
1679
1680         case KERN_PROC_PROC:
1681                 break;
1682
1683         default:
1684                 break;
1685         }
1686         error = sysctl_out_proc(p, req, flags);
1687         PROC_LOCK_ASSERT(p, MA_NOTOWNED);
1688         return (error);
1689 skip:
1690         PROC_UNLOCK(p);
1691         return (0);
1692 }
1693
1694 static int
1695 sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
1696 {
1697         struct kern_proc_out_args iterarg;
1698         int *name = (int *)arg1;
1699         u_int namelen = arg2;
1700         struct proc *p;
1701         int flags, oid_number;
1702         int error = 0;
1703
1704         oid_number = oidp->oid_number;
1705         if (oid_number != KERN_PROC_ALL &&
1706             (oid_number & KERN_PROC_INC_THREAD) == 0)
1707                 flags = KERN_PROC_NOTHREADS;
1708         else {
1709                 flags = 0;
1710                 oid_number &= ~KERN_PROC_INC_THREAD;
1711         }
1712 #ifdef COMPAT_FREEBSD32
1713         if (req->flags & SCTL_MASK32)
1714                 flags |= KERN_PROC_MASK32;
1715 #endif
1716         if (oid_number == KERN_PROC_PID) {
1717                 if (namelen != 1)
1718                         return (EINVAL);
1719                 error = sysctl_wire_old_buffer(req, 0);
1720                 if (error)
1721                         return (error);
1722                 sx_slock(&proctree_lock);
1723                 error = pget((pid_t)name[0], PGET_CANSEE, &p);
1724                 if (error == 0)
1725                         error = sysctl_out_proc(p, req, flags);
1726                 sx_sunlock(&proctree_lock);
1727                 return (error);
1728         }
1729
1730         switch (oid_number) {
1731         case KERN_PROC_ALL:
1732                 if (namelen != 0)
1733                         return (EINVAL);
1734                 break;
1735         case KERN_PROC_PROC:
1736                 if (namelen != 0 && namelen != 1)
1737                         return (EINVAL);
1738                 break;
1739         default:
1740                 if (namelen != 1)
1741                         return (EINVAL);
1742                 break;
1743         }
1744
1745         if (req->oldptr == NULL) {
1746                 /* overestimate by 5 procs */
1747                 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
1748                 if (error)
1749                         return (error);
1750         } else {
1751                 error = sysctl_wire_old_buffer(req, 0);
1752                 if (error != 0)
1753                         return (error);
1754         }
1755         iterarg.flags = flags;
1756         iterarg.oid_number = oid_number;
1757         iterarg.req = req;
1758         iterarg.name = name;
1759         error = proc_iterate(sysctl_kern_proc_iterate, &iterarg);
1760         return (error);
1761 }
1762
1763 struct pargs *
1764 pargs_alloc(int len)
1765 {
1766         struct pargs *pa;
1767
1768         pa = malloc(sizeof(struct pargs) + len, M_PARGS,
1769                 M_WAITOK);
1770         refcount_init(&pa->ar_ref, 1);
1771         pa->ar_length = len;
1772         return (pa);
1773 }
1774
1775 static void
1776 pargs_free(struct pargs *pa)
1777 {
1778
1779         free(pa, M_PARGS);
1780 }
1781
1782 void
1783 pargs_hold(struct pargs *pa)
1784 {
1785
1786         if (pa == NULL)
1787                 return;
1788         refcount_acquire(&pa->ar_ref);
1789 }
1790
1791 void
1792 pargs_drop(struct pargs *pa)
1793 {
1794
1795         if (pa == NULL)
1796                 return;
1797         if (refcount_release(&pa->ar_ref))
1798                 pargs_free(pa);
1799 }
1800
1801 static int
1802 proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf,
1803     size_t len)
1804 {
1805         ssize_t n;
1806
1807         /*
1808          * This may return a short read if the string is shorter than the chunk
1809          * and is aligned at the end of the page, and the following page is not
1810          * mapped.
1811          */
1812         n = proc_readmem(td, p, (vm_offset_t)sptr, buf, len);
1813         if (n <= 0)
1814                 return (ENOMEM);
1815         return (0);
1816 }
1817
1818 #define PROC_AUXV_MAX   256     /* Safety limit on auxv size. */
1819
1820 enum proc_vector_type {
1821         PROC_ARG,
1822         PROC_ENV,
1823         PROC_AUX,
1824 };
1825
1826 #ifdef COMPAT_FREEBSD32
1827 static int
1828 get_proc_vector32(struct thread *td, struct proc *p, char ***proc_vectorp,
1829     size_t *vsizep, enum proc_vector_type type)
1830 {
1831         struct freebsd32_ps_strings pss;
1832         Elf32_Auxinfo aux;
1833         vm_offset_t vptr, ptr;
1834         uint32_t *proc_vector32;
1835         char **proc_vector;
1836         size_t vsize, size;
1837         int i, error;
1838
1839         error = 0;
1840         if (proc_readmem(td, p, (vm_offset_t)p->p_sysent->sv_psstrings, &pss,
1841             sizeof(pss)) != sizeof(pss))
1842                 return (ENOMEM);
1843         switch (type) {
1844         case PROC_ARG:
1845                 vptr = (vm_offset_t)PTRIN(pss.ps_argvstr);
1846                 vsize = pss.ps_nargvstr;
1847                 if (vsize > ARG_MAX)
1848                         return (ENOEXEC);
1849                 size = vsize * sizeof(int32_t);
1850                 break;
1851         case PROC_ENV:
1852                 vptr = (vm_offset_t)PTRIN(pss.ps_envstr);
1853                 vsize = pss.ps_nenvstr;
1854                 if (vsize > ARG_MAX)
1855                         return (ENOEXEC);
1856                 size = vsize * sizeof(int32_t);
1857                 break;
1858         case PROC_AUX:
1859                 vptr = (vm_offset_t)PTRIN(pss.ps_envstr) +
1860                     (pss.ps_nenvstr + 1) * sizeof(int32_t);
1861                 if (vptr % 4 != 0)
1862                         return (ENOEXEC);
1863                 for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
1864                         if (proc_readmem(td, p, ptr, &aux, sizeof(aux)) !=
1865                             sizeof(aux))
1866                                 return (ENOMEM);
1867                         if (aux.a_type == AT_NULL)
1868                                 break;
1869                         ptr += sizeof(aux);
1870                 }
1871                 if (aux.a_type != AT_NULL)
1872                         return (ENOEXEC);
1873                 vsize = i + 1;
1874                 size = vsize * sizeof(aux);
1875                 break;
1876         default:
1877                 KASSERT(0, ("Wrong proc vector type: %d", type));
1878                 return (EINVAL);
1879         }
1880         proc_vector32 = malloc(size, M_TEMP, M_WAITOK);
1881         if (proc_readmem(td, p, vptr, proc_vector32, size) != size) {
1882                 error = ENOMEM;
1883                 goto done;
1884         }
1885         if (type == PROC_AUX) {
1886                 *proc_vectorp = (char **)proc_vector32;
1887                 *vsizep = vsize;
1888                 return (0);
1889         }
1890         proc_vector = malloc(vsize * sizeof(char *), M_TEMP, M_WAITOK);
1891         for (i = 0; i < (int)vsize; i++)
1892                 proc_vector[i] = PTRIN(proc_vector32[i]);
1893         *proc_vectorp = proc_vector;
1894         *vsizep = vsize;
1895 done:
1896         free(proc_vector32, M_TEMP);
1897         return (error);
1898 }
1899 #endif
1900
1901 static int
1902 get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp,
1903     size_t *vsizep, enum proc_vector_type type)
1904 {
1905         struct ps_strings pss;
1906         Elf_Auxinfo aux;
1907         vm_offset_t vptr, ptr;
1908         char **proc_vector;
1909         size_t vsize, size;
1910         int i;
1911
1912 #ifdef COMPAT_FREEBSD32
1913         if (SV_PROC_FLAG(p, SV_ILP32) != 0)
1914                 return (get_proc_vector32(td, p, proc_vectorp, vsizep, type));
1915 #endif
1916         if (proc_readmem(td, p, (vm_offset_t)p->p_sysent->sv_psstrings, &pss,
1917             sizeof(pss)) != sizeof(pss))
1918                 return (ENOMEM);
1919         switch (type) {
1920         case PROC_ARG:
1921                 vptr = (vm_offset_t)pss.ps_argvstr;
1922                 vsize = pss.ps_nargvstr;
1923                 if (vsize > ARG_MAX)
1924                         return (ENOEXEC);
1925                 size = vsize * sizeof(char *);
1926                 break;
1927         case PROC_ENV:
1928                 vptr = (vm_offset_t)pss.ps_envstr;
1929                 vsize = pss.ps_nenvstr;
1930                 if (vsize > ARG_MAX)
1931                         return (ENOEXEC);
1932                 size = vsize * sizeof(char *);
1933                 break;
1934         case PROC_AUX:
1935                 /*
1936                  * The aux array is just above env array on the stack. Check
1937                  * that the address is naturally aligned.
1938                  */
1939                 vptr = (vm_offset_t)pss.ps_envstr + (pss.ps_nenvstr + 1)
1940                     * sizeof(char *);
1941 #if __ELF_WORD_SIZE == 64
1942                 if (vptr % sizeof(uint64_t) != 0)
1943 #else
1944                 if (vptr % sizeof(uint32_t) != 0)
1945 #endif
1946                         return (ENOEXEC);
1947                 /*
1948                  * We count the array size reading the aux vectors from the
1949                  * stack until AT_NULL vector is returned.  So (to keep the code
1950                  * simple) we read the process stack twice: the first time here
1951                  * to find the size and the second time when copying the vectors
1952                  * to the allocated proc_vector.
1953                  */
1954                 for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
1955                         if (proc_readmem(td, p, ptr, &aux, sizeof(aux)) !=
1956                             sizeof(aux))
1957                                 return (ENOMEM);
1958                         if (aux.a_type == AT_NULL)
1959                                 break;
1960                         ptr += sizeof(aux);
1961                 }
1962                 /*
1963                  * If the PROC_AUXV_MAX entries are iterated over, and we have
1964                  * not reached AT_NULL, it is most likely we are reading wrong
1965                  * data: either the process doesn't have auxv array or data has
1966                  * been modified. Return the error in this case.
1967                  */
1968                 if (aux.a_type != AT_NULL)
1969                         return (ENOEXEC);
1970                 vsize = i + 1;
1971                 size = vsize * sizeof(aux);
1972                 break;
1973         default:
1974                 KASSERT(0, ("Wrong proc vector type: %d", type));
1975                 return (EINVAL); /* In case we are built without INVARIANTS. */
1976         }
1977         proc_vector = malloc(size, M_TEMP, M_WAITOK);
1978         if (proc_readmem(td, p, vptr, proc_vector, size) != size) {
1979                 free(proc_vector, M_TEMP);
1980                 return (ENOMEM);
1981         }
1982         *proc_vectorp = proc_vector;
1983         *vsizep = vsize;
1984
1985         return (0);
1986 }
1987
1988 #define GET_PS_STRINGS_CHUNK_SZ 256     /* Chunk size (bytes) for ps_strings operations. */
1989
1990 static int
1991 get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb,
1992     enum proc_vector_type type)
1993 {
1994         size_t done, len, nchr, vsize;
1995         int error, i;
1996         char **proc_vector, *sptr;
1997         char pss_string[GET_PS_STRINGS_CHUNK_SZ];
1998
1999         PROC_ASSERT_HELD(p);
2000
2001         /*
2002          * We are not going to read more than 2 * (PATH_MAX + ARG_MAX) bytes.
2003          */
2004         nchr = 2 * (PATH_MAX + ARG_MAX);
2005
2006         error = get_proc_vector(td, p, &proc_vector, &vsize, type);
2007         if (error != 0)
2008                 return (error);
2009         for (done = 0, i = 0; i < (int)vsize && done < nchr; i++) {
2010                 /*
2011                  * The program may have scribbled into its argv array, e.g. to
2012                  * remove some arguments.  If that has happened, break out
2013                  * before trying to read from NULL.
2014                  */
2015                 if (proc_vector[i] == NULL)
2016                         break;
2017                 for (sptr = proc_vector[i]; ; sptr += GET_PS_STRINGS_CHUNK_SZ) {
2018                         error = proc_read_string(td, p, sptr, pss_string,
2019                             sizeof(pss_string));
2020                         if (error != 0)
2021                                 goto done;
2022                         len = strnlen(pss_string, GET_PS_STRINGS_CHUNK_SZ);
2023                         if (done + len >= nchr)
2024                                 len = nchr - done - 1;
2025                         sbuf_bcat(sb, pss_string, len);
2026                         if (len != GET_PS_STRINGS_CHUNK_SZ)
2027                                 break;
2028                         done += GET_PS_STRINGS_CHUNK_SZ;
2029                 }
2030                 sbuf_bcat(sb, "", 1);
2031                 done += len + 1;
2032         }
2033 done:
2034         free(proc_vector, M_TEMP);
2035         return (error);
2036 }
2037
2038 int
2039 proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb)
2040 {
2041
2042         return (get_ps_strings(curthread, p, sb, PROC_ARG));
2043 }
2044
2045 int
2046 proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb)
2047 {
2048
2049         return (get_ps_strings(curthread, p, sb, PROC_ENV));
2050 }
2051
2052 int
2053 proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb)
2054 {
2055         size_t vsize, size;
2056         char **auxv;
2057         int error;
2058
2059         error = get_proc_vector(td, p, &auxv, &vsize, PROC_AUX);
2060         if (error == 0) {
2061 #ifdef COMPAT_FREEBSD32
2062                 if (SV_PROC_FLAG(p, SV_ILP32) != 0)
2063                         size = vsize * sizeof(Elf32_Auxinfo);
2064                 else
2065 #endif
2066                         size = vsize * sizeof(Elf_Auxinfo);
2067                 if (sbuf_bcat(sb, auxv, size) != 0)
2068                         error = ENOMEM;
2069                 free(auxv, M_TEMP);
2070         }
2071         return (error);
2072 }
2073
2074 /*
2075  * This sysctl allows a process to retrieve the argument list or process
2076  * title for another process without groping around in the address space
2077  * of the other process.  It also allow a process to set its own "process
2078  * title to a string of its own choice.
2079  */
2080 static int
2081 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
2082 {
2083         int *name = (int *)arg1;
2084         u_int namelen = arg2;
2085         struct pargs *newpa, *pa;
2086         struct proc *p;
2087         struct sbuf sb;
2088         int flags, error = 0, error2;
2089         pid_t pid;
2090
2091         if (namelen != 1)
2092                 return (EINVAL);
2093
2094         p = curproc;
2095         pid = (pid_t)name[0];
2096         if (pid == -1) {
2097                 pid = p->p_pid;
2098         }
2099
2100         /*
2101          * If the query is for this process and it is single-threaded, there
2102          * is nobody to modify pargs, thus we can just read.
2103          */
2104         if (pid == p->p_pid && p->p_numthreads == 1 && req->newptr == NULL &&
2105             (pa = p->p_args) != NULL)
2106                 return (SYSCTL_OUT(req, pa->ar_args, pa->ar_length));
2107
2108         flags = PGET_CANSEE;
2109         if (req->newptr != NULL)
2110                 flags |= PGET_ISCURRENT;
2111         error = pget(pid, flags, &p);
2112         if (error)
2113                 return (error);
2114
2115         pa = p->p_args;
2116         if (pa != NULL) {
2117                 pargs_hold(pa);
2118                 PROC_UNLOCK(p);
2119                 error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length);
2120                 pargs_drop(pa);
2121         } else if ((p->p_flag & (P_WEXIT | P_SYSTEM)) == 0) {
2122                 _PHOLD(p);
2123                 PROC_UNLOCK(p);
2124                 sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
2125                 sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
2126                 error = proc_getargv(curthread, p, &sb);
2127                 error2 = sbuf_finish(&sb);
2128                 PRELE(p);
2129                 sbuf_delete(&sb);
2130                 if (error == 0 && error2 != 0)
2131                         error = error2;
2132         } else {
2133                 PROC_UNLOCK(p);
2134         }
2135         if (error != 0 || req->newptr == NULL)
2136                 return (error);
2137
2138         if (req->newlen > ps_arg_cache_limit - sizeof(struct pargs))
2139                 return (ENOMEM);
2140
2141         if (req->newlen == 0) {
2142                 /*
2143                  * Clear the argument pointer, so that we'll fetch arguments
2144                  * with proc_getargv() until further notice.
2145                  */
2146                 newpa = NULL;
2147         } else {
2148                 newpa = pargs_alloc(req->newlen);
2149                 error = SYSCTL_IN(req, newpa->ar_args, req->newlen);
2150                 if (error != 0) {
2151                         pargs_free(newpa);
2152                         return (error);
2153                 }
2154         }
2155         PROC_LOCK(p);
2156         pa = p->p_args;
2157         p->p_args = newpa;
2158         PROC_UNLOCK(p);
2159         pargs_drop(pa);
2160         return (0);
2161 }
2162
2163 /*
2164  * This sysctl allows a process to retrieve environment of another process.
2165  */
2166 static int
2167 sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS)
2168 {
2169         int *name = (int *)arg1;
2170         u_int namelen = arg2;
2171         struct proc *p;
2172         struct sbuf sb;
2173         int error, error2;
2174
2175         if (namelen != 1)
2176                 return (EINVAL);
2177
2178         error = pget((pid_t)name[0], PGET_WANTREAD, &p);
2179         if (error != 0)
2180                 return (error);
2181         if ((p->p_flag & P_SYSTEM) != 0) {
2182                 PRELE(p);
2183                 return (0);
2184         }
2185
2186         sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
2187         sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
2188         error = proc_getenvv(curthread, p, &sb);
2189         error2 = sbuf_finish(&sb);
2190         PRELE(p);
2191         sbuf_delete(&sb);
2192         return (error != 0 ? error : error2);
2193 }
2194
2195 /*
2196  * This sysctl allows a process to retrieve ELF auxiliary vector of
2197  * another process.
2198  */
2199 static int
2200 sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS)
2201 {
2202         int *name = (int *)arg1;
2203         u_int namelen = arg2;
2204         struct proc *p;
2205         struct sbuf sb;
2206         int error, error2;
2207
2208         if (namelen != 1)
2209                 return (EINVAL);
2210
2211         error = pget((pid_t)name[0], PGET_WANTREAD, &p);
2212         if (error != 0)
2213                 return (error);
2214         if ((p->p_flag & P_SYSTEM) != 0) {
2215                 PRELE(p);
2216                 return (0);
2217         }
2218         sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
2219         sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
2220         error = proc_getauxv(curthread, p, &sb);
2221         error2 = sbuf_finish(&sb);
2222         PRELE(p);
2223         sbuf_delete(&sb);
2224         return (error != 0 ? error : error2);
2225 }
2226
2227 /*
2228  * This sysctl allows a process to retrieve the path of the executable for
2229  * itself or another process.
2230  */
2231 static int
2232 sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
2233 {
2234         pid_t *pidp = (pid_t *)arg1;
2235         unsigned int arglen = arg2;
2236         struct proc *p;
2237         struct vnode *vp;
2238         char *retbuf, *freebuf;
2239         int error;
2240
2241         if (arglen != 1)
2242                 return (EINVAL);
2243         if (*pidp == -1) {      /* -1 means this process */
2244                 p = req->td->td_proc;
2245         } else {
2246                 error = pget(*pidp, PGET_CANSEE, &p);
2247                 if (error != 0)
2248                         return (error);
2249         }
2250
2251         vp = p->p_textvp;
2252         if (vp == NULL) {
2253                 if (*pidp != -1)
2254                         PROC_UNLOCK(p);
2255                 return (0);
2256         }
2257         vref(vp);
2258         if (*pidp != -1)
2259                 PROC_UNLOCK(p);
2260         error = vn_fullpath(vp, &retbuf, &freebuf);
2261         vrele(vp);
2262         if (error)
2263                 return (error);
2264         error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1);
2265         free(freebuf, M_TEMP);
2266         return (error);
2267 }
2268
2269 static int
2270 sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
2271 {
2272         struct proc *p;
2273         char *sv_name;
2274         int *name;
2275         int namelen;
2276         int error;
2277
2278         namelen = arg2;
2279         if (namelen != 1)
2280                 return (EINVAL);
2281
2282         name = (int *)arg1;
2283         error = pget((pid_t)name[0], PGET_CANSEE, &p);
2284         if (error != 0)
2285                 return (error);
2286         sv_name = p->p_sysent->sv_name;
2287         PROC_UNLOCK(p);
2288         return (sysctl_handle_string(oidp, sv_name, 0, req));
2289 }
2290
2291 #ifdef KINFO_OVMENTRY_SIZE
2292 CTASSERT(sizeof(struct kinfo_ovmentry) == KINFO_OVMENTRY_SIZE);
2293 #endif
2294
2295 #ifdef COMPAT_FREEBSD7
2296 static int
2297 sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS)
2298 {
2299         vm_map_entry_t entry, tmp_entry;
2300         unsigned int last_timestamp;
2301         char *fullpath, *freepath;
2302         struct kinfo_ovmentry *kve;
2303         struct vattr va;
2304         struct ucred *cred;
2305         int error, *name;
2306         struct vnode *vp;
2307         struct proc *p;
2308         vm_map_t map;
2309         struct vmspace *vm;
2310
2311         name = (int *)arg1;
2312         error = pget((pid_t)name[0], PGET_WANTREAD, &p);
2313         if (error != 0)
2314                 return (error);
2315         vm = vmspace_acquire_ref(p);
2316         if (vm == NULL) {
2317                 PRELE(p);
2318                 return (ESRCH);
2319         }
2320         kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK);
2321
2322         map = &vm->vm_map;
2323         vm_map_lock_read(map);
2324         VM_MAP_ENTRY_FOREACH(entry, map) {
2325                 vm_object_t obj, tobj, lobj;
2326                 vm_offset_t addr;
2327
2328                 if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
2329                         continue;
2330
2331                 bzero(kve, sizeof(*kve));
2332                 kve->kve_structsize = sizeof(*kve);
2333
2334                 kve->kve_private_resident = 0;
2335                 obj = entry->object.vm_object;
2336                 if (obj != NULL) {
2337                         VM_OBJECT_RLOCK(obj);
2338                         if (obj->shadow_count == 1)
2339                                 kve->kve_private_resident =
2340                                     obj->resident_page_count;
2341                 }
2342                 kve->kve_resident = 0;
2343                 addr = entry->start;
2344                 while (addr < entry->end) {
2345                         if (pmap_extract(map->pmap, addr))
2346                                 kve->kve_resident++;
2347                         addr += PAGE_SIZE;
2348                 }
2349
2350                 for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) {
2351                         if (tobj != obj) {
2352                                 VM_OBJECT_RLOCK(tobj);
2353                                 kve->kve_offset += tobj->backing_object_offset;
2354                         }
2355                         if (lobj != obj)
2356                                 VM_OBJECT_RUNLOCK(lobj);
2357                         lobj = tobj;
2358                 }
2359
2360                 kve->kve_start = (void*)entry->start;
2361                 kve->kve_end = (void*)entry->end;
2362                 kve->kve_offset += (off_t)entry->offset;
2363
2364                 if (entry->protection & VM_PROT_READ)
2365                         kve->kve_protection |= KVME_PROT_READ;
2366                 if (entry->protection & VM_PROT_WRITE)
2367                         kve->kve_protection |= KVME_PROT_WRITE;
2368                 if (entry->protection & VM_PROT_EXECUTE)
2369                         kve->kve_protection |= KVME_PROT_EXEC;
2370
2371                 if (entry->eflags & MAP_ENTRY_COW)
2372                         kve->kve_flags |= KVME_FLAG_COW;
2373                 if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
2374                         kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
2375                 if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
2376                         kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
2377
2378                 last_timestamp = map->timestamp;
2379                 vm_map_unlock_read(map);
2380
2381                 kve->kve_fileid = 0;
2382                 kve->kve_fsid = 0;
2383                 freepath = NULL;
2384                 fullpath = "";
2385                 if (lobj) {
2386                         kve->kve_type = vm_object_kvme_type(lobj, &vp);
2387                         if (kve->kve_type == KVME_TYPE_MGTDEVICE)
2388                                 kve->kve_type = KVME_TYPE_UNKNOWN;
2389                         if (vp != NULL)
2390                                 vref(vp);
2391                         if (lobj != obj)
2392                                 VM_OBJECT_RUNLOCK(lobj);
2393
2394                         kve->kve_ref_count = obj->ref_count;
2395                         kve->kve_shadow_count = obj->shadow_count;
2396                         VM_OBJECT_RUNLOCK(obj);
2397                         if (vp != NULL) {
2398                                 vn_fullpath(vp, &fullpath, &freepath);
2399                                 cred = curthread->td_ucred;
2400                                 vn_lock(vp, LK_SHARED | LK_RETRY);
2401                                 if (VOP_GETATTR(vp, &va, cred) == 0) {
2402                                         kve->kve_fileid = va.va_fileid;
2403                                         /* truncate */
2404                                         kve->kve_fsid = va.va_fsid;
2405                                 }
2406                                 vput(vp);
2407                         }
2408                 } else {
2409                         kve->kve_type = KVME_TYPE_NONE;
2410                         kve->kve_ref_count = 0;
2411                         kve->kve_shadow_count = 0;
2412                 }
2413
2414                 strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
2415                 if (freepath != NULL)
2416                         free(freepath, M_TEMP);
2417
2418                 error = SYSCTL_OUT(req, kve, sizeof(*kve));
2419                 vm_map_lock_read(map);
2420                 if (error)
2421                         break;
2422                 if (last_timestamp != map->timestamp) {
2423                         vm_map_lookup_entry(map, addr - 1, &tmp_entry);
2424                         entry = tmp_entry;
2425                 }
2426         }
2427         vm_map_unlock_read(map);
2428         vmspace_free(vm);
2429         PRELE(p);
2430         free(kve, M_TEMP);
2431         return (error);
2432 }
2433 #endif  /* COMPAT_FREEBSD7 */
2434
2435 #ifdef KINFO_VMENTRY_SIZE
2436 CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE);
2437 #endif
2438
2439 void
2440 kern_proc_vmmap_resident(vm_map_t map, vm_map_entry_t entry,
2441     int *resident_count, bool *super)
2442 {
2443         vm_object_t obj, tobj;
2444         vm_page_t m, m_adv;
2445         vm_offset_t addr;
2446         vm_paddr_t pa;
2447         vm_pindex_t pi, pi_adv, pindex;
2448
2449         *super = false;
2450         *resident_count = 0;
2451         if (vmmap_skip_res_cnt)
2452                 return;
2453
2454         pa = 0;
2455         obj = entry->object.vm_object;
2456         addr = entry->start;
2457         m_adv = NULL;
2458         pi = OFF_TO_IDX(entry->offset);
2459         for (; addr < entry->end; addr += IDX_TO_OFF(pi_adv), pi += pi_adv) {
2460                 if (m_adv != NULL) {
2461                         m = m_adv;
2462                 } else {
2463                         pi_adv = atop(entry->end - addr);
2464                         pindex = pi;
2465                         for (tobj = obj;; tobj = tobj->backing_object) {
2466                                 m = vm_page_find_least(tobj, pindex);
2467                                 if (m != NULL) {
2468                                         if (m->pindex == pindex)
2469                                                 break;
2470                                         if (pi_adv > m->pindex - pindex) {
2471                                                 pi_adv = m->pindex - pindex;
2472                                                 m_adv = m;
2473                                         }
2474                                 }
2475                                 if (tobj->backing_object == NULL)
2476                                         goto next;
2477                                 pindex += OFF_TO_IDX(tobj->
2478                                     backing_object_offset);
2479                         }
2480                 }
2481                 m_adv = NULL;
2482                 if (m->psind != 0 && addr + pagesizes[1] <= entry->end &&
2483                     (addr & (pagesizes[1] - 1)) == 0 &&
2484                     (pmap_mincore(map->pmap, addr, &pa) & MINCORE_SUPER) != 0) {
2485                         *super = true;
2486                         pi_adv = atop(pagesizes[1]);
2487                 } else {
2488                         /*
2489                          * We do not test the found page on validity.
2490                          * Either the page is busy and being paged in,
2491                          * or it was invalidated.  The first case
2492                          * should be counted as resident, the second
2493                          * is not so clear; we do account both.
2494                          */
2495                         pi_adv = 1;
2496                 }
2497                 *resident_count += pi_adv;
2498 next:;
2499         }
2500 }
2501
2502 /*
2503  * Must be called with the process locked and will return unlocked.
2504  */
2505 int
2506 kern_proc_vmmap_out(struct proc *p, struct sbuf *sb, ssize_t maxlen, int flags)
2507 {
2508         vm_map_entry_t entry, tmp_entry;
2509         struct vattr va;
2510         vm_map_t map;
2511         vm_object_t lobj, nobj, obj, tobj;
2512         char *fullpath, *freepath;
2513         struct kinfo_vmentry *kve;
2514         struct ucred *cred;
2515         struct vnode *vp;
2516         struct vmspace *vm;
2517         vm_offset_t addr;
2518         unsigned int last_timestamp;
2519         int error;
2520         bool guard, super;
2521
2522         PROC_LOCK_ASSERT(p, MA_OWNED);
2523
2524         _PHOLD(p);
2525         PROC_UNLOCK(p);
2526         vm = vmspace_acquire_ref(p);
2527         if (vm == NULL) {
2528                 PRELE(p);
2529                 return (ESRCH);
2530         }
2531         kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK | M_ZERO);
2532
2533         error = 0;
2534         map = &vm->vm_map;
2535         vm_map_lock_read(map);
2536         VM_MAP_ENTRY_FOREACH(entry, map) {
2537                 if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
2538                         continue;
2539
2540                 addr = entry->end;
2541                 bzero(kve, sizeof(*kve));
2542                 obj = entry->object.vm_object;
2543                 if (obj != NULL) {
2544                         if ((obj->flags & OBJ_ANON) != 0)
2545                                 kve->kve_obj = (uintptr_t)obj;
2546
2547                         for (tobj = obj; tobj != NULL;
2548                             tobj = tobj->backing_object) {
2549                                 VM_OBJECT_RLOCK(tobj);
2550                                 kve->kve_offset += tobj->backing_object_offset;
2551                                 lobj = tobj;
2552                         }
2553                         if (obj->backing_object == NULL)
2554                                 kve->kve_private_resident =
2555                                     obj->resident_page_count;
2556                         kern_proc_vmmap_resident(map, entry,
2557                             &kve->kve_resident, &super);
2558                         if (super)
2559                                 kve->kve_flags |= KVME_FLAG_SUPER;
2560                         for (tobj = obj; tobj != NULL; tobj = nobj) {
2561                                 nobj = tobj->backing_object;
2562                                 if (tobj != obj && tobj != lobj)
2563                                         VM_OBJECT_RUNLOCK(tobj);
2564                         }
2565                 } else {
2566                         lobj = NULL;
2567                 }
2568
2569                 kve->kve_start = entry->start;
2570                 kve->kve_end = entry->end;
2571                 kve->kve_offset += entry->offset;
2572
2573                 if (entry->protection & VM_PROT_READ)
2574                         kve->kve_protection |= KVME_PROT_READ;
2575                 if (entry->protection & VM_PROT_WRITE)
2576                         kve->kve_protection |= KVME_PROT_WRITE;
2577                 if (entry->protection & VM_PROT_EXECUTE)
2578                         kve->kve_protection |= KVME_PROT_EXEC;
2579
2580                 if (entry->eflags & MAP_ENTRY_COW)
2581                         kve->kve_flags |= KVME_FLAG_COW;
2582                 if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
2583                         kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
2584                 if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
2585                         kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
2586                 if (entry->eflags & MAP_ENTRY_GROWS_UP)
2587                         kve->kve_flags |= KVME_FLAG_GROWS_UP;
2588                 if (entry->eflags & MAP_ENTRY_GROWS_DOWN)
2589                         kve->kve_flags |= KVME_FLAG_GROWS_DOWN;
2590                 if (entry->eflags & MAP_ENTRY_USER_WIRED)
2591                         kve->kve_flags |= KVME_FLAG_USER_WIRED;
2592
2593                 guard = (entry->eflags & MAP_ENTRY_GUARD) != 0;
2594
2595                 last_timestamp = map->timestamp;
2596                 vm_map_unlock_read(map);
2597
2598                 freepath = NULL;
2599                 fullpath = "";
2600                 if (lobj != NULL) {
2601                         kve->kve_type = vm_object_kvme_type(lobj, &vp);
2602                         if (vp != NULL)
2603                                 vref(vp);
2604                         if (lobj != obj)
2605                                 VM_OBJECT_RUNLOCK(lobj);
2606
2607                         kve->kve_ref_count = obj->ref_count;
2608                         kve->kve_shadow_count = obj->shadow_count;
2609                         VM_OBJECT_RUNLOCK(obj);
2610                         if (vp != NULL) {
2611                                 vn_fullpath(vp, &fullpath, &freepath);
2612                                 kve->kve_vn_type = vntype_to_kinfo(vp->v_type);
2613                                 cred = curthread->td_ucred;
2614                                 vn_lock(vp, LK_SHARED | LK_RETRY);
2615                                 if (VOP_GETATTR(vp, &va, cred) == 0) {
2616                                         kve->kve_vn_fileid = va.va_fileid;
2617                                         kve->kve_vn_fsid = va.va_fsid;
2618                                         kve->kve_vn_fsid_freebsd11 =
2619                                             kve->kve_vn_fsid; /* truncate */
2620                                         kve->kve_vn_mode =
2621                                             MAKEIMODE(va.va_type, va.va_mode);
2622                                         kve->kve_vn_size = va.va_size;
2623                                         kve->kve_vn_rdev = va.va_rdev;
2624                                         kve->kve_vn_rdev_freebsd11 =
2625                                             kve->kve_vn_rdev; /* truncate */
2626                                         kve->kve_status = KF_ATTR_VALID;
2627                                 }
2628                                 vput(vp);
2629                         }
2630                 } else {
2631                         kve->kve_type = guard ? KVME_TYPE_GUARD :
2632                             KVME_TYPE_NONE;
2633                         kve->kve_ref_count = 0;
2634                         kve->kve_shadow_count = 0;
2635                 }
2636
2637                 strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
2638                 if (freepath != NULL)
2639                         free(freepath, M_TEMP);
2640
2641                 /* Pack record size down */
2642                 if ((flags & KERN_VMMAP_PACK_KINFO) != 0)
2643                         kve->kve_structsize =
2644                             offsetof(struct kinfo_vmentry, kve_path) +
2645                             strlen(kve->kve_path) + 1;
2646                 else
2647                         kve->kve_structsize = sizeof(*kve);
2648                 kve->kve_structsize = roundup(kve->kve_structsize,
2649                     sizeof(uint64_t));
2650
2651                 /* Halt filling and truncate rather than exceeding maxlen */
2652                 if (maxlen != -1 && maxlen < kve->kve_structsize) {
2653                         error = 0;
2654                         vm_map_lock_read(map);
2655                         break;
2656                 } else if (maxlen != -1)
2657                         maxlen -= kve->kve_structsize;
2658
2659                 if (sbuf_bcat(sb, kve, kve->kve_structsize) != 0)
2660                         error = ENOMEM;
2661                 vm_map_lock_read(map);
2662                 if (error != 0)
2663                         break;
2664                 if (last_timestamp != map->timestamp) {
2665                         vm_map_lookup_entry(map, addr - 1, &tmp_entry);
2666                         entry = tmp_entry;
2667                 }
2668         }
2669         vm_map_unlock_read(map);
2670         vmspace_free(vm);
2671         PRELE(p);
2672         free(kve, M_TEMP);
2673         return (error);
2674 }
2675
2676 static int
2677 sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
2678 {
2679         struct proc *p;
2680         struct sbuf sb;
2681         int error, error2, *name;
2682
2683         name = (int *)arg1;
2684         sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_vmentry), req);
2685         sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
2686         error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
2687         if (error != 0) {
2688                 sbuf_delete(&sb);
2689                 return (error);
2690         }
2691         error = kern_proc_vmmap_out(p, &sb, -1, KERN_VMMAP_PACK_KINFO);
2692         error2 = sbuf_finish(&sb);
2693         sbuf_delete(&sb);
2694         return (error != 0 ? error : error2);
2695 }
2696
2697 #if defined(STACK) || defined(DDB)
2698 static int
2699 sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS)
2700 {
2701         struct kinfo_kstack *kkstp;
2702         int error, i, *name, numthreads;
2703         lwpid_t *lwpidarray;
2704         struct thread *td;
2705         struct stack *st;
2706         struct sbuf sb;
2707         struct proc *p;
2708
2709         name = (int *)arg1;
2710         error = pget((pid_t)name[0], PGET_NOTINEXEC | PGET_WANTREAD, &p);
2711         if (error != 0)
2712                 return (error);
2713
2714         kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK);
2715         st = stack_create(M_WAITOK);
2716
2717         lwpidarray = NULL;
2718         PROC_LOCK(p);
2719         do {
2720                 if (lwpidarray != NULL) {
2721                         free(lwpidarray, M_TEMP);
2722                         lwpidarray = NULL;
2723                 }
2724                 numthreads = p->p_numthreads;
2725                 PROC_UNLOCK(p);
2726                 lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP,
2727                     M_WAITOK | M_ZERO);
2728                 PROC_LOCK(p);
2729         } while (numthreads < p->p_numthreads);
2730
2731         /*
2732          * XXXRW: During the below loop, execve(2) and countless other sorts
2733          * of changes could have taken place.  Should we check to see if the
2734          * vmspace has been replaced, or the like, in order to prevent
2735          * giving a snapshot that spans, say, execve(2), with some threads
2736          * before and some after?  Among other things, the credentials could
2737          * have changed, in which case the right to extract debug info might
2738          * no longer be assured.
2739          */
2740         i = 0;
2741         FOREACH_THREAD_IN_PROC(p, td) {
2742                 KASSERT(i < numthreads,
2743                     ("sysctl_kern_proc_kstack: numthreads"));
2744                 lwpidarray[i] = td->td_tid;
2745                 i++;
2746         }
2747         PROC_UNLOCK(p);
2748         numthreads = i;
2749         for (i = 0; i < numthreads; i++) {
2750                 td = tdfind(lwpidarray[i], p->p_pid);
2751                 if (td == NULL) {
2752                         continue;
2753                 }
2754                 bzero(kkstp, sizeof(*kkstp));
2755                 (void)sbuf_new(&sb, kkstp->kkst_trace,
2756                     sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN);
2757                 thread_lock(td);
2758                 kkstp->kkst_tid = td->td_tid;
2759                 if (TD_IS_SWAPPED(td))
2760                         kkstp->kkst_state = KKST_STATE_SWAPPED;
2761                 else if (stack_save_td(st, td) == 0)
2762                         kkstp->kkst_state = KKST_STATE_STACKOK;
2763                 else
2764                         kkstp->kkst_state = KKST_STATE_RUNNING;
2765                 thread_unlock(td);
2766                 PROC_UNLOCK(p);
2767                 stack_sbuf_print(&sb, st);
2768                 sbuf_finish(&sb);
2769                 sbuf_delete(&sb);
2770                 error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp));
2771                 if (error)
2772                         break;
2773         }
2774         PRELE(p);
2775         if (lwpidarray != NULL)
2776                 free(lwpidarray, M_TEMP);
2777         stack_destroy(st);
2778         free(kkstp, M_TEMP);
2779         return (error);
2780 }
2781 #endif
2782
2783 /*
2784  * This sysctl allows a process to retrieve the full list of groups from
2785  * itself or another process.
2786  */
2787 static int
2788 sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS)
2789 {
2790         pid_t *pidp = (pid_t *)arg1;
2791         unsigned int arglen = arg2;
2792         struct proc *p;
2793         struct ucred *cred;
2794         int error;
2795
2796         if (arglen != 1)
2797                 return (EINVAL);
2798         if (*pidp == -1) {      /* -1 means this process */
2799                 p = req->td->td_proc;
2800                 PROC_LOCK(p);
2801         } else {
2802                 error = pget(*pidp, PGET_CANSEE, &p);
2803                 if (error != 0)
2804                         return (error);
2805         }
2806
2807         cred = crhold(p->p_ucred);
2808         PROC_UNLOCK(p);
2809
2810         error = SYSCTL_OUT(req, cred->cr_groups,
2811             cred->cr_ngroups * sizeof(gid_t));
2812         crfree(cred);
2813         return (error);
2814 }
2815
2816 /*
2817  * This sysctl allows a process to retrieve or/and set the resource limit for
2818  * another process.
2819  */
2820 static int
2821 sysctl_kern_proc_rlimit(SYSCTL_HANDLER_ARGS)
2822 {
2823         int *name = (int *)arg1;
2824         u_int namelen = arg2;
2825         struct rlimit rlim;
2826         struct proc *p;
2827         u_int which;
2828         int flags, error;
2829
2830         if (namelen != 2)
2831                 return (EINVAL);
2832
2833         which = (u_int)name[1];
2834         if (which >= RLIM_NLIMITS)
2835                 return (EINVAL);
2836
2837         if (req->newptr != NULL && req->newlen != sizeof(rlim))
2838                 return (EINVAL);
2839
2840         flags = PGET_HOLD | PGET_NOTWEXIT;
2841         if (req->newptr != NULL)
2842                 flags |= PGET_CANDEBUG;
2843         else
2844                 flags |= PGET_CANSEE;
2845         error = pget((pid_t)name[0], flags, &p);
2846         if (error != 0)
2847                 return (error);
2848
2849         /*
2850          * Retrieve limit.
2851          */
2852         if (req->oldptr != NULL) {
2853                 PROC_LOCK(p);
2854                 lim_rlimit_proc(p, which, &rlim);
2855                 PROC_UNLOCK(p);
2856         }
2857         error = SYSCTL_OUT(req, &rlim, sizeof(rlim));
2858         if (error != 0)
2859                 goto errout;
2860
2861         /*
2862          * Set limit.
2863          */
2864         if (req->newptr != NULL) {
2865                 error = SYSCTL_IN(req, &rlim, sizeof(rlim));
2866                 if (error == 0)
2867                         error = kern_proc_setrlimit(curthread, p, which, &rlim);
2868         }
2869
2870 errout:
2871         PRELE(p);
2872         return (error);
2873 }
2874
2875 /*
2876  * This sysctl allows a process to retrieve ps_strings structure location of
2877  * another process.
2878  */
2879 static int
2880 sysctl_kern_proc_ps_strings(SYSCTL_HANDLER_ARGS)
2881 {
2882         int *name = (int *)arg1;
2883         u_int namelen = arg2;
2884         struct proc *p;
2885         vm_offset_t ps_strings;
2886         int error;
2887 #ifdef COMPAT_FREEBSD32
2888         uint32_t ps_strings32;
2889 #endif
2890
2891         if (namelen != 1)
2892                 return (EINVAL);
2893
2894         error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
2895         if (error != 0)
2896                 return (error);
2897 #ifdef COMPAT_FREEBSD32
2898         if ((req->flags & SCTL_MASK32) != 0) {
2899                 /*
2900                  * We return 0 if the 32 bit emulation request is for a 64 bit
2901                  * process.
2902                  */
2903                 ps_strings32 = SV_PROC_FLAG(p, SV_ILP32) != 0 ?
2904                     PTROUT(p->p_sysent->sv_psstrings) : 0;
2905                 PROC_UNLOCK(p);
2906                 error = SYSCTL_OUT(req, &ps_strings32, sizeof(ps_strings32));
2907                 return (error);
2908         }
2909 #endif
2910         ps_strings = p->p_sysent->sv_psstrings;
2911         PROC_UNLOCK(p);
2912         error = SYSCTL_OUT(req, &ps_strings, sizeof(ps_strings));
2913         return (error);
2914 }
2915
2916 /*
2917  * This sysctl allows a process to retrieve umask of another process.
2918  */
2919 static int
2920 sysctl_kern_proc_umask(SYSCTL_HANDLER_ARGS)
2921 {
2922         int *name = (int *)arg1;
2923         u_int namelen = arg2;
2924         struct proc *p;
2925         int error;
2926         u_short cmask;
2927         pid_t pid;
2928
2929         if (namelen != 1)
2930                 return (EINVAL);
2931
2932         pid = (pid_t)name[0];
2933         p = curproc;
2934         if (pid == p->p_pid || pid == 0) {
2935                 cmask = p->p_pd->pd_cmask;
2936                 goto out;
2937         }
2938
2939         error = pget(pid, PGET_WANTREAD, &p);
2940         if (error != 0)
2941                 return (error);
2942
2943         cmask = p->p_pd->pd_cmask;
2944         PRELE(p);
2945 out:
2946         error = SYSCTL_OUT(req, &cmask, sizeof(cmask));
2947         return (error);
2948 }
2949
2950 /*
2951  * This sysctl allows a process to set and retrieve binary osreldate of
2952  * another process.
2953  */
2954 static int
2955 sysctl_kern_proc_osrel(SYSCTL_HANDLER_ARGS)
2956 {
2957         int *name = (int *)arg1;
2958         u_int namelen = arg2;
2959         struct proc *p;
2960         int flags, error, osrel;
2961
2962         if (namelen != 1)
2963                 return (EINVAL);
2964
2965         if (req->newptr != NULL && req->newlen != sizeof(osrel))
2966                 return (EINVAL);
2967
2968         flags = PGET_HOLD | PGET_NOTWEXIT;
2969         if (req->newptr != NULL)
2970                 flags |= PGET_CANDEBUG;
2971         else
2972                 flags |= PGET_CANSEE;
2973         error = pget((pid_t)name[0], flags, &p);
2974         if (error != 0)
2975                 return (error);
2976
2977         error = SYSCTL_OUT(req, &p->p_osrel, sizeof(p->p_osrel));
2978         if (error != 0)
2979                 goto errout;
2980
2981         if (req->newptr != NULL) {
2982                 error = SYSCTL_IN(req, &osrel, sizeof(osrel));
2983                 if (error != 0)
2984                         goto errout;
2985                 if (osrel < 0) {
2986                         error = EINVAL;
2987                         goto errout;
2988                 }
2989                 p->p_osrel = osrel;
2990         }
2991 errout:
2992         PRELE(p);
2993         return (error);
2994 }
2995
2996 static int
2997 sysctl_kern_proc_sigtramp(SYSCTL_HANDLER_ARGS)
2998 {
2999         int *name = (int *)arg1;
3000         u_int namelen = arg2;
3001         struct proc *p;
3002         struct kinfo_sigtramp kst;
3003         const struct sysentvec *sv;
3004         int error;
3005 #ifdef COMPAT_FREEBSD32
3006         struct kinfo_sigtramp32 kst32;
3007 #endif
3008
3009         if (namelen != 1)
3010                 return (EINVAL);
3011
3012         error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
3013         if (error != 0)
3014                 return (error);
3015         sv = p->p_sysent;
3016 #ifdef COMPAT_FREEBSD32
3017         if ((req->flags & SCTL_MASK32) != 0) {
3018                 bzero(&kst32, sizeof(kst32));
3019                 if (SV_PROC_FLAG(p, SV_ILP32)) {
3020                         if (sv->sv_sigcode_base != 0) {
3021                                 kst32.ksigtramp_start = sv->sv_sigcode_base;
3022                                 kst32.ksigtramp_end = sv->sv_sigcode_base +
3023                                     *sv->sv_szsigcode;
3024                         } else {
3025                                 kst32.ksigtramp_start = sv->sv_psstrings -
3026                                     *sv->sv_szsigcode;
3027                                 kst32.ksigtramp_end = sv->sv_psstrings;
3028                         }
3029                 }
3030                 PROC_UNLOCK(p);
3031                 error = SYSCTL_OUT(req, &kst32, sizeof(kst32));
3032                 return (error);
3033         }
3034 #endif
3035         bzero(&kst, sizeof(kst));
3036         if (sv->sv_sigcode_base != 0) {
3037                 kst.ksigtramp_start = (char *)sv->sv_sigcode_base;
3038                 kst.ksigtramp_end = (char *)sv->sv_sigcode_base +
3039                     *sv->sv_szsigcode;
3040         } else {
3041                 kst.ksigtramp_start = (char *)sv->sv_psstrings -
3042                     *sv->sv_szsigcode;
3043                 kst.ksigtramp_end = (char *)sv->sv_psstrings;
3044         }
3045         PROC_UNLOCK(p);
3046         error = SYSCTL_OUT(req, &kst, sizeof(kst));
3047         return (error);
3048 }
3049
3050 static int
3051 sysctl_kern_proc_sigfastblk(SYSCTL_HANDLER_ARGS)
3052 {
3053         int *name = (int *)arg1;
3054         u_int namelen = arg2;
3055         pid_t pid;
3056         struct proc *p;
3057         struct thread *td1;
3058         uintptr_t addr;
3059 #ifdef COMPAT_FREEBSD32
3060         uint32_t addr32;
3061 #endif
3062         int error;
3063
3064         if (namelen != 1 || req->newptr != NULL)
3065                 return (EINVAL);
3066
3067         pid = (pid_t)name[0];
3068         error = pget(pid, PGET_HOLD | PGET_NOTWEXIT | PGET_CANDEBUG, &p);
3069         if (error != 0)
3070                 return (error);
3071
3072         PROC_LOCK(p);
3073 #ifdef COMPAT_FREEBSD32
3074         if (SV_CURPROC_FLAG(SV_ILP32)) {
3075                 if (!SV_PROC_FLAG(p, SV_ILP32)) {
3076                         error = EINVAL;
3077                         goto errlocked;
3078                 }
3079         }
3080 #endif
3081         if (pid <= PID_MAX) {
3082                 td1 = FIRST_THREAD_IN_PROC(p);
3083         } else {
3084                 FOREACH_THREAD_IN_PROC(p, td1) {
3085                         if (td1->td_tid == pid)
3086                                 break;
3087                 }
3088         }
3089         if (td1 == NULL) {
3090                 error = ESRCH;
3091                 goto errlocked;
3092         }
3093         /*
3094          * The access to the private thread flags.  It is fine as far
3095          * as no out-of-thin-air values are read from td_pflags, and
3096          * usermode read of the td_sigblock_ptr is racy inherently,
3097          * since target process might have already changed it
3098          * meantime.
3099          */
3100         if ((td1->td_pflags & TDP_SIGFASTBLOCK) != 0)
3101                 addr = (uintptr_t)td1->td_sigblock_ptr;
3102         else
3103                 error = ENOTTY;
3104
3105 errlocked:
3106         _PRELE(p);
3107         PROC_UNLOCK(p);
3108         if (error != 0)
3109                 return (error);
3110
3111 #ifdef COMPAT_FREEBSD32
3112         if (SV_CURPROC_FLAG(SV_ILP32)) {
3113                 addr32 = addr;
3114                 error = SYSCTL_OUT(req, &addr32, sizeof(addr32));
3115         } else
3116 #endif
3117                 error = SYSCTL_OUT(req, &addr, sizeof(addr));
3118         return (error);
3119 }
3120
3121 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE,  0,
3122     "Process table");
3123
3124 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT|
3125         CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc, "S,proc",
3126         "Return entire process table");
3127
3128 static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD | CTLFLAG_MPSAFE,
3129         sysctl_kern_proc, "Process table");
3130
3131 static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD | CTLFLAG_MPSAFE,
3132         sysctl_kern_proc, "Process table");
3133
3134 static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD | CTLFLAG_MPSAFE,
3135         sysctl_kern_proc, "Process table");
3136
3137 static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD |
3138         CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3139
3140 static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD | CTLFLAG_MPSAFE,
3141         sysctl_kern_proc, "Process table");
3142
3143 static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD | CTLFLAG_MPSAFE,
3144         sysctl_kern_proc, "Process table");
3145
3146 static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD | CTLFLAG_MPSAFE,
3147         sysctl_kern_proc, "Process table");
3148
3149 static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD | CTLFLAG_MPSAFE,
3150         sysctl_kern_proc, "Process table");
3151
3152 static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE,
3153         sysctl_kern_proc, "Return process table, no threads");
3154
3155 static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args,
3156         CTLFLAG_RW | CTLFLAG_CAPWR | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE,
3157         sysctl_kern_proc_args, "Process argument list");
3158
3159 static SYSCTL_NODE(_kern_proc, KERN_PROC_ENV, env, CTLFLAG_RD | CTLFLAG_MPSAFE,
3160         sysctl_kern_proc_env, "Process environment");
3161
3162 static SYSCTL_NODE(_kern_proc, KERN_PROC_AUXV, auxv, CTLFLAG_RD |
3163         CTLFLAG_MPSAFE, sysctl_kern_proc_auxv, "Process ELF auxiliary vector");
3164
3165 static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD |
3166         CTLFLAG_MPSAFE, sysctl_kern_proc_pathname, "Process executable path");
3167
3168 static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD |
3169         CTLFLAG_MPSAFE, sysctl_kern_proc_sv_name,
3170         "Process syscall vector name (ABI type)");
3171
3172 static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td,
3173         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3174
3175 static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td,
3176         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3177
3178 static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td,
3179         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3180
3181 static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD),
3182         sid_td, CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3183
3184 static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td,
3185         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3186
3187 static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td,
3188         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3189
3190 static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td,
3191         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3192
3193 static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td,
3194         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
3195
3196 static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td,
3197         CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc,
3198         "Return process table, including threads");
3199
3200 #ifdef COMPAT_FREEBSD7
3201 static SYSCTL_NODE(_kern_proc, KERN_PROC_OVMMAP, ovmmap, CTLFLAG_RD |
3202         CTLFLAG_MPSAFE, sysctl_kern_proc_ovmmap, "Old Process vm map entries");
3203 #endif
3204
3205 static SYSCTL_NODE(_kern_proc, KERN_PROC_VMMAP, vmmap, CTLFLAG_RD |
3206         CTLFLAG_MPSAFE, sysctl_kern_proc_vmmap, "Process vm map entries");
3207
3208 #if defined(STACK) || defined(DDB)
3209 static SYSCTL_NODE(_kern_proc, KERN_PROC_KSTACK, kstack, CTLFLAG_RD |
3210         CTLFLAG_MPSAFE, sysctl_kern_proc_kstack, "Process kernel stacks");
3211 #endif
3212
3213 static SYSCTL_NODE(_kern_proc, KERN_PROC_GROUPS, groups, CTLFLAG_RD |
3214         CTLFLAG_MPSAFE, sysctl_kern_proc_groups, "Process groups");
3215
3216 static SYSCTL_NODE(_kern_proc, KERN_PROC_RLIMIT, rlimit, CTLFLAG_RW |
3217         CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_rlimit,
3218         "Process resource limits");
3219
3220 static SYSCTL_NODE(_kern_proc, KERN_PROC_PS_STRINGS, ps_strings, CTLFLAG_RD |
3221         CTLFLAG_MPSAFE, sysctl_kern_proc_ps_strings,
3222         "Process ps_strings location");
3223
3224 static SYSCTL_NODE(_kern_proc, KERN_PROC_UMASK, umask, CTLFLAG_RD |
3225         CTLFLAG_MPSAFE, sysctl_kern_proc_umask, "Process umask");
3226
3227 static SYSCTL_NODE(_kern_proc, KERN_PROC_OSREL, osrel, CTLFLAG_RW |
3228         CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_osrel,
3229         "Process binary osreldate");
3230
3231 static SYSCTL_NODE(_kern_proc, KERN_PROC_SIGTRAMP, sigtramp, CTLFLAG_RD |
3232         CTLFLAG_MPSAFE, sysctl_kern_proc_sigtramp,
3233         "Process signal trampoline location");
3234
3235 static SYSCTL_NODE(_kern_proc, KERN_PROC_SIGFASTBLK, sigfastblk, CTLFLAG_RD |
3236         CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_sigfastblk,
3237         "Thread sigfastblock address");
3238
3239 int allproc_gen;
3240
3241 /*
3242  * stop_all_proc() purpose is to stop all process which have usermode,
3243  * except current process for obvious reasons.  This makes it somewhat
3244  * unreliable when invoked from multithreaded process.  The service
3245  * must not be user-callable anyway.
3246  */
3247 void
3248 stop_all_proc(void)
3249 {
3250         struct proc *cp, *p;
3251         int r, gen;
3252         bool restart, seen_stopped, seen_exiting, stopped_some;
3253
3254         cp = curproc;
3255 allproc_loop:
3256         sx_xlock(&allproc_lock);
3257         gen = allproc_gen;
3258         seen_exiting = seen_stopped = stopped_some = restart = false;
3259         LIST_REMOVE(cp, p_list);
3260         LIST_INSERT_HEAD(&allproc, cp, p_list);
3261         for (;;) {
3262                 p = LIST_NEXT(cp, p_list);
3263                 if (p == NULL)
3264                         break;
3265                 LIST_REMOVE(cp, p_list);
3266                 LIST_INSERT_AFTER(p, cp, p_list);
3267                 PROC_LOCK(p);
3268                 if ((p->p_flag & (P_KPROC | P_SYSTEM | P_TOTAL_STOP)) != 0) {
3269                         PROC_UNLOCK(p);
3270                         continue;
3271                 }
3272                 if ((p->p_flag & P_WEXIT) != 0) {
3273                         seen_exiting = true;
3274                         PROC_UNLOCK(p);
3275                         continue;
3276                 }
3277                 if (P_SHOULDSTOP(p) == P_STOPPED_SINGLE) {
3278                         /*
3279                          * Stopped processes are tolerated when there
3280                          * are no other processes which might continue
3281                          * them.  P_STOPPED_SINGLE but not
3282                          * P_TOTAL_STOP process still has at least one
3283                          * thread running.
3284                          */
3285                         seen_stopped = true;
3286                         PROC_UNLOCK(p);
3287                         continue;
3288                 }
3289                 sx_xunlock(&allproc_lock);
3290                 _PHOLD(p);
3291                 r = thread_single(p, SINGLE_ALLPROC);
3292                 if (r != 0)
3293                         restart = true;
3294                 else
3295                         stopped_some = true;
3296                 _PRELE(p);
3297                 PROC_UNLOCK(p);
3298                 sx_xlock(&allproc_lock);
3299         }
3300         /* Catch forked children we did not see in iteration. */
3301         if (gen != allproc_gen)
3302                 restart = true;
3303         sx_xunlock(&allproc_lock);
3304         if (restart || stopped_some || seen_exiting || seen_stopped) {
3305                 kern_yield(PRI_USER);
3306                 goto allproc_loop;
3307         }
3308 }
3309
3310 void
3311 resume_all_proc(void)
3312 {
3313         struct proc *cp, *p;
3314
3315         cp = curproc;
3316         sx_xlock(&allproc_lock);
3317 again:
3318         LIST_REMOVE(cp, p_list);
3319         LIST_INSERT_HEAD(&allproc, cp, p_list);
3320         for (;;) {
3321                 p = LIST_NEXT(cp, p_list);
3322                 if (p == NULL)
3323                         break;
3324                 LIST_REMOVE(cp, p_list);
3325                 LIST_INSERT_AFTER(p, cp, p_list);
3326                 PROC_LOCK(p);
3327                 if ((p->p_flag & P_TOTAL_STOP) != 0) {
3328                         sx_xunlock(&allproc_lock);
3329                         _PHOLD(p);
3330                         thread_single_end(p, SINGLE_ALLPROC);
3331                         _PRELE(p);
3332                         PROC_UNLOCK(p);
3333                         sx_xlock(&allproc_lock);
3334                 } else {
3335                         PROC_UNLOCK(p);
3336                 }
3337         }
3338         /*  Did the loop above missed any stopped process ? */
3339         FOREACH_PROC_IN_SYSTEM(p) {
3340                 /* No need for proc lock. */
3341                 if ((p->p_flag & P_TOTAL_STOP) != 0)
3342                         goto again;
3343         }
3344         sx_xunlock(&allproc_lock);
3345 }
3346
3347 /* #define      TOTAL_STOP_DEBUG        1 */
3348 #ifdef TOTAL_STOP_DEBUG
3349 volatile static int ap_resume;
3350 #include <sys/mount.h>
3351
3352 static int
3353 sysctl_debug_stop_all_proc(SYSCTL_HANDLER_ARGS)
3354 {
3355         int error, val;
3356
3357         val = 0;
3358         ap_resume = 0;
3359         error = sysctl_handle_int(oidp, &val, 0, req);
3360         if (error != 0 || req->newptr == NULL)
3361                 return (error);
3362         if (val != 0) {
3363                 stop_all_proc();
3364                 syncer_suspend();
3365                 while (ap_resume == 0)
3366                         ;
3367                 syncer_resume();
3368                 resume_all_proc();
3369         }
3370         return (0);
3371 }
3372
3373 SYSCTL_PROC(_debug, OID_AUTO, stop_all_proc, CTLTYPE_INT | CTLFLAG_RW |
3374     CTLFLAG_MPSAFE, __DEVOLATILE(int *, &ap_resume), 0,
3375     sysctl_debug_stop_all_proc, "I",
3376     "");
3377 #endif