内核工作队列修炼日记2-keventd/events的演变

EXPORT_SYMBOL_GPL(__create_workqueue);
EXPORT_SYMBOL_GPL(queue_work);
EXPORT_SYMBOL_GPL(queue_delayed_work);
EXPORT_SYMBOL_GPL(flush_workqueue);
EXPORT_SYMBOL_GPL(destroy_workqueue);


EXPORT_SYMBOL(schedule_work);
EXPORT_SYMBOL(schedule_delayed_work);
EXPORT_SYMBOL(schedule_delayed_work_on);
EXPORT_SYMBOL(flush_scheduled_work);

struct workqueue_struct *__create_workqueue(const char *name,
              int singlethread)
{
  int cpu, destroy = 0;
  struct workqueue_struct *wq;
  struct task_struct *p;


  BUG_ON(strlen(name) > 10);


  wq = kmalloc(sizeof(*wq), GFP_KERNEL);
  if (!wq)
    return NULL;
  memset(wq, 0, sizeof(*wq));


  wq->name = name;
  /* We don't need the distraction of CPUs appearing and vanishing. */
  lock_cpu_hotplug();
  if (singlethread) {
    INIT_LIST_HEAD(&wq->list);
    p = create_workqueue_thread(wq, 0);
    if (!p)
      destroy = 1;
    else
      wake_up_process(p);
  } else {
    spin_lock(&workqueue_lock);
    list_add(&wq->list, &workqueues);
    spin_unlock(&workqueue_lock);
    for_each_online_cpu(cpu) {
      p = create_workqueue_thread(wq, cpu);
      if (p) {
        kthread_bind(p, cpu);
        wake_up_process(p);
      } else
        destroy = 1;
    }
  }
  unlock_cpu_hotplug();


  /*
   * Was there any error during startup? If yes then clean up:
   */
  if (destroy) {
    destroy_workqueue(wq);
    wq = NULL;
  }
  return wq;
}

void init_workqueues(void)
{
  hotcpu_notifier(workqueue_cpu_callback, 0);
  keventd_wq = create_workqueue("events");
  BUG_ON(!keventd_wq);
}

/* Preempt must be disabled. */
static void __queue_work(struct cpu_workqueue_struct *cwq,
       struct work_struct *work)
{
  unsigned long flags;


  spin_lock_irqsave(&cwq->lock, flags);
  work->wq_data = cwq;
  list_add_tail(&work->entry, &cwq->worklist);
  cwq->insert_sequence++;
  wake_up(&cwq->more_work);
  spin_unlock_irqrestore(&cwq->lock, flags);
}


/*
 * Queue work on a workqueue. Return non-zero if it was successfully
 * added.
 *
 * We queue the work to the CPU it was submitted, but there is no
 * guarantee that it will be processed by that CPU.
 */
int fastcall queue_work(struct workqueue_struct *wq, struct work_struct *work)
{
  int ret = 0, cpu = get_cpu();


  if (!test_and_set_bit(0, &work->pending)) {
    if (unlikely(is_single_threaded(wq)))
      cpu = 0;
    BUG_ON(!list_empty(&work->entry));
    __queue_work(wq->cpu_wq + cpu, work);
    ret = 1;
  }
  put_cpu();
  return ret;
}
/* 默认的全局队列 */
static struct workqueue_struct *keventd_wq;


int fastcall schedule_work(struct work_struct *work)
{
  return queue_work(keventd_wq, work);
}