kernel/async.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * async.c: Asynchronous function calls for boot performance
   4  *
   5  * (C) Copyright 2009 Intel Corporation
   6  * Author: Arjan van de Ven <arjan@linux.intel.com>
   7  */
   8
   9
  10 /*
  11
  12 Goals and Theory of Operation
  13
  14 The primary goal of this feature is to reduce the kernel boot time,
  15 by doing various independent hardware delays and discovery operations
  16 decoupled and not strictly serialized.
  17
  18 More specifically, the asynchronous function call concept allows
  19 certain operations (primarily during system boot) to happen
  20 asynchronously, out of order, while these operations still
  21 have their externally visible parts happen sequentially and in-order.
  22 (not unlike how out-of-order CPUs retire their instructions in order)
  23
  24 Key to the asynchronous function call implementation is the concept of
  25 a "sequence cookie" (which, although it has an abstracted type, can be
  26 thought of as a monotonically incrementing number).
  27
  28 The async core will assign each scheduled event such a sequence cookie and
  29 pass this to the called functions.
  30
  31 The asynchronously called function should before doing a globally visible
  32 operation, such as registering device numbers, call the
  33 async_synchronize_cookie() function and pass in its own cookie. The
  34 async_synchronize_cookie() function will make sure that all asynchronous
  35 operations that were scheduled prior to the operation corresponding with the
  36 cookie have completed.
  37
  38 Subsystem/driver initialization code that scheduled asynchronous probe
  39 functions, but which shares global resources with other drivers/subsystems
  40 that do not use the asynchronous call feature, need to do a full
  41 synchronization with the async_synchronize_full() function, before returning
  42 from their init function. This is to maintain strict ordering between the
  43 asynchronous and synchronous parts of the kernel.
  44
  45 */
  46
  47 #include <linux/async.h>
  48 #include <linux/atomic.h>
  49 #include <linux/export.h>
  50 #include <linux/ktime.h>
  51 #include <linux/pid.h>
  52 #include <linux/sched.h>
  53 #include <linux/slab.h>
  54 #include <linux/wait.h>
  55 #include <linux/workqueue.h>
  56
  57 #include "workqueue_internal.h"
  58
  59 static async_cookie_t next_cookie = 1;
  60
  61 #define MAX_WORK                32768
  62 #define ASYNC_COOKIE_MAX        ULLONG_MAX      /* infinity cookie */
  63
  64 static LIST_HEAD(async_global_pending); /* pending from all registered doms */
  65 static ASYNC_DOMAIN(async_dfl_domain);
  66 static DEFINE_SPINLOCK(async_lock);
  67
  68 struct async_entry {
  69         struct list_head        domain_list;
  70         struct list_head        global_list;
  71         struct work_struct      work;
  72         async_cookie_t          cookie;
  73         async_func_t            func;
  74         void                    *data;
  75         struct async_domain     *domain;
  76 };
  77
  78 static DECLARE_WAIT_QUEUE_HEAD(async_done);
  79
  80 static atomic_t entry_count;
  81
  82 static long long microseconds_since(ktime_t start)
  83 {
  84         ktime_t now = ktime_get();
  85         return ktime_to_ns(ktime_sub(now, start)) >> 10;
  86 }
  87
  88 static async_cookie_t lowest_in_progress(struct async_domain *domain)
  89 {
  90         struct async_entry *first = NULL;
  91         async_cookie_t ret = ASYNC_COOKIE_MAX;
  92         unsigned long flags;
  93
  94         spin_lock_irqsave(&async_lock, flags);
  95
  96         if (domain) {
  97                 if (!list_empty(&domain->pending))
  98                         first = list_first_entry(&domain->pending,
  99                                         struct async_entry, domain_list);
 100         } else {
 101                 if (!list_empty(&async_global_pending))
 102                         first = list_first_entry(&async_global_pending,
 103                                         struct async_entry, global_list);
 104         }
 105
 106         if (first)
 107                 ret = first->cookie;
 108
 109         spin_unlock_irqrestore(&async_lock, flags);
 110         return ret;
 111 }
 112
 113 /*
 114  * pick the first pending entry and run it
 115  */
 116 static void async_run_entry_fn(struct work_struct *work)
 117 {
 118         struct async_entry *entry =
 119                 container_of(work, struct async_entry, work);
 120         unsigned long flags;
 121         ktime_t calltime;
 122
 123         /* 1) run (and print duration) */
 124         pr_debug("calling  %lli_%pS @ %i\n", (long long)entry->cookie,
 125                  entry->func, task_pid_nr(current));
 126         calltime = ktime_get();
 127
 128         entry->func(entry->data, entry->cookie);
 129
 130         pr_debug("initcall %lli_%pS returned after %lld usecs\n",
 131                  (long long)entry->cookie, entry->func,
 132                  microseconds_since(calltime));
 133
 134         /* 2) remove self from the pending queues */
 135         spin_lock_irqsave(&async_lock, flags);
 136         list_del_init(&entry->domain_list);
 137         list_del_init(&entry->global_list);
 138
 139         /* 3) free the entry */
 140         kfree(entry);
 141         atomic_dec(&entry_count);
 142
 143         spin_unlock_irqrestore(&async_lock, flags);
 144
 145         /* 4) wake up any waiters */
 146         wake_up(&async_done);
 147 }
 148
 149 static async_cookie_t __async_schedule_node_domain(async_func_t func,
 150                                                    void *data, int node,
 151                                                    struct async_domain *domain,
 152                                                    struct async_entry *entry)
 153 {
 154         async_cookie_t newcookie;
 155         unsigned long flags;
 156
 157         INIT_LIST_HEAD(&entry->domain_list);
 158         INIT_LIST_HEAD(&entry->global_list);
 159         INIT_WORK(&entry->work, async_run_entry_fn);
 160         entry->func = func;
 161         entry->data = data;
 162         entry->domain = domain;
 163
 164         spin_lock_irqsave(&async_lock, flags);
 165
 166         /* allocate cookie and queue */
 167         newcookie = entry->cookie = next_cookie++;
 168
 169         list_add_tail(&entry->domain_list, &domain->pending);
 170         if (domain->registered)
 171                 list_add_tail(&entry->global_list, &async_global_pending);
 172
 173         atomic_inc(&entry_count);
 174         spin_unlock_irqrestore(&async_lock, flags);
 175
 176         /* schedule for execution */
 177         queue_work_node(node, system_unbound_wq, &entry->work);
 178
 179         return newcookie;
 180 }
 181
 182 /**
 183  * async_schedule_node_domain - NUMA specific version of async_schedule_domain
 184  * @func: function to execute asynchronously
 185  * @data: data pointer to pass to the function
 186  * @node: NUMA node that we want to schedule this on or close to
 187  * @domain: the domain
 188  *
 189  * Returns an async_cookie_t that may be used for checkpointing later.
 190  * @domain may be used in the async_synchronize_*_domain() functions to
 191  * wait within a certain synchronization domain rather than globally.
 192  *
 193  * Note: This function may be called from atomic or non-atomic contexts.
 194  *
 195  * The node requested will be honored on a best effort basis. If the node
 196  * has no CPUs associated with it then the work is distributed among all
 197  * available CPUs.
 198  */
 199 async_cookie_t async_schedule_node_domain(async_func_t func, void *data,
 200                                           int node, struct async_domain *domain)
 201 {
 202         struct async_entry *entry;
 203         unsigned long flags;
 204         async_cookie_t newcookie;
 205
 206         /* allow irq-off callers */
 207         entry = kzalloc(sizeof(struct async_entry), GFP_ATOMIC);
 208
 209         /*
 210          * If we're out of memory or if there's too much work
 211          * pending already, we execute synchronously.
 212          */
 213         if (!entry || atomic_read(&entry_count) > MAX_WORK) {
 214                 kfree(entry);
 215                 spin_lock_irqsave(&async_lock, flags);
 216                 newcookie = next_cookie++;
 217                 spin_unlock_irqrestore(&async_lock, flags);
 218
 219                 /* low on memory.. run synchronously */
 220                 func(data, newcookie);
 221                 return newcookie;
 222         }
 223
 224         return __async_schedule_node_domain(func, data, node, domain, entry);
 225 }
 226 EXPORT_SYMBOL_GPL(async_schedule_node_domain);
 227
 228 /**
 229  * async_schedule_node - NUMA specific version of async_schedule
 230  * @func: function to execute asynchronously
 231  * @data: data pointer to pass to the function
 232  * @node: NUMA node that we want to schedule this on or close to
 233  *
 234  * Returns an async_cookie_t that may be used for checkpointing later.
 235  * Note: This function may be called from atomic or non-atomic contexts.
 236  *
 237  * The node requested will be honored on a best effort basis. If the node
 238  * has no CPUs associated with it then the work is distributed among all
 239  * available CPUs.
 240  */
 241 async_cookie_t async_schedule_node(async_func_t func, void *data, int node)
 242 {
 243         return async_schedule_node_domain(func, data, node, &async_dfl_domain);
 244 }
 245 EXPORT_SYMBOL_GPL(async_schedule_node);
 246
 247 /**
 248  * async_schedule_dev_nocall - A simplified variant of async_schedule_dev()
 249  * @func: function to execute asynchronously
 250  * @dev: device argument to be passed to function
 251  *
 252  * @dev is used as both the argument for the function and to provide NUMA
 253  * context for where to run the function.
 254  *
 255  * If the asynchronous execution of @func is scheduled successfully, return
 256  * true. Otherwise, do nothing and return false, unlike async_schedule_dev()
 257  * that will run the function synchronously then.
 258  */
 259 bool async_schedule_dev_nocall(async_func_t func, struct device *dev)
 260 {
 261         struct async_entry *entry;
 262
 263         entry = kzalloc(sizeof(struct async_entry), GFP_KERNEL);
 264
 265         /* Give up if there is no memory or too much work. */
 266         if (!entry || atomic_read(&entry_count) > MAX_WORK) {
 267                 kfree(entry);
 268                 return false;
 269         }
 270
 271         __async_schedule_node_domain(func, dev, dev_to_node(dev),
 272                                      &async_dfl_domain, entry);
 273         return true;
 274 }
 275
 276 /**
 277  * async_synchronize_full - synchronize all asynchronous function calls
 278  *
 279  * This function waits until all asynchronous function calls have been done.
 280  */
 281 void async_synchronize_full(void)
 282 {
 283         async_synchronize_full_domain(NULL);
 284 }
 285 EXPORT_SYMBOL_GPL(async_synchronize_full);
 286
 287 /**
 288  * async_synchronize_full_domain - synchronize all asynchronous function within a certain domain
 289  * @domain: the domain to synchronize
 290  *
 291  * This function waits until all asynchronous function calls for the
 292  * synchronization domain specified by @domain have been done.
 293  */
 294 void async_synchronize_full_domain(struct async_domain *domain)
 295 {
 296         async_synchronize_cookie_domain(ASYNC_COOKIE_MAX, domain);
 297 }
 298 EXPORT_SYMBOL_GPL(async_synchronize_full_domain);
 299
 300 /**
 301  * async_synchronize_cookie_domain - synchronize asynchronous function calls within a certain domain with cookie checkpointing
 302  * @cookie: async_cookie_t to use as checkpoint
 303  * @domain: the domain to synchronize (%NULL for all registered domains)
 304  *
 305  * This function waits until all asynchronous function calls for the
 306  * synchronization domain specified by @domain submitted prior to @cookie
 307  * have been done.
 308  */
 309 void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain)
 310 {
 311         ktime_t starttime;
 312
 313         pr_debug("async_waiting @ %i\n", task_pid_nr(current));
 314         starttime = ktime_get();
 315
 316         wait_event(async_done, lowest_in_progress(domain) >= cookie);
 317
 318         pr_debug("async_continuing @ %i after %lli usec\n", task_pid_nr(current),
 319                  microseconds_since(starttime));
 320 }
 321 EXPORT_SYMBOL_GPL(async_synchronize_cookie_domain);
 322
 323 /**
 324  * async_synchronize_cookie - synchronize asynchronous function calls with cookie checkpointing
 325  * @cookie: async_cookie_t to use as checkpoint
 326  *
 327  * This function waits until all asynchronous function calls prior to @cookie
 328  * have been done.
 329  */
 330 void async_synchronize_cookie(async_cookie_t cookie)
 331 {
 332         async_synchronize_cookie_domain(cookie, &async_dfl_domain);
 333 }
 334 EXPORT_SYMBOL_GPL(async_synchronize_cookie);
 335
 336 /**
 337  * current_is_async - is %current an async worker task?
 338  *
 339  * Returns %true if %current is an async worker task.
 340  */
 341 bool current_is_async(void)
 342 {
 343         struct worker *worker = current_wq_worker();
 344
 345         return worker && worker->current_func == async_run_entry_fn;
 346 }
 347 EXPORT_SYMBOL_GPL(current_is_async);