/* * 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_pid(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;	lock_cpu_hotplug();	read_lock(&tasklist_lock);	p = find_process_by_pid(pid);	if (!p) {		read_unlock(&tasklist_lock);		unlock_cpu_hotplug();		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);	unlock_cpu_hotplug();	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;	lock_cpu_hotplug();	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);	unlock_cpu_hotplug();	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 333static __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);