cregit-Linux how code gets into the kernel

Release 4.7 kernel/stop_machine.c

Directory: kernel
/*
 * kernel/stop_machine.c
 *
 * Copyright (C) 2008, 2005     IBM Corporation.
 * Copyright (C) 2008, 2005     Rusty Russell rusty@rustcorp.com.au
 * Copyright (C) 2010           SUSE Linux Products GmbH
 * Copyright (C) 2010           Tejun Heo <tj@kernel.org>
 *
 * This file is released under the GPLv2 and any later version.
 */
#include <linux/completion.h>
#include <linux/cpu.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/export.h>
#include <linux/percpu.h>
#include <linux/sched.h>
#include <linux/stop_machine.h>
#include <linux/interrupt.h>
#include <linux/kallsyms.h>
#include <linux/smpboot.h>
#include <linux/atomic.h>
#include <linux/lglock.h>

/*
 * Structure to determine completion condition and record errors.  May
 * be shared by works on different cpus.
 */

struct cpu_stop_done {
	
atomic_t		nr_todo;	/* nr left to execute */
	
int			ret;		/* collected return value */
	
struct completion	completion;	/* fired if nr_todo reaches 0 */
};

/* the actual stopper, one per every possible cpu, enabled on online cpus */

struct cpu_stopper {
	
struct task_struct	*thread;

	
spinlock_t		lock;
	
bool			enabled;	/* is this stopper enabled? */
	
struct list_head	works;		/* list of pending works */

	
struct cpu_stop_work	stop_work;	/* for stop_cpus */
};

static DEFINE_PER_CPU(struct cpu_stopper, cpu_stopper);

static bool stop_machine_initialized = false;

/*
 * Avoids a race between stop_two_cpus and global stop_cpus, where
 * the stoppers could get queued up in reverse order, leading to
 * system deadlock. Using an lglock means stop_two_cpus remains
 * relatively cheap.
 */

DEFINE_STATIC_LGLOCK(stop_cpus_lock);


static void cpu_stop_init_done(struct cpu_stop_done *done, unsigned int nr_todo) { memset(done, 0, sizeof(*done)); atomic_set(&done->nr_todo, nr_todo); init_completion(&done->completion); }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo46100.00%1100.00%
Total46100.00%1100.00%

/* signal completion unless @done is NULL */
static void cpu_stop_signal_done(struct cpu_stop_done *done) { if (atomic_dec_and_test(&done->nr_todo)) complete(&done->completion); }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo29100.00%1100.00%
Total29100.00%1100.00%


static void __cpu_stop_queue_work(struct cpu_stopper *stopper, struct cpu_stop_work *work) { list_add_tail(&work->list, &stopper->works); wake_up_process(stopper->thread); }

Contributors

PersonTokensPropCommitsCommitProp
oleg nesterovoleg nesterov36100.00%1100.00%
Total36100.00%1100.00%

/* queue @work to @stopper. if offline, @work is completed immediately */
static bool cpu_stop_queue_work(unsigned int cpu, struct cpu_stop_work *work) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); unsigned long flags; bool enabled; spin_lock_irqsave(&stopper->lock, flags); enabled = stopper->enabled; if (enabled) __cpu_stop_queue_work(stopper, work); else if (work->done) cpu_stop_signal_done(work->done); spin_unlock_irqrestore(&stopper->lock, flags); return enabled; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo5056.18%120.00%
oleg nesterovoleg nesterov2325.84%360.00%
thomas gleixnerthomas gleixner1617.98%120.00%
Total89100.00%5100.00%

