mirror of
https://github.com/torvalds/linux.git
synced 2024-11-16 09:02:00 +00:00
0e568536d9
There are some places left in mips, that lookup task in initial namespace, while the code doing so gets the pid from the user space and thus must treat it as virtual. Signed-off-by: Pavel Emelyanov <xemul@openvz.org> Cc: "Eric W. Biederman" <ebiederm@xmission.com> Cc: Ralf Baechle <ralf@linux-mips.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
178 lines
4.1 KiB
C
178 lines
4.1 KiB
C
/*
|
|
* General MIPS MT support routines, usable in AP/SP, SMVP, or SMTC kernels
|
|
* Copyright (C) 2005 Mips Technologies, Inc
|
|
*/
|
|
#include <linux/cpu.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/security.h>
|
|
#include <linux/types.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
/*
|
|
* CPU mask used to set process affinity for MT VPEs/TCs with FPUs
|
|
*/
|
|
cpumask_t mt_fpu_cpumask;
|
|
|
|
static int fpaff_threshold = -1;
|
|
unsigned long mt_fpemul_threshold = 0;
|
|
|
|
/*
|
|
* Replacement functions for the sys_sched_setaffinity() and
|
|
* sys_sched_getaffinity() system calls, so that we can integrate
|
|
* FPU affinity with the user's requested processor affinity.
|
|
* This code is 98% identical with the sys_sched_setaffinity()
|
|
* and sys_sched_getaffinity() system calls, and should be
|
|
* updated when kernel/sched.c changes.
|
|
*/
|
|
|
|
/*
|
|
* find_process_by_pid - find a process with a matching PID value.
|
|
* used in sys_sched_set/getaffinity() in kernel/sched.c, so
|
|
* cloned here.
|
|
*/
|
|
static inline struct task_struct *find_process_by_pid(pid_t pid)
|
|
{
|
|
return pid ? find_task_by_vpid(pid) : current;
|
|
}
|
|
|
|
|
|
/*
|
|
* mipsmt_sys_sched_setaffinity - set the cpu affinity of a process
|
|
*/
|
|
asmlinkage long mipsmt_sys_sched_setaffinity(pid_t pid, unsigned int len,
|
|
unsigned long __user *user_mask_ptr)
|
|
{
|
|
cpumask_t new_mask;
|
|
cpumask_t effective_mask;
|
|
int retval;
|
|
struct task_struct *p;
|
|
struct thread_info *ti;
|
|
|
|
if (len < sizeof(new_mask))
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(&new_mask, user_mask_ptr, sizeof(new_mask)))
|
|
return -EFAULT;
|
|
|
|
get_online_cpus();
|
|
read_lock(&tasklist_lock);
|
|
|
|
p = find_process_by_pid(pid);
|
|
if (!p) {
|
|
read_unlock(&tasklist_lock);
|
|
put_online_cpus();
|
|
return -ESRCH;
|
|
}
|
|
|
|
/*
|
|
* It is not safe to call set_cpus_allowed with the
|
|
* tasklist_lock held. We will bump the task_struct's
|
|
* usage count and drop tasklist_lock before invoking
|
|
* set_cpus_allowed.
|
|
*/
|
|
get_task_struct(p);
|
|
|
|
retval = -EPERM;
|
|
if ((current->euid != p->euid) && (current->euid != p->uid) &&
|
|
!capable(CAP_SYS_NICE)) {
|
|
read_unlock(&tasklist_lock);
|
|
goto out_unlock;
|
|
}
|
|
|
|
retval = security_task_setscheduler(p, 0, NULL);
|
|
if (retval)
|
|
goto out_unlock;
|
|
|
|
/* Record new user-specified CPU set for future reference */
|
|
p->thread.user_cpus_allowed = new_mask;
|
|
|
|
/* Unlock the task list */
|
|
read_unlock(&tasklist_lock);
|
|
|
|
/* Compute new global allowed CPU set if necessary */
|
|
ti = task_thread_info(p);
|
|
if (test_ti_thread_flag(ti, TIF_FPUBOUND) &&
|
|
cpus_intersects(new_mask, mt_fpu_cpumask)) {
|
|
cpus_and(effective_mask, new_mask, mt_fpu_cpumask);
|
|
retval = set_cpus_allowed(p, effective_mask);
|
|
} else {
|
|
clear_ti_thread_flag(ti, TIF_FPUBOUND);
|
|
retval = set_cpus_allowed(p, new_mask);
|
|
}
|
|
|
|
out_unlock:
|
|
put_task_struct(p);
|
|
put_online_cpus();
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
* mipsmt_sys_sched_getaffinity - get the cpu affinity of a process
|
|
*/
|
|
asmlinkage long mipsmt_sys_sched_getaffinity(pid_t pid, unsigned int len,
|
|
unsigned long __user *user_mask_ptr)
|
|
{
|
|
unsigned int real_len;
|
|
cpumask_t mask;
|
|
int retval;
|
|
struct task_struct *p;
|
|
|
|
real_len = sizeof(mask);
|
|
if (len < real_len)
|
|
return -EINVAL;
|
|
|
|
get_online_cpus();
|
|
read_lock(&tasklist_lock);
|
|
|
|
retval = -ESRCH;
|
|
p = find_process_by_pid(pid);
|
|
if (!p)
|
|
goto out_unlock;
|
|
retval = security_task_getscheduler(p);
|
|
if (retval)
|
|
goto out_unlock;
|
|
|
|
cpus_and(mask, p->thread.user_cpus_allowed, cpu_possible_map);
|
|
|
|
out_unlock:
|
|
read_unlock(&tasklist_lock);
|
|
put_online_cpus();
|
|
if (retval)
|
|
return retval;
|
|
if (copy_to_user(user_mask_ptr, &mask, real_len))
|
|
return -EFAULT;
|
|
return real_len;
|
|
}
|
|
|
|
|
|
static int __init fpaff_thresh(char *str)
|
|
{
|
|
get_option(&str, &fpaff_threshold);
|
|
return 1;
|
|
}
|
|
__setup("fpaff=", fpaff_thresh);
|
|
|
|
/*
|
|
* FPU Use Factor empirically derived from experiments on 34K
|
|
*/
|
|
#define FPUSEFACTOR 333
|
|
|
|
static __init int mt_fp_affinity_init(void)
|
|
{
|
|
if (fpaff_threshold >= 0) {
|
|
mt_fpemul_threshold = fpaff_threshold;
|
|
} else {
|
|
mt_fpemul_threshold =
|
|
(FPUSEFACTOR * (loops_per_jiffy/(500000/HZ))) / HZ;
|
|
}
|
|
printk(KERN_DEBUG "FPU Affinity set after %ld emulations\n",
|
|
mt_fpemul_threshold);
|
|
|
|
return 0;
|
|
}
|
|
arch_initcall(mt_fp_affinity_init);
|