linux-imx

/*

 * 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/nmi.h>

#include <linux/sched/wake_q.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;

​

    raw_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;

​

/* static data for stop_cpus */

static DEFINE_MUTEX(stop_cpus_mutex);

static bool stop_cpus_in_progress;

​

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);

}

​

/* 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);

}

​

static void __cpu_stop_queue_work(struct cpu_stopper *stopper,

                    struct cpu_stop_work *work,

                    struct wake_q_head *wakeq)

{

    list_add_tail(&work->list, &stopper->works);

    wake_q_add(wakeq, stopper->thread);

}

​

/* 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);

    DEFINE_WAKE_Q(wakeq);

    unsigned long flags;

    bool enabled;

​

    preempt_disable();

    raw_spin_lock_irqsave(&stopper->lock, flags);

    enabled = stopper->enabled;

    if (enabled)

        __cpu_stop_queue_work(stopper, work, &wakeq);

    else if (work->done)

        cpu_stop_signal_done(work->done);

    raw_spin_unlock_irqrestore(&stopper->lock, flags);

​