contexnt primitives of kernel such as soft interupts, scheduling,
tasklet are implemented for libos. these functions eventually call the
functions registered by lib_init() API as well.

Signed-off-by: Hajime Tazaki <taz...@sfc.wide.ad.jp>
---
 arch/lib/sched.c     | 406 +++++++++++++++++++++++++++++++++++++++++++++++++++
 arch/lib/softirq.c   | 108 ++++++++++++++
 arch/lib/tasklet.c   |  76 ++++++++++
 arch/lib/workqueue.c | 242 ++++++++++++++++++++++++++++++
 4 files changed, 832 insertions(+)
 create mode 100644 arch/lib/sched.c
 create mode 100644 arch/lib/softirq.c
 create mode 100644 arch/lib/tasklet.c
 create mode 100644 arch/lib/workqueue.c

diff --git a/arch/lib/sched.c b/arch/lib/sched.c
new file mode 100644
index 0000000..98a568a
--- /dev/null
+++ b/arch/lib/sched.c
@@ -0,0 +1,406 @@
+/*
+ * glue code for library version of Linux kernel
+ * Copyright (c) 2015 INRIA, Hajime Tazaki
+ *
+ * Author: Mathieu Lacage <mathieu.lac...@gmail.com>
+ *         Hajime Tazaki <taz...@sfc.wide.ad.jp>
+ */
+
+#include <linux/wait.h>
+#include <linux/list.h>
+#include <linux/sched.h>
+#include <linux/nsproxy.h>
+#include <linux/hash.h>
+#include <net/net_namespace.h>
+#include "lib.h"
+#include "sim.h"
+#include "sim-assert.h"
+
+/**
+   called by wait_event macro:
+   - prepare_to_wait
+   - schedule
+   - finish_wait
+ */
+
+struct SimTask *lib_task_create(void *private, unsigned long pid)
+{
+       struct SimTask *task = lib_malloc(sizeof(struct SimTask));
+       struct cred *cred;
+       struct nsproxy *ns;
+       struct user_struct *user;
+       struct thread_info *info;
+       struct pid *kpid;
+
+       if (!task)
+               return NULL;
+       memset(task, 0, sizeof(struct SimTask));
+       cred = lib_malloc(sizeof(struct cred));
+       if (!cred)
+               return NULL;
+       /* XXX: we could optimize away this allocation by sharing it
+          for all tasks */
+       ns = lib_malloc(sizeof(struct nsproxy));
+       if (!ns)
+               return NULL;
+       user = lib_malloc(sizeof(struct user_struct));
+       if (!user)
+               return NULL;
+       info = alloc_thread_info(&task->kernel_task);
+       if (!info)
+               return NULL;
+       kpid = lib_malloc(sizeof(struct pid));
+       if (!kpid)
+               return NULL;
+       kpid->numbers[0].nr = pid;
+       cred->fsuid = make_kuid(current_user_ns(), 0);
+       cred->fsgid = make_kgid(current_user_ns(), 0);
+       cred->user = user;
+       atomic_set(&cred->usage, 1);
+       info->task = &task->kernel_task;
+       info->preempt_count = 0;
+       info->flags = 0;
+       atomic_set(&ns->count, 1);
+       ns->uts_ns = 0;
+       ns->ipc_ns = 0;
+       ns->mnt_ns = 0;
+       ns->pid_ns_for_children = 0;
+       ns->net_ns = &init_net;
+       task->kernel_task.cred = cred;
+       task->kernel_task.pid = pid;
+       task->kernel_task.pids[PIDTYPE_PID].pid = kpid;
+       task->kernel_task.pids[PIDTYPE_PGID].pid = kpid;
+       task->kernel_task.pids[PIDTYPE_SID].pid = kpid;
+       task->kernel_task.nsproxy = ns;
+       task->kernel_task.stack = info;
+       /* this is a hack. */
+       task->kernel_task.group_leader = &task->kernel_task;
+       task->private = private;
+       return task;
+}
+void lib_task_destroy(struct SimTask *task)
+{
+       lib_free((void *)task->kernel_task.nsproxy);
+       lib_free((void *)task->kernel_task.cred);
+       lib_free((void *)task->kernel_task.cred->user);
+       free_thread_info(task->kernel_task.stack);
+       lib_free(task);
+}
+void *lib_task_get_private(struct SimTask *task)
+{
+       return task->private;
+}
+
+int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+       struct SimTask *task = lib_task_start((void (*)(void *))fn, arg);
+
+       return task->kernel_task.pid;
+}
+
+struct task_struct *get_current(void)
+{
+       struct SimTask *lib_task = lib_task_current();
+
+       return &lib_task->kernel_task;
+}
+
+struct thread_info *current_thread_info(void)
+{
+       return task_thread_info(get_current());
+}
+struct thread_info *alloc_thread_info(struct task_struct *task)
+{
+       return lib_malloc(sizeof(struct thread_info));
+}
+void free_thread_info(struct thread_info *ti)
+{
+       lib_free(ti);
+}
+
+
+void __put_task_struct(struct task_struct *t)
+{
+       lib_free(t);
+}
+
+void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
+{
+       wait->flags &= ~WQ_FLAG_EXCLUSIVE;
+       list_add(&wait->task_list, &q->task_list);
+}
+void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
+{
+       wait->flags |= WQ_FLAG_EXCLUSIVE;
+       list_add_tail(&wait->task_list, &q->task_list);
+}
+void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
+{
+       if (wait->task_list.prev != LIST_POISON2)
+               list_del(&wait->task_list);
+}
+void
+prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
+{
+       wait->flags |= WQ_FLAG_EXCLUSIVE;
+       if (list_empty(&wait->task_list))
+               list_add_tail(&wait->task_list, &q->task_list);
+       set_current_state(state);
+}
+void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
+{
+       unsigned long flags;
+
+       wait->flags &= ~WQ_FLAG_EXCLUSIVE;
+       spin_lock_irqsave(&q->lock, flags);
+       if (list_empty(&wait->task_list))
+               __add_wait_queue(q, wait);
+       set_current_state(state);
+       spin_unlock_irqrestore(&q->lock, flags);
+}
+void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
+{
+       set_current_state(TASK_RUNNING);
+       if (!list_empty(&wait->task_list))
+               list_del_init(&wait->task_list);
+}
+int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync,
+                            void *key)
+{
+       int ret = default_wake_function(wait, mode, sync, key);
+
+       if (ret && (wait->task_list.prev != LIST_POISON2))
+               list_del_init(&wait->task_list);
+
+       return ret;
+}
+
+int woken_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
+{
+       wait->flags |= WQ_FLAG_WOKEN;
+       return default_wake_function(wait, mode, sync, key);
+}
+
+void __init_waitqueue_head(wait_queue_head_t *q, const char *name,
+                          struct lock_class_key *k)
+{
+       INIT_LIST_HEAD(&q->task_list);
+}
+/**
+ * wait_for_completion: - waits for completion of a task
+ * @x:  holds the state of this particular completion
+ *
+ * This waits to be signaled for completion of a specific task. It is NOT
+ * interruptible and there is no timeout.
+ *
+ * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
+ * and interrupt capability. Also see complete().
+ */
+void wait_for_completion(struct completion *x)
+{
+       wait_for_completion_timeout(x, MAX_SCHEDULE_TIMEOUT);
+}
+unsigned long wait_for_completion_timeout(struct completion *x,
+                                         unsigned long timeout)
+{
+       if (!x->done) {
+               DECLARE_WAITQUEUE(wait, current);
+               set_current_state(TASK_UNINTERRUPTIBLE);
+               wait.flags |= WQ_FLAG_EXCLUSIVE;
+               list_add_tail(&wait.task_list, &x->wait.task_list);
+               do
+                       timeout = schedule_timeout(timeout);
+               while (!x->done && timeout);
+               if (wait.task_list.prev != LIST_POISON2)
+                       list_del(&wait.task_list);
+
+               if (!x->done)
+                       return timeout;
+       }
+       x->done--;
+       return timeout ? : 1;
+}
+
+/**
+ * __wake_up - wake up threads blocked on a waitqueue.
+ * @q: the waitqueue
+ * @mode: which threads
+ * @nr_exclusive: how many wake-one or wake-many threads to wake up
+ * @key: is directly passed to the wakeup function
+ *
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
+ */
+void __wake_up(wait_queue_head_t *q, unsigned int mode,
+              int nr_exclusive, void *key)
+{
+       wait_queue_t *curr, *next;
+
+       list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
+               unsigned flags = curr->flags;
+
+               if (curr->func(curr, mode, 0, key) &&
+                   (flags & WQ_FLAG_EXCLUSIVE) &&
+                   !--nr_exclusive)
+                       break;
+       }
+}
+void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
+                       int nr_exclusive, void *key)
+{
+       __wake_up(q, mode, nr_exclusive, key);
+}
+int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
+                         void *key)
+{
+       struct task_struct *task = (struct task_struct *)curr->private;
+       struct SimTask *lib_task = container_of(task, struct SimTask,
+                                               kernel_task);
+
+       return lib_task_wakeup(lib_task);
+}
+__sched int bit_wait(struct wait_bit_key *word)
+{
+       if (signal_pending_state(current->state, current))
+               return 1;
+       schedule();
+       return 0;
+}
+int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *arg)
+{
+       struct wait_bit_key *key = arg;
+       struct wait_bit_queue *wait_bit
+               = container_of(wait, struct wait_bit_queue, wait);
+
+       if (wait_bit->key.flags != key->flags ||
+                       wait_bit->key.bit_nr != key->bit_nr ||
+                       test_bit(key->bit_nr, key->flags))
+               return 0;
+       else
+               return autoremove_wake_function(wait, mode, sync, key);
+}
+void __wake_up_bit(wait_queue_head_t *wq, void *word, int bit)
+{
+       struct wait_bit_key key = __WAIT_BIT_KEY_INITIALIZER(word, bit);
+       if (waitqueue_active(wq))
+               __wake_up(wq, TASK_NORMAL, 1, &key);
+}
+void wake_up_bit(void *word, int bit)
+{
+       /* FIXME */
+       return;
+       __wake_up_bit(bit_waitqueue(word, bit), word, bit);
+}
+wait_queue_head_t *bit_waitqueue(void *word, int bit)
+{
+       const int shift = BITS_PER_LONG == 32 ? 5 : 6;
+       const struct zone *zone = page_zone(virt_to_page(word));
+       unsigned long val = (unsigned long)word << shift | bit;
+
+       return &zone->wait_table[hash_long(val, zone->wait_table_bits)];
+}
+
+
+void schedule(void)
+{
+       lib_task_wait();
+}
+
+static void trampoline(void *context)
+{
+       struct SimTask *task = context;
+
+       lib_task_wakeup(task);
+}
+
+signed long schedule_timeout(signed long timeout)
+{
+       u64 ns;
+       struct SimTask *self;
+
+       if (timeout == MAX_SCHEDULE_TIMEOUT) {
+               lib_task_wait();
+               return MAX_SCHEDULE_TIMEOUT;
+       }
+       lib_assert(timeout >= 0);
+       ns = ((__u64)timeout) * (1000000000 / HZ);
+       self = lib_task_current();
+       lib_event_schedule_ns(ns, &trampoline, self);
+       lib_task_wait();
+       /* we know that we are always perfectly on time. */
+       return 0;
+}
+
+signed long schedule_timeout_uninterruptible(signed long timeout)
+{
+       return schedule_timeout(timeout);
+}
+signed long schedule_timeout_interruptible(signed long timeout)
+{
+       return schedule_timeout(timeout);
+}
+
+void yield(void)
+{
+       lib_task_yield();
+}
+
+void complete_all(struct completion *x)
+{
+       x->done += UINT_MAX / 2;
+       __wake_up(&x->wait, TASK_NORMAL, 0, 0);
+}
+void complete(struct completion *x)
+{
+       x->done++;
+       __wake_up(&x->wait, TASK_NORMAL, 1, 0);
+}
+
+long wait_for_completion_interruptible_timeout(
+       struct completion *x, unsigned long timeout)
+{
+       return wait_for_completion_timeout(x, timeout);
+}
+int wait_for_completion_interruptible(struct completion *x)
+{
+       wait_for_completion_timeout(x, MAX_SCHEDULE_TIMEOUT);
+       return 0;
+}
+int wake_up_process(struct task_struct *tsk)
+{
+       struct SimTask *lib_task =
+               container_of(tsk, struct SimTask, kernel_task);
+
+       return lib_task_wakeup(lib_task);
+}
+int _cond_resched(void)
+{
+       /* we never schedule to decrease latency. */
+       return 0;
+}
+int idle_cpu(int cpu)
+{
+       /* we are never idle: we call this from rcutiny.c and the answer */
+       /* does not matter, really. */
+       return 0;
+}
+
+unsigned long long __attribute__((weak)) sched_clock(void)
+{
+       return (unsigned long long)(jiffies - INITIAL_JIFFIES)
+              * (NSEC_PER_SEC / HZ);
+}
+
+u64 local_clock(void)
+{
+       return sched_clock();
+}
+
+void __sched schedule_preempt_disabled(void)
+{
+}
+
+void resched_cpu(int cpu)
+{
+       rcu_sched_qs();
+}
diff --git a/arch/lib/softirq.c b/arch/lib/softirq.c
new file mode 100644
index 0000000..3f6363a
--- /dev/null
+++ b/arch/lib/softirq.c
@@ -0,0 +1,108 @@
+/*
+ * glue code for library version of Linux kernel
+ * Copyright (c) 2015 INRIA, Hajime Tazaki
+ *
+ * Author: Mathieu Lacage <mathieu.lac...@gmail.com>
+ *         Hajime Tazaki <taz...@sfc.wide.ad.jp>
+ */
+
+#include <linux/interrupt.h>
+#include "sim-init.h"
+#include "sim.h"
+#include "sim-assert.h"
+
+
+static struct softirq_action softirq_vec[NR_SOFTIRQS];
+static struct SimTask *g_softirq_task = 0;
+static int g_n_raises = 0;
+
+void lib_softirq_wakeup(void)
+{
+       g_n_raises++;
+       lib_task_wakeup(g_softirq_task);
+}
+
+static void softirq_task_function(void *context)
+{
+       while (true) {
+               do_softirq();
+               g_n_raises--;
+               if (g_n_raises == 0 || local_softirq_pending() == 0) {
+                       g_n_raises = 0;
+                       lib_task_wait();
+               }
+       }
+}
+
+static void ensure_task_created(void)
+{
+       if (g_softirq_task != 0)
+               return;
+       g_softirq_task = lib_task_start(&softirq_task_function, 0);
+}
+
+void open_softirq(int nr, void (*action)(struct softirq_action *))
+{
+       ensure_task_created();
+       softirq_vec[nr].action = action;
+}
+#define MAX_SOFTIRQ_RESTART 10
+
+void do_softirq(void)
+{
+       __u32 pending;
+       int max_restart = MAX_SOFTIRQ_RESTART;
+       struct softirq_action *h;
+
+       pending = local_softirq_pending();
+
+restart:
+       /* Reset the pending bitmask before enabling irqs */
+       set_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;
+}
+void raise_softirq_irqoff(unsigned int nr)
+{
+       __raise_softirq_irqoff(nr);
+
+       lib_softirq_wakeup();
+}
+void __raise_softirq_irqoff(unsigned int nr)
+{
+       /* trace_softirq_raise(nr); */
+       or_softirq_pending(1UL << nr);
+}
+int __cond_resched_softirq(void)
+{
+       /* tell the caller that we did not need to re-schedule. */
+       return 0;
+}
+void raise_softirq(unsigned int nr)
+{
+       /* copy/paste from kernel/softirq.c */
+       unsigned long flags;
+
+       local_irq_save(flags);
+       raise_softirq_irqoff(nr);
+       local_irq_restore(flags);
+}
+
+void __local_bh_enable_ip(unsigned long ip, unsigned int cnt)
+{
+}
diff --git a/arch/lib/tasklet.c b/arch/lib/tasklet.c
new file mode 100644
index 0000000..6cc68f4
--- /dev/null
+++ b/arch/lib/tasklet.c
@@ -0,0 +1,76 @@
+/*
+ * glue code for library version of Linux kernel
+ * Copyright (c) 2015 INRIA, Hajime Tazaki
+ *
+ * Author: Mathieu Lacage <mathieu.lac...@gmail.com>
+ *         Hajime Tazaki <taz...@sfc.wide.ad.jp>
+ */
+
+#include <linux/interrupt.h>
+#include "sim.h"
+#include "sim-assert.h"
+
+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;
+}
+
+void tasklet_kill(struct tasklet_struct *t)
+{
+       /* theoretically, called from user context */
+       while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {
+               do
+                       lib_task_yield();
+               while (test_bit(TASKLET_STATE_SCHED, &t->state));
+       }
+       clear_bit(TASKLET_STATE_SCHED, &t->state);
+}
+struct tasklet_struct *g_sched_events = NULL;
+static void run_tasklet_softirq(struct softirq_action *h)
+{
+       /* while (!list_empty (&g_sched_events)) */
+       /*   { */
+       struct tasklet_struct *tasklet = g_sched_events;
+
+       if (atomic_read(&tasklet->count) == 0) {
+               /* this tasklet is enabled so, we run it. */
+               test_and_clear_bit(TASKLET_STATE_SCHED, &tasklet->state);
+               tasklet->func(tasklet->data);
+       }
+       /* } */
+}
+static void ensure_softirq_opened(void)
+{
+       static bool opened = false;
+
+       if (opened)
+               return;
+       opened = true;
+       open_softirq(TASKLET_SOFTIRQ, run_tasklet_softirq);
+}
+static void trampoline(void *context)
+{
+       ensure_softirq_opened();
+       struct tasklet_struct *tasklet = context;
+       /* allow the tasklet to re-schedule itself */
+       lib_assert(tasklet->next != 0);
+       tasklet->next = 0;
+       g_sched_events = tasklet;
+       raise_softirq(TASKLET_SOFTIRQ);
+}
+void __tasklet_schedule(struct tasklet_struct *t)
+{
+       void *event;
+
+       /* Note: no need to set TASKLET_STATE_SCHED because
+          it is set by caller. */
+       lib_assert(t->next == 0);
+       /* run the tasklet at the next immediately available opportunity. */
+       event = lib_event_schedule_ns(0, &trampoline, t);
+       t->next = event;
+}
diff --git a/arch/lib/workqueue.c b/arch/lib/workqueue.c
new file mode 100644
index 0000000..bd0e9c5
--- /dev/null
+++ b/arch/lib/workqueue.c
@@ -0,0 +1,242 @@
+/*
+ * glue code for library version of Linux kernel
+ * Copyright (c) 2015 INRIA, Hajime Tazaki
+ *
+ * Author: Mathieu Lacage <mathieu.lac...@gmail.com>
+ *         Hajime Tazaki <taz...@sfc.wide.ad.jp>
+ */
+
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+#include "sim.h"
+#include "sim-assert.h"
+
+/* copy from kernel/workqueue.c */
+typedef unsigned long mayday_mask_t;
+struct workqueue_struct {
+       unsigned int flags;                     /* W: WQ_* flags */
+       union {
+               struct cpu_workqueue_struct __percpu *pcpu;
+               struct cpu_workqueue_struct *single;
+               unsigned long v;
+       } cpu_wq;                               /* I: cwq's */
+       struct list_head list;                  /* W: list of all workqueues */
+
+       struct mutex flush_mutex;               /* protects wq flushing */
+       int work_color;                         /* F: current work color */
+       int flush_color;                        /* F: current flush color */
+       atomic_t nr_cwqs_to_flush;              /* flush in progress */
+       struct wq_flusher *first_flusher;       /* F: first flusher */
+       struct list_head flusher_queue;         /* F: flush waiters */
+       struct list_head flusher_overflow;      /* F: flush overflow list */
+
+       mayday_mask_t mayday_mask;              /* cpus requesting rescue */
+       struct worker *rescuer;                 /* I: rescue worker */
+
+       int nr_drainers;                        /* W: drain in progress */
+       int saved_max_active;                   /* W: saved cwq max_active */
+#ifdef CONFIG_LOCKDEP
+       struct lockdep_map lockdep_map;
+#endif
+       char name[];                            /* I: workqueue name */
+};
+
+struct wq_barrier {
+       struct SimTask *waiter;
+       struct workqueue_struct wq;
+};
+
+static void
+workqueue_function(void *context)
+{
+       struct workqueue_struct *wq = context;
+
+       while (true) {
+               lib_task_wait();
+               while (!list_empty(&wq->list)) {
+                       struct work_struct *work =
+                               list_first_entry(&wq->list, struct work_struct,
+                                               entry);
+                       work_func_t f = work->func;
+
+                       if (work->entry.prev != LIST_POISON2) {
+                               list_del_init(&work->entry);
+                               clear_bit(WORK_STRUCT_PENDING_BIT,
+                                         work_data_bits(work));
+                               f(work);
+                       }
+               }
+       }
+}
+
+static struct SimTask *workqueue_task(struct workqueue_struct *wq)
+{
+       struct wq_barrier *barr = container_of(wq, struct wq_barrier, wq);
+
+       if (barr->waiter == 0)
+               barr->waiter = lib_task_start(&workqueue_function, wq);
+       return barr->waiter;
+}
+
+static int flush_entry(struct workqueue_struct *wq, struct list_head *prev)
+{
+       int active = 0;
+
+       if (!list_empty(&wq->list)) {
+               active = 1;
+               lib_task_wakeup(workqueue_task(wq));
+               /* XXX: should wait for completion? but this will block
+                  and init won't return.. */
+               /* lib_task_wait (); */
+       }
+
+       return active;
+}
+
+void delayed_work_timer_fn(unsigned long data)
+{
+       struct delayed_work *dwork = (struct delayed_work *)data;
+       struct work_struct *work = &dwork->work;
+
+       list_add_tail(&work->entry, &dwork->wq->list);
+       lib_task_wakeup(workqueue_task(dwork->wq));
+}
+
+bool queue_work_on(int cpu, struct workqueue_struct *wq,
+                  struct work_struct *work)
+{
+       int ret = 0;
+
+       if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
+               list_add_tail(&work->entry, &wq->list);
+               lib_task_wakeup(workqueue_task(wq));
+               ret = 1;
+       }
+       return ret;
+}
+
+void flush_scheduled_work(void)
+{
+       flush_entry(system_wq, system_wq->list.prev);
+}
+bool flush_work(struct work_struct *work)
+{
+       return flush_entry(system_wq, &work->entry);
+}
+void flush_workqueue(struct workqueue_struct *wq)
+{
+       flush_entry(wq, wq->list.prev);
+}
+bool cancel_work_sync(struct work_struct *work)
+{
+       int retval = 0;
+
+       if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)))
+               /* work was not yet queued */
+               return 0;
+       if (!list_empty(&work->entry)) {
+               /* work was queued. now unqueued. */
+               if (work->entry.prev != LIST_POISON2) {
+                       list_del_init(&work->entry);
+                       clear_bit(WORK_STRUCT_PENDING_BIT,
+                                 work_data_bits(work));
+                       retval = 1;
+               }
+       }
+       return retval;
+}
+bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
+                          struct delayed_work *dwork, unsigned long delay)
+{
+       int ret = 0;
+       struct timer_list *timer = &dwork->timer;
+       struct work_struct *work = &dwork->work;
+
+       if (delay == 0)
+               return queue_work(wq, work);
+
+       if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
+               lib_assert(!timer_pending(timer));
+               dwork->wq = wq;
+               /* This stores cwq for the moment, for the timer_fn */
+               timer->expires = jiffies + delay;
+               timer->data = (unsigned long)dwork;
+               timer->function = delayed_work_timer_fn;
+               add_timer(timer);
+               ret = 1;
+       }
+       return ret;
+}
+bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
+                        struct delayed_work *dwork, unsigned long delay)
+{
+       del_timer(&dwork->timer);
+       __clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(&dwork->work));
+       return queue_delayed_work(wq, dwork, delay);
+}
+bool cancel_delayed_work(struct delayed_work *dwork)
+{
+       del_timer(&dwork->timer);
+       return cancel_work_sync(&dwork->work);
+}
+
+struct workqueue_struct *__alloc_workqueue_key(const char *fmt,
+                                              unsigned int flags,
+                                              int max_active,
+                                              struct lock_class_key *key,
+                                              const char *lock_name, ...)
+{
+       va_list args, args1;
+       struct wq_barrier *barr;
+       struct workqueue_struct *wq;
+       size_t namelen;
+
+       /* determine namelen, allocate wq and format name */
+       va_start(args, lock_name);
+       va_copy(args1, args);
+       namelen = vsnprintf(NULL, 0, fmt, args) + 1;
+
+       barr = kzalloc(sizeof(*barr) + namelen, GFP_KERNEL);
+       if (!barr)
+               goto err;
+       barr->waiter = 0;
+       wq = &barr->wq;
+
+       vsnprintf(wq->name, namelen, fmt, args1);
+       va_end(args);
+       va_end(args1);
+
+       max_active = max_active ? : WQ_DFL_ACTIVE;
+       /* init wq */
+       wq->flags = flags;
+       wq->saved_max_active = max_active;
+       mutex_init(&wq->flush_mutex);
+       atomic_set(&wq->nr_cwqs_to_flush, 0);
+       INIT_LIST_HEAD(&wq->flusher_queue);
+       INIT_LIST_HEAD(&wq->flusher_overflow);
+
+       lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);
+       INIT_LIST_HEAD(&wq->list);
+
+       /* start waiter task */
+       workqueue_task(wq);
+       return wq;
+err:
+       if (barr)
+               kfree(barr);
+       return NULL;
+}
+
+struct workqueue_struct *system_wq __read_mostly;
+struct workqueue_struct *system_power_efficient_wq __read_mostly;
+/* from linux/workqueue.h */
+#define system_nrt_wq                   __system_nrt_wq()
+
+static int __init init_workqueues(void)
+{
+       system_wq = alloc_workqueue("events", 0, 0);
+       system_power_efficient_wq = alloc_workqueue("events_power_efficient",
+                                                   WQ_POWER_EFFICIENT, 0);
+       return 0;
+}
+early_initcall(init_workqueues);
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe netdev" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to