(((unsigned long)response + rlen) >> 31)) {
                lowbuf = kmalloc(rlen, GFP_KERNEL | GFP_DMA);
                if (!lowbuf) {
-                       pr_warning("The cpcmd kernel function failed to "
-                                  "allocate a response buffer\n");
+                       pr_warn("The cpcmd kernel function failed to allocate a response buffer\n");
                        return -ENOMEM;
                }
                spin_lock_irqsave(&cpcmd_lock, flags);
 
        /* Since debugfs currently does not support uid/gid other than root, */
        /* we do not allow gid/uid != 0 until we get support for that. */
        if ((uid != 0) || (gid != 0))
-               pr_warning("Root becomes the owner of all s390dbf files "
-                          "in sysfs\n");
+               pr_warn("Root becomes the owner of all s390dbf files in sysfs\n");
        BUG_ON(!initialized);
        mutex_lock(&debug_mutex);
 
                new_level = debug_get_uint(str);
        }
        if(new_level < 0) {
-               pr_warning("%s is not a valid level for a debug "
-                          "feature\n", str);
+               pr_warn("%s is not a valid level for a debug feature\n", str);
                rc = -EINVAL;
        } else {
                debug_set_level(id, new_level);
 
                if (etr_port0_online && etr_port1_online)
                        set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        } else if (etr_port0_online || etr_port1_online) {
-               pr_warning("The real or virtual hardware system does "
-                          "not provide an ETR interface\n");
+               pr_warn("The real or virtual hardware system does not provide an ETR interface\n");
                etr_port0_online = etr_port1_online = 0;
        }
 }
        if (rc == 0)
                set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
        else if (stp_online) {
-               pr_warning("The real or virtual hardware system does "
-                          "not provide an STP interface\n");
+               pr_warn("The real or virtual hardware system does not provide an STP interface\n");
                free_page((unsigned long) stp_page);
                stp_page = NULL;
                stp_online = 0;
 
                goto out_free;
        }
        if (diag_cc > 1) {
-               pr_warning("Querying a DCSS type failed with rc=%ld\n", vmrc);
+               pr_warn("Querying a DCSS type failed with rc=%ld\n", vmrc);
                rc = dcss_diag_translate_rc (vmrc);
                goto out_free;
        }
                goto out_resource;
        }
        if (diag_cc > 1) {
-               pr_warning("Loading DCSS %s failed with rc=%ld\n", name,
-                          end_addr);
+               pr_warn("Loading DCSS %s failed with rc=%ld\n", name, end_addr);
                rc = dcss_diag_translate_rc(end_addr);
                dcss_diag(&purgeseg_scode, seg->dcss_name,
                                &dummy, &dummy);
                goto out_unlock;
        }
        if (atomic_read (&seg->ref_count) != 1) {
-               pr_warning("DCSS %s is in use and cannot be reloaded\n",
-                          name);
+               pr_warn("DCSS %s is in use and cannot be reloaded\n", name);
                rc = -EAGAIN;
                goto out_unlock;
        }
                        seg->res->flags |= IORESOURCE_READONLY;
 
        if (request_resource(&iomem_resource, seg->res)) {
-               pr_warning("DCSS %s overlaps with used memory resources "
-                          "and cannot be reloaded\n", name);
+               pr_warn("DCSS %s overlaps with used memory resources and cannot be reloaded\n",
+                       name);
                rc = -EBUSY;
                kfree(seg->res);
                goto out_del_mem;
                goto out_del_res;
        }
        if (diag_cc > 1) {
-               pr_warning("Reloading DCSS %s failed with rc=%ld\n", name,
-                          end_addr);
+               pr_warn("Reloading DCSS %s failed with rc=%ld\n",
+                       name, end_addr);
                rc = dcss_diag_translate_rc(end_addr);
                goto out_del_res;
        }
 
                else if (len == 8 && !strncmp(str, "failfast", 8))
                        features |= DASD_FEATURE_FAILFAST;
                else {
-                       pr_warning("%*s is not a supported device option\n",
-                                  len, str);
+                       pr_warn("%*s is not a supported device option\n",
+                               len, str);
                        rc = -EINVAL;
                }
                str += len;
                str++;
        }
        if (*str != ')') {
-               pr_warning("A closing parenthesis ')' is missing in the "
-                          "dasd= parameter\n");
+               pr_warn("A closing parenthesis ')' is missing in the dasd= parameter\n");
                rc = -EINVAL;
        } else
                str++;
                return str + 1;
        if (*str == '\0')
                return str;
