arm: tegra: register save and restore ops
[linux-3.10.git] / kernel / async.c
index bd0c168..61f023c 100644 (file)
@@ -57,55 +57,48 @@ asynchronous and synchronous parts of the kernel.
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 
+#include "workqueue_internal.h"
+
 static async_cookie_t next_cookie = 1;
 
-#define MAX_WORK       32768
+#define MAX_WORK               32768
+#define ASYNC_COOKIE_MAX       ULLONG_MAX      /* infinity cookie */
 
-static LIST_HEAD(async_pending);
-static LIST_HEAD(async_running);
+static LIST_HEAD(async_global_pending);        /* pending from all registered doms */
+static ASYNC_DOMAIN(async_dfl_domain);
 static DEFINE_SPINLOCK(async_lock);
 
 struct async_entry {
-       struct list_head        list;
+       struct list_head        domain_list;
+       struct list_head        global_list;
        struct work_struct      work;
        async_cookie_t          cookie;
-       async_func_ptr          *func;
+       async_func_t            func;
        void                    *data;
-       struct list_head        *running;
+       struct async_domain     *domain;
 };
 
 static DECLARE_WAIT_QUEUE_HEAD(async_done);
 
 static atomic_t entry_count;
 
-
-/*
- * MUST be called with the lock held!
- */
-static async_cookie_t  __lowest_in_progress(struct list_head *running)
+static async_cookie_t lowest_in_progress(struct async_domain *domain)
 {
-       struct async_entry *entry;
-
-       if (!list_empty(running)) {
-               entry = list_first_entry(running,
-                       struct async_entry, list);
-               return entry->cookie;
-       }
+       struct list_head *pending;
+       async_cookie_t ret = ASYNC_COOKIE_MAX;
+       unsigned long flags;
 
-       list_for_each_entry(entry, &async_pending, list)
-               if (entry->running == running)
-                       return entry->cookie;
+       spin_lock_irqsave(&async_lock, flags);
 
-       return next_cookie;     /* "infinity" value */
-}
+       if (domain)
+               pending = &domain->pending;
+       else
+               pending = &async_global_pending;
 
-static async_cookie_t  lowest_in_progress(struct list_head *running)
-{
-       unsigned long flags;
-       async_cookie_t ret;
+       if (!list_empty(pending))
+               ret = list_first_entry(pending, struct async_entry,
+                                      domain_list)->cookie;
 
-       spin_lock_irqsave(&async_lock, flags);
-       ret = __lowest_in_progress(running);
        spin_unlock_irqrestore(&async_lock, flags);
        return ret;
 }
@@ -120,12 +113,7 @@ static void async_run_entry_fn(struct work_struct *work)
        unsigned long flags;
        ktime_t uninitialized_var(calltime), delta, rettime;
 
-       /* 1) move self to the running queue */
-       spin_lock_irqsave(&async_lock, flags);
-       list_move_tail(&entry->list, entry->running);
-       spin_unlock_irqrestore(&async_lock, flags);
-
-       /* 2) run (and print duration) */
+       /* 1) run (and print duration) */
        if (initcall_debug && system_state == SYSTEM_BOOTING) {
                printk(KERN_DEBUG "calling  %lli_%pF @ %i\n",
                        (long long)entry->cookie,
@@ -142,21 +130,22 @@ static void async_run_entry_fn(struct work_struct *work)
                        (long long)ktime_to_ns(delta) >> 10);
        }
 
-       /* 3) remove self from the running queue */
+       /* 2) remove self from the pending queues */
        spin_lock_irqsave(&async_lock, flags);
-       list_del(&entry->list);
+       list_del_init(&entry->domain_list);
+       list_del_init(&entry->global_list);
 
-       /* 4) free the entry */
+       /* 3) free the entry */
        kfree(entry);
        atomic_dec(&entry_count);
 
        spin_unlock_irqrestore(&async_lock, flags);
 
-       /* 5) wake up any waiters */
+       /* 4) wake up any waiters */
        wake_up(&async_done);
 }
 
-static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct list_head *running)
+static async_cookie_t __async_schedule(async_func_t func, void *data, struct async_domain *domain)
 {
        struct async_entry *entry;
        unsigned long flags;
@@ -176,20 +165,31 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct l
                spin_unlock_irqrestore(&async_lock, flags);
 
                /* low on memory.. run synchronously */
-               ptr(data, newcookie);
+               func(data, newcookie);
                return newcookie;
        }
+       INIT_LIST_HEAD(&entry->domain_list);
+       INIT_LIST_HEAD(&entry->global_list);
        INIT_WORK(&entry->work, async_run_entry_fn);
-       entry->func = ptr;
+       entry->func = func;
        entry->data = data;
-       entry->running = running;
+       entry->domain = domain;
 
        spin_lock_irqsave(&async_lock, flags);
+
+       /* allocate cookie and queue */
        newcookie = entry->cookie = next_cookie++;
-       list_add_tail(&entry->list, &async_pending);
+
+       list_add_tail(&entry->domain_list, &domain->pending);
+       if (domain->registered)
+               list_add_tail(&entry->global_list, &async_global_pending);
+
        atomic_inc(&entry_count);
        spin_unlock_irqrestore(&async_lock, flags);
 
+       /* mark that this task has queued an async job, used by module init */
+       current->flags |= PF_USED_ASYNC;
+
        /* schedule for execution */
        queue_work(system_unbound_wq, &entry->work);
 
