fb: rework locking to fix lock ordering on takeover

Adjust the console layer to allow a take over call where the caller
already holds the locks.  Make the fb layer lock in order.

This is partly a band aid, the fb layer is terminally confused about the
locking rules it uses for its notifiers it seems.

[akpm@linux-foundation.org: remove stray non-ascii char, tidy comment]
[akpm@linux-foundation.org: export do_take_over_console()]
[airlied: cleanup another non-ascii char]
Signed-off-by: Alan Cox <alan@linux.intel.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: stable <stable@vger.kernel.org>
Tested-by: Sedat Dilek <sedat.dilek@gmail.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Dave Airlie <airlied@redhat.com>

diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
index 8fd89687d068e58b5546a153f8ea894c32782f47..c076af0b300bc805934087f498bf8f443d85cf64 100644 (file)
--- a/drivers/tty/vt/vt.c
+++ b/drivers/tty/vt/vt.c
@@ -2987,7 +2987,7 @@ int __init vty_init(const struct file_operations *console_fops)
 
 static struct class *vtconsole_class;
 
-static int bind_con_driver(const struct consw *csw, int first, int last,
+static int do_bind_con_driver(const struct consw *csw, int first, int last,
                           int deflt)
 {
        struct module *owner = csw->owner;
@@ -2998,7 +2998,7 @@ static int bind_con_driver(const struct consw *csw, int first, int last,
        if (!try_module_get(owner))
                return -ENODEV;
 
-       console_lock();
+       WARN_CONSOLE_UNLOCKED();
 
        /* check if driver is registered */
        for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
@@ -3083,11 +3083,22 @@ static int bind_con_driver(const struct consw *csw, int first, int last,
 
        retval = 0;
 err:
-       console_unlock();
        module_put(owner);
        return retval;
 };
 
+
+static int bind_con_driver(const struct consw *csw, int first, int last,
+                          int deflt)
+{
+       int ret;
+
+       console_lock();
+       ret = do_bind_con_driver(csw, first, last, deflt);
+       console_unlock();
+       return ret;
+}
+
 #ifdef CONFIG_VT_HW_CONSOLE_BINDING
 static int con_is_graphics(const struct consw *csw, int first, int last)
 {
@@ -3199,9 +3210,9 @@ int unbind_con_driver(const struct consw *csw, int first, int last, int deflt)
        if (!con_is_bound(csw))
                con_driver->flag &= ~CON_DRIVER_FLAG_INIT;
 
-       console_unlock();
        /* ignore return value, binding should not fail */
-       bind_con_driver(defcsw, first, last, deflt);
+       do_bind_con_driver(defcsw, first, last, deflt);
+       console_unlock();
 err:
        module_put(owner);
        return retval;
@@ -3492,28 +3503,18 @@ int con_debug_leave(void)
 }
 EXPORT_SYMBOL_GPL(con_debug_leave);
 
-/**
- * register_con_driver - register console driver to console layer
- * @csw: console driver
- * @first: the first console to take over, minimum value is 0
- * @last: the last console to take over, maximum value is MAX_NR_CONSOLES -1
- *
- * DESCRIPTION: This function registers a console driver which can later
- * bind to a range of consoles specified by @first and @last. It will
- * also initialize the console driver by calling con_startup().
- */
-int register_con_driver(const struct consw *csw, int first, int last)
+static int do_register_con_driver(const struct consw *csw, int first, int last)
 {
        struct module *owner = csw->owner;
        struct con_driver *con_driver;
        const char *desc;
        int i, retval = 0;
 
+       WARN_CONSOLE_UNLOCKED();
+
        if (!try_module_get(owner))
                return -ENODEV;
 
-       console_lock();
-
        for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
                con_driver = &registered_con_driver[i];
 
@@ -3566,10 +3567,29 @@ int register_con_driver(const struct consw *csw, int first, int last)
        }
 
 err:
-       console_unlock();
        module_put(owner);
        return retval;
 }
+
+/**
+ * register_con_driver - register console driver to console layer
+ * @csw: console driver
+ * @first: the first console to take over, minimum value is 0
+ * @last: the last console to take over, maximum value is MAX_NR_CONSOLES -1
+ *
+ * DESCRIPTION: This function registers a console driver which can later
+ * bind to a range of consoles specified by @first and @last. It will
+ * also initialize the console driver by calling con_startup().
+ */
+int register_con_driver(const struct consw *csw, int first, int last)
+{
+       int retval;
+
+       console_lock();
+       retval = do_register_con_driver(csw, first, last);
+       console_unlock();
+       return retval;
+}
 EXPORT_SYMBOL(register_con_driver);
 
 /**
@@ -3623,17 +3643,44 @@ EXPORT_SYMBOL(unregister_con_driver);
  *     when a driver wants to take over some existing consoles
  *     and become default driver for newly opened ones.
  *
- *      take_over_console is basically a register followed by unbind
+ *     take_over_console is basically a register followed by unbind
+ */
+int do_take_over_console(const struct consw *csw, int first, int last, int deflt)
+{
+       int err;
+
+       err = do_register_con_driver(csw, first, last);
+       /*
+        * If we get an busy error we still want to bind the console driver
+        * and return success, as we may have unbound the console driver
+        * but not unregistered it.
+        */
+       if (err == -EBUSY)
+               err = 0;
+       if (!err)
+               do_bind_con_driver(csw, first, last, deflt);
+
+       return err;
+}
+EXPORT_SYMBOL_GPL(do_take_over_console);
+
+/*
+ *     If we support more console drivers, this function is used
+ *     when a driver wants to take over some existing consoles
+ *     and become default driver for newly opened ones.
+ *
+ *     take_over_console is basically a register followed by unbind
  */
 int take_over_console(const struct consw *csw, int first, int last, int deflt)
 {
        int err;
 
        err = register_con_driver(csw, first, last);
-       /* if we get an busy error we still want to bind the console driver
+       /*
+        * If we get an busy error we still want to bind the console driver
         * and return success, as we may have unbound the console driver
-        * but not unregistered it.
-       */
+        * but not unregistered it.
+        */
        if (err == -EBUSY)
                err = 0;
        if (!err)

diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index fdefa8fd72c4da070787d95260b2744d6a9a7dab..4bd7820cf4d087cf93a3690698605f2c5fe36391 100644 (file)
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -529,6 +529,33 @@ static int search_for_mapped_con(void)
        return retval;
 }
 
+static int do_fbcon_takeover(int show_logo)
+{
+       int err, i;
+
+       if (!num_registered_fb)
+               return -ENODEV;
+
+       if (!show_logo)
+               logo_shown = FBCON_LOGO_DONTSHOW;
+
+       for (i = first_fb_vc; i <= last_fb_vc; i++)
+               con2fb_map[i] = info_idx;
+
+       err = do_take_over_console(&fb_con, first_fb_vc, last_fb_vc,
+                               fbcon_is_default);
+
+       if (err) {
+               for (i = first_fb_vc; i <= last_fb_vc; i++)
+                       con2fb_map[i] = -1;
+               info_idx = -1;
+       } else {
+               fbcon_has_console_bind = 1;
+       }
+
+       return err;
+}
+
 static int fbcon_takeover(int show_logo)
 {
        int err, i;
@@ -3115,7 +3142,7 @@ static int fbcon_fb_registered(struct fb_info *info)
                }
 
                if (info_idx != -1)
-                       ret = fbcon_takeover(1);
+                       ret = do_fbcon_takeover(1);
        } else {
                for (i = first_fb_vc; i <= last_fb_vc; i++) {
                        if (con2fb_map_boot[i] == idx)

diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 3ff0105a496a592cc9c1136c585efc463aa9de49..d8d9831b3fdbd0677595241babdb2dd8e927a96e 100644 (file)
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1650,7 +1650,9 @@ static int do_register_framebuffer(struct fb_info *fb_info)
        event.info = fb_info;
        if (!lock_fb_info(fb_info))
                return -ENODEV;
+       console_lock();
        fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);
+       console_unlock();
        unlock_fb_info(fb_info);
        return 0;
 }
@@ -1853,11 +1855,8 @@ int fb_new_modelist(struct fb_info *info)
        err = 1;
 
        if (!list_empty(&info->modelist)) {
-               if (!lock_fb_info(info))
-                       return -ENODEV;
                event.info = info;
                err = fb_notifier_call_chain(FB_EVENT_NEW_MODELIST, &event);
-               unlock_fb_info(info);
        }
 
        return err;

diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index a55e3669d1352f387c29e1342d4d54db429c2b3f..ef476b02fbe5ca7d91aed2b72710fff5ef806938 100644 (file)
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -177,6 +177,8 @@ static ssize_t store_modes(struct device *device,
        if (i * sizeof(struct fb_videomode) != count)
                return -EINVAL;
 
+       if (!lock_fb_info(fb_info))
+               return -ENODEV;
        console_lock();
        list_splice(&fb_info->modelist, &old_list);
        fb_videomode_to_modelist((const struct fb_videomode *)buf, i,
@@ -188,6 +190,7 @@ static ssize_t store_modes(struct device *device,
                fb_destroy_modelist(&old_list);
 
        console_unlock();
+       unlock_fb_info(fb_info);
 
        return 0;
 }

diff --git a/include/linux/console.h b/include/linux/console.h
index dedb082fe50fde9e62190569b0c362238a46f1b0..4ef4307dfb82329240beab54cf7849dd690eb6a9 100644 (file)
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -78,6 +78,7 @@ int con_is_bound(const struct consw *csw);
 int register_con_driver(const struct consw *csw, int first, int last);
 int unregister_con_driver(const struct consw *csw);
 int take_over_console(const struct consw *sw, int first, int last, int deflt);
+int do_take_over_console(const struct consw *sw, int first, int last, int deflt);
 void give_up_console(const struct consw *sw);
 #ifdef CONFIG_HW_CONSOLE
 int con_debug_enter(struct vc_data *vc);