/* * Set the given thread's cpus_allowed mask so that it * will only run on cpus in the given pool. */ static inline void svc_pool_map_set_cpumask(struct task_struct *task, unsigned int pidx) { struct svc_pool_map *m = &svc_pool_map; unsigned int node = m->pool_to[pidx]; /* * The caller checks for sv_nrpools > 1, which * implies that we've been initialized. */ WARN_ON_ONCE(m->count == 0); if (m->count == 0) return; switch (m->mode) { case SVC_POOL_PERCPU: { set_cpus_allowed_ptr(task, cpumask_of(node)); break; } case SVC_POOL_PERNODE: { set_cpus_allowed_ptr(task, cpumask_of_node(node)); break; } } }
/* * After a CPU went down cycle through all the others and rediscover * Must run in process context. */ void cmci_rediscover(int dying) { int banks; int cpu; cpumask_var_t old; if (!cmci_supported(&banks)) return; if (!alloc_cpumask_var(&old, GFP_KERNEL)) return; cpumask_copy(old, ¤t->cpus_allowed); for_each_online_cpu(cpu) { if (cpu == dying) continue; if (set_cpus_allowed_ptr(current, cpumask_of(cpu))) continue; /* Recheck banks in case CPUs don't all have the same */ if (cmci_supported(&banks)) cmci_discover(banks, 0); } set_cpus_allowed_ptr(current, old); free_cpumask_var(old); }
void __init smp_cpus_done(unsigned int max_cpus) { cpumask_var_t old_mask; /* We want the setup_cpu() here to be called from CPU 0, but our * init thread may have been "borrowed" by another CPU in the meantime * se we pin us down to CPU 0 for a short while */ alloc_cpumask_var(&old_mask, GFP_NOWAIT); cpumask_copy(old_mask, tsk_cpus_allowed(current)); set_cpus_allowed_ptr(current, cpumask_of(boot_cpuid)); if (smp_ops && smp_ops->setup_cpu) smp_ops->setup_cpu(boot_cpuid); set_cpus_allowed_ptr(current, old_mask); free_cpumask_var(old_mask); if (smp_ops && smp_ops->bringup_done) smp_ops->bringup_done(); dump_numa_cpu_topology(); set_sched_topology(powerpc_topology); }
static int __init kernel_init(void * unused) { /* * Wait until kthreadd is all set-up. */ wait_for_completion(&kthreadd_done); lock_kernel(); /* * init can allocate pages on any node */ set_mems_allowed(node_states[N_HIGH_MEMORY]); /* * init can run on any cpu. */ set_cpus_allowed_ptr(current, cpu_all_mask); /* * Tell the world that we're going to be the grim * reaper of innocent orphaned children. * * We don't want people to have to make incorrect * assumptions about where in the task array this * can be found. */ init_pid_ns.child_reaper = current; cad_pid = task_pid(current); smp_prepare_cpus(setup_max_cpus); do_pre_smp_initcalls(); start_boot_trace(); smp_init(); sched_init_smp(); do_basic_setup(); /* * check if there is an early userspace init. If yes, let it do all * the work */ if (!ramdisk_execute_command) ramdisk_execute_command = "/init"; if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { ramdisk_execute_command = NULL; prepare_namespace(); } /* * Ok, we have completed the initial bootup, and * we're essentially up and running. Get rid of the * initmem segments and start the user-mode stuff.. */ init_post(); return 0; }
int meson_trustzone_efuse(struct efuse_hal_api_arg* arg) { int ret; if (!arg) { return -1; } set_cpus_allowed_ptr(current, cpumask_of(0)); __cpuc_flush_dcache_area(__va(arg->buffer_phy), arg->size); outer_clean_range((arg->buffer_phy), (arg->buffer_phy + arg->size)); __cpuc_flush_dcache_area(__va(arg->retcnt_phy), sizeof(unsigned int)); outer_clean_range(arg->retcnt_phy, (arg->retcnt_phy + sizeof(unsigned int))); __cpuc_flush_dcache_area((void*)arg, sizeof(struct efuse_hal_api_arg)); outer_clean_range(__pa(arg), __pa(arg + 1)); ret = meson_smc_hal_api(TRUSTZONE_HAL_API_EFUSE, __pa(arg)); if (arg->cmd == EFUSE_HAL_API_READ) { outer_inv_range((arg->buffer_phy), (arg->buffer_phy + arg->size)); dmac_unmap_area(__va(arg->buffer_phy), arg->size, DMA_FROM_DEVICE); } outer_inv_range((arg->retcnt_phy), (arg->retcnt_phy + sizeof(unsigned int))); dmac_unmap_area(__va(arg->buffer_phy), arg->size, DMA_FROM_DEVICE); return ret; }
/* * This thread is responsible for nearly all of the partition * activation/deactivation. */ static int xpc_hb_checker(void *ignore) { int force_IRQ = 0; /* this thread was marked active by xpc_hb_init() */ set_cpus_allowed_ptr(current, cpumask_of(XPC_HB_CHECK_CPU)); /* set our heartbeating to other partitions into motion */ xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ); xpc_start_hb_beater(); while (!xpc_exiting) { dev_dbg(xpc_part, "woke up with %d ticks rem; %d IRQs have " "been received\n", (int)(xpc_hb_check_timeout - jiffies), xpc_activate_IRQ_rcvd); /* checking of remote heartbeats is skewed by IRQ handling */ if (time_is_before_eq_jiffies(xpc_hb_check_timeout)) { xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ); dev_dbg(xpc_part, "checking remote heartbeats\n"); xpc_check_remote_hb(); /* * On sn2 we need to periodically recheck to ensure no * IRQ/amo pairs have been missed. */ if (is_shub()) force_IRQ = 1; } /* check for outstanding IRQs */ if (xpc_activate_IRQ_rcvd > 0 || force_IRQ != 0) { force_IRQ = 0; dev_dbg(xpc_part, "processing activate IRQs " "received\n"); xpc_process_activate_IRQ_rcvd(); } /* wait for IRQ or timeout */ (void)wait_event_interruptible(xpc_activate_IRQ_wq, (time_is_before_eq_jiffies( xpc_hb_check_timeout) || xpc_activate_IRQ_rcvd > 0 || xpc_exiting)); } xpc_stop_hb_beater(); dev_dbg(xpc_part, "heartbeat checker is exiting\n"); /* mark this thread as having exited */ complete(&xpc_hb_checker_exited); return 0; }
static int xpc_hb_checker(void *ignore) { int force_IRQ = 0; /* */ set_cpus_allowed_ptr(current, cpumask_of(XPC_HB_CHECK_CPU)); /* */ xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ); xpc_start_hb_beater(); while (!xpc_exiting) { dev_dbg(xpc_part, "woke up with %d ticks rem; %d IRQs have " "been received\n", (int)(xpc_hb_check_timeout - jiffies), xpc_activate_IRQ_rcvd); /* */ if (time_is_before_eq_jiffies(xpc_hb_check_timeout)) { xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ); dev_dbg(xpc_part, "checking remote heartbeats\n"); xpc_check_remote_hb(); /* */ if (is_shub()) force_IRQ = 1; } /* */ if (xpc_activate_IRQ_rcvd > 0 || force_IRQ != 0) { force_IRQ = 0; dev_dbg(xpc_part, "processing activate IRQs " "received\n"); xpc_arch_ops.process_activate_IRQ_rcvd(); } /* */ (void)wait_event_interruptible(xpc_activate_IRQ_wq, (time_is_before_eq_jiffies( xpc_hb_check_timeout) || xpc_activate_IRQ_rcvd > 0 || xpc_exiting)); } xpc_stop_hb_beater(); dev_dbg(xpc_part, "heartbeat checker is exiting\n"); /* */ complete(&xpc_hb_checker_exited); return 0; }
int kthreadd(void *unused) { struct task_struct *tsk = current; /* Setup a clean context for our children to inherit. */ set_task_comm(tsk, "kthreadd"); ignore_signals(tsk); set_cpus_allowed_ptr(tsk, cpu_all_mask); current->flags |= PF_NOFREEZE; for (;;) { set_current_state(TASK_INTERRUPTIBLE); if (list_empty(&kthread_create_list)) schedule(); __set_current_state(TASK_RUNNING); spin_lock(&kthread_create_lock); while (!list_empty(&kthread_create_list)) { struct kthread_create_info *create; create = list_entry(kthread_create_list.next, struct kthread_create_info, list); list_del_init(&create->list); spin_unlock(&kthread_create_lock); create_kthread(create); spin_lock(&kthread_create_lock); } spin_unlock(&kthread_create_lock); } return 0; }