linux-imx

/*

 *  linux/kernel/softirq.c

 *

 *  Copyright (C) 1992 Linus Torvalds

 *

 *  Distribute under GPLv2.

 *

 *  Rewritten. Old one was good in 2.2, but in 2.3 it was immoral. --ANK (990903)

 */

​

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

​

#include <linux/export.h>

#include <linux/kernel_stat.h>

#include <linux/interrupt.h>

#include <linux/init.h>

#include <linux/mm.h>

#include <linux/notifier.h>

#include <linux/percpu.h>

#include <linux/cpu.h>

#include <linux/freezer.h>

#include <linux/kthread.h>

#include <linux/rcupdate.h>

#include <linux/ftrace.h>

#include <linux/smp.h>

#include <linux/smpboot.h>

#include <linux/tick.h>

#include <linux/irq.h>

​

#define CREATE_TRACE_POINTS

#include <trace/events/irq.h>

​

/*

   - No shared variables, all the data are CPU local.

   - If a softirq needs serialization, let it serialize itself

     by its own spinlocks.

   - Even if softirq is serialized, only local cpu is marked for

     execution. Hence, we get something sort of weak cpu binding.

     Though it is still not clear, will it result in better locality

     or will not.

​

   Examples:

   - NET RX softirq. It is multithreaded and does not require

     any global serialization.

   - NET TX softirq. It kicks software netdevice queues, hence

     it is logically serialized per device, but this serialization

     is invisible to common code.

   - Tasklets: serialized wrt itself.

 */

​

#ifndef __ARCH_IRQ_STAT

DEFINE_PER_CPU_ALIGNED(irq_cpustat_t, irq_stat);

EXPORT_PER_CPU_SYMBOL(irq_stat);

#endif

​

static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp;

​

DEFINE_PER_CPU(struct task_struct *, ksoftirqd);

​

const char * const softirq_to_name[NR_SOFTIRQS] = {

    "HI", "TIMER", "NET_TX", "NET_RX", "BLOCK", "IRQ_POLL",

    "TASKLET", "SCHED", "HRTIMER", "RCU"

};

​

/*

 * we cannot loop indefinitely here to avoid userspace starvation,

 * but we also don't want to introduce a worst case 1/HZ latency

 * to the pending events, so lets the scheduler to balance

 * the softirq load for us.

 */

static void wakeup_softirqd(void)

{

    /* Interrupts are disabled: no need to stop preemption */

    struct task_struct *tsk = __this_cpu_read(ksoftirqd);

​

    if (tsk && tsk->state != TASK_RUNNING)

        wake_up_process(tsk);

}

​

/*

 * If ksoftirqd is scheduled, we do not want to process pending softirqs

 * right now. Let ksoftirqd handle this at its own rate, to get fairness,

 * unless we're doing some of the synchronous softirqs.

 */

#define SOFTIRQ_NOW_MASK ((1 << HI_SOFTIRQ) | (1 << TASKLET_SOFTIRQ))

static bool ksoftirqd_running(unsigned long pending)

{

    struct task_struct *tsk = __this_cpu_read(ksoftirqd);

​

    if (pending & SOFTIRQ_NOW_MASK)

        return false;

    return tsk && (tsk->state == TASK_RUNNING) &&