| /* |
| * linux/kernel/softirq.c |
| * |
| * Copyright (C) 1992 Linus Torvalds |
| * |
| * Rewritten. Old one was good in 2.2, but in 2.3 it was immoral. --ANK (990903) |
| */ |
| |
| #include <linux/module.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> |
| |
| /* |
| - 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 |
| irq_cpustat_t irq_stat[NR_CPUS] ____cacheline_aligned; |
| EXPORT_SYMBOL(irq_stat); |
| #endif |
| |
| static struct softirq_action softirq_vec[32] __cacheline_aligned_in_smp; |
| |
| static DEFINE_PER_CPU(struct task_struct *, ksoftirqd); |
| |
| /* |
| * 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 inline void wakeup_softirqd(void) |
| { |
| /* Interrupts are disabled: no need to stop preemption */ |
| struct task_struct *tsk = __get_cpu_var(ksoftirqd); |
| |
| if (tsk && tsk->state != TASK_RUNNING) |
| wake_up_process(tsk); |
| } |
| |
| /* |
| * We restart softirq processing MAX_SOFTIRQ_RESTART times, |
| * and we fall back to softirqd after that. |
| * |
| * This number has been established via experimentation. |
| * The two things to balance is latency against fairness - |
| * we want to handle softirqs as soon as possible, but they |
| * should not be able to lock up the box. |
| */ |
| #define MAX_SOFTIRQ_RESTART 10 |
| |
| asmlinkage void do_softirq(void) |
| { |
| int max_restart = MAX_SOFTIRQ_RESTART; |
| __u32 pending; |
| unsigned long flags; |
| |
| if (in_interrupt()) |
| return; |
| |
| local_irq_save(flags); |
| |
| pending = local_softirq_pending(); |
| |
| if (pending) { |
| struct softirq_action *h; |
| |
| local_bh_disable(); |
| restart: |
| /* Reset the pending bitmask before enabling irqs */ |
| local_softirq_pending() = 0; |
| |
| local_irq_enable(); |
| |
| h = softirq_vec; |
| |
| do { |
| if (pending & 1) |
| h->action(h); |
| h++; |
| pending >>= 1; |
| } while (pending); |
| |
| local_irq_disable(); |
| |
| pending = local_softirq_pending(); |
| if (pending && --max_restart) |
| goto restart; |
| if (pending) |
| wakeup_softirqd(); |
| __local_bh_enable(); |
| } |
| |
| local_irq_restore(flags); |
| } |
| |
| EXPORT_SYMBOL(do_softirq); |
| |
| void local_bh_enable(void) |
| { |
| __local_bh_enable(); |
| WARN_ON(irqs_disabled()); |
| if (unlikely(!in_interrupt() && |
| local_softirq_pending())) |
| invoke_softirq(); |
| preempt_check_resched(); |
| } |
| EXPORT_SYMBOL(local_bh_enable); |
| |
| /* |
| * This function must run with irqs disabled! |
| */ |
| inline void raise_softirq_irqoff(unsigned int nr) |
| { |
| __raise_softirq_irqoff(nr); |
| |
| /* |
| * If we're in an interrupt or softirq, we're done |
| * (this also catches softirq-disabled code). We will |
| * actually run the softirq once we return from |
| * the irq or softirq. |
| * |
| * Otherwise we wake up ksoftirqd to make sure we |
| * schedule the softirq soon. |
| */ |
| if (!in_interrupt()) |
| wakeup_softirqd(); |
| } |
| |
| EXPORT_SYMBOL(raise_softirq_irqoff); |
| |
| void raise_softirq(unsigned int nr) |
| { |
| unsigned long flags; |
| |
| local_irq_save(flags); |
| raise_softirq_irqoff(nr); |
| local_irq_restore(flags); |
| } |
| |
| EXPORT_SYMBOL(raise_softirq); |
| |
| void open_softirq(int nr, void (*action)(struct softirq_action*), void *data) |
| { |
| softirq_vec[nr].data = data; |
| softirq_vec[nr].action = action; |
| } |
| |
| EXPORT_SYMBOL(open_softirq); |
| |
| /* Tasklets */ |
| struct tasklet_head |
| { |
| struct tasklet_struct *list; |
| }; |
| |
| /* Some compilers disobey section attribute on statics when not |
| initialized -- RR */ |
| static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec) = { NULL }; |
| static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec) = { NULL }; |
| |
| void __tasklet_schedule(struct tasklet_struct *t) |
| { |
| unsigned long flags; |
| |
| local_irq_save(flags); |
| t->next = __get_cpu_var(tasklet_vec).list; |
| __get_cpu_var(tasklet_vec).list = t; |
| raise_softirq_irqoff(TASKLET_SOFTIRQ); |
| local_irq_restore(flags); |
| } |
| |
| EXPORT_SYMBOL(__tasklet_schedule); |
| |
| void __tasklet_hi_schedule(struct tasklet_struct *t) |
| { |
| unsigned long flags; |
| |
| local_irq_save(flags); |
| t->next = __get_cpu_var(tasklet_hi_vec).list; |
| __get_cpu_var(tasklet_hi_vec).list = t; |
| raise_softirq_irqoff(HI_SOFTIRQ); |
| local_irq_restore(flags); |
| } |
| |
| EXPORT_SYMBOL(__tasklet_hi_schedule); |
| |
| static void tasklet_action(struct softirq_action *a) |
| { |
| struct tasklet_struct *list; |
| |
| local_irq_disable(); |
| list = __get_cpu_var(tasklet_vec).list; |
| __get_cpu_var(tasklet_vec).list = NULL; |
| local_irq_enable(); |
| |
| while (list) { |
| struct tasklet_struct *t = list; |
| |
| list = list->next; |
| |
| if (tasklet_trylock(t)) { |
| if (!atomic_read(&t->count)) { |
| if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)) |
| BUG(); |
| t->func(t->data); |
| tasklet_unlock(t); |
| continue; |
| } |
| tasklet_unlock(t); |
| } |
| |
| local_irq_disable(); |
| t->next = __get_cpu_var(tasklet_vec).list; |
| __get_cpu_var(tasklet_vec).list = t; |
| __raise_softirq_irqoff(TASKLET_SOFTIRQ); |
| local_irq_enable(); |
| } |
| } |
| |
| static void tasklet_hi_action(struct softirq_action *a) |
| { |
| struct tasklet_struct *list; |
| |
| local_irq_disable(); |
| list = __get_cpu_var(tasklet_hi_vec).list; |
| __get_cpu_var(tasklet_hi_vec).list = NULL; |
| local_irq_enable(); |
| |
| while (list) { |
| struct tasklet_struct *t = list; |
| |
| list = list->next; |
| |
| if (tasklet_trylock(t)) { |
| if (!atomic_read(&t->count)) { |
| if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)) |
| BUG(); |
| t->func(t->data); |
| tasklet_unlock(t); |
| continue; |
| } |
| tasklet_unlock(t); |
| } |
| |
| local_irq_disable(); |
| t->next = __get_cpu_var(tasklet_hi_vec).list; |
| __get_cpu_var(tasklet_hi_vec).list = t; |
| __raise_softirq_irqoff(HI_SOFTIRQ); |
| local_irq_enable(); |
| } |
| } |
| |
| |
| void tasklet_init(struct tasklet_struct *t, |
| void (*func)(unsigned long), unsigned long data) |
| { |
| t->next = NULL; |
| t->state = 0; |
| atomic_set(&t->count, 0); |
| t->func = func; |
| t->data = data; |
| } |
| |
| EXPORT_SYMBOL(tasklet_init); |
| |
| void tasklet_kill(struct tasklet_struct *t) |
| { |
| if (in_interrupt()) |
| printk("Attempt to kill tasklet from interrupt\n"); |
| |
| while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) { |
| do |
| yield(); |
| while (test_bit(TASKLET_STATE_SCHED, &t->state)); |
| } |
| tasklet_unlock_wait(t); |
| clear_bit(TASKLET_STATE_SCHED, &t->state); |
| } |
| |
| EXPORT_SYMBOL(tasklet_kill); |
| |
| static void tasklet_init_cpu(int cpu) |
| { |
| per_cpu(tasklet_vec, cpu).list = NULL; |
| per_cpu(tasklet_hi_vec, cpu).list = NULL; |
| } |
| |
| static int tasklet_cpu_notify(struct notifier_block *self, |
| unsigned long action, void *hcpu) |
| { |
| long cpu = (long)hcpu; |
| switch(action) { |
| case CPU_UP_PREPARE: |
| tasklet_init_cpu(cpu); |
| break; |
| default: |
| break; |
| } |
| return 0; |
| } |
| |
| static struct notifier_block tasklet_nb = { |
| .notifier_call = tasklet_cpu_notify, |
| .next = NULL, |
| }; |
| |
| void __init softirq_init(void) |
| { |
| open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL); |
| open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL); |
| tasklet_cpu_notify(&tasklet_nb, (unsigned long)CPU_UP_PREPARE, |
| (void *)(long)smp_processor_id()); |
| register_cpu_notifier(&tasklet_nb); |
| } |
| |
| static int ksoftirqd(void * __bind_cpu) |
| { |
| int cpu = (int) (long) __bind_cpu; |
| |
| daemonize("ksoftirqd/%d", cpu); |
| set_user_nice(current, 19); |
| current->flags |= PF_IOTHREAD; |
| |
| /* Migrate to the right CPU */ |
| set_cpus_allowed(current, cpumask_of_cpu(cpu)); |
| BUG_ON(smp_processor_id() != cpu); |
| |
| __set_current_state(TASK_INTERRUPTIBLE); |
| mb(); |
| |
| __get_cpu_var(ksoftirqd) = current; |
| |
| for (;;) { |
| if (!local_softirq_pending()) |
| schedule(); |
| |
| __set_current_state(TASK_RUNNING); |
| |
| while (local_softirq_pending()) { |
| do_softirq(); |
| cond_resched(); |
| } |
| |
| __set_current_state(TASK_INTERRUPTIBLE); |
| } |
| } |
| |
| static int __devinit cpu_callback(struct notifier_block *nfb, |
| unsigned long action, |
| void *hcpu) |
| { |
| int hotcpu = (unsigned long)hcpu; |
| |
| if (action == CPU_ONLINE) { |
| if (kernel_thread(ksoftirqd, hcpu, CLONE_KERNEL) < 0) { |
| printk("ksoftirqd for %i failed\n", hotcpu); |
| return NOTIFY_BAD; |
| } |
| |
| while (!per_cpu(ksoftirqd, hotcpu)) |
| yield(); |
| } |
| return NOTIFY_OK; |
| } |
| |
| static struct notifier_block __devinitdata cpu_nfb = { |
| .notifier_call = cpu_callback |
| }; |
| |
| __init int spawn_ksoftirqd(void) |
| { |
| cpu_callback(&cpu_nfb, CPU_ONLINE, (void *)(long)smp_processor_id()); |
| register_cpu_notifier(&cpu_nfb); |
| return 0; |
| } |