Home | History | Annotate | Line # | Download | only in common
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