/** * stop_one_cpu - stop a cpu * @cpu: cpu to stop * @fn: function to execute * @arg: argument to @fn * * Execute @fn(@arg) on @cpu. @fn is run in a process context with * the highest priority preempting any task on the cpu and * monopolizing it. This function returns after the execution is * complete. * * This function doesn't guarantee @cpu stays online till @fn * completes. If @cpu goes down in the middle, execution may happen * partially or fully on different cpus. @fn should either be ready * for that or the caller should ensure that @cpu stays online until * this function completes. * * CONTEXT: * Might sleep. * * RETURNS: * -ENOENT if @fn(@arg) was not executed because @cpu was offline; * otherwise, the return value of @fn. */
int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg) { struct cpu_stop_done done; struct cpu_stop_work work = { .fn = fn, .arg = arg, .done = &done }; cpu_stop_init_done(&done, 1); if (!cpu_stop_queue_work(cpu, &work)) return -ENOENT; wait_for_completion(&done.completion); return done.ret; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo6988.46%150.00%
oleg nesterovoleg nesterov911.54%150.00%
Total78100.00%2100.00%

/* This controls the threads on each CPU. */ enum multi_stop_state { /* Dummy starting state for thread. */ MULTI_STOP_NONE, /* Awaiting everyone to be scheduled. */ MULTI_STOP_PREPARE, /* Disable interrupts. */ MULTI_STOP_DISABLE_IRQ, /* Run the function */ MULTI_STOP_RUN, /* Exit */ MULTI_STOP_EXIT, }; struct multi_stop_data { cpu_stop_fn_t fn; void *data; /* Like num_online_cpus(), but hotplug cpu uses us, so we need this. */ unsigned int num_threads; const struct cpumask *active_cpus; enum multi_stop_state state; atomic_t thread_ack; };
static void set_state(struct multi_stop_data *msdata, enum multi_stop_state newstate) { /* Reset ack counter. */ atomic_set(&msdata->thread_ack, msdata->num_threads); smp_wmb(); msdata->state = newstate; }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra37100.00%1100.00%
Total37100.00%1100.00%

/* Last one to ack a state moves to the next state. */
static void ack_state(struct multi_stop_data *msdata) { if (atomic_dec_and_test(&msdata->thread_ack)) set_state(msdata, msdata->state + 1); }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra32100.00%1100.00%
Total32100.00%1100.00%

/* This is the cpu_stop function which stops the CPU. */
static int multi_cpu_stop(void *data) { struct multi_stop_data *msdata = data; enum multi_stop_state curstate = MULTI_STOP_NONE; int cpu = smp_processor_id(), err = 0; unsigned long flags; bool is_active; /* * When called from stop_machine_from_inactive_cpu(), irq might * already be disabled. Save the state and restore it on exit. */ local_save_flags(flags); if (!msdata->active_cpus) is_active = cpu == cpumask_first(cpu_online_mask); else is_active = cpumask_test_cpu(cpu, msdata->active_cpus); /* Simple state machine */ do { /* Chill out and ensure we re-read multi_stop_state. */ cpu_relax(); if (msdata->state != curstate) { curstate = msdata->state; switch (curstate) { case MULTI_STOP_DISABLE_IRQ: local_irq_disable(); hard_irq_disable(); break; case MULTI_STOP_RUN: if (is_active) err = msdata->fn(msdata->data); break; default: break; } ack_state(msdata); } } while (curstate != MULTI_STOP_EXIT); local_irq_restore(flags); return err; }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra155100.00%1100.00%
Total155100.00%1100.00%


static int cpu_stop_queue_two_works(int cpu1, struct cpu_stop_work *work1, int cpu2, struct cpu_stop_work *work2) { struct cpu_stopper *stopper1 = per_cpu_ptr(&cpu_stopper, cpu1); struct cpu_stopper *stopper2 = per_cpu_ptr(&cpu_stopper, cpu2); int err; lg_double_lock(&stop_cpus_lock, cpu1, cpu2); spin_lock_irq(&stopper1->lock); spin_lock_nested(&stopper2->lock, SINGLE_DEPTH_NESTING); err = -ENOENT; if (!stopper1->enabled || !stopper2->enabled) goto unlock; err = 0; __cpu_stop_queue_work(stopper1, work1); __cpu_stop_queue_work(stopper2, work2); unlock: spin_unlock(&stopper2->lock); spin_unlock_irq(&stopper1->lock); lg_double_unlock(&stop_cpus_lock, cpu1, cpu2); return err; }

Contributors

PersonTokensPropCommitsCommitProp
oleg nesterovoleg nesterov148100.00%2100.00%
Total148100.00%2100.00%

/** * stop_two_cpus - stops two cpus * @cpu1: the cpu to stop * @cpu2: the other cpu to stop * @fn: function to execute * @arg: argument to @fn * * Stops both the current and specified CPU and runs @fn on one of them. * * returns when both are completed. */
int stop_two_cpus(unsigned int cpu1, unsigned int cpu2, cpu_stop_fn_t fn, void *arg) { struct cpu_stop_done done; struct cpu_stop_work work1, work2; struct multi_stop_data msdata; msdata = (struct multi_stop_data){ .fn = fn, .data = arg, .num_threads = 2, .active_cpus = cpumask_of(cpu1), }; work1 = work2 = (struct cpu_stop_work){ .fn = multi_cpu_stop, .arg = &msdata, .done = &done }; cpu_stop_init_done(&done, 2); set_state(&msdata, MULTI_STOP_PREPARE); if (cpu1 > cpu2) swap(cpu1, cpu2); if (cpu_stop_queue_two_works(cpu1, &work1, cpu2, &work2)) return -ENOENT; wait_for_completion(&done.completion); return done.ret; }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra13588.24%350.00%
oleg nesterovoleg nesterov1711.11%233.33%
rik van rielrik van riel10.65%116.67%
Total153100.00%6100.00%

/** * stop_one_cpu_nowait - stop a cpu but don't wait for completion * @cpu: cpu to stop * @fn: function to execute * @arg: argument to @fn * @work_buf: pointer to cpu_stop_work structure * * Similar to stop_one_cpu() but doesn't wait for completion. The * caller is responsible for ensuring @work_buf is currently unused * and will remain untouched until stopper starts executing @fn. * * CONTEXT: * Don't care. * * RETURNS: * true if cpu_stop_work was queued successfully and @fn will be called, * false otherwise. */
bool stop_one_cpu_nowait(unsigned int cpu, cpu_stop_fn_t fn, void *arg, struct cpu_stop_work *work_buf) { *work_buf = (struct cpu_stop_work){ .fn = fn, .arg = arg, }; return cpu_stop_queue_work(cpu, work_buf); }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo4593.75%150.00%
oleg nesterovoleg nesterov36.25%150.00%
Total48100.00%2100.00%

/* static data for stop_cpus */ static DEFINE_MUTEX(stop_cpus_mutex);
static bool queue_stop_cpus_work(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg, struct cpu_stop_done *done) { struct cpu_stop_work *work; unsigned int cpu; bool queued = false; /* * Disable preemption while queueing to avoid getting * preempted by a stopper which might wait for other stoppers * to enter @fn which can lead to deadlock. */ lg_global_lock(&stop_cpus_lock); for_each_cpu(cpu, cpumask) { work = &per_cpu(cpu_stopper.stop_work, cpu); work->fn = fn; work->arg = arg; work->done = done; if (cpu_stop_queue_work(cpu, work)) queued = true; } lg_global_unlock(&stop_cpus_lock); return queued; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo7369.52%233.33%
oleg nesterovoleg nesterov2725.71%350.00%
rik van rielrik van riel54.76%116.67%
Total105100.00%6100.00%


static int __stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) { struct cpu_stop_done done; cpu_stop_init_done(&done, cpumask_weight(cpumask)); if (!queue_stop_cpus_work(cpumask, fn, arg, &done)) return -ENOENT; wait_for_completion(&done.completion); return done.ret; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo5786.36%266.67%
oleg nesterovoleg nesterov913.64%133.33%
Total66100.00%3100.00%

/** * stop_cpus - stop multiple cpus * @cpumask: cpus to stop * @fn: function to execute * @arg: argument to @fn * * Execute @fn(@arg) on online cpus in @cpumask. On each target cpu, * @fn is run in a process context with the highest priority * preempting any task on the cpu and monopolizing it. This function * returns after all executions are complete. * * This function doesn't guarantee the cpus in @cpumask stay online * till @fn completes. If some cpus go down in the middle, execution * on the cpu may happen partially or fully on different cpus. @fn * should either be ready for that or the caller should ensure that * the cpus stay online until this function completes. * * All stop_cpus() calls are serialized making it safe for @fn to wait * for all cpus to start executing it. * * CONTEXT: * Might sleep. * * RETURNS: * -ENOENT if @fn(@arg) was not executed at all because all cpus in * @cpumask were offline; otherwise, 0 if all executions of @fn * returned 0, any non zero return value if any returned non zero. */
int stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) { int ret; /* static works are used, process one request at a time */ mutex_lock(&stop_cpus_mutex); ret = __stop_cpus(cpumask, fn, arg); mutex_unlock(&stop_cpus_mutex); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo48100.00%1100.00%
Total48100.00%1100.00%

/** * try_stop_cpus - try to stop multiple cpus * @cpumask: cpus to stop * @fn: function to execute * @arg: argument to @fn * * Identical to stop_cpus() except that it fails with -EAGAIN if * someone else is already using the facility. * * CONTEXT: * Might sleep. * * RETURNS: * -EAGAIN if someone else is already stopping cpus, -ENOENT if * @fn(@arg) was not executed at all because all cpus in @cpumask were * offline; otherwise, 0 if all executions of @fn returned 0, any non * zero return value if any returned non zero. */
int try_stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) { int ret; /* static works are used, process one request at a time */ if (!mutex_trylock(&stop_cpus_mutex)) return -EAGAIN; ret = __stop_cpus(cpumask, fn, arg); mutex_unlock(&stop_cpus_mutex); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo55100.00%1100.00%
Total55100.00%1100.00%


static int cpu_stop_should_run(unsigned int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); unsigned long flags; int run; spin_lock_irqsave(&stopper->lock, flags); run = !list_empty(&stopper->works); spin_unlock_irqrestore(&stopper->lock, flags); return run; }

Contributors

PersonTokensPropCommitsCommitProp
thomas gleixnerthomas gleixner4164.06%150.00%
tejun heotejun heo2335.94%150.00%
Total64100.00%2100.00%


static void cpu_stopper_thread(unsigned int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); struct cpu_stop_work *work; repeat: work = NULL; spin_lock_irq(&stopper->lock); if (!list_empty(&stopper->works)) { work = list_first_entry(&stopper->works, struct cpu_stop_work, list); list_del_init(&work->list); } spin_unlock_irq(&stopper->lock); if (work) { cpu_stop_fn_t fn = work->fn; void *arg = work->arg; struct cpu_stop_done *done = work->done; int ret; /* cpu stop callbacks must not sleep, make in_atomic() == T */ preempt_count_inc(); ret = fn(arg); if (done) { if (ret) done->ret = ret; cpu_stop_signal_done(done); } preempt_count_dec(); WARN_ONCE(preempt_count(), "cpu_stop: %pf(%p) leaked preempt count\n", fn, arg); goto repeat; } }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo12171.60%116.67%
thomas gleixnerthomas gleixner3017.75%116.67%
oleg nesterovoleg nesterov1810.65%466.67%
Total169100.00%6100.00%