-       pr_warning("The dasd= parameter value %s has an invalid ending\n",
-                  str);
+       pr_warn("The dasd= parameter value %s has an invalid ending\n", str);
        return ERR_PTR(-EINVAL);
 }
 
 
        rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
        if (rc == 4) {
                if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO, &device->flags)))
-                       pr_warning("%s: The access mode of a DIAG device "
-                                  "changed to read-only\n",
-                                  dev_name(&device->cdev->dev));
+                       pr_warn("%s: The access mode of a DIAG device changed to read-only\n",
+                               dev_name(&device->cdev->dev));
                rc = 0;
        }
        if (rc)
-               pr_warning("%s: DIAG ERP failed with "
-                           "rc=%d\n", dev_name(&device->cdev->dev), rc);
+               pr_warn("%s: DIAG ERP failed with rc=%d\n",
+                       dev_name(&device->cdev->dev), rc);
 }
 
 /* Start a given request at the device. Return zero on success, non-zero
                private->pt_block = 2;
                break;
        default:
-               pr_warning("%s: Device type %d is not supported "
-                          "in DIAG mode\n", dev_name(&device->cdev->dev),
-                          private->rdc_data.vdev_class);
+               pr_warn("%s: Device type %d is not supported in DIAG mode\n",
+                       dev_name(&device->cdev->dev),
+                       private->rdc_data.vdev_class);
                rc = -EOPNOTSUPP;
                goto out;
        }
                private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
                rc = dia250(&private->iob, RW_BIO);
                if (rc == 3) {
-                       pr_warning("%s: A 64-bit DIAG call failed\n",
-                                  dev_name(&device->cdev->dev));
+                       pr_warn("%s: A 64-bit DIAG call failed\n",
+                               dev_name(&device->cdev->dev));
                        rc = -EOPNOTSUPP;
                        goto out_label;
                }
                        break;
        }
        if (bsize > PAGE_SIZE) {
-               pr_warning("%s: Accessing the DASD failed because of an "
-                          "incorrect format (rc=%d)\n",
-                          dev_name(&device->cdev->dev), rc);
+               pr_warn("%s: Accessing the DASD failed because of an incorrect format (rc=%d)\n",
+                       dev_name(&device->cdev->dev), rc);
                rc = -EIO;
                goto out_label;
        }
                block->s2b_shift++;
        rc = mdsk_init_io(device, block->bp_block, 0, NULL);
        if (rc && (rc != 4)) {
-               pr_warning("%s: DIAG initialization failed with rc=%d\n",
-                          dev_name(&device->cdev->dev), rc);
+               pr_warn("%s: DIAG initialization failed with rc=%d\n",
+                       dev_name(&device->cdev->dev), rc);
                rc = -EIO;
        } else {
                if (rc == 4)
 
        /* Register to static dasd major 94 */
        rc = register_blkdev(DASD_MAJOR, "dasd");
        if (rc != 0) {
-               pr_warning("Registering the device driver with major number "
-                          "%d failed\n", DASD_MAJOR);
+               pr_warn("Registering the device driver with major number %d failed\n",
+                       DASD_MAJOR);
                return rc;
        }
        return 0;
 
                return -EFAULT;
        }
        if (bdev != bdev->bd_contains) {
-               pr_warning("%s: The specified DASD is a partition and cannot "
-                          "be formatted\n",
-                          dev_name(&base->cdev->dev));
+               pr_warn("%s: The specified DASD is a partition and cannot be formatted\n",
+                       dev_name(&base->cdev->dev));
                dasd_put_device(base);
                return -EINVAL;
        }
 
        return user_len;
 out_parse_error:
        rc = -EINVAL;
