kern_proc.c revision 1.247 1 1.247 thorpej /* $NetBSD: kern_proc.c,v 1.247 2020/04/24 03:22:06 thorpej Exp $ */
2 1.33 thorpej
3 1.33 thorpej /*-
4 1.242 ad * Copyright (c) 1999, 2006, 2007, 2008, 2020 The NetBSD Foundation, Inc.
5 1.33 thorpej * All rights reserved.
6 1.33 thorpej *
7 1.33 thorpej * This code is derived from software contributed to The NetBSD Foundation
8 1.33 thorpej * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 1.100 ad * NASA Ames Research Center, and by Andrew Doran.
10 1.33 thorpej *
11 1.33 thorpej * Redistribution and use in source and binary forms, with or without
12 1.33 thorpej * modification, are permitted provided that the following conditions
13 1.33 thorpej * are met:
14 1.33 thorpej * 1. Redistributions of source code must retain the above copyright
15 1.33 thorpej * notice, this list of conditions and the following disclaimer.
16 1.33 thorpej * 2. Redistributions in binary form must reproduce the above copyright
17 1.33 thorpej * notice, this list of conditions and the following disclaimer in the
18 1.33 thorpej * documentation and/or other materials provided with the distribution.
19 1.33 thorpej *
20 1.33 thorpej * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 1.33 thorpej * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 1.33 thorpej * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 1.33 thorpej * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 1.33 thorpej * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 1.33 thorpej * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 1.33 thorpej * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 1.33 thorpej * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 1.33 thorpej * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 1.33 thorpej * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 1.33 thorpej * POSSIBILITY OF SUCH DAMAGE.
31 1.33 thorpej */
32 1.9 cgd
33 1.1 cgd /*
34 1.7 cgd * Copyright (c) 1982, 1986, 1989, 1991, 1993
35 1.7 cgd * The Regents of the University of California. All rights reserved.
36 1.1 cgd *
37 1.1 cgd * Redistribution and use in source and binary forms, with or without
38 1.1 cgd * modification, are permitted provided that the following conditions
39 1.1 cgd * are met:
40 1.1 cgd * 1. Redistributions of source code must retain the above copyright
41 1.1 cgd * notice, this list of conditions and the following disclaimer.
42 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
43 1.1 cgd * notice, this list of conditions and the following disclaimer in the
44 1.1 cgd * documentation and/or other materials provided with the distribution.
45 1.65 agc * 3. Neither the name of the University nor the names of its contributors
46 1.1 cgd * may be used to endorse or promote products derived from this software
47 1.1 cgd * without specific prior written permission.
48 1.1 cgd *
49 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 1.1 cgd * SUCH DAMAGE.
60 1.1 cgd *
61 1.23 fvdl * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
62 1.1 cgd */
63 1.45 lukem
64 1.45 lukem #include <sys/cdefs.h>
65 1.247 thorpej __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.247 2020/04/24 03:22:06 thorpej Exp $");
66 1.48 yamt
67 1.165 pooka #ifdef _KERNEL_OPT
68 1.48 yamt #include "opt_kstack.h"
69 1.88 onoe #include "opt_maxuprc.h"
70 1.161 darran #include "opt_dtrace.h"
71 1.171 pooka #include "opt_compat_netbsd32.h"
72 1.222 christos #include "opt_kaslr.h"
73 1.165 pooka #endif
74 1.1 cgd
75 1.205 christos #if defined(__HAVE_COMPAT_NETBSD32) && !defined(COMPAT_NETBSD32) \
76 1.205 christos && !defined(_RUMPKERNEL)
77 1.205 christos #define COMPAT_NETBSD32
78 1.205 christos #endif
79 1.205 christos
80 1.5 mycroft #include <sys/param.h>
81 1.5 mycroft #include <sys/systm.h>
82 1.5 mycroft #include <sys/kernel.h>
83 1.5 mycroft #include <sys/proc.h>
84 1.28 thorpej #include <sys/resourcevar.h>
85 1.5 mycroft #include <sys/buf.h>
86 1.5 mycroft #include <sys/acct.h>
87 1.5 mycroft #include <sys/wait.h>
88 1.5 mycroft #include <sys/file.h>
89 1.8 mycroft #include <ufs/ufs/quota.h>
90 1.5 mycroft #include <sys/uio.h>
91 1.24 thorpej #include <sys/pool.h>
92 1.147 rmind #include <sys/pset.h>
93 1.5 mycroft #include <sys/ioctl.h>
94 1.5 mycroft #include <sys/tty.h>
95 1.11 cgd #include <sys/signalvar.h>
96 1.51 gmcgarry #include <sys/ras.h>
97 1.81 junyoung #include <sys/filedesc.h>
98 1.185 martin #include <sys/syscall_stats.h>
99 1.89 elad #include <sys/kauth.h>
100 1.100 ad #include <sys/sleepq.h>
101 1.126 ad #include <sys/atomic.h>
102 1.131 ad #include <sys/kmem.h>
103 1.194 christos #include <sys/namei.h>
104 1.160 darran #include <sys/dtrace_bsd.h>
105 1.170 pooka #include <sys/sysctl.h>
106 1.170 pooka #include <sys/exec.h>
107 1.170 pooka #include <sys/cpu.h>
108 1.225 pgoyette #include <sys/compat_stub.h>
109 1.160 darran
110 1.169 uebayasi #include <uvm/uvm_extern.h>
111 1.194 christos #include <uvm/uvm.h>
112 1.5 mycroft
113 1.7 cgd /*
114 1.180 rmind * Process lists.
115 1.7 cgd */
116 1.31 thorpej
117 1.180 rmind struct proclist allproc __cacheline_aligned;
118 1.180 rmind struct proclist zombproc __cacheline_aligned;
119 1.32 thorpej
120 1.247 thorpej static kmutex_t proc_lock_s __cacheline_aligned;
121 1.247 thorpej kmutex_t * proc_lock __read_mostly;
122 1.33 thorpej
123 1.33 thorpej /*
124 1.247 thorpej * pid to lwp/proc lookup is done by indexing the pid_table array.
125 1.61 dsl * Since pid numbers are only allocated when an empty slot
126 1.61 dsl * has been found, there is no need to search any lists ever.
127 1.61 dsl * (an orphaned pgrp will lock the slot, a session will lock
128 1.61 dsl * the pgrp with the same number.)
129 1.61 dsl * If the table is too small it is reallocated with twice the
130 1.61 dsl * previous size and the entries 'unzipped' into the two halves.
131 1.247 thorpej * A linked list of free entries is passed through the pt_lwp
132 1.247 thorpej * field of 'free' items - set odd to be an invalid ptr. Two
133 1.247 thorpej * additional bits are also used to indicate if the slot is
134 1.247 thorpej * currently occupied by a proc or lwp, and if the PID is
135 1.247 thorpej * hidden from certain kinds of lookups. We thus require a
136 1.247 thorpej * minimum alignment for proc and lwp structures (LWPs are
137 1.247 thorpej * at least 32-byte aligned).
138 1.61 dsl */
139 1.61 dsl
140 1.61 dsl struct pid_table {
141 1.247 thorpej uintptr_t pt_slot;
142 1.61 dsl struct pgrp *pt_pgrp;
143 1.168 chs pid_t pt_pid;
144 1.72 junyoung };
145 1.247 thorpej
146 1.247 thorpej #define PT_F_FREE __BIT(0)
147 1.247 thorpej #define PT_F_LWP 0 /* pseudo-flag */
148 1.247 thorpej #define PT_F_PROC __BIT(1)
149 1.247 thorpej #define PT_F_HIDDEN __BIT(2)
150 1.247 thorpej
151 1.247 thorpej #define PT_F_TYPEBITS (PT_F_FREE|PT_F_PROC)
152 1.247 thorpej #define PT_F_ALLBITS (PT_F_FREE|PT_F_PROC|PT_F_HIDDEN)
153 1.247 thorpej
154 1.247 thorpej #define PT_VALID(s) (((s) & PT_F_FREE) == 0)
155 1.247 thorpej #define PT_RESERVED(s) ((s) == 0)
156 1.247 thorpej #define PT_HIDDEN(s) ((s) & PT_F_HIDDEN)
157 1.247 thorpej #define PT_NEXT(s) ((u_int)(s) >> 1)
158 1.247 thorpej #define PT_SET_FREE(pid) (((pid) << 1) | PT_F_FREE)
159 1.247 thorpej #define PT_SET_HIDDEN(s) ((s) | PT_F_HIDDEN)
160 1.247 thorpej #define PT_SET_LWP(l) ((uintptr_t)(l))
161 1.247 thorpej #define PT_SET_PROC(p) (((uintptr_t)(p)) | PT_F_PROC)
162 1.247 thorpej #define PT_SET_RESERVED 0
163 1.247 thorpej #define PT_GET_LWP(s) ((struct lwp *)((s) & ~PT_F_ALLBITS))
164 1.247 thorpej #define PT_GET_PROC(s) ((struct proc *)((s) & ~PT_F_ALLBITS))
165 1.247 thorpej #define PT_GET_TYPE(s) ((s) & PT_F_TYPEBITS)
166 1.247 thorpej #define PT_IS_LWP(s) (PT_GET_TYPE(s) == PT_F_LWP && (s) != 0)
167 1.247 thorpej #define PT_IS_PROC(s) (PT_GET_TYPE(s) == PT_F_PROC)
168 1.247 thorpej
169 1.247 thorpej #define MIN_PROC_ALIGNMENT (PT_F_ALLBITS + 1)
170 1.61 dsl
171 1.180 rmind /*
172 1.180 rmind * Table of process IDs (PIDs).
173 1.247 thorpej *
174 1.247 thorpej * Locking order:
175 1.247 thorpej * proc_lock -> pid_table_lock
176 1.247 thorpej * or
177 1.247 thorpej * proc::p_lock -> pid_table_lock
178 1.180 rmind */
179 1.247 thorpej static krwlock_t pid_table_lock __cacheline_aligned;
180 1.180 rmind static struct pid_table *pid_table __read_mostly;
181 1.180 rmind
182 1.180 rmind #define INITIAL_PID_TABLE_SIZE (1 << 5)
183 1.180 rmind
184 1.180 rmind /* Table mask, threshold for growing and number of allocated PIDs. */
185 1.180 rmind static u_int pid_tbl_mask __read_mostly;
186 1.180 rmind static u_int pid_alloc_lim __read_mostly;
187 1.180 rmind static u_int pid_alloc_cnt __cacheline_aligned;
188 1.180 rmind
189 1.180 rmind /* Next free, last free and maximum PIDs. */
190 1.180 rmind static u_int next_free_pt __cacheline_aligned;
191 1.180 rmind static u_int last_free_pt __cacheline_aligned;
192 1.180 rmind static pid_t pid_max __read_mostly;
193 1.31 thorpej
194 1.81 junyoung /* Components of the first process -- never freed. */
195 1.123 matt
196 1.145 ad extern struct emul emul_netbsd; /* defined in kern_exec.c */
197 1.123 matt
198 1.123 matt struct session session0 = {
199 1.123 matt .s_count = 1,
200 1.123 matt .s_sid = 0,
201 1.123 matt };
202 1.123 matt struct pgrp pgrp0 = {
203 1.123 matt .pg_members = LIST_HEAD_INITIALIZER(&pgrp0.pg_members),
204 1.123 matt .pg_session = &session0,
205 1.123 matt };
206 1.132 ad filedesc_t filedesc0;
207 1.123 matt struct cwdinfo cwdi0 = {
208 1.187 pooka .cwdi_cmask = CMASK,
209 1.123 matt .cwdi_refcnt = 1,
210 1.123 matt };
211 1.143 gmcgarry struct plimit limit0;
212 1.81 junyoung struct pstats pstat0;
213 1.81 junyoung struct vmspace vmspace0;
214 1.81 junyoung struct sigacts sigacts0;
215 1.123 matt struct proc proc0 = {
216 1.123 matt .p_lwps = LIST_HEAD_INITIALIZER(&proc0.p_lwps),
217 1.123 matt .p_sigwaiters = LIST_HEAD_INITIALIZER(&proc0.p_sigwaiters),
218 1.123 matt .p_nlwps = 1,
219 1.123 matt .p_nrlwps = 1,
220 1.123 matt .p_pgrp = &pgrp0,
221 1.123 matt .p_comm = "system",
222 1.123 matt /*
223 1.123 matt * Set P_NOCLDWAIT so that kernel threads are reparented to init(8)
224 1.123 matt * when they exit. init(8) can easily wait them out for us.
225 1.123 matt */
226 1.123 matt .p_flag = PK_SYSTEM | PK_NOCLDWAIT,
227 1.123 matt .p_stat = SACTIVE,
228 1.123 matt .p_nice = NZERO,
229 1.123 matt .p_emul = &emul_netbsd,
230 1.123 matt .p_cwdi = &cwdi0,
231 1.123 matt .p_limit = &limit0,
232 1.132 ad .p_fd = &filedesc0,
233 1.123 matt .p_vmspace = &vmspace0,
234 1.123 matt .p_stats = &pstat0,
235 1.123 matt .p_sigacts = &sigacts0,
236 1.188 matt #ifdef PROC0_MD_INITIALIZERS
237 1.188 matt PROC0_MD_INITIALIZERS
238 1.188 matt #endif
239 1.123 matt };
240 1.123 matt kauth_cred_t cred0;
241 1.81 junyoung
242 1.180 rmind static const int nofile = NOFILE;
243 1.180 rmind static const int maxuprc = MAXUPRC;
244 1.81 junyoung
245 1.170 pooka static int sysctl_doeproc(SYSCTLFN_PROTO);
246 1.170 pooka static int sysctl_kern_proc_args(SYSCTLFN_PROTO);
247 1.222 christos static int sysctl_security_expose_address(SYSCTLFN_PROTO);
248 1.170 pooka
249 1.222 christos #ifdef KASLR
250 1.223 christos static int kern_expose_address = 0;
251 1.222 christos #else
252 1.222 christos static int kern_expose_address = 1;
253 1.222 christos #endif
254 1.31 thorpej /*
255 1.31 thorpej * The process list descriptors, used during pid allocation and
256 1.31 thorpej * by sysctl. No locking on this data structure is needed since
257 1.31 thorpej * it is completely static.
258 1.31 thorpej */
259 1.31 thorpej const struct proclist_desc proclists[] = {
260 1.31 thorpej { &allproc },
261 1.31 thorpej { &zombproc },
262 1.31 thorpej { NULL },
263 1.31 thorpej };
264 1.31 thorpej
265 1.151 rmind static struct pgrp * pg_remove(pid_t);
266 1.151 rmind static void pg_delete(pid_t);
267 1.151 rmind static void orphanpg(struct pgrp *);
268 1.13 christos
269 1.95 thorpej static specificdata_domain_t proc_specificdata_domain;
270 1.95 thorpej
271 1.128 ad static pool_cache_t proc_cache;
272 1.128 ad
273 1.153 elad static kauth_listener_t proc_listener;
274 1.153 elad
275 1.222 christos static void fill_proc(const struct proc *, struct proc *, bool);
276 1.194 christos static int fill_pathname(struct lwp *, pid_t, void *, size_t *);
277 1.229 kamil static int fill_cwd(struct lwp *, pid_t, void *, size_t *);
278 1.194 christos
279 1.153 elad static int
280 1.153 elad proc_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
281 1.153 elad void *arg0, void *arg1, void *arg2, void *arg3)
282 1.153 elad {
283 1.153 elad struct proc *p;
284 1.153 elad int result;
285 1.153 elad
286 1.153 elad result = KAUTH_RESULT_DEFER;
287 1.153 elad p = arg0;
288 1.153 elad
289 1.153 elad switch (action) {
290 1.153 elad case KAUTH_PROCESS_CANSEE: {
291 1.153 elad enum kauth_process_req req;
292 1.153 elad
293 1.241 joerg req = (enum kauth_process_req)(uintptr_t)arg1;
294 1.153 elad
295 1.153 elad switch (req) {
296 1.153 elad case KAUTH_REQ_PROCESS_CANSEE_ARGS:
297 1.153 elad case KAUTH_REQ_PROCESS_CANSEE_ENTRY:
298 1.153 elad case KAUTH_REQ_PROCESS_CANSEE_OPENFILES:
299 1.213 maxv case KAUTH_REQ_PROCESS_CANSEE_EPROC:
300 1.153 elad result = KAUTH_RESULT_ALLOW;
301 1.153 elad break;
302 1.153 elad
303 1.153 elad case KAUTH_REQ_PROCESS_CANSEE_ENV:
304 1.153 elad if (kauth_cred_getuid(cred) !=
305 1.153 elad kauth_cred_getuid(p->p_cred) ||
306 1.153 elad kauth_cred_getuid(cred) !=
307 1.153 elad kauth_cred_getsvuid(p->p_cred))
308 1.153 elad break;
309 1.153 elad
310 1.153 elad result = KAUTH_RESULT_ALLOW;
311 1.153 elad
312 1.153 elad break;
313 1.153 elad
314 1.215 maxv case KAUTH_REQ_PROCESS_CANSEE_KPTR:
315 1.222 christos if (!kern_expose_address)
316 1.222 christos break;
317 1.222 christos
318 1.222 christos if (kern_expose_address == 1 && !(p->p_flag & PK_KMEM))
319 1.222 christos break;
320 1.222 christos
321 1.222 christos result = KAUTH_RESULT_ALLOW;
322 1.222 christos
323 1.222 christos break;
324 1.222 christos
325 1.153 elad default:
326 1.153 elad break;
327 1.153 elad }
328 1.153 elad
329 1.153 elad break;
330 1.153 elad }
331 1.153 elad
332 1.153 elad case KAUTH_PROCESS_FORK: {
333 1.153 elad int lnprocs = (int)(unsigned long)arg2;
334 1.153 elad
335 1.153 elad /*
336 1.153 elad * Don't allow a nonprivileged user to use the last few
337 1.153 elad * processes. The variable lnprocs is the current number of
338 1.153 elad * processes, maxproc is the limit.
339 1.153 elad */
340 1.153 elad if (__predict_false((lnprocs >= maxproc - 5)))
341 1.153 elad break;
342 1.153 elad
343 1.153 elad result = KAUTH_RESULT_ALLOW;
344 1.153 elad
345 1.153 elad break;
346 1.153 elad }
347 1.153 elad
348 1.153 elad case KAUTH_PROCESS_CORENAME:
349 1.153 elad case KAUTH_PROCESS_STOPFLAG:
350 1.153 elad if (proc_uidmatch(cred, p->p_cred) == 0)
351 1.153 elad result = KAUTH_RESULT_ALLOW;
352 1.153 elad
353 1.153 elad break;
354 1.153 elad
355 1.153 elad default:
356 1.153 elad break;
357 1.153 elad }
358 1.153 elad
359 1.153 elad return result;
360 1.153 elad }
361 1.153 elad
362 1.221 christos static int
363 1.221 christos proc_ctor(void *arg __unused, void *obj, int flags __unused)
364 1.221 christos {
365 1.221 christos memset(obj, 0, sizeof(struct proc));
366 1.221 christos return 0;
367 1.221 christos }
368 1.221 christos
369 1.247 thorpej static pid_t proc_alloc_pid_slot(struct proc *, uintptr_t);
370 1.247 thorpej
371 1.10 mycroft /*
372 1.10 mycroft * Initialize global process hashing structures.
373 1.10 mycroft */
374 1.11 cgd void
375 1.59 dsl procinit(void)
376 1.7 cgd {
377 1.31 thorpej const struct proclist_desc *pd;
378 1.150 rmind u_int i;
379 1.61 dsl #define LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1))
380 1.31 thorpej
381 1.31 thorpej for (pd = proclists; pd->pd_list != NULL; pd++)
382 1.31 thorpej LIST_INIT(pd->pd_list);
383 1.7 cgd
384 1.247 thorpej mutex_init(&proc_lock_s, MUTEX_DEFAULT, IPL_NONE);
385 1.247 thorpej proc_lock = &proc_lock_s;
386 1.247 thorpej
387 1.247 thorpej rw_init(&pid_table_lock);
388 1.247 thorpej
389 1.150 rmind pid_table = kmem_alloc(INITIAL_PID_TABLE_SIZE
390 1.150 rmind * sizeof(struct pid_table), KM_SLEEP);
391 1.180 rmind pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1;
392 1.180 rmind pid_max = PID_MAX;
393 1.33 thorpej
394 1.61 dsl /* Set free list running through table...
395 1.61 dsl Preset 'use count' above PID_MAX so we allocate pid 1 next. */
396 1.61 dsl for (i = 0; i <= pid_tbl_mask; i++) {
397 1.247 thorpej pid_table[i].pt_slot = PT_SET_FREE(LINK_EMPTY + i + 1);
398 1.61 dsl pid_table[i].pt_pgrp = 0;
399 1.168 chs pid_table[i].pt_pid = 0;
400 1.61 dsl }
401 1.61 dsl /* slot 0 is just grabbed */
402 1.61 dsl next_free_pt = 1;
403 1.61 dsl /* Need to fix last entry. */
404 1.61 dsl last_free_pt = pid_tbl_mask;
405 1.247 thorpej pid_table[last_free_pt].pt_slot = PT_SET_FREE(LINK_EMPTY);
406 1.61 dsl /* point at which we grow table - to avoid reusing pids too often */
407 1.61 dsl pid_alloc_lim = pid_tbl_mask - 1;
408 1.61 dsl #undef LINK_EMPTY
409 1.61 dsl
410 1.247 thorpej /* Reserve PID 1 for init(8). */ /* XXX slightly gross */
411 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
412 1.247 thorpej if (proc_alloc_pid_slot(&proc0, PT_SET_RESERVED) != 1)
413 1.247 thorpej panic("failed to reserve PID 1 for init(8)");
414 1.247 thorpej rw_exit(&pid_table_lock);
415 1.247 thorpej
416 1.95 thorpej proc_specificdata_domain = specificdata_domain_create();
417 1.95 thorpej KASSERT(proc_specificdata_domain != NULL);
418 1.128 ad
419 1.247 thorpej size_t proc_alignment = coherency_unit;
420 1.247 thorpej if (proc_alignment < MIN_PROC_ALIGNMENT)
421 1.247 thorpej proc_alignment = MIN_PROC_ALIGNMENT;
422 1.247 thorpej
423 1.247 thorpej proc_cache = pool_cache_init(sizeof(struct proc), proc_alignment, 0, 0,
424 1.221 christos "procpl", NULL, IPL_NONE, proc_ctor, NULL, NULL);
425 1.153 elad
426 1.153 elad proc_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS,
427 1.153 elad proc_listener_cb, NULL);
428 1.7 cgd }
429 1.1 cgd
430 1.170 pooka void
431 1.170 pooka procinit_sysctl(void)
432 1.170 pooka {
433 1.170 pooka static struct sysctllog *clog;
434 1.170 pooka
435 1.170 pooka sysctl_createv(&clog, 0, NULL, NULL,
436 1.222 christos CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
437 1.222 christos CTLTYPE_INT, "expose_address",
438 1.222 christos SYSCTL_DESCR("Enable exposing kernel addresses"),
439 1.222 christos sysctl_security_expose_address, 0,
440 1.222 christos &kern_expose_address, 0, CTL_KERN, CTL_CREATE, CTL_EOL);
441 1.222 christos sysctl_createv(&clog, 0, NULL, NULL,
442 1.170 pooka CTLFLAG_PERMANENT,
443 1.170 pooka CTLTYPE_NODE, "proc",
444 1.170 pooka SYSCTL_DESCR("System-wide process information"),
445 1.170 pooka sysctl_doeproc, 0, NULL, 0,
446 1.170 pooka CTL_KERN, KERN_PROC, CTL_EOL);
447 1.170 pooka sysctl_createv(&clog, 0, NULL, NULL,
448 1.170 pooka CTLFLAG_PERMANENT,
449 1.170 pooka CTLTYPE_NODE, "proc2",
450 1.170 pooka SYSCTL_DESCR("Machine-independent process information"),
451 1.170 pooka sysctl_doeproc, 0, NULL, 0,
452 1.170 pooka CTL_KERN, KERN_PROC2, CTL_EOL);
453 1.170 pooka sysctl_createv(&clog, 0, NULL, NULL,
454 1.170 pooka CTLFLAG_PERMANENT,
455 1.170 pooka CTLTYPE_NODE, "proc_args",
456 1.170 pooka SYSCTL_DESCR("Process argument information"),
457 1.170 pooka sysctl_kern_proc_args, 0, NULL, 0,
458 1.170 pooka CTL_KERN, KERN_PROC_ARGS, CTL_EOL);
459 1.170 pooka
460 1.170 pooka /*
461 1.170 pooka "nodes" under these:
462 1.170 pooka
463 1.170 pooka KERN_PROC_ALL
464 1.170 pooka KERN_PROC_PID pid
465 1.170 pooka KERN_PROC_PGRP pgrp
466 1.170 pooka KERN_PROC_SESSION sess
467 1.170 pooka KERN_PROC_TTY tty
468 1.170 pooka KERN_PROC_UID uid
469 1.170 pooka KERN_PROC_RUID uid
470 1.170 pooka KERN_PROC_GID gid
471 1.170 pooka KERN_PROC_RGID gid
472 1.170 pooka
473 1.170 pooka all in all, probably not worth the effort...
474 1.170 pooka */
475 1.170 pooka }
476 1.170 pooka
477 1.7 cgd /*
478 1.81 junyoung * Initialize process 0.
479 1.81 junyoung */
480 1.81 junyoung void
481 1.81 junyoung proc0_init(void)
482 1.81 junyoung {
483 1.81 junyoung struct proc *p;
484 1.81 junyoung struct pgrp *pg;
485 1.177 rmind struct rlimit *rlim;
486 1.81 junyoung rlim_t lim;
487 1.143 gmcgarry int i;
488 1.81 junyoung
489 1.81 junyoung p = &proc0;
490 1.81 junyoung pg = &pgrp0;
491 1.123 matt
492 1.127 ad mutex_init(&p->p_stmutex, MUTEX_DEFAULT, IPL_HIGH);
493 1.129 ad mutex_init(&p->p_auxlock, MUTEX_DEFAULT, IPL_NONE);
494 1.137 ad p->p_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
495 1.107 ad
496 1.122 ad rw_init(&p->p_reflock);
497 1.100 ad cv_init(&p->p_waitcv, "wait");
498 1.100 ad cv_init(&p->p_lwpcv, "lwpwait");
499 1.100 ad
500 1.166 pooka LIST_INSERT_HEAD(&p->p_lwps, &lwp0, l_sibling);
501 1.100 ad
502 1.247 thorpej KASSERT(lwp0.l_lid == 0);
503 1.247 thorpej pid_table[lwp0.l_lid].pt_slot = PT_SET_LWP(&lwp0);
504 1.81 junyoung LIST_INSERT_HEAD(&allproc, p, p_list);
505 1.81 junyoung
506 1.247 thorpej pid_table[lwp0.l_lid].pt_pgrp = pg;
507 1.81 junyoung LIST_INSERT_HEAD(&pg->pg_members, p, p_pglist);
508 1.81 junyoung
509 1.81 junyoung #ifdef __HAVE_SYSCALL_INTERN
510 1.81 junyoung (*p->p_emul->e_syscall_intern)(p);
511 1.81 junyoung #endif
512 1.81 junyoung
513 1.81 junyoung /* Create credentials. */
514 1.89 elad cred0 = kauth_cred_alloc();
515 1.89 elad p->p_cred = cred0;
516 1.81 junyoung
517 1.81 junyoung /* Create the CWD info. */
518 1.246 ad rw_init(&cwdi0.cwdi_lock);
519 1.81 junyoung
520 1.81 junyoung /* Create the limits structures. */
521 1.116 dsl mutex_init(&limit0.pl_lock, MUTEX_DEFAULT, IPL_NONE);
522 1.177 rmind
523 1.177 rmind rlim = limit0.pl_rlimit;
524 1.177 rmind for (i = 0; i < __arraycount(limit0.pl_rlimit); i++) {
525 1.177 rmind rlim[i].rlim_cur = RLIM_INFINITY;
526 1.177 rmind rlim[i].rlim_max = RLIM_INFINITY;
527 1.177 rmind }
528 1.177 rmind
529 1.177 rmind rlim[RLIMIT_NOFILE].rlim_max = maxfiles;
530 1.177 rmind rlim[RLIMIT_NOFILE].rlim_cur = maxfiles < nofile ? maxfiles : nofile;
531 1.177 rmind
532 1.177 rmind rlim[RLIMIT_NPROC].rlim_max = maxproc;
533 1.177 rmind rlim[RLIMIT_NPROC].rlim_cur = maxproc < maxuprc ? maxproc : maxuprc;
534 1.81 junyoung
535 1.239 ad lim = MIN(VM_MAXUSER_ADDRESS, ctob((rlim_t)uvm_availmem()));
536 1.177 rmind rlim[RLIMIT_RSS].rlim_max = lim;
537 1.177 rmind rlim[RLIMIT_MEMLOCK].rlim_max = lim;
538 1.177 rmind rlim[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
539 1.177 rmind
540 1.186 christos rlim[RLIMIT_NTHR].rlim_max = maxlwp;
541 1.186 christos rlim[RLIMIT_NTHR].rlim_cur = maxlwp < maxuprc ? maxlwp : maxuprc;
542 1.186 christos
543 1.179 rmind /* Note that default core name has zero length. */
544 1.177 rmind limit0.pl_corename = defcorename;
545 1.179 rmind limit0.pl_cnlen = 0;
546 1.177 rmind limit0.pl_refcnt = 1;
547 1.179 rmind limit0.pl_writeable = false;
548 1.143 gmcgarry limit0.pl_sv_limit = NULL;
549 1.81 junyoung
550 1.81 junyoung /* Configure virtual memory system, set vm rlimits. */
551 1.81 junyoung uvm_init_limits(p);
552 1.81 junyoung
553 1.81 junyoung /* Initialize file descriptor table for proc0. */
554 1.132 ad fd_init(&filedesc0);
555 1.81 junyoung
556 1.81 junyoung /*
557 1.81 junyoung * Initialize proc0's vmspace, which uses the kernel pmap.
558 1.81 junyoung * All kernel processes (which never have user space mappings)
559 1.81 junyoung * share proc0's vmspace, and thus, the kernel pmap.
560 1.81 junyoung */
561 1.81 junyoung uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS),
562 1.197 maxv trunc_page(VM_MAXUSER_ADDRESS),
563 1.191 christos #ifdef __USE_TOPDOWN_VM
564 1.190 martin true
565 1.190 martin #else
566 1.190 martin false
567 1.190 martin #endif
568 1.190 martin );
569 1.81 junyoung
570 1.127 ad /* Initialize signal state for proc0. XXX IPL_SCHED */
571 1.127 ad mutex_init(&p->p_sigacts->sa_mutex, MUTEX_DEFAULT, IPL_SCHED);
572 1.81 junyoung siginit(p);
573 1.96 christos
574 1.164 rmind proc_initspecific(p);
575 1.160 darran kdtrace_proc_ctor(NULL, p);
576 1.81 junyoung }
577 1.81 junyoung
578 1.81 junyoung /*
579 1.151 rmind * Session reference counting.
580 1.151 rmind */
581 1.151 rmind
582 1.151 rmind void
583 1.151 rmind proc_sesshold(struct session *ss)
584 1.151 rmind {
585 1.151 rmind
586 1.151 rmind KASSERT(mutex_owned(proc_lock));
587 1.151 rmind ss->s_count++;
588 1.151 rmind }
589 1.151 rmind
590 1.247 thorpej static void
591 1.247 thorpej proc_sessrele_pid_table_write_locked(struct session *ss)
592 1.151 rmind {
593 1.247 thorpej struct pgrp *pg;
594 1.151 rmind
595 1.151 rmind KASSERT(mutex_owned(proc_lock));
596 1.247 thorpej KASSERT(rw_write_held(&pid_table_lock));
597 1.245 maxv KASSERT(ss->s_count > 0);
598 1.247 thorpej
599 1.151 rmind /*
600 1.151 rmind * We keep the pgrp with the same id as the session in order to
601 1.151 rmind * stop a process being given the same pid. Since the pgrp holds
602 1.151 rmind * a reference to the session, it must be a 'zombie' pgrp by now.
603 1.151 rmind */
604 1.151 rmind if (--ss->s_count == 0) {
605 1.247 thorpej pg = pg_remove(ss->s_sid);
606 1.247 thorpej } else {
607 1.247 thorpej pg = NULL;
608 1.247 thorpej ss = NULL;
609 1.247 thorpej }
610 1.151 rmind
611 1.247 thorpej rw_exit(&pid_table_lock);
612 1.247 thorpej mutex_exit(proc_lock);
613 1.151 rmind
614 1.247 thorpej if (pg)
615 1.151 rmind kmem_free(pg, sizeof(struct pgrp));
616 1.247 thorpej if (ss)
617 1.151 rmind kmem_free(ss, sizeof(struct session));
618 1.247 thorpej }
619 1.247 thorpej
620 1.247 thorpej void
621 1.247 thorpej proc_sessrele(struct session *ss)
622 1.247 thorpej {
623 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
624 1.247 thorpej proc_sessrele_pid_table_write_locked(ss);
625 1.151 rmind }
626 1.151 rmind
627 1.151 rmind /*
628 1.74 junyoung * Check that the specified process group is in the session of the
629 1.60 dsl * specified process.
630 1.60 dsl * Treats -ve ids as process ids.
631 1.60 dsl * Used to validate TIOCSPGRP requests.
632 1.60 dsl */
633 1.60 dsl int
634 1.60 dsl pgid_in_session(struct proc *p, pid_t pg_id)
635 1.60 dsl {
636 1.60 dsl struct pgrp *pgrp;
637 1.101 dsl struct session *session;
638 1.107 ad int error;
639 1.101 dsl
640 1.136 ad mutex_enter(proc_lock);
641 1.60 dsl if (pg_id < 0) {
642 1.167 rmind struct proc *p1 = proc_find(-pg_id);
643 1.167 rmind if (p1 == NULL) {
644 1.167 rmind error = EINVAL;
645 1.167 rmind goto fail;
646 1.167 rmind }
647 1.60 dsl pgrp = p1->p_pgrp;
648 1.60 dsl } else {
649 1.167 rmind pgrp = pgrp_find(pg_id);
650 1.167 rmind if (pgrp == NULL) {
651 1.167 rmind error = EINVAL;
652 1.167 rmind goto fail;
653 1.167 rmind }
654 1.60 dsl }
655 1.101 dsl session = pgrp->pg_session;
656 1.167 rmind error = (session != p->p_pgrp->pg_session) ? EPERM : 0;
657 1.167 rmind fail:
658 1.136 ad mutex_exit(proc_lock);
659 1.107 ad return error;
660 1.7 cgd }
661 1.4 andrew
662 1.1 cgd /*
663 1.148 rmind * p_inferior: is p an inferior of q?
664 1.1 cgd */
665 1.148 rmind static inline bool
666 1.148 rmind p_inferior(struct proc *p, struct proc *q)
667 1.1 cgd {
668 1.1 cgd
669 1.148 rmind KASSERT(mutex_owned(proc_lock));
670 1.148 rmind
671 1.41 sommerfe for (; p != q; p = p->p_pptr)
672 1.1 cgd if (p->p_pid == 0)
673 1.148 rmind return false;
674 1.148 rmind return true;
675 1.1 cgd }
676 1.1 cgd
677 1.1 cgd /*
678 1.247 thorpej * proc_find_lwp: locate an lwp in said proc by the ID.
679 1.247 thorpej *
680 1.247 thorpej * => Must be called with p::p_lock held.
681 1.247 thorpej * => LARVAL lwps are not returned because they are only partially
682 1.247 thorpej * constructed while occupying the slot.
683 1.247 thorpej * => Callers need to be careful about lwp::l_stat of the returned
684 1.247 thorpej * lwp.
685 1.247 thorpej */
686 1.247 thorpej struct lwp *
687 1.247 thorpej proc_find_lwp(proc_t *p, pid_t pid)
688 1.247 thorpej {
689 1.247 thorpej struct pid_table *pt;
690 1.247 thorpej struct lwp *l = NULL;
691 1.247 thorpej uintptr_t slot;
692 1.247 thorpej
693 1.247 thorpej KASSERT(mutex_owned(p->p_lock));
694 1.247 thorpej rw_enter(&pid_table_lock, RW_READER);
695 1.247 thorpej pt = &pid_table[pid & pid_tbl_mask];
696 1.247 thorpej
697 1.247 thorpej slot = pt->pt_slot;
698 1.247 thorpej if (__predict_true(PT_IS_LWP(slot) && pt->pt_pid == pid)) {
699 1.247 thorpej l = PT_GET_LWP(slot);
700 1.247 thorpej if (__predict_false(l->l_proc != p || l->l_stat == LSLARVAL)) {
701 1.247 thorpej l = NULL;
702 1.247 thorpej }
703 1.247 thorpej }
704 1.247 thorpej rw_exit(&pid_table_lock);
705 1.247 thorpej
706 1.247 thorpej return l;
707 1.247 thorpej }
708 1.247 thorpej
709 1.247 thorpej /*
710 1.247 thorpej * proc_seek_lwpid: locate an lwp by only the ID.
711 1.247 thorpej *
712 1.247 thorpej * => This is a specialized interface used for looking up an LWP
713 1.247 thorpej * without holding a lock on its owner process.
714 1.247 thorpej * => Callers of this interface MUST provide a separate synchronization
715 1.247 thorpej * mechanism to ensure the validity of the returned LWP. LARVAL LWPs
716 1.247 thorpej * are found there, so callers must check for them!
717 1.247 thorpej * => Only returns LWPs whose ID has not been hidden from us.
718 1.247 thorpej */
719 1.247 thorpej struct lwp *
720 1.247 thorpej proc_seek_lwpid(pid_t pid)
721 1.247 thorpej {
722 1.247 thorpej struct pid_table *pt;
723 1.247 thorpej struct lwp *l = NULL;
724 1.247 thorpej uintptr_t slot;
725 1.247 thorpej
726 1.247 thorpej rw_enter(&pid_table_lock, RW_READER);
727 1.247 thorpej pt = &pid_table[pid & pid_tbl_mask];
728 1.247 thorpej
729 1.247 thorpej slot = pt->pt_slot;
730 1.247 thorpej if (__predict_true(PT_IS_LWP(slot) && pt->pt_pid == pid &&
731 1.247 thorpej !PT_HIDDEN(slot))) {
732 1.247 thorpej l = PT_GET_LWP(slot);
733 1.247 thorpej }
734 1.247 thorpej rw_exit(&pid_table_lock);
735 1.247 thorpej
736 1.247 thorpej return l;
737 1.247 thorpej }
738 1.247 thorpej
739 1.247 thorpej /*
740 1.247 thorpej * proc_hide_lwpid: hide an lwp ID from seekers.
741 1.247 thorpej */
742 1.247 thorpej void
743 1.247 thorpej proc_hide_lwpid(pid_t pid)
744 1.247 thorpej {
745 1.247 thorpej struct pid_table *pt;
746 1.247 thorpej uintptr_t slot;
747 1.247 thorpej
748 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
749 1.247 thorpej pt = &pid_table[pid & pid_tbl_mask];
750 1.247 thorpej
751 1.247 thorpej slot = pt->pt_slot;
752 1.247 thorpej KASSERT(PT_IS_LWP(slot));
753 1.247 thorpej KASSERT(pt->pt_pid == pid);
754 1.247 thorpej pt->pt_slot = PT_SET_HIDDEN(slot);
755 1.247 thorpej
756 1.247 thorpej rw_exit(&pid_table_lock);
757 1.247 thorpej }
758 1.247 thorpej
759 1.247 thorpej /*
760 1.247 thorpej * proc_find_raw_pid_table_locked: locate a process by the ID.
761 1.167 rmind *
762 1.247 thorpej * => Must be called with proc_lock held and the pid_table_lock
763 1.247 thorpej * at least held for reading.
764 1.1 cgd */
765 1.247 thorpej static proc_t *
766 1.247 thorpej proc_find_raw_pid_table_locked(pid_t pid)
767 1.1 cgd {
768 1.168 chs struct pid_table *pt;
769 1.247 thorpej proc_t *p = NULL;
770 1.247 thorpej uintptr_t slot;
771 1.167 rmind
772 1.168 chs KASSERT(mutex_owned(proc_lock));
773 1.168 chs pt = &pid_table[pid & pid_tbl_mask];
774 1.247 thorpej
775 1.247 thorpej slot = pt->pt_slot;
776 1.247 thorpej if (__predict_true(PT_IS_LWP(slot) && pt->pt_pid == pid)) {
777 1.247 thorpej /*
778 1.247 thorpej * When looking up processes, require a direct match
779 1.247 thorpej * on the PID assigned to the proc, not just one of
780 1.247 thorpej * its LWPs.
781 1.247 thorpej *
782 1.247 thorpej * N.B. We require lwp::l_proc of LARVAL LWPs to be
783 1.247 thorpej * valid here.
784 1.247 thorpej */
785 1.247 thorpej p = PT_GET_LWP(slot)->l_proc;
786 1.247 thorpej if (__predict_false(p->p_pid != pid))
787 1.247 thorpej p = NULL;
788 1.247 thorpej } else if (PT_IS_PROC(slot) && pt->pt_pid == pid) {
789 1.247 thorpej p = PT_GET_PROC(slot);
790 1.167 rmind }
791 1.167 rmind return p;
792 1.167 rmind }
793 1.1 cgd
794 1.167 rmind proc_t *
795 1.247 thorpej proc_find_raw(pid_t pid)
796 1.247 thorpej {
797 1.247 thorpej KASSERT(mutex_owned(proc_lock));
798 1.247 thorpej rw_enter(&pid_table_lock, RW_READER);
799 1.247 thorpej proc_t *p = proc_find_raw_pid_table_locked(pid);
800 1.247 thorpej rw_exit(&pid_table_lock);
801 1.247 thorpej return p;
802 1.247 thorpej }
803 1.247 thorpej
804 1.247 thorpej static proc_t *
805 1.247 thorpej proc_find_pid_table_locked(pid_t pid)
806 1.167 rmind {
807 1.167 rmind proc_t *p;
808 1.100 ad
809 1.247 thorpej KASSERT(mutex_owned(proc_lock));
810 1.247 thorpej
811 1.247 thorpej p = proc_find_raw_pid_table_locked(pid);
812 1.167 rmind if (__predict_false(p == NULL)) {
813 1.167 rmind return NULL;
814 1.167 rmind }
815 1.168 chs
816 1.167 rmind /*
817 1.167 rmind * Only allow live processes to be found by PID.
818 1.247 thorpej * XXX: p_stat might change, since proc unlocked.
819 1.167 rmind */
820 1.167 rmind if (__predict_true(p->p_stat == SACTIVE || p->p_stat == SSTOP)) {
821 1.68 dsl return p;
822 1.68 dsl }
823 1.68 dsl return NULL;
824 1.1 cgd }
825 1.1 cgd
826 1.247 thorpej proc_t *
827 1.247 thorpej proc_find(pid_t pid)
828 1.247 thorpej {
829 1.247 thorpej KASSERT(mutex_owned(proc_lock));
830 1.247 thorpej rw_enter(&pid_table_lock, RW_READER);
831 1.247 thorpej proc_t *p = proc_find_pid_table_locked(pid);
832 1.247 thorpej rw_exit(&pid_table_lock);
833 1.247 thorpej return p;
834 1.247 thorpej }
835 1.247 thorpej
836 1.1 cgd /*
837 1.247 thorpej * pgrp_find_pid_table_locked: locate a process group by the ID.
838 1.167 rmind *
839 1.247 thorpej * => Must be called with proc_lock held and the pid_table_lock
840 1.247 thorpej * held at least for reading.
841 1.1 cgd */
842 1.247 thorpej static struct pgrp *
843 1.247 thorpej pgrp_find_pid_table_locked(pid_t pgid)
844 1.1 cgd {
845 1.68 dsl struct pgrp *pg;
846 1.1 cgd
847 1.167 rmind KASSERT(mutex_owned(proc_lock));
848 1.167 rmind
849 1.68 dsl pg = pid_table[pgid & pid_tbl_mask].pt_pgrp;
850 1.168 chs
851 1.61 dsl /*
852 1.167 rmind * Cannot look up a process group that only exists because the
853 1.167 rmind * session has not died yet (traditional).
854 1.61 dsl */
855 1.68 dsl if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) {
856 1.68 dsl return NULL;
857 1.68 dsl }
858 1.68 dsl return pg;
859 1.1 cgd }
860 1.1 cgd
861 1.247 thorpej struct pgrp *
862 1.247 thorpej pgrp_find(pid_t pgid)
863 1.247 thorpej {
864 1.247 thorpej KASSERT(mutex_owned(proc_lock));
865 1.247 thorpej rw_enter(&pid_table_lock, RW_READER);
866 1.247 thorpej struct pgrp *pg = pgrp_find_pid_table_locked(pgid);
867 1.247 thorpej rw_exit(&pid_table_lock);
868 1.247 thorpej return pg;
869 1.247 thorpej }
870 1.247 thorpej
871 1.61 dsl static void
872 1.61 dsl expand_pid_table(void)
873 1.1 cgd {
874 1.150 rmind size_t pt_size, tsz;
875 1.61 dsl struct pid_table *n_pt, *new_pt;
876 1.247 thorpej uintptr_t slot;
877 1.61 dsl struct pgrp *pgrp;
878 1.168 chs pid_t pid, rpid;
879 1.150 rmind u_int i;
880 1.168 chs uint new_pt_mask;
881 1.1 cgd
882 1.247 thorpej KASSERT(rw_write_held(&pid_table_lock));
883 1.247 thorpej
884 1.247 thorpej /* Unlock the pid_table briefly to allocate memory. */
885 1.247 thorpej rw_exit(&pid_table_lock);
886 1.247 thorpej
887 1.150 rmind pt_size = pid_tbl_mask + 1;
888 1.150 rmind tsz = pt_size * 2 * sizeof(struct pid_table);
889 1.150 rmind new_pt = kmem_alloc(tsz, KM_SLEEP);
890 1.168 chs new_pt_mask = pt_size * 2 - 1;
891 1.61 dsl
892 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
893 1.61 dsl if (pt_size != pid_tbl_mask + 1) {
894 1.61 dsl /* Another process beat us to it... */
895 1.247 thorpej rw_exit(&pid_table_lock);
896 1.150 rmind kmem_free(new_pt, tsz);
897 1.247 thorpej goto out;
898 1.61 dsl }
899 1.72 junyoung
900 1.61 dsl /*
901 1.61 dsl * Copy entries from old table into new one.
902 1.61 dsl * If 'pid' is 'odd' we need to place in the upper half,
903 1.61 dsl * even pid's to the lower half.
904 1.61 dsl * Free items stay in the low half so we don't have to
905 1.61 dsl * fixup the reference to them.
906 1.61 dsl * We stuff free items on the front of the freelist
907 1.61 dsl * because we can't write to unmodified entries.
908 1.74 junyoung * Processing the table backwards maintains a semblance
909 1.168 chs * of issuing pid numbers that increase with time.
910 1.61 dsl */
911 1.61 dsl i = pt_size - 1;
912 1.61 dsl n_pt = new_pt + i;
913 1.61 dsl for (; ; i--, n_pt--) {
914 1.247 thorpej slot = pid_table[i].pt_slot;
915 1.61 dsl pgrp = pid_table[i].pt_pgrp;
916 1.247 thorpej if (!PT_VALID(slot)) {
917 1.61 dsl /* Up 'use count' so that link is valid */
918 1.247 thorpej pid = (PT_NEXT(slot) + pt_size) & ~pt_size;
919 1.168 chs rpid = 0;
920 1.247 thorpej slot = PT_SET_FREE(pid);
921 1.61 dsl if (pgrp)
922 1.61 dsl pid = pgrp->pg_id;
923 1.168 chs } else {
924 1.168 chs pid = pid_table[i].pt_pid;
925 1.168 chs rpid = pid;
926 1.168 chs }
927 1.72 junyoung
928 1.61 dsl /* Save entry in appropriate half of table */
929 1.247 thorpej n_pt[pid & pt_size].pt_slot = slot;
930 1.61 dsl n_pt[pid & pt_size].pt_pgrp = pgrp;
931 1.168 chs n_pt[pid & pt_size].pt_pid = rpid;
932 1.61 dsl
933 1.61 dsl /* Put other piece on start of free list */
934 1.61 dsl pid = (pid ^ pt_size) & ~pid_tbl_mask;
935 1.247 thorpej n_pt[pid & pt_size].pt_slot =
936 1.247 thorpej PT_SET_FREE((pid & ~pt_size) | next_free_pt);
937 1.61 dsl n_pt[pid & pt_size].pt_pgrp = 0;
938 1.168 chs n_pt[pid & pt_size].pt_pid = 0;
939 1.168 chs
940 1.61 dsl next_free_pt = i | (pid & pt_size);
941 1.61 dsl if (i == 0)
942 1.61 dsl break;
943 1.61 dsl }
944 1.61 dsl
945 1.150 rmind /* Save old table size and switch tables */
946 1.150 rmind tsz = pt_size * sizeof(struct pid_table);
947 1.61 dsl n_pt = pid_table;
948 1.61 dsl pid_table = new_pt;
949 1.168 chs pid_tbl_mask = new_pt_mask;
950 1.61 dsl
951 1.61 dsl /*
952 1.61 dsl * pid_max starts as PID_MAX (= 30000), once we have 16384
953 1.61 dsl * allocated pids we need it to be larger!
954 1.61 dsl */
955 1.61 dsl if (pid_tbl_mask > PID_MAX) {
956 1.61 dsl pid_max = pid_tbl_mask * 2 + 1;
957 1.61 dsl pid_alloc_lim |= pid_alloc_lim << 1;
958 1.61 dsl } else
959 1.61 dsl pid_alloc_lim <<= 1; /* doubles number of free slots... */
960 1.61 dsl
961 1.247 thorpej rw_exit(&pid_table_lock);
962 1.150 rmind kmem_free(n_pt, tsz);
963 1.247 thorpej
964 1.247 thorpej out: /* Return with the pid_table_lock held again. */
965 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
966 1.61 dsl }
967 1.61 dsl
968 1.61 dsl struct proc *
969 1.61 dsl proc_alloc(void)
970 1.61 dsl {
971 1.61 dsl struct proc *p;
972 1.61 dsl
973 1.128 ad p = pool_cache_get(proc_cache, PR_WAITOK);
974 1.61 dsl p->p_stat = SIDL; /* protect against others */
975 1.96 christos proc_initspecific(p);
976 1.164 rmind kdtrace_proc_ctor(NULL, p);
977 1.247 thorpej
978 1.247 thorpej /*
979 1.247 thorpej * Allocate a placeholder in the pid_table. When we create the
980 1.247 thorpej * first LWP for this process, it will take ownership of the
981 1.247 thorpej * slot.
982 1.247 thorpej */
983 1.247 thorpej if (__predict_false(proc_alloc_pid(p) == -1)) {
984 1.247 thorpej /* Allocating the PID failed; unwind. */
985 1.247 thorpej proc_finispecific(p);
986 1.247 thorpej proc_free_mem(p);
987 1.247 thorpej p = NULL;
988 1.247 thorpej }
989 1.168 chs return p;
990 1.168 chs }
991 1.168 chs
992 1.183 yamt /*
993 1.247 thorpej * proc_alloc_pid_slot: allocate PID and record the occcupant so that
994 1.183 yamt * proc_find_raw() can find it by the PID.
995 1.183 yamt */
996 1.247 thorpej static pid_t __noinline
997 1.247 thorpej proc_alloc_pid_slot(struct proc *p, uintptr_t slot)
998 1.168 chs {
999 1.168 chs struct pid_table *pt;
1000 1.168 chs pid_t pid;
1001 1.168 chs int nxt;
1002 1.61 dsl
1003 1.247 thorpej KASSERT(rw_write_held(&pid_table_lock));
1004 1.247 thorpej
1005 1.61 dsl for (;;expand_pid_table()) {
1006 1.247 thorpej if (__predict_false(pid_alloc_cnt >= pid_alloc_lim)) {
1007 1.61 dsl /* ensure pids cycle through 2000+ values */
1008 1.61 dsl continue;
1009 1.247 thorpej }
1010 1.247 thorpej /*
1011 1.247 thorpej * The first user process *must* be given PID 1.
1012 1.247 thorpej * it has already been reserved for us. This
1013 1.247 thorpej * will be coming in from the proc_alloc() call
1014 1.247 thorpej * above, and the entry will be usurped later when
1015 1.247 thorpej * the first user LWP is created.
1016 1.247 thorpej * XXX this is slightly gross.
1017 1.247 thorpej */
1018 1.247 thorpej if (__predict_false(PT_RESERVED(pid_table[1].pt_slot) &&
1019 1.247 thorpej p != &proc0)) {
1020 1.247 thorpej KASSERT(PT_IS_PROC(slot));
1021 1.247 thorpej pt = &pid_table[1];
1022 1.247 thorpej pt->pt_slot = slot;
1023 1.247 thorpej return 1;
1024 1.247 thorpej }
1025 1.61 dsl pt = &pid_table[next_free_pt];
1026 1.1 cgd #ifdef DIAGNOSTIC
1027 1.247 thorpej if (__predict_false(PT_VALID(pt->pt_slot) || pt->pt_pgrp))
1028 1.61 dsl panic("proc_alloc: slot busy");
1029 1.1 cgd #endif
1030 1.247 thorpej nxt = PT_NEXT(pt->pt_slot);
1031 1.61 dsl if (nxt & pid_tbl_mask)
1032 1.61 dsl break;
1033 1.61 dsl /* Table full - expand (NB last entry not used....) */
1034 1.61 dsl }
1035 1.61 dsl
1036 1.61 dsl /* pid is 'saved use count' + 'size' + entry */
1037 1.61 dsl pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt;
1038 1.61 dsl if ((uint)pid > (uint)pid_max)
1039 1.61 dsl pid &= pid_tbl_mask;
1040 1.61 dsl next_free_pt = nxt & pid_tbl_mask;
1041 1.61 dsl
1042 1.61 dsl /* Grab table slot */
1043 1.247 thorpej pt->pt_slot = slot;
1044 1.168 chs
1045 1.168 chs KASSERT(pt->pt_pid == 0);
1046 1.168 chs pt->pt_pid = pid;
1047 1.247 thorpej pid_alloc_cnt++;
1048 1.247 thorpej
1049 1.247 thorpej return pid;
1050 1.247 thorpej }
1051 1.247 thorpej
1052 1.247 thorpej pid_t
1053 1.247 thorpej proc_alloc_pid(struct proc *p)
1054 1.247 thorpej {
1055 1.247 thorpej pid_t pid;
1056 1.247 thorpej
1057 1.247 thorpej KASSERT((((uintptr_t)p) & PT_F_ALLBITS) == 0);
1058 1.247 thorpej
1059 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
1060 1.247 thorpej pid = proc_alloc_pid_slot(p, PT_SET_PROC(p));
1061 1.247 thorpej if (pid != -1)
1062 1.168 chs p->p_pid = pid;
1063 1.247 thorpej rw_exit(&pid_table_lock);
1064 1.247 thorpej
1065 1.247 thorpej return pid;
1066 1.247 thorpej }
1067 1.247 thorpej
1068 1.247 thorpej pid_t
1069 1.247 thorpej proc_alloc_lwpid(struct proc *p, struct lwp *l)
1070 1.247 thorpej {
1071 1.247 thorpej struct pid_table *pt;
1072 1.247 thorpej pid_t pid;
1073 1.247 thorpej
1074 1.247 thorpej KASSERT((((uintptr_t)l) & PT_F_ALLBITS) == 0);
1075 1.247 thorpej
1076 1.247 thorpej /*
1077 1.247 thorpej * If the slot for p->p_pid currently points to the proc,
1078 1.247 thorpej * then we should usurp this ID for the LWP. This happens
1079 1.247 thorpej * at least once per process (for the first LWP), and can
1080 1.247 thorpej * happen again if the first LWP for a process exits and
1081 1.247 thorpej * before the process creates another.
1082 1.247 thorpej */
1083 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
1084 1.247 thorpej pid = p->p_pid;
1085 1.247 thorpej pt = &pid_table[pid & pid_tbl_mask];
1086 1.247 thorpej KASSERT(pt->pt_pid == pid);
1087 1.247 thorpej if (PT_IS_PROC(pt->pt_slot)) {
1088 1.247 thorpej KASSERT(PT_GET_PROC(pt->pt_slot) == p);
1089 1.247 thorpej l->l_lid = pid;
1090 1.247 thorpej pt->pt_slot = PT_SET_LWP(l);
1091 1.247 thorpej } else {
1092 1.247 thorpej /* Need to allocate a new slot. */
1093 1.247 thorpej pid = proc_alloc_pid_slot(p, PT_SET_LWP(l));
1094 1.247 thorpej if (pid != -1)
1095 1.247 thorpej l->l_lid = pid;
1096 1.168 chs }
1097 1.247 thorpej rw_exit(&pid_table_lock);
1098 1.61 dsl
1099 1.168 chs return pid;
1100 1.61 dsl }
1101 1.61 dsl
1102 1.247 thorpej static void __noinline
1103 1.247 thorpej proc_free_pid_internal(pid_t pid, uintptr_t type __diagused)
1104 1.61 dsl {
1105 1.61 dsl struct pid_table *pt;
1106 1.61 dsl
1107 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
1108 1.247 thorpej pt = &pid_table[pid & pid_tbl_mask];
1109 1.61 dsl
1110 1.247 thorpej KASSERT(PT_GET_TYPE(pt->pt_slot) == type);
1111 1.247 thorpej KASSERT(pt->pt_pid == pid);
1112 1.168 chs
1113 1.61 dsl /* save pid use count in slot */
1114 1.247 thorpej pt->pt_slot = PT_SET_FREE(pid & ~pid_tbl_mask);
1115 1.168 chs pt->pt_pid = 0;
1116 1.61 dsl
1117 1.61 dsl if (pt->pt_pgrp == NULL) {
1118 1.61 dsl /* link last freed entry onto ours */
1119 1.61 dsl pid &= pid_tbl_mask;
1120 1.61 dsl pt = &pid_table[last_free_pt];
1121 1.247 thorpej pt->pt_slot = PT_SET_FREE(PT_NEXT(pt->pt_slot) | pid);
1122 1.168 chs pt->pt_pid = 0;
1123 1.61 dsl last_free_pt = pid;
1124 1.61 dsl pid_alloc_cnt--;
1125 1.61 dsl }
1126 1.247 thorpej rw_exit(&pid_table_lock);
1127 1.247 thorpej }
1128 1.247 thorpej
1129 1.247 thorpej /*
1130 1.247 thorpej * Free a process id - called from proc_free (in kern_exit.c)
1131 1.247 thorpej *
1132 1.247 thorpej * Called with the proc_lock held.
1133 1.247 thorpej */
1134 1.247 thorpej void
1135 1.247 thorpej proc_free_pid(pid_t pid)
1136 1.247 thorpej {
1137 1.247 thorpej KASSERT(mutex_owned(proc_lock));
1138 1.247 thorpej proc_free_pid_internal(pid, PT_F_PROC);
1139 1.247 thorpej }
1140 1.247 thorpej
1141 1.247 thorpej /*
1142 1.247 thorpej * Free a process id used by an LWP. If this was the process's
1143 1.247 thorpej * first LWP, we convert the slot to point to the process; the
1144 1.247 thorpej * entry will get cleaned up later when the process finishes exiting.
1145 1.247 thorpej *
1146 1.247 thorpej * If not, then it's the same as proc_free_pid().
1147 1.247 thorpej */
1148 1.247 thorpej void
1149 1.247 thorpej proc_free_lwpid(struct proc *p, pid_t pid)
1150 1.247 thorpej {
1151 1.247 thorpej
1152 1.247 thorpej KASSERT(mutex_owned(p->p_lock));
1153 1.247 thorpej
1154 1.247 thorpej if (__predict_true(p->p_pid == pid)) {
1155 1.247 thorpej struct pid_table *pt;
1156 1.247 thorpej
1157 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
1158 1.247 thorpej pt = &pid_table[pid & pid_tbl_mask];
1159 1.247 thorpej
1160 1.247 thorpej KASSERT(pt->pt_pid == pid);
1161 1.247 thorpej KASSERT(PT_IS_LWP(pt->pt_slot));
1162 1.247 thorpej KASSERT(PT_GET_LWP(pt->pt_slot)->l_proc == p);
1163 1.247 thorpej
1164 1.247 thorpej pt->pt_slot = PT_SET_PROC(p);
1165 1.247 thorpej
1166 1.247 thorpej rw_exit(&pid_table_lock);
1167 1.247 thorpej return;
1168 1.247 thorpej }
1169 1.247 thorpej proc_free_pid_internal(pid, PT_F_LWP);
1170 1.61 dsl }
1171 1.61 dsl
1172 1.128 ad void
1173 1.128 ad proc_free_mem(struct proc *p)
1174 1.128 ad {
1175 1.128 ad
1176 1.160 darran kdtrace_proc_dtor(NULL, p);
1177 1.128 ad pool_cache_put(proc_cache, p);
1178 1.128 ad }
1179 1.128 ad
1180 1.61 dsl /*
1181 1.151 rmind * proc_enterpgrp: move p to a new or existing process group (and session).
1182 1.61 dsl *
1183 1.61 dsl * If we are creating a new pgrp, the pgid should equal
1184 1.72 junyoung * the calling process' pid.
1185 1.61 dsl * If is only valid to enter a process group that is in the session
1186 1.61 dsl * of the process.
1187 1.61 dsl * Also mksess should only be set if we are creating a process group
1188 1.61 dsl *
1189 1.181 martin * Only called from sys_setsid, sys_setpgid and posix_spawn/spawn_return.
1190 1.61 dsl */
1191 1.61 dsl int
1192 1.151 rmind proc_enterpgrp(struct proc *curp, pid_t pid, pid_t pgid, bool mksess)
1193 1.61 dsl {
1194 1.61 dsl struct pgrp *new_pgrp, *pgrp;
1195 1.61 dsl struct session *sess;
1196 1.100 ad struct proc *p;
1197 1.61 dsl int rval;
1198 1.61 dsl pid_t pg_id = NO_PGID;
1199 1.61 dsl
1200 1.151 rmind sess = mksess ? kmem_alloc(sizeof(*sess), KM_SLEEP) : NULL;
1201 1.61 dsl
1202 1.107 ad /* Allocate data areas we might need before doing any validity checks */
1203 1.247 thorpej rw_enter(&pid_table_lock, RW_READER);/* Because pid_table might change */
1204 1.107 ad if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) {
1205 1.247 thorpej rw_exit(&pid_table_lock);
1206 1.131 ad new_pgrp = kmem_alloc(sizeof(*new_pgrp), KM_SLEEP);
1207 1.247 thorpej } else {
1208 1.247 thorpej rw_exit(&pid_table_lock);
1209 1.107 ad new_pgrp = NULL;
1210 1.247 thorpej }
1211 1.247 thorpej mutex_enter(proc_lock);
1212 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
1213 1.61 dsl rval = EPERM; /* most common error (to save typing) */
1214 1.61 dsl
1215 1.61 dsl /* Check pgrp exists or can be created */
1216 1.61 dsl pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
1217 1.61 dsl if (pgrp != NULL && pgrp->pg_id != pgid)
1218 1.61 dsl goto done;
1219 1.61 dsl
1220 1.61 dsl /* Can only set another process under restricted circumstances. */
1221 1.100 ad if (pid != curp->p_pid) {
1222 1.167 rmind /* Must exist and be one of our children... */
1223 1.247 thorpej p = proc_find_pid_table_locked(pid);
1224 1.167 rmind if (p == NULL || !p_inferior(p, curp)) {
1225 1.61 dsl rval = ESRCH;
1226 1.61 dsl goto done;
1227 1.61 dsl }
1228 1.61 dsl /* ... in the same session... */
1229 1.61 dsl if (sess != NULL || p->p_session != curp->p_session)
1230 1.61 dsl goto done;
1231 1.61 dsl /* ... existing pgid must be in same session ... */
1232 1.61 dsl if (pgrp != NULL && pgrp->pg_session != p->p_session)
1233 1.61 dsl goto done;
1234 1.61 dsl /* ... and not done an exec. */
1235 1.102 pavel if (p->p_flag & PK_EXEC) {
1236 1.61 dsl rval = EACCES;
1237 1.61 dsl goto done;
1238 1.49 enami }
1239 1.100 ad } else {
1240 1.100 ad /* ... setsid() cannot re-enter a pgrp */
1241 1.100 ad if (mksess && (curp->p_pgid == curp->p_pid ||
1242 1.247 thorpej pgrp_find_pid_table_locked(curp->p_pid)))
1243 1.100 ad goto done;
1244 1.100 ad p = curp;
1245 1.61 dsl }
1246 1.1 cgd
1247 1.61 dsl /* Changing the process group/session of a session
1248 1.61 dsl leader is definitely off limits. */
1249 1.61 dsl if (SESS_LEADER(p)) {
1250 1.61 dsl if (sess == NULL && p->p_pgrp == pgrp)
1251 1.61 dsl /* unless it's a definite noop */
1252 1.61 dsl rval = 0;
1253 1.61 dsl goto done;
1254 1.61 dsl }
1255 1.61 dsl
1256 1.61 dsl /* Can only create a process group with id of process */
1257 1.61 dsl if (pgrp == NULL && pgid != pid)
1258 1.61 dsl goto done;
1259 1.61 dsl
1260 1.61 dsl /* Can only create a session if creating pgrp */
1261 1.61 dsl if (sess != NULL && pgrp != NULL)
1262 1.61 dsl goto done;
1263 1.61 dsl
1264 1.61 dsl /* Check we allocated memory for a pgrp... */
1265 1.61 dsl if (pgrp == NULL && new_pgrp == NULL)
1266 1.61 dsl goto done;
1267 1.61 dsl
1268 1.61 dsl /* Don't attach to 'zombie' pgrp */
1269 1.61 dsl if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members))
1270 1.61 dsl goto done;
1271 1.61 dsl
1272 1.61 dsl /* Expect to succeed now */
1273 1.61 dsl rval = 0;
1274 1.61 dsl
1275 1.61 dsl if (pgrp == p->p_pgrp)
1276 1.61 dsl /* nothing to do */
1277 1.61 dsl goto done;
1278 1.61 dsl
1279 1.61 dsl /* Ok all setup, link up required structures */
1280 1.100 ad
1281 1.61 dsl if (pgrp == NULL) {
1282 1.61 dsl pgrp = new_pgrp;
1283 1.141 yamt new_pgrp = NULL;
1284 1.61 dsl if (sess != NULL) {
1285 1.21 thorpej sess->s_sid = p->p_pid;
1286 1.1 cgd sess->s_leader = p;
1287 1.1 cgd sess->s_count = 1;
1288 1.1 cgd sess->s_ttyvp = NULL;
1289 1.1 cgd sess->s_ttyp = NULL;
1290 1.58 dsl sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET;
1291 1.25 perry memcpy(sess->s_login, p->p_session->s_login,
1292 1.1 cgd sizeof(sess->s_login));
1293 1.100 ad p->p_lflag &= ~PL_CONTROLT;
1294 1.1 cgd } else {
1295 1.61 dsl sess = p->p_pgrp->pg_session;
1296 1.151 rmind proc_sesshold(sess);
1297 1.1 cgd }
1298 1.61 dsl pgrp->pg_session = sess;
1299 1.141 yamt sess = NULL;
1300 1.61 dsl
1301 1.1 cgd pgrp->pg_id = pgid;
1302 1.10 mycroft LIST_INIT(&pgrp->pg_members);
1303 1.61 dsl #ifdef DIAGNOSTIC
1304 1.63 christos if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp))
1305 1.61 dsl panic("enterpgrp: pgrp table slot in use");
1306 1.63 christos if (__predict_false(mksess && p != curp))
1307 1.63 christos panic("enterpgrp: mksession and p != curproc");
1308 1.61 dsl #endif
1309 1.61 dsl pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp;
1310 1.1 cgd pgrp->pg_jobc = 0;
1311 1.136 ad }
1312 1.1 cgd
1313 1.1 cgd /*
1314 1.1 cgd * Adjust eligibility of affected pgrps to participate in job control.
1315 1.1 cgd * Increment eligibility counts before decrementing, otherwise we
1316 1.1 cgd * could reach 0 spuriously during the first call.
1317 1.1 cgd */
1318 1.1 cgd fixjobc(p, pgrp, 1);
1319 1.1 cgd fixjobc(p, p->p_pgrp, 0);
1320 1.1 cgd
1321 1.139 ad /* Interlock with ttread(). */
1322 1.139 ad mutex_spin_enter(&tty_lock);
1323 1.139 ad
1324 1.100 ad /* Move process to requested group. */
1325 1.10 mycroft LIST_REMOVE(p, p_pglist);
1326 1.52 matt if (LIST_EMPTY(&p->p_pgrp->pg_members))
1327 1.61 dsl /* defer delete until we've dumped the lock */
1328 1.61 dsl pg_id = p->p_pgrp->pg_id;
1329 1.1 cgd p->p_pgrp = pgrp;
1330 1.10 mycroft LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
1331 1.100 ad
1332 1.100 ad /* Done with the swap; we can release the tty mutex. */
1333 1.128 ad mutex_spin_exit(&tty_lock);
1334 1.128 ad
1335 1.61 dsl done:
1336 1.247 thorpej rw_exit(&pid_table_lock);
1337 1.151 rmind if (pg_id != NO_PGID) {
1338 1.151 rmind /* Releases proc_lock. */
1339 1.100 ad pg_delete(pg_id);
1340 1.151 rmind } else {
1341 1.151 rmind mutex_exit(proc_lock);
1342 1.151 rmind }
1343 1.61 dsl if (sess != NULL)
1344 1.131 ad kmem_free(sess, sizeof(*sess));
1345 1.61 dsl if (new_pgrp != NULL)
1346 1.131 ad kmem_free(new_pgrp, sizeof(*new_pgrp));
1347 1.63 christos #ifdef DEBUG_PGRP
1348 1.63 christos if (__predict_false(rval))
1349 1.61 dsl printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n",
1350 1.61 dsl pid, pgid, mksess, curp->p_pid, rval);
1351 1.61 dsl #endif
1352 1.61 dsl return rval;
1353 1.1 cgd }
1354 1.1 cgd
1355 1.1 cgd /*
1356 1.151 rmind * proc_leavepgrp: remove a process from its process group.
1357 1.151 rmind * => must be called with the proc_lock held, which will be released;
1358 1.1 cgd */
1359 1.100 ad void
1360 1.151 rmind proc_leavepgrp(struct proc *p)
1361 1.1 cgd {
1362 1.61 dsl struct pgrp *pgrp;
1363 1.1 cgd
1364 1.136 ad KASSERT(mutex_owned(proc_lock));
1365 1.100 ad
1366 1.139 ad /* Interlock with ttread() */
1367 1.128 ad mutex_spin_enter(&tty_lock);
1368 1.61 dsl pgrp = p->p_pgrp;
1369 1.10 mycroft LIST_REMOVE(p, p_pglist);
1370 1.94 ad p->p_pgrp = NULL;
1371 1.128 ad mutex_spin_exit(&tty_lock);
1372 1.100 ad
1373 1.151 rmind if (LIST_EMPTY(&pgrp->pg_members)) {
1374 1.151 rmind /* Releases proc_lock. */
1375 1.100 ad pg_delete(pgrp->pg_id);
1376 1.151 rmind } else {
1377 1.151 rmind mutex_exit(proc_lock);
1378 1.151 rmind }
1379 1.61 dsl }
1380 1.61 dsl
1381 1.100 ad /*
1382 1.151 rmind * pg_remove: remove a process group from the table.
1383 1.151 rmind * => must be called with the proc_lock held;
1384 1.151 rmind * => returns process group to free;
1385 1.100 ad */
1386 1.151 rmind static struct pgrp *
1387 1.151 rmind pg_remove(pid_t pg_id)
1388 1.61 dsl {
1389 1.61 dsl struct pgrp *pgrp;
1390 1.61 dsl struct pid_table *pt;
1391 1.61 dsl
1392 1.136 ad KASSERT(mutex_owned(proc_lock));
1393 1.247 thorpej KASSERT(rw_write_held(&pid_table_lock));
1394 1.100 ad
1395 1.61 dsl pt = &pid_table[pg_id & pid_tbl_mask];
1396 1.61 dsl pgrp = pt->pt_pgrp;
1397 1.151 rmind
1398 1.151 rmind KASSERT(pgrp != NULL);
1399 1.151 rmind KASSERT(pgrp->pg_id == pg_id);
1400 1.151 rmind KASSERT(LIST_EMPTY(&pgrp->pg_members));
1401 1.151 rmind
1402 1.151 rmind pt->pt_pgrp = NULL;
1403 1.61 dsl
1404 1.247 thorpej if (!PT_VALID(pt->pt_slot)) {
1405 1.151 rmind /* Orphaned pgrp, put slot onto free list. */
1406 1.247 thorpej KASSERT((PT_NEXT(pt->pt_slot) & pid_tbl_mask) == 0);
1407 1.61 dsl pg_id &= pid_tbl_mask;
1408 1.61 dsl pt = &pid_table[last_free_pt];
1409 1.247 thorpej pt->pt_slot = PT_SET_FREE(PT_NEXT(pt->pt_slot) | pg_id);
1410 1.168 chs KASSERT(pt->pt_pid == 0);
1411 1.61 dsl last_free_pt = pg_id;
1412 1.61 dsl pid_alloc_cnt--;
1413 1.61 dsl }
1414 1.151 rmind return pgrp;
1415 1.1 cgd }
1416 1.1 cgd
1417 1.1 cgd /*
1418 1.151 rmind * pg_delete: delete and free a process group.
1419 1.151 rmind * => must be called with the proc_lock held, which will be released.
1420 1.1 cgd */
1421 1.61 dsl static void
1422 1.61 dsl pg_delete(pid_t pg_id)
1423 1.61 dsl {
1424 1.151 rmind struct pgrp *pg;
1425 1.61 dsl struct tty *ttyp;
1426 1.61 dsl struct session *ss;
1427 1.100 ad
1428 1.136 ad KASSERT(mutex_owned(proc_lock));
1429 1.61 dsl
1430 1.247 thorpej rw_enter(&pid_table_lock, RW_WRITER);
1431 1.151 rmind pg = pid_table[pg_id & pid_tbl_mask].pt_pgrp;
1432 1.151 rmind if (pg == NULL || pg->pg_id != pg_id || !LIST_EMPTY(&pg->pg_members)) {
1433 1.247 thorpej rw_exit(&pid_table_lock);
1434 1.151 rmind mutex_exit(proc_lock);
1435 1.61 dsl return;
1436 1.151 rmind }
1437 1.61 dsl
1438 1.151 rmind ss = pg->pg_session;
1439 1.71 pk
1440 1.61 dsl /* Remove reference (if any) from tty to this process group */
1441 1.128 ad mutex_spin_enter(&tty_lock);
1442 1.71 pk ttyp = ss->s_ttyp;
1443 1.151 rmind if (ttyp != NULL && ttyp->t_pgrp == pg) {
1444 1.61 dsl ttyp->t_pgrp = NULL;
1445 1.151 rmind KASSERT(ttyp->t_session == ss);
1446 1.71 pk }
1447 1.128 ad mutex_spin_exit(&tty_lock);
1448 1.61 dsl
1449 1.71 pk /*
1450 1.247 thorpej * The leading process group in a session is freed by
1451 1.247 thorpej * proc_sessrele_pid_table_write_locked(), if last
1452 1.247 thorpej * reference. It will also release the locks.
1453 1.71 pk */
1454 1.151 rmind pg = (ss->s_sid != pg->pg_id) ? pg_remove(pg_id) : NULL;
1455 1.247 thorpej proc_sessrele_pid_table_write_locked(ss);
1456 1.61 dsl
1457 1.151 rmind if (pg != NULL) {
1458 1.247 thorpej /* Free it, if was not done above. */
1459 1.151 rmind kmem_free(pg, sizeof(struct pgrp));
1460 1.151 rmind }
1461 1.1 cgd }
1462 1.1 cgd
1463 1.1 cgd /*
1464 1.1 cgd * Adjust pgrp jobc counters when specified process changes process group.
1465 1.1 cgd * We count the number of processes in each process group that "qualify"
1466 1.1 cgd * the group for terminal job control (those with a parent in a different
1467 1.1 cgd * process group of the same session). If that count reaches zero, the
1468 1.1 cgd * process group becomes orphaned. Check both the specified process'
1469 1.1 cgd * process group and that of its children.
1470 1.1 cgd * entering == 0 => p is leaving specified group.
1471 1.1 cgd * entering == 1 => p is entering specified group.
1472 1.68 dsl *
1473 1.136 ad * Call with proc_lock held.
1474 1.1 cgd */
1475 1.4 andrew void
1476 1.59 dsl fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
1477 1.1 cgd {
1478 1.39 augustss struct pgrp *hispgrp;
1479 1.39 augustss struct session *mysession = pgrp->pg_session;
1480 1.68 dsl struct proc *child;
1481 1.1 cgd
1482 1.136 ad KASSERT(mutex_owned(proc_lock));
1483 1.100 ad
1484 1.1 cgd /*
1485 1.1 cgd * Check p's parent to see whether p qualifies its own process
1486 1.1 cgd * group; if so, adjust count for p's process group.
1487 1.1 cgd */
1488 1.68 dsl hispgrp = p->p_pptr->p_pgrp;
1489 1.68 dsl if (hispgrp != pgrp && hispgrp->pg_session == mysession) {
1490 1.100 ad if (entering) {
1491 1.1 cgd pgrp->pg_jobc++;
1492 1.136 ad p->p_lflag &= ~PL_ORPHANPG;
1493 1.245 maxv } else {
1494 1.245 maxv KASSERT(pgrp->pg_jobc > 0);
1495 1.245 maxv if (--pgrp->pg_jobc == 0)
1496 1.245 maxv orphanpg(pgrp);
1497 1.245 maxv }
1498 1.26 thorpej }
1499 1.1 cgd
1500 1.1 cgd /*
1501 1.1 cgd * Check this process' children to see whether they qualify
1502 1.1 cgd * their process groups; if so, adjust counts for children's
1503 1.1 cgd * process groups.
1504 1.1 cgd */
1505 1.68 dsl LIST_FOREACH(child, &p->p_children, p_sibling) {
1506 1.68 dsl hispgrp = child->p_pgrp;
1507 1.68 dsl if (hispgrp != pgrp && hispgrp->pg_session == mysession &&
1508 1.68 dsl !P_ZOMBIE(child)) {
1509 1.100 ad if (entering) {
1510 1.136 ad child->p_lflag &= ~PL_ORPHANPG;
1511 1.1 cgd hispgrp->pg_jobc++;
1512 1.245 maxv } else {
1513 1.245 maxv KASSERT(hispgrp->pg_jobc > 0);
1514 1.245 maxv if (--hispgrp->pg_jobc == 0)
1515 1.245 maxv orphanpg(hispgrp);
1516 1.245 maxv }
1517 1.26 thorpej }
1518 1.26 thorpej }
1519 1.1 cgd }
1520 1.1 cgd
1521 1.72 junyoung /*
1522 1.1 cgd * A process group has become orphaned;
1523 1.1 cgd * if there are any stopped processes in the group,
1524 1.1 cgd * hang-up all process in that group.
1525 1.68 dsl *
1526 1.136 ad * Call with proc_lock held.
1527 1.1 cgd */
1528 1.4 andrew static void
1529 1.59 dsl orphanpg(struct pgrp *pg)
1530 1.1 cgd {
1531 1.39 augustss struct proc *p;
1532 1.100 ad
1533 1.136 ad KASSERT(mutex_owned(proc_lock));
1534 1.100 ad
1535 1.52 matt LIST_FOREACH(p, &pg->pg_members, p_pglist) {
1536 1.1 cgd if (p->p_stat == SSTOP) {
1537 1.136 ad p->p_lflag |= PL_ORPHANPG;
1538 1.100 ad psignal(p, SIGHUP);
1539 1.100 ad psignal(p, SIGCONT);
1540 1.35 bouyer }
1541 1.35 bouyer }
1542 1.35 bouyer }
1543 1.1 cgd
1544 1.61 dsl #ifdef DDB
1545 1.61 dsl #include <ddb/db_output.h>
1546 1.61 dsl void pidtbl_dump(void);
1547 1.14 christos void
1548 1.61 dsl pidtbl_dump(void)
1549 1.1 cgd {
1550 1.61 dsl struct pid_table *pt;
1551 1.61 dsl struct proc *p;
1552 1.39 augustss struct pgrp *pgrp;
1553 1.247 thorpej uintptr_t slot;
1554 1.61 dsl int id;
1555 1.1 cgd
1556 1.61 dsl db_printf("pid table %p size %x, next %x, last %x\n",
1557 1.61 dsl pid_table, pid_tbl_mask+1,
1558 1.61 dsl next_free_pt, last_free_pt);
1559 1.61 dsl for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) {
1560 1.247 thorpej slot = pt->pt_slot;
1561 1.247 thorpej if (!PT_VALID(slot) && !pt->pt_pgrp)
1562 1.61 dsl continue;
1563 1.247 thorpej if (PT_IS_LWP(slot)) {
1564 1.247 thorpej p = PT_GET_LWP(slot)->l_proc;
1565 1.247 thorpej } else if (PT_IS_PROC(slot)) {
1566 1.247 thorpej p = PT_GET_PROC(slot);
1567 1.247 thorpej } else {
1568 1.247 thorpej p = NULL;
1569 1.247 thorpej }
1570 1.61 dsl db_printf(" id %x: ", id);
1571 1.247 thorpej if (p != NULL)
1572 1.168 chs db_printf("slotpid %d proc %p id %d (0x%x) %s\n",
1573 1.168 chs pt->pt_pid, p, p->p_pid, p->p_pid, p->p_comm);
1574 1.61 dsl else
1575 1.61 dsl db_printf("next %x use %x\n",
1576 1.247 thorpej PT_NEXT(slot) & pid_tbl_mask,
1577 1.247 thorpej PT_NEXT(slot) & ~pid_tbl_mask);
1578 1.61 dsl if ((pgrp = pt->pt_pgrp)) {
1579 1.61 dsl db_printf("\tsession %p, sid %d, count %d, login %s\n",
1580 1.61 dsl pgrp->pg_session, pgrp->pg_session->s_sid,
1581 1.61 dsl pgrp->pg_session->s_count,
1582 1.61 dsl pgrp->pg_session->s_login);
1583 1.61 dsl db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n",
1584 1.61 dsl pgrp, pgrp->pg_id, pgrp->pg_jobc,
1585 1.135 yamt LIST_FIRST(&pgrp->pg_members));
1586 1.135 yamt LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
1587 1.72 junyoung db_printf("\t\tpid %d addr %p pgrp %p %s\n",
1588 1.61 dsl p->p_pid, p, p->p_pgrp, p->p_comm);
1589 1.10 mycroft }
1590 1.1 cgd }
1591 1.1 cgd }
1592 1.1 cgd }
1593 1.61 dsl #endif /* DDB */
1594 1.48 yamt
1595 1.48 yamt #ifdef KSTACK_CHECK_MAGIC
1596 1.48 yamt
1597 1.48 yamt #define KSTACK_MAGIC 0xdeadbeaf
1598 1.48 yamt
1599 1.48 yamt /* XXX should be per process basis? */
1600 1.149 rmind static int kstackleftmin = KSTACK_SIZE;
1601 1.149 rmind static int kstackleftthres = KSTACK_SIZE / 8;
1602 1.48 yamt
1603 1.48 yamt void
1604 1.56 yamt kstack_setup_magic(const struct lwp *l)
1605 1.48 yamt {
1606 1.85 perry uint32_t *ip;
1607 1.85 perry uint32_t const *end;
1608 1.48 yamt
1609 1.56 yamt KASSERT(l != NULL);
1610 1.56 yamt KASSERT(l != &lwp0);
1611 1.48 yamt
1612 1.48 yamt /*
1613 1.48 yamt * fill all the stack with magic number
1614 1.48 yamt * so that later modification on it can be detected.
1615 1.48 yamt */
1616 1.85 perry ip = (uint32_t *)KSTACK_LOWEST_ADDR(l);
1617 1.114 dyoung end = (uint32_t *)((char *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1618 1.48 yamt for (; ip < end; ip++) {
1619 1.48 yamt *ip = KSTACK_MAGIC;
1620 1.48 yamt }
1621 1.48 yamt }
1622 1.48 yamt
1623 1.48 yamt void
1624 1.56 yamt kstack_check_magic(const struct lwp *l)
1625 1.48 yamt {
1626 1.85 perry uint32_t const *ip, *end;
1627 1.48 yamt int stackleft;
1628 1.48 yamt
1629 1.56 yamt KASSERT(l != NULL);
1630 1.48 yamt
1631 1.48 yamt /* don't check proc0 */ /*XXX*/
1632 1.56 yamt if (l == &lwp0)
1633 1.48 yamt return;
1634 1.48 yamt
1635 1.48 yamt #ifdef __MACHINE_STACK_GROWS_UP
1636 1.48 yamt /* stack grows upwards (eg. hppa) */
1637 1.106 christos ip = (uint32_t *)((void *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1638 1.85 perry end = (uint32_t *)KSTACK_LOWEST_ADDR(l);
1639 1.48 yamt for (ip--; ip >= end; ip--)
1640 1.48 yamt if (*ip != KSTACK_MAGIC)
1641 1.48 yamt break;
1642 1.72 junyoung
1643 1.106 christos stackleft = (void *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (void *)ip;
1644 1.48 yamt #else /* __MACHINE_STACK_GROWS_UP */
1645 1.48 yamt /* stack grows downwards (eg. i386) */
1646 1.85 perry ip = (uint32_t *)KSTACK_LOWEST_ADDR(l);
1647 1.114 dyoung end = (uint32_t *)((char *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1648 1.48 yamt for (; ip < end; ip++)
1649 1.48 yamt if (*ip != KSTACK_MAGIC)
1650 1.48 yamt break;
1651 1.48 yamt
1652 1.93 christos stackleft = ((const char *)ip) - (const char *)KSTACK_LOWEST_ADDR(l);
1653 1.48 yamt #endif /* __MACHINE_STACK_GROWS_UP */
1654 1.48 yamt
1655 1.48 yamt if (kstackleftmin > stackleft) {
1656 1.48 yamt kstackleftmin = stackleft;
1657 1.48 yamt if (stackleft < kstackleftthres)
1658 1.56 yamt printf("warning: kernel stack left %d bytes"
1659 1.56 yamt "(pid %u:lid %u)\n", stackleft,
1660 1.56 yamt (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
1661 1.48 yamt }
1662 1.48 yamt
1663 1.48 yamt if (stackleft <= 0) {
1664 1.56 yamt panic("magic on the top of kernel stack changed for "
1665 1.56 yamt "pid %u, lid %u: maybe kernel stack overflow",
1666 1.56 yamt (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
1667 1.48 yamt }
1668 1.48 yamt }
1669 1.50 enami #endif /* KSTACK_CHECK_MAGIC */
1670 1.79 yamt
1671 1.79 yamt int
1672 1.79 yamt proclist_foreach_call(struct proclist *list,
1673 1.79 yamt int (*callback)(struct proc *, void *arg), void *arg)
1674 1.79 yamt {
1675 1.79 yamt struct proc marker;
1676 1.79 yamt struct proc *p;
1677 1.79 yamt int ret = 0;
1678 1.79 yamt
1679 1.102 pavel marker.p_flag = PK_MARKER;
1680 1.136 ad mutex_enter(proc_lock);
1681 1.79 yamt for (p = LIST_FIRST(list); ret == 0 && p != NULL;) {
1682 1.102 pavel if (p->p_flag & PK_MARKER) {
1683 1.79 yamt p = LIST_NEXT(p, p_list);
1684 1.79 yamt continue;
1685 1.79 yamt }
1686 1.79 yamt LIST_INSERT_AFTER(p, &marker, p_list);
1687 1.79 yamt ret = (*callback)(p, arg);
1688 1.136 ad KASSERT(mutex_owned(proc_lock));
1689 1.79 yamt p = LIST_NEXT(&marker, p_list);
1690 1.79 yamt LIST_REMOVE(&marker, p_list);
1691 1.79 yamt }
1692 1.136 ad mutex_exit(proc_lock);
1693 1.79 yamt
1694 1.79 yamt return ret;
1695 1.79 yamt }
1696 1.86 yamt
1697 1.86 yamt int
1698 1.86 yamt proc_vmspace_getref(struct proc *p, struct vmspace **vm)
1699 1.86 yamt {
1700 1.86 yamt
1701 1.86 yamt /* XXXCDC: how should locking work here? */
1702 1.86 yamt
1703 1.87 yamt /* curproc exception is for coredump. */
1704 1.87 yamt
1705 1.100 ad if ((p != curproc && (p->p_sflag & PS_WEXIT) != 0) ||
1706 1.86 yamt (p->p_vmspace->vm_refcnt < 1)) { /* XXX */
1707 1.86 yamt return EFAULT;
1708 1.86 yamt }
1709 1.86 yamt
1710 1.86 yamt uvmspace_addref(p->p_vmspace);
1711 1.86 yamt *vm = p->p_vmspace;
1712 1.86 yamt
1713 1.86 yamt return 0;
1714 1.86 yamt }
1715 1.94 ad
1716 1.94 ad /*
1717 1.94 ad * Acquire a write lock on the process credential.
1718 1.94 ad */
1719 1.94 ad void
1720 1.100 ad proc_crmod_enter(void)
1721 1.94 ad {
1722 1.100 ad struct lwp *l = curlwp;
1723 1.100 ad struct proc *p = l->l_proc;
1724 1.100 ad kauth_cred_t oc;
1725 1.94 ad
1726 1.117 dsl /* Reset what needs to be reset in plimit. */
1727 1.117 dsl if (p->p_limit->pl_corename != defcorename) {
1728 1.178 rmind lim_setcorename(p, defcorename, 0);
1729 1.117 dsl }
1730 1.117 dsl
1731 1.137 ad mutex_enter(p->p_lock);
1732 1.100 ad
1733 1.100 ad /* Ensure the LWP cached credentials are up to date. */
1734 1.100 ad if ((oc = l->l_cred) != p->p_cred) {
1735 1.100 ad kauth_cred_hold(p->p_cred);
1736 1.100 ad l->l_cred = p->p_cred;
1737 1.100 ad kauth_cred_free(oc);
1738 1.100 ad }
1739 1.94 ad }
1740 1.94 ad
1741 1.94 ad /*
1742 1.100 ad * Set in a new process credential, and drop the write lock. The credential
1743 1.100 ad * must have a reference already. Optionally, free a no-longer required
1744 1.100 ad * credential. The scheduler also needs to inspect p_cred, so we also
1745 1.100 ad * briefly acquire the sched state mutex.
1746 1.94 ad */
1747 1.94 ad void
1748 1.104 thorpej proc_crmod_leave(kauth_cred_t scred, kauth_cred_t fcred, bool sugid)
1749 1.94 ad {
1750 1.133 ad struct lwp *l = curlwp, *l2;
1751 1.100 ad struct proc *p = l->l_proc;
1752 1.100 ad kauth_cred_t oc;
1753 1.100 ad
1754 1.137 ad KASSERT(mutex_owned(p->p_lock));
1755 1.137 ad
1756 1.100 ad /* Is there a new credential to set in? */
1757 1.100 ad if (scred != NULL) {
1758 1.100 ad p->p_cred = scred;
1759 1.133 ad LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
1760 1.133 ad if (l2 != l)
1761 1.133 ad l2->l_prflag |= LPR_CRMOD;
1762 1.133 ad }
1763 1.100 ad
1764 1.100 ad /* Ensure the LWP cached credentials are up to date. */
1765 1.100 ad if ((oc = l->l_cred) != scred) {
1766 1.100 ad kauth_cred_hold(scred);
1767 1.100 ad l->l_cred = scred;
1768 1.100 ad }
1769 1.100 ad } else
1770 1.100 ad oc = NULL; /* XXXgcc */
1771 1.100 ad
1772 1.100 ad if (sugid) {
1773 1.100 ad /*
1774 1.100 ad * Mark process as having changed credentials, stops
1775 1.100 ad * tracing etc.
1776 1.100 ad */
1777 1.102 pavel p->p_flag |= PK_SUGID;
1778 1.100 ad }
1779 1.94 ad
1780 1.137 ad mutex_exit(p->p_lock);
1781 1.100 ad
1782 1.100 ad /* If there is a credential to be released, free it now. */
1783 1.100 ad if (fcred != NULL) {
1784 1.100 ad KASSERT(scred != NULL);
1785 1.94 ad kauth_cred_free(fcred);
1786 1.100 ad if (oc != scred)
1787 1.100 ad kauth_cred_free(oc);
1788 1.100 ad }
1789 1.100 ad }
1790 1.100 ad
1791 1.100 ad /*
1792 1.95 thorpej * proc_specific_key_create --
1793 1.95 thorpej * Create a key for subsystem proc-specific data.
1794 1.95 thorpej */
1795 1.95 thorpej int
1796 1.95 thorpej proc_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor)
1797 1.95 thorpej {
1798 1.95 thorpej
1799 1.98 thorpej return (specificdata_key_create(proc_specificdata_domain, keyp, dtor));
1800 1.95 thorpej }
1801 1.95 thorpej
1802 1.95 thorpej /*
1803 1.95 thorpej * proc_specific_key_delete --
1804 1.95 thorpej * Delete a key for subsystem proc-specific data.
1805 1.95 thorpej */
1806 1.95 thorpej void
1807 1.95 thorpej proc_specific_key_delete(specificdata_key_t key)
1808 1.95 thorpej {
1809 1.95 thorpej
1810 1.95 thorpej specificdata_key_delete(proc_specificdata_domain, key);
1811 1.95 thorpej }
1812 1.95 thorpej
1813 1.98 thorpej /*
1814 1.98 thorpej * proc_initspecific --
1815 1.98 thorpej * Initialize a proc's specificdata container.
1816 1.98 thorpej */
1817 1.96 christos void
1818 1.96 christos proc_initspecific(struct proc *p)
1819 1.96 christos {
1820 1.189 martin int error __diagused;
1821 1.98 thorpej
1822 1.96 christos error = specificdata_init(proc_specificdata_domain, &p->p_specdataref);
1823 1.96 christos KASSERT(error == 0);
1824 1.96 christos }
1825 1.96 christos
1826 1.95 thorpej /*
1827 1.98 thorpej * proc_finispecific --
1828 1.98 thorpej * Finalize a proc's specificdata container.
1829 1.98 thorpej */
1830 1.98 thorpej void
1831 1.98 thorpej proc_finispecific(struct proc *p)
1832 1.98 thorpej {
1833 1.98 thorpej
1834 1.98 thorpej specificdata_fini(proc_specificdata_domain, &p->p_specdataref);
1835 1.98 thorpej }
1836 1.98 thorpej
1837 1.98 thorpej /*
1838 1.95 thorpej * proc_getspecific --
1839 1.95 thorpej * Return proc-specific data corresponding to the specified key.
1840 1.95 thorpej */
1841 1.95 thorpej void *
1842 1.95 thorpej proc_getspecific(struct proc *p, specificdata_key_t key)
1843 1.95 thorpej {
1844 1.95 thorpej
1845 1.95 thorpej return (specificdata_getspecific(proc_specificdata_domain,
1846 1.95 thorpej &p->p_specdataref, key));
1847 1.95 thorpej }
1848 1.95 thorpej
1849 1.95 thorpej /*
1850 1.95 thorpej * proc_setspecific --
1851 1.95 thorpej * Set proc-specific data corresponding to the specified key.
1852 1.95 thorpej */
1853 1.95 thorpej void
1854 1.95 thorpej proc_setspecific(struct proc *p, specificdata_key_t key, void *data)
1855 1.95 thorpej {
1856 1.95 thorpej
1857 1.95 thorpej specificdata_setspecific(proc_specificdata_domain,
1858 1.95 thorpej &p->p_specdataref, key, data);
1859 1.95 thorpej }
1860 1.154 elad
1861 1.154 elad int
1862 1.154 elad proc_uidmatch(kauth_cred_t cred, kauth_cred_t target)
1863 1.154 elad {
1864 1.154 elad int r = 0;
1865 1.154 elad
1866 1.154 elad if (kauth_cred_getuid(cred) != kauth_cred_getuid(target) ||
1867 1.154 elad kauth_cred_getuid(cred) != kauth_cred_getsvuid(target)) {
1868 1.154 elad /*
1869 1.154 elad * suid proc of ours or proc not ours
1870 1.154 elad */
1871 1.154 elad r = EPERM;
1872 1.154 elad } else if (kauth_cred_getgid(target) != kauth_cred_getsvgid(target)) {
1873 1.154 elad /*
1874 1.154 elad * sgid proc has sgid back to us temporarily
1875 1.154 elad */
1876 1.154 elad r = EPERM;
1877 1.154 elad } else {
1878 1.154 elad /*
1879 1.154 elad * our rgid must be in target's group list (ie,
1880 1.154 elad * sub-processes started by a sgid process)
1881 1.154 elad */
1882 1.154 elad int ismember = 0;
1883 1.154 elad
1884 1.154 elad if (kauth_cred_ismember_gid(cred,
1885 1.154 elad kauth_cred_getgid(target), &ismember) != 0 ||
1886 1.154 elad !ismember)
1887 1.154 elad r = EPERM;
1888 1.154 elad }
1889 1.154 elad
1890 1.154 elad return (r);
1891 1.154 elad }
1892 1.170 pooka
1893 1.170 pooka /*
1894 1.170 pooka * sysctl stuff
1895 1.170 pooka */
1896 1.170 pooka
1897 1.170 pooka #define KERN_PROCSLOP (5 * sizeof(struct kinfo_proc))
1898 1.170 pooka
1899 1.170 pooka static const u_int sysctl_flagmap[] = {
1900 1.170 pooka PK_ADVLOCK, P_ADVLOCK,
1901 1.170 pooka PK_EXEC, P_EXEC,
1902 1.170 pooka PK_NOCLDWAIT, P_NOCLDWAIT,
1903 1.170 pooka PK_32, P_32,
1904 1.170 pooka PK_CLDSIGIGN, P_CLDSIGIGN,
1905 1.170 pooka PK_SUGID, P_SUGID,
1906 1.170 pooka 0
1907 1.170 pooka };
1908 1.170 pooka
1909 1.170 pooka static const u_int sysctl_sflagmap[] = {
1910 1.170 pooka PS_NOCLDSTOP, P_NOCLDSTOP,
1911 1.170 pooka PS_WEXIT, P_WEXIT,
1912 1.170 pooka PS_STOPFORK, P_STOPFORK,
1913 1.170 pooka PS_STOPEXEC, P_STOPEXEC,
1914 1.170 pooka PS_STOPEXIT, P_STOPEXIT,
1915 1.170 pooka 0
1916 1.170 pooka };
1917 1.170 pooka
1918 1.170 pooka static const u_int sysctl_slflagmap[] = {
1919 1.170 pooka PSL_TRACED, P_TRACED,
1920 1.170 pooka PSL_CHTRACED, P_CHTRACED,
1921 1.170 pooka PSL_SYSCALL, P_SYSCALL,
1922 1.170 pooka 0
1923 1.170 pooka };
1924 1.170 pooka
1925 1.170 pooka static const u_int sysctl_lflagmap[] = {
1926 1.170 pooka PL_CONTROLT, P_CONTROLT,
1927 1.170 pooka PL_PPWAIT, P_PPWAIT,
1928 1.170 pooka 0
1929 1.170 pooka };
1930 1.170 pooka
1931 1.170 pooka static const u_int sysctl_stflagmap[] = {
1932 1.170 pooka PST_PROFIL, P_PROFIL,
1933 1.170 pooka 0
1934 1.170 pooka
1935 1.170 pooka };
1936 1.170 pooka
1937 1.170 pooka /* used by kern_lwp also */
1938 1.170 pooka const u_int sysctl_lwpflagmap[] = {
1939 1.170 pooka LW_SINTR, L_SINTR,
1940 1.170 pooka LW_SYSTEM, L_SYSTEM,
1941 1.170 pooka 0
1942 1.170 pooka };
1943 1.170 pooka
1944 1.170 pooka /*
1945 1.170 pooka * Find the most ``active'' lwp of a process and return it for ps display
1946 1.170 pooka * purposes
1947 1.170 pooka */
1948 1.170 pooka static struct lwp *
1949 1.170 pooka proc_active_lwp(struct proc *p)
1950 1.170 pooka {
1951 1.170 pooka static const int ostat[] = {
1952 1.170 pooka 0,
1953 1.170 pooka 2, /* LSIDL */
1954 1.170 pooka 6, /* LSRUN */
1955 1.170 pooka 5, /* LSSLEEP */
1956 1.170 pooka 4, /* LSSTOP */
1957 1.170 pooka 0, /* LSZOMB */
1958 1.170 pooka 1, /* LSDEAD */
1959 1.170 pooka 7, /* LSONPROC */
1960 1.170 pooka 3 /* LSSUSPENDED */
1961 1.170 pooka };
1962 1.170 pooka
1963 1.170 pooka struct lwp *l, *lp = NULL;
1964 1.170 pooka LIST_FOREACH(l, &p->p_lwps, l_sibling) {
1965 1.170 pooka KASSERT(l->l_stat >= 0 && l->l_stat < __arraycount(ostat));
1966 1.170 pooka if (lp == NULL ||
1967 1.170 pooka ostat[l->l_stat] > ostat[lp->l_stat] ||
1968 1.170 pooka (ostat[l->l_stat] == ostat[lp->l_stat] &&
1969 1.170 pooka l->l_cpticks > lp->l_cpticks)) {
1970 1.170 pooka lp = l;
1971 1.170 pooka continue;
1972 1.170 pooka }
1973 1.170 pooka }
1974 1.170 pooka return lp;
1975 1.170 pooka }
1976 1.170 pooka
1977 1.170 pooka static int
1978 1.170 pooka sysctl_doeproc(SYSCTLFN_ARGS)
1979 1.170 pooka {
1980 1.170 pooka union {
1981 1.170 pooka struct kinfo_proc kproc;
1982 1.170 pooka struct kinfo_proc2 kproc2;
1983 1.170 pooka } *kbuf;
1984 1.170 pooka struct proc *p, *next, *marker;
1985 1.170 pooka char *where, *dp;
1986 1.170 pooka int type, op, arg, error;
1987 1.170 pooka u_int elem_size, kelem_size, elem_count;
1988 1.170 pooka size_t buflen, needed;
1989 1.170 pooka bool match, zombie, mmmbrains;
1990 1.222 christos const bool allowaddr = get_expose_address(curproc);
1991 1.170 pooka
1992 1.170 pooka if (namelen == 1 && name[0] == CTL_QUERY)
1993 1.170 pooka return (sysctl_query(SYSCTLFN_CALL(rnode)));
1994 1.170 pooka
1995 1.170 pooka dp = where = oldp;
1996 1.170 pooka buflen = where != NULL ? *oldlenp : 0;
1997 1.170 pooka error = 0;
1998 1.170 pooka needed = 0;
1999 1.170 pooka type = rnode->sysctl_num;
2000 1.170 pooka
2001 1.170 pooka if (type == KERN_PROC) {
2002 1.194 christos if (namelen == 0)
2003 1.194 christos return EINVAL;
2004 1.194 christos switch (op = name[0]) {
2005 1.194 christos case KERN_PROC_ALL:
2006 1.194 christos if (namelen != 1)
2007 1.194 christos return EINVAL;
2008 1.194 christos arg = 0;
2009 1.194 christos break;
2010 1.194 christos default:
2011 1.194 christos if (namelen != 2)
2012 1.194 christos return EINVAL;
2013 1.170 pooka arg = name[1];
2014 1.194 christos break;
2015 1.194 christos }
2016 1.210 kre elem_count = 0; /* Hush little compiler, don't you cry */
2017 1.170 pooka kelem_size = elem_size = sizeof(kbuf->kproc);
2018 1.170 pooka } else {
2019 1.170 pooka if (namelen != 4)
2020 1.194 christos return EINVAL;
2021 1.170 pooka op = name[0];
2022 1.170 pooka arg = name[1];
2023 1.170 pooka elem_size = name[2];
2024 1.170 pooka elem_count = name[3];
2025 1.170 pooka kelem_size = sizeof(kbuf->kproc2);
2026 1.170 pooka }
2027 1.170 pooka
2028 1.170 pooka sysctl_unlock();
2029 1.170 pooka
2030 1.221 christos kbuf = kmem_zalloc(sizeof(*kbuf), KM_SLEEP);
2031 1.170 pooka marker = kmem_alloc(sizeof(*marker), KM_SLEEP);
2032 1.170 pooka marker->p_flag = PK_MARKER;
2033 1.170 pooka
2034 1.170 pooka mutex_enter(proc_lock);
2035 1.211 kamil /*
2036 1.211 kamil * Start with zombies to prevent reporting processes twice, in case they
2037 1.211 kamil * are dying and being moved from the list of alive processes to zombies.
2038 1.211 kamil */
2039 1.211 kamil mmmbrains = true;
2040 1.211 kamil for (p = LIST_FIRST(&zombproc);; p = next) {
2041 1.170 pooka if (p == NULL) {
2042 1.211 kamil if (mmmbrains) {
2043 1.211 kamil p = LIST_FIRST(&allproc);
2044 1.211 kamil mmmbrains = false;
2045 1.170 pooka }
2046 1.170 pooka if (p == NULL)
2047 1.170 pooka break;
2048 1.170 pooka }
2049 1.170 pooka next = LIST_NEXT(p, p_list);
2050 1.170 pooka if ((p->p_flag & PK_MARKER) != 0)
2051 1.170 pooka continue;
2052 1.170 pooka
2053 1.170 pooka /*
2054 1.170 pooka * Skip embryonic processes.
2055 1.170 pooka */
2056 1.170 pooka if (p->p_stat == SIDL)
2057 1.170 pooka continue;
2058 1.170 pooka
2059 1.170 pooka mutex_enter(p->p_lock);
2060 1.170 pooka error = kauth_authorize_process(l->l_cred,
2061 1.170 pooka KAUTH_PROCESS_CANSEE, p,
2062 1.213 maxv KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_EPROC), NULL, NULL);
2063 1.170 pooka if (error != 0) {
2064 1.170 pooka mutex_exit(p->p_lock);
2065 1.170 pooka continue;
2066 1.170 pooka }
2067 1.170 pooka
2068 1.170 pooka /*
2069 1.211 kamil * Hande all the operations in one switch on the cost of
2070 1.211 kamil * algorithm complexity is on purpose. The win splitting this
2071 1.211 kamil * function into several similar copies makes maintenance burden
2072 1.211 kamil * burden, code grow and boost is neglible in practical systems.
2073 1.170 pooka */
2074 1.170 pooka switch (op) {
2075 1.170 pooka case KERN_PROC_PID:
2076 1.170 pooka match = (p->p_pid == (pid_t)arg);
2077 1.170 pooka break;
2078 1.170 pooka
2079 1.170 pooka case KERN_PROC_PGRP:
2080 1.170 pooka match = (p->p_pgrp->pg_id == (pid_t)arg);
2081 1.170 pooka break;
2082 1.170 pooka
2083 1.170 pooka case KERN_PROC_SESSION:
2084 1.170 pooka match = (p->p_session->s_sid == (pid_t)arg);
2085 1.170 pooka break;
2086 1.170 pooka
2087 1.170 pooka case KERN_PROC_TTY:
2088 1.170 pooka match = true;
2089 1.170 pooka if (arg == (int) KERN_PROC_TTY_REVOKE) {
2090 1.170 pooka if ((p->p_lflag & PL_CONTROLT) == 0 ||
2091 1.170 pooka p->p_session->s_ttyp == NULL ||
2092 1.170 pooka p->p_session->s_ttyvp != NULL) {
2093 1.170 pooka match = false;
2094 1.170 pooka }
2095 1.170 pooka } else if ((p->p_lflag & PL_CONTROLT) == 0 ||
2096 1.170 pooka p->p_session->s_ttyp == NULL) {
2097 1.170 pooka if ((dev_t)arg != KERN_PROC_TTY_NODEV) {
2098 1.170 pooka match = false;
2099 1.170 pooka }
2100 1.170 pooka } else if (p->p_session->s_ttyp->t_dev != (dev_t)arg) {
2101 1.170 pooka match = false;
2102 1.170 pooka }
2103 1.170 pooka break;
2104 1.170 pooka
2105 1.170 pooka case KERN_PROC_UID:
2106 1.170 pooka match = (kauth_cred_geteuid(p->p_cred) == (uid_t)arg);
2107 1.170 pooka break;
2108 1.170 pooka
2109 1.170 pooka case KERN_PROC_RUID:
2110 1.170 pooka match = (kauth_cred_getuid(p->p_cred) == (uid_t)arg);
2111 1.170 pooka break;
2112 1.170 pooka
2113 1.170 pooka case KERN_PROC_GID:
2114 1.170 pooka match = (kauth_cred_getegid(p->p_cred) == (uid_t)arg);
2115 1.170 pooka break;
2116 1.170 pooka
2117 1.170 pooka case KERN_PROC_RGID:
2118 1.170 pooka match = (kauth_cred_getgid(p->p_cred) == (uid_t)arg);
2119 1.170 pooka break;
2120 1.170 pooka
2121 1.170 pooka case KERN_PROC_ALL:
2122 1.170 pooka match = true;
2123 1.170 pooka /* allow everything */
2124 1.170 pooka break;
2125 1.170 pooka
2126 1.170 pooka default:
2127 1.170 pooka error = EINVAL;
2128 1.170 pooka mutex_exit(p->p_lock);
2129 1.170 pooka goto cleanup;
2130 1.170 pooka }
2131 1.170 pooka if (!match) {
2132 1.170 pooka mutex_exit(p->p_lock);
2133 1.170 pooka continue;
2134 1.170 pooka }
2135 1.170 pooka
2136 1.170 pooka /*
2137 1.170 pooka * Grab a hold on the process.
2138 1.170 pooka */
2139 1.170 pooka if (mmmbrains) {
2140 1.170 pooka zombie = true;
2141 1.170 pooka } else {
2142 1.170 pooka zombie = !rw_tryenter(&p->p_reflock, RW_READER);
2143 1.170 pooka }
2144 1.170 pooka if (zombie) {
2145 1.170 pooka LIST_INSERT_AFTER(p, marker, p_list);
2146 1.170 pooka }
2147 1.170 pooka
2148 1.170 pooka if (buflen >= elem_size &&
2149 1.170 pooka (type == KERN_PROC || elem_count > 0)) {
2150 1.234 kamil ruspace(p); /* Update process vm resource use */
2151 1.234 kamil
2152 1.170 pooka if (type == KERN_PROC) {
2153 1.222 christos fill_proc(p, &kbuf->kproc.kp_proc, allowaddr);
2154 1.222 christos fill_eproc(p, &kbuf->kproc.kp_eproc, zombie,
2155 1.222 christos allowaddr);
2156 1.170 pooka } else {
2157 1.222 christos fill_kproc2(p, &kbuf->kproc2, zombie,
2158 1.222 christos allowaddr);
2159 1.170 pooka elem_count--;
2160 1.170 pooka }
2161 1.170 pooka mutex_exit(p->p_lock);
2162 1.170 pooka mutex_exit(proc_lock);
2163 1.170 pooka /*
2164 1.170 pooka * Copy out elem_size, but not larger than kelem_size
2165 1.170 pooka */
2166 1.170 pooka error = sysctl_copyout(l, kbuf, dp,
2167 1.214 riastrad uimin(kelem_size, elem_size));
2168 1.170 pooka mutex_enter(proc_lock);
2169 1.170 pooka if (error) {
2170 1.170 pooka goto bah;
2171 1.170 pooka }
2172 1.170 pooka dp += elem_size;
2173 1.170 pooka buflen -= elem_size;
2174 1.170 pooka } else {
2175 1.170 pooka mutex_exit(p->p_lock);
2176 1.170 pooka }
2177 1.170 pooka needed += elem_size;
2178 1.170 pooka
2179 1.170 pooka /*
2180 1.170 pooka * Release reference to process.
2181 1.170 pooka */
2182 1.170 pooka if (zombie) {
2183 1.170 pooka next = LIST_NEXT(marker, p_list);
2184 1.170 pooka LIST_REMOVE(marker, p_list);
2185 1.170 pooka } else {
2186 1.170 pooka rw_exit(&p->p_reflock);
2187 1.170 pooka next = LIST_NEXT(p, p_list);
2188 1.170 pooka }
2189 1.211 kamil
2190 1.211 kamil /*
2191 1.211 kamil * Short-circuit break quickly!
2192 1.211 kamil */
2193 1.211 kamil if (op == KERN_PROC_PID)
2194 1.211 kamil break;
2195 1.170 pooka }
2196 1.170 pooka mutex_exit(proc_lock);
2197 1.170 pooka
2198 1.170 pooka if (where != NULL) {
2199 1.170 pooka *oldlenp = dp - where;
2200 1.170 pooka if (needed > *oldlenp) {
2201 1.170 pooka error = ENOMEM;
2202 1.170 pooka goto out;
2203 1.170 pooka }
2204 1.170 pooka } else {
2205 1.170 pooka needed += KERN_PROCSLOP;
2206 1.170 pooka *oldlenp = needed;
2207 1.170 pooka }
2208 1.211 kamil kmem_free(kbuf, sizeof(*kbuf));
2209 1.211 kamil kmem_free(marker, sizeof(*marker));
2210 1.170 pooka sysctl_relock();
2211 1.170 pooka return 0;
2212 1.170 pooka bah:
2213 1.170 pooka if (zombie)
2214 1.170 pooka LIST_REMOVE(marker, p_list);
2215 1.170 pooka else
2216 1.170 pooka rw_exit(&p->p_reflock);
2217 1.170 pooka cleanup:
2218 1.170 pooka mutex_exit(proc_lock);
2219 1.170 pooka out:
2220 1.211 kamil kmem_free(kbuf, sizeof(*kbuf));
2221 1.211 kamil kmem_free(marker, sizeof(*marker));
2222 1.170 pooka sysctl_relock();
2223 1.170 pooka return error;
2224 1.170 pooka }
2225 1.170 pooka
2226 1.172 joerg int
2227 1.172 joerg copyin_psstrings(struct proc *p, struct ps_strings *arginfo)
2228 1.172 joerg {
2229 1.225 pgoyette #if !defined(_RUMPKERNEL)
2230 1.225 pgoyette int retval;
2231 1.172 joerg
2232 1.172 joerg if (p->p_flag & PK_32) {
2233 1.228 pgoyette MODULE_HOOK_CALL(kern_proc32_copyin_hook, (p, arginfo),
2234 1.225 pgoyette enosys(), retval);
2235 1.225 pgoyette return retval;
2236 1.225 pgoyette }
2237 1.225 pgoyette #endif /* !defined(_RUMPKERNEL) */
2238 1.172 joerg
2239 1.173 matt return copyin_proc(p, (void *)p->p_psstrp, arginfo, sizeof(*arginfo));
2240 1.172 joerg }
2241 1.172 joerg
2242 1.172 joerg static int
2243 1.172 joerg copy_procargs_sysctl_cb(void *cookie_, const void *src, size_t off, size_t len)
2244 1.172 joerg {
2245 1.172 joerg void **cookie = cookie_;
2246 1.172 joerg struct lwp *l = cookie[0];
2247 1.172 joerg char *dst = cookie[1];
2248 1.172 joerg
2249 1.172 joerg return sysctl_copyout(l, src, dst + off, len);
2250 1.172 joerg }
2251 1.172 joerg
2252 1.170 pooka /*
2253 1.170 pooka * sysctl helper routine for kern.proc_args pseudo-subtree.
2254 1.170 pooka */
2255 1.170 pooka static int
2256 1.170 pooka sysctl_kern_proc_args(SYSCTLFN_ARGS)
2257 1.170 pooka {
2258 1.170 pooka struct ps_strings pss;
2259 1.170 pooka struct proc *p;
2260 1.170 pooka pid_t pid;
2261 1.172 joerg int type, error;
2262 1.172 joerg void *cookie[2];
2263 1.170 pooka
2264 1.170 pooka if (namelen == 1 && name[0] == CTL_QUERY)
2265 1.170 pooka return (sysctl_query(SYSCTLFN_CALL(rnode)));
2266 1.170 pooka
2267 1.170 pooka if (newp != NULL || namelen != 2)
2268 1.170 pooka return (EINVAL);
2269 1.170 pooka pid = name[0];
2270 1.170 pooka type = name[1];
2271 1.170 pooka
2272 1.170 pooka switch (type) {
2273 1.194 christos case KERN_PROC_PATHNAME:
2274 1.194 christos sysctl_unlock();
2275 1.194 christos error = fill_pathname(l, pid, oldp, oldlenp);
2276 1.194 christos sysctl_relock();
2277 1.194 christos return error;
2278 1.194 christos
2279 1.229 kamil case KERN_PROC_CWD:
2280 1.229 kamil sysctl_unlock();
2281 1.229 kamil error = fill_cwd(l, pid, oldp, oldlenp);
2282 1.229 kamil sysctl_relock();
2283 1.229 kamil return error;
2284 1.229 kamil
2285 1.170 pooka case KERN_PROC_ARGV:
2286 1.170 pooka case KERN_PROC_NARGV:
2287 1.170 pooka case KERN_PROC_ENV:
2288 1.170 pooka case KERN_PROC_NENV:
2289 1.170 pooka /* ok */
2290 1.170 pooka break;
2291 1.170 pooka default:
2292 1.170 pooka return (EINVAL);
2293 1.170 pooka }
2294 1.170 pooka
2295 1.170 pooka sysctl_unlock();
2296 1.170 pooka
2297 1.170 pooka /* check pid */
2298 1.170 pooka mutex_enter(proc_lock);
2299 1.170 pooka if ((p = proc_find(pid)) == NULL) {
2300 1.170 pooka error = EINVAL;
2301 1.170 pooka goto out_locked;
2302 1.170 pooka }
2303 1.170 pooka mutex_enter(p->p_lock);
2304 1.170 pooka
2305 1.170 pooka /* Check permission. */
2306 1.170 pooka if (type == KERN_PROC_ARGV || type == KERN_PROC_NARGV)
2307 1.170 pooka error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE,
2308 1.170 pooka p, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ARGS), NULL, NULL);
2309 1.170 pooka else if (type == KERN_PROC_ENV || type == KERN_PROC_NENV)
2310 1.170 pooka error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE,
2311 1.170 pooka p, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENV), NULL, NULL);
2312 1.170 pooka else
2313 1.170 pooka error = EINVAL; /* XXXGCC */
2314 1.170 pooka if (error) {
2315 1.170 pooka mutex_exit(p->p_lock);
2316 1.170 pooka goto out_locked;
2317 1.170 pooka }
2318 1.170 pooka
2319 1.170 pooka if (oldp == NULL) {
2320 1.170 pooka if (type == KERN_PROC_NARGV || type == KERN_PROC_NENV)
2321 1.170 pooka *oldlenp = sizeof (int);
2322 1.170 pooka else
2323 1.170 pooka *oldlenp = ARG_MAX; /* XXX XXX XXX */
2324 1.170 pooka error = 0;
2325 1.170 pooka mutex_exit(p->p_lock);
2326 1.170 pooka goto out_locked;
2327 1.170 pooka }
2328 1.170 pooka
2329 1.170 pooka /*
2330 1.170 pooka * Zombies don't have a stack, so we can't read their psstrings.
2331 1.170 pooka * System processes also don't have a user stack.
2332 1.170 pooka */
2333 1.170 pooka if (P_ZOMBIE(p) || (p->p_flag & PK_SYSTEM) != 0) {
2334 1.170 pooka error = EINVAL;
2335 1.170 pooka mutex_exit(p->p_lock);
2336 1.170 pooka goto out_locked;
2337 1.170 pooka }
2338 1.170 pooka
2339 1.174 rmind error = rw_tryenter(&p->p_reflock, RW_READER) ? 0 : EBUSY;
2340 1.172 joerg mutex_exit(p->p_lock);
2341 1.174 rmind if (error) {
2342 1.174 rmind goto out_locked;
2343 1.174 rmind }
2344 1.172 joerg mutex_exit(proc_lock);
2345 1.172 joerg
2346 1.172 joerg if (type == KERN_PROC_NARGV || type == KERN_PROC_NENV) {
2347 1.172 joerg int value;
2348 1.172 joerg if ((error = copyin_psstrings(p, &pss)) == 0) {
2349 1.172 joerg if (type == KERN_PROC_NARGV)
2350 1.172 joerg value = pss.ps_nargvstr;
2351 1.172 joerg else
2352 1.172 joerg value = pss.ps_nenvstr;
2353 1.172 joerg error = sysctl_copyout(l, &value, oldp, sizeof(value));
2354 1.172 joerg *oldlenp = sizeof(value);
2355 1.172 joerg }
2356 1.170 pooka } else {
2357 1.172 joerg cookie[0] = l;
2358 1.172 joerg cookie[1] = oldp;
2359 1.172 joerg error = copy_procargs(p, type, oldlenp,
2360 1.172 joerg copy_procargs_sysctl_cb, cookie);
2361 1.170 pooka }
2362 1.172 joerg rw_exit(&p->p_reflock);
2363 1.172 joerg sysctl_relock();
2364 1.172 joerg return error;
2365 1.172 joerg
2366 1.172 joerg out_locked:
2367 1.170 pooka mutex_exit(proc_lock);
2368 1.172 joerg sysctl_relock();
2369 1.172 joerg return error;
2370 1.172 joerg }
2371 1.172 joerg
2372 1.172 joerg int
2373 1.172 joerg copy_procargs(struct proc *p, int oid, size_t *limit,
2374 1.172 joerg int (*cb)(void *, const void *, size_t, size_t), void *cookie)
2375 1.172 joerg {
2376 1.172 joerg struct ps_strings pss;
2377 1.172 joerg size_t len, i, loaded, entry_len;
2378 1.172 joerg struct uio auio;
2379 1.172 joerg struct iovec aiov;
2380 1.172 joerg int error, argvlen;
2381 1.172 joerg char *arg;
2382 1.172 joerg char **argv;
2383 1.172 joerg vaddr_t user_argv;
2384 1.172 joerg struct vmspace *vmspace;
2385 1.170 pooka
2386 1.170 pooka /*
2387 1.172 joerg * Allocate a temporary buffer to hold the argument vector and
2388 1.172 joerg * the arguments themselve.
2389 1.170 pooka */
2390 1.170 pooka arg = kmem_alloc(PAGE_SIZE, KM_SLEEP);
2391 1.172 joerg argv = kmem_alloc(PAGE_SIZE, KM_SLEEP);
2392 1.172 joerg
2393 1.172 joerg /*
2394 1.172 joerg * Lock the process down in memory.
2395 1.172 joerg */
2396 1.172 joerg vmspace = p->p_vmspace;
2397 1.172 joerg uvmspace_addref(vmspace);
2398 1.170 pooka
2399 1.170 pooka /*
2400 1.170 pooka * Read in the ps_strings structure.
2401 1.170 pooka */
2402 1.172 joerg if ((error = copyin_psstrings(p, &pss)) != 0)
2403 1.170 pooka goto done;
2404 1.170 pooka
2405 1.170 pooka /*
2406 1.170 pooka * Now read the address of the argument vector.
2407 1.170 pooka */
2408 1.172 joerg switch (oid) {
2409 1.170 pooka case KERN_PROC_ARGV:
2410 1.172 joerg user_argv = (uintptr_t)pss.ps_argvstr;
2411 1.172 joerg argvlen = pss.ps_nargvstr;
2412 1.172 joerg break;
2413 1.170 pooka case KERN_PROC_ENV:
2414 1.172 joerg user_argv = (uintptr_t)pss.ps_envstr;
2415 1.172 joerg argvlen = pss.ps_nenvstr;
2416 1.170 pooka break;
2417 1.170 pooka default:
2418 1.170 pooka error = EINVAL;
2419 1.170 pooka goto done;
2420 1.170 pooka }
2421 1.170 pooka
2422 1.172 joerg if (argvlen < 0) {
2423 1.172 joerg error = EIO;
2424 1.172 joerg goto done;
2425 1.172 joerg }
2426 1.172 joerg
2427 1.170 pooka
2428 1.170 pooka /*
2429 1.170 pooka * Now copy each string.
2430 1.170 pooka */
2431 1.170 pooka len = 0; /* bytes written to user buffer */
2432 1.172 joerg loaded = 0; /* bytes from argv already processed */
2433 1.172 joerg i = 0; /* To make compiler happy */
2434 1.198 christos entry_len = PROC_PTRSZ(p);
2435 1.172 joerg
2436 1.172 joerg for (; argvlen; --argvlen) {
2437 1.170 pooka int finished = 0;
2438 1.170 pooka vaddr_t base;
2439 1.170 pooka size_t xlen;
2440 1.170 pooka int j;
2441 1.170 pooka
2442 1.172 joerg if (loaded == 0) {
2443 1.172 joerg size_t rem = entry_len * argvlen;
2444 1.172 joerg loaded = MIN(rem, PAGE_SIZE);
2445 1.172 joerg error = copyin_vmspace(vmspace,
2446 1.172 joerg (const void *)user_argv, argv, loaded);
2447 1.172 joerg if (error)
2448 1.172 joerg break;
2449 1.172 joerg user_argv += loaded;
2450 1.172 joerg i = 0;
2451 1.172 joerg }
2452 1.172 joerg
2453 1.225 pgoyette #if !defined(_RUMPKERNEL)
2454 1.225 pgoyette if (p->p_flag & PK_32)
2455 1.228 pgoyette MODULE_HOOK_CALL(kern_proc32_base_hook,
2456 1.225 pgoyette (argv, i++), 0, base);
2457 1.225 pgoyette else
2458 1.225 pgoyette #endif /* !defined(_RUMPKERNEL) */
2459 1.172 joerg base = (vaddr_t)argv[i++];
2460 1.172 joerg loaded -= entry_len;
2461 1.170 pooka
2462 1.170 pooka /*
2463 1.170 pooka * The program has messed around with its arguments,
2464 1.170 pooka * possibly deleting some, and replacing them with
2465 1.170 pooka * NULL's. Treat this as the last argument and not
2466 1.170 pooka * a failure.
2467 1.170 pooka */
2468 1.170 pooka if (base == 0)
2469 1.170 pooka break;
2470 1.170 pooka
2471 1.170 pooka while (!finished) {
2472 1.170 pooka xlen = PAGE_SIZE - (base & PAGE_MASK);
2473 1.170 pooka
2474 1.170 pooka aiov.iov_base = arg;
2475 1.170 pooka aiov.iov_len = PAGE_SIZE;
2476 1.170 pooka auio.uio_iov = &aiov;
2477 1.170 pooka auio.uio_iovcnt = 1;
2478 1.170 pooka auio.uio_offset = base;
2479 1.170 pooka auio.uio_resid = xlen;
2480 1.170 pooka auio.uio_rw = UIO_READ;
2481 1.170 pooka UIO_SETUP_SYSSPACE(&auio);
2482 1.196 christos error = uvm_io(&vmspace->vm_map, &auio, 0);
2483 1.170 pooka if (error)
2484 1.170 pooka goto done;
2485 1.170 pooka
2486 1.170 pooka /* Look for the end of the string */
2487 1.170 pooka for (j = 0; j < xlen; j++) {
2488 1.170 pooka if (arg[j] == '\0') {
2489 1.170 pooka xlen = j + 1;
2490 1.170 pooka finished = 1;
2491 1.170 pooka break;
2492 1.170 pooka }
2493 1.170 pooka }
2494 1.170 pooka
2495 1.170 pooka /* Check for user buffer overflow */
2496 1.172 joerg if (len + xlen > *limit) {
2497 1.170 pooka finished = 1;
2498 1.172 joerg if (len > *limit)
2499 1.170 pooka xlen = 0;
2500 1.170 pooka else
2501 1.172 joerg xlen = *limit - len;
2502 1.170 pooka }
2503 1.170 pooka
2504 1.170 pooka /* Copyout the page */
2505 1.172 joerg error = (*cb)(cookie, arg, len, xlen);
2506 1.170 pooka if (error)
2507 1.170 pooka goto done;
2508 1.170 pooka
2509 1.170 pooka len += xlen;
2510 1.170 pooka base += xlen;
2511 1.170 pooka }
2512 1.170 pooka }
2513 1.172 joerg *limit = len;
2514 1.170 pooka
2515 1.170 pooka done:
2516 1.172 joerg kmem_free(argv, PAGE_SIZE);
2517 1.172 joerg kmem_free(arg, PAGE_SIZE);
2518 1.170 pooka uvmspace_free(vmspace);
2519 1.170 pooka return error;
2520 1.170 pooka }
2521 1.170 pooka
2522 1.170 pooka /*
2523 1.220 maxv * Fill in a proc structure for the specified process.
2524 1.220 maxv */
2525 1.220 maxv static void
2526 1.222 christos fill_proc(const struct proc *psrc, struct proc *p, bool allowaddr)
2527 1.220 maxv {
2528 1.220 maxv COND_SET_VALUE(p->p_list, psrc->p_list, allowaddr);
2529 1.220 maxv COND_SET_VALUE(p->p_auxlock, psrc->p_auxlock, allowaddr);
2530 1.220 maxv COND_SET_VALUE(p->p_lock, psrc->p_lock, allowaddr);
2531 1.220 maxv COND_SET_VALUE(p->p_stmutex, psrc->p_stmutex, allowaddr);
2532 1.220 maxv COND_SET_VALUE(p->p_reflock, psrc->p_reflock, allowaddr);
2533 1.220 maxv COND_SET_VALUE(p->p_waitcv, psrc->p_waitcv, allowaddr);
2534 1.220 maxv COND_SET_VALUE(p->p_lwpcv, psrc->p_lwpcv, allowaddr);
2535 1.220 maxv COND_SET_VALUE(p->p_cred, psrc->p_cred, allowaddr);
2536 1.220 maxv COND_SET_VALUE(p->p_fd, psrc->p_fd, allowaddr);
2537 1.220 maxv COND_SET_VALUE(p->p_cwdi, psrc->p_cwdi, allowaddr);
2538 1.220 maxv COND_SET_VALUE(p->p_stats, psrc->p_stats, allowaddr);
2539 1.220 maxv COND_SET_VALUE(p->p_limit, psrc->p_limit, allowaddr);
2540 1.220 maxv COND_SET_VALUE(p->p_vmspace, psrc->p_vmspace, allowaddr);
2541 1.220 maxv COND_SET_VALUE(p->p_sigacts, psrc->p_sigacts, allowaddr);
2542 1.220 maxv COND_SET_VALUE(p->p_aio, psrc->p_aio, allowaddr);
2543 1.220 maxv p->p_mqueue_cnt = psrc->p_mqueue_cnt;
2544 1.220 maxv COND_SET_VALUE(p->p_specdataref, psrc->p_specdataref, allowaddr);
2545 1.220 maxv p->p_exitsig = psrc->p_exitsig;
2546 1.220 maxv p->p_flag = psrc->p_flag;
2547 1.220 maxv p->p_sflag = psrc->p_sflag;
2548 1.220 maxv p->p_slflag = psrc->p_slflag;
2549 1.220 maxv p->p_lflag = psrc->p_lflag;
2550 1.220 maxv p->p_stflag = psrc->p_stflag;
2551 1.220 maxv p->p_stat = psrc->p_stat;
2552 1.220 maxv p->p_trace_enabled = psrc->p_trace_enabled;
2553 1.220 maxv p->p_pid = psrc->p_pid;
2554 1.220 maxv COND_SET_VALUE(p->p_pglist, psrc->p_pglist, allowaddr);
2555 1.220 maxv COND_SET_VALUE(p->p_pptr, psrc->p_pptr, allowaddr);
2556 1.220 maxv COND_SET_VALUE(p->p_sibling, psrc->p_sibling, allowaddr);
2557 1.220 maxv COND_SET_VALUE(p->p_children, psrc->p_children, allowaddr);
2558 1.220 maxv COND_SET_VALUE(p->p_lwps, psrc->p_lwps, allowaddr);
2559 1.220 maxv COND_SET_VALUE(p->p_raslist, psrc->p_raslist, allowaddr);
2560 1.220 maxv p->p_nlwps = psrc->p_nlwps;
2561 1.220 maxv p->p_nzlwps = psrc->p_nzlwps;
2562 1.220 maxv p->p_nrlwps = psrc->p_nrlwps;
2563 1.220 maxv p->p_nlwpwait = psrc->p_nlwpwait;
2564 1.220 maxv p->p_ndlwps = psrc->p_ndlwps;
2565 1.220 maxv p->p_nstopchild = psrc->p_nstopchild;
2566 1.220 maxv p->p_waited = psrc->p_waited;
2567 1.220 maxv COND_SET_VALUE(p->p_zomblwp, psrc->p_zomblwp, allowaddr);
2568 1.220 maxv COND_SET_VALUE(p->p_vforklwp, psrc->p_vforklwp, allowaddr);
2569 1.220 maxv COND_SET_VALUE(p->p_sched_info, psrc->p_sched_info, allowaddr);
2570 1.220 maxv p->p_estcpu = psrc->p_estcpu;
2571 1.220 maxv p->p_estcpu_inherited = psrc->p_estcpu_inherited;
2572 1.220 maxv p->p_forktime = psrc->p_forktime;
2573 1.220 maxv p->p_pctcpu = psrc->p_pctcpu;
2574 1.220 maxv COND_SET_VALUE(p->p_opptr, psrc->p_opptr, allowaddr);
2575 1.220 maxv COND_SET_VALUE(p->p_timers, psrc->p_timers, allowaddr);
2576 1.220 maxv p->p_rtime = psrc->p_rtime;
2577 1.220 maxv p->p_uticks = psrc->p_uticks;
2578 1.220 maxv p->p_sticks = psrc->p_sticks;
2579 1.220 maxv p->p_iticks = psrc->p_iticks;
2580 1.220 maxv p->p_xutime = psrc->p_xutime;
2581 1.220 maxv p->p_xstime = psrc->p_xstime;
2582 1.220 maxv p->p_traceflag = psrc->p_traceflag;
2583 1.220 maxv COND_SET_VALUE(p->p_tracep, psrc->p_tracep, allowaddr);
2584 1.220 maxv COND_SET_VALUE(p->p_textvp, psrc->p_textvp, allowaddr);
2585 1.220 maxv COND_SET_VALUE(p->p_emul, psrc->p_emul, allowaddr);
2586 1.220 maxv COND_SET_VALUE(p->p_emuldata, psrc->p_emuldata, allowaddr);
2587 1.220 maxv COND_SET_VALUE(p->p_execsw, psrc->p_execsw, allowaddr);
2588 1.220 maxv COND_SET_VALUE(p->p_klist, psrc->p_klist, allowaddr);
2589 1.220 maxv COND_SET_VALUE(p->p_sigwaiters, psrc->p_sigwaiters, allowaddr);
2590 1.220 maxv COND_SET_VALUE(p->p_sigpend, psrc->p_sigpend, allowaddr);
2591 1.220 maxv COND_SET_VALUE(p->p_lwpctl, psrc->p_lwpctl, allowaddr);
2592 1.220 maxv p->p_ppid = psrc->p_ppid;
2593 1.243 kamil p->p_oppid = psrc->p_oppid;
2594 1.220 maxv COND_SET_VALUE(p->p_path, psrc->p_path, allowaddr);
2595 1.220 maxv COND_SET_VALUE(p->p_sigctx, psrc->p_sigctx, allowaddr);
2596 1.220 maxv p->p_nice = psrc->p_nice;
2597 1.220 maxv memcpy(p->p_comm, psrc->p_comm, sizeof(p->p_comm));
2598 1.220 maxv COND_SET_VALUE(p->p_pgrp, psrc->p_pgrp, allowaddr);
2599 1.220 maxv COND_SET_VALUE(p->p_psstrp, psrc->p_psstrp, allowaddr);
2600 1.220 maxv p->p_pax = psrc->p_pax;
2601 1.220 maxv p->p_xexit = psrc->p_xexit;
2602 1.220 maxv p->p_xsig = psrc->p_xsig;
2603 1.220 maxv p->p_acflag = psrc->p_acflag;
2604 1.220 maxv COND_SET_VALUE(p->p_md, psrc->p_md, allowaddr);
2605 1.220 maxv p->p_stackbase = psrc->p_stackbase;
2606 1.220 maxv COND_SET_VALUE(p->p_dtrace, psrc->p_dtrace, allowaddr);
2607 1.220 maxv }
2608 1.220 maxv
2609 1.220 maxv /*
2610 1.170 pooka * Fill in an eproc structure for the specified process.
2611 1.170 pooka */
2612 1.170 pooka void
2613 1.222 christos fill_eproc(struct proc *p, struct eproc *ep, bool zombie, bool allowaddr)
2614 1.170 pooka {
2615 1.170 pooka struct tty *tp;
2616 1.170 pooka struct lwp *l;
2617 1.170 pooka
2618 1.170 pooka KASSERT(mutex_owned(proc_lock));
2619 1.170 pooka KASSERT(mutex_owned(p->p_lock));
2620 1.170 pooka
2621 1.218 christos COND_SET_VALUE(ep->e_paddr, p, allowaddr);
2622 1.218 christos COND_SET_VALUE(ep->e_sess, p->p_session, allowaddr);
2623 1.170 pooka if (p->p_cred) {
2624 1.170 pooka kauth_cred_topcred(p->p_cred, &ep->e_pcred);
2625 1.170 pooka kauth_cred_toucred(p->p_cred, &ep->e_ucred);
2626 1.170 pooka }
2627 1.170 pooka if (p->p_stat != SIDL && !P_ZOMBIE(p) && !zombie) {
2628 1.170 pooka struct vmspace *vm = p->p_vmspace;
2629 1.170 pooka
2630 1.170 pooka ep->e_vm.vm_rssize = vm_resident_count(vm);
2631 1.170 pooka ep->e_vm.vm_tsize = vm->vm_tsize;
2632 1.170 pooka ep->e_vm.vm_dsize = vm->vm_dsize;
2633 1.170 pooka ep->e_vm.vm_ssize = vm->vm_ssize;
2634 1.170 pooka ep->e_vm.vm_map.size = vm->vm_map.size;
2635 1.170 pooka
2636 1.170 pooka /* Pick the primary (first) LWP */
2637 1.170 pooka l = proc_active_lwp(p);
2638 1.170 pooka KASSERT(l != NULL);
2639 1.170 pooka lwp_lock(l);
2640 1.170 pooka if (l->l_wchan)
2641 1.170 pooka strncpy(ep->e_wmesg, l->l_wmesg, WMESGLEN);
2642 1.170 pooka lwp_unlock(l);
2643 1.170 pooka }
2644 1.199 kre ep->e_ppid = p->p_ppid;
2645 1.170 pooka if (p->p_pgrp && p->p_session) {
2646 1.170 pooka ep->e_pgid = p->p_pgrp->pg_id;
2647 1.170 pooka ep->e_jobc = p->p_pgrp->pg_jobc;
2648 1.170 pooka ep->e_sid = p->p_session->s_sid;
2649 1.170 pooka if ((p->p_lflag & PL_CONTROLT) &&
2650 1.216 maxv (tp = p->p_session->s_ttyp)) {
2651 1.170 pooka ep->e_tdev = tp->t_dev;
2652 1.170 pooka ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID;
2653 1.218 christos COND_SET_VALUE(ep->e_tsess, tp->t_session, allowaddr);
2654 1.170 pooka } else
2655 1.170 pooka ep->e_tdev = (uint32_t)NODEV;
2656 1.216 maxv ep->e_flag = p->p_session->s_ttyvp ? EPROC_CTTY : 0;
2657 1.170 pooka if (SESS_LEADER(p))
2658 1.170 pooka ep->e_flag |= EPROC_SLEADER;
2659 1.216 maxv strncpy(ep->e_login, p->p_session->s_login, MAXLOGNAME);
2660 1.170 pooka }
2661 1.170 pooka ep->e_xsize = ep->e_xrssize = 0;
2662 1.170 pooka ep->e_xccount = ep->e_xswrss = 0;
2663 1.170 pooka }
2664 1.170 pooka
2665 1.170 pooka /*
2666 1.170 pooka * Fill in a kinfo_proc2 structure for the specified process.
2667 1.170 pooka */
2668 1.193 njoly void
2669 1.222 christos fill_kproc2(struct proc *p, struct kinfo_proc2 *ki, bool zombie, bool allowaddr)
2670 1.170 pooka {
2671 1.170 pooka struct tty *tp;
2672 1.170 pooka struct lwp *l, *l2;
2673 1.170 pooka struct timeval ut, st, rt;
2674 1.170 pooka sigset_t ss1, ss2;
2675 1.170 pooka struct rusage ru;
2676 1.170 pooka struct vmspace *vm;
2677 1.170 pooka
2678 1.170 pooka KASSERT(mutex_owned(proc_lock));
2679 1.170 pooka KASSERT(mutex_owned(p->p_lock));
2680 1.170 pooka
2681 1.170 pooka sigemptyset(&ss1);
2682 1.170 pooka sigemptyset(&ss2);
2683 1.170 pooka
2684 1.218 christos COND_SET_VALUE(ki->p_paddr, PTRTOUINT64(p), allowaddr);
2685 1.218 christos COND_SET_VALUE(ki->p_fd, PTRTOUINT64(p->p_fd), allowaddr);
2686 1.218 christos COND_SET_VALUE(ki->p_cwdi, PTRTOUINT64(p->p_cwdi), allowaddr);
2687 1.218 christos COND_SET_VALUE(ki->p_stats, PTRTOUINT64(p->p_stats), allowaddr);
2688 1.218 christos COND_SET_VALUE(ki->p_limit, PTRTOUINT64(p->p_limit), allowaddr);
2689 1.218 christos COND_SET_VALUE(ki->p_vmspace, PTRTOUINT64(p->p_vmspace), allowaddr);
2690 1.218 christos COND_SET_VALUE(ki->p_sigacts, PTRTOUINT64(p->p_sigacts), allowaddr);
2691 1.218 christos COND_SET_VALUE(ki->p_sess, PTRTOUINT64(p->p_session), allowaddr);
2692 1.170 pooka ki->p_tsess = 0; /* may be changed if controlling tty below */
2693 1.218 christos COND_SET_VALUE(ki->p_ru, PTRTOUINT64(&p->p_stats->p_ru), allowaddr);
2694 1.170 pooka ki->p_eflag = 0;
2695 1.170 pooka ki->p_exitsig = p->p_exitsig;
2696 1.170 pooka ki->p_flag = L_INMEM; /* Process never swapped out */
2697 1.170 pooka ki->p_flag |= sysctl_map_flags(sysctl_flagmap, p->p_flag);
2698 1.170 pooka ki->p_flag |= sysctl_map_flags(sysctl_sflagmap, p->p_sflag);
2699 1.170 pooka ki->p_flag |= sysctl_map_flags(sysctl_slflagmap, p->p_slflag);
2700 1.170 pooka ki->p_flag |= sysctl_map_flags(sysctl_lflagmap, p->p_lflag);
2701 1.170 pooka ki->p_flag |= sysctl_map_flags(sysctl_stflagmap, p->p_stflag);
2702 1.170 pooka ki->p_pid = p->p_pid;
2703 1.199 kre ki->p_ppid = p->p_ppid;
2704 1.170 pooka ki->p_uid = kauth_cred_geteuid(p->p_cred);
2705 1.170 pooka ki->p_ruid = kauth_cred_getuid(p->p_cred);
2706 1.170 pooka ki->p_gid = kauth_cred_getegid(p->p_cred);
2707 1.170 pooka ki->p_rgid = kauth_cred_getgid(p->p_cred);
2708 1.170 pooka ki->p_svuid = kauth_cred_getsvuid(p->p_cred);
2709 1.170 pooka ki->p_svgid = kauth_cred_getsvgid(p->p_cred);
2710 1.170 pooka ki->p_ngroups = kauth_cred_ngroups(p->p_cred);
2711 1.170 pooka kauth_cred_getgroups(p->p_cred, ki->p_groups,
2712 1.214 riastrad uimin(ki->p_ngroups, sizeof(ki->p_groups) / sizeof(ki->p_groups[0])),
2713 1.170 pooka UIO_SYSSPACE);
2714 1.170 pooka
2715 1.170 pooka ki->p_uticks = p->p_uticks;
2716 1.170 pooka ki->p_sticks = p->p_sticks;
2717 1.170 pooka ki->p_iticks = p->p_iticks;
2718 1.170 pooka ki->p_tpgid = NO_PGID; /* may be changed if controlling tty below */
2719 1.218 christos COND_SET_VALUE(ki->p_tracep, PTRTOUINT64(p->p_tracep), allowaddr);
2720 1.170 pooka ki->p_traceflag = p->p_traceflag;
2721 1.170 pooka
2722 1.170 pooka memcpy(&ki->p_sigignore, &p->p_sigctx.ps_sigignore,sizeof(ki_sigset_t));
2723 1.170 pooka memcpy(&ki->p_sigcatch, &p->p_sigctx.ps_sigcatch, sizeof(ki_sigset_t));
2724 1.170 pooka
2725 1.170 pooka ki->p_cpticks = 0;
2726 1.170 pooka ki->p_pctcpu = p->p_pctcpu;
2727 1.170 pooka ki->p_estcpu = 0;
2728 1.170 pooka ki->p_stat = p->p_stat; /* Will likely be overridden by LWP status */
2729 1.170 pooka ki->p_realstat = p->p_stat;
2730 1.170 pooka ki->p_nice = p->p_nice;
2731 1.195 christos ki->p_xstat = P_WAITSTATUS(p);
2732 1.170 pooka ki->p_acflag = p->p_acflag;
2733 1.170 pooka
2734 1.170 pooka strncpy(ki->p_comm, p->p_comm,
2735 1.214 riastrad uimin(sizeof(ki->p_comm), sizeof(p->p_comm)));
2736 1.170 pooka strncpy(ki->p_ename, p->p_emul->e_name, sizeof(ki->p_ename));
2737 1.170 pooka
2738 1.170 pooka ki->p_nlwps = p->p_nlwps;
2739 1.170 pooka ki->p_realflag = ki->p_flag;
2740 1.170 pooka
2741 1.170 pooka if (p->p_stat != SIDL && !P_ZOMBIE(p) && !zombie) {
2742 1.170 pooka vm = p->p_vmspace;
2743 1.170 pooka ki->p_vm_rssize = vm_resident_count(vm);
2744 1.170 pooka ki->p_vm_tsize = vm->vm_tsize;
2745 1.170 pooka ki->p_vm_dsize = vm->vm_dsize;
2746 1.170 pooka ki->p_vm_ssize = vm->vm_ssize;
2747 1.184 martin ki->p_vm_vsize = atop(vm->vm_map.size);
2748 1.170 pooka /*
2749 1.170 pooka * Since the stack is initially mapped mostly with
2750 1.170 pooka * PROT_NONE and grown as needed, adjust the "mapped size"
2751 1.170 pooka * to skip the unused stack portion.
2752 1.170 pooka */
2753 1.170 pooka ki->p_vm_msize =
2754 1.170 pooka atop(vm->vm_map.size) - vm->vm_issize + vm->vm_ssize;
2755 1.170 pooka
2756 1.170 pooka /* Pick the primary (first) LWP */
2757 1.170 pooka l = proc_active_lwp(p);
2758 1.170 pooka KASSERT(l != NULL);
2759 1.170 pooka lwp_lock(l);
2760 1.170 pooka ki->p_nrlwps = p->p_nrlwps;
2761 1.170 pooka ki->p_forw = 0;
2762 1.170 pooka ki->p_back = 0;
2763 1.218 christos COND_SET_VALUE(ki->p_addr, PTRTOUINT64(l->l_addr), allowaddr);
2764 1.170 pooka ki->p_stat = l->l_stat;
2765 1.170 pooka ki->p_flag |= sysctl_map_flags(sysctl_lwpflagmap, l->l_flag);
2766 1.170 pooka ki->p_swtime = l->l_swtime;
2767 1.170 pooka ki->p_slptime = l->l_slptime;
2768 1.170 pooka if (l->l_stat == LSONPROC)
2769 1.170 pooka ki->p_schedflags = l->l_cpu->ci_schedstate.spc_flags;
2770 1.170 pooka else
2771 1.170 pooka ki->p_schedflags = 0;
2772 1.170 pooka ki->p_priority = lwp_eprio(l);
2773 1.170 pooka ki->p_usrpri = l->l_priority;
2774 1.170 pooka if (l->l_wchan)
2775 1.170 pooka strncpy(ki->p_wmesg, l->l_wmesg, sizeof(ki->p_wmesg));
2776 1.218 christos COND_SET_VALUE(ki->p_wchan, PTRTOUINT64(l->l_wchan), allowaddr);
2777 1.170 pooka ki->p_cpuid = cpu_index(l->l_cpu);
2778 1.170 pooka lwp_unlock(l);
2779 1.170 pooka LIST_FOREACH(l, &p->p_lwps, l_sibling) {
2780 1.170 pooka /* This is hardly correct, but... */
2781 1.170 pooka sigplusset(&l->l_sigpend.sp_set, &ss1);
2782 1.170 pooka sigplusset(&l->l_sigmask, &ss2);
2783 1.170 pooka ki->p_cpticks += l->l_cpticks;
2784 1.170 pooka ki->p_pctcpu += l->l_pctcpu;
2785 1.170 pooka ki->p_estcpu += l->l_estcpu;
2786 1.170 pooka }
2787 1.170 pooka }
2788 1.237 kamil sigplusset(&p->p_sigpend.sp_set, &ss1);
2789 1.170 pooka memcpy(&ki->p_siglist, &ss1, sizeof(ki_sigset_t));
2790 1.170 pooka memcpy(&ki->p_sigmask, &ss2, sizeof(ki_sigset_t));
2791 1.170 pooka
2792 1.170 pooka if (p->p_session != NULL) {
2793 1.170 pooka ki->p_sid = p->p_session->s_sid;
2794 1.170 pooka ki->p__pgid = p->p_pgrp->pg_id;
2795 1.170 pooka if (p->p_session->s_ttyvp)
2796 1.170 pooka ki->p_eflag |= EPROC_CTTY;
2797 1.170 pooka if (SESS_LEADER(p))
2798 1.170 pooka ki->p_eflag |= EPROC_SLEADER;
2799 1.170 pooka strncpy(ki->p_login, p->p_session->s_login,
2800 1.214 riastrad uimin(sizeof ki->p_login - 1, sizeof p->p_session->s_login));
2801 1.170 pooka ki->p_jobc = p->p_pgrp->pg_jobc;
2802 1.170 pooka if ((p->p_lflag & PL_CONTROLT) && (tp = p->p_session->s_ttyp)) {
2803 1.170 pooka ki->p_tdev = tp->t_dev;
2804 1.170 pooka ki->p_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID;
2805 1.218 christos COND_SET_VALUE(ki->p_tsess, PTRTOUINT64(tp->t_session),
2806 1.217 maxv allowaddr);
2807 1.170 pooka } else {
2808 1.170 pooka ki->p_tdev = (int32_t)NODEV;
2809 1.170 pooka }
2810 1.170 pooka }
2811 1.170 pooka
2812 1.170 pooka if (!P_ZOMBIE(p) && !zombie) {
2813 1.170 pooka ki->p_uvalid = 1;
2814 1.170 pooka ki->p_ustart_sec = p->p_stats->p_start.tv_sec;
2815 1.170 pooka ki->p_ustart_usec = p->p_stats->p_start.tv_usec;
2816 1.170 pooka
2817 1.170 pooka calcru(p, &ut, &st, NULL, &rt);
2818 1.170 pooka ki->p_rtime_sec = rt.tv_sec;
2819 1.170 pooka ki->p_rtime_usec = rt.tv_usec;
2820 1.170 pooka ki->p_uutime_sec = ut.tv_sec;
2821 1.170 pooka ki->p_uutime_usec = ut.tv_usec;
2822 1.170 pooka ki->p_ustime_sec = st.tv_sec;
2823 1.170 pooka ki->p_ustime_usec = st.tv_usec;
2824 1.170 pooka
2825 1.170 pooka memcpy(&ru, &p->p_stats->p_ru, sizeof(ru));
2826 1.170 pooka ki->p_uru_nvcsw = 0;
2827 1.170 pooka ki->p_uru_nivcsw = 0;
2828 1.170 pooka LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
2829 1.170 pooka ki->p_uru_nvcsw += (l2->l_ncsw - l2->l_nivcsw);
2830 1.170 pooka ki->p_uru_nivcsw += l2->l_nivcsw;
2831 1.170 pooka ruadd(&ru, &l2->l_ru);
2832 1.170 pooka }
2833 1.170 pooka ki->p_uru_maxrss = ru.ru_maxrss;
2834 1.170 pooka ki->p_uru_ixrss = ru.ru_ixrss;
2835 1.170 pooka ki->p_uru_idrss = ru.ru_idrss;
2836 1.170 pooka ki->p_uru_isrss = ru.ru_isrss;
2837 1.170 pooka ki->p_uru_minflt = ru.ru_minflt;
2838 1.170 pooka ki->p_uru_majflt = ru.ru_majflt;
2839 1.170 pooka ki->p_uru_nswap = ru.ru_nswap;
2840 1.170 pooka ki->p_uru_inblock = ru.ru_inblock;
2841 1.170 pooka ki->p_uru_oublock = ru.ru_oublock;
2842 1.170 pooka ki->p_uru_msgsnd = ru.ru_msgsnd;
2843 1.170 pooka ki->p_uru_msgrcv = ru.ru_msgrcv;
2844 1.170 pooka ki->p_uru_nsignals = ru.ru_nsignals;
2845 1.170 pooka
2846 1.170 pooka timeradd(&p->p_stats->p_cru.ru_utime,
2847 1.170 pooka &p->p_stats->p_cru.ru_stime, &ut);
2848 1.170 pooka ki->p_uctime_sec = ut.tv_sec;
2849 1.170 pooka ki->p_uctime_usec = ut.tv_usec;
2850 1.170 pooka }
2851 1.170 pooka }
2852 1.194 christos
2853 1.194 christos
2854 1.194 christos int
2855 1.194 christos proc_find_locked(struct lwp *l, struct proc **p, pid_t pid)
2856 1.194 christos {
2857 1.194 christos int error;
2858 1.194 christos
2859 1.194 christos mutex_enter(proc_lock);
2860 1.194 christos if (pid == -1)
2861 1.194 christos *p = l->l_proc;
2862 1.194 christos else
2863 1.194 christos *p = proc_find(pid);
2864 1.194 christos
2865 1.194 christos if (*p == NULL) {
2866 1.194 christos if (pid != -1)
2867 1.194 christos mutex_exit(proc_lock);
2868 1.194 christos return ESRCH;
2869 1.194 christos }
2870 1.194 christos if (pid != -1)
2871 1.194 christos mutex_enter((*p)->p_lock);
2872 1.194 christos mutex_exit(proc_lock);
2873 1.194 christos
2874 1.194 christos error = kauth_authorize_process(l->l_cred,
2875 1.194 christos KAUTH_PROCESS_CANSEE, *p,
2876 1.194 christos KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
2877 1.194 christos if (error) {
2878 1.194 christos if (pid != -1)
2879 1.194 christos mutex_exit((*p)->p_lock);
2880 1.194 christos }
2881 1.194 christos return error;
2882 1.194 christos }
2883 1.194 christos
2884 1.194 christos static int
2885 1.194 christos fill_pathname(struct lwp *l, pid_t pid, void *oldp, size_t *oldlenp)
2886 1.194 christos {
2887 1.194 christos int error;
2888 1.194 christos struct proc *p;
2889 1.194 christos
2890 1.194 christos if ((error = proc_find_locked(l, &p, pid)) != 0)
2891 1.194 christos return error;
2892 1.194 christos
2893 1.208 christos if (p->p_path == NULL) {
2894 1.194 christos if (pid != -1)
2895 1.194 christos mutex_exit(p->p_lock);
2896 1.194 christos return ENOENT;
2897 1.194 christos }
2898 1.194 christos
2899 1.208 christos size_t len = strlen(p->p_path) + 1;
2900 1.194 christos if (oldp != NULL) {
2901 1.219 maxv size_t copylen = uimin(len, *oldlenp);
2902 1.219 maxv error = sysctl_copyout(l, p->p_path, oldp, copylen);
2903 1.194 christos if (error == 0 && *oldlenp < len)
2904 1.194 christos error = ENOSPC;
2905 1.194 christos }
2906 1.194 christos *oldlenp = len;
2907 1.194 christos if (pid != -1)
2908 1.194 christos mutex_exit(p->p_lock);
2909 1.194 christos return error;
2910 1.194 christos }
2911 1.206 christos
2912 1.229 kamil static int
2913 1.229 kamil fill_cwd(struct lwp *l, pid_t pid, void *oldp, size_t *oldlenp)
2914 1.229 kamil {
2915 1.229 kamil int error;
2916 1.229 kamil struct proc *p;
2917 1.229 kamil char *path;
2918 1.229 kamil char *bp, *bend;
2919 1.246 ad struct cwdinfo *cwdi;
2920 1.229 kamil struct vnode *vp;
2921 1.229 kamil size_t len, lenused;
2922 1.229 kamil
2923 1.229 kamil if ((error = proc_find_locked(l, &p, pid)) != 0)
2924 1.229 kamil return error;
2925 1.229 kamil
2926 1.229 kamil len = MAXPATHLEN * 4;
2927 1.229 kamil
2928 1.229 kamil path = kmem_alloc(len, KM_SLEEP);
2929 1.229 kamil
2930 1.229 kamil bp = &path[len];
2931 1.229 kamil bend = bp;
2932 1.229 kamil *(--bp) = '\0';
2933 1.229 kamil
2934 1.246 ad cwdi = p->p_cwdi;
2935 1.246 ad rw_enter(&cwdi->cwdi_lock, RW_READER);
2936 1.229 kamil vp = cwdi->cwdi_cdir;
2937 1.231 kamil error = getcwd_common(vp, NULL, &bp, path, len/2, 0, l);
2938 1.246 ad rw_exit(&cwdi->cwdi_lock);
2939 1.229 kamil
2940 1.229 kamil if (error)
2941 1.229 kamil goto out;
2942 1.229 kamil
2943 1.229 kamil lenused = bend - bp;
2944 1.229 kamil
2945 1.229 kamil if (oldp != NULL) {
2946 1.230 kamil size_t copylen = uimin(lenused, *oldlenp);
2947 1.230 kamil error = sysctl_copyout(l, bp, oldp, copylen);
2948 1.229 kamil if (error == 0 && *oldlenp < lenused)
2949 1.229 kamil error = ENOSPC;
2950 1.229 kamil }
2951 1.229 kamil *oldlenp = lenused;
2952 1.229 kamil out:
2953 1.229 kamil if (pid != -1)
2954 1.229 kamil mutex_exit(p->p_lock);
2955 1.229 kamil kmem_free(path, len);
2956 1.229 kamil return error;
2957 1.229 kamil }
2958 1.229 kamil
2959 1.206 christos int
2960 1.206 christos proc_getauxv(struct proc *p, void **buf, size_t *len)
2961 1.206 christos {
2962 1.206 christos struct ps_strings pss;
2963 1.206 christos int error;
2964 1.206 christos void *uauxv, *kauxv;
2965 1.209 maxv size_t size;
2966 1.206 christos
2967 1.206 christos if ((error = copyin_psstrings(p, &pss)) != 0)
2968 1.206 christos return error;
2969 1.209 maxv if (pss.ps_envstr == NULL)
2970 1.209 maxv return EIO;
2971 1.206 christos
2972 1.209 maxv size = p->p_execsw->es_arglen;
2973 1.209 maxv if (size == 0)
2974 1.206 christos return EIO;
2975 1.206 christos
2976 1.206 christos size_t ptrsz = PROC_PTRSZ(p);
2977 1.206 christos uauxv = (void *)((char *)pss.ps_envstr + (pss.ps_nenvstr + 1) * ptrsz);
2978 1.206 christos
2979 1.206 christos kauxv = kmem_alloc(size, KM_SLEEP);
2980 1.206 christos
2981 1.206 christos error = copyin_proc(p, uauxv, kauxv, size);
2982 1.206 christos if (error) {
2983 1.206 christos kmem_free(kauxv, size);
2984 1.206 christos return error;
2985 1.206 christos }
2986 1.206 christos
2987 1.206 christos *buf = kauxv;
2988 1.206 christos *len = size;
2989 1.206 christos
2990 1.206 christos return 0;
2991 1.206 christos }
2992 1.222 christos
2993 1.222 christos
2994 1.222 christos static int
2995 1.222 christos sysctl_security_expose_address(SYSCTLFN_ARGS)
2996 1.222 christos {
2997 1.222 christos int expose_address, error;
2998 1.222 christos struct sysctlnode node;
2999 1.222 christos
3000 1.222 christos node = *rnode;
3001 1.222 christos node.sysctl_data = &expose_address;
3002 1.222 christos expose_address = *(int *)rnode->sysctl_data;
3003 1.222 christos error = sysctl_lookup(SYSCTLFN_CALL(&node));
3004 1.222 christos if (error || newp == NULL)
3005 1.222 christos return error;
3006 1.222 christos
3007 1.222 christos if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_KERNADDR,
3008 1.222 christos 0, NULL, NULL, NULL))
3009 1.222 christos return EPERM;
3010 1.222 christos
3011 1.222 christos switch (expose_address) {
3012 1.222 christos case 0:
3013 1.222 christos case 1:
3014 1.222 christos case 2:
3015 1.222 christos break;
3016 1.222 christos default:
3017 1.222 christos return EINVAL;
3018 1.222 christos }
3019 1.222 christos
3020 1.222 christos *(int *)rnode->sysctl_data = expose_address;
3021 1.222 christos
3022 1.222 christos return 0;
3023 1.222 christos }
3024 1.222 christos
3025 1.222 christos bool
3026 1.222 christos get_expose_address(struct proc *p)
3027 1.222 christos {
3028 1.222 christos /* allow only if sysctl variable is set or privileged */
3029 1.222 christos return kauth_authorize_process(kauth_cred_get(), KAUTH_PROCESS_CANSEE,
3030 1.222 christos p, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_KPTR), NULL, NULL) == 0;
3031 1.222 christos }
3032