void stop_machine_park(int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); /* * Lockless. cpu_stopper_thread() will take stopper->lock and flush * the pending works before it parks, until then it is fine to queue * the new works. */ stopper->enabled = false; kthread_park(stopper->thread); }

Contributors

PersonTokensPropCommitsCommitProp
oleg nesterovoleg nesterov35100.00%1100.00%
Total35100.00%1100.00%

extern void sched_set_stop_task(int cpu, struct task_struct *stop);
static void cpu_stop_create(unsigned int cpu) { sched_set_stop_task(cpu, per_cpu(cpu_stopper.thread, cpu)); }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra1354.17%125.00%
tejun heotejun heo625.00%125.00%
oleg nesterovoleg nesterov312.50%125.00%
thomas gleixnerthomas gleixner28.33%125.00%
Total24100.00%4100.00%


static void cpu_stop_park(unsigned int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); WARN_ON(!list_empty(&stopper->works)); }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo2160.00%240.00%
oleg nesterovoleg nesterov514.29%120.00%
rusty russellrusty russell514.29%120.00%
peter zijlstrapeter zijlstra411.43%120.00%
Total35100.00%5100.00%


void stop_machine_unpark(int cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); stopper->enabled = true; kthread_unpark(stopper->thread); }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra2161.76%120.00%
oleg nesterovoleg nesterov926.47%240.00%
rusty russellrusty russell411.76%240.00%
Total34100.00%5100.00%

