usr/src/uts/common/sys/proc.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2018 Joyent, Inc.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #ifndef _SYS_PROC_H
  31 #define _SYS_PROC_H
  32
  33 #include <sys/time.h>
  34 #include <sys/thread.h>
  35 #include <sys/cred.h>
  36 #include <sys/user.h>
  37 #include <sys/watchpoint.h>
  38 #include <sys/timer.h>
  39 #if defined(__x86)
  40 #include <sys/tss.h>
  41 #include <sys/segments.h>
  42 #endif
  43 #include <sys/utrap.h>
  44 #include <sys/model.h>
  45 #include <sys/refstr.h>
  46 #include <sys/avl.h>
  47 #include <sys/rctl.h>
  48 #include <sys/list.h>
  49 #include <sys/avl.h>
  50 #include <sys/door_impl.h>
  51 #include <sys/signalfd.h>
  52 #include <sys/secflags.h>
  53
  54 #ifdef  __cplusplus
  55 extern "C" {
  56 #endif
  57
  58 /*
  59  * Profile arguments.
  60  */
  61 struct prof {
  62         void            *pr_base;       /* buffer base */
  63         uintptr_t       pr_off;         /* pc offset */
  64         size_t          pr_size;        /* buffer size */
  65         uint32_t        pr_scale;       /* pc scaling */
  66         long            pr_samples;     /* sample count */
  67 };
  68
  69 /*
  70  * An lwp directory entry.
  71  * If le_thread != NULL, this is an active lwp.
  72  * If le_thread == NULL, this is an unreaped zombie lwp.
  73  */
  74 typedef struct lwpent {
  75         kthread_t       *le_thread;     /* the active lwp, NULL if zombie */
  76         id_t            le_lwpid;       /* its lwpid (t->t_tid) */
  77         uint16_t        le_waiters;     /* total number of lwp_wait()ers */
  78         uint16_t        le_dwaiters;    /* number that are daemons */
  79         clock_t         le_start;       /* start time of this lwp */
  80         struct vnode    *le_trace;      /* pointer to /proc lwp vnode */
  81 } lwpent_t;
  82
  83 typedef struct pctxop {
  84         void    (*save_op)(void *);     /* function to invoke to save ctx */
  85         void    (*restore_op)(void *);  /* function to invoke to restore ctx */
  86         void    (*fork_op)(void *, void *); /* invoke to fork context */
  87         void    (*exit_op)(void *);     /* invoked during process exit */
  88         void    (*free_op)(void *, int); /* function which frees the context */
  89         void    *arg;                   /* argument to above functions */
  90         struct pctxop *next;            /* next pcontext ops */
  91 } pctxop_t;
  92
  93 /*
  94  * Elements of the lwp directory, p->p_lwpdir[].
  95  *
  96  * We allocate lwp directory entries separately from lwp directory
  97  * elements because the lwp directory must be allocated as an array.
  98  * The number of lwps can grow quite large and we want to keep the
  99  * size of the kmem_alloc()d directory as small as possible.
 100  *
 101  * If ld_entry == NULL, the entry is free and is on the free list,
 102  * p->p_lwpfree, linked through ld_next.  If ld_entry != NULL, the
 103  * entry is used and ld_next is the thread-id hash link pointer.
 104  */
 105 typedef struct lwpdir {
 106         struct lwpdir   *ld_next;       /* hash chain or free list */
 107         struct lwpent   *ld_entry;      /* lwp directory entry */
 108 } lwpdir_t;
 109
 110 /*
 111  * Element of the p_tidhash thread-id (lwpid) hash table.
 112  */
 113 typedef struct tidhash {
 114         kmutex_t        th_lock;
 115         lwpdir_t        *th_list;
 116 } tidhash_t;
 117
 118 /*
 119  * Retired tidhash hash tables.
 120  */
 121 typedef struct ret_tidhash {
 122         struct ret_tidhash      *rth_next;
 123         tidhash_t               *rth_tidhash;
 124         uint_t                  rth_tidhash_sz;
 125 } ret_tidhash_t;
 126
 127 struct pool;
 128 struct task;
 129 struct zone;
 130 struct brand;
 131 struct corectl_path;
 132 struct corectl_content;
 133
 134 /*
 135  * One structure allocated per active process.  It contains all
 136  * data needed about the process while the process may be swapped
 137  * out.  Other per-process data (user.h) is also inside the proc structure.
 138  * Lightweight-process data (lwp.h) and the kernel stack may be swapped out.
 139  */
 140 typedef struct  proc {
 141         /*
 142          * Fields requiring no explicit locking
 143          */
 144         struct  vnode *p_exec;          /* pointer to a.out vnode */
 145         struct  as *p_as;               /* process address space pointer */
 146         struct  plock *p_lockp;         /* ptr to proc struct's mutex lock */
 147         kmutex_t p_crlock;              /* lock for p_cred */
 148         struct  cred    *p_cred;        /* process credentials */
 149         /*
 150          * Fields protected by pidlock
 151          */
 152         int     p_swapcnt;              /* number of swapped out lwps */
 153         char    p_stat;                 /* status of process */
 154         char    p_wcode;                /* current wait code */
 155         ushort_t p_pidflag;             /* flags protected only by pidlock */
 156         int     p_wdata;                /* current wait return value */
 157         pid_t   p_ppid;                 /* process id of parent */
 158         struct  proc    *p_link;        /* forward link */
 159         struct  proc    *p_parent;      /* ptr to parent process */
 160         struct  proc    *p_child;       /* ptr to first child process */
 161         struct  proc    *p_sibling;     /* ptr to next sibling proc on chain */
 162         struct  proc    *p_psibling;    /* ptr to prev sibling proc on chain */
 163         struct  proc    *p_sibling_ns;  /* prt to siblings with new state */
 164         struct  proc    *p_child_ns;    /* prt to children with new state */
 165         struct  proc    *p_next;        /* active chain link next */
 166         struct  proc    *p_prev;        /* active chain link prev */
 167         struct  proc    *p_nextofkin;   /* gets accounting info at exit */
 168         struct  proc    *p_orphan;
 169         struct  proc    *p_nextorph;
 170         struct  proc    *p_pglink;      /* process group hash chain link next */
 171         struct  proc    *p_ppglink;     /* process group hash chain link prev */
 172         struct  sess    *p_sessp;       /* session information */
 173         struct  pid     *p_pidp;        /* process ID info */
 174         struct  pid     *p_pgidp;       /* process group ID info */
 175         /*
 176          * Fields protected by p_lock
 177          */
 178         kcondvar_t p_cv;                /* proc struct's condition variable */
 179         kcondvar_t p_flag_cv;
 180         kcondvar_t p_lwpexit;           /* waiting for some lwp to exit */
 181         kcondvar_t p_holdlwps;          /* process is waiting for its lwps */
 182                                         /* to to be held.  */
 183         uint_t  p_proc_flag;            /* /proc-related flags */
 184         uint_t  p_flag;                 /* protected while set. */
 185                                         /* flags defined below */
 186         clock_t p_utime;                /* user time, this process */
 187         clock_t p_stime;                /* system time, this process */
 188         clock_t p_cutime;               /* sum of children's user time */
 189         clock_t p_cstime;               /* sum of children's system time */
 190         avl_tree_t *p_segacct;          /* System V shared segment list */
 191         avl_tree_t *p_semacct;          /* System V semaphore undo list */
 192         caddr_t p_bssbase;              /* base addr of last bss below heap */
 193         caddr_t p_brkbase;              /* base addr of heap */
 194         size_t  p_brksize;              /* heap size in bytes */
 195         uint_t  p_brkpageszc;           /* preferred heap max page size code */
 196         /*
 197          * Per process signal stuff.
 198          */
 199         k_sigset_t p_sig;               /* signals pending to this process */
 200         k_sigset_t p_extsig;            /* signals sent from another contract */
 201         k_sigset_t p_ignore;            /* ignore when generated */
 202         k_sigset_t p_siginfo;           /* gets signal info with signal */
 203         void *p_sigfd;                  /* signalfd support state */
 204         struct sigqueue *p_sigqueue;    /* queued siginfo structures */
 205         struct sigqhdr *p_sigqhdr;      /* hdr to sigqueue structure pool */
 206         struct sigqhdr *p_signhdr;      /* hdr to signotify structure pool */
 207         uchar_t p_stopsig;              /* jobcontrol stop signal */
 208
 209         /*
 210          * Special per-process flag when set will fix misaligned memory
 211          * references.
 212          */
 213         char    p_fixalignment;
 214
 215         /*
 216          * Per process lwp and kernel thread stuff
 217          */
 218         id_t    p_lwpid;                /* most recently allocated lwpid */
 219         int     p_lwpcnt;               /* number of lwps in this process */
 220         int     p_lwprcnt;              /* number of not stopped lwps */
 221         int     p_lwpdaemon;            /* number of TP_DAEMON lwps */
 222         int     p_lwpwait;              /* number of lwps in lwp_wait() */
 223         int     p_lwpdwait;             /* number of daemons in lwp_wait() */
 224         int     p_zombcnt;              /* number of zombie lwps */
 225         kthread_t *p_tlist;             /* circular list of threads */
 226         lwpdir_t *p_lwpdir;             /* thread (lwp) directory */
 227         lwpdir_t *p_lwpfree;            /* p_lwpdir free list */
 228         tidhash_t *p_tidhash;           /* tid (lwpid) lookup hash table */
 229         uint_t  p_lwpdir_sz;            /* number of p_lwpdir[] entries */
 230         uint_t  p_tidhash_sz;           /* number of p_tidhash[] entries */
 231         ret_tidhash_t *p_ret_tidhash;   /* retired tidhash hash tables */
 232         uint64_t p_lgrpset;             /* unprotected hint of set of lgrps */
 233                                         /* on which process has threads */
 234         volatile lgrp_id_t  p_t1_lgrpid; /* main's thread lgroup id */
 235         volatile lgrp_id_t  p_tr_lgrpid; /* text replica's lgroup id */
 236 #if defined(_LP64)
 237         uintptr_t  p_lgrpres2;          /* reserved for lgrp migration */
 238 #endif
 239         /*
 240          * /proc (process filesystem) debugger interface stuff.
 241          */
 242         k_sigset_t p_sigmask;           /* mask of traced signals (/proc) */
 243         k_fltset_t p_fltmask;           /* mask of traced faults (/proc) */
 244         struct vnode *p_trace;          /* pointer to primary /proc vnode */
 245         struct vnode *p_plist;          /* list of /proc vnodes for process */
 246         kthread_t *p_agenttp;           /* thread ptr for /proc agent lwp */
 247         avl_tree_t p_warea;             /* list of watched areas */
 248         avl_tree_t p_wpage;             /* remembered watched pages (vfork) */
 249         watched_page_t *p_wprot;        /* pages that need to have prot set */
 250         int     p_mapcnt;               /* number of active pr_mappage()s */
 251         kmutex_t p_maplock;             /* lock for pr_mappage() */
 252         struct  proc  *p_rlink;         /* linked list for server */
 253         kcondvar_t p_srwchan_cv;
 254
 255         /*
 256          * Stack sizing and guard information.
 257          * Generally protected by as_rangelock()
 258          */
 259         size_t          p_stksize;      /* process stack size in bytes */
 260         uint_t          p_stkpageszc;   /* preferred stack max page size code */
 261         uintptr_t       p_stkg_start;   /* start of stack guard */
 262         uintptr_t       p_stkg_end;     /* end of stack guard */
 263
 264         /*
 265          * Microstate accounting, resource usage, and real-time profiling
 266          */
 267         hrtime_t p_mstart;              /* hi-res process start time */
 268         hrtime_t p_mterm;               /* hi-res process termination time */
 269         hrtime_t p_mlreal;              /* elapsed time sum over defunct lwps */
 270         hrtime_t p_acct[NMSTATES];      /* microstate sum over defunct lwps */
 271         hrtime_t p_cacct[NMSTATES];     /* microstate sum over child procs */
 272         struct lrusage p_ru;            /* lrusage sum over defunct lwps */
 273         struct lrusage p_cru;           /* lrusage sum over child procs */
 274         struct itimerval p_rprof_timer; /* ITIMER_REALPROF interval timer */
 275         uintptr_t p_rprof_cyclic;       /* ITIMER_REALPROF cyclic */
 276         uint_t  p_defunct;              /* number of defunct lwps */
 277         /*
 278          * profiling. A lock is used in the event of multiple lwp's
 279          * using the same profiling base/size.
 280          */
 281         kmutex_t p_pflock;              /* protects user profile arguments */
 282         struct prof p_prof;             /* profile arguments */
 283
 284         /*
 285          * Doors.
 286          */
 287         door_pool_t             p_server_threads; /* common thread pool */
 288         struct door_node        *p_door_list;   /* active doors */
 289         struct door_node        *p_unref_list;
 290         kcondvar_t              p_unref_cv;
 291         char                    p_unref_thread; /* unref thread created */
 292
 293         /*
 294          * Kernel probes
 295          */
 296         uchar_t                 p_tnf_flags;
 297
 298         /*
 299          * Solaris Audit
 300          */
 301         struct p_audit_data     *p_audit_data; /* per process audit structure */
 302
 303         pctxop_t        *p_pctx;
 304
 305 #if defined(__x86)
 306         /*
 307          * LDT support.
 308          */
 309         kmutex_t        p_ldtlock;      /* protects the following fields */
 310         user_desc_t     *p_ldt;         /* Pointer to private LDT */
 311         uint64_t        p_unused1;      /* no longer used */
 312         uint64_t        p_unused2;      /* no longer used */
 313         ushort_t        p_ldtlimit;     /* highest selector used */
 314 #endif
 315         size_t p_swrss;                 /* resident set size before last swap */
 316         struct aio      *p_aio;         /* pointer to async I/O struct */
 317         struct itimer   **p_itimer;     /* interval timers */
 318         timeout_id_t    p_alarmid;      /* alarm's timeout id */
 319         caddr_t         p_usrstack;     /* top of the process stack */
 320         uint_t          p_stkprot;      /* stack memory protection */
 321         uint_t          p_datprot;      /* data memory protection */
 322         model_t         p_model;        /* data model determined at exec time */
 323         struct lwpchan_data *p_lcp;     /* lwpchan cache */
 324         kmutex_t        p_lcp_lock;     /* protects assignments to p_lcp */
 325         utrap_handler_t *p_utraps;      /* pointer to user trap handlers */
 326         struct corectl_path     *p_corefile;    /* pattern for core file */
 327         struct task     *p_task;        /* our containing task */
 328         struct proc     *p_taskprev;    /* ptr to previous process in task */
 329         struct proc     *p_tasknext;    /* ptr to next process in task */
 330         kmutex_t        p_sc_lock;      /* protects p_pagep */
 331         struct sc_page_ctl *p_pagep;    /* list of process's shared pages */
 332         struct rctl_set *p_rctls;       /* resource controls for this process */
 333         rlim64_t        p_stk_ctl;      /* currently enforced stack size */
 334         rlim64_t        p_fsz_ctl;      /* currently enforced file size */
 335         rlim64_t        p_vmem_ctl;     /* currently enforced addr-space size */
 336         rlim64_t        p_fno_ctl;      /* currently enforced file-desc limit */
 337         pid_t           p_ancpid;       /* ancestor pid, used by exacct */
 338         struct itimerval p_realitimer;  /* real interval timer */
 339         timeout_id_t    p_itimerid;     /* real interval timer's timeout id */
 340         struct corectl_content *p_content;      /* content of core file */
 341
 342         avl_tree_t      p_ct_held;      /* held contracts */
 343         struct ct_equeue **p_ct_equeue; /* process-type event queues */
 344
 345         struct cont_process *p_ct_process; /* process contract */
 346         list_node_t     p_ct_member;    /* process contract membership */
 347         sigqueue_t      *p_killsqp;     /* sigqueue pointer for SIGKILL */
 348
 349         int             p_dtrace_probes; /* are there probes for this proc? */
 350         uint64_t        p_dtrace_count; /* number of DTrace tracepoints */
 351                                         /* (protected by P_PR_LOCK) */
 352         void            *p_dtrace_helpers; /* DTrace helpers, if any */
 353         struct pool     *p_pool;        /* pointer to containing pool */
 354         kcondvar_t      p_poolcv;       /* synchronization with pools */
 355         uint_t          p_poolcnt;      /* # threads inside pool barrier */
 356         uint_t          p_poolflag;     /* pool-related flags (see below) */
 357         uintptr_t       p_portcnt;      /* event ports counter */
 358         struct zone     *p_zone;        /* zone in which process lives */
 359         struct vnode    *p_execdir;     /* directory that p_exec came from */
 360         struct brand    *p_brand;       /* process's brand  */
 361         void            *p_brand_data;  /* per-process brand state */
 362         psecflags_t     p_secflags;     /* per-process security flags */
 363
 364         /* additional lock to protect p_sessp (but not its contents) */
 365         kmutex_t p_splock;
 366         rctl_qty_t      p_locked_mem;   /* locked memory charged to proc */
 367                                         /* protected by p_lock */
 368         rctl_qty_t      p_crypto_mem;   /* /dev/crypto memory charged to proc */
 369                                         /* protected by p_lock */
 370         clock_t p_ttime;                /* buffered task time */
 371
 372         /*
 373          * The user structure
 374          */
 375         struct user p_user;             /* (see sys/user.h) */
 376 } proc_t;
 377
 378 #define PROC_T                          /* headers relying on proc_t are OK */
 379
 380 #ifdef _KERNEL
 381
 382 /* active process chain */
 383
 384 extern proc_t *practive;
 385
 386 /* Well known processes */
 387
 388 extern proc_t *proc_sched;              /* memory scheduler */
 389 extern proc_t *proc_init;               /* init */
 390 extern proc_t *proc_pageout;            /* pageout daemon */
 391 extern proc_t *proc_fsflush;            /* filesystem sync-er */
 392
 393 #endif /* _KERNEL */
 394
 395 /*
 396  * Stuff to keep track of the number of processes each uid has.
 397  * It is tracked on a per-zone basis; that is, if users in different
 398  * zones have the same uid, they are tracked separately.
 399  *
 400  * A structure is allocated when a new <uid,zoneid> pair shows up
 401  * There is a hash to find each structure.
 402  */
 403 struct  upcount {
 404         struct  upcount *up_next;
 405         uid_t           up_uid;
 406         zoneid_t        up_zoneid;
 407         uint_t          up_count;
 408 };
 409
 410 /* process ID info */
 411
 412 struct pid {
 413         unsigned int pid_prinactive :1;
 414         unsigned int pid_pgorphaned :1;
 415         unsigned int pid_padding :6;    /* used to be pid_ref, now an int */
 416         unsigned int pid_prslot :24;
 417         pid_t pid_id;
 418         struct proc *pid_pglink;
 419         struct proc *pid_pgtail;
 420         struct pid *pid_link;
 421         uint_t pid_ref;
 422 };
 423
 424 #define p_pgrp p_pgidp->pid_id
 425 #define p_pid  p_pidp->pid_id
 426 #define p_slot p_pidp->pid_prslot
 427 #define p_detached p_pgidp->pid_pgorphaned
 428
 429 #define PID_HOLD(pidp)  ASSERT(MUTEX_HELD(&pidlock)); \
 430                         ++(pidp)->pid_ref;
 431 #define PID_RELE(pidp)  ASSERT(MUTEX_HELD(&pidlock)); \
 432                         (pidp)->pid_ref > 1 ? \
 433                                 --(pidp)->pid_ref : pid_rele(pidp);
 434
 435 /*
 436  * Structure containing persistent process lock.  The structure and
 437  * macro allow "mutex_enter(&p->p_lock)" to continue working.
 438  */
 439 struct plock {
 440         kmutex_t pl_lock;
 441 };
 442 #define p_lock  p_lockp->pl_lock
 443
 444 #ifdef _KERNEL
 445 extern proc_t p0;               /* process 0 */
 446 extern struct plock p0lock;     /* p0's plock */
 447 extern struct pid pid0;         /* p0's pid */
 448
 449 /* pid_allocate() flags */
 450 #define PID_ALLOC_PROC  0x0001  /* assign a /proc slot as well */
 451
 452 #endif /* _KERNEL */
 453
 454 /* stat codes */
 455
 456 #define SSLEEP  1               /* awaiting an event */
 457 #define SRUN    2               /* runnable */
 458 #define SZOMB   3               /* process terminated but not waited for */
 459 #define SSTOP   4               /* process stopped by debugger */
 460 #define SIDL    5               /* intermediate state in process creation */
 461 #define SONPROC 6               /* process is being run on a processor */
 462 #define SWAIT   7               /* process is waiting to become runnable */
 463
 464 /* p_pidflag codes */
 465 #define CLDPEND         0x0001  /* have yet to post a SIGCHLD to the parent */
 466 #define CLDCONT         0x0002  /* child has notified parent of CLD_CONTINUED */
 467 #define CLDNOSIGCHLD    0x0004  /* do not post SIGCHLD when child terminates */
 468 #define CLDWAITPID      0x0008  /* only waitid(P_PID, pid) can reap the child */
 469
 470 /* p_proc_flag codes -- these flags are mostly private to /proc */
 471 #define P_PR_TRACE      0x0001  /* signal, fault or syscall tracing via /proc */
 472 #define P_PR_PTRACE     0x0002  /* ptrace() compatibility mode */
 473 #define P_PR_FORK       0x0004  /* child inherits tracing flags */
 474 #define P_PR_LOCK       0x0008  /* process locked by /proc */
 475 #define P_PR_ASYNC      0x0010  /* asynchronous stopping via /proc */
 476 #define P_PR_EXEC       0x0020  /* process is in exec() */
 477 #define P_PR_BPTADJ     0x0040  /* adjust pc on breakpoint trap */
 478 #define P_PR_RUNLCL     0x0080  /* set process running on last /proc close */
 479 #define P_PR_KILLCL     0x0100  /* kill process on last /proc close */
 480
 481 /*
 482  * p_flag codes
 483  *
 484  * note that two of these flags, SMSACCT and SSYS, are exported to /proc's
 485  * psinfo_t.p_flag field.  Historically, all were, but since they are
 486  * implementation dependant, we only export the ones people have come to
 487  * rely upon.  Hence, the bit positions of SSYS and SMSACCT should not be
 488  * altered.
 489  */
 490 #define SSYS       0x00000001   /* system (resident) process */
 491 #define SEXITING   0x00000002   /* process is exiting */
 492 #define SITBUSY    0x00000004   /* setitimer(ITIMER_REAL) in progress */
 493 #define SFORKING   0x00000008   /* tells called functions that we're forking */
 494 #define SWATCHOK   0x00000010   /* proc in acceptable state for watchpoints */
 495 #define SKILLED    0x00000100   /* SIGKILL has been posted to the process */
 496 #define SSCONT     0x00000200   /* SIGCONT has been posted to the process */
 497 #define SZONETOP   0x00000400   /* process has no valid PPID in its zone */
 498 #define SEXTKILLED 0x00000800   /* SKILLED is from another contract */
 499 #define SUGID      0x00002000   /* process was result of set[ug]id exec */
 500 #define SEXECED    0x00004000   /* this process has execed */
 501 #define SJCTL      0x00010000   /* SIGCHLD sent when children stop/continue */
 502 #define SNOWAIT    0x00020000   /* children never become zombies */
 503 #define SVFORK     0x00040000   /* child of vfork that has not yet exec'd */
 504 #define SVFWAIT    0x00080000   /* parent of vfork waiting for child to exec */
 505 #define SEXITLWPS  0x00100000   /* have lwps exit within the process */
 506 #define SHOLDFORK  0x00200000   /* hold lwps where they're cloneable */
 507 #define SHOLDFORK1 0x00800000   /* hold lwps in place (not cloning) */
 508 #define SCOREDUMP  0x01000000   /* process is dumping core */
 509 #define SMSACCT    0x02000000   /* process is keeping micro-state accounting */
 510 #define SLWPWRAP   0x04000000   /* process has wrapped its lwp ids */
 511 #define SAUTOLPG   0x08000000   /* kernel controls page sizes */
 512 #define SNOCD      0x10000000   /* new creds from VSxID, do not coredump */
 513 #define SHOLDWATCH 0x20000000   /* hold lwps for watchpoint operation */
 514 #define SMSFORK    0x40000000   /* child inherits micro-state accounting */
 515 #define SDOCORE    0x80000000   /* process will attempt to dump core */
 516
 517 /*
 518  * p_poolflag codes
 519  *
 520  * These flags are used to synchronize with the pool subsystem to allow
 521  * re-binding of processes to new pools.
 522  */
 523 #define PBWAIT          0x0001  /* process should wait outside fork/exec/exit */
 524 #define PEXITED         0x0002  /* process exited and about to become zombie */
 525
 526 /* Macro to convert proc pointer to a user block pointer */
 527 #define PTOU(p)         (&(p)->p_user)
 528
 529 #define tracing(p, sig) (sigismember(&(p)->p_sigmask, sig))
 530
 531 /* Macro to reduce unnecessary calls to issig() */
 532
 533 #define ISSIG(t, why)   ISSIG_FAST(t, ttolwp(t), ttoproc(t), why)
 534
 535 /*
 536  * Fast version of ISSIG.
 537  *      1. uses register pointers to lwp and proc instead of reloading them.
 538  *      2. uses bit-wise OR of tests, since the usual case is that none of them
 539  *         are true, this saves orcc's and branches.
 540  *      3. load the signal flags instead of using sigisempty() macro which does
 541  *         a branch to convert to boolean.
 542  */
 543 #define ISSIG_FAST(t, lwp, p, why)              \
 544         (ISSIG_PENDING(t, lwp, p) && issig(why))
 545
 546 #define ISSIG_PENDING(t, lwp, p)                \
 547         ((lwp)->lwp_cursig |                    \
 548             sigcheck((p), (t)) |                \
 549             (p)->p_stopsig |                    \
 550             (t)->t_dtrace_stop |                \
 551             (t)->t_dtrace_sig |                 \
 552             ((t)->t_proc_flag & (TP_PRSTOP|TP_HOLDLWP|TP_CHKPT|TP_PAUSE)) | \
 553             ((p)->p_flag & (SEXITLWPS|SKILLED|SHOLDFORK1|SHOLDWATCH)))
 554
 555 #define ISSTOP(sig)      (u.u_signal[sig-1] == SIG_DFL && \
 556                                 sigismember(&stopdefault, sig))
 557
 558 #define ISHOLD(p)       ((p)->p_flag & SHOLDFORK)
 559
 560 #define MUSTRETURN(p, t)        (ISHOLD(p) | (t)->t_activefd.a_stale)
 561
 562 /*
 563  * Determine if there are any watchpoints active in the process.
 564  */
 565 #define pr_watch_active(p)      (avl_numnodes(&(p)->p_warea) != 0)
 566
 567 /* Reasons for calling issig() */
 568
 569 #define FORREAL         0       /* Usual side-effects */
 570 #define JUSTLOOKING     1       /* Don't stop the process */
 571
 572 /* 'what' values for stop(PR_SUSPENDED, what) */
 573 #define SUSPEND_NORMAL  0
 574 #define SUSPEND_PAUSE   1
 575
 576 /* pseudo-flag to lwp_create() */
 577 #define NOCLASS (-1)
 578
 579 /* unused scheduling class ID */
 580 #define CLASS_UNUSED    (-2)
 581
 582 /* LWP stats updated via lwp_stats_update() */
 583 typedef enum {
 584         LWP_STAT_INBLK,
 585         LWP_STAT_OUBLK,
 586         LWP_STAT_MSGRCV,
 587         LWP_STAT_MSGSND
 588 } lwp_stat_id_t;
 589
 590 typedef struct prkillinfo {
 591         int32_t prk_error;              /* errno */
 592         int32_t prk_pad;                /* pad */
 593         siginfo_t prk_info;             /* siginfo of killing signal */
 594 } prkillinfo_t;
 595
 596 #ifdef _KERNEL
 597
 598 /* user profiling functions */
 599
 600 extern void profil_tick(uintptr_t);
 601
 602 /* process management functions */
 603
 604 extern int newproc(void (*)(), caddr_t, id_t, int, struct contract **, pid_t);
 605 extern void vfwait(pid_t);
 606 extern void proc_detach(proc_t *);
 607 extern void freeproc(proc_t *);
 608 extern void setrun(kthread_t *);
 609 extern void setrun_locked(kthread_t *);
 610 extern void exit(int, int);
 611 extern int proc_exit(int, int);
 612 extern void proc_is_exiting(proc_t *);
 613 extern void relvm(void);
 614 extern void add_ns(proc_t *, proc_t *);
 615 extern void delete_ns(proc_t *, proc_t *);
 616 extern void upcount_inc(uid_t, zoneid_t);
 617 extern void upcount_dec(uid_t, zoneid_t);
 618 extern int upcount_get(uid_t, zoneid_t);
 619 #if defined(__x86)
 620 extern selector_t setup_thrptr(proc_t *, uintptr_t);
 621 extern void deferred_singlestep_trap(caddr_t);
 622 #endif
 623
 624 extern void sigcld(proc_t *, sigqueue_t *);
 625 extern void sigcld_delete(k_siginfo_t *);
 626 extern void sigcld_repost(void);
 627 extern int fsig(k_sigset_t *, kthread_t *);
 628 extern void psig(void);
 629 extern void stop(int, int);
 630 extern int stop_on_fault(uint_t, k_siginfo_t *);
 631 extern int issig(int);
 632 extern int jobstopped(proc_t *);
 633 extern void psignal(proc_t *, int);
 634 extern void tsignal(kthread_t *, int);
 635 extern void sigtoproc(proc_t *, kthread_t *, int);
 636 extern void trapsig(k_siginfo_t *, int);
 637 extern void realsigprof(int, int, int);
 638 extern int eat_signal(kthread_t *, int);
 639 extern int signal_is_blocked(kthread_t *, int);
 640 extern int sigcheck(proc_t *, kthread_t *);
 641 extern void sigdefault(proc_t *);
 642
 643 extern void pid_setmin(void);
 644 extern pid_t pid_allocate(proc_t *, pid_t, int);
 645 extern int pid_rele(struct pid *);
 646 extern void pid_exit(proc_t *, struct task *);
 647 extern void proc_entry_free(struct pid *);
 648 extern proc_t *prfind(pid_t);
 649 extern proc_t *prfind_zone(pid_t, zoneid_t);
 650 extern proc_t *pgfind(pid_t);
 651 extern proc_t *pgfind_zone(pid_t, zoneid_t);
 652 extern proc_t *sprlock(pid_t);
 653 extern proc_t *sprlock_zone(pid_t, zoneid_t);
 654 extern int sprtrylock_proc(proc_t *);
 655 extern void sprwaitlock_proc(proc_t *);
 656 extern void sprlock_proc(proc_t *);
 657 extern void sprunlock(proc_t *);
 658 extern void pid_init(void);
 659 extern proc_t *pid_entry(int);
 660 extern int pid_slot(proc_t *);
 661 extern void signal(pid_t, int);
 662 extern void prsignal(struct pid *, int);
 663 extern int uread(proc_t *, void *, size_t, uintptr_t);
 664 extern int uwrite(proc_t *, void *, size_t, uintptr_t);
 665
 666 extern void pgsignal(struct pid *, int);
 667 extern void pgjoin(proc_t *, struct pid *);
 668 extern void pgcreate(proc_t *);
 669 extern void pgexit(proc_t *);
 670 extern void pgdetach(proc_t *);
 671 extern int pgmembers(pid_t);
 672
 673 extern  void    init_mstate(kthread_t *, int);
 674 extern  int     new_mstate(kthread_t *, int);
 675 extern  void    restore_mstate(kthread_t *);
 676 extern  void    term_mstate(kthread_t *);
 677 extern  void    estimate_msacct(kthread_t *, hrtime_t);
 678 extern  void    disable_msacct(proc_t *);
 679 extern  hrtime_t mstate_aggr_state(proc_t *, int);
 680 extern  hrtime_t mstate_thread_onproc_time(kthread_t *);
 681 extern  void    mstate_systhread_times(kthread_t *, hrtime_t *, hrtime_t *);
 682 extern  void    syscall_mstate(int, int);
 683
 684 extern  uint_t  cpu_update_pct(kthread_t *, hrtime_t);
 685
 686 extern void     set_proc_pre_sys(proc_t *p);
 687 extern void     set_proc_post_sys(proc_t *p);
 688 extern void     set_proc_sys(proc_t *p);
 689 extern void     set_proc_ast(proc_t *p);
 690 extern void     set_all_proc_sys(void);
 691 extern void     set_all_zone_usr_proc_sys(zoneid_t);
 692
 693 /* thread function prototypes */
 694
 695 extern  kthread_t       *thread_create(
 696         caddr_t         stk,
 697         size_t          stksize,
 698         void            (*proc)(),
 699         void            *arg,
 700         size_t          len,
 701         proc_t          *pp,
 702         int             state,
 703         pri_t           pri);
 704 extern  void    thread_exit(void) __NORETURN;
 705 extern  void    thread_free(kthread_t *);
 706 extern  void    thread_rele(kthread_t *);
 707 extern  void    thread_join(kt_did_t);
 708 extern  int     reaper(void);
 709 extern  void    installctx(kthread_t *, void *, void (*)(), void (*)(),
 710     void (*)(), void (*)(), void (*)(), void (*)());
 711 extern  int     removectx(kthread_t *, void *, void (*)(), void (*)(),
 712     void (*)(), void (*)(), void (*)(), void (*)());
 713 extern  void    savectx(kthread_t *);
 714 extern  void    restorectx(kthread_t *);
 715 extern  void    forkctx(kthread_t *, kthread_t *);
 716 extern  void    lwp_createctx(kthread_t *, kthread_t *);
 717 extern  void    exitctx(kthread_t *);
 718 extern  void    freectx(kthread_t *, int);
 719 extern  void    installpctx(proc_t *, void *, void (*)(), void (*)(),
 720     void (*)(), void (*)(), void (*)());
 721 extern  int     removepctx(proc_t *, void *, void (*)(), void (*)(),
 722     void (*)(), void (*)(), void (*)());
 723 extern  void    savepctx(proc_t *);
 724 extern  void    restorepctx(proc_t *);
 725 extern  void    forkpctx(proc_t *, proc_t *);
 726 extern  void    exitpctx(proc_t *);
 727 extern  void    freepctx(proc_t *, int);
 728 extern  kthread_t *thread_unpin(void);
 729 extern  void    thread_init(void);
 730 extern  void    thread_load(kthread_t *, void (*)(), caddr_t, size_t);
 731
 732 extern  void    tsd_create(uint_t *, void (*)(void *));
 733 extern  void    tsd_destroy(uint_t *);
 734 extern  void    *tsd_getcreate(uint_t *, void (*)(void *), void *(*)(void));
 735 extern  void    *tsd_get(uint_t);
 736 extern  int     tsd_set(uint_t, void *);
 737 extern  void    tsd_exit(void);
 738 extern  void    *tsd_agent_get(kthread_t *, uint_t);
 739 extern  int     tsd_agent_set(kthread_t *, uint_t, void *);
 740
 741 /* lwp function prototypes */
 742
 743 extern kthread_t *lwp_kernel_create(proc_t *, void (*)(), void *, int, pri_t);
 744 extern  klwp_t          *lwp_create(
 745         void            (*proc)(),
 746         caddr_t         arg,
 747         size_t          len,
 748         proc_t          *p,
 749         int             state,
 750         int             pri,
 751         const k_sigset_t *smask,
 752         int             cid,
 753         id_t            lwpid);
 754 extern  kthread_t *idtot(proc_t *, id_t);
 755 extern  void    lwp_hash_in(proc_t *, lwpent_t *, tidhash_t *, uint_t, int);
 756 extern  void    lwp_hash_out(proc_t *, id_t);
 757 extern  lwpdir_t *lwp_hash_lookup(proc_t *, id_t);
 758 extern  lwpdir_t *lwp_hash_lookup_and_lock(proc_t *, id_t, kmutex_t **);
 759 extern  void    lwp_create_done(kthread_t *);
 760 extern  void    lwp_exit(void);
 761 extern  void    lwp_pcb_exit(void);
 762 extern  void    lwp_cleanup(void);
 763 extern  int     lwp_suspend(kthread_t *);
 764 extern  void    lwp_continue(kthread_t *);
 765 extern  void    holdlwp(void);
 766 extern  void    stoplwp(void);
 767 extern  int     holdlwps(int);
 768 extern  int     holdwatch(void);
 769 extern  void    pokelwps(proc_t *);
 770 extern  void    continuelwps(proc_t *);
 771 extern  int     exitlwps(int);
 772 extern  void    lwp_ctmpl_copy(klwp_t *, klwp_t *);
 773 extern  void    lwp_ctmpl_clear(klwp_t *);
 774 extern  klwp_t  *forklwp(klwp_t *, proc_t *, id_t);
 775 extern  void    lwp_load(klwp_t *, gregset_t, uintptr_t);
 776 extern  void    lwp_setrval(klwp_t *, int, int);
 777 extern  void    lwp_forkregs(klwp_t *, klwp_t *);
 778 extern  void    lwp_freeregs(klwp_t *, int);
 779 extern  caddr_t lwp_stk_init(klwp_t *, caddr_t);
 780 extern  void    lwp_stk_cache_init(void);
 781 extern  void    lwp_stk_fini(klwp_t *);
 782 extern  void    lwp_fp_init(klwp_t *);
 783 extern  void    lwp_installctx(klwp_t *);
 784 extern  void    lwp_rtt(void);
 785 extern  void    lwp_rtt_initial(void);
 786 extern  int     lwp_setprivate(klwp_t *, int, uintptr_t);
 787 extern  void    lwp_stat_update(lwp_stat_id_t, long);
 788 extern  void    lwp_attach_brand_hdlrs(klwp_t *);
 789 extern  void    lwp_detach_brand_hdlrs(klwp_t *);
 790
 791 #if defined(__sparcv9)
 792 extern  void    lwp_mmodel_newlwp(void);
 793 extern  void    lwp_mmodel_shared_as(caddr_t, size_t);
 794 #define LWP_MMODEL_NEWLWP()             lwp_mmodel_newlwp()
 795 #define LWP_MMODEL_SHARED_AS(addr, sz)  lwp_mmodel_shared_as((addr), (sz))
 796 #else
 797 #define LWP_MMODEL_NEWLWP()
 798 #define LWP_MMODEL_SHARED_AS(addr, sz)
 799 #endif
 800
 801 /*
 802  * Signal queue function prototypes. Must be here due to header ordering
 803  * dependencies.
 804  */
 805 extern void sigqfree(proc_t *);
 806 extern void siginfofree(sigqueue_t *);
 807 extern void sigdeq(proc_t *, kthread_t *, int, sigqueue_t **);
 808 extern void sigdelq(proc_t *, kthread_t *, int);
 809 extern void sigaddq(proc_t *, kthread_t *, k_siginfo_t *, int);
 810 extern void sigaddqa(proc_t *, kthread_t *, sigqueue_t *);
 811 extern void sigqsend(int, proc_t *, kthread_t *, sigqueue_t *);
 812 extern void sigdupq(proc_t *, proc_t *);
 813 extern int sigwillqueue(int, int);
 814 extern sigqhdr_t *sigqhdralloc(size_t, uint_t);
 815 extern sigqueue_t *sigqalloc(sigqhdr_t *);
 816 extern void sigqhdrfree(sigqhdr_t *);
 817 extern sigqueue_t *sigappend(k_sigset_t *, sigqueue_t *,
 818         k_sigset_t *, sigqueue_t *);
 819 extern sigqueue_t *sigprepend(k_sigset_t *, sigqueue_t *,
 820         k_sigset_t *, sigqueue_t *);
 821 extern void winfo(proc_t *, k_siginfo_t *, int);
 822 extern int wstat(int, int);
 823 extern int sendsig(int, k_siginfo_t *, void (*)());
 824 #if defined(_SYSCALL32_IMPL)
 825 extern int sendsig32(int, k_siginfo_t *, void (*)());
 826 #endif
 827
 828 #endif  /* _KERNEL */
 829
 830 #ifdef  __cplusplus
 831 }
 832 #endif
 833
 834 #endif  /* _SYS_PROC_H */