Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux

Pull s390 updates from Martin Schwidefsky:
 "There are two memory management related changes, the CMMA support for
  KVM to avoid swap-in of freed pages and the split page table lock for
  the PMD level.  These two come with common code changes in mm/.

  A fix for the long standing theoretical TLB flush problem, this one
  comes with a common code change in kernel/sched/.

  Another set of changes is Heikos uaccess work, included is the initial
  set of patches with more to come.

  And fixes and cleanups as usual"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux: (36 commits)
  s390/con3270: optionally disable auto update
  s390/mm: remove unecessary parameter from pgste_ipte_notify
  s390/mm: remove unnecessary parameter from gmap_do_ipte_notify
  s390/mm: fixing comment so that parameter name match
  s390/smp: limit number of cpus in possible cpu mask
  hypfs: Add clarification for "weight_min" attribute
  s390: update defconfigs
  s390/ptrace: add support for PTRACE_SINGLEBLOCK
  s390/perf: make print_debug_cf() static
  s390/topology: Remove call to update_cpu_masks()
  s390/compat: remove compat exec domain
  s390: select CONFIG_TTY for use of tty in unconditional keyboard driver
  s390/appldata_os: fix cpu array size calculation
  s390/checksum: remove memset() within csum_partial_copy_from_user()
  s390/uaccess: remove copy_from_user_real()
  s390/sclp_early: Return correct HSA block count also for zero
  s390: add some drivers/subsystems to the MAINTAINERS file
  s390: improve debug feature usage
  s390/airq: add support for irq ranges
  s390/mm: enable split page table lock for PMD level
  ...

4 files changed, 76 insertions, 49 deletions

diff --git a/drivers/s390/cio/airq.c b/drivers/s390/cio/airq.c
index f055df0b167f..445564c790f6 100644
--- a/drivers/s390/cio/airq.c
+++ b/drivers/s390/cio/airq.c
@@ -186,55 +186,71 @@ void airq_iv_release(struct airq_iv *iv)
 EXPORT_SYMBOL(airq_iv_release);
 
 /**
- * airq_iv_alloc_bit - allocate an irq bit from an interrupt vector
+ * airq_iv_alloc - allocate irq bits from an interrupt vector
  * @iv: pointer to an interrupt vector structure
+ * @num: number of consecutive irq bits to allocate
  *
- * Returns the bit number of the allocated irq, or -1UL if no bit
- * is available or the AIRQ_IV_ALLOC flag has not been specified
+ * Returns the bit number of the first irq in the allocated block of irqs,
+ * or -1UL if no bit is available or the AIRQ_IV_ALLOC flag has not been
+ * specified
  */
-unsigned long airq_iv_alloc_bit(struct airq_iv *iv)
+unsigned long airq_iv_alloc(struct airq_iv *iv, unsigned long num)
 {
-        unsigned long bit;
+        unsigned long bit, i;
 
-        if (!iv->avail)
+        if (!iv->avail || num == 0)
                 return -1UL;
         spin_lock(&iv->lock);
         bit = find_first_bit_inv(iv->avail, iv->bits);
-        if (bit < iv->bits) {
-                clear_bit_inv(bit, iv->avail);
-                if (bit >= iv->end)
-                        iv->end = bit + 1;
-        } else
+        while (bit + num <= iv->bits) {
+                for (i = 1; i < num; i++)
+                        if (!test_bit_inv(bit + i, iv->avail))
+                                break;
+                if (i >= num) {
+                        /* Found a suitable block of irqs */
+                        for (i = 0; i < num; i++)
+                                clear_bit_inv(bit + i, iv->avail);
+                        if (bit + num >= iv->end)
+                                iv->end = bit + num + 1;
+                        break;
+                }
+                bit = find_next_bit_inv(iv->avail, iv->bits, bit + i + 1);
+        }
+        if (bit + num > iv->bits)
                 bit = -1UL;
         spin_unlock(&iv->lock);
         return bit;
 
 }
-EXPORT_SYMBOL(airq_iv_alloc_bit);
+EXPORT_SYMBOL(airq_iv_alloc);
 
 /**
- * airq_iv_free_bit - free an irq bit of an interrupt vector
+ * airq_iv_free - free irq bits of an interrupt vector
  * @iv: pointer to interrupt vector structure
- * @bit: number of the irq bit to free
+ * @bit: number of the first irq bit to free
+ * @num: number of consecutive irq bits to free
  */