static struct smp_hotplug_thread cpu_stop_threads = { .store = &cpu_stopper.thread, .thread_should_run = cpu_stop_should_run, .thread_fn = cpu_stopper_thread, .thread_comm = "migration/%u", .create = cpu_stop_create, .park = cpu_stop_park, .selfparking = true, };
static int __init cpu_stop_init(void) { unsigned int cpu; for_each_possible_cpu(cpu) { struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu); spin_lock_init(&stopper->lock); INIT_LIST_HEAD(&stopper->works); } BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); stop_machine_unpark(raw_smp_processor_id()); stop_machine_initialized = true; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
peter zijlstrapeter zijlstra3550.00%110.00%
heiko carstensheiko carstens1115.71%330.00%
rusty russellrusty russell912.86%220.00%
tejun heotejun heo811.43%220.00%
oleg nesterovoleg nesterov68.57%110.00%
srivatsa vaddagirisrivatsa vaddagiri11.43%110.00%
Total70100.00%10100.00%

early_initcall(cpu_stop_init);
static int __stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus) { struct multi_stop_data msdata = { .fn = fn, .data = data, .num_threads = num_online_cpus(), .active_cpus = cpus, }; if (!stop_machine_initialized) { /* * Handle the case where stop_machine() is called * early in boot before stop_machine() has been * initialized. */ unsigned long flags; int ret; WARN_ON_ONCE(msdata.num_threads != 1); local_irq_save(flags); hard_irq_disable(); ret = (*fn)(data); local_irq_restore(flags); return ret; } /* Set the initial state and stop all online cpus. */ set_state(&msdata, MULTI_STOP_PREPARE); return stop_cpus(cpu_online_mask, multi_cpu_stop, &msdata); }

