FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_proc.c
1 /* $NetBSD: kern_proc.c,v 1.99.2.1 2007/04/01 16:16:20 bouyer Exp $ */
2
3 /*-
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 /*
41 * Copyright (c) 1982, 1986, 1989, 1991, 1993
42 * The Regents of the University of California. All rights reserved.
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 * notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 * notice, this list of conditions and the following disclaimer in the
51 * documentation and/or other materials provided with the distribution.
52 * 3. Neither the name of the University nor the names of its contributors
53 * may be used to endorse or promote products derived from this software
54 * without specific prior written permission.
55 *
56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
66 * SUCH DAMAGE.
67 *
68 * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
69 */
70
71 #include <sys/cdefs.h>
72 __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.99.2.1 2007/04/01 16:16:20 bouyer Exp $");
73
74 #include "opt_kstack.h"
75 #include "opt_maxuprc.h"
76 #include "opt_multiprocessor.h"
77 #include "opt_lockdebug.h"
78
79 #include <sys/param.h>
80 #include <sys/systm.h>
81 #include <sys/kernel.h>
82 #include <sys/proc.h>
83 #include <sys/resourcevar.h>
84 #include <sys/buf.h>
85 #include <sys/acct.h>
86 #include <sys/wait.h>
87 #include <sys/file.h>
88 #include <ufs/ufs/quota.h>
89 #include <sys/uio.h>
90 #include <sys/malloc.h>
91 #include <sys/pool.h>
92 #include <sys/mbuf.h>
93 #include <sys/ioctl.h>
94 #include <sys/tty.h>
95 #include <sys/signalvar.h>
96 #include <sys/ras.h>
97 #include <sys/sa.h>
98 #include <sys/savar.h>
99 #include <sys/filedesc.h>
100 #include <sys/kauth.h>
101
102 #include <uvm/uvm.h>
103 #include <uvm/uvm_extern.h>
104
105 /*
106 * Other process lists
107 */
108
109 struct proclist allproc;
110 struct proclist zombproc; /* resources have been freed */
111
112
113 /*
114 * Process list locking:
115 *
116 * We have two types of locks on the proclists: read locks and write
117 * locks. Read locks can be used in interrupt context, so while we
118 * hold the write lock, we must also block clock interrupts to
119 * lock out any scheduling changes that may happen in interrupt
120 * context.
121 *
122 * The proclist lock locks the following structures:
123 *
124 * allproc
125 * zombproc
126 * pid_table
127 */
128 struct lock proclist_lock;
129
130 /*
131 * pid to proc lookup is done by indexing the pid_table array.
132 * Since pid numbers are only allocated when an empty slot
133 * has been found, there is no need to search any lists ever.
134 * (an orphaned pgrp will lock the slot, a session will lock
135 * the pgrp with the same number.)
136 * If the table is too small it is reallocated with twice the
137 * previous size and the entries 'unzipped' into the two halves.
138 * A linked list of free entries is passed through the pt_proc
139 * field of 'free' items - set odd to be an invalid ptr.
140 */
141
142 struct pid_table {
143 struct proc *pt_proc;
144 struct pgrp *pt_pgrp;
145 };
146 #if 1 /* strongly typed cast - should be a noop */
147 static inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; }
148 #else
149 #define p2u(p) ((uint)p)
150 #endif
151 #define P_VALID(p) (!(p2u(p) & 1))
152 #define P_NEXT(p) (p2u(p) >> 1)
153 #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1))
154
155 #define INITIAL_PID_TABLE_SIZE (1 << 5)
156 static struct pid_table *pid_table;
157 static uint pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1;
158 static uint pid_alloc_lim; /* max we allocate before growing table */
159 static uint pid_alloc_cnt; /* number of allocated pids */
160
161 /* links through free slots - never empty! */
162 static uint next_free_pt, last_free_pt;
163 static pid_t pid_max = PID_MAX; /* largest value we allocate */
164
165 /* Components of the first process -- never freed. */
166 struct session session0;
167 struct pgrp pgrp0;
168 struct proc proc0;
169 struct lwp lwp0;
170 kauth_cred_t cred0;
171 struct filedesc0 filedesc0;
172 struct cwdinfo cwdi0;
173 struct plimit limit0;
174 struct pstats pstat0;
175 struct vmspace vmspace0;
176 struct sigacts sigacts0;
177
178 extern struct user *proc0paddr;
179
180 extern const struct emul emul_netbsd; /* defined in kern_exec.c */
181
182 int nofile = NOFILE;
183 int maxuprc = MAXUPRC;
184 int cmask = CMASK;
185
186 POOL_INIT(proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
187 &pool_allocator_nointr);
188 POOL_INIT(pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
189 &pool_allocator_nointr);
190 POOL_INIT(plimit_pool, sizeof(struct plimit), 0, 0, 0, "plimitpl",
191 &pool_allocator_nointr);
192 POOL_INIT(pstats_pool, sizeof(struct pstats), 0, 0, 0, "pstatspl",
193 &pool_allocator_nointr);
194 POOL_INIT(rusage_pool, sizeof(struct rusage), 0, 0, 0, "rusgepl",
195 &pool_allocator_nointr);
196 POOL_INIT(session_pool, sizeof(struct session), 0, 0, 0, "sessionpl",
197 &pool_allocator_nointr);
198
199 MALLOC_DEFINE(M_EMULDATA, "emuldata", "Per-process emulation data");
200 MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
201 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
202
203 /*
204 * The process list descriptors, used during pid allocation and
205 * by sysctl. No locking on this data structure is needed since
206 * it is completely static.
207 */
208 const struct proclist_desc proclists[] = {
209 { &allproc },
210 { &zombproc },
211 { NULL },
212 };
213
214 static void orphanpg(struct pgrp *);
215 static void pg_delete(pid_t);
216
217 static specificdata_domain_t proc_specificdata_domain;
218
219 /*
220 * Initialize global process hashing structures.
221 */
222 void
223 procinit(void)
224 {
225 const struct proclist_desc *pd;
226 int i;
227 #define LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1))
228
229 for (pd = proclists; pd->pd_list != NULL; pd++)
230 LIST_INIT(pd->pd_list);
231
232 spinlockinit(&proclist_lock, "proclk", 0);
233
234 pid_table = malloc(INITIAL_PID_TABLE_SIZE * sizeof *pid_table,
235 M_PROC, M_WAITOK);
236 /* Set free list running through table...
237 Preset 'use count' above PID_MAX so we allocate pid 1 next. */
238 for (i = 0; i <= pid_tbl_mask; i++) {
239 pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1);
240 pid_table[i].pt_pgrp = 0;
241 }
242 /* slot 0 is just grabbed */
243 next_free_pt = 1;
244 /* Need to fix last entry. */
245 last_free_pt = pid_tbl_mask;
246 pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY);
247 /* point at which we grow table - to avoid reusing pids too often */
248 pid_alloc_lim = pid_tbl_mask - 1;
249 #undef LINK_EMPTY
250
251 LIST_INIT(&alllwp);
252
253 uihashtbl =
254 hashinit(maxproc / 16, HASH_LIST, M_PROC, M_WAITOK, &uihash);
255
256 proc_specificdata_domain = specificdata_domain_create();
257 KASSERT(proc_specificdata_domain != NULL);
258 }
259
260 /*
261 * Initialize process 0.
262 */
263 void
264 proc0_init(void)
265 {
266 struct proc *p;
267 struct pgrp *pg;
268 struct session *sess;
269 struct lwp *l;
270 int s;
271 u_int i;
272 rlim_t lim;
273
274 p = &proc0;
275 pg = &pgrp0;
276 sess = &session0;
277 l = &lwp0;
278
279 simple_lock_init(&p->p_lock);
280 LIST_INIT(&p->p_lwps);
281 LIST_INSERT_HEAD(&p->p_lwps, l, l_sibling);
282 p->p_nlwps = 1;
283 simple_lock_init(&p->p_sigctx.ps_silock);
284 CIRCLEQ_INIT(&p->p_sigctx.ps_siginfo);
285
286 s = proclist_lock_write();
287
288 pid_table[0].pt_proc = p;
289 LIST_INSERT_HEAD(&allproc, p, p_list);
290 LIST_INSERT_HEAD(&alllwp, l, l_list);
291
292 p->p_pgrp = pg;
293 pid_table[0].pt_pgrp = pg;
294 LIST_INIT(&pg->pg_members);
295 LIST_INSERT_HEAD(&pg->pg_members, p, p_pglist);
296
297 pg->pg_session = sess;
298 sess->s_count = 1;
299 sess->s_sid = 0;
300 sess->s_leader = p;
301
302 proclist_unlock_write(s);
303
304 /*
305 * Set P_NOCLDWAIT so that kernel threads are reparented to
306 * init(8) when they exit. init(8) can easily wait them out
307 * for us.
308 */
309 p->p_flag = P_SYSTEM | P_NOCLDWAIT;
310 p->p_stat = SACTIVE;
311 p->p_nice = NZERO;
312 p->p_emul = &emul_netbsd;
313 #ifdef __HAVE_SYSCALL_INTERN
314 (*p->p_emul->e_syscall_intern)(p);
315 #endif
316 strncpy(p->p_comm, "swapper", MAXCOMLEN);
317
318 l->l_flag = L_INMEM;
319 l->l_stat = LSONPROC;
320 p->p_nrlwps = 1;
321
322 callout_init(&l->l_tsleep_ch);
323
324 /* Create credentials. */
325 cred0 = kauth_cred_alloc();
326 p->p_cred = cred0;
327 lwp_update_creds(l);
328
329 /* Create the CWD info. */
330 p->p_cwdi = &cwdi0;
331 cwdi0.cwdi_cmask = cmask;
332 cwdi0.cwdi_refcnt = 1;
333 simple_lock_init(&cwdi0.cwdi_slock);
334
335 /* Create the limits structures. */
336 p->p_limit = &limit0;
337 simple_lock_init(&limit0.p_slock);
338 for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
339 limit0.pl_rlimit[i].rlim_cur =
340 limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
341
342 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
343 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur =
344 maxfiles < nofile ? maxfiles : nofile;
345
346 limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
347 limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur =
348 maxproc < maxuprc ? maxproc : maxuprc;
349
350 lim = ptoa(uvmexp.free);
351 limit0.pl_rlimit[RLIMIT_RSS].rlim_max = lim;
352 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim;
353 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
354 limit0.pl_corename = defcorename;
355 limit0.p_refcnt = 1;
356
357 /* Configure virtual memory system, set vm rlimits. */
358 uvm_init_limits(p);
359
360 /* Initialize file descriptor table for proc0. */
361 p->p_fd = &filedesc0.fd_fd;
362 fdinit1(&filedesc0);
363
364 /*
365 * Initialize proc0's vmspace, which uses the kernel pmap.
366 * All kernel processes (which never have user space mappings)
367 * share proc0's vmspace, and thus, the kernel pmap.
368 */
369 uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS),
370 trunc_page(VM_MAX_ADDRESS));
371 p->p_vmspace = &vmspace0;
372
373 l->l_addr = proc0paddr; /* XXX */
374
375 p->p_stats = &pstat0;
376
377 /* Initialize signal state for proc0. */
378 p->p_sigacts = &sigacts0;
379 siginit(p);
380
381 proc_initspecific(p);
382 lwp_initspecific(l);
383 }
384
385 /*
386 * Acquire a read lock on the proclist.
387 */
388 void
389 proclist_lock_read(void)
390 {
391 int error;
392
393 error = spinlockmgr(&proclist_lock, LK_SHARED, NULL);
394 #ifdef DIAGNOSTIC
395 if (__predict_false(error != 0))
396 panic("proclist_lock_read: failed to acquire lock");
397 #endif
398 }
399
400 /*
401 * Release a read lock on the proclist.
402 */
403 void
404 proclist_unlock_read(void)
405 {
406
407 (void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
408 }
409
410 /*
411 * Acquire a write lock on the proclist.
412 */
413 int
414 proclist_lock_write(void)
415 {
416 int s, error;
417
418 s = splclock();
419 error = spinlockmgr(&proclist_lock, LK_EXCLUSIVE, NULL);
420 #ifdef DIAGNOSTIC
421 if (__predict_false(error != 0))
422 panic("proclist_lock: failed to acquire lock");
423 #endif
424 return s;
425 }
426
427 /*
428 * Release a write lock on the proclist.
429 */
430 void
431 proclist_unlock_write(int s)
432 {
433
434 (void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
435 splx(s);
436 }
437
438 /*
439 * Check that the specified process group is in the session of the
440 * specified process.
441 * Treats -ve ids as process ids.
442 * Used to validate TIOCSPGRP requests.
443 */
444 int
445 pgid_in_session(struct proc *p, pid_t pg_id)
446 {
447 struct pgrp *pgrp;
448
449 if (pg_id < 0) {
450 struct proc *p1 = pfind(-pg_id);
451 if (p1 == NULL)
452 return EINVAL;
453 pgrp = p1->p_pgrp;
454 } else {
455 pgrp = pgfind(pg_id);
456 if (pgrp == NULL)
457 return EINVAL;
458 }
459 if (pgrp->pg_session != p->p_pgrp->pg_session)
460 return EPERM;
461 return 0;
462 }
463
464 /*
465 * Is p an inferior of q?
466 *
467 * Call with the proclist_lock held.
468 */
469 int
470 inferior(struct proc *p, struct proc *q)
471 {
472
473 for (; p != q; p = p->p_pptr)
474 if (p->p_pid == 0)
475 return 0;
476 return 1;
477 }
478
479 /*
480 * Locate a process by number
481 */
482 struct proc *
483 p_find(pid_t pid, uint flags)
484 {
485 struct proc *p;
486 char stat;
487
488 if (!(flags & PFIND_LOCKED))
489 proclist_lock_read();
490 p = pid_table[pid & pid_tbl_mask].pt_proc;
491 /* Only allow live processes to be found by pid. */
492 if (P_VALID(p) && p->p_pid == pid &&
493 ((stat = p->p_stat) == SACTIVE || stat == SSTOP ||
494 ((flags & PFIND_ZOMBIE) && (stat == SDYING || stat == SZOMB)))) {
495 if (flags & PFIND_UNLOCK_OK)
496 proclist_unlock_read();
497 return p;
498 }
499 if (flags & PFIND_UNLOCK_FAIL)
500 proclist_unlock_read();
501 return NULL;
502 }
503
504
505 /*
506 * Locate a process group by number
507 */
508 struct pgrp *
509 pg_find(pid_t pgid, uint flags)
510 {
511 struct pgrp *pg;
512
513 if (!(flags & PFIND_LOCKED))
514 proclist_lock_read();
515 pg = pid_table[pgid & pid_tbl_mask].pt_pgrp;
516 /*
517 * Can't look up a pgrp that only exists because the session
518 * hasn't died yet (traditional)
519 */
520 if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) {
521 if (flags & PFIND_UNLOCK_FAIL)
522 proclist_unlock_read();
523 return NULL;
524 }
525
526 if (flags & PFIND_UNLOCK_OK)
527 proclist_unlock_read();
528 return pg;
529 }
530
531 static void
532 expand_pid_table(void)
533 {
534 uint pt_size = pid_tbl_mask + 1;
535 struct pid_table *n_pt, *new_pt;
536 struct proc *proc;
537 struct pgrp *pgrp;
538 int i;
539 int s;
540 pid_t pid;
541
542 new_pt = malloc(pt_size * 2 * sizeof *new_pt, M_PROC, M_WAITOK);
543
544 s = proclist_lock_write();
545 if (pt_size != pid_tbl_mask + 1) {
546 /* Another process beat us to it... */
547 proclist_unlock_write(s);
548 FREE(new_pt, M_PROC);
549 return;
550 }
551
552 /*
553 * Copy entries from old table into new one.
554 * If 'pid' is 'odd' we need to place in the upper half,
555 * even pid's to the lower half.
556 * Free items stay in the low half so we don't have to
557 * fixup the reference to them.
558 * We stuff free items on the front of the freelist
559 * because we can't write to unmodified entries.
560 * Processing the table backwards maintains a semblance
561 * of issueing pid numbers that increase with time.
562 */
563 i = pt_size - 1;
564 n_pt = new_pt + i;
565 for (; ; i--, n_pt--) {
566 proc = pid_table[i].pt_proc;
567 pgrp = pid_table[i].pt_pgrp;
568 if (!P_VALID(proc)) {
569 /* Up 'use count' so that link is valid */
570 pid = (P_NEXT(proc) + pt_size) & ~pt_size;
571 proc = P_FREE(pid);
572 if (pgrp)
573 pid = pgrp->pg_id;
574 } else
575 pid = proc->p_pid;
576
577 /* Save entry in appropriate half of table */
578 n_pt[pid & pt_size].pt_proc = proc;
579 n_pt[pid & pt_size].pt_pgrp = pgrp;
580
581 /* Put other piece on start of free list */
582 pid = (pid ^ pt_size) & ~pid_tbl_mask;
583 n_pt[pid & pt_size].pt_proc =
584 P_FREE((pid & ~pt_size) | next_free_pt);
585 n_pt[pid & pt_size].pt_pgrp = 0;
586 next_free_pt = i | (pid & pt_size);
587 if (i == 0)
588 break;
589 }
590
591 /* Switch tables */
592 n_pt = pid_table;
593 pid_table = new_pt;
594 pid_tbl_mask = pt_size * 2 - 1;
595
596 /*
597 * pid_max starts as PID_MAX (= 30000), once we have 16384
598 * allocated pids we need it to be larger!
599 */
600 if (pid_tbl_mask > PID_MAX) {
601 pid_max = pid_tbl_mask * 2 + 1;
602 pid_alloc_lim |= pid_alloc_lim << 1;
603 } else
604 pid_alloc_lim <<= 1; /* doubles number of free slots... */
605
606 proclist_unlock_write(s);
607 FREE(n_pt, M_PROC);
608 }
609
610 struct proc *
611 proc_alloc(void)
612 {
613 struct proc *p;
614 int s, nxt;
615 pid_t pid;
616 struct pid_table *pt;
617
618 p = pool_get(&proc_pool, PR_WAITOK);
619 p->p_stat = SIDL; /* protect against others */
620
621 proc_initspecific(p);
622 /* allocate next free pid */
623
624 for (;;expand_pid_table()) {
625 if (__predict_false(pid_alloc_cnt >= pid_alloc_lim))
626 /* ensure pids cycle through 2000+ values */
627 continue;
628 s = proclist_lock_write();
629 pt = &pid_table[next_free_pt];
630 #ifdef DIAGNOSTIC
631 if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp))
632 panic("proc_alloc: slot busy");
633 #endif
634 nxt = P_NEXT(pt->pt_proc);
635 if (nxt & pid_tbl_mask)
636 break;
637 /* Table full - expand (NB last entry not used....) */
638 proclist_unlock_write(s);
639 }
640
641 /* pid is 'saved use count' + 'size' + entry */
642 pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt;
643 if ((uint)pid > (uint)pid_max)
644 pid &= pid_tbl_mask;
645 p->p_pid = pid;
646 next_free_pt = nxt & pid_tbl_mask;
647
648 /* Grab table slot */
649 pt->pt_proc = p;
650 pid_alloc_cnt++;
651
652 proclist_unlock_write(s);
653
654 return p;
655 }
656
657 /*
658 * Free last resources of a process - called from proc_free (in kern_exit.c)
659 */
660 void
661 proc_free_mem(struct proc *p)
662 {
663 int s;
664 pid_t pid = p->p_pid;
665 struct pid_table *pt;
666
667 s = proclist_lock_write();
668
669 pt = &pid_table[pid & pid_tbl_mask];
670 #ifdef DIAGNOSTIC
671 if (__predict_false(pt->pt_proc != p))
672 panic("proc_free: pid_table mismatch, pid %x, proc %p",
673 pid, p);
674 #endif
675 /* save pid use count in slot */
676 pt->pt_proc = P_FREE(pid & ~pid_tbl_mask);
677
678 if (pt->pt_pgrp == NULL) {
679 /* link last freed entry onto ours */
680 pid &= pid_tbl_mask;
681 pt = &pid_table[last_free_pt];
682 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid);
683 last_free_pt = pid;
684 pid_alloc_cnt--;
685 }
686
687 nprocs--;
688 proclist_unlock_write(s);
689
690 pool_put(&proc_pool, p);
691 }
692
693 /*
694 * Move p to a new or existing process group (and session)
695 *
696 * If we are creating a new pgrp, the pgid should equal
697 * the calling process' pid.
698 * If is only valid to enter a process group that is in the session
699 * of the process.
700 * Also mksess should only be set if we are creating a process group
701 *
702 * Only called from sys_setsid, sys_setpgid/sys_setpgrp and the
703 * SYSV setpgrp support for hpux == enterpgrp(curproc, curproc->p_pid)
704 */
705 int
706 enterpgrp(struct proc *p, pid_t pgid, int mksess)
707 {
708 struct pgrp *new_pgrp, *pgrp;
709 struct session *sess;
710 struct proc *curp = curproc;
711 pid_t pid = p->p_pid;
712 int rval;
713 int s;
714 pid_t pg_id = NO_PGID;
715
716 /* Allocate data areas we might need before doing any validity checks */
717 proclist_lock_read(); /* Because pid_table might change */
718 if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) {
719 proclist_unlock_read();
720 new_pgrp = pool_get(&pgrp_pool, PR_WAITOK);
721 } else {
722 proclist_unlock_read();
723 new_pgrp = NULL;
724 }
725 if (mksess)
726 sess = pool_get(&session_pool, PR_WAITOK);
727 else
728 sess = NULL;
729
730 s = proclist_lock_write();
731 rval = EPERM; /* most common error (to save typing) */
732
733 /* Check pgrp exists or can be created */
734 pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
735 if (pgrp != NULL && pgrp->pg_id != pgid)
736 goto done;
737
738 /* Can only set another process under restricted circumstances. */
739 if (p != curp) {
740 /* must exist and be one of our children... */
741 if (p != pid_table[pid & pid_tbl_mask].pt_proc
742 || !inferior(p, curp)) {
743 rval = ESRCH;
744 goto done;
745 }
746 /* ... in the same session... */
747 if (sess != NULL || p->p_session != curp->p_session)
748 goto done;
749 /* ... existing pgid must be in same session ... */
750 if (pgrp != NULL && pgrp->pg_session != p->p_session)
751 goto done;
752 /* ... and not done an exec. */
753 if (p->p_flag & P_EXEC) {
754 rval = EACCES;
755 goto done;
756 }
757 }
758
759 /* Changing the process group/session of a session
760 leader is definitely off limits. */
761 if (SESS_LEADER(p)) {
762 if (sess == NULL && p->p_pgrp == pgrp)
763 /* unless it's a definite noop */
764 rval = 0;
765 goto done;
766 }
767
768 /* Can only create a process group with id of process */
769 if (pgrp == NULL && pgid != pid)
770 goto done;
771
772 /* Can only create a session if creating pgrp */
773 if (sess != NULL && pgrp != NULL)
774 goto done;
775
776 /* Check we allocated memory for a pgrp... */
777 if (pgrp == NULL && new_pgrp == NULL)
778 goto done;
779
780 /* Don't attach to 'zombie' pgrp */
781 if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members))
782 goto done;
783
784 /* Expect to succeed now */
785 rval = 0;
786
787 if (pgrp == p->p_pgrp)
788 /* nothing to do */
789 goto done;
790
791 /* Ok all setup, link up required structures */
792 if (pgrp == NULL) {
793 pgrp = new_pgrp;
794 new_pgrp = 0;
795 if (sess != NULL) {
796 sess->s_sid = p->p_pid;
797 sess->s_leader = p;
798 sess->s_count = 1;
799 sess->s_ttyvp = NULL;
800 sess->s_ttyp = NULL;
801 sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET;
802 memcpy(sess->s_login, p->p_session->s_login,
803 sizeof(sess->s_login));
804 p->p_flag &= ~P_CONTROLT;
805 } else {
806 sess = p->p_pgrp->pg_session;
807 SESSHOLD(sess);
808 }
809 pgrp->pg_session = sess;
810 sess = 0;
811
812 pgrp->pg_id = pgid;
813 LIST_INIT(&pgrp->pg_members);
814 #ifdef DIAGNOSTIC
815 if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp))
816 panic("enterpgrp: pgrp table slot in use");
817 if (__predict_false(mksess && p != curp))
818 panic("enterpgrp: mksession and p != curproc");
819 #endif
820 pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp;
821 pgrp->pg_jobc = 0;
822 }
823
824 /*
825 * Adjust eligibility of affected pgrps to participate in job control.
826 * Increment eligibility counts before decrementing, otherwise we
827 * could reach 0 spuriously during the first call.
828 */
829 fixjobc(p, pgrp, 1);
830 fixjobc(p, p->p_pgrp, 0);
831
832 /* Move process to requested group */
833 LIST_REMOVE(p, p_pglist);
834 if (LIST_EMPTY(&p->p_pgrp->pg_members))
835 /* defer delete until we've dumped the lock */
836 pg_id = p->p_pgrp->pg_id;
837 p->p_pgrp = pgrp;
838 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
839
840 done:
841 proclist_unlock_write(s);
842 if (sess != NULL)
843 pool_put(&session_pool, sess);
844 if (new_pgrp != NULL)
845 pool_put(&pgrp_pool, new_pgrp);
846 if (pg_id != NO_PGID)
847 pg_delete(pg_id);
848 #ifdef DEBUG_PGRP
849 if (__predict_false(rval))
850 printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n",
851 pid, pgid, mksess, curp->p_pid, rval);
852 #endif
853 return rval;
854 }
855
856 /*
857 * Remove a process from its process group.
858 */
859 int
860 leavepgrp(struct proc *p)
861 {
862 int s;
863 struct pgrp *pgrp;
864 pid_t pg_id;
865
866 s = proclist_lock_write();
867 pgrp = p->p_pgrp;
868 LIST_REMOVE(p, p_pglist);
869 p->p_pgrp = NULL;
870 pg_id = LIST_EMPTY(&pgrp->pg_members) ? pgrp->pg_id : NO_PGID;
871 proclist_unlock_write(s);
872
873 if (pg_id != NO_PGID)
874 pg_delete(pg_id);
875 return 0;
876 }
877
878 static void
879 pg_free(pid_t pg_id)
880 {
881 struct pgrp *pgrp;
882 struct pid_table *pt;
883 int s;
884
885 s = proclist_lock_write();
886 pt = &pid_table[pg_id & pid_tbl_mask];
887 pgrp = pt->pt_pgrp;
888 #ifdef DIAGNOSTIC
889 if (__predict_false(!pgrp || pgrp->pg_id != pg_id
890 || !LIST_EMPTY(&pgrp->pg_members)))
891 panic("pg_free: process group absent or has members");
892 #endif
893 pt->pt_pgrp = 0;
894
895 if (!P_VALID(pt->pt_proc)) {
896 /* orphaned pgrp, put slot onto free list */
897 #ifdef DIAGNOSTIC
898 if (__predict_false(P_NEXT(pt->pt_proc) & pid_tbl_mask))
899 panic("pg_free: process slot on free list");
900 #endif
901
902 pg_id &= pid_tbl_mask;
903 pt = &pid_table[last_free_pt];
904 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id);
905 last_free_pt = pg_id;
906 pid_alloc_cnt--;
907 }
908 proclist_unlock_write(s);
909
910 pool_put(&pgrp_pool, pgrp);
911 }
912
913 /*
914 * delete a process group
915 */
916 static void
917 pg_delete(pid_t pg_id)
918 {
919 struct pgrp *pgrp;
920 struct tty *ttyp;
921 struct session *ss;
922 int s, is_pgrp_leader;
923
924 s = proclist_lock_write();
925 pgrp = pid_table[pg_id & pid_tbl_mask].pt_pgrp;
926 if (pgrp == NULL || pgrp->pg_id != pg_id ||
927 !LIST_EMPTY(&pgrp->pg_members)) {
928 proclist_unlock_write(s);
929 return;
930 }
931
932 ss = pgrp->pg_session;
933
934 /* Remove reference (if any) from tty to this process group */
935 ttyp = ss->s_ttyp;
936 if (ttyp != NULL && ttyp->t_pgrp == pgrp) {
937 ttyp->t_pgrp = NULL;
938 #ifdef DIAGNOSTIC
939 if (ttyp->t_session != ss)
940 panic("pg_delete: wrong session on terminal");
941 #endif
942 }
943
944 /*
945 * The leading process group in a session is freed
946 * by sessdelete() if last reference.
947 */
948 is_pgrp_leader = (ss->s_sid == pgrp->pg_id);
949 proclist_unlock_write(s);
950 SESSRELE(ss);
951
952 if (is_pgrp_leader)
953 return;
954
955 pg_free(pg_id);
956 }
957
958 /*
959 * Delete session - called from SESSRELE when s_count becomes zero.
960 */
961 void
962 sessdelete(struct session *ss)
963 {
964 /*
965 * We keep the pgrp with the same id as the session in
966 * order to stop a process being given the same pid.
967 * Since the pgrp holds a reference to the session, it
968 * must be a 'zombie' pgrp by now.
969 */
970
971 pg_free(ss->s_sid);
972
973 pool_put(&session_pool, ss);
974 }
975
976 /*
977 * Adjust pgrp jobc counters when specified process changes process group.
978 * We count the number of processes in each process group that "qualify"
979 * the group for terminal job control (those with a parent in a different
980 * process group of the same session). If that count reaches zero, the
981 * process group becomes orphaned. Check both the specified process'
982 * process group and that of its children.
983 * entering == 0 => p is leaving specified group.
984 * entering == 1 => p is entering specified group.
985 *
986 * Call with proclist_lock held.
987 */
988 void
989 fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
990 {
991 struct pgrp *hispgrp;
992 struct session *mysession = pgrp->pg_session;
993 struct proc *child;
994
995 /*
996 * Check p's parent to see whether p qualifies its own process
997 * group; if so, adjust count for p's process group.
998 */
999 hispgrp = p->p_pptr->p_pgrp;
1000 if (hispgrp != pgrp && hispgrp->pg_session == mysession) {
1001 if (entering)
1002 pgrp->pg_jobc++;
1003 else if (--pgrp->pg_jobc == 0)
1004 orphanpg(pgrp);
1005 }
1006
1007 /*
1008 * Check this process' children to see whether they qualify
1009 * their process groups; if so, adjust counts for children's
1010 * process groups.
1011 */
1012 LIST_FOREACH(child, &p->p_children, p_sibling) {
1013 hispgrp = child->p_pgrp;
1014 if (hispgrp != pgrp && hispgrp->pg_session == mysession &&
1015 !P_ZOMBIE(child)) {
1016 if (entering)
1017 hispgrp->pg_jobc++;
1018 else if (--hispgrp->pg_jobc == 0)
1019 orphanpg(hispgrp);
1020 }
1021 }
1022 }
1023
1024 /*
1025 * A process group has become orphaned;
1026 * if there are any stopped processes in the group,
1027 * hang-up all process in that group.
1028 *
1029 * Call with proclist_lock held.
1030 */
1031 static void
1032 orphanpg(struct pgrp *pg)
1033 {
1034 struct proc *p;
1035
1036 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
1037 if (p->p_stat == SSTOP) {
1038 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
1039 psignal(p, SIGHUP);
1040 psignal(p, SIGCONT);
1041 }
1042 return;
1043 }
1044 }
1045 }
1046
1047 /* mark process as suid/sgid, reset some values to defaults */
1048 void
1049 p_sugid(struct proc *p)
1050 {
1051 struct plimit *lim;
1052 char *cn;
1053
1054 p->p_flag |= P_SUGID;
1055 /* reset what needs to be reset in plimit */
1056 lim = p->p_limit;
1057 if (lim->pl_corename != defcorename) {
1058 if (lim->p_refcnt > 1 &&
1059 (lim->p_lflags & PL_SHAREMOD) == 0) {
1060 p->p_limit = limcopy(lim);
1061 limfree(lim);
1062 lim = p->p_limit;
1063 }
1064 simple_lock(&lim->p_slock);
1065 cn = lim->pl_corename;
1066 lim->pl_corename = defcorename;
1067 simple_unlock(&lim->p_slock);
1068 if (cn != defcorename)
1069 free(cn, M_TEMP);
1070 }
1071 }
1072
1073 #ifdef DDB
1074 #include <ddb/db_output.h>
1075 void pidtbl_dump(void);
1076 void
1077 pidtbl_dump(void)
1078 {
1079 struct pid_table *pt;
1080 struct proc *p;
1081 struct pgrp *pgrp;
1082 int id;
1083
1084 db_printf("pid table %p size %x, next %x, last %x\n",
1085 pid_table, pid_tbl_mask+1,
1086 next_free_pt, last_free_pt);
1087 for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) {
1088 p = pt->pt_proc;
1089 if (!P_VALID(p) && !pt->pt_pgrp)
1090 continue;
1091 db_printf(" id %x: ", id);
1092 if (P_VALID(p))
1093 db_printf("proc %p id %d (0x%x) %s\n",
1094 p, p->p_pid, p->p_pid, p->p_comm);
1095 else
1096 db_printf("next %x use %x\n",
1097 P_NEXT(p) & pid_tbl_mask,
1098 P_NEXT(p) & ~pid_tbl_mask);
1099 if ((pgrp = pt->pt_pgrp)) {
1100 db_printf("\tsession %p, sid %d, count %d, login %s\n",
1101 pgrp->pg_session, pgrp->pg_session->s_sid,
1102 pgrp->pg_session->s_count,
1103 pgrp->pg_session->s_login);
1104 db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n",
1105 pgrp, pgrp->pg_id, pgrp->pg_jobc,
1106 pgrp->pg_members.lh_first);
1107 for (p = pgrp->pg_members.lh_first; p != 0;
1108 p = p->p_pglist.le_next) {
1109 db_printf("\t\tpid %d addr %p pgrp %p %s\n",
1110 p->p_pid, p, p->p_pgrp, p->p_comm);
1111 }
1112 }
1113 }
1114 }
1115 #endif /* DDB */
1116
1117 #ifdef KSTACK_CHECK_MAGIC
1118 #include <sys/user.h>
1119
1120 #define KSTACK_MAGIC 0xdeadbeaf
1121
1122 /* XXX should be per process basis? */
1123 int kstackleftmin = KSTACK_SIZE;
1124 int kstackleftthres = KSTACK_SIZE / 8; /* warn if remaining stack is
1125 less than this */
1126
1127 void
1128 kstack_setup_magic(const struct lwp *l)
1129 {
1130 uint32_t *ip;
1131 uint32_t const *end;
1132
1133 KASSERT(l != NULL);
1134 KASSERT(l != &lwp0);
1135
1136 /*
1137 * fill all the stack with magic number
1138 * so that later modification on it can be detected.
1139 */
1140 ip = (uint32_t *)KSTACK_LOWEST_ADDR(l);
1141 end = (uint32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1142 for (; ip < end; ip++) {
1143 *ip = KSTACK_MAGIC;
1144 }
1145 }
1146
1147 void
1148 kstack_check_magic(const struct lwp *l)
1149 {
1150 uint32_t const *ip, *end;
1151 int stackleft;
1152
1153 KASSERT(l != NULL);
1154
1155 /* don't check proc0 */ /*XXX*/
1156 if (l == &lwp0)
1157 return;
1158
1159 #ifdef __MACHINE_STACK_GROWS_UP
1160 /* stack grows upwards (eg. hppa) */
1161 ip = (uint32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1162 end = (uint32_t *)KSTACK_LOWEST_ADDR(l);
1163 for (ip--; ip >= end; ip--)
1164 if (*ip != KSTACK_MAGIC)
1165 break;
1166
1167 stackleft = (caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (caddr_t)ip;
1168 #else /* __MACHINE_STACK_GROWS_UP */
1169 /* stack grows downwards (eg. i386) */
1170 ip = (uint32_t *)KSTACK_LOWEST_ADDR(l);
1171 end = (uint32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1172 for (; ip < end; ip++)
1173 if (*ip != KSTACK_MAGIC)
1174 break;
1175
1176 stackleft = ((const char *)ip) - (const char *)KSTACK_LOWEST_ADDR(l);
1177 #endif /* __MACHINE_STACK_GROWS_UP */
1178
1179 if (kstackleftmin > stackleft) {
1180 kstackleftmin = stackleft;
1181 if (stackleft < kstackleftthres)
1182 printf("warning: kernel stack left %d bytes"
1183 "(pid %u:lid %u)\n", stackleft,
1184 (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
1185 }
1186
1187 if (stackleft <= 0) {
1188 panic("magic on the top of kernel stack changed for "
1189 "pid %u, lid %u: maybe kernel stack overflow",
1190 (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
1191 }
1192 }
1193 #endif /* KSTACK_CHECK_MAGIC */
1194
1195 /* XXX shouldn't be here */
1196 #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
1197 #define PROCLIST_ASSERT_LOCKED_READ() \
1198 KASSERT(lockstatus(&proclist_lock) == LK_SHARED)
1199 #else
1200 #define PROCLIST_ASSERT_LOCKED_READ() /* nothing */
1201 #endif
1202
1203 int
1204 proclist_foreach_call(struct proclist *list,
1205 int (*callback)(struct proc *, void *arg), void *arg)
1206 {
1207 struct proc marker;
1208 struct proc *p;
1209 struct lwp * const l = curlwp;
1210 int ret = 0;
1211
1212 marker.p_flag = P_MARKER;
1213 PHOLD(l);
1214 proclist_lock_read();
1215 for (p = LIST_FIRST(list); ret == 0 && p != NULL;) {
1216 if (p->p_flag & P_MARKER) {
1217 p = LIST_NEXT(p, p_list);
1218 continue;
1219 }
1220 LIST_INSERT_AFTER(p, &marker, p_list);
1221 ret = (*callback)(p, arg);
1222 PROCLIST_ASSERT_LOCKED_READ();
1223 p = LIST_NEXT(&marker, p_list);
1224 LIST_REMOVE(&marker, p_list);
1225 }
1226 proclist_unlock_read();
1227 PRELE(l);
1228
1229 return ret;
1230 }
1231
1232 int
1233 proc_vmspace_getref(struct proc *p, struct vmspace **vm)
1234 {
1235
1236 /* XXXCDC: how should locking work here? */
1237
1238 /* curproc exception is for coredump. */
1239
1240 if ((p != curproc && (p->p_flag & P_WEXIT) != 0) ||
1241 (p->p_vmspace->vm_refcnt < 1)) { /* XXX */
1242 return EFAULT;
1243 }
1244
1245 uvmspace_addref(p->p_vmspace);
1246 *vm = p->p_vmspace;
1247
1248 return 0;
1249 }
1250
1251 /*
1252 * Acquire a write lock on the process credential.
1253 */
1254 void
1255 proc_crmod_enter(struct proc *p)
1256 {
1257
1258 /*
1259 * XXXSMP This should be a lightweight sleep lock. 'struct lock' is
1260 * too large.
1261 */
1262 simple_lock(&p->p_lock);
1263 while ((p->p_flag & P_CRLOCK) != 0)
1264 ltsleep(&p->p_cred, PLOCK, "crlock", 0, &p->p_lock);
1265 p->p_flag |= P_CRLOCK;
1266 simple_unlock(&p->p_lock);
1267 }
1268
1269 /*
1270 * Block out readers, set in a new process credential, and drop the write
1271 * lock. The credential must have a reference already. Optionally, free a
1272 * no-longer required credential.
1273 */
1274 void
1275 proc_crmod_leave(struct proc *p, kauth_cred_t scred, kauth_cred_t fcred)
1276 {
1277
1278 KDASSERT((p->p_flag & P_CRLOCK) != 0);
1279 simple_lock(&p->p_lock);
1280 p->p_cred = scred;
1281 p->p_flag &= ~P_CRLOCK;
1282 simple_unlock(&p->p_lock);
1283 wakeup(&p->p_cred);
1284 if (fcred != NULL)
1285 kauth_cred_free(fcred);
1286 }
1287
1288 /*
1289 * proc_specific_key_create --
1290 * Create a key for subsystem proc-specific data.
1291 */
1292 int
1293 proc_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor)
1294 {
1295
1296 return (specificdata_key_create(proc_specificdata_domain, keyp, dtor));
1297 }
1298
1299 /*
1300 * proc_specific_key_delete --
1301 * Delete a key for subsystem proc-specific data.
1302 */
1303 void
1304 proc_specific_key_delete(specificdata_key_t key)
1305 {
1306
1307 specificdata_key_delete(proc_specificdata_domain, key);
1308 }
1309
1310 /*
1311 * proc_initspecific --
1312 * Initialize a proc's specificdata container.
1313 */
1314 void
1315 proc_initspecific(struct proc *p)
1316 {
1317 int error;
1318
1319 error = specificdata_init(proc_specificdata_domain, &p->p_specdataref);
1320 KASSERT(error == 0);
1321 }
1322
1323 /*
1324 * proc_finispecific --
1325 * Finalize a proc's specificdata container.
1326 */
1327 void
1328 proc_finispecific(struct proc *p)
1329 {
1330
1331 specificdata_fini(proc_specificdata_domain, &p->p_specdataref);
1332 }
1333
1334 /*
1335 * proc_getspecific --
1336 * Return proc-specific data corresponding to the specified key.
1337 */
1338 void *
1339 proc_getspecific(struct proc *p, specificdata_key_t key)
1340 {
1341
1342 return (specificdata_getspecific(proc_specificdata_domain,
1343 &p->p_specdataref, key));
1344 }
1345
1346 /*
1347 * proc_setspecific --
1348 * Set proc-specific data corresponding to the specified key.
1349 */
1350 void
1351 proc_setspecific(struct proc *p, specificdata_key_t key, void *data)
1352 {
1353
1354 specificdata_setspecific(proc_specificdata_domain,
1355 &p->p_specdataref, key, data);
1356 }
Cache object: 4278258e3277e325959ebee57176ecb8
|