@@ -198,34 +198,34 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct l
 
 /**
  * async_schedule - schedule a function for asynchronous execution
- * @ptr: function to execute asynchronously
+ * @func: function to execute asynchronously
  * @data: data pointer to pass to the function
  *
  * Returns an async_cookie_t that may be used for checkpointing later.
  * Note: This function may be called from atomic or non-atomic contexts.
  */
-async_cookie_t async_schedule(async_func_ptr *ptr, void *data)
+async_cookie_t async_schedule(async_func_t func, void *data)
 {
-       return __async_schedule(ptr, data, &async_running);
+       return __async_schedule(func, data, &async_dfl_domain);
 }
 EXPORT_SYMBOL_GPL(async_schedule);
 
 /**
  * async_schedule_domain - schedule a function for asynchronous execution within a certain domain
- * @ptr: function to execute asynchronously
+ * @func: function to execute asynchronously
  * @data: data pointer to pass to the function
- * @running: running list for the domain
+ * @domain: the domain
  *
  * Returns an async_cookie_t that may be used for checkpointing later.
- * @running may be used in the async_synchronize_*_domain() functions
- * to wait within a certain synchronization domain rather than globally.
- * A synchronization domain is specified via the running queue @running to use.
- * Note: This function may be called from atomic or non-atomic contexts.
+ * @domain may be used in the async_synchronize_*_domain() functions to
+ * wait within a certain synchronization domain rather than globally.  A
+ * synchronization domain is specified via @domain.  Note: This function
+ * may be called from atomic or non-atomic contexts.
  */
-async_cookie_t async_schedule_domain(async_func_ptr *ptr, void *data,
-                                    struct list_head *running)
+async_cookie_t async_schedule_domain(async_func_t func, void *data,
+                                    struct async_domain *domain)
 {
-       return __async_schedule(ptr, data, running);
+       return __async_schedule(func, data, domain);
 }
 EXPORT_SYMBOL_GPL(async_schedule_domain);
 
@@ -236,36 +236,51 @@ EXPORT_SYMBOL_GPL(async_schedule_domain);
  */
 void async_synchronize_full(void)
 {
-       do {
-               async_synchronize_cookie(next_cookie);
-       } while (!list_empty(&async_running) || !list_empty(&async_pending));
+       async_synchronize_full_domain(NULL);
 }
 EXPORT_SYMBOL_GPL(async_synchronize_full);
 
 /**
+ * async_unregister_domain - ensure no more anonymous waiters on this domain
+ * @domain: idle domain to flush out of any async_synchronize_full instances
+ *
+ * async_synchronize_{cookie|full}_domain() are not flushed since callers
+ * of these routines should know the lifetime of @domain
+ *
+ * Prefer ASYNC_DOMAIN_EXCLUSIVE() declarations over flushing
+ */
+void async_unregister_domain(struct async_domain *domain)
+{
+       spin_lock_irq(&async_lock);
+       WARN_ON(!domain->registered || !list_empty(&domain->pending));
+       domain->registered = 0;
+       spin_unlock_irq(&async_lock);
+}
+EXPORT_SYMBOL_GPL(async_unregister_domain);
+
+/**
  * async_synchronize_full_domain - synchronize all asynchronous function within a certain domain
- * @list: running list to synchronize on
+ * @domain: the domain to synchronize
  *
  * This function waits until all asynchronous function calls for the
- * synchronization domain specified by the running list @list have been done.
+ * synchronization domain specified by @domain have been done.
  */
-void async_synchronize_full_domain(struct list_head *list)
+void async_synchronize_full_domain(struct async_domain *domain)
 {
-       async_synchronize_cookie_domain(next_cookie, list);
+       async_synchronize_cookie_domain(ASYNC_COOKIE_MAX, domain);
 }
 EXPORT_SYMBOL_GPL(async_synchronize_full_domain);
 
 /**
  * async_synchronize_cookie_domain - synchronize asynchronous function calls within a certain domain with cookie checkpointing
  * @cookie: async_cookie_t to use as checkpoint
- * @running: running list to synchronize on
+ * @domain: the domain to synchronize (%NULL for all registered domains)
  *
  * This function waits until all asynchronous function calls for the
- * synchronization domain specified by the running list @list submitted
- * prior to @cookie have been done.
+ * synchronization domain specified by @domain submitted prior to @cookie
+ * have been done.
  */
-void async_synchronize_cookie_domain(async_cookie_t cookie,
-                                    struct list_head *running)
+void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain)
 {
        ktime_t uninitialized_var(starttime), delta, endtime;
 
@@ -274,7 +289,7 @@ void async_synchronize_cookie_domain(async_cookie_t cookie,
                starttime = ktime_get();
        }
 
-       wait_event(async_done, lowest_in_progress(running) >= cookie);
+       wait_event(async_done, lowest_in_progress(domain) >= cookie);
 
        if (initcall_debug && system_state == SYSTEM_BOOTING) {
                endtime = ktime_get();
@@ -296,6 +311,18 @@ EXPORT_SYMBOL_GPL(async_synchronize_cookie_domain);
  */
 void async_synchronize_cookie(async_cookie_t cookie)
 {
-       async_synchronize_cookie_domain(cookie, &async_running);
+       async_synchronize_cookie_domain(cookie, &async_dfl_domain);
 }
 EXPORT_SYMBOL_GPL(async_synchronize_cookie);
+
+/**
+ * current_is_async - is %current an async worker task?
+ *
+ * Returns %true if %current is an async worker task.
+ */
+bool current_is_async(void)
+{
+       struct worker *worker = current_wq_worker();
+
+       return worker && worker->current_func == async_run_entry_fn;
+}