Commit ece8e0b2 authored by Linus Torvalds's avatar Linus Torvalds

Merge branch 'for-3.9-async' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq

Pull async changes from Tejun Heo:
 "These are followups for the earlier deadlock issue involving async
  ending up waiting for itself through block requesting module[1].  The
  following changes are made by these commits.

   - Instead of requesting default elevator on each request_queue init,
     block now requests it once early during boot.

   - Kmod triggers warning if invoked from an async worker.

   - Async synchronization implementation has been reimplemented.  It's
     a lot simpler now."

* 'for-3.9-async' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq:
  async: initialise list heads to fix crash
  async: replace list of active domains with global list of pending items
  async: keep pending tasks on async_domain and remove async_pending
  async: use ULLONG_MAX for infinity cookie value
  async: bring sanity to the use of words domain and running
  async, kmod: warn on synchronous request_module() from async workers
  block: don't request module during elevator init
  init, block: try to load default elevator module early during boot
parents 67cb104b a0327ff0
...@@ -100,14 +100,14 @@ static void elevator_put(struct elevator_type *e) ...@@ -100,14 +100,14 @@ static void elevator_put(struct elevator_type *e)
module_put(e->elevator_owner); module_put(e->elevator_owner);
} }
static struct elevator_type *elevator_get(const char *name) static struct elevator_type *elevator_get(const char *name, bool try_loading)
{ {
struct elevator_type *e; struct elevator_type *e;
spin_lock(&elv_list_lock); spin_lock(&elv_list_lock);
e = elevator_find(name); e = elevator_find(name);
if (!e) { if (!e && try_loading) {
spin_unlock(&elv_list_lock); spin_unlock(&elv_list_lock);
request_module("%s-iosched", name); request_module("%s-iosched", name);
spin_lock(&elv_list_lock); spin_lock(&elv_list_lock);
...@@ -136,6 +136,22 @@ static int __init elevator_setup(char *str) ...@@ -136,6 +136,22 @@ static int __init elevator_setup(char *str)
__setup("elevator=", elevator_setup); __setup("elevator=", elevator_setup);
/* called during boot to load the elevator chosen by the elevator param */
void __init load_default_elevator_module(void)
{
struct elevator_type *e;
if (!chosen_elevator[0])
return;
spin_lock(&elv_list_lock);
e = elevator_find(chosen_elevator);
spin_unlock(&elv_list_lock);
if (!e)
request_module("%s-iosched", chosen_elevator);
}
static struct kobj_type elv_ktype; static struct kobj_type elv_ktype;
static struct elevator_queue *elevator_alloc(struct request_queue *q, static struct elevator_queue *elevator_alloc(struct request_queue *q,
...@@ -191,25 +207,30 @@ int elevator_init(struct request_queue *q, char *name) ...@@ -191,25 +207,30 @@ int elevator_init(struct request_queue *q, char *name)
q->boundary_rq = NULL; q->boundary_rq = NULL;
if (name) { if (name) {
e = elevator_get(name); e = elevator_get(name, true);
if (!e) if (!e)
return -EINVAL; return -EINVAL;
} }
/*
* Use the default elevator specified by config boot param or
* config option. Don't try to load modules as we could be running
* off async and request_module() isn't allowed from async.
*/
if (!e && *chosen_elevator) { if (!e && *chosen_elevator) {
e = elevator_get(chosen_elevator); e = elevator_get(chosen_elevator, false);
if (!e) if (!e)
printk(KERN_ERR "I/O scheduler %s not found\n", printk(KERN_ERR "I/O scheduler %s not found\n",
chosen_elevator); chosen_elevator);
} }
if (!e) { if (!e) {
e = elevator_get(CONFIG_DEFAULT_IOSCHED); e = elevator_get(CONFIG_DEFAULT_IOSCHED, false);
if (!e) { if (!e) {
printk(KERN_ERR printk(KERN_ERR
"Default I/O scheduler not found. " \ "Default I/O scheduler not found. " \
"Using noop.\n"); "Using noop.\n");
e = elevator_get("noop"); e = elevator_get("noop", false);
} }
} }
...@@ -951,7 +972,7 @@ int elevator_change(struct request_queue *q, const char *name) ...@@ -951,7 +972,7 @@ int elevator_change(struct request_queue *q, const char *name)
return -ENXIO; return -ENXIO;
strlcpy(elevator_name, name, sizeof(elevator_name)); strlcpy(elevator_name, name, sizeof(elevator_name));
e = elevator_get(strstrip(elevator_name)); e = elevator_get(strstrip(elevator_name), true);
if (!e) { if (!e) {
printk(KERN_ERR "elevator: type %s not found\n", elevator_name); printk(KERN_ERR "elevator: type %s not found\n", elevator_name);
return -EINVAL; return -EINVAL;
......
...@@ -19,8 +19,7 @@ typedef u64 async_cookie_t; ...@@ -19,8 +19,7 @@ typedef u64 async_cookie_t;
typedef void (async_func_ptr) (void *data, async_cookie_t cookie); typedef void (async_func_ptr) (void *data, async_cookie_t cookie);
struct async_domain { struct async_domain {
struct list_head node; struct list_head node;
struct list_head domain; struct list_head pending;
int count;
unsigned registered:1; unsigned registered:1;
}; };
...@@ -29,8 +28,7 @@ struct async_domain { ...@@ -29,8 +28,7 @@ struct async_domain {
*/ */
#define ASYNC_DOMAIN(_name) \ #define ASYNC_DOMAIN(_name) \
struct async_domain _name = { .node = LIST_HEAD_INIT(_name.node), \ struct async_domain _name = { .node = LIST_HEAD_INIT(_name.node), \
.domain = LIST_HEAD_INIT(_name.domain), \ .pending = LIST_HEAD_INIT(_name.pending), \
.count = 0, \
.registered = 1 } .registered = 1 }
/* /*
...@@ -39,8 +37,7 @@ struct async_domain { ...@@ -39,8 +37,7 @@ struct async_domain {
*/ */
#define ASYNC_DOMAIN_EXCLUSIVE(_name) \ #define ASYNC_DOMAIN_EXCLUSIVE(_name) \
struct async_domain _name = { .node = LIST_HEAD_INIT(_name.node), \ struct async_domain _name = { .node = LIST_HEAD_INIT(_name.node), \
.domain = LIST_HEAD_INIT(_name.domain), \ .pending = LIST_HEAD_INIT(_name.pending), \
.count = 0, \
.registered = 0 } .registered = 0 }
extern async_cookie_t async_schedule(async_func_ptr *ptr, void *data); extern async_cookie_t async_schedule(async_func_ptr *ptr, void *data);
......
...@@ -138,6 +138,7 @@ extern void elv_drain_elevator(struct request_queue *); ...@@ -138,6 +138,7 @@ extern void elv_drain_elevator(struct request_queue *);
/* /*
* io scheduler registration * io scheduler registration
*/ */
extern void __init load_default_elevator_module(void);
extern int elv_register(struct elevator_type *); extern int elv_register(struct elevator_type *);
extern void elv_unregister(struct elevator_type *); extern void elv_unregister(struct elevator_type *);
...@@ -206,5 +207,9 @@ enum { ...@@ -206,5 +207,9 @@ enum {
INIT_LIST_HEAD(&(rq)->csd.list); \ INIT_LIST_HEAD(&(rq)->csd.list); \
} while (0) } while (0)
#else /* CONFIG_BLOCK */
static inline void load_default_elevator_module(void) { }
#endif /* CONFIG_BLOCK */ #endif /* CONFIG_BLOCK */
#endif #endif
...@@ -153,6 +153,7 @@ extern unsigned int reset_devices; ...@@ -153,6 +153,7 @@ extern unsigned int reset_devices;
/* used by init/main.c */ /* used by init/main.c */
void setup_arch(char **); void setup_arch(char **);
void prepare_namespace(void); void prepare_namespace(void);
void __init load_default_modules(void);
extern void (*late_time_init)(void); extern void (*late_time_init)(void);
......
...@@ -61,6 +61,9 @@ static void __init handle_initrd(void) ...@@ -61,6 +61,9 @@ static void __init handle_initrd(void)
sys_mkdir("/old", 0700); sys_mkdir("/old", 0700);
sys_chdir("/old"); sys_chdir("/old");
/* try loading default modules from initrd */
load_default_modules();
/* /*
* In case that a resume from disk is carried out by linuxrc or one of * In case that a resume from disk is carried out by linuxrc or one of
* its children, we need to tell the freezer not to wait for us. * its children, we need to tell the freezer not to wait for us.
......
...@@ -592,7 +592,7 @@ static int __init populate_rootfs(void) ...@@ -592,7 +592,7 @@ static int __init populate_rootfs(void)
initrd_end - initrd_start); initrd_end - initrd_start);
if (!err) { if (!err) {
free_initrd(); free_initrd();
return 0; goto done;
} else { } else {
clean_rootfs(); clean_rootfs();
unpack_to_rootfs(__initramfs_start, __initramfs_size); unpack_to_rootfs(__initramfs_start, __initramfs_size);
...@@ -607,6 +607,7 @@ static int __init populate_rootfs(void) ...@@ -607,6 +607,7 @@ static int __init populate_rootfs(void)
sys_close(fd); sys_close(fd);
free_initrd(); free_initrd();
} }
done:
#else #else
printk(KERN_INFO "Unpacking initramfs...\n"); printk(KERN_INFO "Unpacking initramfs...\n");
err = unpack_to_rootfs((char *)initrd_start, err = unpack_to_rootfs((char *)initrd_start,
...@@ -615,6 +616,11 @@ static int __init populate_rootfs(void) ...@@ -615,6 +616,11 @@ static int __init populate_rootfs(void)
printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err); printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err);
free_initrd(); free_initrd();
#endif #endif
/*
* Try loading default modules from initramfs. This gives
* us a chance to load before device_initcalls.
*/
load_default_modules();
} }
return 0; return 0;
} }
......
...@@ -70,6 +70,8 @@ ...@@ -70,6 +70,8 @@
#include <linux/perf_event.h> #include <linux/perf_event.h>
#include <linux/file.h> #include <linux/file.h>
#include <linux/ptrace.h> #include <linux/ptrace.h>
#include <linux/blkdev.h>
#include <linux/elevator.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/bugs.h> #include <asm/bugs.h>
...@@ -794,6 +796,17 @@ static void __init do_pre_smp_initcalls(void) ...@@ -794,6 +796,17 @@ static void __init do_pre_smp_initcalls(void)
do_one_initcall(*fn); do_one_initcall(*fn);
} }
/*
* This function requests modules which should be loaded by default and is
* called twice right after initrd is mounted and right before init is
* exec'd. If such modules are on either initrd or rootfs, they will be
* loaded before control is passed to userland.
*/
void __init load_default_modules(void)
{
load_default_elevator_module();
}
static int run_init_process(const char *init_filename) static int run_init_process(const char *init_filename)
{ {
argv_init[0] = init_filename; argv_init[0] = init_filename;
...@@ -900,4 +913,7 @@ static noinline void __init kernel_init_freeable(void) ...@@ -900,4 +913,7 @@ static noinline void __init kernel_init_freeable(void)
* we're essentially up and running. Get rid of the * we're essentially up and running. Get rid of the
* initmem segments and start the user-mode stuff.. * initmem segments and start the user-mode stuff..
*/ */
/* rootfs is available now, try loading default modules */
load_default_modules();
} }
...@@ -61,63 +61,48 @@ asynchronous and synchronous parts of the kernel. ...@@ -61,63 +61,48 @@ asynchronous and synchronous parts of the kernel.
static async_cookie_t next_cookie = 1; 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_global_pending); /* pending from all registered doms */
static ASYNC_DOMAIN(async_running); static ASYNC_DOMAIN(async_dfl_domain);
static LIST_HEAD(async_domains);
static DEFINE_SPINLOCK(async_lock); static DEFINE_SPINLOCK(async_lock);
static DEFINE_MUTEX(async_register_mutex);
struct async_entry { struct async_entry {
struct list_head list; struct list_head domain_list;
struct list_head global_list;
struct work_struct work; struct work_struct work;
async_cookie_t cookie; async_cookie_t cookie;
async_func_ptr *func; async_func_ptr *func;
void *data; void *data;
struct async_domain *running; struct async_domain *domain;
}; };
static DECLARE_WAIT_QUEUE_HEAD(async_done); static DECLARE_WAIT_QUEUE_HEAD(async_done);
static atomic_t entry_count; static atomic_t entry_count;
static async_cookie_t lowest_in_progress(struct async_domain *domain)
/*
* MUST be called with the lock held!
*/
static async_cookie_t __lowest_in_progress(struct async_domain *running)
{ {
async_cookie_t first_running = next_cookie; /* infinity value */ struct async_entry *first = NULL;
async_cookie_t first_pending = next_cookie; /* ditto */ async_cookie_t ret = ASYNC_COOKIE_MAX;
struct async_entry *entry; unsigned long flags;
/* spin_lock_irqsave(&async_lock, flags);
* Both running and pending lists are sorted but not disjoint.
* Take the first cookies from both and return the min.
*/
if (!list_empty(&running->domain)) {
entry = list_first_entry(&running->domain, typeof(*entry), list);
first_running = entry->cookie;
}
list_for_each_entry(entry, &async_pending, list) { if (domain) {
if (entry->running == running) { if (!list_empty(&domain->pending))
first_pending = entry->cookie; first = list_first_entry(&domain->pending,
break; struct async_entry, domain_list);
} } else {
if (!list_empty(&async_global_pending))
first = list_first_entry(&async_global_pending,
struct async_entry, global_list);
} }
return min(first_running, first_pending); if (first)
} ret = first->cookie;
static async_cookie_t lowest_in_progress(struct async_domain *running)
{
unsigned long flags;
async_cookie_t ret;
spin_lock_irqsave(&async_lock, flags);
ret = __lowest_in_progress(running);
spin_unlock_irqrestore(&async_lock, flags); spin_unlock_irqrestore(&async_lock, flags);
return ret; return ret;
} }
...@@ -129,20 +114,10 @@ static void async_run_entry_fn(struct work_struct *work) ...@@ -129,20 +114,10 @@ static void async_run_entry_fn(struct work_struct *work)
{ {
struct async_entry *entry = struct async_entry *entry =
container_of(work, struct async_entry, work); container_of(work, struct async_entry, work);
struct async_entry *pos;
unsigned long flags; unsigned long flags;
ktime_t uninitialized_var(calltime), delta, rettime; ktime_t uninitialized_var(calltime), delta, rettime;
struct async_domain *running = entry->running;
/* 1) move self to the running queue, make sure it stays sorted */
spin_lock_irqsave(&async_lock, flags);
list_for_each_entry_reverse(pos, &running->domain, list)
if (entry->cookie < pos->cookie)
break;
list_move_tail(&entry->list, &pos->list);
spin_unlock_irqrestore(&async_lock, flags);
/* 2) run (and print duration) */ /* 1) run (and print duration) */
if (initcall_debug && system_state == SYSTEM_BOOTING) { if (initcall_debug && system_state == SYSTEM_BOOTING) {
printk(KERN_DEBUG "calling %lli_%pF @ %i\n", printk(KERN_DEBUG "calling %lli_%pF @ %i\n",
(long long)entry->cookie, (long long)entry->cookie,
...@@ -159,23 +134,22 @@ static void async_run_entry_fn(struct work_struct *work) ...@@ -159,23 +134,22 @@ static void async_run_entry_fn(struct work_struct *work)
(long long)ktime_to_ns(delta) >> 10); (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); spin_lock_irqsave(&async_lock, flags);
list_del(&entry->list); list_del_init(&entry->domain_list);
if (running->registered && --running->count == 0) list_del_init(&entry->global_list);
list_del_init(&running->node);
/* 4) free the entry */ /* 3) free the entry */
kfree(entry); kfree(entry);
atomic_dec(&entry_count); atomic_dec(&entry_count);
spin_unlock_irqrestore(&async_lock, flags); spin_unlock_irqrestore(&async_lock, flags);
/* 5) wake up any waiters */ /* 4) wake up any waiters */
wake_up(&async_done); wake_up(&async_done);
} }
static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct async_domain *running) static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct async_domain *domain)
{ {
struct async_entry *entry; struct async_entry *entry;
unsigned long flags; unsigned long flags;
...@@ -198,16 +172,22 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct a ...@@ -198,16 +172,22 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct a
ptr(data, newcookie); ptr(data, newcookie);
return newcookie; return newcookie;
} }
INIT_LIST_HEAD(&entry->domain_list);
INIT_LIST_HEAD(&entry->global_list);
INIT_WORK(&entry->work, async_run_entry_fn); INIT_WORK(&entry->work, async_run_entry_fn);
entry->func = ptr; entry->func = ptr;
entry->data = data; entry->data = data;
entry->running = running; entry->domain = domain;
spin_lock_irqsave(&async_lock, flags); spin_lock_irqsave(&async_lock, flags);
/* allocate cookie and queue */
newcookie = entry->cookie = next_cookie++; newcookie = entry->cookie = next_cookie++;
list_add_tail(&entry->list, &async_pending);
if (running->registered && running->count++ == 0) list_add_tail(&entry->domain_list, &domain->pending);
list_add_tail(&running->node, &async_domains); if (domain->registered)
list_add_tail(&entry->global_list, &async_global_pending);
atomic_inc(&entry_count); atomic_inc(&entry_count);
spin_unlock_irqrestore(&async_lock, flags); spin_unlock_irqrestore(&async_lock, flags);
...@@ -230,7 +210,7 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct a ...@@ -230,7 +210,7 @@ static async_cookie_t __async_schedule(async_func_ptr *ptr, void *data, struct a
*/ */
async_cookie_t async_schedule(async_func_ptr *ptr, void *data) async_cookie_t async_schedule(async_func_ptr *ptr, void *data)
{ {
return __async_schedule(ptr, data, &async_running); return __async_schedule(ptr, data, &async_dfl_domain);
} }
EXPORT_SYMBOL_GPL(async_schedule); EXPORT_SYMBOL_GPL(async_schedule);
...@@ -238,18 +218,18 @@ EXPORT_SYMBOL_GPL(async_schedule); ...@@ -238,18 +218,18 @@ EXPORT_SYMBOL_GPL(async_schedule);
* async_schedule_domain - schedule a function for asynchronous execution within a certain domain * async_schedule_domain - schedule a function for asynchronous execution within a certain domain
* @ptr: function to execute asynchronously * @ptr: function to execute asynchronously
* @data: data pointer to pass to the function * @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. * Returns an async_cookie_t that may be used for checkpointing later.
* @running may be used in the async_synchronize_*_domain() functions * @domain may be used in the async_synchronize_*_domain() functions to
* to wait within a certain synchronization domain rather than globally. * wait within a certain synchronization domain rather than globally. A
* A synchronization domain is specified via the running queue @running to use. * synchronization domain is specified via @domain. Note: This function
* Note: This function may be called from atomic or non-atomic contexts. * may be called from atomic or non-atomic contexts.
*/ */
async_cookie_t async_schedule_domain(async_func_ptr *ptr, void *data, async_cookie_t async_schedule_domain(async_func_ptr *ptr, void *data,
struct async_domain *running) struct async_domain *domain)
{ {
return __async_schedule(ptr, data, running); return __async_schedule(ptr, data, domain);
} }
EXPORT_SYMBOL_GPL(async_schedule_domain); EXPORT_SYMBOL_GPL(async_schedule_domain);
...@@ -260,18 +240,7 @@ EXPORT_SYMBOL_GPL(async_schedule_domain); ...@@ -260,18 +240,7 @@ EXPORT_SYMBOL_GPL(async_schedule_domain);
*/ */
void async_synchronize_full(void) void async_synchronize_full(void)
{ {
mutex_lock(&async_register_mutex); async_synchronize_full_domain(NULL);
do {
struct async_domain *domain = NULL;
spin_lock_irq(&async_lock);
if (!list_empty(&async_domains))
domain = list_first_entry(&async_domains, typeof(*domain), node);
spin_unlock_irq(&async_lock);
async_synchronize_cookie_domain(next_cookie, domain);
} while (!list_empty(&async_domains));
mutex_unlock(&async_register_mutex);
} }
EXPORT_SYMBOL_GPL(async_synchronize_full); EXPORT_SYMBOL_GPL(async_synchronize_full);
...@@ -286,51 +255,45 @@ EXPORT_SYMBOL_GPL(async_synchronize_full); ...@@ -286,51 +255,45 @@ EXPORT_SYMBOL_GPL(async_synchronize_full);
*/ */
void async_unregister_domain(struct async_domain *domain) void async_unregister_domain(struct async_domain *domain)
{ {
mutex_lock(&async_register_mutex);
spin_lock_irq(&async_lock); spin_lock_irq(&async_lock);
WARN_ON(!domain->registered || !list_empty(&domain->node) || WARN_ON(!domain->registered || !list_empty(&domain->pending));
!list_empty(&domain->domain));
domain->registered = 0; domain->registered = 0;
spin_unlock_irq(&async_lock); spin_unlock_irq(&async_lock);
mutex_unlock(&async_register_mutex);
} }
EXPORT_SYMBOL_GPL(async_unregister_domain); EXPORT_SYMBOL_GPL(async_unregister_domain);
/** /**
* async_synchronize_full_domain - synchronize all asynchronous function within a certain domain * async_synchronize_full_domain - synchronize all asynchronous function within a certain domain
* @domain: running list to synchronize on * @domain: the domain to synchronize
* *
* This function waits until all asynchronous function calls for the * This function waits until all asynchronous function calls for the
* synchronization domain specified by the running list @domain have been done. * synchronization domain specified by @domain have been done.
*/ */
void async_synchronize_full_domain(struct async_domain *domain) void async_synchronize_full_domain(struct async_domain *domain)
{ {
async_synchronize_cookie_domain(next_cookie, domain); async_synchronize_cookie_domain(ASYNC_COOKIE_MAX, domain);
} }
EXPORT_SYMBOL_GPL(async_synchronize_full_domain); EXPORT_SYMBOL_GPL(async_synchronize_full_domain);
/** /**
* async_synchronize_cookie_domain - synchronize asynchronous function calls within a certain domain with cookie checkpointing * async_synchronize_cookie_domain - synchronize asynchronous function calls within a certain domain with cookie checkpointing
* @cookie: async_cookie_t to use as checkpoint * @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 * This function waits until all asynchronous function calls for the
* synchronization domain specified by running list @running submitted * synchronization domain specified by @domain submitted prior to @cookie
* prior to @cookie have been done. * have been done.
*/ */
void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *running) void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain)
{ {
ktime_t uninitialized_var(starttime), delta, endtime; ktime_t uninitialized_var(starttime), delta, endtime;
if (!running)
return;
if (initcall_debug && system_state == SYSTEM_BOOTING) { if (initcall_debug && system_state == SYSTEM_BOOTING) {
printk(KERN_DEBUG "async_waiting @ %i\n", task_pid_nr(current)); printk(KERN_DEBUG "async_waiting @ %i\n", task_pid_nr(current));
starttime = ktime_get(); 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) { if (initcall_debug && system_state == SYSTEM_BOOTING) {
endtime = ktime_get(); endtime = ktime_get();
...@@ -352,7 +315,7 @@ EXPORT_SYMBOL_GPL(async_synchronize_cookie_domain); ...@@ -352,7 +315,7 @@ EXPORT_SYMBOL_GPL(async_synchronize_cookie_domain);
*/ */
void async_synchronize_cookie(async_cookie_t cookie) 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); EXPORT_SYMBOL_GPL(async_synchronize_cookie);
......
...@@ -38,6 +38,7 @@ ...@@ -38,6 +38,7 @@
#include <linux/suspend.h> #include <linux/suspend.h>
#include <linux/rwsem.h> #include <linux/rwsem.h>
#include <linux/ptrace.h> #include <linux/ptrace.h>
#include <linux/async.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <trace/events/module.h> #include <trace/events/module.h>
...@@ -130,6 +131,14 @@ int __request_module(bool wait, const char *fmt, ...) ...@@ -130,6 +131,14 @@ int __request_module(bool wait, const char *fmt, ...)
#define MAX_KMOD_CONCURRENT 50 /* Completely arbitrary value - KAO */ #define MAX_KMOD_CONCURRENT 50 /* Completely arbitrary value - KAO */
static int kmod_loop_msg; static int kmod_loop_msg;
/*
* We don't allow synchronous module loading from async. Module
* init may invoke async_synchronize_full() which will end up
* waiting for this task which already is waiting for the module
* loading to complete, leading to a deadlock.
*/
WARN_ON_ONCE(wait && current_is_async());
va_start(args, fmt); va_start(args, fmt);
ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args); ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
va_end(args); va_end(args);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment