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/ktime.h>
  50 #include <linux/export.h>
  51 #include <linux/wait.h>
  52 #include <linux/sched.h>
  53 #include <linux/slab.h>
  54 #include <linux/workqueue.h>
  55
  56 #include "workqueue_internal.h"
  57
  58 static async_cookie_t next_cookie = 1;
  59
  60 #define MAX_WORK                32768
  61 #define ASYNC_COOKIE_MAX        ULLONG_MAX      /* infinity cookie */
  62
  63 static LIST_HEAD(async_global_pending); /* pending from all registered doms */
  64 static ASYNC_DOMAIN(async_dfl_domain);
  65 static DEFINE_SPINLOCK(async_lock);
  66
  67 struct async_entry {
  68         struct list_head        domain_list;
  69         struct list_head        global_list;
  70         struct work_struct      work;
  71         async_cookie_t          cookie;
  72         async_func_t            func;
  73         void                    *data;
  74         struct async_domain     *domain;
  75 };
  76
  77 static DECLARE_WAIT_QUEUE_HEAD(async_done);
  78
  79 static atomic_t entry_count;
  80
  81 static async_cookie_t lowest_in_progress(struct async_domain *domain)
  82 {
  83         struct async_entry *first = NULL;
  84         async_cookie_t ret = ASYNC_COOKIE_MAX;
  85         unsigned long flags;
  86
  87         spin_lock_irqsave(&async_lock, flags);
  88
  89         if (domain) {
  90                 if (!list_empty(&domain->pending))
  91                         first = list_first_entry(&domain->pending,
  92                                         struct async_entry, domain_list);
  93         } else {
  94                 if (!list_empty(&async_global_pending))
  95                         first = list_first_entry(&async_global_pending,
  96                                         struct async_entry, global_list);
  97         }
  98
  99         if (first)
 100                 ret = first->cookie;
 101
 102         spin_unlock_irqrestore(&async_lock, flags);
 103         return ret;
 104 }
 105
 106 /*
 107  * pick the first pending entry and run it
 108  */
 109 static void async_run_entry_fn(struct work_struct *work)
 110 {
 111         struct async_entry *entry =
 112                 container_of(work, struct async_entry, work);
 113         unsigned long flags;
 114         ktime_t calltime, delta, rettime;
 115
 116         /* 1) run (and print duration) */
 117         if (initcall_debug && system_state < SYSTEM_RUNNING) {
 118                 pr_debug("calling  %lli_%pS @ %i\n",
 119                         (long long)entry->cookie,
 120                         entry->func, task_pid_nr(current));
 121                 calltime = ktime_get();
 122         }
 123         entry->func(entry->data, entry->cookie);
 124         if (initcall_debug && system_state < SYSTEM_RUNNING) {
 125                 rettime = ktime_get();
 126                 delta = ktime_sub(rettime, calltime);
 127                 pr_debug("initcall %lli_%pS returned 0 after %lld usecs\n",
 128                         (long long)entry->cookie,
 129                         entry->func,
 130                         (long long)ktime_to_ns(delta) >> 10);
 131         }
 132
 133         /* 2) remove self from the pending queues */
 134         spin_lock_irqsave(&async_lock, flags);
 135         list_del_init(&entry->domain_list);
 136         list_del_init(&entry->global_list);
 137
 138         /* 3) free the entry */
 139         kfree(entry);
 140         atomic_dec(&entry_count);
 141
 142         spin_unlock_irqrestore(&async_lock, flags);
 143
 144         /* 4) wake up any waiters */
 145         wake_up(&async_done);
 146 }
 147
 148 static async_cookie_t __async_schedule_node_domain(async_func_t func,
 149                                                    void *data, int node,
 150                                                    struct async_domain *domain,
 151                                                    struct async_entry *entry)
 152 {
 153         async_cookie_t newcookie;
 154         unsigned long flags;
 155
 156         INIT_LIST_HEAD(&entry->domain_list);
 157         INIT_LIST_HEAD(&entry->global_list);
 158         INIT_WORK(&entry->work, async_run_entry_fn);
 159         entry->func = func;
 160         entry->data = data;
 161         entry->domain = domain;
 162
 163         spin_lock_irqsave(&async_lock, flags);
 164
 165         /* allocate cookie and queue */
 166         newcookie = entry->cookie = next_cookie++;
 167
 168         list_add_tail(&entry->domain_list, &domain->pending);
 169         if (domain->registered)
 170                 list_add_tail(&entry->global_list, &async_global_pending);
 171
 172         atomic_inc(&entry_count);
 173         spin_unlock_irqrestore(&async_lock, flags);
 174
 175         /* schedule for execution */
 176         queue_work_node(node, system_unbound_wq, &entry->work);
 177
 178         return newcookie;
 179 }
 180
 181 /**
 182  * async_schedule_node_domain - NUMA specific version of async_schedule_domain
 183  * @func: function to execute asynchronously
 184  * @data: data pointer to pass to the function
 185  * @node: NUMA node that we want to schedule this on or close to
 186  * @domain: the domain
 187  *
 188  * Returns an async_cookie_t that may be used for checkpointing later.
 189  * @domain may be used in the async_synchronize_*_domain() functions to
 190  * wait within a certain synchronization domain rather than globally.
 191  *
 192  * Note: This function may be called from atomic or non-atomic contexts.
 193  *
 194  * The node requested will be honored on a best effort basis. If the node
 195  * has no CPUs associated with it then the work is distributed among all
 196  * available CPUs.
 197  */
 198 async_cookie_t async_schedule_node_domain(async_func_t func, void *data,
 199                                           int node, struct async_domain *domain)
 200 {
 201         struct async_entry *entry;
 202         unsigned long flags;
 203         async_cookie_t newcookie;
 204
 205         /* allow irq-off callers */
 206         entry = kzalloc(sizeof(struct async_entry), GFP_ATOMIC);
 207
 208         /*
 209          * If we're out of memory or if there's too much work
 210          * pending already, we execute synchronously.
 211          */
 212         if (!entry || atomic_read(&entry_count) > MAX_WORK) {
 213                 kfree(entry);
 214                 spin_lock_irqsave(&async_lock, flags);
 215                 newcookie = next_cookie++;
 216                 spin_unlock_irqrestore(&async_lock, flags);
 217
 218                 /* low on memory.. run synchronously */
 219                 func(data, newcookie);
 220                 return newcookie;
 221         }
 222
 223         return __async_schedule_node_domain(func, data, node, domain, entry);
 224 }
 225 EXPORT_SYMBOL_GPL(async_schedule_node_domain);
 226
 227 /**
 228  * async_schedule_node - NUMA specific version of async_schedule
 229  * @func: function to execute asynchronously
 230  * @data: data pointer to pass to the function
 231  * @node: NUMA node that we want to schedule this on or close to
 232  *
 233  * Returns an async_cookie_t that may be used for checkpointing later.
 234  * Note: This function may be called from atomic or non-atomic contexts.
 235  *
 236  * The node requested will be honored on a best effort basis. If the node
 237  * has no CPUs associated with it then the work is distributed among all
 238  * available CPUs.
 239  */
 240 async_cookie_t async_schedule_node(async_func_t func, void *data, int node)
 241 {
 242         return async_schedule_node_domain(func, data, node, &async_dfl_domain);
 243 }
 244 EXPORT_SYMBOL_GPL(async_schedule_node);
 245
 246 /**
 247  * async_schedule_dev_nocall - A simplified variant of async_schedule_dev()
 248  * @func: function to execute asynchronously
 249  * @dev: device argument to be passed to function
 250  *
 251  * @dev is used as both the argument for the function and to provide NUMA
 252  * context for where to run the function.
 253  *
 254  * If the asynchronous execution of @func is scheduled successfully, return
 255  * true. Otherwise, do nothing and return false, unlike async_schedule_dev()
 256  * that will run the function synchronously then.
 257  */
 258 bool async_schedule_dev_nocall(async_func_t func, struct device *dev)
 259 {
 260         struct async_entry *entry;
 261
 262         entry = kzalloc(sizeof(struct async_entry), GFP_KERNEL);
 263
 264         /* Give up if there is no memory or too much work. */
 265         if (!entry || atomic_read(&entry_count) > MAX_WORK) {
 266                 kfree(entry);
 267                 return false;
 268         }
 269
 270         __async_schedule_node_domain(func, dev, dev_to_node(dev),
 271                                      &async_dfl_domain, entry);
 272         return true;
 273 }
 274
 275 /**
 276  * async_synchronize_full - synchronize all asynchronous function calls
 277  *
 278  * This function waits until all asynchronous function calls have been done.
 279  */
 280 void async_synchronize_full(void)
 281 {
 282         async_synchronize_full_domain(NULL);
 283 }
 284 EXPORT_SYMBOL_GPL(async_synchronize_full);
 285
 286 /**
 287  * async_unregister_domain - ensure no more anonymous waiters on this domain
 288  * @domain: idle domain to flush out of any async_synchronize_full instances
 289  *
 290  * async_synchronize_{cookie|full}_domain() are not flushed since callers
 291  * of these routines should know the lifetime of @domain
 292  *
 293  * Prefer ASYNC_DOMAIN_EXCLUSIVE() declarations over flushing
 294  */
 295 void async_unregister_domain(struct async_domain *domain)
 296 {
 297         spin_lock_irq(&async_lock);
 298         WARN_ON(!domain->registered || !list_empty(&domain->pending));
 299         domain->registered = 0;
 300         spin_unlock_irq(&async_lock);
 301 }
 302 EXPORT_SYMBOL_GPL(async_unregister_domain);
 303
 304 /**
 305  * async_synchronize_full_domain - synchronize all asynchronous function within a certain domain
 306  * @domain: the domain to synchronize
 307  *
 308  * This function waits until all asynchronous function calls for the
 309  * synchronization domain specified by @domain have been done.
 310  */
 311 void async_synchronize_full_domain(struct async_domain *domain)
 312 {
 313         async_synchronize_cookie_domain(ASYNC_COOKIE_MAX, domain);
 314 }
 315 EXPORT_SYMBOL_GPL(async_synchronize_full_domain);
 316
 317 /**
 318  * async_synchronize_cookie_domain - synchronize asynchronous function calls within a certain domain with cookie checkpointing
 319  * @cookie: async_cookie_t to use as checkpoint
 320  * @domain: the domain to synchronize (%NULL for all registered domains)
 321  *
 322  * This function waits until all asynchronous function calls for the
 323  * synchronization domain specified by @domain submitted prior to @cookie
 324  * have been done.
 325  */
 326 void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain)
 327 {
 328         ktime_t starttime, delta, endtime;
 329
 330         if (initcall_debug && system_state < SYSTEM_RUNNING) {
 331                 pr_debug("async_waiting @ %i\n", task_pid_nr(current));
 332                 starttime = ktime_get();
 333         }
 334
 335         wait_event(async_done, lowest_in_progress(domain) >= cookie);
 336
 337         if (initcall_debug && system_state < SYSTEM_RUNNING) {
 338                 endtime = ktime_get();
 339                 delta = ktime_sub(endtime, starttime);
 340
 341                 pr_debug("async_continuing @ %i after %lli usec\n",
 342                         task_pid_nr(current),
 343                         (long long)ktime_to_ns(delta) >> 10);
 344         }
 345 }
 346 EXPORT_SYMBOL_GPL(async_synchronize_cookie_domain);
 347
 348 /**
 349  * async_synchronize_cookie - synchronize asynchronous function calls with cookie checkpointing
 350  * @cookie: async_cookie_t to use as checkpoint
 351  *
 352  * This function waits until all asynchronous function calls prior to @cookie
 353  * have been done.
 354  */
 355 void async_synchronize_cookie(async_cookie_t cookie)
 356 {
 357         async_synchronize_cookie_domain(cookie, &async_dfl_domain);
 358 }
 359 EXPORT_SYMBOL_GPL(async_synchronize_cookie);
 360
 361 /**
 362  * current_is_async - is %current an async worker task?
 363  *
 364  * Returns %true if %current is an async worker task.
 365  */
 366 bool current_is_async(void)
 367 {
 368         struct worker *worker = current_wq_worker();
 369
 370         return worker && worker->current_func == async_run_entry_fn;
 371 }
 372 EXPORT_SYMBOL_GPL(current_is_async);