-void airq_iv_free_bit(struct airq_iv *iv, unsigned long bit)
+void airq_iv_free(struct airq_iv *iv, unsigned long bit, unsigned long num)
 {
-        if (!iv->avail)
+        unsigned long i;
+
+        if (!iv->avail || num == 0)
                 return;
         spin_lock(&iv->lock);
-        /* Clear (possibly left over) interrupt bit */
-        clear_bit_inv(bit, iv->vector);
-        /* Make the bit position available again */
-        set_bit_inv(bit, iv->avail);
-        if (bit == iv->end - 1) {
+        for (i = 0; i < num; i++) {
+                /* Clear (possibly left over) interrupt bit */
+                clear_bit_inv(bit + i, iv->vector);
+                /* Make the bit positions available again */
+                set_bit_inv(bit + i, iv->avail);
+        }
+        if (bit + num >= iv->end) {
                 /* Find new end of bit-field */
-                while (--iv->end > 0)
-                        if (!test_bit_inv(iv->end - 1, iv->avail))
-                                break;
+                while (iv->end > 0 && !test_bit_inv(iv->end - 1, iv->avail))
+                        iv->end--;
         }
         spin_unlock(&iv->lock);
 }
-EXPORT_SYMBOL(airq_iv_free_bit);
+EXPORT_SYMBOL(airq_iv_free);
 
 /**
  * airq_iv_scan - scan interrupt vector for non-zero bits
diff --git a/drivers/s390/cio/chsc_sch.c b/drivers/s390/cio/chsc_sch.c
index 7b29d0be0ca3..1d3661af7bd8 100644
--- a/drivers/s390/cio/chsc_sch.c
+++ b/drivers/s390/cio/chsc_sch.c
@@ -173,8 +173,7 @@ static struct css_driver chsc_subchannel_driver = {
 
 static int __init chsc_init_dbfs(void)
 {
-        chsc_debug_msg_id = debug_register("chsc_msg", 16, 1,
-                                           16 * sizeof(long));
+        chsc_debug_msg_id = debug_register("chsc_msg", 8, 1, 4 * sizeof(long));
         if (!chsc_debug_msg_id)
                 goto out;
         debug_register_view(chsc_debug_msg_id, &debug_sprintf_view);
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 8ee88c4ebd83..97c48b38d67d 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -54,7 +54,7 @@ debug_info_t *cio_debug_crw_id;
  */
 static int __init cio_debug_init(void)
 {
-        cio_debug_msg_id = debug_register("cio_msg", 16, 1, 16 * sizeof(long));
+        cio_debug_msg_id = debug_register("cio_msg", 16, 1, 11 * sizeof(long));
         if (!cio_debug_msg_id)
                 goto out_unregister;
         debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
@@ -64,7 +64,7 @@ static int __init cio_debug_init(void)
                 goto out_unregister;
         debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
         debug_set_level(cio_debug_trace_id, 2);
-        cio_debug_crw_id = debug_register("cio_crw", 16, 1, 16 * sizeof(long));
+        cio_debug_crw_id = debug_register("cio_crw", 8, 1, 8 * sizeof(long));
         if (!cio_debug_crw_id)
                 goto out_unregister;
         debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index e9d783563cbb..d8d9b5b5cc56 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -1571,12 +1571,27 @@ out:
         return rc;
 }
 
+static void ccw_device_set_int_class(struct ccw_device *cdev)
+{
+        struct ccw_driver *cdrv = cdev->drv;
+
+        /* Note: we interpret class 0 in this context as an uninitialized
+         * field since it translates to a non-I/O interrupt class. */
+        if (cdrv->int_class != 0)
+                cdev->private->int_class = cdrv->int_class;
+        else
+                cdev->private->int_class = IRQIO_CIO;
+}
+
 #ifdef CONFIG_CCW_CONSOLE
-static int ccw_device_console_enable(struct ccw_device *cdev,
-                                     struct subchannel *sch)
+int __init ccw_device_enable_console(struct ccw_device *cdev)
 {
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
         int rc;
 
+        if (!cdev->drv || !cdev->handler)
+                return -EINVAL;
+
         io_subchannel_init_fields(sch);
         rc = cio_commit_config(sch);
         if (rc)
@@ -1609,12 +1624,11 @@ out_unlock:
         return rc;
 }
 
-struct ccw_device *ccw_device_probe_console(void)
+struct ccw_device * __init ccw_device_create_console(struct ccw_driver *drv)
 {
         struct io_subchannel_private *io_priv;
         struct ccw_device *cdev;
         struct subchannel *sch;
-        int ret;
 
         sch = cio_probe_console();
         if (IS_ERR(sch))
@@ -1631,18 +1645,23 @@ struct ccw_device *ccw_device_probe_console(void)
                 kfree(io_priv);
                 return cdev;
         }
+        cdev->drv = drv;
         set_io_private(sch, io_priv);
-        ret = ccw_device_console_enable(cdev, sch);
-        if (ret) {
-                set_io_private(sch, NULL);
-                put_device(&sch->dev);
-                put_device(&cdev->dev);
-                kfree(io_priv);
-                return ERR_PTR(ret);
-        }
+        ccw_device_set_int_class(cdev);
         return cdev;
 }
 
+void __init ccw_device_destroy_console(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct io_subchannel_private *io_priv = to_io_private(sch);
+
+        set_io_private(sch, NULL);
+        put_device(&sch->dev);
+        put_device(&cdev->dev);
+        kfree(io_priv);
+}
+
 /**
  * ccw_device_wait_idle() - busy wait for device to become idle
  * @cdev: ccw device
@@ -1726,15 +1745,8 @@ ccw_device_probe (struct device *dev)
         int ret;
 
         cdev->drv = cdrv; /* to let the driver call _set_online */
-        /* Note: we interpret class 0 in this context as an uninitialized
-         * field since it translates to a non-I/O interrupt class. */
-        if (cdrv->int_class != 0)
-                cdev->private->int_class = cdrv->int_class;
-        else
-                cdev->private->int_class = IRQIO_CIO;
-
+        ccw_device_set_int_class(cdev);
         ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV;
-
         if (ret) {
                 cdev->drv = NULL;
                 cdev->private->int_class = IRQIO_CIO;