extern int smp_num_siblings;
 extern unsigned int num_processors;
 
-DECLARE_PER_CPU(cpumask_t, cpu_sibling_map);
-DECLARE_PER_CPU(cpumask_t, cpu_core_map);
+DECLARE_PER_CPU(cpumask_var_t, cpu_sibling_map);
+DECLARE_PER_CPU(cpumask_var_t, cpu_core_map);
 DECLARE_PER_CPU(u16, cpu_llc_id);
 DECLARE_PER_CPU(int, cpu_number);
 
 static inline struct cpumask *cpu_sibling_mask(int cpu)
 {
-       return &per_cpu(cpu_sibling_map, cpu);
+       return per_cpu(cpu_sibling_map, cpu);
 }
 
 static inline struct cpumask *cpu_core_mask(int cpu)
 {
-       return &per_cpu(cpu_core_map, cpu);
+       return per_cpu(cpu_core_map, cpu);
 }
 
 DECLARE_EARLY_PER_CPU(u16, x86_cpu_to_apicid);
 
 #ifdef ENABLE_TOPO_DEFINES
 #define topology_physical_package_id(cpu)      (cpu_data(cpu).phys_proc_id)
 #define topology_core_id(cpu)                  (cpu_data(cpu).cpu_core_id)
-#define topology_core_cpumask(cpu)             (&per_cpu(cpu_core_map, cpu))
-#define topology_thread_cpumask(cpu)           (&per_cpu(cpu_sibling_map, cpu))
+#define topology_core_cpumask(cpu)             (per_cpu(cpu_core_map, cpu))
+#define topology_thread_cpumask(cpu)           (per_cpu(cpu_sibling_map, cpu))
 
 /* indicates that pointers to the topology cpumask_t maps are valid */
 #define arch_provides_topology_pointers                yes
 void set_pci_bus_resources_arch_default(struct pci_bus *b);
 
 #ifdef CONFIG_SMP
-#define mc_capable()   (cpus_weight(per_cpu(cpu_core_map, 0)) != nr_cpu_ids)
+#define mc_capable()   (cpumask_weight(cpu_core_mask(0)) != nr_cpu_ids)
 #define smt_capable()                  (smp_num_siblings > 1)
 #endif
 
 
        unsigned int i;
 
 #ifdef CONFIG_SMP
-       cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
+       cpumask_copy(policy->cpus, cpu_sibling_mask(policy->cpu));
 #endif
 
        /* Errata workaround */
 
 static int cpu_family = CPU_OPTERON;
 
 #ifndef CONFIG_SMP
-DEFINE_PER_CPU(cpumask_t, cpu_core_map);
+static inline const struct cpumask *cpu_core_mask(int cpu)
+{
+       return cpumask_of(0);
+}
 #endif
 
 /* Return a frequency in MHz, given an input fid */
 
        dprintk("cfid 0x%x, cvid 0x%x\n", data->currfid, data->currvid);
        data->powernow_table = powernow_table;
-       if (first_cpu(per_cpu(cpu_core_map, data->cpu)) == data->cpu)
+       if (cpumask_first(cpu_core_mask(data->cpu)) == data->cpu)
                print_basics(data);
 
        for (j = 0; j < data->numps; j++)
 
        /* fill in data */
        data->numps = data->acpi_data.state_count;
-       if (first_cpu(per_cpu(cpu_core_map, data->cpu)) == data->cpu)
+       if (cpumask_first(cpu_core_mask(data->cpu)) == data->cpu)
                print_basics(data);
        powernow_k8_acpi_pst_values(data, 0);
 
        if (cpu_family == CPU_HW_PSTATE)
                cpumask_copy(pol->cpus, cpumask_of(pol->cpu));
        else