Contributors

PersonTokensPropCommitsCommitProp
jeremy fitzhardingejeremy fitzhardinge4942.24%110.00%
rusty russellrusty russell3832.76%440.00%
tejun heotejun heo1613.79%110.00%
peter zijlstrapeter zijlstra86.90%110.00%
satoru takeuchisatoru takeuchi32.59%110.00%
oleg nesterovoleg nesterov21.72%220.00%
Total116100.00%10100.00%


int stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus) { int ret; /* No CPUs can come up or down during this. */ get_online_cpus(); ret = __stop_machine(fn, data, cpus); put_online_cpus(); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell3992.86%466.67%
gautham r shenoygautham r shenoy24.76%116.67%
oleg nesterovoleg nesterov12.38%116.67%
Total42100.00%6100.00%

EXPORT_SYMBOL_GPL(stop_machine); /** * stop_machine_from_inactive_cpu - stop_machine() from inactive CPU * @fn: the function to run * @data: the data ptr for the @fn() * @cpus: the cpus to run the @fn() on (NULL = any online cpu) * * This is identical to stop_machine() but can be called from a CPU which * is not active. The local CPU is in the process of hotplug (so no other * CPU hotplug can start) and not marked active and doesn't have enough * context to sleep. * * This function provides stop_machine() functionality for such state by * using busy-wait for synchronization and executing @fn directly for local * CPU. * * CONTEXT: * Local CPU is inactive. Temporarily stops all active CPUs. * * RETURNS: * 0 if all executions of @fn returned 0, any non zero return value if any * returned non zero. */
int stop_machine_from_inactive_cpu(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus) { struct multi_stop_data msdata = { .fn = fn, .data = data, .active_cpus = cpus }; struct cpu_stop_done done; int ret; /* Local CPU must be inactive and CPU hotplug in progress. */ BUG_ON(cpu_active(raw_smp_processor_id())); msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ /* No proper task established and can't sleep - busy wait for lock. */ while (!mutex_trylock(&stop_cpus_mutex)) cpu_relax(); /* Schedule work on other CPUs and execute directly for local CPU */ set_state(&msdata, MULTI_STOP_PREPARE); cpu_stop_init_done(&done, num_active_cpus()); queue_stop_cpus_work(cpu_active_mask, multi_cpu_stop, &msdata, &done); ret = multi_cpu_stop(&msdata); /* Busy wait for completion. */ while (!completion_done(&done.completion)) cpu_relax(); mutex_unlock(&stop_cpus_mutex); return ret ?: done.ret; }

Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo13793.20%133.33%
peter zijlstrapeter zijlstra96.12%133.33%
oleg nesterovoleg nesterov10.68%133.33%
Total147100.00%3100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
tejun heotejun heo86641.16%48.70%
peter zijlstrapeter zijlstra56026.62%48.70%
oleg nesterovoleg nesterov36817.49%1736.96%
rusty russellrusty russell1115.28%48.70%
thomas gleixnerthomas gleixner924.37%24.35%
jeremy fitzhardingejeremy fitzhardinge552.61%12.17%
rik van rielrik van riel150.71%12.17%
heiko carstensheiko carstens110.52%36.52%
prarit bhargavaprarit bhargava70.33%12.17%
richard kennedyrichard kennedy40.19%12.17%
benjamin herrenschmidtbenjamin herrenschmidt30.14%12.17%
satoru takeuchisatoru takeuchi30.14%12.17%
gautham r shenoygautham r shenoy20.10%12.17%
suresh siddhasuresh siddha20.10%12.17%
linus torvaldslinus torvalds20.10%12.17%
arun sharmaarun sharma10.05%12.17%
paul gortmakerpaul gortmaker10.05%12.17%
srivatsa vaddagirisrivatsa vaddagiri10.05%12.17%
Total2104100.00%46100.00%
Directory: kernel
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}