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) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2019 Joyent, Inc.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 #include <sys/types.h>
31 #include <sys/param.h>
32 #include <sys/sysmacros.h>
33 #include <sys/proc.h>
34 #include <sys/kmem.h>
35 #include <sys/tuneable.h>
36 #include <sys/var.h>
37 #include <sys/cred.h>
38 #include <sys/systm.h>
39 #include <sys/prsystm.h>
40 #include <sys/vnode.h>
41 #include <sys/session.h>
42 #include <sys/cpuvar.h>
43 #include <sys/cmn_err.h>
44 #include <sys/bitmap.h>
45 #include <sys/debug.h>
46 #include <c2/audit.h>
47 #include <sys/project.h>
48 #include <sys/task.h>
49 #include <sys/zone.h>
50
51 /* directory entries for /proc */
52 union procent {
53 proc_t *pe_proc;
54 union procent *pe_next;
55 };
56
57 struct pid pid0 = {
58 0, /* pid_prinactive */
59 1, /* pid_pgorphaned */
60 0, /* pid_padding */
61 0, /* pid_prslot */
62 0, /* pid_id */
63 NULL, /* pid_pglink */
64 NULL, /* pid_pgtail */
65 NULL, /* pid_link */
66 3 /* pid_ref */
67 };
68
69 static int pid_hashlen = 4; /* desired average hash chain length */
70 static int pid_hashsz; /* number of buckets in the hash table */
71
72 #define HASHPID(pid) (pidhash[((pid)&(pid_hashsz-1))])
73
74 extern uint_t nproc;
75 extern struct kmem_cache *process_cache;
76 static void upcount_init(void);
77
78 kmutex_t pidlock; /* global process lock */
79 kmutex_t pr_pidlock; /* /proc global process lock */
80 kcondvar_t *pr_pid_cv; /* for /proc, one per process slot */
81 struct plock *proc_lock; /* persistent array of p_lock's */
82
83 /*
84 * See the comment above pid_getlockslot() for a detailed explanation of this
85 * constant. Note that a PLOCK_SHIFT of 3 implies 64-byte coherence
86 * granularity; if the coherence granularity is ever changed, this constant
87 * should be modified to reflect the change to minimize proc_lock false
88 * sharing (correctness, however, is guaranteed regardless of the coherence
89 * granularity).
90 */
91 #define PLOCK_SHIFT 3
92
93 static kmutex_t pidlinklock;
94 static struct pid **pidhash;
95 static pid_t minpid;
96 static pid_t mpid = FAMOUS_PIDS; /* one more than the last famous pid */
97 static union procent *procdir;
98 static union procent *procentfree;
99
100 static struct pid *
101 pid_lookup(pid_t pid)
102 {
103 struct pid *pidp;
104
105 ASSERT(MUTEX_HELD(&pidlinklock));
106
107 for (pidp = HASHPID(pid); pidp; pidp = pidp->pid_link) {
108 if (pidp->pid_id == pid) {
109 ASSERT(pidp->pid_ref > 0);
110 break;
111 }
112 }
113 return (pidp);
114 }
115
116 void
117 pid_setmin(void)
118 {
119 if (jump_pid && jump_pid > mpid)
120 minpid = mpid = jump_pid;
121 else
122 minpid = mpid;
123 }
124
125 /*
126 * When prslots are simply used as an index to determine a process' p_lock,
127 * adjacent prslots share adjacent p_locks. On machines where the size
128 * of a mutex is smaller than that of a cache line (which, as of this writing,
129 * is true for all machines on which Solaris runs), this can potentially
130 * induce false sharing. The standard solution for false sharing is to pad
131 * out one's data structures (in this case, struct plock). However,
132 * given the size and (generally) sparse use of the proc_lock array, this
133 * is suboptimal. We therefore stride through the proc_lock array with
134 * a stride of PLOCK_SHIFT. PLOCK_SHIFT should be defined as:
135 *
136 * log_2 (coherence_granularity / sizeof (kmutex_t))
137 *
138 * Under this scheme, false sharing is still possible -- but only when
139 * the number of active processes is very large. Note that the one-to-one
140 * mapping between prslots and lockslots is maintained.
141 */
142 static int
143 pid_getlockslot(int prslot)
144 {
145 int even = (v.v_proc >> PLOCK_SHIFT) << PLOCK_SHIFT;
146 int perlap = even >> PLOCK_SHIFT;
147
148 if (prslot >= even)
149 return (prslot);
150
151 return (((prslot % perlap) << PLOCK_SHIFT) + (prslot / perlap));
152 }
153
154 /*
155 * This function allocates a pid structure, a free pid, and optionally a
156 * slot in the proc table for it.
157 *
158 * pid_allocate() returns the new pid on success, -1 on failure.
159 */
160 pid_t
161 pid_allocate(proc_t *prp, pid_t pid, int flags)
162 {
163 struct pid *pidp;
164 union procent *pep;
165 pid_t newpid, startpid;
166
167 pidp = kmem_zalloc(sizeof (struct pid), KM_SLEEP);
168
169 mutex_enter(&pidlinklock);
170 if ((flags & PID_ALLOC_PROC) && (pep = procentfree) == NULL) {
171 /*
172 * ran out of /proc directory entries
173 */
174 goto failed;
175 }
176
177 if (pid != 0) {
178 VERIFY(minpid == 0);
179 VERIFY3P(pid, <, mpid);
180 VERIFY3P(pid_lookup(pid), ==, NULL);
181 newpid = pid;
182 } else {
183 /*
184 * Allocate a pid
185 */
186 ASSERT(minpid <= mpid && mpid < maxpid);
187
188 startpid = mpid;
189 for (;;) {
190 newpid = mpid;
191 if (++mpid == maxpid)
192 mpid = minpid;
193
194 if (pid_lookup(newpid) == NULL)
195 break;
196
197 if (mpid == startpid)
198 goto failed;
199 }
200 }
201
202 /*
203 * Put pid into the pid hash table.
204 */
205 pidp->pid_link = HASHPID(newpid);
206 HASHPID(newpid) = pidp;
207 pidp->pid_ref = 1;
208 pidp->pid_id = newpid;
209
210 if (flags & PID_ALLOC_PROC) {
211 procentfree = pep->pe_next;
212 pidp->pid_prslot = pep - procdir;
213 pep->pe_proc = prp;
214 prp->p_pidp = pidp;
215 prp->p_lockp = &proc_lock[pid_getlockslot(pidp->pid_prslot)];
216 } else {
217 pidp->pid_prslot = 0;
218 }
219
220 mutex_exit(&pidlinklock);
221
222 return (newpid);
223
224 failed:
225 mutex_exit(&pidlinklock);
226 kmem_free(pidp, sizeof (struct pid));
227 return (-1);
228 }
229
230 /*
231 * decrement the reference count for pid
232 */
233 int
234 pid_rele(struct pid *pidp)
235 {
236 struct pid **pidpp;
237
238 mutex_enter(&pidlinklock);
239 ASSERT(pidp != &pid0);
240
241 pidpp = &HASHPID(pidp->pid_id);
242 for (;;) {
243 ASSERT(*pidpp != NULL);
244 if (*pidpp == pidp)
245 break;
246 pidpp = &(*pidpp)->pid_link;
247 }
248
249 *pidpp = pidp->pid_link;
250 mutex_exit(&pidlinklock);
251
252 kmem_free(pidp, sizeof (*pidp));
253 return (0);
254 }
255
256 void
257 proc_entry_free(struct pid *pidp)
258 {
259 mutex_enter(&pidlinklock);
260 pidp->pid_prinactive = 1;
261 procdir[pidp->pid_prslot].pe_next = procentfree;
262 procentfree = &procdir[pidp->pid_prslot];
263 mutex_exit(&pidlinklock);
264 }
265
266 /*
267 * The original task needs to be passed in since the process has already been
268 * detached from the task at this point in time.
269 */
270 void
271 pid_exit(proc_t *prp, struct task *tk)
272 {
273 struct pid *pidp;
274 zone_t *zone = prp->p_zone;
275
276 ASSERT(MUTEX_HELD(&pidlock));
277
278 /*
279 * Exit process group. If it is NULL, it's because fork failed
280 * before calling pgjoin().
281 */
282 ASSERT(prp->p_pgidp != NULL || prp->p_stat == SIDL);
283 if (prp->p_pgidp != NULL)
284 pgexit(prp);
285
286 sess_rele(prp->p_sessp, B_TRUE);
287
288 pidp = prp->p_pidp;
289
290 proc_entry_free(pidp);
291
292 if (audit_active)
293 audit_pfree(prp);
294
295 if (practive == prp) {
296 practive = prp->p_next;
297 }
298
299 if (prp->p_next) {
300 prp->p_next->p_prev = prp->p_prev;
301 }
302 if (prp->p_prev) {
303 prp->p_prev->p_next = prp->p_next;
304 }
305
306 PID_RELE(pidp);
307
308 mutex_destroy(&prp->p_crlock);
309 kmem_cache_free(process_cache, prp);
310 nproc--;
311
312 /*
313 * Decrement the process counts of the original task, project and zone.
314 */
315 mutex_enter(&zone->zone_nlwps_lock);
316 tk->tk_nprocs--;
317 tk->tk_proj->kpj_nprocs--;
318 zone->zone_nprocs--;
319 mutex_exit(&zone->zone_nlwps_lock);
320 }
321
322 /*
323 * Find a process visible from the specified zone given its process ID.
324 */
325 proc_t *
326 prfind_zone(pid_t pid, zoneid_t zoneid)
327 {
328 struct pid *pidp;
329 proc_t *p;
330
331 ASSERT(MUTEX_HELD(&pidlock));
332
333 mutex_enter(&pidlinklock);
334 pidp = pid_lookup(pid);
335 mutex_exit(&pidlinklock);
336 if (pidp != NULL && pidp->pid_prinactive == 0) {
337 p = procdir[pidp->pid_prslot].pe_proc;
338 if (zoneid == ALL_ZONES || p->p_zone->zone_id == zoneid)
339 return (p);
340 }
341 return (NULL);
342 }
343
344 /*
345 * Find a process given its process ID. This obeys zone restrictions,
346 * so if the caller is in a non-global zone it won't find processes
347 * associated with other zones. Use prfind_zone(pid, ALL_ZONES) to
348 * bypass this restriction.
349 */
350 proc_t *
351 prfind(pid_t pid)
352 {
353 zoneid_t zoneid;
354
355 if (INGLOBALZONE(curproc))
356 zoneid = ALL_ZONES;
357 else
358 zoneid = getzoneid();
359 return (prfind_zone(pid, zoneid));
360 }
361
362 proc_t *
363 pgfind_zone(pid_t pgid, zoneid_t zoneid)
364 {
365 struct pid *pidp;
366
367 ASSERT(MUTEX_HELD(&pidlock));
368
369 mutex_enter(&pidlinklock);
370 pidp = pid_lookup(pgid);
371 mutex_exit(&pidlinklock);
372 if (pidp != NULL) {
373 proc_t *p = pidp->pid_pglink;
374
375 if (zoneid == ALL_ZONES || pgid == 0 || p == NULL ||
376 p->p_zone->zone_id == zoneid)
377 return (p);
378 }
379 return (NULL);
380 }
381
382 /*
383 * return the head of the list of processes whose process group ID is 'pgid',
384 * or NULL, if no such process group
385 */
386 proc_t *
387 pgfind(pid_t pgid)
388 {
389 zoneid_t zoneid;
390
391 if (INGLOBALZONE(curproc))
392 zoneid = ALL_ZONES;
393 else
394 zoneid = getzoneid();
395 return (pgfind_zone(pgid, zoneid));
396 }
397
398 /*
399 * Sets P_PR_LOCK on a non-system process. Process must be fully created
400 * and not exiting to succeed.
401 *
402 * Returns 0 on success.
403 * Returns 1 if P_PR_LOCK is set.
404 * Returns -1 if proc is in invalid state.
405 */
406 int
407 sprtrylock_proc(proc_t *p)
408 {
409 ASSERT(MUTEX_HELD(&p->p_lock));
410
411 /* skip system and incomplete processes */
412 if (p->p_stat == SIDL || p->p_stat == SZOMB ||
413 (p->p_flag & (SSYS | SEXITING | SEXITLWPS))) {
414 return (-1);
415 }
416
417 if (p->p_proc_flag & P_PR_LOCK)
418 return (1);
419
420 p->p_proc_flag |= P_PR_LOCK;
421
422 return (0);
423 }
424
425 /*
426 * Wait for P_PR_LOCK to become clear. Returns with p_lock dropped,
427 * and the proc pointer no longer valid, as the proc may have exited.
428 */
429 void
430 sprwaitlock_proc(proc_t *p)
431 {
432 kmutex_t *mp;
433
434 ASSERT(MUTEX_HELD(&p->p_lock));
435 ASSERT(p->p_proc_flag & P_PR_LOCK);
436
437 /*
438 * p_lock is persistent, but p itself is not -- it could
439 * vanish during cv_wait(). Load p->p_lock now so we can
440 * drop it after cv_wait() without referencing p.
441 */
442 mp = &p->p_lock;
443 cv_wait(&pr_pid_cv[p->p_slot], mp);
444 mutex_exit(mp);
445 }
446
447 /*
448 * If pid exists, find its proc, acquire its p_lock and mark it P_PR_LOCK.
449 * Returns the proc pointer on success, NULL on failure. sprlock() is
450 * really just a stripped-down version of pr_p_lock() to allow practive
451 * walkers like dofusers() and dumpsys() to synchronize with /proc.
452 */
453 proc_t *
454 sprlock_zone(pid_t pid, zoneid_t zoneid)
455 {
456 proc_t *p;
457 int ret;
458
459 for (;;) {
460 mutex_enter(&pidlock);
461 if ((p = prfind_zone(pid, zoneid)) == NULL) {
462 mutex_exit(&pidlock);
463 return (NULL);
464 }
465 mutex_enter(&p->p_lock);
466 mutex_exit(&pidlock);
467
468 if (panicstr)
469 return (p);
470
471 ret = sprtrylock_proc(p);
472 if (ret == -1) {
473 mutex_exit(&p->p_lock);
474 return (NULL);
475 } else if (ret == 0) {
476 break;
477 }
478 sprwaitlock_proc(p);
479 }
480 return (p);
481 }
482
483 proc_t *
484 sprlock(pid_t pid)
485 {
486 zoneid_t zoneid;
487
488 if (INGLOBALZONE(curproc))
489 zoneid = ALL_ZONES;
490 else
491 zoneid = getzoneid();
492 return (sprlock_zone(pid, zoneid));
493 }
494
495 void
496 sprlock_proc(proc_t *p)
497 {
498 ASSERT(MUTEX_HELD(&p->p_lock));
499
500 while (p->p_proc_flag & P_PR_LOCK) {
501 cv_wait(&pr_pid_cv[p->p_slot], &p->p_lock);
502 }
503
504 p->p_proc_flag |= P_PR_LOCK;
505 }
506
507 void
508 sprunlock(proc_t *p)
509 {
510 if (panicstr) {
511 mutex_exit(&p->p_lock);
512 return;
513 }
514
515 ASSERT(p->p_proc_flag & P_PR_LOCK);
516 ASSERT(MUTEX_HELD(&p->p_lock));
517
518 cv_signal(&pr_pid_cv[p->p_slot]);
519 p->p_proc_flag &= ~P_PR_LOCK;
520 mutex_exit(&p->p_lock);
521 }
522
523 void
524 pid_init(void)
525 {
526 int i;
527
528 pid_hashsz = 1 << highbit(v.v_proc / pid_hashlen);
529
530 pidhash = kmem_zalloc(sizeof (struct pid *) * pid_hashsz, KM_SLEEP);
531 procdir = kmem_alloc(sizeof (union procent) * v.v_proc, KM_SLEEP);
532 pr_pid_cv = kmem_zalloc(sizeof (kcondvar_t) * v.v_proc, KM_SLEEP);
533 proc_lock = kmem_zalloc(sizeof (struct plock) * v.v_proc, KM_SLEEP);
534
535 nproc = 1;
536 practive = proc_sched;
537 proc_sched->p_next = NULL;
538 procdir[0].pe_proc = proc_sched;
539
540 procentfree = &procdir[1];
541 for (i = 1; i < v.v_proc - 1; i++)
542 procdir[i].pe_next = &procdir[i+1];
543 procdir[i].pe_next = NULL;
544
545 HASHPID(0) = &pid0;
546
547 upcount_init();
548 }
549
550 proc_t *
551 pid_entry(int slot)
552 {
553 union procent *pep;
554 proc_t *prp;
555
556 ASSERT(MUTEX_HELD(&pidlock));
557 ASSERT(slot >= 0 && slot < v.v_proc);
558
559 pep = procdir[slot].pe_next;
560 if (pep >= procdir && pep < &procdir[v.v_proc])
561 return (NULL);
562 prp = procdir[slot].pe_proc;
563 if (prp != 0 && prp->p_stat == SIDL)
564 return (NULL);
565 return (prp);
566 }
567
568 /*
569 * Send the specified signal to all processes whose process group ID is
570 * equal to 'pgid'
571 */
572
573 void
574 signal(pid_t pgid, int sig)
575 {
576 struct pid *pidp;
577 proc_t *prp;
578
579 mutex_enter(&pidlock);
580 mutex_enter(&pidlinklock);
581 if (pgid == 0 || (pidp = pid_lookup(pgid)) == NULL) {
582 mutex_exit(&pidlinklock);
583 mutex_exit(&pidlock);
584 return;
585 }
586 mutex_exit(&pidlinklock);
587 for (prp = pidp->pid_pglink; prp; prp = prp->p_pglink) {
588 mutex_enter(&prp->p_lock);
589 sigtoproc(prp, NULL, sig);
590 mutex_exit(&prp->p_lock);
591 }
592 mutex_exit(&pidlock);
593 }
594
595 /*
596 * Send the specified signal to the specified process
597 */
598
599 void
600 prsignal(struct pid *pidp, int sig)
601 {
602 if (!(pidp->pid_prinactive))
603 psignal(procdir[pidp->pid_prslot].pe_proc, sig);
604 }
605
606 #include <sys/sunddi.h>
607
608 /*
609 * DDI/DKI interfaces for drivers to send signals to processes
610 */
611
612 /*
613 * obtain an opaque reference to a process for signaling
614 */
615 void *
616 proc_ref(void)
617 {
618 struct pid *pidp;
619
620 mutex_enter(&pidlock);
621 pidp = curproc->p_pidp;
622 PID_HOLD(pidp);
623 mutex_exit(&pidlock);
624
625 return (pidp);
626 }
627
628 /*
629 * release a reference to a process
630 * - a process can exit even if a driver has a reference to it
631 * - one proc_unref for every proc_ref
632 */
633 void
634 proc_unref(void *pref)
635 {
636 mutex_enter(&pidlock);
637 PID_RELE((struct pid *)pref);
638 mutex_exit(&pidlock);
639 }
640
641 /*
642 * send a signal to a process
643 *
644 * - send the process the signal
645 * - if the process went away, return a -1
646 * - if the process is still there return 0
647 */
648 int
649 proc_signal(void *pref, int sig)
650 {
651 struct pid *pidp = pref;
652
653 prsignal(pidp, sig);
654 return (pidp->pid_prinactive ? -1 : 0);
655 }
656
657
658 static struct upcount **upc_hash; /* a boot time allocated array */
659 static ulong_t upc_hashmask;
660 #define UPC_HASH(x, y) ((ulong_t)(x ^ y) & upc_hashmask)
661
662 /*
663 * Get us off the ground. Called once at boot.
664 */
665 void
666 upcount_init(void)
667 {
668 ulong_t upc_hashsize;
669
670 /*
671 * An entry per MB of memory is our current guess
672 */
673 /*
674 * 2^20 is a meg, so shifting right by 20 - PAGESHIFT
675 * converts pages to megs (without overflowing a u_int
676 * if you have more than 4G of memory, like ptob(physmem)/1M
677 * would).
678 */
679 upc_hashsize = (1 << highbit(physmem >> (20 - PAGESHIFT)));
680 upc_hashmask = upc_hashsize - 1;
681 upc_hash = kmem_zalloc(upc_hashsize * sizeof (struct upcount *),
682 KM_SLEEP);
683 }
684
685 /*
686 * Increment the number of processes associated with a given uid and zoneid.
687 */
688 void
689 upcount_inc(uid_t uid, zoneid_t zoneid)
690 {
691 struct upcount **upc, **hupc;
692 struct upcount *new;
693
694 ASSERT(MUTEX_HELD(&pidlock));
695 new = NULL;
696 hupc = &upc_hash[UPC_HASH(uid, zoneid)];
697 top:
698 upc = hupc;
699 while ((*upc) != NULL) {
700 if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) {
701 (*upc)->up_count++;
702 if (new) {
703 /*
704 * did not need `new' afterall.
705 */
706 kmem_free(new, sizeof (*new));
707 }
708 return;
709 }
710 upc = &(*upc)->up_next;
711 }
712
713 /*
714 * There is no entry for this <uid,zoneid> pair.
715 * Allocate one. If we have to drop pidlock, check
716 * again.
717 */
718 if (new == NULL) {
719 new = (struct upcount *)kmem_alloc(sizeof (*new), KM_NOSLEEP);
720 if (new == NULL) {
721 mutex_exit(&pidlock);
722 new = (struct upcount *)kmem_alloc(sizeof (*new),
723 KM_SLEEP);
724 mutex_enter(&pidlock);
725 goto top;
726 }
727 }
728
729
730 /*
731 * On the assumption that a new user is going to do some
732 * more forks, put the new upcount structure on the front.
733 */
734 upc = hupc;
735
736 new->up_uid = uid;
737 new->up_zoneid = zoneid;
738 new->up_count = 1;
739 new->up_next = *upc;
740
741 *upc = new;
742 }
743
744 /*
745 * Decrement the number of processes a given uid and zoneid has.
746 */
747 void
748 upcount_dec(uid_t uid, zoneid_t zoneid)
749 {
750 struct upcount **upc;
751 struct upcount *done;
752
753 ASSERT(MUTEX_HELD(&pidlock));
754
755 upc = &upc_hash[UPC_HASH(uid, zoneid)];
756 while ((*upc) != NULL) {
757 if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) {
758 (*upc)->up_count--;
759 if ((*upc)->up_count == 0) {
760 done = *upc;
761 *upc = (*upc)->up_next;
762 kmem_free(done, sizeof (*done));
763 }
764 return;
765 }
766 upc = &(*upc)->up_next;
767 }
768 cmn_err(CE_PANIC, "decr_upcount-off the end");
769 }
770
771 /*
772 * Returns the number of processes a uid has.
773 * Non-existent uid's are assumed to have no processes.
774 */
775 int
776 upcount_get(uid_t uid, zoneid_t zoneid)
777 {
778 struct upcount *upc;
779
780 ASSERT(MUTEX_HELD(&pidlock));
781
782 upc = upc_hash[UPC_HASH(uid, zoneid)];
783 while (upc != NULL) {
784 if (upc->up_uid == uid && upc->up_zoneid == zoneid) {
785 return (upc->up_count);
786 }
787 upc = upc->up_next;
788 }
789 return (0);
790 }