-               cpumask_copy(pol->cpus, &per_cpu(cpu_core_map, pol->cpu));
+               cpumask_copy(pol->cpus, cpu_core_mask(pol->cpu));
        data->available_cores = pol->cpus;
 
        if (cpu_family == CPU_HW_PSTATE)
        unsigned int khz = 0;
        unsigned int first;
 
-       first = first_cpu(per_cpu(cpu_core_map, cpu));
+       first = cpumask_first(cpu_core_mask(cpu));
        data = per_cpu(powernow_data, first);
 
        if (!data)
 
 
        /* only run on CPU to be set, or on its sibling */
 #ifdef CONFIG_SMP
-       cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
+       cpumask_copy(policy->cpus, cpu_sibling_mask(policy->cpu));
 #endif
 
        cpus_allowed = current->cpus_allowed;
 
 
 #ifdef CONFIG_SMP
        if (cpu_data(cpu).cpu_core_id && shared_bank[bank]) {   /* symlink */
-               i = cpumask_first(&per_cpu(cpu_core_map, cpu));
+               i = cpumask_first(cpu_core_mask(cpu));
 
                /* first core not up yet */
                if (cpu_data(i).cpu_core_id)
                if (err)
                        goto out;
 
-               cpumask_copy(b->cpus, &per_cpu(cpu_core_map, cpu));
+               cpumask_copy(b->cpus, cpu_core_mask(cpu));
                per_cpu(threshold_banks, cpu)[bank] = b;
                goto out;
        }
 #ifndef CONFIG_SMP
        cpumask_setall(b->cpus);
 #else
-       cpumask_copy(b->cpus, &per_cpu(cpu_core_map, cpu));
+       cpumask_copy(b->cpus, cpu_core_mask(cpu));
 #endif
 
        per_cpu(threshold_banks, cpu)[bank] = b;
 
        if (c->x86_max_cores * smp_num_siblings > 1) {
                seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
                seq_printf(m, "siblings\t: %d\n",
-                          cpus_weight(per_cpu(cpu_core_map, cpu)));
+                          cpumask_weight(cpu_sibling_mask(cpu)));
                seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
                seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
                seq_printf(m, "apicid\t\t: %d\n", c->apicid);
 
 DEFINE_PER_CPU(u16, cpu_llc_id) = BAD_APICID;
 
 /* representing HT siblings of each logical CPU */
-DEFINE_PER_CPU(cpumask_t, cpu_sibling_map);
+DEFINE_PER_CPU(cpumask_var_t, cpu_sibling_map);
 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
 
 /* representing HT and core siblings of each logical CPU */
-DEFINE_PER_CPU(cpumask_t, cpu_core_map);
+DEFINE_PER_CPU(cpumask_var_t, cpu_core_map);
 EXPORT_PER_CPU_SYMBOL(cpu_core_map);
 
 /* Per CPU bogomips and other parameters */
  */
 void __init native_smp_prepare_cpus(unsigned int max_cpus)
 {
+       unsigned int i;
+
        preempt_disable();
        smp_cpu_index_default();
        current_cpu_data = boot_cpu_data;
        boot_cpu_logical_apicid = logical_smp_processor_id();
 #endif
        current_thread_info()->cpu = 0;  /* needed? */
+       for_each_possible_cpu(i) {
+               alloc_cpumask_var(&per_cpu(cpu_sibling_map, i), GFP_KERNEL);
+               alloc_cpumask_var(&per_cpu(cpu_core_map, i), GFP_KERNEL);
+               cpumask_clear(per_cpu(cpu_core_map, i));
+               cpumask_clear(per_cpu(cpu_sibling_map, i));
+       }
        set_cpu_sibling_map(0);
 
        enable_IR_x2apic();
 
 {
 #ifdef CONFIG_SMP
        int cpu = smp_processor_id();
-       return (cpu != first_cpu(per_cpu(cpu_sibling_map, cpu)));
+       return cpu != cpumask_first(__get_cpu_var(cpu_sibling_map));
 #endif
        return 0;
 }