lkml.org 
[lkml]   [2008]   [Mar]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
Subject[PATCH 02/12] cpumask: pass pointer to cpumask for set_cpus_allowed() v2
Instead of passing by value, the "newly allowed cpus" cpumask
argument, pass a pointer:

-int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
+int set_cpus_allowed(struct task_struct *p, const cpumask_t *new_mask)

This is a major ABI change and unfortunately touches a number of files
as the function is very commonly used. I had thought of using a macro
to "silently" pass the 2nd arg as a pointer, but you lose in the
situation where you already have a pointer to the new cpumask.

This removes 10792 bytes of stack usage.

Based on:
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
git://git.kernel.org/pub/scm/linux/kernel/git/x86/linux-2.6-x86.git

Signed-off-by: Mike Travis <travis@sgi.com>
---
v2: rebased on linux-2.6.git + linux-2.6-x86.git
---
arch/arm/mach-integrator/cpu.c | 10 ++++-----
arch/ia64/kernel/cpufreq/acpi-cpufreq.c | 10 ++++-----
arch/ia64/kernel/salinfo.c | 4 +--
arch/ia64/kernel/topology.c | 4 +--
arch/ia64/sn/kernel/sn2/sn_hwperf.c | 4 +--
arch/ia64/sn/kernel/xpc_main.c | 4 +--
arch/mips/kernel/mips-mt-fpaff.c | 4 +--
arch/mips/kernel/traps.c | 2 -
arch/powerpc/kernel/smp.c | 4 +--
arch/powerpc/kernel/sysfs.c | 4 +--
arch/powerpc/platforms/pseries/rtasd.c | 4 +--
arch/sh/kernel/cpufreq.c | 4 +--
arch/sparc64/kernel/sysfs.c | 4 +--
arch/sparc64/kernel/us2e_cpufreq.c | 8 +++----
arch/sparc64/kernel/us3_cpufreq.c | 8 +++----
arch/x86/kernel/acpi/cstate.c | 4 +--
arch/x86/kernel/apm_32.c | 6 ++---
arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c | 12 +++++------
arch/x86/kernel/cpu/cpufreq/powernow-k8.c | 20 +++++++++---------
arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c | 12 +++++------
arch/x86/kernel/cpu/cpufreq/speedstep-ich.c | 12 +++++------
arch/x86/kernel/cpu/intel_cacheinfo.c | 4 +--
arch/x86/kernel/cpu/mcheck/mce_amd_64.c | 4 +--
arch/x86/kernel/microcode.c | 16 +++++++-------
arch/x86/kernel/process_64.c | 1
arch/x86/kernel/reboot.c | 2 -
drivers/acpi/processor_throttling.c | 10 ++++-----
drivers/firmware/dcdbas.c | 4 +--
drivers/pci/pci-driver.c | 10 ++++++---
include/linux/cpuset.h | 13 ++++++-----
include/linux/sched.h | 10 +++++----
init/main.c | 2 -
kernel/cpu.c | 4 +--
kernel/cpuset.c | 22 +++++++-------------
kernel/kmod.c | 2 -
kernel/kthread.c | 4 +--
kernel/rcutorture.c | 11 +++++-----
kernel/sched.c | 25 +++++++++++------------
kernel/sched_rt.c | 3 +-
kernel/stop_machine.c | 2 -
mm/pdflush.c | 4 +--
mm/vmscan.c | 6 ++---
net/sunrpc/svc.c | 18 +++++++++++-----
43 files changed, 166 insertions(+), 155 deletions(-)
--- linux.trees.git.orig/arch/arm/mach-integrator/cpu.c
+++ linux.trees.git/arch/arm/mach-integrator/cpu.c
@@ -94,7 +94,7 @@ static int integrator_set_target(struct
* Bind to the specified CPU. When this call returns,
* we should be running on the right CPU.
*/
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
BUG_ON(cpu != smp_processor_id());

/* get current setting */
@@ -122,7 +122,7 @@ static int integrator_set_target(struct
freqs.cpu = policy->cpu;

if (freqs.old == freqs.new) {
- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);
return 0;
}

@@ -145,7 +145,7 @@ static int integrator_set_target(struct
/*
* Restore the CPUs allowed mask.
*/
- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);

cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);

@@ -161,7 +161,7 @@ static unsigned int integrator_get(unsig

cpus_allowed = current->cpus_allowed;

- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
BUG_ON(cpu != smp_processor_id());

/* detect memory etc. */
@@ -177,7 +177,7 @@ static unsigned int integrator_get(unsig

current_freq = icst525_khz(&cclk_params, vco); /* current freq */

- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);

return current_freq;
}
--- linux.trees.git.orig/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
+++ linux.trees.git/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
@@ -112,7 +112,7 @@ processor_get_freq (
dprintk("processor_get_freq\n");

saved_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (smp_processor_id() != cpu)
goto migrate_end;

@@ -120,7 +120,7 @@ processor_get_freq (
ret = processor_get_pstate(&value);

if (ret) {
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
printk(KERN_WARNING "get performance failed with error %d\n",
ret);
ret = 0;
@@ -130,7 +130,7 @@ processor_get_freq (
ret = (clock_freq*1000);

migrate_end:
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return ret;
}

@@ -150,7 +150,7 @@ processor_set_freq (
dprintk("processor_set_freq\n");

saved_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (smp_processor_id() != cpu) {
retval = -EAGAIN;
goto migrate_end;
@@ -207,7 +207,7 @@ processor_set_freq (
retval = 0;

migrate_end:
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return (retval);
}

--- linux.trees.git.orig/arch/ia64/kernel/salinfo.c
+++ linux.trees.git/arch/ia64/kernel/salinfo.c
@@ -405,9 +405,9 @@ call_on_cpu(int cpu, void (*fn)(void *),
{
cpumask_t save_cpus_allowed = current->cpus_allowed;
cpumask_t new_cpus_allowed = cpumask_of_cpu(cpu);
- set_cpus_allowed(current, new_cpus_allowed);
+ set_cpus_allowed(current, &new_cpus_allowed);
(*fn)(arg);
- set_cpus_allowed(current, save_cpus_allowed);
+ set_cpus_allowed(current, &save_cpus_allowed);
}

static void
--- linux.trees.git.orig/arch/ia64/kernel/topology.c
+++ linux.trees.git/arch/ia64/kernel/topology.c
@@ -345,12 +345,12 @@ static int __cpuinit cache_add_dev(struc
return 0;

oldmask = current->cpus_allowed;
- retval = set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ retval = set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (unlikely(retval))
return retval;

retval = cpu_cache_sysfs_init(cpu);
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
if (unlikely(retval < 0))
return retval;

--- linux.trees.git.orig/arch/ia64/sn/kernel/sn2/sn_hwperf.c
+++ linux.trees.git/arch/ia64/sn/kernel/sn2/sn_hwperf.c
@@ -635,9 +635,9 @@ static int sn_hwperf_op_cpu(struct sn_hw
else {
/* migrate the task before calling SAL */
save_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
sn_hwperf_call_sal(op_info);
- set_cpus_allowed(current, save_allowed);
+ set_cpus_allowed(current, &save_allowed);
}
}
r = op_info->ret;
--- linux.trees.git.orig/arch/ia64/sn/kernel/xpc_main.c
+++ linux.trees.git/arch/ia64/sn/kernel/xpc_main.c
@@ -255,7 +255,7 @@ xpc_hb_checker(void *ignore)

daemonize(XPC_HB_CHECK_THREAD_NAME);

- set_cpus_allowed(current, cpumask_of_cpu(XPC_HB_CHECK_CPU));
+ set_cpus_allowed(current, &cpumask_of_cpu(XPC_HB_CHECK_CPU));

/* set our heartbeating to other partitions into motion */
xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ);
@@ -509,7 +509,7 @@ xpc_activating(void *__partid)
}

/* allow this thread and its children to run on any CPU */
- set_cpus_allowed(current, CPU_MASK_ALL);
+ set_cpus_allowed(current, &CPU_MASK_ALL);

/*
* Register the remote partition's AMOs with SAL so it can handle
--- linux.trees.git.orig/arch/mips/kernel/mips-mt-fpaff.c
+++ linux.trees.git/arch/mips/kernel/mips-mt-fpaff.c
@@ -98,10 +98,10 @@ asmlinkage long mipsmt_sys_sched_setaffi
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);
+ retval = set_cpus_allowed(p, &effective_mask);
} else {
clear_ti_thread_flag(ti, TIF_FPUBOUND);
- retval = set_cpus_allowed(p, new_mask);
+ retval = set_cpus_allowed(p, &new_mask);
}

out_unlock:
--- linux.trees.git.orig/arch/mips/kernel/traps.c
+++ linux.trees.git/arch/mips/kernel/traps.c
@@ -804,7 +804,7 @@ static void mt_ase_fp_affinity(void)

cpus_and(tmask, current->thread.user_cpus_allowed,
mt_fpu_cpumask);
- set_cpus_allowed(current, tmask);
+ set_cpus_allowed(current, &tmask);
set_thread_flag(TIF_FPUBOUND);
}
}
--- linux.trees.git.orig/arch/powerpc/kernel/smp.c
+++ linux.trees.git/arch/powerpc/kernel/smp.c
@@ -618,12 +618,12 @@ void __init smp_cpus_done(unsigned int m
* se we pin us down to CPU 0 for a short while
*/
old_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(boot_cpuid));
+ set_cpus_allowed(current, &cpumask_of_cpu(boot_cpuid));

if (smp_ops)
smp_ops->setup_cpu(boot_cpuid);

- set_cpus_allowed(current, old_mask);
+ set_cpus_allowed(current, &old_mask);

snapshot_timebases();

--- linux.trees.git.orig/arch/powerpc/kernel/sysfs.c
+++ linux.trees.git/arch/powerpc/kernel/sysfs.c
@@ -131,12 +131,12 @@ static unsigned long run_on_cpu(unsigned
unsigned long ret;

/* should return -EINVAL to userspace */
- if (set_cpus_allowed(current, cpumask_of_cpu(cpu)))
+ if (set_cpus_allowed(current, &cpumask_of_cpu(cpu)))
return 0;

ret = func(arg);

- set_cpus_allowed(current, old_affinity);
+ set_cpus_allowed(current, &old_affinity);

return ret;
}
--- linux.trees.git.orig/arch/powerpc/platforms/pseries/rtasd.c
+++ linux.trees.git/arch/powerpc/platforms/pseries/rtasd.c
@@ -385,9 +385,9 @@ static void do_event_scan_all_cpus(long
get_online_cpus();
cpu = first_cpu(cpu_online_map);
for (;;) {
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
do_event_scan();
- set_cpus_allowed(current, CPU_MASK_ALL);
+ set_cpus_allowed(current, &CPU_MASK_ALL);

/* Drop hotplug lock, and sleep for the specified delay */
put_online_cpus();
--- linux.trees.git.orig/arch/sh/kernel/cpufreq.c
+++ linux.trees.git/arch/sh/kernel/cpufreq.c
@@ -48,7 +48,7 @@ static int sh_cpufreq_target(struct cpuf
return -ENODEV;

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

BUG_ON(smp_processor_id() != cpu);

@@ -66,7 +66,7 @@ static int sh_cpufreq_target(struct cpuf
freqs.flags = 0;

cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);
clk_set_rate(cpuclk, freq);
cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);

--- linux.trees.git.orig/arch/sparc64/kernel/sysfs.c
+++ linux.trees.git/arch/sparc64/kernel/sysfs.c
@@ -104,12 +104,12 @@ static unsigned long run_on_cpu(unsigned
unsigned long ret;

/* should return -EINVAL to userspace */
- if (set_cpus_allowed(current, cpumask_of_cpu(cpu)))
+ if (set_cpus_allowed(current, &cpumask_of_cpu(cpu)))
return 0;

ret = func(arg);

- set_cpus_allowed(current, old_affinity);
+ set_cpus_allowed(current, &old_affinity);

return ret;
}
--- linux.trees.git.orig/arch/sparc64/kernel/us2e_cpufreq.c
+++ linux.trees.git/arch/sparc64/kernel/us2e_cpufreq.c
@@ -238,12 +238,12 @@ static unsigned int us2e_freq_get(unsign
return 0;

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

clock_tick = sparc64_get_clock_tick(cpu) / 1000;
estar = read_hbreg(HBIRD_ESTAR_MODE_ADDR);

- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);

return clock_tick / estar_to_divisor(estar);
}
@@ -259,7 +259,7 @@ static void us2e_set_cpu_divider_index(u
return;

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

new_freq = clock_tick = sparc64_get_clock_tick(cpu) / 1000;
new_bits = index_to_estar_mode(index);
@@ -281,7 +281,7 @@ static void us2e_set_cpu_divider_index(u

cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);

- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);
}

static int us2e_freq_target(struct cpufreq_policy *policy,
--- linux.trees.git.orig/arch/sparc64/kernel/us3_cpufreq.c
+++ linux.trees.git/arch/sparc64/kernel/us3_cpufreq.c
@@ -86,12 +86,12 @@ static unsigned int us3_freq_get(unsigne
return 0;

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

reg = read_safari_cfg();
ret = get_current_freq(cpu, reg);

- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);

return ret;
}
@@ -106,7 +106,7 @@ static void us3_set_cpu_divider_index(un
return;

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

new_freq = sparc64_get_clock_tick(cpu) / 1000;
switch (index) {
@@ -140,7 +140,7 @@ static void us3_set_cpu_divider_index(un

cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);

- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);
}

static int us3_freq_target(struct cpufreq_policy *policy,
--- linux.trees.git.orig/arch/x86/kernel/acpi/cstate.c
+++ linux.trees.git/arch/x86/kernel/acpi/cstate.c
@@ -91,7 +91,7 @@ int acpi_processor_ffh_cstate_probe(unsi

/* Make sure we are running on right CPU */
saved_mask = current->cpus_allowed;
- retval = set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ retval = set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (retval)
return -1;

@@ -128,7 +128,7 @@ int acpi_processor_ffh_cstate_probe(unsi
cx->address);

out:
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return retval;
}
EXPORT_SYMBOL_GPL(acpi_processor_ffh_cstate_probe);
--- linux.trees.git.orig/arch/x86/kernel/apm_32.c
+++ linux.trees.git/arch/x86/kernel/apm_32.c
@@ -496,14 +496,14 @@ static cpumask_t apm_save_cpus(void)
{
cpumask_t x = current->cpus_allowed;
/* Some bioses don't like being called from CPU != 0 */
- set_cpus_allowed(current, cpumask_of_cpu(0));
+ set_cpus_allowed(current, &cpumask_of_cpu(0));
BUG_ON(smp_processor_id() != 0);
return x;
}

static inline void apm_restore_cpus(cpumask_t mask)
{
- set_cpus_allowed(current, mask);
+ set_cpus_allowed(current, &mask);
}

#else
@@ -1694,7 +1694,7 @@ static int apm(void *unused)
* Some bioses don't like being called from CPU != 0.
* Method suggested by Ingo Molnar.
*/
- set_cpus_allowed(current, cpumask_of_cpu(0));
+ set_cpus_allowed(current, &cpumask_of_cpu(0));
BUG_ON(smp_processor_id() != 0);
#endif

--- linux.trees.git.orig/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ linux.trees.git/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -192,9 +192,9 @@ static void drv_read(struct drv_cmd *cmd
cpumask_t saved_mask = current->cpus_allowed;
cmd->val = 0;

- set_cpus_allowed(current, cmd->mask);
+ set_cpus_allowed(current, &cmd->mask);
do_drv_read(cmd);
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
}

static void drv_write(struct drv_cmd *cmd)
@@ -203,11 +203,11 @@ static void drv_write(struct drv_cmd *cm
unsigned int i;

for_each_cpu_mask(i, cmd->mask) {
- set_cpus_allowed(current, cpumask_of_cpu(i));
+ set_cpus_allowed(current, &cpumask_of_cpu(i));
do_drv_write(cmd);
}

- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return;
}

@@ -271,7 +271,7 @@ static unsigned int get_measured_perf(un
unsigned int retval;

saved_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (get_cpu() != cpu) {
/* We were not able to run on requested processor */
put_cpu();
@@ -329,7 +329,7 @@ static unsigned int get_measured_perf(un
retval = per_cpu(drv_data, cpu)->max_freq * perf_percent / 100;

put_cpu();
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);

dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
return retval;
--- linux.trees.git.orig/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ linux.trees.git/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -483,7 +483,7 @@ static int check_supported_cpu(unsigned
unsigned int rc = 0;

oldmask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

if (smp_processor_id() != cpu) {
printk(KERN_ERR PFX "limiting to cpu %u failed\n", cpu);
@@ -528,7 +528,7 @@ static int check_supported_cpu(unsigned
rc = 1;

out:
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
return rc;
}

@@ -1030,7 +1030,7 @@ static int powernowk8_target(struct cpuf

/* only run on specific CPU from here on */
oldmask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(pol->cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(pol->cpu));

if (smp_processor_id() != pol->cpu) {
printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1085,7 +1085,7 @@ static int powernowk8_target(struct cpuf
ret = 0;

err_out:
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
return ret;
}

@@ -1145,7 +1145,7 @@ static int __cpuinit powernowk8_cpu_init

/* only run on specific CPU from here on */
oldmask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(pol->cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(pol->cpu));

if (smp_processor_id() != pol->cpu) {
printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1164,7 +1164,7 @@ static int __cpuinit powernowk8_cpu_init
fidvid_msr_init();

/* run on any CPU again */
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);

if (cpu_family == CPU_HW_PSTATE)
pol->cpus = cpumask_of_cpu(pol->cpu);
@@ -1205,7 +1205,7 @@ static int __cpuinit powernowk8_cpu_init
return 0;

err_out:
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
powernow_k8_cpu_exit_acpi(data);

kfree(data);
@@ -1242,10 +1242,10 @@ static unsigned int powernowk8_get (unsi
if (!data)
return -EINVAL;

- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (smp_processor_id() != cpu) {
printk(KERN_ERR PFX "limiting to CPU %d failed in powernowk8_get\n", cpu);
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
return 0;
}

@@ -1259,7 +1259,7 @@ static unsigned int powernowk8_get (unsi


out:
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
return khz;
}

--- linux.trees.git.orig/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ linux.trees.git/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -315,7 +315,7 @@ static unsigned int get_cur_freq(unsigne
cpumask_t saved_mask;

saved_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (smp_processor_id() != cpu)
return 0;

@@ -333,7 +333,7 @@ static unsigned int get_cur_freq(unsigne
clock_freq = extract_clock(l, cpu, 1);
}

- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return clock_freq;
}

@@ -487,7 +487,7 @@ static int centrino_target (struct cpufr
else
cpu_set(j, set_mask);

- set_cpus_allowed(current, set_mask);
+ set_cpus_allowed(current, &set_mask);
preempt_disable();
if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
dprintk("couldn't limit to CPUs in this domain\n");
@@ -555,7 +555,7 @@ static int centrino_target (struct cpufr

if (!cpus_empty(covered_cpus)) {
for_each_cpu_mask(j, covered_cpus) {
- set_cpus_allowed(current, cpumask_of_cpu(j));
+ set_cpus_allowed(current, &cpumask_of_cpu(j));
wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
}
}
@@ -569,12 +569,12 @@ static int centrino_target (struct cpufr
cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
}
}
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return 0;

migrate_end:
preempt_enable();
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return 0;
}

--- linux.trees.git.orig/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ linux.trees.git/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
@@ -235,9 +235,9 @@ static unsigned int _speedstep_get(cpuma
cpumask_t cpus_allowed;

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, cpus);
+ set_cpus_allowed(current, &cpus);
speed = speedstep_get_processor_frequency(speedstep_processor);
- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);
dprintk("detected %u kHz as current frequency\n", speed);
return speed;
}
@@ -285,12 +285,12 @@ static int speedstep_target (struct cpuf
}

/* switch to physical CPU where state is to be changed */
- set_cpus_allowed(current, policy->cpus);
+ set_cpus_allowed(current, &policy->cpus);

speedstep_set_state(newstate);

/* allow to be run on all CPUs */
- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);

for_each_cpu_mask(i, policy->cpus) {
freqs.cpu = i;
@@ -326,7 +326,7 @@ static int speedstep_cpu_init(struct cpu
#endif

cpus_allowed = current->cpus_allowed;
- set_cpus_allowed(current, policy->cpus);
+ set_cpus_allowed(current, &policy->cpus);

/* detect low and high frequency and transition latency */
result = speedstep_get_freqs(speedstep_processor,
@@ -334,7 +334,7 @@ static int speedstep_cpu_init(struct cpu
&speedstep_freqs[SPEEDSTEP_HIGH].frequency,
&policy->cpuinfo.transition_latency,
&speedstep_set_state);
- set_cpus_allowed(current, cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);
if (result)
return result;

--- linux.trees.git.orig/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ linux.trees.git/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -525,7 +525,7 @@ static int __cpuinit detect_cache_attrib
return -ENOMEM;

oldmask = current->cpus_allowed;
- retval = set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ retval = set_cpus_allowed(current, &cpumask_of_cpu(cpu));
if (retval)
goto out;

@@ -542,7 +542,7 @@ static int __cpuinit detect_cache_attrib
}
cache_shared_cpu_map_setup(cpu, j);
}
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);

out:
if (retval) {
--- linux.trees.git.orig/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
+++ linux.trees.git/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
@@ -256,13 +256,13 @@ static cpumask_t affinity_set(unsigned i
cpumask_t oldmask = current->cpus_allowed;
cpumask_t newmask = CPU_MASK_NONE;
cpu_set(cpu, newmask);
- set_cpus_allowed(current, newmask);
+ set_cpus_allowed(current, &newmask);
return oldmask;
}

static void affinity_restore(cpumask_t oldmask)
{
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
}

#define SHOW_FIELDS(name) \
--- linux.trees.git.orig/arch/x86/kernel/microcode.c
+++ linux.trees.git/arch/x86/kernel/microcode.c
@@ -402,7 +402,7 @@ static int do_microcode_update (void)

if (!uci->valid)
continue;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
error = get_maching_microcode(new_mc, cpu);
if (error < 0)
goto out;
@@ -416,7 +416,7 @@ out:
vfree(new_mc);
if (cursor < 0)
error = cursor;
- set_cpus_allowed(current, old);
+ set_cpus_allowed(current, &old);
return error;
}

@@ -579,7 +579,7 @@ static int apply_microcode_check_cpu(int
return 0;

old = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

/* Check if the microcode we have in memory matches the CPU */
if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
@@ -610,7 +610,7 @@ static int apply_microcode_check_cpu(int
" sig=0x%x, pf=0x%x, rev=0x%x\n",
cpu, uci->sig, uci->pf, uci->rev);

- set_cpus_allowed(current, old);
+ set_cpus_allowed(current, &old);
return err;
}

@@ -621,13 +621,13 @@ static void microcode_init_cpu(int cpu,

old = current->cpus_allowed;

- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
mutex_lock(&microcode_mutex);
collect_cpu_info(cpu);
if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
cpu_request_microcode(cpu);
mutex_unlock(&microcode_mutex);
- set_cpus_allowed(current, old);
+ set_cpus_allowed(current, &old);
}

static void microcode_fini_cpu(int cpu)
@@ -657,14 +657,14 @@ static ssize_t reload_store(struct sys_d
old = current->cpus_allowed;

get_online_cpus();
- set_cpus_allowed(current, cpumask_of_cpu(cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));

mutex_lock(&microcode_mutex);
if (uci->valid)
err = cpu_request_microcode(cpu);
mutex_unlock(&microcode_mutex);
put_online_cpus();
- set_cpus_allowed(current, old);
+ set_cpus_allowed(current, &old);
}
if (err)
return err;
--- linux.trees.git.orig/arch/x86/kernel/process_64.c
+++ linux.trees.git/arch/x86/kernel/process_64.c
@@ -37,6 +37,7 @@
#include <linux/kprobes.h>
#include <linux/kdebug.h>
#include <linux/tick.h>
+#include <linux/sched.h>

#include <asm/uaccess.h>
#include <asm/pgtable.h>
--- linux.trees.git.orig/arch/x86/kernel/reboot.c
+++ linux.trees.git/arch/x86/kernel/reboot.c
@@ -420,7 +420,7 @@ static void native_machine_shutdown(void
reboot_cpu_id = smp_processor_id();

/* Make certain I only run on the appropriate processor */
- set_cpus_allowed(current, cpumask_of_cpu(reboot_cpu_id));
+ set_cpus_allowed(current, &cpumask_of_cpu(reboot_cpu_id));

/* O.K Now that I'm on the appropriate processor,
* stop all of the others.
--- linux.trees.git.orig/drivers/acpi/processor_throttling.c
+++ linux.trees.git/drivers/acpi/processor_throttling.c
@@ -838,10 +838,10 @@ static int acpi_processor_get_throttling
* Migrate task to the cpu pointed by pr.
*/
saved_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(pr->id));
+ set_cpus_allowed(current, &cpumask_of_cpu(pr->id));
ret = pr->throttling.acpi_processor_get_throttling(pr);
/* restore the previous state */
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);

return ret;
}
@@ -1025,7 +1025,7 @@ int acpi_processor_set_throttling(struct
* it can be called only for the cpu pointed by pr.
*/
if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
- set_cpus_allowed(current, cpumask_of_cpu(pr->id));
+ set_cpus_allowed(current, &cpumask_of_cpu(pr->id));
ret = p_throttling->acpi_processor_set_throttling(pr,
t_state.target_state);
} else {
@@ -1056,7 +1056,7 @@ int acpi_processor_set_throttling(struct
continue;
}
t_state.cpu = i;
- set_cpus_allowed(current, cpumask_of_cpu(i));
+ set_cpus_allowed(current, &cpumask_of_cpu(i));
ret = match_pr->throttling.
acpi_processor_set_throttling(
match_pr, t_state.target_state);
@@ -1074,7 +1074,7 @@ int acpi_processor_set_throttling(struct
&t_state);
}
/* restore the previous state */
- set_cpus_allowed(current, saved_mask);
+ set_cpus_allowed(current, &saved_mask);
return ret;
}

--- linux.trees.git.orig/drivers/firmware/dcdbas.c
+++ linux.trees.git/drivers/firmware/dcdbas.c
@@ -265,7 +265,7 @@ static int smi_request(struct smi_cmd *s

/* SMI requires CPU 0 */
old_mask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(0));
+ set_cpus_allowed(current, &cpumask_of_cpu(0));
if (smp_processor_id() != 0) {
dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
__FUNCTION__);
@@ -285,7 +285,7 @@ static int smi_request(struct smi_cmd *s
);

out:
- set_cpus_allowed(current, old_mask);
+ set_cpus_allowed(current, &old_mask);
return ret;
}

--- linux.trees.git.orig/drivers/pci/pci-driver.c
+++ linux.trees.git/drivers/pci/pci-driver.c
@@ -182,15 +182,19 @@ static int pci_call_probe(struct pci_dri
struct mempolicy *oldpol;
cpumask_t oldmask = current->cpus_allowed;
int node = dev_to_node(&dev->dev);
- if (node >= 0)
- set_cpus_allowed(current, node_to_cpumask(node));
+
+ if (node >= 0) {
+ cpumask_t nodecpumask = node_to_cpumask(node);
+ set_cpus_allowed(current, &nodecpumask);
+ }
+
/* And set default memory allocation policy */
oldpol = current->mempolicy;
current->mempolicy = NULL; /* fall back to system default policy */
#endif
error = drv->probe(dev, id);
#ifdef CONFIG_NUMA
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);
current->mempolicy = oldpol;
#endif
return error;
--- linux.trees.git.orig/include/linux/cpuset.h
+++ linux.trees.git/include/linux/cpuset.h
@@ -20,8 +20,8 @@ extern int number_of_cpusets; /* How man
extern int cpuset_init_early(void);
extern int cpuset_init(void);
extern void cpuset_init_smp(void);
-extern cpumask_t cpuset_cpus_allowed(struct task_struct *p);
-extern cpumask_t cpuset_cpus_allowed_locked(struct task_struct *p);
+extern void cpuset_cpus_allowed(struct task_struct *p, cpumask_t *mask);
+extern void cpuset_cpus_allowed_locked(struct task_struct *p, cpumask_t *mask);
extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
#define cpuset_current_mems_allowed (current->mems_allowed)
void cpuset_init_current_mems_allowed(void);
@@ -84,13 +84,14 @@ static inline int cpuset_init_early(void
static inline int cpuset_init(void) { return 0; }
static inline void cpuset_init_smp(void) {}

-static inline cpumask_t cpuset_cpus_allowed(struct task_struct *p)
+static inline void cpuset_cpus_allowed(struct task_struct *p, cpumask_t *mask)
{
- return cpu_possible_map;
+ *mask = cpu_possible_map;
}
-static inline cpumask_t cpuset_cpus_allowed_locked(struct task_struct *p)
+static inline void cpuset_cpus_allowed_locked(struct task_struct *p,
+ cpumask_t *mask)
{
- return cpu_possible_map;
+ *mask = cpu_possible_map;
}

static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
--- linux.trees.git.orig/include/linux/sched.h
+++ linux.trees.git/include/linux/sched.h
@@ -889,7 +889,8 @@ struct sched_class {
void (*set_curr_task) (struct rq *rq);
void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
void (*task_new) (struct rq *rq, struct task_struct *p);
- void (*set_cpus_allowed)(struct task_struct *p, cpumask_t *newmask);
+ void (*set_cpus_allowed)(struct task_struct *p,
+ const cpumask_t *newmask);

void (*join_domain)(struct rq *rq);
void (*leave_domain)(struct rq *rq);
@@ -1501,11 +1502,12 @@ static inline void put_task_struct(struc
#define used_math() tsk_used_math(current)

#ifdef CONFIG_SMP
-extern int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask);
+extern int set_cpus_allowed(struct task_struct *p, const cpumask_t *new_mask);
#else
-static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
+static inline int set_cpus_allowed(struct task_struct *p,
+ const cpumask_t *new_mask)
{
- if (!cpu_isset(0, new_mask))
+ if (!cpu_isset(0, *new_mask))
return -EINVAL;
return 0;
}
--- linux.trees.git.orig/init/main.c
+++ linux.trees.git/init/main.c
@@ -845,7 +845,7 @@ static int __init kernel_init(void * unu
/*
* init can run on any cpu.
*/
- set_cpus_allowed(current, CPU_MASK_ALL);
+ set_cpus_allowed(current, &CPU_MASK_ALL);
/*
* Tell the world that we're going to be the grim
* reaper of innocent orphaned children.
--- linux.trees.git.orig/kernel/cpu.c
+++ linux.trees.git/kernel/cpu.c
@@ -234,7 +234,7 @@ static int _cpu_down(unsigned int cpu, i
old_allowed = current->cpus_allowed;
tmp = CPU_MASK_ALL;
cpu_clear(cpu, tmp);
- set_cpus_allowed(current, tmp);
+ set_cpus_allowed(current, &tmp);

p = __stop_machine_run(take_cpu_down, &tcd_param, cpu);

@@ -268,7 +268,7 @@ static int _cpu_down(unsigned int cpu, i
out_thread:
err = kthread_stop(p);
out_allowed:
- set_cpus_allowed(current, old_allowed);
+ set_cpus_allowed(current, &old_allowed);
out_release:
cpu_hotplug_done();
return err;
--- linux.trees.git.orig/kernel/cpuset.c
+++ linux.trees.git/kernel/cpuset.c
@@ -729,7 +729,8 @@ int cpuset_test_cpumask(struct task_stru
*/
void cpuset_change_cpumask(struct task_struct *tsk, struct cgroup_scanner *scan)
{
- set_cpus_allowed(tsk, (cgroup_cs(scan->cg))->cpus_allowed);
+ cpumask_t newmask = cgroup_cs(scan->cg)->cpus_allowed;
+ set_cpus_allowed(tsk, &newmask);
}

/**
@@ -1178,7 +1179,7 @@ static void cpuset_attach(struct cgroup_

mutex_lock(&callback_mutex);
guarantee_online_cpus(cs, &cpus);
- set_cpus_allowed(tsk, cpus);
+ set_cpus_allowed(tsk, &cpus);
mutex_unlock(&callback_mutex);

from = oldcs->mems_allowed;
@@ -1844,6 +1845,7 @@ void __init cpuset_init_smp(void)

* cpuset_cpus_allowed - return cpus_allowed mask from a tasks cpuset.
* @tsk: pointer to task_struct from which to obtain cpuset->cpus_allowed.
+ * @mask: pointer to cpumask to be returned.
*
* Description: Returns the cpumask_t cpus_allowed of the cpuset
* attached to the specified @tsk. Guaranteed to return some non-empty
@@ -1851,30 +1853,22 @@ void __init cpuset_init_smp(void)
* tasks cpuset.
**/

-cpumask_t cpuset_cpus_allowed(struct task_struct *tsk)
+void cpuset_cpus_allowed(struct task_struct *tsk, cpumask_t *mask)
{
- cpumask_t mask;
-
mutex_lock(&callback_mutex);
- mask = cpuset_cpus_allowed_locked(tsk);
+ cpuset_cpus_allowed_locked(tsk, mask);
mutex_unlock(&callback_mutex);
-
- return mask;
}

/**
* cpuset_cpus_allowed_locked - return cpus_allowed mask from a tasks cpuset.
* Must be called with callback_mutex held.
**/
-cpumask_t cpuset_cpus_allowed_locked(struct task_struct *tsk)
+void cpuset_cpus_allowed_locked(struct task_struct *tsk, cpumask_t *mask)
{
- cpumask_t mask;
-
task_lock(tsk);
- guarantee_online_cpus(task_cs(tsk), &mask);
+ guarantee_online_cpus(task_cs(tsk), mask);
task_unlock(tsk);
-
- return mask;
}

void cpuset_init_current_mems_allowed(void)
--- linux.trees.git.orig/kernel/kmod.c
+++ linux.trees.git/kernel/kmod.c
@@ -165,7 +165,7 @@ static int ____call_usermodehelper(void
}

/* We can run anywhere, unlike our parent keventd(). */
- set_cpus_allowed(current, CPU_MASK_ALL);
+ set_cpus_allowed(current, &CPU_MASK_ALL);

/*
* Our parent is keventd, which runs with elevated scheduling priority.
--- linux.trees.git.orig/kernel/kthread.c
+++ linux.trees.git/kernel/kthread.c
@@ -107,7 +107,7 @@ static void create_kthread(struct kthrea
*/
sched_setscheduler(create->result, SCHED_NORMAL, &param);
set_user_nice(create->result, KTHREAD_NICE_LEVEL);
- set_cpus_allowed(create->result, CPU_MASK_ALL);
+ set_cpus_allowed(create->result, &CPU_MASK_ALL);
}
complete(&create->done);
}
@@ -232,7 +232,7 @@ int kthreadd(void *unused)
set_task_comm(tsk, "kthreadd");
ignore_signals(tsk);
set_user_nice(tsk, KTHREAD_NICE_LEVEL);
- set_cpus_allowed(tsk, CPU_MASK_ALL);
+ set_cpus_allowed(tsk, &CPU_MASK_ALL);

current->flags |= PF_NOFREEZE;

--- linux.trees.git.orig/kernel/rcutorture.c
+++ linux.trees.git/kernel/rcutorture.c
@@ -737,25 +737,26 @@ static void rcu_torture_shuffle_tasks(vo
if (rcu_idle_cpu != -1)
cpu_clear(rcu_idle_cpu, tmp_mask);

- set_cpus_allowed(current, tmp_mask);
+ set_cpus_allowed(current, &tmp_mask);

if (reader_tasks) {
for (i = 0; i < nrealreaders; i++)
if (reader_tasks[i])
- set_cpus_allowed(reader_tasks[i], tmp_mask);
+ set_cpus_allowed(reader_tasks[i], &tmp_mask);
}

if (fakewriter_tasks) {
for (i = 0; i < nfakewriters; i++)
if (fakewriter_tasks[i])
- set_cpus_allowed(fakewriter_tasks[i], tmp_mask);
+ set_cpus_allowed(fakewriter_tasks[i],
+ &tmp_mask);
}

if (writer_task)
- set_cpus_allowed(writer_task, tmp_mask);
+ set_cpus_allowed(writer_task, &tmp_mask);

if (stats_task)
- set_cpus_allowed(stats_task, tmp_mask);
+ set_cpus_allowed(stats_task, &tmp_mask);

if (rcu_idle_cpu == -1)
rcu_idle_cpu = num_online_cpus() - 1;
--- linux.trees.git.orig/kernel/sched.c
+++ linux.trees.git/kernel/sched.c
@@ -4739,13 +4739,13 @@ long sched_setaffinity(pid_t pid, cpumas
if (retval)
goto out_unlock;

- cpus_allowed = cpuset_cpus_allowed(p);
+ cpuset_cpus_allowed(p, &cpus_allowed);
cpus_and(new_mask, new_mask, cpus_allowed);
again:
- retval = set_cpus_allowed(p, new_mask);
+ retval = set_cpus_allowed(p, &new_mask);

if (!retval) {
- cpus_allowed = cpuset_cpus_allowed(p);
+ cpuset_cpus_allowed(p, &cpus_allowed);
if (!cpus_subset(new_mask, cpus_allowed)) {
/*
* We must have raced with a concurrent cpuset
@@ -5280,7 +5280,7 @@ static inline void sched_init_granularit
* task must not exit() & deallocate itself prematurely. The
* call is not atomic; no spinlocks may be held.
*/
-int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
+int set_cpus_allowed(struct task_struct *p, const cpumask_t *new_mask)
{
struct migration_req req;
unsigned long flags;
@@ -5288,23 +5288,23 @@ int set_cpus_allowed(struct task_struct
int ret = 0;

rq = task_rq_lock(p, &flags);
- if (!cpus_intersects(new_mask, cpu_online_map)) {
+ if (!cpus_intersects(*new_mask, cpu_online_map)) {
ret = -EINVAL;
goto out;
}

if (p->sched_class->set_cpus_allowed)
- p->sched_class->set_cpus_allowed(p, &new_mask);
+ p->sched_class->set_cpus_allowed(p, new_mask);
else {
- p->cpus_allowed = new_mask;
- p->rt.nr_cpus_allowed = cpus_weight(new_mask);
+ p->cpus_allowed = *new_mask;
+ p->rt.nr_cpus_allowed = cpus_weight(*new_mask);
}

/* Can the task run on the task's current CPU? If so, we're done */
- if (cpu_isset(task_cpu(p), new_mask))
+ if (cpu_isset(task_cpu(p), *new_mask))
goto out;

- if (migrate_task(p, any_online_cpu(new_mask), &req)) {
+ if (migrate_task(p, any_online_cpu(*new_mask), &req)) {
/* Need help from migration thread: drop lock and wait. */
task_rq_unlock(rq, &flags);
wake_up_process(rq->migration_thread);
@@ -5460,7 +5460,8 @@ static void move_task_off_dead_cpu(int d

/* No more Mr. Nice Guy. */
if (dest_cpu >= nr_cpu_ids) {
- cpumask_t cpus_allowed = cpuset_cpus_allowed_locked(p);
+ cpumask_t cpus_allowed;
+ cpuset_cpus_allowed_locked(p, &cpus_allowed);
/*
* Try to stay on the same cpuset, where the
* current cpuset may be a subset of all cpus.
@@ -7049,7 +7050,7 @@ void __init sched_init_smp(void)
hotcpu_notifier(update_sched_domains, 0);

/* Move init over to a non-isolated CPU */
- if (set_cpus_allowed(current, non_isolated_cpus) < 0)
+ if (set_cpus_allowed(current, &non_isolated_cpus) < 0)
BUG();
sched_init_granularity();
}
--- linux.trees.git.orig/kernel/sched_rt.c
+++ linux.trees.git/kernel/sched_rt.c
@@ -1001,7 +1001,8 @@ move_one_task_rt(struct rq *this_rq, int
return 0;
}

-static void set_cpus_allowed_rt(struct task_struct *p, cpumask_t *new_mask)
+static void set_cpus_allowed_rt(struct task_struct *p,
+ const cpumask_t *new_mask)
{
int weight = cpus_weight(*new_mask);

--- linux.trees.git.orig/kernel/stop_machine.c
+++ linux.trees.git/kernel/stop_machine.c
@@ -35,7 +35,7 @@ static int stopmachine(void *cpu)
int irqs_disabled = 0;
int prepared = 0;

- set_cpus_allowed(current, cpumask_of_cpu((int)(long)cpu));
+ set_cpus_allowed(current, &cpumask_of_cpu((int)(long)cpu));

/* Ack: we are alive */
smp_mb(); /* Theoretically the ack = 0 might not be on this CPU yet. */
--- linux.trees.git.orig/mm/pdflush.c
+++ linux.trees.git/mm/pdflush.c
@@ -187,8 +187,8 @@ static int pdflush(void *dummy)
* This is needed as pdflush's are dynamically created and destroyed.
* The boottime pdflush's are easily placed w/o these 2 lines.
*/
- cpus_allowed = cpuset_cpus_allowed(current);
- set_cpus_allowed(current, cpus_allowed);
+ cpuset_cpus_allowed(current, &cpus_allowed);
+ set_cpus_allowed(current, &cpus_allowed);

return __pdflush(&my_work);
}
--- linux.trees.git.orig/mm/vmscan.c
+++ linux.trees.git/mm/vmscan.c
@@ -1668,7 +1668,7 @@ static int kswapd(void *p)

cpumask = node_to_cpumask(pgdat->node_id);
if (!cpus_empty(cpumask))
- set_cpus_allowed(tsk, cpumask);
+ set_cpus_allowed(tsk, &cpumask);
current->reclaim_state = &reclaim_state;

/*
@@ -1905,9 +1905,9 @@ static int __devinit cpu_callback(struct
for_each_node_state(nid, N_HIGH_MEMORY) {
pgdat = NODE_DATA(nid);
mask = node_to_cpumask(pgdat->node_id);
- if (any_online_cpu(mask) != NR_CPUS)
+ if (any_online_cpu(mask) < nr_cpu_ids)
/* One of our CPUs online: restore mask */
- set_cpus_allowed(pgdat->kswapd, mask);
+ set_cpus_allowed(pgdat->kswapd, &mask);
}
}
return NOTIFY_OK;
--- linux.trees.git.orig/net/sunrpc/svc.c
+++ linux.trees.git/net/sunrpc/svc.c
@@ -301,7 +301,6 @@ static inline int
svc_pool_map_set_cpumask(unsigned int pidx, cpumask_t *oldmask)
{
struct svc_pool_map *m = &svc_pool_map;
- unsigned int node; /* or cpu */

/*
* The caller checks for sv_nrpools > 1, which
@@ -314,16 +313,23 @@ svc_pool_map_set_cpumask(unsigned int pi
default:
return 0;
case SVC_POOL_PERCPU:
- node = m->pool_to[pidx];
+ {
+ unsigned int cpu = m->pool_to[pidx];
+
*oldmask = current->cpus_allowed;
- set_cpus_allowed(current, cpumask_of_cpu(node));
+ set_cpus_allowed(current, &cpumask_of_cpu(cpu));
return 1;
+ }
case SVC_POOL_PERNODE:
- node = m->pool_to[pidx];
+ {
+ unsigned int node = m->pool_to[pidx];
+ cpumask_t nodecpumask = node_to_cpumask(node);
+
*oldmask = current->cpus_allowed;
- set_cpus_allowed(current, node_to_cpumask(node));
+ set_cpus_allowed(current, &nodecpumask);
return 1;
}
+ }
}

/*
@@ -598,7 +604,7 @@ __svc_create_thread(svc_thread_fn func,
error = kernel_thread((int (*)(void *)) func, rqstp, 0);

if (have_oldmask)
- set_cpus_allowed(current, oldmask);
+ set_cpus_allowed(current, &oldmask);

if (error < 0)
goto out_thread;
--


\
 
 \ /
  Last update: 2008-03-26 02:41    [from the cache]
©2003-2011 Jasper Spaans