Merge patch series "Clean up the SCSI disk driver source code"

+132 -144

1 changed file

expand all

drivers

scsi

sd.c

+132 -144

drivers/scsi/sd.c

··· 102 102 103 103 #define SD_MINORS 16 104 104 105 - static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim, 106 - unsigned int mode); 107 105 static void sd_config_write_same(struct scsi_disk *sdkp, 108 106 struct queue_limits *lim); 109 107 static void sd_revalidate_disk(struct gendisk *); 110 - static void sd_unlock_native_capacity(struct gendisk *disk); 111 - static void sd_shutdown(struct scsi_device *); 112 - static void scsi_disk_release(struct device *cdev); 113 108 114 109 static DEFINE_IDA(sd_index_ida); 115 110 ··· 115 120 "write through", "none", "write back", 116 121 "write back, no read (daft)" 117 122 }; 123 + 124 + static void sd_disable_discard(struct scsi_disk *sdkp) 125 + { 126 + sdkp->provisioning_mode = SD_LBP_DISABLE; 127 + blk_queue_disable_discard(sdkp->disk->queue); 128 + } 129 + 130 + static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim, 131 + unsigned int mode) 132 + { 133 + unsigned int logical_block_size = sdkp->device->sector_size; 134 + unsigned int max_blocks = 0; 135 + 136 + lim->discard_alignment = sdkp->unmap_alignment * logical_block_size; 137 + lim->discard_granularity = max(sdkp->physical_block_size, 138 + sdkp->unmap_granularity * logical_block_size); 139 + sdkp->provisioning_mode = mode; 140 + 141 + switch (mode) { 142 + 143 + case SD_LBP_FULL: 144 + case SD_LBP_DISABLE: 145 + break; 146 + 147 + case SD_LBP_UNMAP: 148 + max_blocks = min_not_zero(sdkp->max_unmap_blocks, 149 + (u32)SD_MAX_WS16_BLOCKS); 150 + break; 151 + 152 + case SD_LBP_WS16: 153 + if (sdkp->device->unmap_limit_for_ws) 154 + max_blocks = sdkp->max_unmap_blocks; 155 + else 156 + max_blocks = sdkp->max_ws_blocks; 157 + 158 + max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS16_BLOCKS); 159 + break; 160 + 161 + case SD_LBP_WS10: 162 + if (sdkp->device->unmap_limit_for_ws) 163 + max_blocks = sdkp->max_unmap_blocks; 164 + else 165 + max_blocks = sdkp->max_ws_blocks; 166 + 167 + max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS10_BLOCKS); 168 + break; 169 + 170 + case SD_LBP_ZERO: 171 + max_blocks = min_not_zero(sdkp->max_ws_blocks, 172 + (u32)SD_MAX_WS10_BLOCKS); 173 + break; 174 + } 175 + 176 + lim->max_hw_discard_sectors = max_blocks * 177 + (logical_block_size >> SECTOR_SHIFT); 178 + } 118 179 119 180 static void sd_set_flush_flag(struct scsi_disk *sdkp, 120 181 struct queue_limits *lim) ··· 749 698 }; 750 699 ATTRIBUTE_GROUPS(sd_disk); 751 700 701 + static void scsi_disk_release(struct device *dev) 702 + { 703 + struct scsi_disk *sdkp = to_scsi_disk(dev); 704 + 705 + ida_free(&sd_index_ida, sdkp->index); 706 + put_device(&sdkp->device->sdev_gendev); 707 + free_opal_dev(sdkp->opal_dev); 708 + 709 + kfree(sdkp); 710 + } 711 + 752 712 static struct class sd_disk_class = { 753 713 .name = "scsi_disk", 754 714 .dev_release = scsi_disk_release, ··· 926 864 scmd->prot_flags &= sd_prot_flag_mask(prot_op); 927 865 928 866 return protect; 929 - } 930 - 931 - static void sd_disable_discard(struct scsi_disk *sdkp) 932 - { 933 - sdkp->provisioning_mode = SD_LBP_DISABLE; 934 - blk_queue_disable_discard(sdkp->disk->queue); 935 - } 936 - 937 - static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim, 938 - unsigned int mode) 939 - { 940 - unsigned int logical_block_size = sdkp->device->sector_size; 941 - unsigned int max_blocks = 0; 942 - 943 - lim->discard_alignment = sdkp->unmap_alignment * logical_block_size; 944 - lim->discard_granularity = max(sdkp->physical_block_size, 945 - sdkp->unmap_granularity * logical_block_size); 946 - sdkp->provisioning_mode = mode; 947 - 948 - switch (mode) { 949 - 950 - case SD_LBP_FULL: 951 - case SD_LBP_DISABLE: 952 - break; 953 - 954 - case SD_LBP_UNMAP: 955 - max_blocks = min_not_zero(sdkp->max_unmap_blocks, 956 - (u32)SD_MAX_WS16_BLOCKS); 957 - break; 958 - 959 - case SD_LBP_WS16: 960 - if (sdkp->device->unmap_limit_for_ws) 961 - max_blocks = sdkp->max_unmap_blocks; 962 - else 963 - max_blocks = sdkp->max_ws_blocks; 964 - 965 - max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS16_BLOCKS); 966 - break; 967 - 968 - case SD_LBP_WS10: 969 - if (sdkp->device->unmap_limit_for_ws) 970 - max_blocks = sdkp->max_unmap_blocks; 971 - else 972 - max_blocks = sdkp->max_ws_blocks; 973 - 974 - max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS10_BLOCKS); 975 - break; 976 - 977 - case SD_LBP_ZERO: 978 - max_blocks = min_not_zero(sdkp->max_ws_blocks, 979 - (u32)SD_MAX_WS10_BLOCKS); 980 - break; 981 - } 982 - 983 - lim->max_hw_discard_sectors = max_blocks * 984 - (logical_block_size >> SECTOR_SHIFT); 985 867 } 986 868 987 869 static void *sd_set_special_bvec(struct request *rq, unsigned int data_len) ··· 1682 1676 struct scsi_device *sdp = sdkp->device; 1683 1677 void __user *p = (void __user *)arg; 1684 1678 int error; 1685 - 1686 - SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, " 1687 - "cmd=0x%x\n", disk->disk_name, cmd)); 1679 + 1680 + SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, 1681 + "sd_ioctl: disk=%s, cmd=0x%x\n", 1682 + disk->disk_name, cmd)); 1688 1683 1689 1684 if (bdev_is_partition(bdev) && !capable(CAP_SYS_RAWIO)) 1690 1685 return -ENOIOCTLCMD; ··· 2184 2177 put_device(&sdkp->disk_dev); 2185 2178 } 2186 2179 2187 - static const struct block_device_operations sd_fops = { 2188 - .owner = THIS_MODULE, 2189 - .open = sd_open, 2190 - .release = sd_release, 2191 - .ioctl = sd_ioctl, 2192 - .getgeo = sd_getgeo, 2193 - .compat_ioctl = blkdev_compat_ptr_ioctl, 2194 - .check_events = sd_check_events, 2195 - .unlock_native_capacity = sd_unlock_native_capacity, 2196 - .report_zones = sd_zbc_report_zones, 2197 - .get_unique_id = sd_get_unique_id, 2198 - .free_disk = scsi_disk_free_disk, 2199 - .pr_ops = &sd_pr_ops, 2200 - }; 2201 - 2202 2180 /** 2203 2181 * sd_eh_reset - reset error handling callback 2204 2182 * @scmd: sd-issued command that has failed ··· 2594 2602 type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */ 2595 2603 2596 2604 if (type > T10_PI_TYPE3_PROTECTION) { 2597 - sd_printk(KERN_ERR, sdkp, "formatted with unsupported" \ 2598 - " protection type %u. Disabling disk!\n", 2605 + sd_printk(KERN_ERR, sdkp, 2606 + "formatted with unsupported protection type %u. Disabling disk!\n", 2599 2607 type); 2600 2608 sdkp->protection_type = 0; 2601 2609 return -ENODEV; ··· 2872 2880 if ((sizeof(sdkp->capacity) > 4) && 2873 2881 (sdkp->capacity > 0xffffffffULL)) { 2874 2882 int old_sector_size = sector_size; 2875 - sd_printk(KERN_NOTICE, sdkp, "Very big device. " 2876 - "Trying to use READ CAPACITY(16).\n"); 2883 + sd_printk(KERN_NOTICE, sdkp, 2884 + "Very big device. Trying to use READ CAPACITY(16).\n"); 2877 2885 sector_size = read_capacity_16(sdkp, sdp, lim, buffer); 2878 2886 if (sector_size < 0) { 2879 2887 sd_printk(KERN_NOTICE, sdkp, ··· 2899 2907 */ 2900 2908 if (sdp->fix_capacity || 2901 2909 (sdp->guess_capacity && (sdkp->capacity & 0x01))) { 2902 - sd_printk(KERN_INFO, sdkp, "Adjusting the sector count " 2903 - "from its reported value: %llu\n", 2904 - (unsigned long long) sdkp->capacity); 2910 + sd_printk(KERN_INFO, sdkp, 2911 + "Adjusting the sector count from its reported value: %llu\n", 2912 + (unsigned long long) sdkp->capacity); 2905 2913 --sdkp->capacity; 2906 2914 } 2907 2915 2908 2916 got_data: 2909 2917 if (sector_size == 0) { 2910 2918 sector_size = 512; 2911 - sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, " 2912 - "assuming 512.\n"); 2919 + sd_printk(KERN_NOTICE, sdkp, 2920 + "Sector size 0 reported, assuming 512.\n"); 2913 2921 } 2914 2922 2915 2923 if (sector_size != 512 && ··· 3114 3122 if (len < 3) 3115 3123 goto bad_sense; 3116 3124 else if (len > SD_BUF_SIZE) { 3117 - sd_first_printk(KERN_NOTICE, sdkp, "Truncating mode parameter " 3118 - "data from %d to %d bytes\n", len, SD_BUF_SIZE); 3125 + sd_first_printk(KERN_NOTICE, sdkp, 3126 + "Truncating mode parameter data from %d to %d bytes\n", 3127 + len, SD_BUF_SIZE); 3119 3128 len = SD_BUF_SIZE; 3120 3129 } 3121 3130 if (modepage == 0x3F && sdp->use_192_bytes_for_3f) ··· 3139 3146 */ 3140 3147 if (len - offset <= 2) { 3141 3148 sd_first_printk(KERN_ERR, sdkp, 3142 - "Incomplete mode parameter " 3143 - "data\n"); 3149 + "Incomplete mode parameter data\n"); 3144 3150 goto defaults; 3145 3151 } else { 3146 3152 modepage = page_code; ··· 3154 3162 offset += 2 + buffer[offset+1]; 3155 3163 else { 3156 3164 sd_first_printk(KERN_ERR, sdkp, 3157 - "Incomplete mode " 3158 - "parameter data\n"); 3165 + "Incomplete mode parameter data\n"); 3159 3166 goto defaults; 3160 3167 } 3161 3168 } ··· 3617 3626 3618 3627 if (min_xfer_bytes & (sdkp->physical_block_size - 1)) { 3619 3628 sd_first_printk(KERN_WARNING, sdkp, 3620 - "Preferred minimum I/O size %u bytes not a " \ 3621 - "multiple of physical block size (%u bytes)\n", 3629 + "Preferred minimum I/O size %u bytes not a multiple of physical block size (%u bytes)\n", 3622 3630 min_xfer_bytes, sdkp->physical_block_size); 3623 3631 sdkp->min_xfer_blocks = 0; 3624 3632 return false; ··· 3647 3657 3648 3658 if (sdkp->opt_xfer_blocks > dev_max) { 3649 3659 sd_first_printk(KERN_WARNING, sdkp, 3650 - "Optimal transfer size %u logical blocks " \ 3651 - "> dev_max (%u logical blocks)\n", 3660 + "Optimal transfer size %u logical blocks > dev_max (%u logical blocks)\n", 3652 3661 sdkp->opt_xfer_blocks, dev_max); 3653 3662 return false; 3654 3663 } 3655 3664 3656 3665 if (sdkp->opt_xfer_blocks > SD_DEF_XFER_BLOCKS) { 3657 3666 sd_first_printk(KERN_WARNING, sdkp, 3658 - "Optimal transfer size %u logical blocks " \ 3659 - "> sd driver limit (%u logical blocks)\n", 3667 + "Optimal transfer size %u logical blocks > sd driver limit (%u logical blocks)\n", 3660 3668 sdkp->opt_xfer_blocks, SD_DEF_XFER_BLOCKS); 3661 3669 return false; 3662 3670 } 3663 3671 3664 3672 if (opt_xfer_bytes < PAGE_SIZE) { 3665 3673 sd_first_printk(KERN_WARNING, sdkp, 3666 - "Optimal transfer size %u bytes < " \ 3667 - "PAGE_SIZE (%u bytes)\n", 3674 + "Optimal transfer size %u bytes < PAGE_SIZE (%u bytes)\n", 3668 3675 opt_xfer_bytes, (unsigned int)PAGE_SIZE); 3669 3676 return false; 3670 3677 } 3671 3678 3672 3679 if (min_xfer_bytes && opt_xfer_bytes % min_xfer_bytes) { 3673 3680 sd_first_printk(KERN_WARNING, sdkp, 3674 - "Optimal transfer size %u bytes not a " \ 3675 - "multiple of preferred minimum block " \ 3676 - "size (%u bytes)\n", 3681 + "Optimal transfer size %u bytes not a multiple of preferred minimum block size (%u bytes)\n", 3677 3682 opt_xfer_bytes, min_xfer_bytes); 3678 3683 return false; 3679 3684 } 3680 3685 3681 3686 if (opt_xfer_bytes & (sdkp->physical_block_size - 1)) { 3682 3687 sd_first_printk(KERN_WARNING, sdkp, 3683 - "Optimal transfer size %u bytes not a " \ 3684 - "multiple of physical block size (%u bytes)\n", 3688 + "Optimal transfer size %u bytes not a multiple of physical block size (%u bytes)\n", 3685 3689 opt_xfer_bytes, sdkp->physical_block_size); 3686 3690 return false; 3687 3691 } ··· 3868 3884 if (sdev->host->hostt->unlock_native_capacity) 3869 3885 sdev->host->hostt->unlock_native_capacity(sdev); 3870 3886 } 3887 + 3888 + static const struct block_device_operations sd_fops = { 3889 + .owner = THIS_MODULE, 3890 + .open = sd_open, 3891 + .release = sd_release, 3892 + .ioctl = sd_ioctl, 3893 + .getgeo = sd_getgeo, 3894 + .compat_ioctl = blkdev_compat_ptr_ioctl, 3895 + .check_events = sd_check_events, 3896 + .unlock_native_capacity = sd_unlock_native_capacity, 3897 + .report_zones = sd_zbc_report_zones, 3898 + .get_unique_id = sd_get_unique_id, 3899 + .free_disk = scsi_disk_free_disk, 3900 + .pr_ops = &sd_pr_ops, 3901 + }; 3871 3902 3872 3903 /** 3873 3904 * sd_format_disk_name - format disk name ··· 4086 4087 return error; 4087 4088 } 4088 4089 4089 - /** 4090 - * sd_remove - called whenever a scsi disk (previously recognized by 4091 - * sd_probe) is detached from the system. It is called (potentially 4092 - * multiple times) during sd module unload. 4093 - * @sdp: pointer to device object 4094 - * 4095 - * Note: this function is invoked from the scsi mid-level. 4096 - * This function potentially frees up a device name (e.g. /dev/sdc) 4097 - * that could be re-used by a subsequent sd_probe(). 4098 - * This function is not called when the built-in sd driver is "exit-ed". 4099 - **/ 4100 - static void sd_remove(struct scsi_device *sdp) 4101 - { 4102 - struct device *dev = &sdp->sdev_gendev; 4103 - struct scsi_disk *sdkp = dev_get_drvdata(dev); 4104 - 4105 - scsi_autopm_get_device(sdkp->device); 4106 - 4107 - device_del(&sdkp->disk_dev); 4108 - del_gendisk(sdkp->disk); 4109 - if (!sdkp->suspended) 4110 - sd_shutdown(sdp); 4111 - 4112 - put_disk(sdkp->disk); 4113 - } 4114 - 4115 - static void scsi_disk_release(struct device *dev) 4116 - { 4117 - struct scsi_disk *sdkp = to_scsi_disk(dev); 4118 - 4119 - ida_free(&sd_index_ida, sdkp->index); 4120 - put_device(&sdkp->device->sdev_gendev); 4121 - free_opal_dev(sdkp->opal_dev); 4122 - 4123 - kfree(sdkp); 4124 - } 4125 - 4126 4090 static int sd_start_stop_device(struct scsi_disk *sdkp, int start) 4127 4091 { 4128 4092 unsigned char cmd[6] = { START_STOP }; /* START_VALID */ ··· 4186 4224 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n"); 4187 4225 sd_start_stop_device(sdkp, 0); 4188 4226 } 4227 + } 4228 + 4229 + /** 4230 + * sd_remove - called whenever a scsi disk (previously recognized by 4231 + * sd_probe) is detached from the system. It is called (potentially 4232 + * multiple times) during sd module unload. 4233 + * @sdp: pointer to device object 4234 + * 4235 + * Note: this function is invoked from the scsi mid-level. 4236 + * This function potentially frees up a device name (e.g. /dev/sdc) 4237 + * that could be re-used by a subsequent sd_probe(). 4238 + * This function is not called when the built-in sd driver is "exit-ed". 4239 + **/ 4240 + static void sd_remove(struct scsi_device *sdp) 4241 + { 4242 + struct device *dev = &sdp->sdev_gendev; 4243 + struct scsi_disk *sdkp = dev_get_drvdata(dev); 4244 + 4245 + scsi_autopm_get_device(sdkp->device); 4246 + 4247 + device_del(&sdkp->disk_dev); 4248 + del_gendisk(sdkp->disk); 4249 + if (!sdkp->suspended) 4250 + sd_shutdown(sdp); 4251 + 4252 + put_disk(sdkp->disk); 4189 4253 } 4190 4254 4191 4255 static inline bool sd_do_start_stop(struct scsi_device *sdev, bool runtime)

Configure Feed

Configure Feed