-       pr_warning("%s is not a supported value for /proc/dasd/statistics\n",
-               str);
+       pr_warn("%s is not a supported value for /proc/dasd/statistics\n", str);
 out_error:
        vfree(buffer);
        return rc;
 #else
-       pr_warning("/proc/dasd/statistics: is not activated in this kernel\n");
+       pr_warn("/proc/dasd/statistics: is not activated in this kernel\n");
        return user_len;
 #endif                         /* CONFIG_DASD_PROFILE */
 }
 
        dev_info = dcssblk_get_device_by_name(local_buf);
        if (dev_info == NULL) {
                up_write(&dcssblk_devices_sem);
-               pr_warning("Device %s cannot be removed because it is not a "
-                          "known device\n", local_buf);
+               pr_warn("Device %s cannot be removed because it is not a known device\n",
+                       local_buf);
                rc = -ENODEV;
                goto out_buf;
        }
        if (atomic_read(&dev_info->use_count) != 0) {
                up_write(&dcssblk_devices_sem);
-               pr_warning("Device %s cannot be removed while it is in "
-                          "use\n", local_buf);
+               pr_warn("Device %s cannot be removed while it is in use\n",
+                       local_buf);
                rc = -EBUSY;
                goto out_buf;
        }
                case SEG_TYPE_SC:
                        /* cannot write to these segments */
                        if (bio_data_dir(bio) == WRITE) {
-                               pr_warning("Writing to %s failed because it "
-                                          "is a read-only device\n",
-                                          dev_name(&dev_info->dev));
+                               pr_warn("Writing to %s failed because it is a read-only device\n",
+                                       dev_name(&dev_info->dev));
                                goto fail;
                        }
                }
 
        memcpy(&monpriv->msg_array[monpriv->write_index]->msg,
               msg, sizeof(*msg));
        if (atomic_inc_return(&monpriv->msglim_count) == MON_MSGLIM) {
-               pr_warning("The read queue for monitor data is full\n");
+               pr_warn("The read queue for monitor data is full\n");
                monpriv->msg_array[monpriv->write_index]->msglim_reached = 1;
        }
        monpriv->write_index = (monpriv->write_index + 1) % MON_MSGLIM;
        if (monpriv->path) {
                rc = iucv_path_sever(monpriv->path, user_data_sever);
                if (rc)
-                       pr_warning("Disconnecting the z/VM *MONITOR system "
-                                  "service failed with rc=%i\n", rc);
+                       pr_warn("Disconnecting the z/VM *MONITOR system service failed with rc=%i\n",
+                               rc);
                iucv_path_free(monpriv->path);
        }
 
        if (monpriv->path) {
                rc = iucv_path_sever(monpriv->path, user_data_sever);
                if (rc)
-                       pr_warning("Disconnecting the z/VM *MONITOR system "
-                                  "service failed with rc=%i\n", rc);
+                       pr_warn("Disconnecting the z/VM *MONITOR system service failed with rc=%i\n",
+                               rc);
                iucv_path_free(monpriv->path);
        }
        atomic_set(&monpriv->iucv_severed, 0);
 
 
        /* Check response. */
        if (request->status != SCLP_REQ_DONE) {
-               pr_warning("sync request failed (cmd=0x%08x, "
-                          "status=0x%02x)\n", cmd, request->status);
+               pr_warn("sync request failed (cmd=0x%08x, status=0x%02x)\n",
+                       cmd, request->status);
                rc = -EIO;
        }
 out:
        if (rc)
                goto out;
        if (sccb->header.response_code != 0x0010) {
-               pr_warning("readcpuinfo failed (response=0x%04x)\n",
-                          sccb->header.response_code);
+               pr_warn("readcpuinfo failed (response=0x%04x)\n",
+                       sccb->header.response_code);
                rc = -EIO;
                goto out;
        }
        case 0x0120:
                break;
        default:
-               pr_warning("configure cpu failed (cmd=0x%08x, "
-                          "response=0x%04x)\n", cmd,
-                          sccb->header.response_code);
+               pr_warn("configure cpu failed (cmd=0x%08x, response=0x%04x)\n",
+                       cmd, sccb->header.response_code);
                rc = -EIO;
                break;
        }
        case 0x0120:
                break;
        default:
-               pr_warning("assign storage failed (cmd=0x%08x, "
-                          "response=0x%04x, rn=0x%04x)\n", cmd,
-                          sccb->header.response_code, rn);
+               pr_warn("assign storage failed (cmd=0x%08x, response=0x%04x, rn=0x%04x)\n",
+                       cmd, sccb->header.response_code, rn);
                rc = -EIO;
                break;
        }
        case 0x0450:
                break;
        default:
-               pr_warning("configure channel-path failed "
-                          "(cmd=0x%08x, response=0x%04x)\n", cmd,
-                          sccb->header.response_code);
+               pr_warn("configure channel-path failed (cmd=0x%08x, response=0x%04x)\n",
+                       cmd, sccb->header.response_code);
                rc = -EIO;
                break;
        }
        if (rc)
                goto out;
        if (sccb->header.response_code != 0x0010) {
-               pr_warning("read channel-path info failed "
-                          "(response=0x%04x)\n", sccb->header.response_code);
+               pr_warn("read channel-path info failed (response=0x%04x)\n",
+                       sccb->header.response_code);
                rc = -EIO;
                goto out;
        }
 
        wait_for_completion(&completion);
 
        if (req->status != SCLP_REQ_DONE) {
-               pr_warning("request failed (status=0x%02x)\n",
-                          req->status);
+               pr_warn("request failed (status=0x%02x)\n", req->status);
                rc = -EIO;
                goto out_free_req;
        }
 
        response = ((struct cpi_sccb *) req->sccb)->header.response_code;
        if (response != 0x0020) {
-               pr_warning("request failed with response code 0x%x\n",
-                          response);
+               pr_warn("request failed with response code 0x%x\n", response);
                rc = -EIO;
        }
 
 
                         */
                        DBF_EVENT(3, "(%08x): Drive in use vanished!\n",
                                device->cdev_id);
