9 files changed, 126 insertions, 138 deletions

diff --git a/drivers/char/efirtc.c b/drivers/char/efirtc.c
index 26a47dc88f61..53c524e7b829 100644
--- a/drivers/char/efirtc.c
+++ b/drivers/char/efirtc.c
@@ -285,6 +285,7 @@ static const struct file_operations efi_rtc_fops = {
         .unlocked_ioctl = efi_rtc_ioctl,
         .open           = efi_rtc_open,
         .release        = efi_rtc_close,
+        .llseek         = no_llseek,
 };
 
 static struct miscdevice efi_rtc_dev= {
diff --git a/drivers/char/hvc_iucv.c b/drivers/char/hvc_iucv.c
index b8a5d654d3d0..fe62bd0e17b7 100644
--- a/drivers/char/hvc_iucv.c
+++ b/drivers/char/hvc_iucv.c
@@ -931,7 +931,7 @@ static struct hv_ops hvc_iucv_ops = {
 };
 
 /* Suspend / resume device operations */
-static struct dev_pm_ops hvc_iucv_pm_ops = {
+static const struct dev_pm_ops hvc_iucv_pm_ops = {
         .freeze   = hvc_iucv_pm_freeze,
         .thaw     = hvc_iucv_pm_restore_thaw,
         .restore  = hvc_iucv_pm_restore_thaw,
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index 80704875794c..cf82fedae099 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -370,7 +370,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                         return SI_SM_IDLE;
 
         case KCS_START_OP:
-                if (state != KCS_IDLE) {
+                if (state != KCS_IDLE_STATE) {
                         start_error_recovery(kcs,
                                              "State machine not idle at start");
                         break;
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 5619007e7e05..f706b1dffdb3 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -233,7 +233,8 @@ int setkeycode(unsigned int scancode, unsigned int keycode)
 }
 
 /*
- * Making beeps and bells.
+ * Making beeps and bells. Note that we prefer beeps to bells, but when
+ * shutting the sound off we do both.
  */
 
 static int kd_sound_helper(struct input_handle *handle, void *data)
@@ -242,9 +243,12 @@ static int kd_sound_helper(struct input_handle *handle, void *data)
         struct input_dev *dev = handle->dev;
 
         if (test_bit(EV_SND, dev->evbit)) {
-                if (test_bit(SND_TONE, dev->sndbit))
+                if (test_bit(SND_TONE, dev->sndbit)) {
                         input_inject_event(handle, EV_SND, SND_TONE, *hz);
-                if (test_bit(SND_BELL, handle->dev->sndbit))
+                        if (*hz)
+                                return 0;
+                }
+                if (test_bit(SND_BELL, dev->sndbit))
                         input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
         }
 
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index fba76fb55abf..be832b6f8279 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -34,6 +34,16 @@
 # include <linux/efi.h>
 #endif
 
+static inline unsigned long size_inside_page(unsigned long start,
+                                             unsigned long size)
+{
+        unsigned long sz;
+
+        sz = PAGE_SIZE - (start & (PAGE_SIZE - 1));
+
+        return min(sz, size);
+}
+
 /*
  * Architectures vary in how they handle caching for addresses
  * outside of main memory.
@@ -126,9 +136,7 @@ static ssize_t read_mem(struct file * file, char __user * buf,
 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
         /* we don't have page 0 mapped on sparc and m68k.. */
         if (p < PAGE_SIZE) {
-                sz = PAGE_SIZE - p;
-                if (sz > count) 
-                        sz = count; 
+                sz = size_inside_page(p, count);
                 if (sz > 0) {
                         if (clear_user(buf, sz))
                                 return -EFAULT;
@@ -141,15 +149,9 @@ static ssize_t read_mem(struct file * file, char __user * buf,
 #endif
 
         while (count > 0) {
-                /*
-                 * Handle first page in case it's not aligned
-                 */
-                if (-p & (PAGE_SIZE - 1))
-                        sz = -p & (PAGE_SIZE - 1);
-                else
-                        sz = PAGE_SIZE;
+                unsigned long remaining;
 
-                sz = min_t(unsigned long, sz, count);
+                sz = size_inside_page(p, count);
 
                 if (!range_is_allowed(p >> PAGE_SHIFT, count))
                         return -EPERM;
@@ -163,12 +165,10 @@ static ssize_t read_mem(struct file * file, char __user * buf,
                 if (!ptr)
                         return -EFAULT;
 
-                if (copy_to_user(buf, ptr, sz)) {
-                        unxlate_dev_mem_ptr(p, ptr);
-                        return -EFAULT;
-                }
-
+                remaining = copy_to_user(buf, ptr, sz);
                 unxlate_dev_mem_ptr(p, ptr);
+                if (remaining)
+                        return -EFAULT;
 
                 buf += sz;
                 p += sz;
@@ -196,9 +196,7 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
         /* we don't have page 0 mapped on sparc and m68k.. */
         if (p < PAGE_SIZE) {
-                unsigned long sz = PAGE_SIZE - p;
-                if (sz > count)
-                        sz = count;
+                sz = size_inside_page(p, count);
                 /* Hmm. Do something? */
                 buf += sz;
                 p += sz;
@@ -208,15 +206,7 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
 #endif
 
         while (count > 0) {
-                /*
-                 * Handle first page in case it's not aligned
-                 */
-                if (-p & (PAGE_SIZE - 1))
-                        sz = -p & (PAGE_SIZE - 1);
-                else
-                        sz = PAGE_SIZE;
-
-                sz = min_t(unsigned long, sz, count);
+                sz = size_inside_page(p, count);
 
                 if (!range_is_allowed(p >> PAGE_SHIFT, sz))
                         return -EPERM;
@@ -234,16 +224,14 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
                 }
 
                 copied = copy_from_user(ptr, buf, sz);
+                unxlate_dev_mem_ptr(p, ptr);
                 if (copied) {
                         written += sz - copied;
-                        unxlate_dev_mem_ptr(p, ptr);
                         if (written)
                                 break;
                         return -EFAULT;
                 }
 
-                unxlate_dev_mem_ptr(p, ptr);
-
                 buf += sz;
                 p += sz;
                 count -= sz;
@@ -417,27 +405,18 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
                 /* we don't have page 0 mapped on sparc and m68k.. */
                 if (p < PAGE_SIZE && low_count > 0) {
-                        size_t tmp = PAGE_SIZE - p;
-                        if (tmp > low_count) tmp = low_count;
-                        if (clear_user(buf, tmp))
+                        sz = size_inside_page(p, low_count);
+                        if (clear_user(buf, sz))
                                 return -EFAULT;
-                        buf += tmp;
-                        p += tmp;
-                        read += tmp;
-                        low_count -= tmp;
-                        count -= tmp;
+                        buf += sz;
+                        p += sz;
+                        read += sz;
+                        low_count -= sz;
+                        count -= sz;
                 }
 #endif
                 while (low_count > 0) {
-                        /*
-                         * Handle first page in case it's not aligned
-                         */
-                        if (-p & (PAGE_SIZE - 1))
-                                sz = -p & (PAGE_SIZE - 1);
-                        else
-                                sz = PAGE_SIZE;
-
-                        sz = min_t(unsigned long, sz, low_count);
+                        sz = size_inside_page(p, low_count);
 
                         /*
                          * On ia64 if a page has been mapped somewhere as
@@ -461,21 +440,18 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
                 if (!kbuf)
                         return -ENOMEM;
                 while (count > 0) {
-                        int len = count;
-
-                        if (len > PAGE_SIZE)
-                                len = PAGE_SIZE;
-                        len = vread(kbuf, (char *)p, len);
-                        if (!len)
+                        sz = size_inside_page(p, count);
+                        sz = vread(kbuf, (char *)p, sz);
+                        if (!sz)
                                 break;
-                        if (copy_to_user(buf, kbuf, len)) {
+                        if (copy_to_user(buf, kbuf, sz)) {
                                 free_page((unsigned long)kbuf);
                                 return -EFAULT;
                         }
-                        count -= len;
-                        buf += len;
-                        read += len;
-                        p += len;
+                        count -= sz;
+                        buf += sz;
+                        read += sz;
+                        p += sz;
                 }
                 free_page((unsigned long)kbuf);
         }
@@ -485,7 +461,7 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
 
 
 static inline ssize_t
-do_write_kmem(void *p, unsigned long realp, const char __user * buf,
+do_write_kmem(unsigned long p, const char __user *buf,
               size_t count, loff_t *ppos)
 {
         ssize_t written, sz;
@@ -494,14 +470,11 @@ do_write_kmem(void *p, unsigned long realp, const char __user * buf,
         written = 0;
 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
         /* we don't have page 0 mapped on sparc and m68k.. */
-        if (realp < PAGE_SIZE) {
-                unsigned long sz = PAGE_SIZE - realp;
-                if (sz > count)
-                        sz = count;
+        if (p < PAGE_SIZE) {
+                sz = size_inside_page(p, count);
                 /* Hmm. Do something? */
                 buf += sz;
                 p += sz;
-                realp += sz;
                 count -= sz;
                 written += sz;
         }
@@ -509,22 +482,15 @@ do_write_kmem(void *p, unsigned long realp, const char __user * buf,
 
         while (count > 0) {
                 char *ptr;
-                /*
-                 * Handle first page in case it's not aligned
-                 */
-                if (-realp & (PAGE_SIZE - 1))
-                        sz = -realp & (PAGE_SIZE - 1);
-                else
-                        sz = PAGE_SIZE;
 
-                sz = min_t(unsigned long, sz, count);
+                sz = size_inside_page(p, count);
 
                 /*
                  * On ia64 if a page has been mapped somewhere as
                  * uncached, then it must also be accessed uncached
                  * by the kernel or data corruption may occur
                  */
-                ptr = xlate_dev_kmem_ptr(p);
+                ptr = xlate_dev_kmem_ptr((char *)p);
 
                 copied = copy_from_user(ptr, buf, sz);
                 if (copied) {
@@ -535,7 +501,6 @@ do_write_kmem(void *p, unsigned long realp, const char __user * buf,
                 }
                 buf += sz;
                 p += sz;
-                realp += sz;
                 count -= sz;
                 written += sz;
         }
@@ -554,19 +519,14 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
         unsigned long p = *ppos;
         ssize_t wrote = 0;
         ssize_t virtr = 0;
-        ssize_t written;
         char * kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */
 
         if (p < (unsigned long) high_memory) {
-
-                wrote = count;
-                if (count > (unsigned long) high_memory - p)
-                        wrote = (unsigned long) high_memory - p;
-
-                written = do_write_kmem((void*)p, p, buf, wrote, ppos);
-                if (written != wrote)
-                        return written;
-                wrote = written;
+                unsigned long to_write = min_t(unsigned long, count,
+                                               (unsigned long)high_memory - p);
+                wrote = do_write_kmem(p, buf, to_write, ppos);
+                if (wrote != to_write)
+                        return wrote;
                 p += wrote;
                 buf += wrote;
                 count -= wrote;
@@ -577,24 +537,21 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
                 if (!kbuf)
                         return wrote ? wrote : -ENOMEM;
                 while (count > 0) {
-                        int len = count;
-
-                        if (len > PAGE_SIZE)
-                                len = PAGE_SIZE;
-                        if (len) {
-                                written = copy_from_user(kbuf, buf, len);
-                                if (written) {
-                                        if (wrote + virtr)
-                                                break;
-                                        free_page((unsigned long)kbuf);
-                                        return -EFAULT;
-                                }
+                        unsigned long sz = size_inside_page(p, count);
+                        unsigned long n;
+
+                        n = copy_from_user(kbuf, buf, sz);
+                        if (n) {
+                                if (wrote + virtr)
+                                        break;
+                                free_page((unsigned long)kbuf);
+                                return -EFAULT;
                         }
-                        len = vwrite(kbuf, (char *)p, len);
-                        count -= len;
-                        buf += len;
-                        virtr += len;
-                        p += len;
+                        sz = vwrite(kbuf, (char *)p, sz);
+                        count -= sz;
+                        buf += sz;
+                        virtr += sz;
+                        p += sz;
                 }
                 free_page((unsigned long)kbuf);
         }
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 96f1cd086dd2..94a136e96c06 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -60,9 +60,7 @@ static DEFINE_MUTEX(misc_mtx);
  * Assigned numbers, used for dynamic minors
  */
 #define DYNAMIC_MINORS 64 /* like dynamic majors */
-static unsigned char misc_minors[DYNAMIC_MINORS / 8];
-
-extern int pmu_device_init(void);
+static DECLARE_BITMAP(misc_minors, DYNAMIC_MINORS);
 
 #ifdef CONFIG_PROC_FS
 static void *misc_seq_start(struct seq_file *seq, loff_t *pos)
@@ -198,24 +196,23 @@ int misc_register(struct miscdevice * misc)
         }
 
         if (misc->minor == MISC_DYNAMIC_MINOR) {
-                int i = DYNAMIC_MINORS;
-                while (--i >= 0)
-                        if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)
-                                break;
-                if (i<0) {
+                int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS);
+                if (i >= DYNAMIC_MINORS) {
                         mutex_unlock(&misc_mtx);
                         return -EBUSY;
                 }
-                misc->minor = i;
+                misc->minor = DYNAMIC_MINORS - i - 1;
+                set_bit(i, misc_minors);
         }
 
-        if (misc->minor < DYNAMIC_MINORS)
-                misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
         dev = MKDEV(MISC_MAJOR, misc->minor);
 
         misc->this_device = device_create(misc_class, misc->parent, dev,
                                           misc, "%s", misc->name);
         if (IS_ERR(misc->this_device)) {
+                int i = DYNAMIC_MINORS - misc->minor - 1;
+                if (i < DYNAMIC_MINORS && i >= 0)
+                        clear_bit(i, misc_minors);
                 err = PTR_ERR(misc->this_device);
                 goto out;
         }
@@ -242,7 +239,7 @@ int misc_register(struct miscdevice * misc)
 
 int misc_deregister(struct miscdevice *misc)
 {
-        int i = misc->minor;
+        int i = DYNAMIC_MINORS - misc->minor - 1;
 
         if (list_empty(&misc->list))
                 return -EINVAL;
@@ -250,9 +247,8 @@ int misc_deregister(struct miscdevice *misc)
         mutex_lock(&misc_mtx);
         list_del(&misc->list);
         device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
-        if (i < DYNAMIC_MINORS && i>0) {
-                misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
-        }
+        if (i < DYNAMIC_MINORS && i >= 0)
+                clear_bit(i, misc_minors);
         mutex_unlock(&misc_mtx);
         return 0;
 }
diff --git a/drivers/char/random.c b/drivers/char/random.c
index dcd08635cf1b..8258982b49ec 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1245,12 +1245,8 @@ static int proc_do_uuid(ctl_table *table, int write,
         if (uuid[8] == 0)
                 generate_random_uuid(uuid);
 
-        sprintf(buf, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
-                "%02x%02x%02x%02x%02x%02x",
-                uuid[0],  uuid[1],  uuid[2],  uuid[3],
-                uuid[4],  uuid[5],  uuid[6],  uuid[7],
-                uuid[8],  uuid[9],  uuid[10], uuid[11],
-                uuid[12], uuid[13], uuid[14], uuid[15]);
+        sprintf(buf, "%pU", uuid);
+
         fake_table.data = buf;
         fake_table.maxlen = sizeof(buf);
 
@@ -1310,7 +1306,7 @@ ctl_table random_table[] = {
 
 /********************************************************************
  *
- * Random funtions for networking
+ * Random functions for networking
  *
  ********************************************************************/
 
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 44203ff599da..1ae2de7d8b4f 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -339,7 +339,7 @@ static struct sysrq_key_op sysrq_term_op = {
 
 static void moom_callback(struct work_struct *ignored)
 {
-        out_of_memory(node_zonelist(0, GFP_KERNEL), GFP_KERNEL, 0);
+        out_of_memory(node_zonelist(0, GFP_KERNEL), GFP_KERNEL, 0, NULL);
 }
 
 static DECLARE_WORK(moom_work, moom_callback);
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 1e3d728dbf7e..50faa1fb0f06 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -164,6 +164,9 @@ module_param(default_utf8, int, S_IRUGO | S_IWUSR);
 int global_cursor_default = -1;
 module_param(global_cursor_default, int, S_IRUGO | S_IWUSR);
 
+static int cur_default = CUR_DEFAULT;
+module_param(cur_default, int, S_IRUGO | S_IWUSR);
+
 /*
  * ignore_poke: don't unblank the screen when things are typed.  This is
  * mainly for the privacy of braille terminal users.
@@ -184,12 +187,10 @@ static DECLARE_WORK(console_work, console_callback);
  * fg_console is the current virtual console,
  * last_console is the last used one,
  * want_console is the console we want to switch to,
- * kmsg_redirect is the console for kernel messages,
  */
 int fg_console;
 int last_console;
 int want_console = -1;
-int kmsg_redirect;
 
 /*
  * For each existing display, we have a pointer to console currently visible
@@ -1638,7 +1639,7 @@ static void reset_terminal(struct vc_data *vc, int do_clear)
         /* do not do set_leds here because this causes an endless tasklet loop
            when the keyboard hasn't been initialized yet */
 
-        vc->vc_cursor_type = CUR_DEFAULT;
+        vc->vc_cursor_type = cur_default;
         vc->vc_complement_mask = vc->vc_s_complement_mask;
 
         default_attr(vc);
@@ -1840,7 +1841,7 @@ static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
                                 if (vc->vc_par[0])
                                         vc->vc_cursor_type = vc->vc_par[0] | (vc->vc_par[1] << 8) | (vc->vc_par[2] << 16);
                                 else
-                                        vc->vc_cursor_type = CUR_DEFAULT;
+                                        vc->vc_cursor_type = cur_default;
                                 return;
                         }
                         break;
@@ -2434,6 +2435,37 @@ struct tty_driver *console_driver;
 
 #ifdef CONFIG_VT_CONSOLE
 
+/**
+ * vt_kmsg_redirect() - Sets/gets the kernel message console
+ * @new:        The new virtual terminal number or -1 if the console should stay
+ *              unchanged
+ *
+ * By default, the kernel messages are always printed on the current virtual
+ * console. However, the user may modify that default with the
+ * TIOCL_SETKMSGREDIRECT ioctl call.
+ *
+ * This function sets the kernel message console to be @new. It returns the old
+ * virtual console number. The virtual terminal number 0 (both as parameter and
+ * return value) means no redirection (i.e. always printed on the currently
+ * active console).
+ *
+ * The parameter -1 means that only the current console is returned, but the
+ * value is not modified. You may use the macro vt_get_kmsg_redirect() in that
+ * case to make the code more understandable.
+ *
+ * When the kernel is compiled without CONFIG_VT_CONSOLE, this function ignores
+ * the parameter and always returns 0.
+ */
+int vt_kmsg_redirect(int new)
+{
+        static int kmsg_con;
+
+        if (new != -1)
+                return xchg(&kmsg_con, new);
+        else
+                return kmsg_con;
+}
+
 /*
  *      Console on virtual terminal
  *
@@ -2448,6 +2480,7 @@ static void vt_console_print(struct console *co, const char *b, unsigned count)
         const ushort *start;
         ushort cnt = 0;
         ushort myx;
+        int kmsg_console;
 
         /* console busy or not yet initialized */
         if (!printable)
@@ -2455,8 +2488,9 @@ static void vt_console_print(struct console *co, const char *b, unsigned count)
         if (!spin_trylock(&printing_lock))
                 return;
 
-        if (kmsg_redirect && vc_cons_allocated(kmsg_redirect - 1))
-                vc = vc_cons[kmsg_redirect - 1].d;
+        kmsg_console = vt_get_kmsg_redirect();
+        if (kmsg_console && vc_cons_allocated(kmsg_console - 1))
+                vc = vc_cons[kmsg_console - 1].d;
 
         /* read `x' only after setting currcons properly (otherwise
            the `x' macro will read the x of the foreground console). */
@@ -2613,7 +2647,7 @@ int tioclinux(struct tty_struct *tty, unsigned long arg)
                         ret = set_vesa_blanking(p);
                         break;
                 case TIOCL_GETKMSGREDIRECT:
-                        data = kmsg_redirect;
+                        data = vt_get_kmsg_redirect();
                         ret = __put_user(data, p);
                         break;
                 case TIOCL_SETKMSGREDIRECT:
@@ -2623,7 +2657,7 @@ int tioclinux(struct tty_struct *tty, unsigned long arg)
                                 if (get_user(data, p+1))
                                         ret = -EFAULT;
                                 else
-                                        kmsg_redirect = data;
+                                        vt_kmsg_redirect(data);
                         }
                         break;
                 case TIOCL_GETFGCONSOLE: