Merge branch 'for-linus' of git://git390.marist.edu/pub/scm/linux-2.6

* 'for-linus' of git://git390.marist.edu/pub/scm/linux-2.6: (35 commits)
  [S390] time: remove unused code
  [S390] zcore: Add prefix registers to dump header
  [S390] correct vdso version string
  [S390] add support for compressed kernels
  [S390] Define new s390 ELF note sections in elf.h
  [S390] codepage conversion of kernel parameter line
  [S390] seq_file: convert drivers/s390/
  [S390] add z9-ec/z10 instruction to kernel disassembler
  [S390] dasd: correct offline processing
  [S390] dasd: fix refcounting.
  [S390] dasd: fix online/offline race
  [S390] use kprobes_built_in() in mm/fault code
  [S390] bug: use relative pointers in bug table entries
  [S390] Cleanup struct _lowcore usage and defines.
  [S390] free_initmem: reduce code duplication
  [S390] Replace ENOTSUPP usage with EOPNOTSUPP
  [S390] spinlock: check virtual cpu running status
  [S390] sysinfo: fix SYSIB 3,2,2 structure
  [S390] add MACHINE_IS_LPAR flag
  [S390] qdio: optimize cache line usage of struct qdio_irq
  ...

23 files changed, 562 insertions, 443 deletions

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 5905936c7c60..9ab1ae40565f 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -20,6 +20,7 @@
 #include <linux/buffer_head.h>
 #include <linux/hdreg.h>
 #include <linux/async.h>
+#include <linux/mutex.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
@@ -112,6 +113,7 @@ struct dasd_device *dasd_alloc_device(void)
         INIT_WORK(&device->restore_device, do_restore_device);
         device->state = DASD_STATE_NEW;
         device->target = DASD_STATE_NEW;
+        mutex_init(&device->state_mutex);
 
         return device;
 }
@@ -321,8 +323,8 @@ static int dasd_state_ready_to_basic(struct dasd_device *device)
                         device->state = DASD_STATE_READY;
                         return rc;
                 }
-                dasd_destroy_partitions(block);
                 dasd_flush_request_queue(block);
+                dasd_destroy_partitions(block);
                 block->blocks = 0;
                 block->bp_block = 0;
                 block->s2b_shift = 0;
@@ -484,10 +486,8 @@ static void dasd_change_state(struct dasd_device *device)
         if (rc)
                 device->target = device->state;
 
-        if (device->state == device->target) {
+        if (device->state == device->target)
                 wake_up(&dasd_init_waitq);
-                dasd_put_device(device);
-        }
 
         /* let user-space know that the device status changed */
         kobject_uevent(&device->cdev->dev.kobj, KOBJ_CHANGE);
@@ -502,7 +502,9 @@ static void dasd_change_state(struct dasd_device *device)
 static void do_kick_device(struct work_struct *work)
 {
         struct dasd_device *device = container_of(work, struct dasd_device, kick_work);
+        mutex_lock(&device->state_mutex);
         dasd_change_state(device);
+        mutex_unlock(&device->state_mutex);
         dasd_schedule_device_bh(device);
         dasd_put_device(device);
 }
@@ -539,18 +541,19 @@ void dasd_restore_device(struct dasd_device *device)
 void dasd_set_target_state(struct dasd_device *device, int target)
 {
         dasd_get_device(device);
+        mutex_lock(&device->state_mutex);
         /* If we are in probeonly mode stop at DASD_STATE_READY. */
         if (dasd_probeonly && target > DASD_STATE_READY)
                 target = DASD_STATE_READY;
         if (device->target != target) {
-                if (device->state == target) {
+                if (device->state == target)
                         wake_up(&dasd_init_waitq);
-                        dasd_put_device(device);
-                }
                 device->target = target;
         }
         if (device->state != device->target)
                 dasd_change_state(device);
+        mutex_unlock(&device->state_mutex);
+        dasd_put_device(device);
 }
 
 /*
@@ -1000,12 +1003,20 @@ static void dasd_handle_killed_request(struct ccw_device *cdev,
                 return;
         }
 
-        device = (struct dasd_device *) cqr->startdev;
-        if (device == NULL ||
-            device != dasd_device_from_cdev_locked(cdev) ||
-            strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
+        device = dasd_device_from_cdev_locked(cdev);
+        if (IS_ERR(device)) {
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
+                                "unable to get device from cdev");
+                return;
+        }
+
+        if (!cqr->startdev ||
+            device != cqr->startdev ||
+            strncmp(cqr->startdev->discipline->ebcname,
+                    (char *) &cqr->magic, 4)) {
                 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
                                 "invalid device in request");
+                dasd_put_device(device);
                 return;
         }
 
@@ -1692,7 +1703,6 @@ int dasd_cancel_req(struct dasd_ccw_req *cqr)
                                 cqr, rc);
                 } else {
                         cqr->stopclk = get_clock();
-                        rc = 1;
                 }
                 break;
         default: /* already finished or clear pending - do nothing */
@@ -2170,9 +2180,13 @@ static void dasd_flush_request_queue(struct dasd_block *block)
 static int dasd_open(struct block_device *bdev, fmode_t mode)
 {
         struct dasd_block *block = bdev->bd_disk->private_data;
-        struct dasd_device *base = block->base;
+        struct dasd_device *base;
         int rc;
 
+        if (!block)
+                return -ENODEV;
+
+        base = block->base;
         atomic_inc(&block->open_count);
         if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) {
                 rc = -ENODEV;
@@ -2285,11 +2299,6 @@ static void dasd_generic_auto_online(void *data, async_cookie_t cookie)
         if (ret)
                 pr_warning("%s: Setting the DASD online failed with rc=%d\n",
                            dev_name(&cdev->dev), ret);
-        else {
-                struct dasd_device *device = dasd_device_from_cdev(cdev);
-                wait_event(dasd_init_waitq, _wait_for_device(device));
-                dasd_put_device(device);
-        }
 }
 
 /*
@@ -2424,6 +2433,9 @@ int dasd_generic_set_online(struct ccw_device *cdev,
         } else
                 pr_debug("dasd_generic device %s found\n",
                                 dev_name(&cdev->dev));
+
+        wait_event(dasd_init_waitq, _wait_for_device(device));
+
         dasd_put_device(device);
         return rc;
 }
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 4cac5b54f26a..d49766f3b940 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -874,12 +874,19 @@ dasd_discipline_show(struct device *dev, struct device_attribute *attr,
         ssize_t len;
 
         device = dasd_device_from_cdev(to_ccwdev(dev));
-        if (!IS_ERR(device) && device->discipline) {
+        if (IS_ERR(device))
+                goto out;
+        else if (!device->discipline) {
+                dasd_put_device(device);
+                goto out;
+        } else {
                 len = snprintf(buf, PAGE_SIZE, "%s\n",
                                device->discipline->name);
                 dasd_put_device(device);
-        } else
-                len = snprintf(buf, PAGE_SIZE, "none\n");
+                return len;
+        }
+out:
+        len = snprintf(buf, PAGE_SIZE, "none\n");
         return len;
 }
 
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index d3198303b93c..94f92a1247f2 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -88,6 +88,7 @@ void dasd_gendisk_free(struct dasd_block *block)
         if (block->gdp) {
                 del_gendisk(block->gdp);
                 block->gdp->queue = NULL;
+                block->gdp->private_data = NULL;
                 put_disk(block->gdp);
                 block->gdp = NULL;
         }
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index e4c2143dabf6..ed73ce550822 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -368,6 +368,7 @@ struct dasd_device {
 
         /* Device state and target state. */
         int state, target;
+        struct mutex state_mutex;
         int stopped;            /* device (ccw_device_start) was stopped */
 
         /* reference count. */
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index 71f95f54866f..f13a0bdd148c 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -165,51 +165,32 @@ static const struct file_operations dasd_devices_file_ops = {
         .release        = seq_release,
 };
 
-static int
-dasd_calc_metrics(char *page, char **start, off_t off,
-                  int count, int *eof, int len)
-{
-        len = (len > off) ? len - off : 0;
-        if (len > count)
-                len = count;
-        if (len < count)
-                *eof = 1;
-        *start = page + off;
-        return len;
-}
-
 #ifdef CONFIG_DASD_PROFILE
-static char *
-dasd_statistics_array(char *str, unsigned int *array, int factor)
+static void dasd_statistics_array(struct seq_file *m, unsigned int *array, int factor)
 {
         int i;
 
         for (i = 0; i < 32; i++) {
-                str += sprintf(str, "%7d ", array[i] / factor);
+                seq_printf(m, "%7d ", array[i] / factor);
                 if (i == 15)
-                        str += sprintf(str, "\n");
+                        seq_putc(m, '\n');
         }
-        str += sprintf(str,"\n");
-        return str;
+        seq_putc(m, '\n');
 }
 #endif /* CONFIG_DASD_PROFILE */
 
-static int
-dasd_statistics_read(char *page, char **start, off_t off,
-                     int count, int *eof, void *data)
+static int dasd_stats_proc_show(struct seq_file *m, void *v)
 {
-        unsigned long len;
 #ifdef CONFIG_DASD_PROFILE
         struct dasd_profile_info_t *prof;
-        char *str;
         int factor;
 
         /* check for active profiling */
         if (dasd_profile_level == DASD_PROFILE_OFF) {
-                len = sprintf(page, "Statistics are off - they might be "
+                seq_printf(m, "Statistics are off - they might be "
                                     "switched on using 'echo set on > "
                                     "/proc/dasd/statistics'\n");
-                return dasd_calc_metrics(page, start, off, count, eof, len);
+                return 0;
         }
 
         prof = &dasd_global_profile;
@@ -217,47 +198,49 @@ dasd_statistics_read(char *page, char **start, off_t off,
         for (factor = 1; (prof->dasd_io_reqs / factor) > 9999999;
              factor *= 10);
 
-        str = page;
-        str += sprintf(str, "%d dasd I/O requests\n", prof->dasd_io_reqs);
-        str += sprintf(str, "with %u sectors(512B each)\n",
+        seq_printf(m, "%d dasd I/O requests\n", prof->dasd_io_reqs);
+        seq_printf(m, "with %u sectors(512B each)\n",
                        prof->dasd_io_sects);
-        str += sprintf(str, "Scale Factor is  %d\n", factor);
-        str += sprintf(str,
+        seq_printf(m, "Scale Factor is  %d\n", factor);
+        seq_printf(m,
                        "   __<4    ___8    __16    __32    __64    _128 "
                        "   _256    _512    __1k    __2k    __4k    __8k "
                        "   _16k    _32k    _64k    128k\n");
-        str += sprintf(str,
+        seq_printf(m,
                        "   _256    _512    __1M    __2M    __4M    __8M "
                        "   _16M    _32M    _64M    128M    256M    512M "
                        "   __1G    __2G    __4G " "   _>4G\n");
 
-        str += sprintf(str, "Histogram of sizes (512B secs)\n");
-        str = dasd_statistics_array(str, prof->dasd_io_secs, factor);
-        str += sprintf(str, "Histogram of I/O times (microseconds)\n");
-        str = dasd_statistics_array(str, prof->dasd_io_times, factor);
-        str += sprintf(str, "Histogram of I/O times per sector\n");
-        str = dasd_statistics_array(str, prof->dasd_io_timps, factor);
-        str += sprintf(str, "Histogram of I/O time till ssch\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time1, factor);
-        str += sprintf(str, "Histogram of I/O time between ssch and irq\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time2, factor);
-        str += sprintf(str, "Histogram of I/O time between ssch "
+        seq_printf(m, "Histogram of sizes (512B secs)\n");
+        dasd_statistics_array(m, prof->dasd_io_secs, factor);
+        seq_printf(m, "Histogram of I/O times (microseconds)\n");
+        dasd_statistics_array(m, prof->dasd_io_times, factor);
+        seq_printf(m, "Histogram of I/O times per sector\n");
+        dasd_statistics_array(m, prof->dasd_io_timps, factor);
+        seq_printf(m, "Histogram of I/O time till ssch\n");
+        dasd_statistics_array(m, prof->dasd_io_time1, factor);
+        seq_printf(m, "Histogram of I/O time between ssch and irq\n");
+        dasd_statistics_array(m, prof->dasd_io_time2, factor);
+        seq_printf(m, "Histogram of I/O time between ssch "
                             "and irq per sector\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time2ps, factor);
-        str += sprintf(str, "Histogram of I/O time between irq and end\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time3, factor);
-        str += sprintf(str, "# of req in chanq at enqueuing (1..32) \n");
-        str = dasd_statistics_array(str, prof->dasd_io_nr_req, factor);
-        len = str - page;
+        dasd_statistics_array(m, prof->dasd_io_time2ps, factor);
+        seq_printf(m, "Histogram of I/O time between irq and end\n");
+        dasd_statistics_array(m, prof->dasd_io_time3, factor);
+        seq_printf(m, "# of req in chanq at enqueuing (1..32) \n");
+        dasd_statistics_array(m, prof->dasd_io_nr_req, factor);
 #else
-        len = sprintf(page, "Statistics are not activated in this kernel\n");
+        seq_printf(m, "Statistics are not activated in this kernel\n");
 #endif
-        return dasd_calc_metrics(page, start, off, count, eof, len);
+        return 0;
 }
 
-static int
-dasd_statistics_write(struct file *file, const char __user *user_buf,
-                      unsigned long user_len, void *data)
+static int dasd_stats_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, dasd_stats_proc_show, NULL);
+}
+
+static ssize_t dasd_stats_proc_write(struct file *file,
+                const char __user *user_buf, size_t user_len, loff_t *pos)
 {
 #ifdef CONFIG_DASD_PROFILE
         char *buffer, *str;
@@ -308,6 +291,15 @@ out_error:
 #endif                          /* CONFIG_DASD_PROFILE */
 }
 
+static const struct file_operations dasd_stats_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = dasd_stats_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = dasd_stats_proc_write,
+};
+
 /*
  * Create dasd proc-fs entries.
  * In case creation failed, cleanup and return -ENOENT.
@@ -324,13 +316,12 @@ dasd_proc_init(void)
                                          &dasd_devices_file_ops);
         if (!dasd_devices_entry)
                 goto out_nodevices;
-        dasd_statistics_entry = create_proc_entry("statistics",
-                                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                                  dasd_proc_root_entry);
+        dasd_statistics_entry = proc_create("statistics",
+                                            S_IFREG | S_IRUGO | S_IWUSR,
+                                            dasd_proc_root_entry,
+                                            &dasd_stats_proc_fops);
         if (!dasd_statistics_entry)
                 goto out_nostatistics;
-        dasd_statistics_entry->read_proc = dasd_statistics_read;
-        dasd_statistics_entry->write_proc = dasd_statistics_write;
         return 0;
 
  out_nostatistics:
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index 82daa3c1dc9c..3438658b66b7 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/miscdevice.h>
 #include <linux/debugfs.h>
+#include <asm/asm-offsets.h>
 #include <asm/ipl.h>
 #include <asm/sclp.h>
 #include <asm/setup.h>
@@ -40,12 +41,12 @@ enum arch_id {
 /* dump system info */
 
 struct sys_info {
-        enum arch_id    arch;
-        unsigned long   sa_base;
-        u32             sa_size;
-        int             cpu_map[NR_CPUS];
-        unsigned long   mem_size;
-        union save_area lc_mask;
+        enum arch_id     arch;
+        unsigned long    sa_base;
+        u32              sa_size;
+        int              cpu_map[NR_CPUS];
+        unsigned long    mem_size;
+        struct save_area lc_mask;
 };
 
 struct ipib_info {
@@ -183,52 +184,9 @@ static int memcpy_real_user(void __user *dest, unsigned long src, size_t count)
         return 0;
 }
 
-#ifdef __s390x__
-/*
- * Convert s390x (64 bit) cpu info to s390 (32 bit) cpu info
- */
-static void __init s390x_to_s390_regs(union save_area *out, union save_area *in,
-                                      int cpu)
-{
-        int i;
-
-        for (i = 0; i < 16; i++) {
-                out->s390.gp_regs[i] = in->s390x.gp_regs[i] & 0x00000000ffffffff;
-                out->s390.acc_regs[i] = in->s390x.acc_regs[i];
-                out->s390.ctrl_regs[i] =
-                        in->s390x.ctrl_regs[i] & 0x00000000ffffffff;
-        }
-        /* locore for 31 bit has only space for fpregs 0,2,4,6 */
-        out->s390.fp_regs[0] = in->s390x.fp_regs[0];
-        out->s390.fp_regs[1] = in->s390x.fp_regs[2];
-        out->s390.fp_regs[2] = in->s390x.fp_regs[4];
-        out->s390.fp_regs[3] = in->s390x.fp_regs[6];
-        memcpy(&(out->s390.psw[0]), &(in->s390x.psw[0]), 4);
-        out->s390.psw[1] |= 0x8; /* set bit 12 */
-        memcpy(&(out->s390.psw[4]),&(in->s390x.psw[12]), 4);
-        out->s390.psw[4] |= 0x80; /* set (31bit) addressing bit */
-        out->s390.pref_reg = in->s390x.pref_reg;
-        out->s390.timer = in->s390x.timer;
-        out->s390.clk_cmp = in->s390x.clk_cmp;
-}
-
-static void __init s390x_to_s390_save_areas(void)
-{
-        int i = 1;
-        static union save_area tmp;
-
-        while (zfcpdump_save_areas[i]) {
-                s390x_to_s390_regs(&tmp, zfcpdump_save_areas[i], i);
-                memcpy(zfcpdump_save_areas[i], &tmp, sizeof(tmp));
-                i++;
-        }
-}
-
-#endif /* __s390x__ */
-
 static int __init init_cpu_info(enum arch_id arch)
 {
-        union save_area *sa;
+        struct save_area *sa;
 
         /* get info for boot cpu from lowcore, stored in the HSA */
 
@@ -241,20 +199,12 @@ static int __init init_cpu_info(enum arch_id arch)
                 return -EIO;
         }
         zfcpdump_save_areas[0] = sa;
-
-#ifdef __s390x__
-        /* convert s390x regs to s390, if we are dumping an s390 Linux */
-
-        if (arch == ARCH_S390)
-                s390x_to_s390_save_areas();
-#endif
-
         return 0;
 }
 
 static DEFINE_MUTEX(zcore_mutex);
 
-#define DUMP_VERSION    0x3
+#define DUMP_VERSION    0x5
 #define DUMP_MAGIC      0xa8190173618f23fdULL
 #define DUMP_ARCH_S390X 2
 #define DUMP_ARCH_S390  1
@@ -279,7 +229,14 @@ struct zcore_header {
         u32 volnr;
         u32 build_arch;
         u64 rmem_size;
-        char pad2[4016];
+        u8 mvdump;
+        u16 cpu_cnt;
+        u16 real_cpu_cnt;
+        u8 end_pad1[0x200-0x061];
+        u64 mvdump_sign;
+        u64 mvdump_zipl_time;
+        u8 end_pad2[0x800-0x210];
+        u32 lc_vec[512];
 } __attribute__((packed,__aligned__(16)));
 
 static struct zcore_header zcore_header = {
@@ -289,7 +246,7 @@ static struct zcore_header zcore_header = {
         .dump_level     = 0,
         .page_size      = PAGE_SIZE,
         .mem_start      = 0,
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
         .build_arch     = DUMP_ARCH_S390X,
 #else
         .build_arch     = DUMP_ARCH_S390,
@@ -340,11 +297,7 @@ static int zcore_add_lc(char __user *buf, unsigned long start, size_t count)
                 unsigned long prefix;
                 unsigned long sa_off, len, buf_off;
 
-                if (sys_info.arch == ARCH_S390)
-                        prefix = zfcpdump_save_areas[i]->s390.pref_reg;
-                else
-                        prefix = zfcpdump_save_areas[i]->s390x.pref_reg;
-
+                prefix = zfcpdump_save_areas[i]->pref_reg;
                 sa_start = prefix + sys_info.sa_base;
                 sa_end = prefix + sys_info.sa_base + sys_info.sa_size;
 
@@ -561,34 +514,39 @@ static const struct file_operations zcore_reipl_fops = {
         .release        = zcore_reipl_release,
 };
 
+#ifdef CONFIG_32BIT
 
-static void __init set_s390_lc_mask(union save_area *map)
+static void __init set_lc_mask(struct save_area *map)
 {
-        memset(&map->s390.ext_save, 0xff, sizeof(map->s390.ext_save));
-        memset(&map->s390.timer, 0xff, sizeof(map->s390.timer));
-        memset(&map->s390.clk_cmp, 0xff, sizeof(map->s390.clk_cmp));
-        memset(&map->s390.psw, 0xff, sizeof(map->s390.psw));
-        memset(&map->s390.pref_reg, 0xff, sizeof(map->s390.pref_reg));
-        memset(&map->s390.acc_regs, 0xff, sizeof(map->s390.acc_regs));
-        memset(&map->s390.fp_regs, 0xff, sizeof(map->s390.fp_regs));
-        memset(&map->s390.gp_regs, 0xff, sizeof(map->s390.gp_regs));
-        memset(&map->s390.ctrl_regs, 0xff, sizeof(map->s390.ctrl_regs));
+        memset(&map->ext_save, 0xff, sizeof(map->ext_save));
+        memset(&map->timer, 0xff, sizeof(map->timer));
+        memset(&map->clk_cmp, 0xff, sizeof(map->clk_cmp));
+        memset(&map->psw, 0xff, sizeof(map->psw));
+        memset(&map->pref_reg, 0xff, sizeof(map->pref_reg));
+        memset(&map->acc_regs, 0xff, sizeof(map->acc_regs));
+        memset(&map->fp_regs, 0xff, sizeof(map->fp_regs));
+        memset(&map->gp_regs, 0xff, sizeof(map->gp_regs));
+        memset(&map->ctrl_regs, 0xff, sizeof(map->ctrl_regs));
 }
 
-static void __init set_s390x_lc_mask(union save_area *map)
+#else /* CONFIG_32BIT */
+
+static void __init set_lc_mask(struct save_area *map)
 {
-        memset(&map->s390x.fp_regs, 0xff, sizeof(map->s390x.fp_regs));
-        memset(&map->s390x.gp_regs, 0xff, sizeof(map->s390x.gp_regs));
-        memset(&map->s390x.psw, 0xff, sizeof(map->s390x.psw));
-        memset(&map->s390x.pref_reg, 0xff, sizeof(map->s390x.pref_reg));
-        memset(&map->s390x.fp_ctrl_reg, 0xff, sizeof(map->s390x.fp_ctrl_reg));
-        memset(&map->s390x.tod_reg, 0xff, sizeof(map->s390x.tod_reg));
-        memset(&map->s390x.timer, 0xff, sizeof(map->s390x.timer));
-        memset(&map->s390x.clk_cmp, 0xff, sizeof(map->s390x.clk_cmp));
-        memset(&map->s390x.acc_regs, 0xff, sizeof(map->s390x.acc_regs));
-        memset(&map->s390x.ctrl_regs, 0xff, sizeof(map->s390x.ctrl_regs));
+        memset(&map->fp_regs, 0xff, sizeof(map->fp_regs));
+        memset(&map->gp_regs, 0xff, sizeof(map->gp_regs));
+        memset(&map->psw, 0xff, sizeof(map->psw));
+        memset(&map->pref_reg, 0xff, sizeof(map->pref_reg));
+        memset(&map->fp_ctrl_reg, 0xff, sizeof(map->fp_ctrl_reg));
+        memset(&map->tod_reg, 0xff, sizeof(map->tod_reg));
+        memset(&map->timer, 0xff, sizeof(map->timer));
+        memset(&map->clk_cmp, 0xff, sizeof(map->clk_cmp));
+        memset(&map->acc_regs, 0xff, sizeof(map->acc_regs));
+        memset(&map->ctrl_regs, 0xff, sizeof(map->ctrl_regs));
 }
 
+#endif /* CONFIG_32BIT */
+
 /*
  * Initialize dump globals for a given architecture
  */
@@ -599,21 +557,18 @@ static int __init sys_info_init(enum arch_id arch)
         switch (arch) {
         case ARCH_S390X:
                 pr_alert("DETECTED 'S390X (64 bit) OS'\n");
-                sys_info.sa_base = SAVE_AREA_BASE_S390X;
-                sys_info.sa_size = sizeof(struct save_area_s390x);
-                set_s390x_lc_mask(&sys_info.lc_mask);
                 break;
         case ARCH_S390:
                 pr_alert("DETECTED 'S390 (32 bit) OS'\n");
-                sys_info.sa_base = SAVE_AREA_BASE_S390;
-                sys_info.sa_size = sizeof(struct save_area_s390);
-                set_s390_lc_mask(&sys_info.lc_mask);
                 break;
         default:
                 pr_alert("0x%x is an unknown architecture.\n",arch);
                 return -EINVAL;
         }
+        sys_info.sa_base = SAVE_AREA_BASE;
+        sys_info.sa_size = sizeof(struct save_area);
         sys_info.arch = arch;
+        set_lc_mask(&sys_info.lc_mask);
         rc = init_cpu_info(arch);
         if (rc)
                 return rc;
@@ -660,8 +615,9 @@ static int __init get_mem_size(unsigned long *mem)
 
 static int __init zcore_header_init(int arch, struct zcore_header *hdr)
 {
-        int rc;
+        int rc, i;
         unsigned long memory = 0;
+        u32 prefix;
 
         if (arch == ARCH_S390X)
                 hdr->arch_id = DUMP_ARCH_S390X;
@@ -676,6 +632,14 @@ static int __init zcore_header_init(int arch, struct zcore_header *hdr)
         hdr->num_pages = memory / PAGE_SIZE;
         hdr->tod = get_clock();
         get_cpu_id(&hdr->cpu_id);
+        for (i = 0; zfcpdump_save_areas[i]; i++) {
+                prefix = zfcpdump_save_areas[i]->pref_reg;
+                hdr->real_cpu_cnt++;
+                if (!prefix)
+                        continue;
+                hdr->lc_vec[hdr->cpu_cnt] = prefix;
+                hdr->cpu_cnt++;
+        }
         return 0;
 }
 
@@ -741,14 +705,21 @@ static int __init zcore_init(void)
         if (rc)
                 goto fail;
 
-#ifndef __s390x__
+#ifdef CONFIG_64BIT
+        if (arch == ARCH_S390) {
+                pr_alert("The 64-bit dump tool cannot be used for a "
+                         "32-bit system\n");
+                rc = -EINVAL;
+                goto fail;
+        }
+#else /* CONFIG_64BIT */
         if (arch == ARCH_S390X) {
                 pr_alert("The 32-bit dump tool cannot be used for a "
                          "64-bit system\n");
                 rc = -EINVAL;
                 goto fail;
         }
-#endif
+#endif /* CONFIG_64BIT */
 
         rc = sys_info_init(arch);
         if (rc)
diff --git a/drivers/s390/cio/ccwreq.c b/drivers/s390/cio/ccwreq.c
index 7a28a3029a3f..37df42af05ec 100644
--- a/drivers/s390/cio/ccwreq.c
+++ b/drivers/s390/cio/ccwreq.c
@@ -224,8 +224,8 @@ static void ccwreq_log_status(struct ccw_device *cdev, enum io_status status)
  */
 void ccw_request_handler(struct ccw_device *cdev)
 {
+        struct irb *irb = (struct irb *)&S390_lowcore.irb;
         struct ccw_request *req = &cdev->private->req;
-        struct irb *irb = (struct irb *) __LC_IRB;
         enum io_status status;
         int rc = -EOPNOTSUPP;
 
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index 1ecd3e567648..4038f5b4f144 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -574,7 +574,7 @@ int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
         secm_area->request.length = 0x0050;
         secm_area->request.code = 0x0016;
 
-        secm_area->key = PAGE_DEFAULT_KEY;
+        secm_area->key = PAGE_DEFAULT_KEY >> 4;
         secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
         secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
 
diff --git a/drivers/s390/cio/chsc_sch.c b/drivers/s390/cio/chsc_sch.c
index c84ac9443079..852612f5dba0 100644
--- a/drivers/s390/cio/chsc_sch.c
+++ b/drivers/s390/cio/chsc_sch.c
@@ -51,7 +51,7 @@ static void chsc_subchannel_irq(struct subchannel *sch)
 {
         struct chsc_private *private = sch->private;
         struct chsc_request *request = private->request;
-        struct irb *irb = (struct irb *)__LC_IRB;
+        struct irb *irb = (struct irb *)&S390_lowcore.irb;
 
         CHSC_LOG(4, "irb");
         CHSC_LOG_HEX(4, irb, sizeof(*irb));
@@ -237,7 +237,7 @@ static int chsc_async(struct chsc_async_area *chsc_area,
         int ret = -ENODEV;
         char dbf[10];
 
-        chsc_area->header.key = PAGE_DEFAULT_KEY;
+        chsc_area->header.key = PAGE_DEFAULT_KEY >> 4;
         while ((sch = chsc_get_next_subchannel(sch))) {
                 spin_lock(sch->lock);
                 private = sch->private;
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 126f240715a4..f736cdcf08ad 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -625,8 +625,8 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
         /*
          * Get interrupt information from lowcore
          */
-        tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
-        irb = (struct irb *) __LC_IRB;
+        tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
+        irb = (struct irb *)&S390_lowcore.irb;
         do {
                 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
                 /*
@@ -661,7 +661,7 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
                  * We don't do this for VM because a tpi drops the cpu
                  * out of the sie which costs more cycles than it saves.
                  */
-        } while (!MACHINE_IS_VM && tpi (NULL) != 0);
+        } while (MACHINE_IS_LPAR && tpi(NULL) != 0);
         irq_exit();
         set_irq_regs(old_regs);
 }
@@ -682,10 +682,10 @@ static int cio_tpi(void)
         struct irb *irb;
         int irq_context;
 
-        tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
+        tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
         if (tpi(NULL) != 1)
                 return 0;
-        irb = (struct irb *) __LC_IRB;
+        irb = (struct irb *)&S390_lowcore.irb;
         /* Store interrupt response block to lowcore. */
         if (tsch(tpi_info->schid, irb) != 0)
                 /* Not status pending or not operational. */
@@ -885,7 +885,7 @@ __clear_io_subchannel_easy(struct subchannel_id schid)
                 struct tpi_info ti;
 
                 if (tpi(&ti)) {
-                        tsch(ti.schid, (struct irb *)__LC_IRB);
+                        tsch(ti.schid, (struct irb *)&S390_lowcore.irb);
                         if (schid_equal(&ti.schid, &schid))
                                 return 0;
                 }
@@ -1083,7 +1083,7 @@ int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
         struct subchannel_id schid;
         struct schib schib;
 
-        schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
+        schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id;
         if (!schid.one)
                 return -ENODEV;
         if (stsch(schid, &schib))
diff --git a/drivers/s390/cio/crw.c b/drivers/s390/cio/crw.c
index d157665d0e76..425f741a280c 100644
--- a/drivers/s390/cio/crw.c
+++ b/drivers/s390/cio/crw.c
@@ -8,15 +8,16 @@
  *               Heiko Carstens <heiko.carstens@de.ibm.com>,
  */
 
-#include <linux/semaphore.h>
 #include <linux/mutex.h>
 #include <linux/kthread.h>
 #include <linux/init.h>
+#include <linux/wait.h>
 #include <asm/crw.h>
 
-static struct semaphore crw_semaphore;
 static DEFINE_MUTEX(crw_handler_mutex);
 static crw_handler_t crw_handlers[NR_RSCS];
+static atomic_t crw_nr_req = ATOMIC_INIT(0);
+static DECLARE_WAIT_QUEUE_HEAD(crw_handler_wait_q);
 
 /**
  * crw_register_handler() - register a channel report word handler
@@ -59,12 +60,14 @@ void crw_unregister_handler(int rsc)
 static int crw_collect_info(void *unused)
 {
         struct crw crw[2];
-        int ccode;
+        int ccode, signal;
         unsigned int chain;
-        int ignore;
 
 repeat:
-        ignore = down_interruptible(&crw_semaphore);
+        signal = wait_event_interruptible(crw_handler_wait_q,
+                                          atomic_read(&crw_nr_req) > 0);
+        if (unlikely(signal))
+                atomic_inc(&crw_nr_req);
         chain = 0;
         while (1) {
                 crw_handler_t handler;
@@ -122,25 +125,23 @@ repeat:
                 /* chain is always 0 or 1 here. */
                 chain = crw[chain].chn ? chain + 1 : 0;
         }
+        if (atomic_dec_and_test(&crw_nr_req))
+                wake_up(&crw_handler_wait_q);
         goto repeat;
         return 0;
 }
 
 void crw_handle_channel_report(void)
 {
-        up(&crw_semaphore);
+        atomic_inc(&crw_nr_req);
+        wake_up(&crw_handler_wait_q);
 }
 
-/*
- * Separate initcall needed for semaphore initialization since
- * crw_handle_channel_report might be called before crw_machine_check_init.
- */
-static int __init crw_init_semaphore(void)
+void crw_wait_for_channel_report(void)
 {
-        init_MUTEX_LOCKED(&crw_semaphore);
-        return 0;
+        crw_handle_channel_report();
+        wait_event(crw_handler_wait_q, atomic_read(&crw_nr_req) == 0);
 }
-pure_initcall(crw_init_semaphore);
 
 /*
  * Machine checks for the channel subsystem must be enabled
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 7679aee6fa14..2769da54f2b9 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -18,6 +18,7 @@
 #include <linux/list.h>
 #include <linux/reboot.h>
 #include <linux/suspend.h>
+#include <linux/proc_fs.h>
 #include <asm/isc.h>
 #include <asm/crw.h>
 
@@ -232,7 +233,7 @@ void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo)
         if (!get_device(&sch->dev))
                 return;
         sch->todo = todo;
-        if (!queue_work(slow_path_wq, &sch->todo_work)) {
+        if (!queue_work(cio_work_q, &sch->todo_work)) {
                 /* Already queued, release workqueue ref. */
                 put_device(&sch->dev);
         }
@@ -543,7 +544,7 @@ static void css_slow_path_func(struct work_struct *unused)
 }
 
 static DECLARE_WORK(slow_path_work, css_slow_path_func);
-struct workqueue_struct *slow_path_wq;
+struct workqueue_struct *cio_work_q;
 
 void css_schedule_eval(struct subchannel_id schid)
 {
@@ -552,7 +553,7 @@ void css_schedule_eval(struct subchannel_id schid)
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         idset_sch_add(slow_subchannel_set, schid);
         atomic_set(&css_eval_scheduled, 1);
-        queue_work(slow_path_wq, &slow_path_work);
+        queue_work(cio_work_q, &slow_path_work);
         spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 
@@ -563,7 +564,7 @@ void css_schedule_eval_all(void)
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         idset_fill(slow_subchannel_set);
         atomic_set(&css_eval_scheduled, 1);
-        queue_work(slow_path_wq, &slow_path_work);
+        queue_work(cio_work_q, &slow_path_work);
         spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 
@@ -594,14 +595,14 @@ void css_schedule_eval_all_unreg(void)
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         idset_add_set(slow_subchannel_set, unreg_set);
         atomic_set(&css_eval_scheduled, 1);
-        queue_work(slow_path_wq, &slow_path_work);
+        queue_work(cio_work_q, &slow_path_work);
         spin_unlock_irqrestore(&slow_subchannel_lock, flags);
         idset_free(unreg_set);
 }
 
 void css_wait_for_slow_path(void)
 {
-        flush_workqueue(slow_path_wq);
+        flush_workqueue(cio_work_q);
 }
 
 /* Schedule reprobing of all unregistered subchannels. */
@@ -992,12 +993,21 @@ static int __init channel_subsystem_init(void)
         ret = css_bus_init();
         if (ret)
                 return ret;
-
+        cio_work_q = create_singlethread_workqueue("cio");
+        if (!cio_work_q) {
+                ret = -ENOMEM;
+                goto out_bus;
+        }
         ret = io_subchannel_init();
         if (ret)
-                css_bus_cleanup();
+                goto out_wq;
 
         return ret;
+out_wq:
+        destroy_workqueue(cio_work_q);
+out_bus:
+        css_bus_cleanup();
+        return ret;
 }
 subsys_initcall(channel_subsystem_init);
 
@@ -1006,10 +1016,25 @@ static int css_settle(struct device_driver *drv, void *unused)
         struct css_driver *cssdrv = to_cssdriver(drv);
 
         if (cssdrv->settle)
-                cssdrv->settle();
+                return cssdrv->settle();
         return 0;
 }
 
+int css_complete_work(void)
+{
+        int ret;
+
+        /* Wait for the evaluation of subchannels to finish. */
+        ret = wait_event_interruptible(css_eval_wq,
+                                       atomic_read(&css_eval_scheduled) == 0);
+        if (ret)
+                return -EINTR;
+        flush_workqueue(cio_work_q);
+        /* Wait for the subchannel type specific initialization to finish */
+        return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
+}
+
+
 /*
  * Wait for the initialization of devices to finish, to make sure we are
  * done with our setup if the search for the root device starts.
@@ -1018,13 +1043,41 @@ static int __init channel_subsystem_init_sync(void)
 {
         /* Start initial subchannel evaluation. */
         css_schedule_eval_all();
-        /* Wait for the evaluation of subchannels to finish. */
-        wait_event(css_eval_wq, atomic_read(&css_eval_scheduled) == 0);
-        /* Wait for the subchannel type specific initialization to finish */
-        return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
+        css_complete_work();
+        return 0;
 }
 subsys_initcall_sync(channel_subsystem_init_sync);
 
+#ifdef CONFIG_PROC_FS
+static ssize_t cio_settle_write(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        int ret;
+
+        /* Handle pending CRW's. */
+        crw_wait_for_channel_report();
+        ret = css_complete_work();
+
+        return ret ? ret : count;
+}
+
+static const struct file_operations cio_settle_proc_fops = {
+        .write = cio_settle_write,
+};
+
+static int __init cio_settle_init(void)
+{
+        struct proc_dir_entry *entry;
+
+        entry = proc_create("cio_settle", S_IWUSR, NULL,
+                            &cio_settle_proc_fops);
+        if (!entry)
+                return -ENOMEM;
+        return 0;
+}
+device_initcall(cio_settle_init);
+#endif /*CONFIG_PROC_FS*/
+
 int sch_is_pseudo_sch(struct subchannel *sch)
 {
         return sch == to_css(sch->dev.parent)->pseudo_subchannel;
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index fe84b92cde60..7e37886de231 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -95,7 +95,7 @@ struct css_driver {
         int (*freeze)(struct subchannel *);
         int (*thaw) (struct subchannel *);
         int (*restore)(struct subchannel *);
-        void (*settle)(void);
+        int (*settle)(void);
         const char *name;
 };
 
@@ -146,12 +146,13 @@ extern struct channel_subsystem *channel_subsystems[];
 /* Helper functions to build lists for the slow path. */
 void css_schedule_eval(struct subchannel_id schid);
 void css_schedule_eval_all(void);
+int css_complete_work(void);
 
 int sch_is_pseudo_sch(struct subchannel *);
 struct schib;
 int css_sch_is_valid(struct schib *);
 
-extern struct workqueue_struct *slow_path_wq;
+extern struct workqueue_struct *cio_work_q;
 void css_wait_for_slow_path(void);
 void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo);
 #endif
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index a6c7d5426fb2..c6abb75c4615 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -136,7 +136,6 @@ static int io_subchannel_sch_event(struct subchannel *, int);
 static int io_subchannel_chp_event(struct subchannel *, struct chp_link *,
                                    int);
 static void recovery_func(unsigned long data);
-struct workqueue_struct *ccw_device_work;
 wait_queue_head_t ccw_device_init_wq;
 atomic_t ccw_device_init_count;
 
@@ -159,11 +158,16 @@ static int io_subchannel_prepare(struct subchannel *sch)
         return 0;
 }
 
-static void io_subchannel_settle(void)
+static int io_subchannel_settle(void)
 {
-        wait_event(ccw_device_init_wq,
-                   atomic_read(&ccw_device_init_count) == 0);
-        flush_workqueue(ccw_device_work);
+        int ret;
+
+        ret = wait_event_interruptible(ccw_device_init_wq,
+                                atomic_read(&ccw_device_init_count) == 0);
+        if (ret)
+                return -EINTR;
+        flush_workqueue(cio_work_q);
+        return 0;
 }
 
 static struct css_driver io_subchannel_driver = {
@@ -188,27 +192,13 @@ int __init io_subchannel_init(void)
         atomic_set(&ccw_device_init_count, 0);
         setup_timer(&recovery_timer, recovery_func, 0);
 
-        ccw_device_work = create_singlethread_workqueue("cio");
-        if (!ccw_device_work)
-                return -ENOMEM;
-        slow_path_wq = create_singlethread_workqueue("kslowcrw");
-        if (!slow_path_wq) {
-                ret = -ENOMEM;
-                goto out_err;
-        }
-        if ((ret = bus_register (&ccw_bus_type)))
-                goto out_err;
-
+        ret = bus_register(&ccw_bus_type);
+        if (ret)
+                return ret;
         ret = css_driver_register(&io_subchannel_driver);
         if (ret)
-                goto out_err;
+                bus_unregister(&ccw_bus_type);
 
-        return 0;
-out_err:
-        if (ccw_device_work)
-                destroy_workqueue(ccw_device_work);
-        if (slow_path_wq)
-                destroy_workqueue(slow_path_wq);
         return ret;
 }
 
@@ -1348,7 +1338,7 @@ static enum io_sch_action sch_get_action(struct subchannel *sch)
                 /* Not operational. */
                 if (!cdev)
                         return IO_SCH_UNREG;
-                if (!ccw_device_notify(cdev, CIO_GONE))
+                if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
                         return IO_SCH_UNREG;
                 return IO_SCH_ORPH_UNREG;
         }
@@ -1356,12 +1346,12 @@ static enum io_sch_action sch_get_action(struct subchannel *sch)
         if (!cdev)
                 return IO_SCH_ATTACH;
         if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
-                if (!ccw_device_notify(cdev, CIO_GONE))
+                if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
                         return IO_SCH_UNREG_ATTACH;
                 return IO_SCH_ORPH_ATTACH;
         }
         if ((sch->schib.pmcw.pam & sch->opm) == 0) {
-                if (!ccw_device_notify(cdev, CIO_NO_PATH))
+                if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
                         return IO_SCH_UNREG;
                 return IO_SCH_DISC;
         }
@@ -1410,6 +1400,12 @@ static int io_subchannel_sch_event(struct subchannel *sch, int process)
                 rc = 0;
                 goto out_unlock;
         case IO_SCH_VERIFY:
+                if (cdev->private->flags.resuming == 1) {
+                        if (cio_enable_subchannel(sch, (u32)(addr_t)sch)) {
+                                ccw_device_set_notoper(cdev);
+                                break;
+                        }
+                }
                 /* Trigger path verification. */
                 io_subchannel_verify(sch);
                 rc = 0;
@@ -1448,7 +1444,8 @@ static int io_subchannel_sch_event(struct subchannel *sch, int process)
                 break;
         case IO_SCH_UNREG_ATTACH:
                 /* Unregister ccw device. */
-                ccw_device_unregister(cdev);
+                if (!cdev->private->flags.resuming)
+                        ccw_device_unregister(cdev);
                 break;
         default:
                 break;
@@ -1457,7 +1454,8 @@ static int io_subchannel_sch_event(struct subchannel *sch, int process)
         switch (action) {
         case IO_SCH_ORPH_UNREG:
         case IO_SCH_UNREG:
-                css_sch_device_unregister(sch);
+                if (!cdev || !cdev->private->flags.resuming)
+                        css_sch_device_unregister(sch);
                 break;
         case IO_SCH_ORPH_ATTACH:
         case IO_SCH_UNREG_ATTACH:
@@ -1779,26 +1777,42 @@ static void __ccw_device_pm_restore(struct ccw_device *cdev)
 {
         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 
-        if (cio_is_console(sch->schid))
-                goto out;
+        spin_lock_irq(sch->lock);
+        if (cio_is_console(sch->schid)) {
+                cio_enable_subchannel(sch, (u32)(addr_t)sch);
+                goto out_unlock;
+        }
         /*
          * While we were sleeping, devices may have gone or become
          * available again. Kick re-detection.
          */
-        spin_lock_irq(sch->lock);
         cdev->private->flags.resuming = 1;
+        css_schedule_eval(sch->schid);
+        spin_unlock_irq(sch->lock);
+        css_complete_work();
+
+        /* cdev may have been moved to a different subchannel. */
+        sch = to_subchannel(cdev->dev.parent);
+        spin_lock_irq(sch->lock);
+        if (cdev->private->state != DEV_STATE_ONLINE &&
+            cdev->private->state != DEV_STATE_OFFLINE)
+                goto out_unlock;
+
         ccw_device_recognition(cdev);
         spin_unlock_irq(sch->lock);
         wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev) ||
                    cdev->private->state == DEV_STATE_DISCONNECTED);
-out:
+        spin_lock_irq(sch->lock);
+
+out_unlock:
         cdev->private->flags.resuming = 0;
+        spin_unlock_irq(sch->lock);
 }
 
 static int resume_handle_boxed(struct ccw_device *cdev)
 {
         cdev->private->state = DEV_STATE_BOXED;
-        if (ccw_device_notify(cdev, CIO_BOXED))
+        if (ccw_device_notify(cdev, CIO_BOXED) == NOTIFY_OK)
                 return 0;
         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
         return -ENODEV;
@@ -1807,7 +1821,7 @@ static int resume_handle_boxed(struct ccw_device *cdev)
 static int resume_handle_disc(struct ccw_device *cdev)
 {
         cdev->private->state = DEV_STATE_DISCONNECTED;
-        if (ccw_device_notify(cdev, CIO_GONE))
+        if (ccw_device_notify(cdev, CIO_GONE) == NOTIFY_OK)
                 return 0;
         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
         return -ENODEV;
@@ -1816,40 +1830,31 @@ static int resume_handle_disc(struct ccw_device *cdev)
 static int ccw_device_pm_restore(struct device *dev)
 {
         struct ccw_device *cdev = to_ccwdev(dev);
-        struct subchannel *sch = to_subchannel(cdev->dev.parent);
-        int ret = 0, cm_enabled;
+        struct subchannel *sch;
+        int ret = 0;
 
         __ccw_device_pm_restore(cdev);
+        sch = to_subchannel(cdev->dev.parent);
         spin_lock_irq(sch->lock);
-        if (cio_is_console(sch->schid)) {
-                cio_enable_subchannel(sch, (u32)(addr_t)sch);
-                spin_unlock_irq(sch->lock);
+        if (cio_is_console(sch->schid))
                 goto out_restore;
-        }
-        cdev->private->flags.donotify = 0;
+
         /* check recognition results */
         switch (cdev->private->state) {
         case DEV_STATE_OFFLINE:
+        case DEV_STATE_ONLINE:
+                cdev->private->flags.donotify = 0;
                 break;
         case DEV_STATE_BOXED:
                 ret = resume_handle_boxed(cdev);
-                spin_unlock_irq(sch->lock);
                 if (ret)
-                        goto out;
+                        goto out_unlock;
                 goto out_restore;
-        case DEV_STATE_DISCONNECTED:
-                goto out_disc_unlock;
         default:
-                goto out_unreg_unlock;
-        }
-        /* check if the device id has changed */
-        if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
-                CIO_MSG_EVENT(0, "resume: sch 0.%x.%04x: failed (devno "
-                              "changed from %04x to %04x)\n",
-                              sch->schid.ssid, sch->schid.sch_no,
-                              cdev->private->dev_id.devno,
-                              sch->schib.pmcw.dev);
-                goto out_unreg_unlock;
+                ret = resume_handle_disc(cdev);
+                if (ret)
+                        goto out_unlock;
+                goto out_restore;
         }
         /* check if the device type has changed */
         if (!ccw_device_test_sense_data(cdev)) {
@@ -1858,24 +1863,30 @@ static int ccw_device_pm_restore(struct device *dev)
                 ret = -ENODEV;
                 goto out_unlock;
         }
-        if (!cdev->online) {
-                ret = 0;
+        if (!cdev->online)
                 goto out_unlock;
-        }
-        ret = ccw_device_online(cdev);
-        if (ret)
-                goto out_disc_unlock;
 
-        cm_enabled = cdev->private->cmb != NULL;
+        if (ccw_device_online(cdev)) {
+                ret = resume_handle_disc(cdev);
+                if (ret)
+                        goto out_unlock;
+                goto out_restore;
+        }
         spin_unlock_irq(sch->lock);
-
         wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
-        if (cdev->private->state != DEV_STATE_ONLINE) {
-                spin_lock_irq(sch->lock);
-                goto out_disc_unlock;
+        spin_lock_irq(sch->lock);
+
+        if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_BAD) {
+                ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
+                ret = -ENODEV;
+                goto out_unlock;
         }
-        if (cm_enabled) {
+
+        /* reenable cmf, if needed */
+        if (cdev->private->cmb) {
+                spin_unlock_irq(sch->lock);
                 ret = ccw_set_cmf(cdev, 1);
+                spin_lock_irq(sch->lock);
                 if (ret) {
                         CIO_MSG_EVENT(2, "resume: cdev 0.%x.%04x: cmf failed "
                                       "(rc=%d)\n", cdev->private->dev_id.ssid,
@@ -1885,21 +1896,11 @@ static int ccw_device_pm_restore(struct device *dev)
         }
 
 out_restore:
+        spin_unlock_irq(sch->lock);
         if (cdev->online && cdev->drv && cdev->drv->restore)
                 ret = cdev->drv->restore(cdev);
-out:
         return ret;
 
-out_disc_unlock:
-        ret = resume_handle_disc(cdev);
-        spin_unlock_irq(sch->lock);
-        if (ret)
-                return ret;
-        goto out_restore;
-
-out_unreg_unlock:
-        ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);
-        ret = -ENODEV;
 out_unlock:
         spin_unlock_irq(sch->lock);
         return ret;
@@ -2028,7 +2029,7 @@ void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)
         /* Get workqueue ref. */
         if (!get_device(&cdev->dev))
                 return;
-        if (!queue_work(slow_path_wq, &cdev->private->todo_work)) {
+        if (!queue_work(cio_work_q, &cdev->private->todo_work)) {
                 /* Already queued, release workqueue ref. */
                 put_device(&cdev->dev);
         }
@@ -2041,5 +2042,4 @@ EXPORT_SYMBOL(ccw_driver_register);
 EXPORT_SYMBOL(ccw_driver_unregister);
 EXPORT_SYMBOL(get_ccwdev_by_busid);
 EXPORT_SYMBOL(ccw_bus_type);
-EXPORT_SYMBOL(ccw_device_work);
 EXPORT_SYMBOL_GPL(ccw_device_get_subchannel_id);
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index bcfe13e42638..379de2d1ec49 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -4,7 +4,7 @@
 #include <asm/ccwdev.h>
 #include <asm/atomic.h>
 #include <linux/wait.h>
-
+#include <linux/notifier.h>
 #include "io_sch.h"
 
 /*
@@ -71,7 +71,6 @@ dev_fsm_final_state(struct ccw_device *cdev)
                 cdev->private->state == DEV_STATE_BOXED);
 }
 
-extern struct workqueue_struct *ccw_device_work;
 extern wait_queue_head_t ccw_device_init_wq;
 extern atomic_t ccw_device_init_count;
 int __init io_subchannel_init(void);
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index ae760658a131..c56ab94612f9 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -313,21 +313,43 @@ ccw_device_sense_id_done(struct ccw_device *cdev, int err)
         }
 }
 
+/**
+  * ccw_device_notify() - inform the device's driver about an event
+  * @cdev: device for which an event occured
+  * @event: event that occurred
+  *
+  * Returns:
+  *   -%EINVAL if the device is offline or has no driver.
+  *   -%EOPNOTSUPP if the device's driver has no notifier registered.
+  *   %NOTIFY_OK if the driver wants to keep the device.
+  *   %NOTIFY_BAD if the driver doesn't want to keep the device.
+  */
 int ccw_device_notify(struct ccw_device *cdev, int event)
 {
+        int ret = -EINVAL;
+
         if (!cdev->drv)
-                return 0;
+                goto out;
         if (!cdev->online)
-                return 0;
+                goto out;
         CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
                       cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
                       event);
-        return cdev->drv->notify ? cdev->drv->notify(cdev, event) : 0;
+        if (!cdev->drv->notify) {
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
+        if (cdev->drv->notify(cdev, event))
+                ret = NOTIFY_OK;
+        else
+                ret = NOTIFY_BAD;
+out:
+        return ret;
 }
 
 static void ccw_device_oper_notify(struct ccw_device *cdev)
 {
-        if (ccw_device_notify(cdev, CIO_OPER)) {
+        if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_OK) {
                 /* Reenable channel measurements, if needed. */
                 ccw_device_sched_todo(cdev, CDEV_TODO_ENABLE_CMF);
                 return;
@@ -361,14 +383,15 @@ ccw_device_done(struct ccw_device *cdev, int state)
         case DEV_STATE_BOXED:
                 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
                               cdev->private->dev_id.devno, sch->schid.sch_no);
-                if (cdev->online && !ccw_device_notify(cdev, CIO_BOXED))
+                if (cdev->online &&
+                    ccw_device_notify(cdev, CIO_BOXED) != NOTIFY_OK)
                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 cdev->private->flags.donotify = 0;
                 break;
         case DEV_STATE_NOT_OPER:
                 CIO_MSG_EVENT(0, "Device %04x gone on subchannel %04x\n",
                               cdev->private->dev_id.devno, sch->schid.sch_no);
-                if (!ccw_device_notify(cdev, CIO_GONE))
+                if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 else
                         ccw_device_set_disconnected(cdev);
@@ -378,7 +401,7 @@ ccw_device_done(struct ccw_device *cdev, int state)
                 CIO_MSG_EVENT(0, "Disconnected device %04x on subchannel "
                               "%04x\n", cdev->private->dev_id.devno,
                               sch->schid.sch_no);
-                if (!ccw_device_notify(cdev, CIO_NO_PATH))
+                if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 else
                         ccw_device_set_disconnected(cdev);
@@ -586,7 +609,7 @@ ccw_device_offline(struct ccw_device *cdev)
 static void ccw_device_generic_notoper(struct ccw_device *cdev,
                                        enum dev_event dev_event)
 {
-        if (!ccw_device_notify(cdev, CIO_GONE))
+        if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
                 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
         else
                 ccw_device_set_disconnected(cdev);
@@ -667,7 +690,7 @@ ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
         struct irb *irb;
         int is_cmd;
 
-        irb = (struct irb *) __LC_IRB;
+        irb = (struct irb *)&S390_lowcore.irb;
         is_cmd = !scsw_is_tm(&irb->scsw);
         /* Check for unsolicited interrupt. */
         if (!scsw_is_solicited(&irb->scsw)) {
@@ -732,7 +755,7 @@ ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
 {
         struct irb *irb;
 
-        irb = (struct irb *) __LC_IRB;
+        irb = (struct irb *)&S390_lowcore.irb;
         /* Check for unsolicited interrupt. */
         if (scsw_stctl(&irb->scsw) ==
             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
diff --git a/drivers/s390/cio/qdio.h b/drivers/s390/cio/qdio.h
index 44f2f6a97f33..48aa0647432b 100644
--- a/drivers/s390/cio/qdio.h
+++ b/drivers/s390/cio/qdio.h
@@ -208,18 +208,27 @@ struct qdio_dev_perf_stat {
         unsigned int eqbs_partial;
         unsigned int sqbs;
         unsigned int sqbs_partial;
+} ____cacheline_aligned;
+
+struct qdio_queue_perf_stat {
+        /*
+         * Sorted into order-2 buckets: 1, 2-3, 4-7, ... 64-127, 128.
+         * Since max. 127 SBALs are scanned reuse entry for 128 as queue full
+         * aka 127 SBALs found.
+         */
+        unsigned int nr_sbals[8];
+        unsigned int nr_sbal_error;
+        unsigned int nr_sbal_nop;
+        unsigned int nr_sbal_total;
 };
 
 struct qdio_input_q {
         /* input buffer acknowledgement flag */
         int polling;
-
         /* first ACK'ed buffer */
         int ack_start;
-
         /* how much sbals are acknowledged with qebsm */
         int ack_count;
-
         /* last time of noticing incoming data */
         u64 timestamp;
 };
@@ -227,40 +236,27 @@ struct qdio_input_q {
 struct qdio_output_q {
         /* PCIs are enabled for the queue */
         int pci_out_enabled;
-
         /* IQDIO: output multiple buffers (enhanced SIGA) */
         int use_enh_siga;
-
         /* timer to check for more outbound work */
         struct timer_list timer;
 };
 
+/*
+ * Note on cache alignment: grouped slsb and write mostly data at the beginning
+ * sbal[] is read-only and starts on a new cacheline followed by read mostly.
+ */
 struct qdio_q {
         struct slsb slsb;
+
         union {
                 struct qdio_input_q in;
                 struct qdio_output_q out;
         } u;
 
-        /* queue number */
-        int nr;
-
-        /* bitmask of queue number */
-        int mask;
-
-        /* input or output queue */
-        int is_input_q;
-
-        /* list of thinint input queues */
-        struct list_head entry;
-
-        /* upper-layer program handler */
-        qdio_handler_t (*handler);
-
         /*
          * inbound: next buffer the program should check for
-         * outbound: next buffer to check for having been processed
-         * by the card
+         * outbound: next buffer to check if adapter processed it
          */
         int first_to_check;
 
@@ -273,16 +269,32 @@ struct qdio_q {
         /* number of buffers in use by the adapter */
         atomic_t nr_buf_used;
 
-        struct qdio_irq *irq_ptr;
-        struct dentry *debugfs_q;
-        struct tasklet_struct tasklet;
-
         /* error condition during a data transfer */
         unsigned int qdio_error;
 
-        struct sl *sl;
-        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
+        struct tasklet_struct tasklet;
+        struct qdio_queue_perf_stat q_stats;
+
+        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q] ____cacheline_aligned;
+
+        /* queue number */
+        int nr;
+
+        /* bitmask of queue number */
+        int mask;
+
+        /* input or output queue */
+        int is_input_q;
+
+        /* list of thinint input queues */
+        struct list_head entry;
 
+        /* upper-layer program handler */
+        qdio_handler_t (*handler);
+
+        struct dentry *debugfs_q;
+        struct qdio_irq *irq_ptr;
+        struct sl *sl;
         /*
          * Warning: Leave this member at the end so it won't be cleared in
          * qdio_fill_qs. A page is allocated under this pointer and used for
@@ -317,12 +329,8 @@ struct qdio_irq {
         struct qdio_ssqd_desc ssqd_desc;
         void (*orig_handler) (struct ccw_device *, unsigned long, struct irb *);
 
-        struct qdio_dev_perf_stat perf_stat;
         int perf_stat_enabled;
-        /*
-         * Warning: Leave these members together at the end so they won't be
-         * cleared in qdio_setup_irq.
-         */
+
         struct qdr *qdr;
         unsigned long chsc_page;
 
@@ -331,6 +339,7 @@ struct qdio_irq {
 
         debug_info_t *debug_area;
         struct mutex setup_mutex;
+        struct qdio_dev_perf_stat perf_stat;
 };
 
 /* helper functions */
@@ -341,9 +350,20 @@ struct qdio_irq {
         (irq->qib.qfmt == QDIO_IQDIO_QFMT || \
          css_general_characteristics.aif_osa)
 
-#define qperf(qdev,attr)        qdev->perf_stat.attr
-#define qperf_inc(q,attr)       if (q->irq_ptr->perf_stat_enabled) \
-                                        q->irq_ptr->perf_stat.attr++
+#define qperf(__qdev, __attr)   ((__qdev)->perf_stat.(__attr))
+
+#define qperf_inc(__q, __attr)                                          \
+({                                                                      \
+        struct qdio_irq *qdev = (__q)->irq_ptr;                         \
+        if (qdev->perf_stat_enabled)                                    \
+                (qdev->perf_stat.__attr)++;                             \
+})
+
+static inline void account_sbals_error(struct qdio_q *q, int count)
+{
+        q->q_stats.nr_sbal_error += count;
+        q->q_stats.nr_sbal_total += count;
+}
 
 /* the highest iqdio queue is used for multicast */
 static inline int multicast_outbound(struct qdio_q *q)
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c
index f49761ff9a00..c94eb2a0fa2e 100644
--- a/drivers/s390/cio/qdio_debug.c
+++ b/drivers/s390/cio/qdio_debug.c
@@ -60,7 +60,7 @@ static int qstat_show(struct seq_file *m, void *v)
         seq_printf(m, "ftc: %d  last_move: %d\n", q->first_to_check, q->last_move);
         seq_printf(m, "polling: %d  ack start: %d  ack count: %d\n",
                    q->u.in.polling, q->u.in.ack_start, q->u.in.ack_count);
-        seq_printf(m, "slsb buffer states:\n");
+        seq_printf(m, "SBAL states:\n");
         seq_printf(m, "|0      |8      |16     |24     |32     |40     |48     |56  63|\n");
 
         for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
@@ -97,6 +97,20 @@ static int qstat_show(struct seq_file *m, void *v)
         }
         seq_printf(m, "\n");
         seq_printf(m, "|64     |72     |80     |88     |96     |104    |112    |   127|\n");
+
+        seq_printf(m, "\nSBAL statistics:");
+        if (!q->irq_ptr->perf_stat_enabled) {
+                seq_printf(m, " disabled\n");
+                return 0;
+        }
+
+        seq_printf(m, "\n1          2..        4..        8..        "
+                   "16..       32..       64..       127\n");
+        for (i = 0; i < ARRAY_SIZE(q->q_stats.nr_sbals); i++)
+                seq_printf(m, "%-10u ", q->q_stats.nr_sbals[i]);
+        seq_printf(m, "\nError      NOP        Total\n%-10u %-10u %-10u\n\n",
+                   q->q_stats.nr_sbal_error, q->q_stats.nr_sbal_nop,
+                   q->q_stats.nr_sbal_total);
         return 0;
 }
 
@@ -181,9 +195,10 @@ static ssize_t qperf_seq_write(struct file *file, const char __user *ubuf,
 {
         struct seq_file *seq = file->private_data;
         struct qdio_irq *irq_ptr = seq->private;
+        struct qdio_q *q;
         unsigned long val;
         char buf[8];
-        int ret;
+        int ret, i;
 
         if (!irq_ptr)
                 return 0;
@@ -201,6 +216,10 @@ static ssize_t qperf_seq_write(struct file *file, const char __user *ubuf,
         case 0:
                 irq_ptr->perf_stat_enabled = 0;
                 memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
+                for_each_input_queue(irq_ptr, q, i)
+                        memset(&q->q_stats, 0, sizeof(q->q_stats));
+                for_each_output_queue(irq_ptr, q, i)
+                        memset(&q->q_stats, 0, sizeof(q->q_stats));
                 break;
         case 1:
                 irq_ptr->perf_stat_enabled = 1;
diff --git a/drivers/s390/cio/qdio_main.c b/drivers/s390/cio/qdio_main.c
index 62b654af9237..232ef047ba34 100644
--- a/drivers/s390/cio/qdio_main.c
+++ b/drivers/s390/cio/qdio_main.c
@@ -392,6 +392,20 @@ static inline void qdio_stop_polling(struct qdio_q *q)
                 set_buf_state(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT);
 }
 
+static inline void account_sbals(struct qdio_q *q, int count)
+{
+        int pos = 0;
+
+        q->q_stats.nr_sbal_total += count;
+        if (count == QDIO_MAX_BUFFERS_MASK) {
+                q->q_stats.nr_sbals[7]++;
+                return;
+        }
+        while (count >>= 1)
+                pos++;
+        q->q_stats.nr_sbals[pos]++;
+}
+
 static void announce_buffer_error(struct qdio_q *q, int count)
 {
         q->qdio_error |= QDIO_ERROR_SLSB_STATE;
@@ -487,16 +501,22 @@ static int get_inbound_buffer_frontier(struct qdio_q *q)
                 q->first_to_check = add_buf(q->first_to_check, count);
                 if (atomic_sub(count, &q->nr_buf_used) == 0)
                         qperf_inc(q, inbound_queue_full);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals(q, count);
                 break;
         case SLSB_P_INPUT_ERROR:
                 announce_buffer_error(q, count);
                 /* process the buffer, the upper layer will take care of it */
                 q->first_to_check = add_buf(q->first_to_check, count);
                 atomic_sub(count, &q->nr_buf_used);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals_error(q, count);
                 break;
         case SLSB_CU_INPUT_EMPTY:
         case SLSB_P_INPUT_NOT_INIT:
         case SLSB_P_INPUT_ACK:
+                if (q->irq_ptr->perf_stat_enabled)
+                        q->q_stats.nr_sbal_nop++;
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in nop");
                 break;
         default:
@@ -514,7 +534,7 @@ static int qdio_inbound_q_moved(struct qdio_q *q)
 
         if ((bufnr != q->last_move) || q->qdio_error) {
                 q->last_move = bufnr;
-                if (!is_thinint_irq(q->irq_ptr) && !MACHINE_IS_VM)
+                if (!is_thinint_irq(q->irq_ptr) && MACHINE_IS_LPAR)
                         q->u.in.timestamp = get_usecs();
                 return 1;
         } else
@@ -643,15 +663,21 @@ static int get_outbound_buffer_frontier(struct qdio_q *q)
 
                 atomic_sub(count, &q->nr_buf_used);
                 q->first_to_check = add_buf(q->first_to_check, count);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals(q, count);
                 break;
         case SLSB_P_OUTPUT_ERROR:
                 announce_buffer_error(q, count);
                 /* process the buffer, the upper layer will take care of it */
                 q->first_to_check = add_buf(q->first_to_check, count);
                 atomic_sub(count, &q->nr_buf_used);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals_error(q, count);
                 break;
         case SLSB_CU_OUTPUT_PRIMED:
                 /* the adapter has not fetched the output yet */
+                if (q->irq_ptr->perf_stat_enabled)
+                        q->q_stats.nr_sbal_nop++;
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out primed:%1d", q->nr);
                 break;
         case SLSB_P_OUTPUT_NOT_INIT:
diff --git a/drivers/s390/cio/qdio_setup.c b/drivers/s390/cio/qdio_setup.c
index 8c2dea5fa2b4..7f4a75465140 100644
--- a/drivers/s390/cio/qdio_setup.c
+++ b/drivers/s390/cio/qdio_setup.c
@@ -333,10 +333,10 @@ static void __qdio_allocate_fill_qdr(struct qdio_irq *irq_ptr,
         irq_ptr->qdr->qdf0[i + nr].slsba =
                 (unsigned long)&irq_ptr_qs[i]->slsb.val[0];
 
-        irq_ptr->qdr->qdf0[i + nr].akey = PAGE_DEFAULT_KEY;
-        irq_ptr->qdr->qdf0[i + nr].bkey = PAGE_DEFAULT_KEY;
-        irq_ptr->qdr->qdf0[i + nr].ckey = PAGE_DEFAULT_KEY;
-        irq_ptr->qdr->qdf0[i + nr].dkey = PAGE_DEFAULT_KEY;
+        irq_ptr->qdr->qdf0[i + nr].akey = PAGE_DEFAULT_KEY >> 4;
+        irq_ptr->qdr->qdf0[i + nr].bkey = PAGE_DEFAULT_KEY >> 4;
+        irq_ptr->qdr->qdf0[i + nr].ckey = PAGE_DEFAULT_KEY >> 4;
+        irq_ptr->qdr->qdf0[i + nr].dkey = PAGE_DEFAULT_KEY >> 4;
 }
 
 static void setup_qdr(struct qdio_irq *irq_ptr,
@@ -350,7 +350,7 @@ static void setup_qdr(struct qdio_irq *irq_ptr,
         irq_ptr->qdr->iqdsz = sizeof(struct qdesfmt0) / 4; /* size in words */
         irq_ptr->qdr->oqdsz = sizeof(struct qdesfmt0) / 4;
         irq_ptr->qdr->qiba = (unsigned long)&irq_ptr->qib;
-        irq_ptr->qdr->qkey = PAGE_DEFAULT_KEY;
+        irq_ptr->qdr->qkey = PAGE_DEFAULT_KEY >> 4;
 
         for (i = 0; i < qdio_init->no_input_qs; i++)
                 __qdio_allocate_fill_qdr(irq_ptr, irq_ptr->input_qs, i, 0);
@@ -382,7 +382,15 @@ int qdio_setup_irq(struct qdio_initialize *init_data)
         struct qdio_irq *irq_ptr = init_data->cdev->private->qdio_data;
         int rc;
 
-        memset(irq_ptr, 0, ((char *)&irq_ptr->qdr) - ((char *)irq_ptr));
+        memset(&irq_ptr->qib, 0, sizeof(irq_ptr->qib));
+        memset(&irq_ptr->siga_flag, 0, sizeof(irq_ptr->siga_flag));
+        memset(&irq_ptr->ccw, 0, sizeof(irq_ptr->ccw));
+        memset(&irq_ptr->ssqd_desc, 0, sizeof(irq_ptr->ssqd_desc));
+        memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
+
+        irq_ptr->debugfs_dev = irq_ptr->debugfs_perf = NULL;
+        irq_ptr->sch_token = irq_ptr->state = irq_ptr->perf_stat_enabled = 0;
+
         /* wipes qib.ac, required by ar7063 */
         memset(irq_ptr->qdr, 0, sizeof(struct qdr));
 
diff --git a/drivers/s390/cio/qdio_thinint.c b/drivers/s390/cio/qdio_thinint.c
index 091d904d3182..9942c1031b25 100644
--- a/drivers/s390/cio/qdio_thinint.c
+++ b/drivers/s390/cio/qdio_thinint.c
@@ -198,8 +198,8 @@ static int set_subchannel_ind(struct qdio_irq *irq_ptr, int reset)
                 .code   = 0x0021,
         };
         scssc_area->operation_code = 0;
-        scssc_area->ks = PAGE_DEFAULT_KEY;
-        scssc_area->kc = PAGE_DEFAULT_KEY;
+        scssc_area->ks = PAGE_DEFAULT_KEY >> 4;
+        scssc_area->kc = PAGE_DEFAULT_KEY >> 4;
         scssc_area->isc = QDIO_AIRQ_ISC;
         scssc_area->schid = irq_ptr->schid;
 
diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c
index c68be24e27d9..ba50fe02e572 100644
--- a/drivers/s390/crypto/zcrypt_api.c
+++ b/drivers/s390/crypto/zcrypt_api.c
@@ -33,6 +33,7 @@
 #include <linux/miscdevice.h>
 #include <linux/fs.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/compat.h>
 #include <linux/smp_lock.h>
 #include <asm/atomic.h>
@@ -912,126 +913,105 @@ static struct miscdevice zcrypt_misc_device = {
  */
 static struct proc_dir_entry *zcrypt_entry;
 
-static int sprintcl(unsigned char *outaddr, unsigned char *addr,
-                    unsigned int len)
+static void sprintcl(struct seq_file *m, unsigned char *addr, unsigned int len)
 {
-        int hl, i;
+        int i;
 
-        hl = 0;
         for (i = 0; i < len; i++)
-                hl += sprintf(outaddr+hl, "%01x", (unsigned int) addr[i]);
-        hl += sprintf(outaddr+hl, " ");
-        return hl;
+                seq_printf(m, "%01x", (unsigned int) addr[i]);
+        seq_putc(m, ' ');
 }
 
-static int sprintrw(unsigned char *outaddr, unsigned char *addr,
-                    unsigned int len)
+static void sprintrw(struct seq_file *m, unsigned char *addr, unsigned int len)
 {
-        int hl, inl, c, cx;
+        int inl, c, cx;
 
-        hl = sprintf(outaddr, "    ");
+        seq_printf(m, "    ");
         inl = 0;
         for (c = 0; c < (len / 16); c++) {
-                hl += sprintcl(outaddr+hl, addr+inl, 16);
+                sprintcl(m, addr+inl, 16);
                 inl += 16;
         }
         cx = len%16;
         if (cx) {
-                hl += sprintcl(outaddr+hl, addr+inl, cx);
+                sprintcl(m, addr+inl, cx);
                 inl += cx;
         }
-        hl += sprintf(outaddr+hl, "\n");
-        return hl;
+        seq_putc(m, '\n');
 }
 
-static int sprinthx(unsigned char *title, unsigned char *outaddr,
-                    unsigned char *addr, unsigned int len)
+static void sprinthx(unsigned char *title, struct seq_file *m,
+                     unsigned char *addr, unsigned int len)
 {
-        int hl, inl, r, rx;
+        int inl, r, rx;
 
-        hl = sprintf(outaddr, "\n%s\n", title);
+        seq_printf(m, "\n%s\n", title);
         inl = 0;
         for (r = 0; r < (len / 64); r++) {
-                hl += sprintrw(outaddr+hl, addr+inl, 64);
+                sprintrw(m, addr+inl, 64);
                 inl += 64;
         }
         rx = len % 64;
         if (rx) {
-                hl += sprintrw(outaddr+hl, addr+inl, rx);
+                sprintrw(m, addr+inl, rx);
                 inl += rx;
         }
-        hl += sprintf(outaddr+hl, "\n");
-        return hl;
+        seq_putc(m, '\n');
 }
 
-static int sprinthx4(unsigned char *title, unsigned char *outaddr,
-                     unsigned int *array, unsigned int len)
+static void sprinthx4(unsigned char *title, struct seq_file *m,
+                      unsigned int *array, unsigned int len)
 {
-        int hl, r;
+        int r;
 
-        hl = sprintf(outaddr, "\n%s\n", title);
+        seq_printf(m, "\n%s\n", title);
         for (r = 0; r < len; r++) {
                 if ((r % 8) == 0)
-                        hl += sprintf(outaddr+hl, "    ");
-                hl += sprintf(outaddr+hl, "%08X ", array[r]);
+                        seq_printf(m, "    ");
+                seq_printf(m, "%08X ", array[r]);
                 if ((r % 8) == 7)
-                        hl += sprintf(outaddr+hl, "\n");
+                        seq_putc(m, '\n');
         }
-        hl += sprintf(outaddr+hl, "\n");
-        return hl;
+        seq_putc(m, '\n');
 }
 
-static int zcrypt_status_read(char *resp_buff, char **start, off_t offset,
-                              int count, int *eof, void *data)
+static int zcrypt_proc_show(struct seq_file *m, void *v)
 {
-        unsigned char *workarea;
-        int len;
-
-        len = 0;
-
-        /* resp_buff is a page. Use the right half for a work area */
-        workarea = resp_buff + 2000;
-        len += sprintf(resp_buff + len, "\nzcrypt version: %d.%d.%d\n",
-                ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
-        len += sprintf(resp_buff + len, "Cryptographic domain: %d\n",
-                       ap_domain_index);
-        len += sprintf(resp_buff + len, "Total device count: %d\n",
-                       zcrypt_device_count);
-        len += sprintf(resp_buff + len, "PCICA count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCICA));
-        len += sprintf(resp_buff + len, "PCICC count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCICC));
-        len += sprintf(resp_buff + len, "PCIXCC MCL2 count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
-        len += sprintf(resp_buff + len, "PCIXCC MCL3 count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
-        len += sprintf(resp_buff + len, "CEX2C count: %d\n",
-                       zcrypt_count_type(ZCRYPT_CEX2C));
-        len += sprintf(resp_buff + len, "CEX2A count: %d\n",
-                       zcrypt_count_type(ZCRYPT_CEX2A));
-        len += sprintf(resp_buff + len, "CEX3C count: %d\n",
-                       zcrypt_count_type(ZCRYPT_CEX3C));
-        len += sprintf(resp_buff + len, "CEX3A count: %d\n",
-                       zcrypt_count_type(ZCRYPT_CEX3A));
-        len += sprintf(resp_buff + len, "requestq count: %d\n",
-                       zcrypt_requestq_count());
-        len += sprintf(resp_buff + len, "pendingq count: %d\n",
-                       zcrypt_pendingq_count());
-        len += sprintf(resp_buff + len, "Total open handles: %d\n\n",
-                       atomic_read(&zcrypt_open_count));
+        char workarea[sizeof(int) * AP_DEVICES];
+
+        seq_printf(m, "\nzcrypt version: %d.%d.%d\n",
+                   ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
+        seq_printf(m, "Cryptographic domain: %d\n", ap_domain_index);
+        seq_printf(m, "Total device count: %d\n", zcrypt_device_count);
+        seq_printf(m, "PCICA count: %d\n", zcrypt_count_type(ZCRYPT_PCICA));
+        seq_printf(m, "PCICC count: %d\n", zcrypt_count_type(ZCRYPT_PCICC));
+        seq_printf(m, "PCIXCC MCL2 count: %d\n",
+                   zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
+        seq_printf(m, "PCIXCC MCL3 count: %d\n",
+                   zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
+        seq_printf(m, "CEX2C count: %d\n", zcrypt_count_type(ZCRYPT_CEX2C));
+        seq_printf(m, "CEX2A count: %d\n", zcrypt_count_type(ZCRYPT_CEX2A));
+        seq_printf(m, "CEX3C count: %d\n", zcrypt_count_type(ZCRYPT_CEX3C));
+        seq_printf(m, "CEX3A count: %d\n", zcrypt_count_type(ZCRYPT_CEX3A));
+        seq_printf(m, "requestq count: %d\n", zcrypt_requestq_count());
+        seq_printf(m, "pendingq count: %d\n", zcrypt_pendingq_count());
+        seq_printf(m, "Total open handles: %d\n\n",
+                   atomic_read(&zcrypt_open_count));
         zcrypt_status_mask(workarea);
-        len += sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
-                        "4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
-                        resp_buff+len, workarea, AP_DEVICES);
+        sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
+                 "4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
+                 m, workarea, AP_DEVICES);
         zcrypt_qdepth_mask(workarea);
-        len += sprinthx("Waiting work element counts",
-                        resp_buff+len, workarea, AP_DEVICES);
+        sprinthx("Waiting work element counts", m, workarea, AP_DEVICES);
         zcrypt_perdev_reqcnt((int *) workarea);
-        len += sprinthx4("Per-device successfully completed request counts",
-                         resp_buff+len,(unsigned int *) workarea, AP_DEVICES);
-        *eof = 1;
-        memset((void *) workarea, 0x00, AP_DEVICES * sizeof(unsigned int));
-        return len;
+        sprinthx4("Per-device successfully completed request counts",
+                  m, (unsigned int *) workarea, AP_DEVICES);
+        return 0;
+}
+
+static int zcrypt_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, zcrypt_proc_show, NULL);
 }
 
 static void zcrypt_disable_card(int index)
@@ -1061,11 +1041,11 @@ static void zcrypt_enable_card(int index)
         spin_unlock_bh(&zcrypt_device_lock);
 }
 
-static int zcrypt_status_write(struct file *file, const char __user *buffer,
-                               unsigned long count, void *data)
+static ssize_t zcrypt_proc_write(struct file *file, const char __user *buffer,
+                                 size_t count, loff_t *pos)
 {
         unsigned char *lbuf, *ptr;
-        unsigned long local_count;
+        size_t local_count;
         int j;
 
         if (count <= 0)
@@ -1115,6 +1095,15 @@ out:
         return count;
 }
 
+static const struct file_operations zcrypt_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = zcrypt_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = zcrypt_proc_write,
+};
+
 static int zcrypt_rng_device_count;
 static u32 *zcrypt_rng_buffer;
 static int zcrypt_rng_buffer_index;
@@ -1197,14 +1186,11 @@ int __init zcrypt_api_init(void)
                 goto out;
 
         /* Set up the proc file system */
-        zcrypt_entry = create_proc_entry("driver/z90crypt", 0644, NULL);
+        zcrypt_entry = proc_create("driver/z90crypt", 0644, NULL, &zcrypt_proc_fops);
         if (!zcrypt_entry) {
                 rc = -ENOMEM;
                 goto out_misc;
         }
-        zcrypt_entry->data = NULL;
-        zcrypt_entry->read_proc = zcrypt_status_read;
-        zcrypt_entry->write_proc = zcrypt_status_write;
 
         return 0;
 
diff --git a/drivers/s390/kvm/kvm_virtio.c b/drivers/s390/kvm/kvm_virtio.c
index 2930fc763ac5..b2fc4fd63f7f 100644
--- a/drivers/s390/kvm/kvm_virtio.c
+++ b/drivers/s390/kvm/kvm_virtio.c
@@ -340,11 +340,11 @@ static void kvm_extint_handler(u16 code)
                 return;
 
         /* The LSB might be overloaded, we have to mask it */
-        vq = (struct virtqueue *) ((*(long *) __LC_PFAULT_INTPARM) & ~1UL);
+        vq = (struct virtqueue *)(S390_lowcore.ext_params2 & ~1UL);
 
         /* We use the LSB of extparam, to decide, if this interrupt is a config
          * change or a "standard" interrupt */
-        config_changed =  (*(int *)  __LC_EXT_PARAMS & 1);
+        config_changed = S390_lowcore.ext_params & 1;
 
         if (config_changed) {
                 struct virtio_driver *drv;