-                       pr_warning("%s: A tape unit was detached while in "
-                                  "use\n", dev_name(&device->cdev->dev));
+                       pr_warn("%s: A tape unit was detached while in use\n",
+                               dev_name(&device->cdev->dev));
                        tape_state_set(device, TS_NOT_OPER);
                        __tape_discard_requests(device);
                        spin_unlock_irq(get_ccwdev_lock(device->cdev));
 
        if (logptr->autorecording) {
                ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
                if (ret)
-                       pr_warning("vmlogrdr: failed to start "
-                                  "recording automatically\n");
+                       pr_warn("vmlogrdr: failed to start recording automatically\n");
        }
 
        /* create connection to the system service */
        if (logptr->autorecording) {
                ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
                if (ret)
-                       pr_warning("vmlogrdr: failed to stop "
-                                  "recording automatically\n");
+                       pr_warn("vmlogrdr: failed to stop recording automatically\n");
        }
        logptr->dev_in_use = 0;
 
 
 {
        if ((from_ssid > to_ssid) || ((from_ssid == to_ssid) && (from > to))) {
                if (msgtrigger)
-                       pr_warning("0.%x.%04x to 0.%x.%04x is not a valid "
-                                  "range for cio_ignore\n", from_ssid, from,
-                                  to_ssid, to);
+                       pr_warn("0.%x.%04x to 0.%x.%04x is not a valid range for cio_ignore\n",
+                               from_ssid, from, to_ssid, to);
 
                return 1;
        }
        rc = 0;
 out:
        if (rc && msgtrigger)
-               pr_warning("%s is not a valid device for the cio_ignore "
-                          "kernel parameter\n", str);
+               pr_warn("%s is not a valid device for the cio_ignore kernel parameter\n",
+                       str);
 
        return rc;
 }
 
 
        for (chp = 0; chp < 8; chp++) {
                if ((0x80 >> chp) & sch->schib.pmcw.lpum)
-                       pr_warning("%s: No interrupt was received within %lus "
-                                  "(CS=%02x, DS=%02x, CHPID=%x.%02x)\n",
-                                  dev_name(&cdev->dev), req->timeout / HZ,
-                                  scsw_cstat(&sch->schib.scsw),
-                                  scsw_dstat(&sch->schib.scsw),
-                                  sch->schid.cssid,
-                                  sch->schib.pmcw.chpid[chp]);
+                       pr_warn("%s: No interrupt was received within %lus (CS=%02x, DS=%02x, CHPID=%x.%02x)\n",
+                               dev_name(&cdev->dev), req->timeout / HZ,
+                               scsw_cstat(&sch->schib.scsw),
+                               scsw_dstat(&sch->schib.scsw),
+                               sch->schid.cssid,
+                               sch->schib.pmcw.chpid[chp]);
        }
 
        if (!ccwreq_next_path(cdev)) {
 
 
        sch_no = cio_get_console_sch_no();
        if (sch_no == -1) {
-               pr_warning("No CCW console was found\n");
+               pr_warn("No CCW console was found\n");
                return ERR_PTR(-ENODEV);
        }
        init_subchannel_id(&schid);
 
                   cdev->private->state == DEV_STATE_DISCONNECTED));
        /* Inform the user if set offline failed. */
        if (cdev->private->state == DEV_STATE_BOXED) {
-               pr_warning("%s: The device entered boxed state while "
-                          "being set offline\n", dev_name(&cdev->dev));
+               pr_warn("%s: The device entered boxed state while being set offline\n",
+                       dev_name(&cdev->dev));
        } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
-               pr_warning("%s: The device stopped operating while "
-                          "being set offline\n", dev_name(&cdev->dev));
+               pr_warn("%s: The device stopped operating while being set offline\n",
+                       dev_name(&cdev->dev));
        }
        /* Give up reference from ccw_device_set_online(). */
        put_device(&cdev->dev);
                spin_unlock_irq(cdev->ccwlock);
                /* Inform the user that set online failed. */
                if (cdev->private->state == DEV_STATE_BOXED) {
-                       pr_warning("%s: Setting the device online failed "
-                                  "because it is boxed\n",
-                                  dev_name(&cdev->dev));
+                       pr_warn("%s: Setting the device online failed because it is boxed\n",
+                               dev_name(&cdev->dev));
                } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
-                       pr_warning("%s: Setting the device online failed "
-                                  "because it is not operational\n",
-                                  dev_name(&cdev->dev));
+                       pr_warn("%s: Setting the device online failed because it is not operational\n",
+                               dev_name(&cdev->dev));
                }
                /* Give up online reference since onlining failed. */
                put_device(&cdev->dev);
 
        rc = chsc_siosl(sch->schid);
        if (rc < 0) {
-               pr_warning("Logging for subchannel 0.%x.%04x failed with "
-                          "errno=%d\n",
-                          sch->schid.ssid, sch->schid.sch_no, rc);
+               pr_warn("Logging for subchannel 0.%x.%04x failed with errno=%d\n",
+                       sch->schid.ssid, sch->schid.sch_no, rc);
                return rc;
        }
        pr_notice("Logging for subchannel 0.%x.%04x was triggered\n",
 
                        lcs_schedule_recovery(card);
                        break;
                case LCS_CMD_STOPLAN:
-                       pr_warning("Stoplan for %s initiated by LGW.\n",
-                                  card->dev->name);
+                       pr_warn("Stoplan for %s initiated by LGW\n",
+                               card->dev->name);
                        if (card->dev)
                                netif_carrier_off(card->dev);
                        break;
 
                return rc;
        }
 #else
-       pr_warning("There is no IPv6 support for the layer 3 discipline\n");
+       pr_warn("There is no IPv6 support for the layer 3 discipline\n");
 #endif
        return 0;
 }