scsi: sd: Do not split error messages

Make it easier to find these error messages with grep. This patch has been
created as follows:
* Delete all occurrences of the following regular expression:
  "[[:blank:]]*\\*\n[[:blank:]]*"
* Split long lines manually where necessary.

Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Reviewed-by: Himanshu Madhani <himanshu.madhani@oracle.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Link: https://patch.msgid.link/20260114175054.4118163-6-bvanassche@acm.org
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 1dae8a02c446e440aaf405d909d02aee87135847..d76996d6cbc9c9dde966d2f24e3f905a7c840e25 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1682,9 +1682,10 @@ static int sd_ioctl(struct block_device *bdev, blk_mode_t mode,
        struct scsi_device *sdp = sdkp->device;
        void __user *p = (void __user *)arg;
        int error;
-    
-       SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
-                                   "cmd=0x%x\n", disk->disk_name, cmd));
+
+       SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp,
+                                   "sd_ioctl: disk=%s, cmd=0x%x\n",
+                                   disk->disk_name, cmd));
 
        if (bdev_is_partition(bdev) && !capable(CAP_SYS_RAWIO))
                return -ENOIOCTLCMD;
@@ -2593,8 +2594,8 @@ static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer
        type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
 
        if (type > T10_PI_TYPE3_PROTECTION) {
-               sd_printk(KERN_ERR, sdkp, "formatted with unsupported"  \
-                         " protection type %u. Disabling disk!\n",
+               sd_printk(KERN_ERR, sdkp,
+                         "formatted with unsupported protection type %u. Disabling disk!\n",
                          type);
                sdkp->protection_type = 0;
                return -ENODEV;
@@ -2871,8 +2872,8 @@ sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,
                if ((sizeof(sdkp->capacity) > 4) &&
                    (sdkp->capacity > 0xffffffffULL)) {
                        int old_sector_size = sector_size;
-                       sd_printk(KERN_NOTICE, sdkp, "Very big device. "
-                                       "Trying to use READ CAPACITY(16).\n");
+                       sd_printk(KERN_NOTICE, sdkp,
+                                 "Very big device. Trying to use READ CAPACITY(16).\n");
                        sector_size = read_capacity_16(sdkp, sdp, lim, buffer);
                        if (sector_size < 0) {
                                sd_printk(KERN_NOTICE, sdkp,
@@ -2898,17 +2899,17 @@ sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,
         */
        if (sdp->fix_capacity ||
            (sdp->guess_capacity && (sdkp->capacity & 0x01))) {
-               sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
-                               "from its reported value: %llu\n",
-                               (unsigned long long) sdkp->capacity);
+               sd_printk(KERN_INFO, sdkp,
+                         "Adjusting the sector count from its reported value: %llu\n",
+                         (unsigned long long) sdkp->capacity);
                --sdkp->capacity;
        }
 
 got_data:
        if (sector_size == 0) {
                sector_size = 512;
-               sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
-                         "assuming 512.\n");
+               sd_printk(KERN_NOTICE, sdkp,
+                         "Sector size 0 reported, assuming 512.\n");
        }
 
        if (sector_size != 512 &&
@@ -3113,8 +3114,9 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
        if (len < 3)
                goto bad_sense;
        else if (len > SD_BUF_SIZE) {
-               sd_first_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
-                         "data from %d to %d bytes\n", len, SD_BUF_SIZE);
+               sd_first_printk(KERN_NOTICE, sdkp,
+                               "Truncating mode parameter data from %d to %d bytes\n",
+                               len, SD_BUF_SIZE);
                len = SD_BUF_SIZE;
        }
        if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
@@ -3137,8 +3139,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
                                 */
                                if (len - offset <= 2) {
                                        sd_first_printk(KERN_ERR, sdkp,
-                                               "Incomplete mode parameter "
-                                                       "data\n");
+                                               "Incomplete mode parameter data\n");
                                        goto defaults;
                                } else {
                                        modepage = page_code;
@@ -3153,8 +3154,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
                                        offset += 2 + buffer[offset+1];
                                else {
                                        sd_first_printk(KERN_ERR, sdkp,
-                                                       "Incomplete mode "
-                                                       "parameter data\n");
+                                                       "Incomplete mode parameter data\n");
                                        goto defaults;
                                }
                        }
@@ -3617,8 +3617,7 @@ static bool sd_validate_min_xfer_size(struct scsi_disk *sdkp)
 
        if (min_xfer_bytes & (sdkp->physical_block_size - 1)) {
                sd_first_printk(KERN_WARNING, sdkp,
-                               "Preferred minimum I/O size %u bytes not a " \
-                               "multiple of physical block size (%u bytes)\n",
+                               "Preferred minimum I/O size %u bytes not a multiple of physical block size (%u bytes)\n",
                                min_xfer_bytes, sdkp->physical_block_size);
                sdkp->min_xfer_blocks = 0;
                return false;
@@ -3648,41 +3647,35 @@ static bool sd_validate_opt_xfer_size(struct scsi_disk *sdkp,
 
        if (sdkp->opt_xfer_blocks > dev_max) {
                sd_first_printk(KERN_WARNING, sdkp,
-                               "Optimal transfer size %u logical blocks " \
-                               "> dev_max (%u logical blocks)\n",
+                               "Optimal transfer size %u logical blocks > dev_max (%u logical blocks)\n",
                                sdkp->opt_xfer_blocks, dev_max);
                return false;
        }
 
        if (sdkp->opt_xfer_blocks > SD_DEF_XFER_BLOCKS) {
                sd_first_printk(KERN_WARNING, sdkp,
-                               "Optimal transfer size %u logical blocks " \
-                               "> sd driver limit (%u logical blocks)\n",
+                               "Optimal transfer size %u logical blocks > sd driver limit (%u logical blocks)\n",
                                sdkp->opt_xfer_blocks, SD_DEF_XFER_BLOCKS);
                return false;
        }
 
        if (opt_xfer_bytes < PAGE_SIZE) {
                sd_first_printk(KERN_WARNING, sdkp,
-                               "Optimal transfer size %u bytes < " \
-                               "PAGE_SIZE (%u bytes)\n",
+                               "Optimal transfer size %u bytes < PAGE_SIZE (%u bytes)\n",
                                opt_xfer_bytes, (unsigned int)PAGE_SIZE);
                return false;
        }
 
        if (min_xfer_bytes && opt_xfer_bytes % min_xfer_bytes) {
                sd_first_printk(KERN_WARNING, sdkp,
-                               "Optimal transfer size %u bytes not a " \
-                               "multiple of preferred minimum block " \
-                               "size (%u bytes)\n",
+                               "Optimal transfer size %u bytes not a multiple of preferred minimum block size (%u bytes)\n",
                                opt_xfer_bytes, min_xfer_bytes);
                return false;
        }
 
        if (opt_xfer_bytes & (sdkp->physical_block_size - 1)) {
                sd_first_printk(KERN_WARNING, sdkp,
-                               "Optimal transfer size %u bytes not a " \
-                               "multiple of physical block size (%u bytes)\n",
+                               "Optimal transfer size %u bytes not a multiple of physical block size (%u bytes)\n",
                                opt_xfer_bytes, sdkp->physical_block_size);
                return false;
        }