softirq.c

Go to the documentation of this file.

/* $Id: softirq.c,v 1.15 2004/05/05 13:50:24 ch12 Exp $ */
/*****************************************************************************/
/* (c) 2003 Technische Universitaet Dresden
 * This file is part of DROPS, which is distributed under the terms of the
 * GNU General Public License 2. Please see the COPYING file for details.
 */

/* L4 */
#include <l4/env/errno.h>
#include <l4/sys/syscalls.h>
#include <l4/thread/thread.h>
#include <l4/semaphore/semaphore.h>
#include <l4/lock/lock.h>

#include <l4/dde_linux/dde.h>

/* Linux */
#include <linux/config.h>
#include <linux/mm.h>
#include <linux/kernel_stat.h>
#include <linux/interrupt.h>
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <linux/tqueue.h>

/* local */
#include "internal.h"
#include "__config.h"

static l4thread_t softirq_tid[SOFTIRQ_THREADS];

static l4semaphore_t softirq_sema = L4SEMAPHORE_LOCKED;

static int _initialized = 0;

void __cpu_raise_softirq(unsigned cpu, int nr)
{
  l4semaphore_up(&softirq_sema);
}

void raise_softirq(int nr)
{
  /* original comment: I do not want to use atomic variables now, so that
     cli/sti */
  cli();
  __cpu_raise_softirq(0, nr);
  sti();
}

static struct tasklet_head tasklet_vec[NR_CPUS];

static struct tasklet_head tasklet_hi_vec[NR_CPUS];

static void tasklet_action(void)
{
  struct tasklet_struct *list;

  LOGd(DEBUG_SOFTIRQ, "low prio tasklet exec entrance");

  cli();
  list = tasklet_vec[0].list;
  tasklet_vec[0].list = NULL;
  sti();

  while (list != NULL)
    {
      struct tasklet_struct *t = list;

      list = list->next;

      if (tasklet_trylock(t))
        {
          if (atomic_read(&t->count) == 0)
            {
              clear_bit(TASKLET_STATE_SCHED, &t->state);

              t->func(t->data);
              tasklet_unlock(t);
              continue;
            }
          tasklet_unlock(t);
        }
      cli();
      t->next = tasklet_vec[0].list;
      tasklet_vec[0].list = t;
      __cpu_raise_softirq(0, TASKLET_SOFTIRQ);
      sti();
    }
}

static int tasklet_hi_action(void)
{
  struct tasklet_struct *list;

  if (!tasklet_hi_vec[0].list)
    /* no tasks */
    return 0;

  LOGd(DEBUG_SOFTIRQ, "hi prio tasklet exec entrance");

  cli();
  list = tasklet_hi_vec[0].list;
  tasklet_hi_vec[0].list = NULL;
  sti();

  while (list != NULL)
    {
      struct tasklet_struct *t = list;

      list = list->next;

      if (tasklet_trylock(t))
        {
          if (atomic_read(&t->count) == 0)
            {
              clear_bit(TASKLET_STATE_SCHED, &t->state);

              t->func(t->data);
              tasklet_unlock(t);
              continue;
            }
          tasklet_unlock(t);
        }
      cli();
      t->next = tasklet_hi_vec[0].list;
      tasklet_hi_vec[0].list = t;
      __cpu_raise_softirq(0, HI_SOFTIRQ);
      sti();
    }

  return !0;
}

void tasklet_init(struct tasklet_struct *t,
                  void (*func) (unsigned long), unsigned long data)
{
  t->func = func;
  t->data = data;
  t->state = 0;
  atomic_set(&t->count, 0);
}

void tasklet_kill(struct tasklet_struct *t)
{
//      if (in_interrupt())
//              printf("Attempt to kill tasklet from interrupt\n");

  while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
    {
#if 0   /* original implementation uses schedule() */
      current->state = TASK_RUNNING;
      do
        {
          current->policy |= SCHED_YIELD;
          schedule();
        }
      while (test_bit(TASKLET_STATE_SCHED, &t->state));
#else /* spin for tasklet while it is scheduled */
      do
        {
          /* release CPU on any way (like schedule() does in DDE) */
# if SCHED_YIELD_OPT
          l4thread_usleep(SCHED_YIELD_TO);
# else
          l4_yield();
# endif
        }
      while (test_bit(TASKLET_STATE_SCHED, &t->state));
#endif /* 0 */
    }
  tasklet_unlock_wait(t);
  clear_bit(TASKLET_STATE_SCHED, &t->state);
}

void tasklet_schedule(struct tasklet_struct *t)
{
  if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
    {
      cli();
      t->next = tasklet_vec[0].list;
      tasklet_vec[0].list = t;

      /* raise softirq only on new 1st element */
      if (!t->next)
        __cpu_raise_softirq(0, TASKLET_SOFTIRQ);
      sti();
    }
}

/*****************************************************************************/
/*****************************************************************************/
void tasklet_hi_schedule(struct tasklet_struct *t)
{
  if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
    {
      cli();
      t->next = tasklet_hi_vec[0].list;
      tasklet_hi_vec[0].list = t;

      /* raise softirq only on new 1st element */
      if (!t->next)
        __cpu_raise_softirq(0, HI_SOFTIRQ);
      sti();
    }
}

spinlock_t tqueue_lock = SPIN_LOCK_UNLOCKED;

void __run_task_queue(task_queue * list)
{
  struct list_head head, *next;
  unsigned long flags;

  spin_lock_irqsave(&tqueue_lock, flags);
  list_add(&head, list);
  list_del_init(list);
  spin_unlock_irqrestore(&tqueue_lock, flags);

  next = head.next;
  while (next != &head)
    {
      void (*f) (void *);
      struct tq_struct *p;
      void *data;

      p = list_entry(next, struct tq_struct, list);
      next = next->next;
      f = p->routine;
      data = p->data;
      wmb();
      p->sync = 0;
      if (f)
        f(data);
    }
}

static void dde_softirq_thread(int num)
{
  softirq_tid[num] = l4thread_myself();

  if (l4dde_process_add_worker())
      Panic("l4dde_process_add_worker() failed");

  ++local_bh_count(smp_processor_id());

  /* we are up */
  if (l4thread_started(NULL)<0)
    Panic("softirq thread startup failed!");

  LOGd(DEBUG_MSG, "dde_softirq_thread[%d] "l4util_idfmt" running.", num,
       l4util_idstr(l4thread_l4_id(l4thread_myself())));

  /* softirq loop */
  while (1)
    {
      /* softirq _consumer_ */
      l4semaphore_down(&softirq_sema);

      /* low-priority tasks only if no high-priority available */
      if (!tasklet_hi_action())
        tasklet_action();
    }
}

int l4dde_softirq_init()
{
#if !(SOFTIRQ_THREADS == 1)
#error SOFTIRQ_THREADS has to be 1
#else
  int err;

  if (_initialized)
    return 0;

  /* create softirq thread */
  err = l4thread_create_long(L4THREAD_INVALID_ID,
                             (l4thread_fn_t) dde_softirq_thread,
                             ".softirq",
                             L4THREAD_INVALID_SP,
                             L4THREAD_DEFAULT_SIZE,
                             L4THREAD_DEFAULT_PRIO,
                             (void *) 0,
                             L4THREAD_CREATE_SYNC);

  if (err < 0)
    return err;

  ++_initialized;
  return 0;
#endif
}

---