linux_sched.c revision 1.53.2.1 1 1.53.2.1 yamt /* $NetBSD: linux_sched.c,v 1.53.2.1 2008/05/16 02:23:42 yamt Exp $ */
2 1.1 tron
3 1.1 tron /*-
4 1.1 tron * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 1.1 tron * All rights reserved.
6 1.1 tron *
7 1.1 tron * This code is derived from software contributed to The NetBSD Foundation
8 1.2 thorpej * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 1.1 tron * NASA Ames Research Center; by Matthias Scheler.
10 1.1 tron *
11 1.1 tron * Redistribution and use in source and binary forms, with or without
12 1.1 tron * modification, are permitted provided that the following conditions
13 1.1 tron * are met:
14 1.1 tron * 1. Redistributions of source code must retain the above copyright
15 1.1 tron * notice, this list of conditions and the following disclaimer.
16 1.1 tron * 2. Redistributions in binary form must reproduce the above copyright
17 1.1 tron * notice, this list of conditions and the following disclaimer in the
18 1.1 tron * documentation and/or other materials provided with the distribution.
19 1.1 tron *
20 1.1 tron * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 1.1 tron * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 1.1 tron * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 1.1 tron * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 1.1 tron * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 1.1 tron * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 1.1 tron * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 1.1 tron * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 1.1 tron * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 1.1 tron * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 1.1 tron * POSSIBILITY OF SUCH DAMAGE.
31 1.1 tron */
32 1.1 tron
33 1.1 tron /*
34 1.1 tron * Linux compatibility module. Try to deal with scheduler related syscalls.
35 1.1 tron */
36 1.8 lukem
37 1.8 lukem #include <sys/cdefs.h>
38 1.53.2.1 yamt __KERNEL_RCSID(0, "$NetBSD: linux_sched.c,v 1.53.2.1 2008/05/16 02:23:42 yamt Exp $");
39 1.1 tron
40 1.1 tron #include <sys/param.h>
41 1.1 tron #include <sys/mount.h>
42 1.1 tron #include <sys/proc.h>
43 1.1 tron #include <sys/systm.h>
44 1.22 manu #include <sys/sysctl.h>
45 1.22 manu #include <sys/malloc.h>
46 1.1 tron #include <sys/syscallargs.h>
47 1.14 jdolecek #include <sys/wait.h>
48 1.30 elad #include <sys/kauth.h>
49 1.34 manu #include <sys/ptrace.h>
50 1.3 itohy
51 1.43 ad #include <sys/cpu.h>
52 1.1 tron
53 1.1 tron #include <compat/linux/common/linux_types.h>
54 1.1 tron #include <compat/linux/common/linux_signal.h>
55 1.21 manu #include <compat/linux/common/linux_machdep.h> /* For LINUX_NPTL */
56 1.19 manu #include <compat/linux/common/linux_emuldata.h>
57 1.44 njoly #include <compat/linux/common/linux_ipc.h>
58 1.44 njoly #include <compat/linux/common/linux_sem.h>
59 1.1 tron
60 1.1 tron #include <compat/linux/linux_syscallargs.h>
61 1.1 tron
62 1.1 tron #include <compat/linux/common/linux_sched.h>
63 1.1 tron
64 1.1 tron int
65 1.46 dsl linux_sys_clone(struct lwp *l, const struct linux_sys_clone_args *uap, register_t *retval)
66 1.1 tron {
67 1.46 dsl /* {
68 1.1 tron syscallarg(int) flags;
69 1.1 tron syscallarg(void *) stack;
70 1.21 manu #ifdef LINUX_NPTL
71 1.19 manu syscallarg(void *) parent_tidptr;
72 1.19 manu syscallarg(void *) child_tidptr;
73 1.19 manu #endif
74 1.46 dsl } */
75 1.1 tron int flags, sig;
76 1.19 manu int error;
77 1.21 manu #ifdef LINUX_NPTL
78 1.19 manu struct linux_emuldata *led;
79 1.19 manu #endif
80 1.1 tron
81 1.1 tron /*
82 1.1 tron * We don't support the Linux CLONE_PID or CLONE_PTRACE flags.
83 1.1 tron */
84 1.1 tron if (SCARG(uap, flags) & (LINUX_CLONE_PID|LINUX_CLONE_PTRACE))
85 1.1 tron return (EINVAL);
86 1.1 tron
87 1.13 jdolecek /*
88 1.13 jdolecek * Thread group implies shared signals. Shared signals
89 1.13 jdolecek * imply shared VM. This matches what Linux kernel does.
90 1.13 jdolecek */
91 1.13 jdolecek if (SCARG(uap, flags) & LINUX_CLONE_THREAD
92 1.13 jdolecek && (SCARG(uap, flags) & LINUX_CLONE_SIGHAND) == 0)
93 1.13 jdolecek return (EINVAL);
94 1.13 jdolecek if (SCARG(uap, flags) & LINUX_CLONE_SIGHAND
95 1.13 jdolecek && (SCARG(uap, flags) & LINUX_CLONE_VM) == 0)
96 1.13 jdolecek return (EINVAL);
97 1.13 jdolecek
98 1.1 tron flags = 0;
99 1.1 tron
100 1.1 tron if (SCARG(uap, flags) & LINUX_CLONE_VM)
101 1.1 tron flags |= FORK_SHAREVM;
102 1.1 tron if (SCARG(uap, flags) & LINUX_CLONE_FS)
103 1.1 tron flags |= FORK_SHARECWD;
104 1.1 tron if (SCARG(uap, flags) & LINUX_CLONE_FILES)
105 1.1 tron flags |= FORK_SHAREFILES;
106 1.1 tron if (SCARG(uap, flags) & LINUX_CLONE_SIGHAND)
107 1.1 tron flags |= FORK_SHARESIGS;
108 1.1 tron if (SCARG(uap, flags) & LINUX_CLONE_VFORK)
109 1.1 tron flags |= FORK_PPWAIT;
110 1.1 tron
111 1.34 manu sig = SCARG(uap, flags) & LINUX_CLONE_CSIGNAL;
112 1.34 manu if (sig < 0 || sig >= LINUX__NSIG)
113 1.34 manu return (EINVAL);
114 1.34 manu sig = linux_to_native_signo[sig];
115 1.1 tron
116 1.21 manu #ifdef LINUX_NPTL
117 1.19 manu led = (struct linux_emuldata *)l->l_proc->p_emuldata;
118 1.19 manu
119 1.34 manu led->parent_tidptr = SCARG(uap, parent_tidptr);
120 1.34 manu led->child_tidptr = SCARG(uap, child_tidptr);
121 1.34 manu led->clone_flags = SCARG(uap, flags);
122 1.34 manu #endif /* LINUX_NPTL */
123 1.19 manu
124 1.1 tron /*
125 1.1 tron * Note that Linux does not provide a portable way of specifying
126 1.1 tron * the stack area; the caller must know if the stack grows up
127 1.1 tron * or down. So, we pass a stack size of 0, so that the code
128 1.1 tron * that makes this adjustment is a noop.
129 1.1 tron */
130 1.19 manu if ((error = fork1(l, flags, sig, SCARG(uap, stack), 0,
131 1.19 manu NULL, NULL, retval, NULL)) != 0)
132 1.19 manu return error;
133 1.19 manu
134 1.19 manu return 0;
135 1.1 tron }
136 1.1 tron
137 1.49 elad /*
138 1.49 elad * linux realtime priority
139 1.49 elad *
140 1.49 elad * - SCHED_RR and SCHED_FIFO tasks have priorities [1,99].
141 1.49 elad *
142 1.49 elad * - SCHED_OTHER tasks don't have realtime priorities.
143 1.49 elad * in particular, sched_param::sched_priority is always 0.
144 1.49 elad */
145 1.49 elad
146 1.49 elad #define LINUX_SCHED_RTPRIO_MIN 1
147 1.49 elad #define LINUX_SCHED_RTPRIO_MAX 99
148 1.49 elad
149 1.49 elad static int
150 1.49 elad sched_linux2native(int linux_policy, struct linux_sched_param *linux_params,
151 1.49 elad int *native_policy, struct sched_param *native_params)
152 1.49 elad {
153 1.49 elad
154 1.49 elad switch (linux_policy) {
155 1.49 elad case LINUX_SCHED_OTHER:
156 1.49 elad if (native_policy != NULL) {
157 1.49 elad *native_policy = SCHED_OTHER;
158 1.49 elad }
159 1.49 elad break;
160 1.49 elad
161 1.49 elad case LINUX_SCHED_FIFO:
162 1.49 elad if (native_policy != NULL) {
163 1.49 elad *native_policy = SCHED_FIFO;
164 1.49 elad }
165 1.49 elad break;
166 1.49 elad
167 1.49 elad case LINUX_SCHED_RR:
168 1.49 elad if (native_policy != NULL) {
169 1.49 elad *native_policy = SCHED_RR;
170 1.49 elad }
171 1.49 elad break;
172 1.49 elad
173 1.49 elad default:
174 1.49 elad return EINVAL;
175 1.49 elad }
176 1.49 elad
177 1.49 elad if (linux_params != NULL) {
178 1.49 elad int prio = linux_params->sched_priority;
179 1.49 elad
180 1.49 elad KASSERT(native_params != NULL);
181 1.49 elad
182 1.49 elad if (linux_policy == LINUX_SCHED_OTHER) {
183 1.49 elad if (prio != 0) {
184 1.49 elad return EINVAL;
185 1.49 elad }
186 1.49 elad native_params->sched_priority = PRI_NONE; /* XXX */
187 1.49 elad } else {
188 1.49 elad if (prio < LINUX_SCHED_RTPRIO_MIN ||
189 1.49 elad prio > LINUX_SCHED_RTPRIO_MAX) {
190 1.49 elad return EINVAL;
191 1.49 elad }
192 1.49 elad native_params->sched_priority =
193 1.49 elad (prio - LINUX_SCHED_RTPRIO_MIN)
194 1.49 elad * (SCHED_PRI_MAX - SCHED_PRI_MIN)
195 1.49 elad / (LINUX_SCHED_RTPRIO_MAX - LINUX_SCHED_RTPRIO_MIN)
196 1.49 elad + SCHED_PRI_MIN;
197 1.49 elad }
198 1.49 elad }
199 1.49 elad
200 1.49 elad return 0;
201 1.49 elad }
202 1.49 elad
203 1.49 elad static int
204 1.49 elad sched_native2linux(int native_policy, struct sched_param *native_params,
205 1.49 elad int *linux_policy, struct linux_sched_param *linux_params)
206 1.49 elad {
207 1.49 elad
208 1.49 elad switch (native_policy) {
209 1.49 elad case SCHED_OTHER:
210 1.49 elad if (linux_policy != NULL) {
211 1.49 elad *linux_policy = LINUX_SCHED_OTHER;
212 1.49 elad }
213 1.49 elad break;
214 1.49 elad
215 1.49 elad case SCHED_FIFO:
216 1.49 elad if (linux_policy != NULL) {
217 1.49 elad *linux_policy = LINUX_SCHED_FIFO;
218 1.49 elad }
219 1.49 elad break;
220 1.49 elad
221 1.49 elad case SCHED_RR:
222 1.49 elad if (linux_policy != NULL) {
223 1.49 elad *linux_policy = LINUX_SCHED_RR;
224 1.49 elad }
225 1.49 elad break;
226 1.49 elad
227 1.49 elad default:
228 1.49 elad panic("%s: unknown policy %d\n", __func__, native_policy);
229 1.49 elad }
230 1.49 elad
231 1.49 elad if (native_params != NULL) {
232 1.49 elad int prio = native_params->sched_priority;
233 1.49 elad
234 1.49 elad KASSERT(prio >= SCHED_PRI_MIN);
235 1.49 elad KASSERT(prio <= SCHED_PRI_MAX);
236 1.49 elad KASSERT(linux_params != NULL);
237 1.49 elad
238 1.53.2.1 yamt #ifdef DEBUG_LINUX
239 1.53.2.1 yamt printf("native2linux: native: policy %d, priority %d\n",
240 1.53.2.1 yamt native_policy, prio);
241 1.53.2.1 yamt #endif
242 1.53.2.1 yamt
243 1.49 elad if (native_policy == SCHED_OTHER) {
244 1.49 elad linux_params->sched_priority = 0;
245 1.49 elad } else {
246 1.49 elad linux_params->sched_priority =
247 1.49 elad (prio - SCHED_PRI_MIN)
248 1.49 elad * (LINUX_SCHED_RTPRIO_MAX - LINUX_SCHED_RTPRIO_MIN)
249 1.49 elad / (SCHED_PRI_MAX - SCHED_PRI_MIN)
250 1.49 elad + LINUX_SCHED_RTPRIO_MIN;
251 1.49 elad }
252 1.53.2.1 yamt #ifdef DEBUG_LINUX
253 1.53.2.1 yamt printf("native2linux: linux: policy %d, priority %d\n",
254 1.53.2.1 yamt -1, linux_params->sched_priority);
255 1.53.2.1 yamt #endif
256 1.49 elad }
257 1.49 elad
258 1.49 elad return 0;
259 1.49 elad }
260 1.49 elad
261 1.1 tron int
262 1.46 dsl linux_sys_sched_setparam(struct lwp *l, const struct linux_sys_sched_setparam_args *uap, register_t *retval)
263 1.1 tron {
264 1.46 dsl /* {
265 1.1 tron syscallarg(linux_pid_t) pid;
266 1.1 tron syscallarg(const struct linux_sched_param *) sp;
267 1.46 dsl } */
268 1.49 elad int error, policy;
269 1.1 tron struct linux_sched_param lp;
270 1.49 elad struct sched_param sp;
271 1.49 elad
272 1.49 elad if (SCARG(uap, pid) < 0 || SCARG(uap, sp) == NULL) {
273 1.49 elad error = EINVAL;
274 1.49 elad goto out;
275 1.49 elad }
276 1.1 tron
277 1.49 elad error = copyin(SCARG(uap, sp), &lp, sizeof(lp));
278 1.49 elad if (error)
279 1.49 elad goto out;
280 1.1 tron
281 1.49 elad /* We need the current policy in Linux terms. */
282 1.49 elad error = do_sched_getparam(SCARG(uap, pid), 0, &policy, NULL);
283 1.49 elad if (error)
284 1.49 elad goto out;
285 1.49 elad error = sched_native2linux(policy, NULL, &policy, NULL);
286 1.49 elad if (error)
287 1.49 elad goto out;
288 1.1 tron
289 1.49 elad error = sched_linux2native(policy, &lp, &policy, &sp);
290 1.1 tron if (error)
291 1.49 elad goto out;
292 1.1 tron
293 1.49 elad error = do_sched_setparam(SCARG(uap, pid), 0, policy, &sp);
294 1.49 elad if (error)
295 1.49 elad goto out;
296 1.1 tron
297 1.49 elad out:
298 1.49 elad return error;
299 1.1 tron }
300 1.1 tron
301 1.1 tron int
302 1.46 dsl linux_sys_sched_getparam(struct lwp *l, const struct linux_sys_sched_getparam_args *uap, register_t *retval)
303 1.1 tron {
304 1.46 dsl /* {
305 1.1 tron syscallarg(linux_pid_t) pid;
306 1.1 tron syscallarg(struct linux_sched_param *) sp;
307 1.46 dsl } */
308 1.1 tron struct linux_sched_param lp;
309 1.49 elad struct sched_param sp;
310 1.50 elad int error, policy;
311 1.49 elad
312 1.49 elad if (SCARG(uap, pid) < 0 || SCARG(uap, sp) == NULL) {
313 1.49 elad error = EINVAL;
314 1.49 elad goto out;
315 1.49 elad }
316 1.1 tron
317 1.50 elad error = do_sched_getparam(SCARG(uap, pid), 0, &policy, &sp);
318 1.49 elad if (error)
319 1.49 elad goto out;
320 1.53.2.1 yamt #ifdef DEBUG_LINUX
321 1.53.2.1 yamt printf("getparam: native: policy %d, priority %d\n",
322 1.53.2.1 yamt policy, sp.sched_priority);
323 1.53.2.1 yamt #endif
324 1.1 tron
325 1.50 elad error = sched_native2linux(policy, &sp, NULL, &lp);
326 1.49 elad if (error)
327 1.49 elad goto out;
328 1.53.2.1 yamt #ifdef DEBUG_LINUX
329 1.53.2.1 yamt printf("getparam: linux: policy %d, priority %d\n",
330 1.53.2.1 yamt policy, lp.sched_priority);
331 1.53.2.1 yamt #endif
332 1.47 elad
333 1.49 elad error = copyout(&lp, SCARG(uap, sp), sizeof(lp));
334 1.49 elad if (error)
335 1.49 elad goto out;
336 1.1 tron
337 1.49 elad out:
338 1.49 elad return error;
339 1.1 tron }
340 1.1 tron
341 1.1 tron int
342 1.46 dsl linux_sys_sched_setscheduler(struct lwp *l, const struct linux_sys_sched_setscheduler_args *uap, register_t *retval)
343 1.1 tron {
344 1.46 dsl /* {
345 1.1 tron syscallarg(linux_pid_t) pid;
346 1.1 tron syscallarg(int) policy;
347 1.1 tron syscallarg(cont struct linux_sched_scheduler *) sp;
348 1.46 dsl } */
349 1.49 elad int error, policy;
350 1.1 tron struct linux_sched_param lp;
351 1.49 elad struct sched_param sp;
352 1.1 tron
353 1.49 elad if (SCARG(uap, pid) < 0 || SCARG(uap, sp) == NULL) {
354 1.49 elad error = EINVAL;
355 1.49 elad goto out;
356 1.49 elad }
357 1.1 tron
358 1.1 tron error = copyin(SCARG(uap, sp), &lp, sizeof(lp));
359 1.1 tron if (error)
360 1.49 elad goto out;
361 1.53.2.1 yamt #ifdef DEBUG_LINUX
362 1.53.2.1 yamt printf("setscheduler: linux: policy %d, priority %d\n",
363 1.53.2.1 yamt SCARG(uap, policy), lp.sched_priority);
364 1.53.2.1 yamt #endif
365 1.1 tron
366 1.49 elad error = sched_linux2native(SCARG(uap, policy), &lp, &policy, &sp);
367 1.49 elad if (error)
368 1.49 elad goto out;
369 1.53.2.1 yamt #ifdef DEBUG_LINUX
370 1.53.2.1 yamt printf("setscheduler: native: policy %d, priority %d\n",
371 1.53.2.1 yamt policy, sp.sched_priority);
372 1.53.2.1 yamt #endif
373 1.1 tron
374 1.49 elad error = do_sched_setparam(SCARG(uap, pid), 0, policy, &sp);
375 1.49 elad if (error)
376 1.49 elad goto out;
377 1.1 tron
378 1.49 elad out:
379 1.49 elad return error;
380 1.1 tron }
381 1.1 tron
382 1.1 tron int
383 1.46 dsl linux_sys_sched_getscheduler(struct lwp *l, const struct linux_sys_sched_getscheduler_args *uap, register_t *retval)
384 1.1 tron {
385 1.46 dsl /* {
386 1.1 tron syscallarg(linux_pid_t) pid;
387 1.46 dsl } */
388 1.49 elad int error, policy;
389 1.1 tron
390 1.1 tron *retval = -1;
391 1.1 tron
392 1.49 elad error = do_sched_getparam(SCARG(uap, pid), 0, &policy, NULL);
393 1.49 elad if (error)
394 1.49 elad goto out;
395 1.49 elad
396 1.49 elad error = sched_native2linux(policy, NULL, &policy, NULL);
397 1.49 elad if (error)
398 1.49 elad goto out;
399 1.49 elad
400 1.49 elad *retval = policy;
401 1.1 tron
402 1.49 elad out:
403 1.49 elad return error;
404 1.1 tron }
405 1.1 tron
406 1.1 tron int
407 1.46 dsl linux_sys_sched_yield(struct lwp *l, const void *v, register_t *retval)
408 1.1 tron {
409 1.11 gmcgarry
410 1.11 gmcgarry yield();
411 1.1 tron return 0;
412 1.1 tron }
413 1.1 tron
414 1.1 tron int
415 1.46 dsl linux_sys_sched_get_priority_max(struct lwp *l, const struct linux_sys_sched_get_priority_max_args *uap, register_t *retval)
416 1.1 tron {
417 1.46 dsl /* {
418 1.1 tron syscallarg(int) policy;
419 1.46 dsl } */
420 1.1 tron
421 1.53.2.1 yamt switch (SCARG(uap, policy)) {
422 1.53.2.1 yamt case LINUX_SCHED_OTHER:
423 1.53.2.1 yamt *retval = 0;
424 1.53.2.1 yamt break;
425 1.53.2.1 yamt case LINUX_SCHED_FIFO:
426 1.53.2.1 yamt case LINUX_SCHED_RR:
427 1.53.2.1 yamt *retval = LINUX_SCHED_RTPRIO_MAX;
428 1.53.2.1 yamt break;
429 1.53.2.1 yamt default:
430 1.1 tron return EINVAL;
431 1.1 tron }
432 1.1 tron
433 1.1 tron return 0;
434 1.1 tron }
435 1.1 tron
436 1.1 tron int
437 1.46 dsl linux_sys_sched_get_priority_min(struct lwp *l, const struct linux_sys_sched_get_priority_min_args *uap, register_t *retval)
438 1.1 tron {
439 1.46 dsl /* {
440 1.1 tron syscallarg(int) policy;
441 1.46 dsl } */
442 1.1 tron
443 1.53.2.1 yamt switch (SCARG(uap, policy)) {
444 1.53.2.1 yamt case LINUX_SCHED_OTHER:
445 1.53.2.1 yamt *retval = 0;
446 1.53.2.1 yamt break;
447 1.53.2.1 yamt case LINUX_SCHED_FIFO:
448 1.53.2.1 yamt case LINUX_SCHED_RR:
449 1.53.2.1 yamt *retval = LINUX_SCHED_RTPRIO_MIN;
450 1.53.2.1 yamt break;
451 1.53.2.1 yamt default:
452 1.1 tron return EINVAL;
453 1.1 tron }
454 1.1 tron
455 1.1 tron return 0;
456 1.1 tron }
457 1.14 jdolecek
458 1.14 jdolecek #ifndef __m68k__
459 1.14 jdolecek /* Present on everything but m68k */
460 1.14 jdolecek int
461 1.46 dsl linux_sys_exit_group(struct lwp *l, const struct linux_sys_exit_group_args *uap, register_t *retval)
462 1.14 jdolecek {
463 1.35 dogcow #ifdef LINUX_NPTL
464 1.46 dsl /* {
465 1.14 jdolecek syscallarg(int) error_code;
466 1.46 dsl } */
467 1.31 manu struct proc *p = l->l_proc;
468 1.31 manu struct linux_emuldata *led = p->p_emuldata;
469 1.31 manu struct linux_emuldata *e;
470 1.14 jdolecek
471 1.39 njoly if (led->s->flags & LINUX_LES_USE_NPTL) {
472 1.39 njoly
473 1.34 manu #ifdef DEBUG_LINUX
474 1.39 njoly printf("%s:%d, led->s->refs = %d\n", __func__, __LINE__,
475 1.39 njoly led->s->refs);
476 1.34 manu #endif
477 1.39 njoly
478 1.39 njoly /*
479 1.39 njoly * The calling thread is supposed to kill all threads
480 1.39 njoly * in the same thread group (i.e. all threads created
481 1.39 njoly * via clone(2) with CLONE_THREAD flag set).
482 1.39 njoly *
483 1.39 njoly * If there is only one thread, things are quite simple
484 1.39 njoly */
485 1.39 njoly if (led->s->refs == 1)
486 1.46 dsl return sys_exit(l, (const void *)uap, retval);
487 1.31 manu
488 1.31 manu #ifdef DEBUG_LINUX
489 1.39 njoly printf("%s:%d\n", __func__, __LINE__);
490 1.31 manu #endif
491 1.34 manu
492 1.53 ad mutex_enter(proc_lock);
493 1.39 njoly led->s->flags |= LINUX_LES_INEXITGROUP;
494 1.39 njoly led->s->xstat = W_EXITCODE(SCARG(uap, error_code), 0);
495 1.34 manu
496 1.39 njoly /*
497 1.39 njoly * Kill all threads in the group. The emulation exit hook takes
498 1.39 njoly * care of hiding the zombies and reporting the exit code
499 1.39 njoly * properly.
500 1.39 njoly */
501 1.39 njoly LIST_FOREACH(e, &led->s->threads, threads) {
502 1.39 njoly if (e->proc == p)
503 1.39 njoly continue;
504 1.31 manu
505 1.34 manu #ifdef DEBUG_LINUX
506 1.39 njoly printf("%s: kill PID %d\n", __func__, e->proc->p_pid);
507 1.34 manu #endif
508 1.39 njoly psignal(e->proc, SIGKILL);
509 1.39 njoly }
510 1.39 njoly
511 1.39 njoly /* Now, kill ourselves */
512 1.39 njoly psignal(p, SIGKILL);
513 1.53 ad mutex_exit(proc_lock);
514 1.41 ad
515 1.39 njoly return 0;
516 1.39 njoly
517 1.31 manu }
518 1.39 njoly #endif /* LINUX_NPTL */
519 1.14 jdolecek
520 1.46 dsl return sys_exit(l, (const void *)uap, retval);
521 1.14 jdolecek }
522 1.14 jdolecek #endif /* !__m68k__ */
523 1.19 manu
524 1.21 manu #ifdef LINUX_NPTL
525 1.19 manu int
526 1.46 dsl linux_sys_set_tid_address(struct lwp *l, const struct linux_sys_set_tid_address_args *uap, register_t *retval)
527 1.19 manu {
528 1.46 dsl /* {
529 1.19 manu syscallarg(int *) tidptr;
530 1.46 dsl } */
531 1.19 manu struct linux_emuldata *led;
532 1.19 manu
533 1.19 manu led = (struct linux_emuldata *)l->l_proc->p_emuldata;
534 1.19 manu led->clear_tid = SCARG(uap, tid);
535 1.19 manu
536 1.39 njoly led->s->flags |= LINUX_LES_USE_NPTL;
537 1.39 njoly
538 1.19 manu *retval = l->l_proc->p_pid;
539 1.19 manu
540 1.19 manu return 0;
541 1.19 manu }
542 1.20 manu
543 1.20 manu /* ARGUSED1 */
544 1.20 manu int
545 1.46 dsl linux_sys_gettid(struct lwp *l, const void *v, register_t *retval)
546 1.20 manu {
547 1.31 manu /* The Linux kernel does it exactly that way */
548 1.20 manu *retval = l->l_proc->p_pid;
549 1.20 manu return 0;
550 1.20 manu }
551 1.22 manu
552 1.31 manu #ifdef LINUX_NPTL
553 1.31 manu /* ARGUSED1 */
554 1.31 manu int
555 1.46 dsl linux_sys_getpid(struct lwp *l, const void *v, register_t *retval)
556 1.31 manu {
557 1.39 njoly struct linux_emuldata *led = l->l_proc->p_emuldata;
558 1.31 manu
559 1.39 njoly if (led->s->flags & LINUX_LES_USE_NPTL) {
560 1.39 njoly /* The Linux kernel does it exactly that way */
561 1.39 njoly *retval = led->s->group_pid;
562 1.39 njoly } else {
563 1.39 njoly *retval = l->l_proc->p_pid;
564 1.39 njoly }
565 1.31 manu
566 1.31 manu return 0;
567 1.31 manu }
568 1.31 manu
569 1.31 manu /* ARGUSED1 */
570 1.31 manu int
571 1.46 dsl linux_sys_getppid(struct lwp *l, const void *v, register_t *retval)
572 1.31 manu {
573 1.31 manu struct proc *p = l->l_proc;
574 1.31 manu struct linux_emuldata *led = p->p_emuldata;
575 1.31 manu struct proc *glp;
576 1.31 manu struct proc *pp;
577 1.31 manu
578 1.53 ad mutex_enter(proc_lock);
579 1.39 njoly if (led->s->flags & LINUX_LES_USE_NPTL) {
580 1.31 manu
581 1.39 njoly /* Find the thread group leader's parent */
582 1.51 ad if ((glp = p_find(led->s->group_pid, PFIND_LOCKED)) == NULL) {
583 1.39 njoly /* Maybe panic... */
584 1.39 njoly printf("linux_sys_getppid: missing group leader PID"
585 1.39 njoly " %d\n", led->s->group_pid);
586 1.53 ad mutex_exit(proc_lock);
587 1.39 njoly return -1;
588 1.39 njoly }
589 1.39 njoly pp = glp->p_pptr;
590 1.39 njoly
591 1.39 njoly /* If this is a Linux process too, return thread group PID */
592 1.39 njoly if (pp->p_emul == p->p_emul) {
593 1.39 njoly struct linux_emuldata *pled;
594 1.39 njoly
595 1.39 njoly pled = pp->p_emuldata;
596 1.39 njoly *retval = pled->s->group_pid;
597 1.39 njoly } else {
598 1.39 njoly *retval = pp->p_pid;
599 1.39 njoly }
600 1.31 manu
601 1.31 manu } else {
602 1.39 njoly *retval = p->p_pptr->p_pid;
603 1.31 manu }
604 1.53 ad mutex_exit(proc_lock);
605 1.31 manu
606 1.31 manu return 0;
607 1.31 manu }
608 1.31 manu #endif /* LINUX_NPTL */
609 1.31 manu
610 1.22 manu int
611 1.46 dsl linux_sys_sched_getaffinity(struct lwp *l, const struct linux_sys_sched_getaffinity_args *uap, register_t *retval)
612 1.22 manu {
613 1.46 dsl /* {
614 1.22 manu syscallarg(pid_t) pid;
615 1.22 manu syscallarg(unsigned int) len;
616 1.22 manu syscallarg(unsigned long *) mask;
617 1.46 dsl } */
618 1.22 manu int error;
619 1.22 manu int ret;
620 1.22 manu char *data;
621 1.22 manu int *retp;
622 1.22 manu
623 1.22 manu if (SCARG(uap, mask) == NULL)
624 1.22 manu return EINVAL;
625 1.22 manu
626 1.22 manu if (SCARG(uap, len) < sizeof(int))
627 1.22 manu return EINVAL;
628 1.22 manu
629 1.22 manu if (pfind(SCARG(uap, pid)) == NULL)
630 1.22 manu return ESRCH;
631 1.22 manu
632 1.22 manu /*
633 1.22 manu * return the actual number of CPU, tag all of them as available
634 1.22 manu * The result is a mask, the first CPU being in the least significant
635 1.22 manu * bit.
636 1.22 manu */
637 1.22 manu ret = (1 << ncpu) - 1;
638 1.22 manu data = malloc(SCARG(uap, len), M_TEMP, M_WAITOK|M_ZERO);
639 1.22 manu retp = (int *)&data[SCARG(uap, len) - sizeof(ret)];
640 1.22 manu *retp = ret;
641 1.22 manu
642 1.22 manu if ((error = copyout(data, SCARG(uap, mask), SCARG(uap, len))) != 0)
643 1.22 manu return error;
644 1.22 manu
645 1.22 manu free(data, M_TEMP);
646 1.22 manu
647 1.22 manu return 0;
648 1.22 manu
649 1.22 manu }
650 1.22 manu
651 1.22 manu int
652 1.46 dsl linux_sys_sched_setaffinity(struct lwp *l, const struct linux_sys_sched_setaffinity_args *uap, register_t *retval)
653 1.22 manu {
654 1.46 dsl /* {
655 1.22 manu syscallarg(pid_t) pid;
656 1.22 manu syscallarg(unsigned int) len;
657 1.22 manu syscallarg(unsigned long *) mask;
658 1.46 dsl } */
659 1.22 manu
660 1.22 manu if (pfind(SCARG(uap, pid)) == NULL)
661 1.22 manu return ESRCH;
662 1.22 manu
663 1.22 manu /* Let's ignore it */
664 1.22 manu #ifdef DEBUG_LINUX
665 1.22 manu printf("linux_sys_sched_setaffinity\n");
666 1.22 manu #endif
667 1.22 manu return 0;
668 1.22 manu };
669 1.23 manu #endif /* LINUX_NPTL */
670