LCOV - code coverage report
Current view: top level - drivers/scsi - scsi_sysfs.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 9 443 2.0 %
Date: 2020-09-30 20:25:40 Functions: 2 88 2.3 %
Branches: 2 274 0.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * scsi_sysfs.c
       4                 :            :  *
       5                 :            :  * SCSI sysfs interface routines.
       6                 :            :  *
       7                 :            :  * Created to pull SCSI mid layer sysfs routines into one file.
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <linux/module.h>
      11                 :            : #include <linux/slab.h>
      12                 :            : #include <linux/init.h>
      13                 :            : #include <linux/blkdev.h>
      14                 :            : #include <linux/device.h>
      15                 :            : #include <linux/pm_runtime.h>
      16                 :            : 
      17                 :            : #include <scsi/scsi.h>
      18                 :            : #include <scsi/scsi_device.h>
      19                 :            : #include <scsi/scsi_host.h>
      20                 :            : #include <scsi/scsi_tcq.h>
      21                 :            : #include <scsi/scsi_dh.h>
      22                 :            : #include <scsi/scsi_transport.h>
      23                 :            : #include <scsi/scsi_driver.h>
      24                 :            : #include <scsi/scsi_devinfo.h>
      25                 :            : 
      26                 :            : #include "scsi_priv.h"
      27                 :            : #include "scsi_logging.h"
      28                 :            : 
      29                 :            : static struct device_type scsi_dev_type;
      30                 :            : 
      31                 :            : static const struct {
      32                 :            :         enum scsi_device_state  value;
      33                 :            :         char                    *name;
      34                 :            : } sdev_states[] = {
      35                 :            :         { SDEV_CREATED, "created" },
      36                 :            :         { SDEV_RUNNING, "running" },
      37                 :            :         { SDEV_CANCEL, "cancel" },
      38                 :            :         { SDEV_DEL, "deleted" },
      39                 :            :         { SDEV_QUIESCE, "quiesce" },
      40                 :            :         { SDEV_OFFLINE, "offline" },
      41                 :            :         { SDEV_TRANSPORT_OFFLINE, "transport-offline" },
      42                 :            :         { SDEV_BLOCK,   "blocked" },
      43                 :            :         { SDEV_CREATED_BLOCK, "created-blocked" },
      44                 :            : };
      45                 :            : 
      46                 :          0 : const char *scsi_device_state_name(enum scsi_device_state state)
      47                 :            : {
      48                 :            :         int i;
      49                 :            :         char *name = NULL;
      50                 :            : 
      51   [ #  #  #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
      52   [ #  #  #  # ]:          0 :                 if (sdev_states[i].value == state) {
      53                 :          0 :                         name = sdev_states[i].name;
      54                 :          0 :                         break;
      55                 :            :                 }
      56                 :            :         }
      57                 :          0 :         return name;
      58                 :            : }
      59                 :            : 
      60                 :            : static const struct {
      61                 :            :         enum scsi_host_state    value;
      62                 :            :         char                    *name;
      63                 :            : } shost_states[] = {
      64                 :            :         { SHOST_CREATED, "created" },
      65                 :            :         { SHOST_RUNNING, "running" },
      66                 :            :         { SHOST_CANCEL, "cancel" },
      67                 :            :         { SHOST_DEL, "deleted" },
      68                 :            :         { SHOST_RECOVERY, "recovery" },
      69                 :            :         { SHOST_CANCEL_RECOVERY, "cancel/recovery" },
      70                 :            :         { SHOST_DEL_RECOVERY, "deleted/recovery", },
      71                 :            : };
      72                 :          0 : const char *scsi_host_state_name(enum scsi_host_state state)
      73                 :            : {
      74                 :            :         int i;
      75                 :            :         char *name = NULL;
      76                 :            : 
      77   [ #  #  #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
      78   [ #  #  #  # ]:          0 :                 if (shost_states[i].value == state) {
      79                 :          0 :                         name = shost_states[i].name;
      80                 :          0 :                         break;
      81                 :            :                 }
      82                 :            :         }
      83                 :          0 :         return name;
      84                 :            : }
      85                 :            : 
      86                 :            : #ifdef CONFIG_SCSI_DH
      87                 :            : static const struct {
      88                 :            :         unsigned char   value;
      89                 :            :         char            *name;
      90                 :            : } sdev_access_states[] = {
      91                 :            :         { SCSI_ACCESS_STATE_OPTIMAL, "active/optimized" },
      92                 :            :         { SCSI_ACCESS_STATE_ACTIVE, "active/non-optimized" },
      93                 :            :         { SCSI_ACCESS_STATE_STANDBY, "standby" },
      94                 :            :         { SCSI_ACCESS_STATE_UNAVAILABLE, "unavailable" },
      95                 :            :         { SCSI_ACCESS_STATE_LBA, "lba-dependent" },
      96                 :            :         { SCSI_ACCESS_STATE_OFFLINE, "offline" },
      97                 :            :         { SCSI_ACCESS_STATE_TRANSITIONING, "transitioning" },
      98                 :            : };
      99                 :            : 
     100                 :            : static const char *scsi_access_state_name(unsigned char state)
     101                 :            : {
     102                 :            :         int i;
     103                 :            :         char *name = NULL;
     104                 :            : 
     105                 :            :         for (i = 0; i < ARRAY_SIZE(sdev_access_states); i++) {
     106                 :            :                 if (sdev_access_states[i].value == state) {
     107                 :            :                         name = sdev_access_states[i].name;
     108                 :            :                         break;
     109                 :            :                 }
     110                 :            :         }
     111                 :            :         return name;
     112                 :            : }
     113                 :            : #endif
     114                 :            : 
     115                 :          0 : static int check_set(unsigned long long *val, char *src)
     116                 :            : {
     117                 :            :         char *last;
     118                 :            : 
     119         [ #  # ]:          0 :         if (strcmp(src, "-") == 0) {
     120                 :          0 :                 *val = SCAN_WILD_CARD;
     121                 :            :         } else {
     122                 :            :                 /*
     123                 :            :                  * Doesn't check for int overflow
     124                 :            :                  */
     125                 :          0 :                 *val = simple_strtoull(src, &last, 0);
     126         [ #  # ]:          0 :                 if (*last != '\0')
     127                 :            :                         return 1;
     128                 :            :         }
     129                 :            :         return 0;
     130                 :            : }
     131                 :            : 
     132                 :          0 : static int scsi_scan(struct Scsi_Host *shost, const char *str)
     133                 :            : {
     134                 :            :         char s1[15], s2[15], s3[17], junk;
     135                 :            :         unsigned long long channel, id, lun;
     136                 :            :         int res;
     137                 :            : 
     138                 :          0 :         res = sscanf(str, "%10s %10s %16s %c", s1, s2, s3, &junk);
     139         [ #  # ]:          0 :         if (res != 3)
     140                 :            :                 return -EINVAL;
     141         [ #  # ]:          0 :         if (check_set(&channel, s1))
     142                 :            :                 return -EINVAL;
     143         [ #  # ]:          0 :         if (check_set(&id, s2))
     144                 :            :                 return -EINVAL;
     145         [ #  # ]:          0 :         if (check_set(&lun, s3))
     146                 :            :                 return -EINVAL;
     147         [ #  # ]:          0 :         if (shost->transportt->user_scan)
     148                 :          0 :                 res = shost->transportt->user_scan(shost, channel, id, lun);
     149                 :            :         else
     150                 :          0 :                 res = scsi_scan_host_selected(shost, channel, id, lun,
     151                 :            :                                               SCSI_SCAN_MANUAL);
     152                 :          0 :         return res;
     153                 :            : }
     154                 :            : 
     155                 :            : /*
     156                 :            :  * shost_show_function: macro to create an attr function that can be used to
     157                 :            :  * show a non-bit field.
     158                 :            :  */
     159                 :            : #define shost_show_function(name, field, format_string)                 \
     160                 :            : static ssize_t                                                          \
     161                 :            : show_##name (struct device *dev, struct device_attribute *attr,         \
     162                 :            :              char *buf)                                                 \
     163                 :            : {                                                                       \
     164                 :            :         struct Scsi_Host *shost = class_to_shost(dev);                  \
     165                 :            :         return snprintf (buf, 20, format_string, shost->field);              \
     166                 :            : }
     167                 :            : 
     168                 :            : /*
     169                 :            :  * shost_rd_attr: macro to create a function and attribute variable for a
     170                 :            :  * read only field.
     171                 :            :  */
     172                 :            : #define shost_rd_attr2(name, field, format_string)                      \
     173                 :            :         shost_show_function(name, field, format_string)                 \
     174                 :            : static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
     175                 :            : 
     176                 :            : #define shost_rd_attr(field, format_string) \
     177                 :            : shost_rd_attr2(field, field, format_string)
     178                 :            : 
     179                 :            : /*
     180                 :            :  * Create the actual show/store functions and data structures.
     181                 :            :  */
     182                 :            : 
     183                 :            : static ssize_t
     184                 :          0 : store_scan(struct device *dev, struct device_attribute *attr,
     185                 :            :            const char *buf, size_t count)
     186                 :            : {
     187                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     188                 :            :         int res;
     189                 :            : 
     190                 :          0 :         res = scsi_scan(shost, buf);
     191         [ #  # ]:          0 :         if (res == 0)
     192                 :          0 :                 res = count;
     193                 :          0 :         return res;
     194                 :            : };
     195                 :            : static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
     196                 :            : 
     197                 :            : static ssize_t
     198                 :          0 : store_shost_state(struct device *dev, struct device_attribute *attr,
     199                 :            :                   const char *buf, size_t count)
     200                 :            : {
     201                 :            :         int i;
     202                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     203                 :            :         enum scsi_host_state state = 0;
     204                 :            : 
     205         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
     206                 :          0 :                 const int len = strlen(shost_states[i].name);
     207   [ #  #  #  # ]:          0 :                 if (strncmp(shost_states[i].name, buf, len) == 0 &&
     208                 :          0 :                    buf[len] == '\n') {
     209                 :          0 :                         state = shost_states[i].value;
     210                 :          0 :                         break;
     211                 :            :                 }
     212                 :            :         }
     213         [ #  # ]:          0 :         if (!state)
     214                 :            :                 return -EINVAL;
     215                 :            : 
     216         [ #  # ]:          0 :         if (scsi_host_set_state(shost, state))
     217                 :            :                 return -EINVAL;
     218                 :          0 :         return count;
     219                 :            : }
     220                 :            : 
     221                 :            : static ssize_t
     222                 :          0 : show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
     223                 :            : {
     224                 :            :         struct Scsi_Host *shost = class_to_shost(dev);
     225                 :          0 :         const char *name = scsi_host_state_name(shost->shost_state);
     226                 :            : 
     227         [ #  # ]:          0 :         if (!name)
     228                 :            :                 return -EINVAL;
     229                 :            : 
     230                 :          0 :         return snprintf(buf, 20, "%s\n", name);
     231                 :            : }
     232                 :            : 
     233                 :            : /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
     234                 :            : static struct device_attribute dev_attr_hstate =
     235                 :            :         __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
     236                 :            : 
     237                 :            : static ssize_t
     238                 :          0 : show_shost_mode(unsigned int mode, char *buf)
     239                 :            : {
     240                 :            :         ssize_t len = 0;
     241                 :            : 
     242         [ #  # ]:          0 :         if (mode & MODE_INITIATOR)
     243                 :          0 :                 len = sprintf(buf, "%s", "Initiator");
     244                 :            : 
     245         [ #  # ]:          0 :         if (mode & MODE_TARGET)
     246         [ #  # ]:          0 :                 len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
     247                 :            : 
     248                 :          0 :         len += sprintf(buf + len, "\n");
     249                 :            : 
     250                 :          0 :         return len;
     251                 :            : }
     252                 :            : 
     253                 :            : static ssize_t
     254                 :          0 : show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
     255                 :            :                           char *buf)
     256                 :            : {
     257                 :            :         struct Scsi_Host *shost = class_to_shost(dev);
     258                 :          0 :         unsigned int supported_mode = shost->hostt->supported_mode;
     259                 :            : 
     260         [ #  # ]:          0 :         if (supported_mode == MODE_UNKNOWN)
     261                 :            :                 /* by default this should be initiator */
     262                 :            :                 supported_mode = MODE_INITIATOR;
     263                 :            : 
     264                 :          0 :         return show_shost_mode(supported_mode, buf);
     265                 :            : }
     266                 :            : 
     267                 :            : static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
     268                 :            : 
     269                 :            : static ssize_t
     270                 :          0 : show_shost_active_mode(struct device *dev,
     271                 :            :                        struct device_attribute *attr, char *buf)
     272                 :            : {
     273                 :            :         struct Scsi_Host *shost = class_to_shost(dev);
     274                 :            : 
     275         [ #  # ]:          0 :         if (shost->active_mode == MODE_UNKNOWN)
     276                 :          0 :                 return snprintf(buf, 20, "unknown\n");
     277                 :            :         else
     278                 :          0 :                 return show_shost_mode(shost->active_mode, buf);
     279                 :            : }
     280                 :            : 
     281                 :            : static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
     282                 :            : 
     283                 :          0 : static int check_reset_type(const char *str)
     284                 :            : {
     285         [ #  # ]:          0 :         if (sysfs_streq(str, "adapter"))
     286                 :            :                 return SCSI_ADAPTER_RESET;
     287         [ #  # ]:          0 :         else if (sysfs_streq(str, "firmware"))
     288                 :            :                 return SCSI_FIRMWARE_RESET;
     289                 :            :         else
     290                 :          0 :                 return 0;
     291                 :            : }
     292                 :            : 
     293                 :            : static ssize_t
     294                 :          0 : store_host_reset(struct device *dev, struct device_attribute *attr,
     295                 :            :                 const char *buf, size_t count)
     296                 :            : {
     297                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     298                 :          0 :         struct scsi_host_template *sht = shost->hostt;
     299                 :            :         int ret = -EINVAL;
     300                 :            :         int type;
     301                 :            : 
     302                 :          0 :         type = check_reset_type(buf);
     303         [ #  # ]:          0 :         if (!type)
     304                 :            :                 goto exit_store_host_reset;
     305                 :            : 
     306         [ #  # ]:          0 :         if (sht->host_reset)
     307                 :          0 :                 ret = sht->host_reset(shost, type);
     308                 :            :         else
     309                 :            :                 ret = -EOPNOTSUPP;
     310                 :            : 
     311                 :            : exit_store_host_reset:
     312         [ #  # ]:          0 :         if (ret == 0)
     313                 :          0 :                 ret = count;
     314                 :          0 :         return ret;
     315                 :            : }
     316                 :            : 
     317                 :            : static DEVICE_ATTR(host_reset, S_IWUSR, NULL, store_host_reset);
     318                 :            : 
     319                 :            : static ssize_t
     320                 :          0 : show_shost_eh_deadline(struct device *dev,
     321                 :            :                       struct device_attribute *attr, char *buf)
     322                 :            : {
     323                 :            :         struct Scsi_Host *shost = class_to_shost(dev);
     324                 :            : 
     325         [ #  # ]:          0 :         if (shost->eh_deadline == -1)
     326                 :          0 :                 return snprintf(buf, strlen("off") + 2, "off\n");
     327                 :          0 :         return sprintf(buf, "%u\n", shost->eh_deadline / HZ);
     328                 :            : }
     329                 :            : 
     330                 :            : static ssize_t
     331                 :          0 : store_shost_eh_deadline(struct device *dev, struct device_attribute *attr,
     332                 :            :                 const char *buf, size_t count)
     333                 :            : {
     334                 :            :         struct Scsi_Host *shost = class_to_shost(dev);
     335                 :            :         int ret = -EINVAL;
     336                 :            :         unsigned long deadline, flags;
     337                 :            : 
     338   [ #  #  #  # ]:          0 :         if (shost->transportt &&
     339         [ #  # ]:          0 :             (shost->transportt->eh_strategy_handler ||
     340                 :          0 :              !shost->hostt->eh_host_reset_handler))
     341                 :            :                 return ret;
     342                 :            : 
     343         [ #  # ]:          0 :         if (!strncmp(buf, "off", strlen("off")))
     344                 :          0 :                 deadline = -1;
     345                 :            :         else {
     346                 :            :                 ret = kstrtoul(buf, 10, &deadline);
     347         [ #  # ]:          0 :                 if (ret)
     348                 :            :                         return ret;
     349                 :            :                 if (deadline * HZ > UINT_MAX)
     350                 :            :                         return -EINVAL;
     351                 :            :         }
     352                 :            : 
     353                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
     354         [ #  # ]:          0 :         if (scsi_host_in_recovery(shost))
     355                 :            :                 ret = -EBUSY;
     356                 :            :         else {
     357         [ #  # ]:          0 :                 if (deadline == -1)
     358                 :          0 :                         shost->eh_deadline = -1;
     359                 :            :                 else
     360                 :          0 :                         shost->eh_deadline = deadline * HZ;
     361                 :            : 
     362                 :          0 :                 ret = count;
     363                 :            :         }
     364                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
     365                 :            : 
     366                 :          0 :         return ret;
     367                 :            : }
     368                 :            : 
     369                 :            : static DEVICE_ATTR(eh_deadline, S_IRUGO | S_IWUSR, show_shost_eh_deadline, store_shost_eh_deadline);
     370                 :            : 
     371                 :          0 : shost_rd_attr(unique_id, "%u\n");
     372                 :          0 : shost_rd_attr(cmd_per_lun, "%hd\n");
     373                 :          0 : shost_rd_attr(can_queue, "%hd\n");
     374                 :          0 : shost_rd_attr(sg_tablesize, "%hu\n");
     375                 :          0 : shost_rd_attr(sg_prot_tablesize, "%hu\n");
     376                 :          0 : shost_rd_attr(unchecked_isa_dma, "%d\n");
     377                 :          0 : shost_rd_attr(prot_capabilities, "%u\n");
     378                 :          0 : shost_rd_attr(prot_guard_type, "%hd\n");
     379                 :          0 : shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
     380                 :            : 
     381                 :            : static ssize_t
     382                 :          0 : show_host_busy(struct device *dev, struct device_attribute *attr, char *buf)
     383                 :            : {
     384                 :          0 :         struct Scsi_Host *shost = class_to_shost(dev);
     385                 :          0 :         return snprintf(buf, 20, "%d\n", scsi_host_busy(shost));
     386                 :            : }
     387                 :            : static DEVICE_ATTR(host_busy, S_IRUGO, show_host_busy, NULL);
     388                 :            : 
     389                 :            : static ssize_t
     390                 :          0 : show_use_blk_mq(struct device *dev, struct device_attribute *attr, char *buf)
     391                 :            : {
     392                 :          0 :         return sprintf(buf, "1\n");
     393                 :            : }
     394                 :            : static DEVICE_ATTR(use_blk_mq, S_IRUGO, show_use_blk_mq, NULL);
     395                 :            : 
     396                 :            : static struct attribute *scsi_sysfs_shost_attrs[] = {
     397                 :            :         &dev_attr_use_blk_mq.attr,
     398                 :            :         &dev_attr_unique_id.attr,
     399                 :            :         &dev_attr_host_busy.attr,
     400                 :            :         &dev_attr_cmd_per_lun.attr,
     401                 :            :         &dev_attr_can_queue.attr,
     402                 :            :         &dev_attr_sg_tablesize.attr,
     403                 :            :         &dev_attr_sg_prot_tablesize.attr,
     404                 :            :         &dev_attr_unchecked_isa_dma.attr,
     405                 :            :         &dev_attr_proc_name.attr,
     406                 :            :         &dev_attr_scan.attr,
     407                 :            :         &dev_attr_hstate.attr,
     408                 :            :         &dev_attr_supported_mode.attr,
     409                 :            :         &dev_attr_active_mode.attr,
     410                 :            :         &dev_attr_prot_capabilities.attr,
     411                 :            :         &dev_attr_prot_guard_type.attr,
     412                 :            :         &dev_attr_host_reset.attr,
     413                 :            :         &dev_attr_eh_deadline.attr,
     414                 :            :         NULL
     415                 :            : };
     416                 :            : 
     417                 :            : static struct attribute_group scsi_shost_attr_group = {
     418                 :            :         .attrs =        scsi_sysfs_shost_attrs,
     419                 :            : };
     420                 :            : 
     421                 :            : const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
     422                 :            :         &scsi_shost_attr_group,
     423                 :            :         NULL
     424                 :            : };
     425                 :            : 
     426                 :          0 : static void scsi_device_cls_release(struct device *class_dev)
     427                 :            : {
     428                 :            :         struct scsi_device *sdev;
     429                 :            : 
     430                 :            :         sdev = class_to_sdev(class_dev);
     431                 :          0 :         put_device(&sdev->sdev_gendev);
     432                 :          0 : }
     433                 :            : 
     434                 :          0 : static void scsi_device_dev_release_usercontext(struct work_struct *work)
     435                 :            : {
     436                 :            :         struct scsi_device *sdev;
     437                 :            :         struct device *parent;
     438                 :            :         struct list_head *this, *tmp;
     439                 :            :         struct scsi_vpd *vpd_pg80 = NULL, *vpd_pg83 = NULL;
     440                 :            :         unsigned long flags;
     441                 :            : 
     442                 :          0 :         sdev = container_of(work, struct scsi_device, ew.work);
     443                 :            : 
     444                 :            :         scsi_dh_release_device(sdev);
     445                 :            : 
     446                 :          0 :         parent = sdev->sdev_gendev.parent;
     447                 :            : 
     448                 :          0 :         spin_lock_irqsave(sdev->host->host_lock, flags);
     449                 :            :         list_del(&sdev->siblings);
     450                 :            :         list_del(&sdev->same_target_siblings);
     451                 :            :         list_del(&sdev->starved_entry);
     452                 :          0 :         spin_unlock_irqrestore(sdev->host->host_lock, flags);
     453                 :            : 
     454                 :          0 :         cancel_work_sync(&sdev->event_work);
     455                 :            : 
     456         [ #  # ]:          0 :         list_for_each_safe(this, tmp, &sdev->event_list) {
     457                 :            :                 struct scsi_event *evt;
     458                 :            : 
     459                 :          0 :                 evt = list_entry(this, struct scsi_event, node);
     460                 :            :                 list_del(&evt->node);
     461                 :          0 :                 kfree(evt);
     462                 :            :         }
     463                 :            : 
     464                 :          0 :         blk_put_queue(sdev->request_queue);
     465                 :            :         /* NULL queue means the device can't be used */
     466                 :          0 :         sdev->request_queue = NULL;
     467                 :            : 
     468                 :          0 :         mutex_lock(&sdev->inquiry_mutex);
     469                 :          0 :         rcu_swap_protected(sdev->vpd_pg80, vpd_pg80,
     470                 :            :                            lockdep_is_held(&sdev->inquiry_mutex));
     471                 :          0 :         rcu_swap_protected(sdev->vpd_pg83, vpd_pg83,
     472                 :            :                            lockdep_is_held(&sdev->inquiry_mutex));
     473                 :          0 :         mutex_unlock(&sdev->inquiry_mutex);
     474                 :            : 
     475         [ #  # ]:          0 :         if (vpd_pg83)
     476         [ #  # ]:          0 :                 kfree_rcu(vpd_pg83, rcu);
     477         [ #  # ]:          0 :         if (vpd_pg80)
     478         [ #  # ]:          0 :                 kfree_rcu(vpd_pg80, rcu);
     479                 :          0 :         kfree(sdev->inquiry);
     480                 :          0 :         kfree(sdev);
     481                 :            : 
     482         [ #  # ]:          0 :         if (parent)
     483                 :          0 :                 put_device(parent);
     484                 :          0 : }
     485                 :            : 
     486                 :          0 : static void scsi_device_dev_release(struct device *dev)
     487                 :            : {
     488                 :            :         struct scsi_device *sdp = to_scsi_device(dev);
     489                 :          0 :         execute_in_process_context(scsi_device_dev_release_usercontext,
     490                 :            :                                    &sdp->ew);
     491                 :          0 : }
     492                 :            : 
     493                 :            : static struct class sdev_class = {
     494                 :            :         .name           = "scsi_device",
     495                 :            :         .dev_release    = scsi_device_cls_release,
     496                 :            : };
     497                 :            : 
     498                 :            : /* all probing is done in the individual ->probe routines */
     499                 :          0 : static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
     500                 :            : {
     501                 :            :         struct scsi_device *sdp;
     502                 :            : 
     503         [ #  # ]:          0 :         if (dev->type != &scsi_dev_type)
     504                 :            :                 return 0;
     505                 :            : 
     506                 :            :         sdp = to_scsi_device(dev);
     507         [ #  # ]:          0 :         if (sdp->no_uld_attach)
     508                 :            :                 return 0;
     509                 :          0 :         return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
     510                 :            : }
     511                 :            : 
     512                 :          0 : static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
     513                 :            : {
     514                 :            :         struct scsi_device *sdev;
     515                 :            : 
     516         [ #  # ]:          0 :         if (dev->type != &scsi_dev_type)
     517                 :            :                 return 0;
     518                 :            : 
     519                 :            :         sdev = to_scsi_device(dev);
     520                 :            : 
     521                 :          0 :         add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
     522                 :          0 :         return 0;
     523                 :            : }
     524                 :            : 
     525                 :            : struct bus_type scsi_bus_type = {
     526                 :            :         .name           = "scsi",
     527                 :            :         .match          = scsi_bus_match,
     528                 :            :         .uevent         = scsi_bus_uevent,
     529                 :            : #ifdef CONFIG_PM
     530                 :            :         .pm             = &scsi_bus_pm_ops,
     531                 :            : #endif
     532                 :            : };
     533                 :            : EXPORT_SYMBOL_GPL(scsi_bus_type);
     534                 :            : 
     535                 :        207 : int scsi_sysfs_register(void)
     536                 :            : {
     537                 :            :         int error;
     538                 :            : 
     539                 :        207 :         error = bus_register(&scsi_bus_type);
     540         [ +  - ]:        207 :         if (!error) {
     541                 :        207 :                 error = class_register(&sdev_class);
     542         [ -  + ]:        207 :                 if (error)
     543                 :          0 :                         bus_unregister(&scsi_bus_type);
     544                 :            :         }
     545                 :            : 
     546                 :        207 :         return error;
     547                 :            : }
     548                 :            : 
     549                 :          0 : void scsi_sysfs_unregister(void)
     550                 :            : {
     551                 :          0 :         class_unregister(&sdev_class);
     552                 :          0 :         bus_unregister(&scsi_bus_type);
     553                 :          0 : }
     554                 :            : 
     555                 :            : /*
     556                 :            :  * sdev_show_function: macro to create an attr function that can be used to
     557                 :            :  * show a non-bit field.
     558                 :            :  */
     559                 :            : #define sdev_show_function(field, format_string)                                \
     560                 :            : static ssize_t                                                          \
     561                 :            : sdev_show_##field (struct device *dev, struct device_attribute *attr,   \
     562                 :            :                    char *buf)                                           \
     563                 :            : {                                                                       \
     564                 :            :         struct scsi_device *sdev;                                       \
     565                 :            :         sdev = to_scsi_device(dev);                                     \
     566                 :            :         return snprintf (buf, 20, format_string, sdev->field);               \
     567                 :            : }                                                                       \
     568                 :            : 
     569                 :            : /*
     570                 :            :  * sdev_rd_attr: macro to create a function and attribute variable for a
     571                 :            :  * read only field.
     572                 :            :  */
     573                 :            : #define sdev_rd_attr(field, format_string)                              \
     574                 :            :         sdev_show_function(field, format_string)                        \
     575                 :            : static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
     576                 :            : 
     577                 :            : 
     578                 :            : /*
     579                 :            :  * sdev_rw_attr: create a function and attribute variable for a
     580                 :            :  * read/write field.
     581                 :            :  */
     582                 :            : #define sdev_rw_attr(field, format_string)                              \
     583                 :            :         sdev_show_function(field, format_string)                                \
     584                 :            :                                                                         \
     585                 :            : static ssize_t                                                          \
     586                 :            : sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
     587                 :            :                     const char *buf, size_t count)                      \
     588                 :            : {                                                                       \
     589                 :            :         struct scsi_device *sdev;                                       \
     590                 :            :         sdev = to_scsi_device(dev);                                     \
     591                 :            :         sscanf (buf, format_string, &sdev->field);                       \
     592                 :            :         return count;                                                   \
     593                 :            : }                                                                       \
     594                 :            : static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
     595                 :            : 
     596                 :            : /* Currently we don't export bit fields, but we might in future,
     597                 :            :  * so leave this code in */
     598                 :            : #if 0
     599                 :            : /*
     600                 :            :  * sdev_rd_attr: create a function and attribute variable for a
     601                 :            :  * read/write bit field.
     602                 :            :  */
     603                 :            : #define sdev_rw_attr_bit(field)                                         \
     604                 :            :         sdev_show_function(field, "%d\n")                                     \
     605                 :            :                                                                         \
     606                 :            : static ssize_t                                                          \
     607                 :            : sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
     608                 :            :                     const char *buf, size_t count)                      \
     609                 :            : {                                                                       \
     610                 :            :         int ret;                                                        \
     611                 :            :         struct scsi_device *sdev;                                       \
     612                 :            :         ret = scsi_sdev_check_buf_bit(buf);                             \
     613                 :            :         if (ret >= 0)        {                                               \
     614                 :            :                 sdev = to_scsi_device(dev);                             \
     615                 :            :                 sdev->field = ret;                                   \
     616                 :            :                 ret = count;                                            \
     617                 :            :         }                                                               \
     618                 :            :         return ret;                                                     \
     619                 :            : }                                                                       \
     620                 :            : static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
     621                 :            : 
     622                 :            : /*
     623                 :            :  * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
     624                 :            :  * else return -EINVAL.
     625                 :            :  */
     626                 :            : static int scsi_sdev_check_buf_bit(const char *buf)
     627                 :            : {
     628                 :            :         if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
     629                 :            :                 if (buf[0] == '1')
     630                 :            :                         return 1;
     631                 :            :                 else if (buf[0] == '0')
     632                 :            :                         return 0;
     633                 :            :                 else 
     634                 :            :                         return -EINVAL;
     635                 :            :         } else
     636                 :            :                 return -EINVAL;
     637                 :            : }
     638                 :            : #endif
     639                 :            : /*
     640                 :            :  * Create the actual show/store functions and data structures.
     641                 :            :  */
     642                 :          0 : sdev_rd_attr (type, "%d\n");
     643                 :          0 : sdev_rd_attr (scsi_level, "%d\n");
     644                 :          0 : sdev_rd_attr (vendor, "%.8s\n");
     645                 :          0 : sdev_rd_attr (model, "%.16s\n");
     646                 :          0 : sdev_rd_attr (rev, "%.4s\n");
     647                 :            : 
     648                 :            : static ssize_t
     649                 :          0 : sdev_show_device_busy(struct device *dev, struct device_attribute *attr,
     650                 :            :                 char *buf)
     651                 :            : {
     652                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
     653                 :          0 :         return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_busy));
     654                 :            : }
     655                 :            : static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);
     656                 :            : 
     657                 :            : static ssize_t
     658                 :          0 : sdev_show_device_blocked(struct device *dev, struct device_attribute *attr,
     659                 :            :                 char *buf)
     660                 :            : {
     661                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
     662                 :          0 :         return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_blocked));
     663                 :            : }
     664                 :            : static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL);
     665                 :            : 
     666                 :            : /*
     667                 :            :  * TODO: can we make these symlinks to the block layer ones?
     668                 :            :  */
     669                 :            : static ssize_t
     670                 :          0 : sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
     671                 :            : {
     672                 :            :         struct scsi_device *sdev;
     673                 :            :         sdev = to_scsi_device(dev);
     674                 :          0 :         return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
     675                 :            : }
     676                 :            : 
     677                 :            : static ssize_t
     678                 :          0 : sdev_store_timeout (struct device *dev, struct device_attribute *attr,
     679                 :            :                     const char *buf, size_t count)
     680                 :            : {
     681                 :            :         struct scsi_device *sdev;
     682                 :            :         int timeout;
     683                 :            :         sdev = to_scsi_device(dev);
     684                 :          0 :         sscanf (buf, "%d\n", &timeout);
     685                 :          0 :         blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
     686                 :          0 :         return count;
     687                 :            : }
     688                 :            : static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
     689                 :            : 
     690                 :            : static ssize_t
     691                 :          0 : sdev_show_eh_timeout(struct device *dev, struct device_attribute *attr, char *buf)
     692                 :            : {
     693                 :            :         struct scsi_device *sdev;
     694                 :            :         sdev = to_scsi_device(dev);
     695                 :          0 :         return snprintf(buf, 20, "%u\n", sdev->eh_timeout / HZ);
     696                 :            : }
     697                 :            : 
     698                 :            : static ssize_t
     699                 :          0 : sdev_store_eh_timeout(struct device *dev, struct device_attribute *attr,
     700                 :            :                     const char *buf, size_t count)
     701                 :            : {
     702                 :            :         struct scsi_device *sdev;
     703                 :            :         unsigned int eh_timeout;
     704                 :            :         int err;
     705                 :            : 
     706         [ #  # ]:          0 :         if (!capable(CAP_SYS_ADMIN))
     707                 :            :                 return -EACCES;
     708                 :            : 
     709                 :            :         sdev = to_scsi_device(dev);
     710                 :          0 :         err = kstrtouint(buf, 10, &eh_timeout);
     711         [ #  # ]:          0 :         if (err)
     712                 :            :                 return err;
     713                 :          0 :         sdev->eh_timeout = eh_timeout * HZ;
     714                 :            : 
     715                 :          0 :         return count;
     716                 :            : }
     717                 :            : static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout);
     718                 :            : 
     719                 :            : static ssize_t
     720                 :          0 : store_rescan_field (struct device *dev, struct device_attribute *attr,
     721                 :            :                     const char *buf, size_t count)
     722                 :            : {
     723                 :          0 :         scsi_rescan_device(dev);
     724                 :          0 :         return count;
     725                 :            : }
     726                 :            : static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
     727                 :            : 
     728                 :            : static ssize_t
     729                 :          0 : sdev_store_delete(struct device *dev, struct device_attribute *attr,
     730                 :            :                   const char *buf, size_t count)
     731                 :            : {
     732                 :            :         struct kernfs_node *kn;
     733                 :          0 :         struct scsi_device *sdev = to_scsi_device(dev);
     734                 :            : 
     735                 :            :         /*
     736                 :            :          * We need to try to get module, avoiding the module been removed
     737                 :            :          * during delete.
     738                 :            :          */
     739         [ #  # ]:          0 :         if (scsi_device_get(sdev))
     740                 :            :                 return -ENODEV;
     741                 :            : 
     742                 :          0 :         kn = sysfs_break_active_protection(&dev->kobj, &attr->attr);
     743   [ #  #  #  # ]:          0 :         WARN_ON_ONCE(!kn);
     744                 :            :         /*
     745                 :            :          * Concurrent writes into the "delete" sysfs attribute may trigger
     746                 :            :          * concurrent calls to device_remove_file() and scsi_remove_device().
     747                 :            :          * device_remove_file() handles concurrent removal calls by
     748                 :            :          * serializing these and by ignoring the second and later removal
     749                 :            :          * attempts.  Concurrent calls of scsi_remove_device() are
     750                 :            :          * serialized. The second and later calls of scsi_remove_device() are
     751                 :            :          * ignored because the first call of that function changes the device
     752                 :            :          * state into SDEV_DEL.
     753                 :            :          */
     754                 :          0 :         device_remove_file(dev, attr);
     755                 :          0 :         scsi_remove_device(sdev);
     756         [ #  # ]:          0 :         if (kn)
     757                 :          0 :                 sysfs_unbreak_active_protection(kn);
     758                 :          0 :         scsi_device_put(sdev);
     759                 :          0 :         return count;
     760                 :            : };
     761                 :            : static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
     762                 :            : 
     763                 :            : static ssize_t
     764                 :          0 : store_state_field(struct device *dev, struct device_attribute *attr,
     765                 :            :                   const char *buf, size_t count)
     766                 :            : {
     767                 :            :         int i, ret;
     768                 :          0 :         struct scsi_device *sdev = to_scsi_device(dev);
     769                 :            :         enum scsi_device_state state = 0;
     770                 :            : 
     771         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
     772                 :          0 :                 const int len = strlen(sdev_states[i].name);
     773   [ #  #  #  # ]:          0 :                 if (strncmp(sdev_states[i].name, buf, len) == 0 &&
     774                 :          0 :                    buf[len] == '\n') {
     775                 :          0 :                         state = sdev_states[i].value;
     776                 :          0 :                         break;
     777                 :            :                 }
     778                 :            :         }
     779         [ #  # ]:          0 :         switch (state) {
     780                 :            :         case SDEV_RUNNING:
     781                 :            :         case SDEV_OFFLINE:
     782                 :            :                 break;
     783                 :            :         default:
     784                 :            :                 return -EINVAL;
     785                 :            :         }
     786                 :            : 
     787                 :          0 :         mutex_lock(&sdev->state_mutex);
     788                 :          0 :         ret = scsi_device_set_state(sdev, state);
     789                 :            :         /*
     790                 :            :          * If the device state changes to SDEV_RUNNING, we need to run
     791                 :            :          * the queue to avoid I/O hang.
     792                 :            :          */
     793         [ #  # ]:          0 :         if (ret == 0 && state == SDEV_RUNNING)
     794                 :          0 :                 blk_mq_run_hw_queues(sdev->request_queue, true);
     795                 :          0 :         mutex_unlock(&sdev->state_mutex);
     796                 :            : 
     797         [ #  # ]:          0 :         return ret == 0 ? count : -EINVAL;
     798                 :            : }
     799                 :            : 
     800                 :            : static ssize_t
     801                 :          0 : show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
     802                 :            : {
     803                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
     804                 :          0 :         const char *name = scsi_device_state_name(sdev->sdev_state);
     805                 :            : 
     806         [ #  # ]:          0 :         if (!name)
     807                 :            :                 return -EINVAL;
     808                 :            : 
     809                 :          0 :         return snprintf(buf, 20, "%s\n", name);
     810                 :            : }
     811                 :            : 
     812                 :            : static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
     813                 :            : 
     814                 :            : static ssize_t
     815                 :          0 : show_queue_type_field(struct device *dev, struct device_attribute *attr,
     816                 :            :                       char *buf)
     817                 :            : {
     818                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
     819                 :            :         const char *name = "none";
     820                 :            : 
     821         [ #  # ]:          0 :         if (sdev->simple_tags)
     822                 :            :                 name = "simple";
     823                 :            : 
     824                 :          0 :         return snprintf(buf, 20, "%s\n", name);
     825                 :            : }
     826                 :            : 
     827                 :            : static ssize_t
     828                 :          0 : store_queue_type_field(struct device *dev, struct device_attribute *attr,
     829                 :            :                        const char *buf, size_t count)
     830                 :            : {
     831                 :          0 :         struct scsi_device *sdev = to_scsi_device(dev);
     832                 :            : 
     833         [ #  # ]:          0 :         if (!sdev->tagged_supported)
     834                 :            :                 return -EINVAL;
     835                 :            :                 
     836                 :          0 :         sdev_printk(KERN_INFO, sdev,
     837                 :            :                     "ignoring write to deprecated queue_type attribute");
     838                 :          0 :         return count;
     839                 :            : }
     840                 :            : 
     841                 :            : static DEVICE_ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
     842                 :            :                    store_queue_type_field);
     843                 :            : 
     844                 :            : #define sdev_vpd_pg_attr(_page)                                         \
     845                 :            : static ssize_t                                                  \
     846                 :            : show_vpd_##_page(struct file *filp, struct kobject *kobj,       \
     847                 :            :                  struct bin_attribute *bin_attr,                        \
     848                 :            :                  char *buf, loff_t off, size_t count)                   \
     849                 :            : {                                                                       \
     850                 :            :         struct device *dev = container_of(kobj, struct device, kobj);   \
     851                 :            :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     852                 :            :         struct scsi_vpd *vpd_page;                                      \
     853                 :            :         int ret = -EINVAL;                                              \
     854                 :            :                                                                         \
     855                 :            :         rcu_read_lock();                                                \
     856                 :            :         vpd_page = rcu_dereference(sdev->vpd_##_page);                       \
     857                 :            :         if (vpd_page)                                                   \
     858                 :            :                 ret = memory_read_from_buffer(buf, count, &off,             \
     859                 :            :                                 vpd_page->data, vpd_page->len);           \
     860                 :            :         rcu_read_unlock();                                              \
     861                 :            :         return ret;                                                     \
     862                 :            : }                                                                       \
     863                 :            : static struct bin_attribute dev_attr_vpd_##_page = {            \
     864                 :            :         .attr = {.name = __stringify(vpd_##_page), .mode = S_IRUGO },   \
     865                 :            :         .size = 0,                                                      \
     866                 :            :         .read = show_vpd_##_page,                                       \
     867                 :            : };
     868                 :            : 
     869         [ #  # ]:          0 : sdev_vpd_pg_attr(pg83);
     870         [ #  # ]:          0 : sdev_vpd_pg_attr(pg80);
     871                 :            : 
     872                 :          0 : static ssize_t show_inquiry(struct file *filep, struct kobject *kobj,
     873                 :            :                             struct bin_attribute *bin_attr,
     874                 :            :                             char *buf, loff_t off, size_t count)
     875                 :            : {
     876                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
     877                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
     878                 :            : 
     879         [ #  # ]:          0 :         if (!sdev->inquiry)
     880                 :            :                 return -EINVAL;
     881                 :            : 
     882                 :          0 :         return memory_read_from_buffer(buf, count, &off, sdev->inquiry,
     883                 :          0 :                                        sdev->inquiry_len);
     884                 :            : }
     885                 :            : 
     886                 :            : static struct bin_attribute dev_attr_inquiry = {
     887                 :            :         .attr = {
     888                 :            :                 .name = "inquiry",
     889                 :            :                 .mode = S_IRUGO,
     890                 :            :         },
     891                 :            :         .size = 0,
     892                 :            :         .read = show_inquiry,
     893                 :            : };
     894                 :            : 
     895                 :            : static ssize_t
     896                 :          0 : show_iostat_counterbits(struct device *dev, struct device_attribute *attr,
     897                 :            :                         char *buf)
     898                 :            : {
     899                 :          0 :         return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
     900                 :            : }
     901                 :            : 
     902                 :            : static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
     903                 :            : 
     904                 :            : #define show_sdev_iostat(field)                                         \
     905                 :            : static ssize_t                                                          \
     906                 :            : show_iostat_##field(struct device *dev, struct device_attribute *attr,  \
     907                 :            :                     char *buf)                                          \
     908                 :            : {                                                                       \
     909                 :            :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     910                 :            :         unsigned long long count = atomic_read(&sdev->field);            \
     911                 :            :         return snprintf(buf, 20, "0x%llx\n", count);                  \
     912                 :            : }                                                                       \
     913                 :            : static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
     914                 :            : 
     915                 :          0 : show_sdev_iostat(iorequest_cnt);
     916                 :          0 : show_sdev_iostat(iodone_cnt);
     917                 :          0 : show_sdev_iostat(ioerr_cnt);
     918                 :            : 
     919                 :            : static ssize_t
     920                 :          0 : sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
     921                 :            : {
     922                 :            :         struct scsi_device *sdev;
     923                 :            :         sdev = to_scsi_device(dev);
     924                 :          0 :         return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
     925                 :            : }
     926                 :            : static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
     927                 :            : 
     928                 :            : #define DECLARE_EVT_SHOW(name, Cap_name)                                \
     929                 :            : static ssize_t                                                          \
     930                 :            : sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
     931                 :            :                      char *buf)                                         \
     932                 :            : {                                                                       \
     933                 :            :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     934                 :            :         int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
     935                 :            :         return snprintf(buf, 20, "%d\n", val);                                \
     936                 :            : }
     937                 :            : 
     938                 :            : #define DECLARE_EVT_STORE(name, Cap_name)                               \
     939                 :            : static ssize_t                                                          \
     940                 :            : sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
     941                 :            :                       const char *buf, size_t count)                    \
     942                 :            : {                                                                       \
     943                 :            :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     944                 :            :         int val = simple_strtoul(buf, NULL, 0);                         \
     945                 :            :         if (val == 0)                                                   \
     946                 :            :                 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events);      \
     947                 :            :         else if (val == 1)                                              \
     948                 :            :                 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);        \
     949                 :            :         else                                                            \
     950                 :            :                 return -EINVAL;                                         \
     951                 :            :         return count;                                                   \
     952                 :            : }
     953                 :            : 
     954                 :            : #define DECLARE_EVT(name, Cap_name)                                     \
     955                 :            :         DECLARE_EVT_SHOW(name, Cap_name)                                \
     956                 :            :         DECLARE_EVT_STORE(name, Cap_name)                               \
     957                 :            :         static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,   \
     958                 :            :                            sdev_store_evt_##name);
     959                 :            : #define REF_EVT(name) &dev_attr_evt_##name.attr
     960                 :            : 
     961   [ #  #  #  # ]:          0 : DECLARE_EVT(media_change, MEDIA_CHANGE)
     962   [ #  #  #  # ]:          0 : DECLARE_EVT(inquiry_change_reported, INQUIRY_CHANGE_REPORTED)
     963   [ #  #  #  # ]:          0 : DECLARE_EVT(capacity_change_reported, CAPACITY_CHANGE_REPORTED)
     964   [ #  #  #  # ]:          0 : DECLARE_EVT(soft_threshold_reached, SOFT_THRESHOLD_REACHED_REPORTED)
     965   [ #  #  #  # ]:          0 : DECLARE_EVT(mode_parameter_change_reported, MODE_PARAMETER_CHANGE_REPORTED)
     966   [ #  #  #  # ]:          0 : DECLARE_EVT(lun_change_reported, LUN_CHANGE_REPORTED)
     967                 :            : 
     968                 :            : static ssize_t
     969                 :          0 : sdev_store_queue_depth(struct device *dev, struct device_attribute *attr,
     970                 :            :                        const char *buf, size_t count)
     971                 :            : {
     972                 :            :         int depth, retval;
     973                 :          0 :         struct scsi_device *sdev = to_scsi_device(dev);
     974                 :          0 :         struct scsi_host_template *sht = sdev->host->hostt;
     975                 :            : 
     976         [ #  # ]:          0 :         if (!sht->change_queue_depth)
     977                 :            :                 return -EINVAL;
     978                 :            : 
     979                 :          0 :         depth = simple_strtoul(buf, NULL, 0);
     980                 :            : 
     981   [ #  #  #  # ]:          0 :         if (depth < 1 || depth > sdev->host->can_queue)
     982                 :            :                 return -EINVAL;
     983                 :            : 
     984                 :          0 :         retval = sht->change_queue_depth(sdev, depth);
     985         [ #  # ]:          0 :         if (retval < 0)
     986                 :            :                 return retval;
     987                 :            : 
     988                 :          0 :         sdev->max_queue_depth = sdev->queue_depth;
     989                 :            : 
     990                 :          0 :         return count;
     991                 :            : }
     992                 :          0 : sdev_show_function(queue_depth, "%d\n");
     993                 :            : 
     994                 :            : static DEVICE_ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
     995                 :            :                    sdev_store_queue_depth);
     996                 :            : 
     997                 :            : static ssize_t
     998                 :          0 : sdev_show_wwid(struct device *dev, struct device_attribute *attr,
     999                 :            :                     char *buf)
    1000                 :            : {
    1001                 :          0 :         struct scsi_device *sdev = to_scsi_device(dev);
    1002                 :            :         ssize_t count;
    1003                 :            : 
    1004                 :          0 :         count = scsi_vpd_lun_id(sdev, buf, PAGE_SIZE);
    1005         [ #  # ]:          0 :         if (count > 0) {
    1006                 :          0 :                 buf[count] = '\n';
    1007                 :          0 :                 count++;
    1008                 :            :         }
    1009                 :          0 :         return count;
    1010                 :            : }
    1011                 :            : static DEVICE_ATTR(wwid, S_IRUGO, sdev_show_wwid, NULL);
    1012                 :            : 
    1013                 :            : #define BLIST_FLAG_NAME(name)                                   \
    1014                 :            :         [const_ilog2((__force __u64)BLIST_##name)] = #name
    1015                 :            : static const char *const sdev_bflags_name[] = {
    1016                 :            : #include "scsi_devinfo_tbl.c"
    1017                 :            : };
    1018                 :            : #undef BLIST_FLAG_NAME
    1019                 :            : 
    1020                 :            : static ssize_t
    1021                 :          0 : sdev_show_blacklist(struct device *dev, struct device_attribute *attr,
    1022                 :            :                     char *buf)
    1023                 :            : {
    1024                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1025                 :            :         int i;
    1026                 :            :         ssize_t len = 0;
    1027                 :            : 
    1028         [ #  # ]:          0 :         for (i = 0; i < sizeof(sdev->sdev_bflags) * BITS_PER_BYTE; i++) {
    1029                 :            :                 const char *name = NULL;
    1030                 :            : 
    1031         [ #  # ]:          0 :                 if (!(sdev->sdev_bflags & (__force blist_flags_t)BIT(i)))
    1032                 :          0 :                         continue;
    1033   [ #  #  #  # ]:          0 :                 if (i < ARRAY_SIZE(sdev_bflags_name) && sdev_bflags_name[i])
    1034                 :            :                         name = sdev_bflags_name[i];
    1035                 :            : 
    1036         [ #  # ]:          0 :                 if (name)
    1037         [ #  # ]:          0 :                         len += snprintf(buf + len, PAGE_SIZE - len,
    1038                 :            :                                         "%s%s", len ? " " : "", name);
    1039                 :            :                 else
    1040         [ #  # ]:          0 :                         len += snprintf(buf + len, PAGE_SIZE - len,
    1041                 :            :                                         "%sINVALID_BIT(%d)", len ? " " : "", i);
    1042                 :            :         }
    1043         [ #  # ]:          0 :         if (len)
    1044                 :          0 :                 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
    1045                 :          0 :         return len;
    1046                 :            : }
    1047                 :            : static DEVICE_ATTR(blacklist, S_IRUGO, sdev_show_blacklist, NULL);
    1048                 :            : 
    1049                 :            : #ifdef CONFIG_SCSI_DH
    1050                 :            : static ssize_t
    1051                 :            : sdev_show_dh_state(struct device *dev, struct device_attribute *attr,
    1052                 :            :                    char *buf)
    1053                 :            : {
    1054                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1055                 :            : 
    1056                 :            :         if (!sdev->handler)
    1057                 :            :                 return snprintf(buf, 20, "detached\n");
    1058                 :            : 
    1059                 :            :         return snprintf(buf, 20, "%s\n", sdev->handler->name);
    1060                 :            : }
    1061                 :            : 
    1062                 :            : static ssize_t
    1063                 :            : sdev_store_dh_state(struct device *dev, struct device_attribute *attr,
    1064                 :            :                     const char *buf, size_t count)
    1065                 :            : {
    1066                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1067                 :            :         int err = -EINVAL;
    1068                 :            : 
    1069                 :            :         if (sdev->sdev_state == SDEV_CANCEL ||
    1070                 :            :             sdev->sdev_state == SDEV_DEL)
    1071                 :            :                 return -ENODEV;
    1072                 :            : 
    1073                 :            :         if (!sdev->handler) {
    1074                 :            :                 /*
    1075                 :            :                  * Attach to a device handler
    1076                 :            :                  */
    1077                 :            :                 err = scsi_dh_attach(sdev->request_queue, buf);
    1078                 :            :         } else if (!strncmp(buf, "activate", 8)) {
    1079                 :            :                 /*
    1080                 :            :                  * Activate a device handler
    1081                 :            :                  */
    1082                 :            :                 if (sdev->handler->activate)
    1083                 :            :                         err = sdev->handler->activate(sdev, NULL, NULL);
    1084                 :            :                 else
    1085                 :            :                         err = 0;
    1086                 :            :         } else if (!strncmp(buf, "detach", 6)) {
    1087                 :            :                 /*
    1088                 :            :                  * Detach from a device handler
    1089                 :            :                  */
    1090                 :            :                 sdev_printk(KERN_WARNING, sdev,
    1091                 :            :                             "can't detach handler %s.\n",
    1092                 :            :                             sdev->handler->name);
    1093                 :            :                 err = -EINVAL;
    1094                 :            :         }
    1095                 :            : 
    1096                 :            :         return err < 0 ? err : count;
    1097                 :            : }
    1098                 :            : 
    1099                 :            : static DEVICE_ATTR(dh_state, S_IRUGO | S_IWUSR, sdev_show_dh_state,
    1100                 :            :                    sdev_store_dh_state);
    1101                 :            : 
    1102                 :            : static ssize_t
    1103                 :            : sdev_show_access_state(struct device *dev,
    1104                 :            :                        struct device_attribute *attr,
    1105                 :            :                        char *buf)
    1106                 :            : {
    1107                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1108                 :            :         unsigned char access_state;
    1109                 :            :         const char *access_state_name;
    1110                 :            : 
    1111                 :            :         if (!sdev->handler)
    1112                 :            :                 return -EINVAL;
    1113                 :            : 
    1114                 :            :         access_state = (sdev->access_state & SCSI_ACCESS_STATE_MASK);
    1115                 :            :         access_state_name = scsi_access_state_name(access_state);
    1116                 :            : 
    1117                 :            :         return sprintf(buf, "%s\n",
    1118                 :            :                        access_state_name ? access_state_name : "unknown");
    1119                 :            : }
    1120                 :            : static DEVICE_ATTR(access_state, S_IRUGO, sdev_show_access_state, NULL);
    1121                 :            : 
    1122                 :            : static ssize_t
    1123                 :            : sdev_show_preferred_path(struct device *dev,
    1124                 :            :                          struct device_attribute *attr,
    1125                 :            :                          char *buf)
    1126                 :            : {
    1127                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1128                 :            : 
    1129                 :            :         if (!sdev->handler)
    1130                 :            :                 return -EINVAL;
    1131                 :            : 
    1132                 :            :         if (sdev->access_state & SCSI_ACCESS_STATE_PREFERRED)
    1133                 :            :                 return sprintf(buf, "1\n");
    1134                 :            :         else
    1135                 :            :                 return sprintf(buf, "0\n");
    1136                 :            : }
    1137                 :            : static DEVICE_ATTR(preferred_path, S_IRUGO, sdev_show_preferred_path, NULL);
    1138                 :            : #endif
    1139                 :            : 
    1140                 :            : static ssize_t
    1141                 :          0 : sdev_show_queue_ramp_up_period(struct device *dev,
    1142                 :            :                                struct device_attribute *attr,
    1143                 :            :                                char *buf)
    1144                 :            : {
    1145                 :            :         struct scsi_device *sdev;
    1146                 :            :         sdev = to_scsi_device(dev);
    1147                 :          0 :         return snprintf(buf, 20, "%u\n",
    1148                 :            :                         jiffies_to_msecs(sdev->queue_ramp_up_period));
    1149                 :            : }
    1150                 :            : 
    1151                 :            : static ssize_t
    1152                 :          0 : sdev_store_queue_ramp_up_period(struct device *dev,
    1153                 :            :                                 struct device_attribute *attr,
    1154                 :            :                                 const char *buf, size_t count)
    1155                 :            : {
    1156                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1157                 :            :         unsigned int period;
    1158                 :            : 
    1159         [ #  # ]:          0 :         if (kstrtouint(buf, 10, &period))
    1160                 :            :                 return -EINVAL;
    1161                 :            : 
    1162                 :          0 :         sdev->queue_ramp_up_period = msecs_to_jiffies(period);
    1163                 :          0 :         return count;
    1164                 :            : }
    1165                 :            : 
    1166                 :            : static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
    1167                 :            :                    sdev_show_queue_ramp_up_period,
    1168                 :            :                    sdev_store_queue_ramp_up_period);
    1169                 :            : 
    1170                 :          0 : static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj,
    1171                 :            :                                          struct attribute *attr, int i)
    1172                 :            : {
    1173                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
    1174                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1175                 :            : 
    1176                 :            : 
    1177   [ #  #  #  # ]:          0 :         if (attr == &dev_attr_queue_depth.attr &&
    1178                 :          0 :             !sdev->host->hostt->change_queue_depth)
    1179                 :            :                 return S_IRUGO;
    1180                 :            : 
    1181   [ #  #  #  # ]:          0 :         if (attr == &dev_attr_queue_ramp_up_period.attr &&
    1182                 :          0 :             !sdev->host->hostt->change_queue_depth)
    1183                 :            :                 return 0;
    1184                 :            : 
    1185                 :            : #ifdef CONFIG_SCSI_DH
    1186                 :            :         if (attr == &dev_attr_access_state.attr &&
    1187                 :            :             !sdev->handler)
    1188                 :            :                 return 0;
    1189                 :            :         if (attr == &dev_attr_preferred_path.attr &&
    1190                 :            :             !sdev->handler)
    1191                 :            :                 return 0;
    1192                 :            : #endif
    1193                 :          0 :         return attr->mode;
    1194                 :            : }
    1195                 :            : 
    1196                 :          0 : static umode_t scsi_sdev_bin_attr_is_visible(struct kobject *kobj,
    1197                 :            :                                              struct bin_attribute *attr, int i)
    1198                 :            : {
    1199                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
    1200                 :            :         struct scsi_device *sdev = to_scsi_device(dev);
    1201                 :            : 
    1202                 :            : 
    1203   [ #  #  #  # ]:          0 :         if (attr == &dev_attr_vpd_pg80 && !sdev->vpd_pg80)
    1204                 :            :                 return 0;
    1205                 :            : 
    1206   [ #  #  #  # ]:          0 :         if (attr == &dev_attr_vpd_pg83 && !sdev->vpd_pg83)
    1207                 :            :                 return 0;
    1208                 :            : 
    1209                 :          0 :         return S_IRUGO;
    1210                 :            : }
    1211                 :            : 
    1212                 :            : /* Default template for device attributes.  May NOT be modified */
    1213                 :            : static struct attribute *scsi_sdev_attrs[] = {
    1214                 :            :         &dev_attr_device_blocked.attr,
    1215                 :            :         &dev_attr_type.attr,
    1216                 :            :         &dev_attr_scsi_level.attr,
    1217                 :            :         &dev_attr_device_busy.attr,
    1218                 :            :         &dev_attr_vendor.attr,
    1219                 :            :         &dev_attr_model.attr,
    1220                 :            :         &dev_attr_rev.attr,
    1221                 :            :         &dev_attr_rescan.attr,
    1222                 :            :         &dev_attr_delete.attr,
    1223                 :            :         &dev_attr_state.attr,
    1224                 :            :         &dev_attr_timeout.attr,
    1225                 :            :         &dev_attr_eh_timeout.attr,
    1226                 :            :         &dev_attr_iocounterbits.attr,
    1227                 :            :         &dev_attr_iorequest_cnt.attr,
    1228                 :            :         &dev_attr_iodone_cnt.attr,
    1229                 :            :         &dev_attr_ioerr_cnt.attr,
    1230                 :            :         &dev_attr_modalias.attr,
    1231                 :            :         &dev_attr_queue_depth.attr,
    1232                 :            :         &dev_attr_queue_type.attr,
    1233                 :            :         &dev_attr_wwid.attr,
    1234                 :            :         &dev_attr_blacklist.attr,
    1235                 :            : #ifdef CONFIG_SCSI_DH
    1236                 :            :         &dev_attr_dh_state.attr,
    1237                 :            :         &dev_attr_access_state.attr,
    1238                 :            :         &dev_attr_preferred_path.attr,
    1239                 :            : #endif
    1240                 :            :         &dev_attr_queue_ramp_up_period.attr,
    1241                 :            :         REF_EVT(media_change),
    1242                 :            :         REF_EVT(inquiry_change_reported),
    1243                 :            :         REF_EVT(capacity_change_reported),
    1244                 :            :         REF_EVT(soft_threshold_reached),
    1245                 :            :         REF_EVT(mode_parameter_change_reported),
    1246                 :            :         REF_EVT(lun_change_reported),
    1247                 :            :         NULL
    1248                 :            : };
    1249                 :            : 
    1250                 :            : static struct bin_attribute *scsi_sdev_bin_attrs[] = {
    1251                 :            :         &dev_attr_vpd_pg83,
    1252                 :            :         &dev_attr_vpd_pg80,
    1253                 :            :         &dev_attr_inquiry,
    1254                 :            :         NULL
    1255                 :            : };
    1256                 :            : static struct attribute_group scsi_sdev_attr_group = {
    1257                 :            :         .attrs =        scsi_sdev_attrs,
    1258                 :            :         .bin_attrs =    scsi_sdev_bin_attrs,
    1259                 :            :         .is_visible =   scsi_sdev_attr_is_visible,
    1260                 :            :         .is_bin_visible = scsi_sdev_bin_attr_is_visible,
    1261                 :            : };
    1262                 :            : 
    1263                 :            : static const struct attribute_group *scsi_sdev_attr_groups[] = {
    1264                 :            :         &scsi_sdev_attr_group,
    1265                 :            :         NULL
    1266                 :            : };
    1267                 :            : 
    1268                 :          0 : static int scsi_target_add(struct scsi_target *starget)
    1269                 :            : {
    1270                 :            :         int error;
    1271                 :            : 
    1272         [ #  # ]:          0 :         if (starget->state != STARGET_CREATED)
    1273                 :            :                 return 0;
    1274                 :            : 
    1275                 :          0 :         error = device_add(&starget->dev);
    1276         [ #  # ]:          0 :         if (error) {
    1277                 :          0 :                 dev_err(&starget->dev, "target device_add failed, error %d\n", error);
    1278                 :          0 :                 return error;
    1279                 :            :         }
    1280                 :          0 :         transport_add_device(&starget->dev);
    1281                 :          0 :         starget->state = STARGET_RUNNING;
    1282                 :            : 
    1283                 :            :         pm_runtime_set_active(&starget->dev);
    1284                 :          0 :         pm_runtime_enable(&starget->dev);
    1285                 :            :         device_enable_async_suspend(&starget->dev);
    1286                 :            : 
    1287                 :            :         return 0;
    1288                 :            : }
    1289                 :            : 
    1290                 :            : /**
    1291                 :            :  * scsi_sysfs_add_sdev - add scsi device to sysfs
    1292                 :            :  * @sdev:       scsi_device to add
    1293                 :            :  *
    1294                 :            :  * Return value:
    1295                 :            :  *      0 on Success / non-zero on Failure
    1296                 :            :  **/
    1297                 :          0 : int scsi_sysfs_add_sdev(struct scsi_device *sdev)
    1298                 :            : {
    1299                 :            :         int error, i;
    1300                 :          0 :         struct request_queue *rq = sdev->request_queue;
    1301                 :          0 :         struct scsi_target *starget = sdev->sdev_target;
    1302                 :            : 
    1303                 :          0 :         error = scsi_target_add(starget);
    1304         [ #  # ]:          0 :         if (error)
    1305                 :            :                 return error;
    1306                 :            : 
    1307                 :          0 :         transport_configure_device(&starget->dev);
    1308                 :            : 
    1309                 :            :         device_enable_async_suspend(&sdev->sdev_gendev);
    1310                 :          0 :         scsi_autopm_get_target(starget);
    1311                 :          0 :         pm_runtime_set_active(&sdev->sdev_gendev);
    1312                 :          0 :         pm_runtime_forbid(&sdev->sdev_gendev);
    1313                 :          0 :         pm_runtime_enable(&sdev->sdev_gendev);
    1314                 :          0 :         scsi_autopm_put_target(starget);
    1315                 :            : 
    1316                 :          0 :         scsi_autopm_get_device(sdev);
    1317                 :            : 
    1318                 :            :         scsi_dh_add_device(sdev);
    1319                 :            : 
    1320                 :          0 :         error = device_add(&sdev->sdev_gendev);
    1321         [ #  # ]:          0 :         if (error) {
    1322                 :          0 :                 sdev_printk(KERN_INFO, sdev,
    1323                 :            :                                 "failed to add device: %d\n", error);
    1324                 :          0 :                 return error;
    1325                 :            :         }
    1326                 :            : 
    1327                 :            :         device_enable_async_suspend(&sdev->sdev_dev);
    1328                 :          0 :         error = device_add(&sdev->sdev_dev);
    1329         [ #  # ]:          0 :         if (error) {
    1330                 :          0 :                 sdev_printk(KERN_INFO, sdev,
    1331                 :            :                                 "failed to add class device: %d\n", error);
    1332                 :          0 :                 device_del(&sdev->sdev_gendev);
    1333                 :          0 :                 return error;
    1334                 :            :         }
    1335                 :          0 :         transport_add_device(&sdev->sdev_gendev);
    1336                 :          0 :         sdev->is_visible = 1;
    1337                 :            : 
    1338                 :          0 :         error = bsg_scsi_register_queue(rq, &sdev->sdev_gendev);
    1339         [ #  # ]:          0 :         if (error)
    1340                 :            :                 /* we're treating error on bsg register as non-fatal,
    1341                 :            :                  * so pretend nothing went wrong */
    1342                 :          0 :                 sdev_printk(KERN_INFO, sdev,
    1343                 :            :                             "Failed to register bsg queue, errno=%d\n", error);
    1344                 :            : 
    1345                 :            :         /* add additional host specific attributes */
    1346         [ #  # ]:          0 :         if (sdev->host->hostt->sdev_attrs) {
    1347         [ #  # ]:          0 :                 for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
    1348                 :          0 :                         error = device_create_file(&sdev->sdev_gendev,
    1349                 :            :                                         sdev->host->hostt->sdev_attrs[i]);
    1350         [ #  # ]:          0 :                         if (error)
    1351                 :          0 :                                 return error;
    1352                 :            :                 }
    1353                 :            :         }
    1354                 :            : 
    1355         [ #  # ]:          0 :         if (sdev->host->hostt->sdev_groups) {
    1356                 :          0 :                 error = sysfs_create_groups(&sdev->sdev_gendev.kobj,
    1357                 :            :                                 sdev->host->hostt->sdev_groups);
    1358         [ #  # ]:          0 :                 if (error)
    1359                 :            :                         return error;
    1360                 :            :         }
    1361                 :            : 
    1362                 :          0 :         scsi_autopm_put_device(sdev);
    1363                 :          0 :         return error;
    1364                 :            : }
    1365                 :            : 
    1366                 :          0 : void __scsi_remove_device(struct scsi_device *sdev)
    1367                 :            : {
    1368                 :          0 :         struct device *dev = &sdev->sdev_gendev;
    1369                 :            :         int res;
    1370                 :            : 
    1371                 :            :         /*
    1372                 :            :          * This cleanup path is not reentrant and while it is impossible
    1373                 :            :          * to get a new reference with scsi_device_get() someone can still
    1374                 :            :          * hold a previously acquired one.
    1375                 :            :          */
    1376         [ #  # ]:          0 :         if (sdev->sdev_state == SDEV_DEL)
    1377                 :            :                 return;
    1378                 :            : 
    1379         [ #  # ]:          0 :         if (sdev->is_visible) {
    1380                 :            :                 /*
    1381                 :            :                  * If scsi_internal_target_block() is running concurrently,
    1382                 :            :                  * wait until it has finished before changing the device state.
    1383                 :            :                  */
    1384                 :          0 :                 mutex_lock(&sdev->state_mutex);
    1385                 :            :                 /*
    1386                 :            :                  * If blocked, we go straight to DEL and restart the queue so
    1387                 :            :                  * any commands issued during driver shutdown (like sync
    1388                 :            :                  * cache) are errored immediately.
    1389                 :            :                  */
    1390                 :          0 :                 res = scsi_device_set_state(sdev, SDEV_CANCEL);
    1391         [ #  # ]:          0 :                 if (res != 0) {
    1392                 :          0 :                         res = scsi_device_set_state(sdev, SDEV_DEL);
    1393         [ #  # ]:          0 :                         if (res == 0)
    1394                 :          0 :                                 scsi_start_queue(sdev);
    1395                 :            :                 }
    1396                 :          0 :                 mutex_unlock(&sdev->state_mutex);
    1397                 :            : 
    1398         [ #  # ]:          0 :                 if (res != 0)
    1399                 :            :                         return;
    1400                 :            : 
    1401         [ #  # ]:          0 :                 if (sdev->host->hostt->sdev_groups)
    1402                 :          0 :                         sysfs_remove_groups(&sdev->sdev_gendev.kobj,
    1403                 :            :                                         sdev->host->hostt->sdev_groups);
    1404                 :            : 
    1405                 :          0 :                 bsg_unregister_queue(sdev->request_queue);
    1406                 :          0 :                 device_unregister(&sdev->sdev_dev);
    1407                 :          0 :                 transport_remove_device(dev);
    1408                 :          0 :                 device_del(dev);
    1409                 :            :         } else
    1410                 :          0 :                 put_device(&sdev->sdev_dev);
    1411                 :            : 
    1412                 :            :         /*
    1413                 :            :          * Stop accepting new requests and wait until all queuecommand() and
    1414                 :            :          * scsi_run_queue() invocations have finished before tearing down the
    1415                 :            :          * device.
    1416                 :            :          */
    1417                 :          0 :         mutex_lock(&sdev->state_mutex);
    1418                 :          0 :         scsi_device_set_state(sdev, SDEV_DEL);
    1419                 :          0 :         mutex_unlock(&sdev->state_mutex);
    1420                 :            : 
    1421                 :          0 :         blk_cleanup_queue(sdev->request_queue);
    1422                 :          0 :         cancel_work_sync(&sdev->requeue_work);
    1423                 :            : 
    1424         [ #  # ]:          0 :         if (sdev->host->hostt->slave_destroy)
    1425                 :          0 :                 sdev->host->hostt->slave_destroy(sdev);
    1426                 :          0 :         transport_destroy_device(dev);
    1427                 :            : 
    1428                 :            :         /*
    1429                 :            :          * Paired with the kref_get() in scsi_sysfs_initialize().  We have
    1430                 :            :          * remoed sysfs visibility from the device, so make the target
    1431                 :            :          * invisible if this was the last device underneath it.
    1432                 :            :          */
    1433                 :          0 :         scsi_target_reap(scsi_target(sdev));
    1434                 :            : 
    1435                 :          0 :         put_device(dev);
    1436                 :            : }
    1437                 :            : 
    1438                 :            : /**
    1439                 :            :  * scsi_remove_device - unregister a device from the scsi bus
    1440                 :            :  * @sdev:       scsi_device to unregister
    1441                 :            :  **/
    1442                 :          0 : void scsi_remove_device(struct scsi_device *sdev)
    1443                 :            : {
    1444                 :          0 :         struct Scsi_Host *shost = sdev->host;
    1445                 :            : 
    1446                 :          0 :         mutex_lock(&shost->scan_mutex);
    1447                 :          0 :         __scsi_remove_device(sdev);
    1448                 :          0 :         mutex_unlock(&shost->scan_mutex);
    1449                 :          0 : }
    1450                 :            : EXPORT_SYMBOL(scsi_remove_device);
    1451                 :            : 
    1452                 :          0 : static void __scsi_remove_target(struct scsi_target *starget)
    1453                 :            : {
    1454                 :          0 :         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
    1455                 :            :         unsigned long flags;
    1456                 :            :         struct scsi_device *sdev;
    1457                 :            : 
    1458                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    1459                 :            :  restart:
    1460         [ #  # ]:          0 :         list_for_each_entry(sdev, &shost->__devices, siblings) {
    1461                 :            :                 /*
    1462                 :            :                  * We cannot call scsi_device_get() here, as
    1463                 :            :                  * we might've been called from rmmod() causing
    1464                 :            :                  * scsi_device_get() to fail the module_is_live()
    1465                 :            :                  * check.
    1466                 :            :                  */
    1467   [ #  #  #  # ]:          0 :                 if (sdev->channel != starget->channel ||
    1468                 :          0 :                     sdev->id != starget->id)
    1469                 :          0 :                         continue;
    1470         [ #  # ]:          0 :                 if (sdev->sdev_state == SDEV_DEL ||
    1471         [ #  # ]:          0 :                     sdev->sdev_state == SDEV_CANCEL ||
    1472                 :          0 :                     !get_device(&sdev->sdev_gendev))
    1473                 :          0 :                         continue;
    1474                 :          0 :                 spin_unlock_irqrestore(shost->host_lock, flags);
    1475                 :          0 :                 scsi_remove_device(sdev);
    1476                 :          0 :                 put_device(&sdev->sdev_gendev);
    1477                 :          0 :                 spin_lock_irqsave(shost->host_lock, flags);
    1478                 :          0 :                 goto restart;
    1479                 :            :         }
    1480                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1481                 :          0 : }
    1482                 :            : 
    1483                 :            : /**
    1484                 :            :  * scsi_remove_target - try to remove a target and all its devices
    1485                 :            :  * @dev: generic starget or parent of generic stargets to be removed
    1486                 :            :  *
    1487                 :            :  * Note: This is slightly racy.  It is possible that if the user
    1488                 :            :  * requests the addition of another device then the target won't be
    1489                 :            :  * removed.
    1490                 :            :  */
    1491                 :          0 : void scsi_remove_target(struct device *dev)
    1492                 :            : {
    1493                 :          0 :         struct Scsi_Host *shost = dev_to_shost(dev->parent);
    1494                 :            :         struct scsi_target *starget;
    1495                 :            :         unsigned long flags;
    1496                 :            : 
    1497                 :            : restart:
    1498                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    1499         [ #  # ]:          0 :         list_for_each_entry(starget, &shost->__targets, siblings) {
    1500         [ #  # ]:          0 :                 if (starget->state == STARGET_DEL ||
    1501         [ #  # ]:          0 :                     starget->state == STARGET_REMOVE ||
    1502                 :            :                     starget->state == STARGET_CREATED_REMOVE)
    1503                 :          0 :                         continue;
    1504   [ #  #  #  # ]:          0 :                 if (starget->dev.parent == dev || &starget->dev == dev) {
    1505                 :            :                         kref_get(&starget->reap_ref);
    1506         [ #  # ]:          0 :                         if (starget->state == STARGET_CREATED)
    1507                 :          0 :                                 starget->state = STARGET_CREATED_REMOVE;
    1508                 :            :                         else
    1509                 :          0 :                                 starget->state = STARGET_REMOVE;
    1510                 :          0 :                         spin_unlock_irqrestore(shost->host_lock, flags);
    1511                 :          0 :                         __scsi_remove_target(starget);
    1512                 :          0 :                         scsi_target_reap(starget);
    1513                 :          0 :                         goto restart;
    1514                 :            :                 }
    1515                 :            :         }
    1516                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1517                 :          0 : }
    1518                 :            : EXPORT_SYMBOL(scsi_remove_target);
    1519                 :            : 
    1520                 :        207 : int scsi_register_driver(struct device_driver *drv)
    1521                 :            : {
    1522                 :        207 :         drv->bus = &scsi_bus_type;
    1523                 :            : 
    1524                 :        207 :         return driver_register(drv);
    1525                 :            : }
    1526                 :            : EXPORT_SYMBOL(scsi_register_driver);
    1527                 :            : 
    1528                 :          0 : int scsi_register_interface(struct class_interface *intf)
    1529                 :            : {
    1530                 :          0 :         intf->class = &sdev_class;
    1531                 :            : 
    1532                 :          0 :         return class_interface_register(intf);
    1533                 :            : }
    1534                 :            : EXPORT_SYMBOL(scsi_register_interface);
    1535                 :            : 
    1536                 :            : /**
    1537                 :            :  * scsi_sysfs_add_host - add scsi host to subsystem
    1538                 :            :  * @shost:     scsi host struct to add to subsystem
    1539                 :            :  **/
    1540                 :          0 : int scsi_sysfs_add_host(struct Scsi_Host *shost)
    1541                 :            : {
    1542                 :            :         int error, i;
    1543                 :            : 
    1544                 :            :         /* add host specific attributes */
    1545         [ #  # ]:          0 :         if (shost->hostt->shost_attrs) {
    1546         [ #  # ]:          0 :                 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
    1547                 :          0 :                         error = device_create_file(&shost->shost_dev,
    1548                 :            :                                         shost->hostt->shost_attrs[i]);
    1549         [ #  # ]:          0 :                         if (error)
    1550                 :          0 :                                 return error;
    1551                 :            :                 }
    1552                 :            :         }
    1553                 :            : 
    1554                 :          0 :         transport_register_device(&shost->shost_gendev);
    1555                 :          0 :         transport_configure_device(&shost->shost_gendev);
    1556                 :          0 :         return 0;
    1557                 :            : }
    1558                 :            : 
    1559                 :            : static struct device_type scsi_dev_type = {
    1560                 :            :         .name =         "scsi_device",
    1561                 :            :         .release =      scsi_device_dev_release,
    1562                 :            :         .groups =       scsi_sdev_attr_groups,
    1563                 :            : };
    1564                 :            : 
    1565                 :          0 : void scsi_sysfs_device_initialize(struct scsi_device *sdev)
    1566                 :            : {
    1567                 :            :         unsigned long flags;
    1568                 :          0 :         struct Scsi_Host *shost = sdev->host;
    1569                 :          0 :         struct scsi_target  *starget = sdev->sdev_target;
    1570                 :            : 
    1571                 :          0 :         device_initialize(&sdev->sdev_gendev);
    1572                 :          0 :         sdev->sdev_gendev.bus = &scsi_bus_type;
    1573                 :          0 :         sdev->sdev_gendev.type = &scsi_dev_type;
    1574                 :          0 :         dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%llu",
    1575                 :          0 :                      sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
    1576                 :            : 
    1577                 :          0 :         device_initialize(&sdev->sdev_dev);
    1578                 :          0 :         sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
    1579                 :          0 :         sdev->sdev_dev.class = &sdev_class;
    1580                 :          0 :         dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%llu",
    1581                 :          0 :                      sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
    1582                 :            :         /*
    1583                 :            :          * Get a default scsi_level from the target (derived from sibling
    1584                 :            :          * devices).  This is the best we can do for guessing how to set
    1585                 :            :          * sdev->lun_in_cdb for the initial INQUIRY command.  For LUN 0 the
    1586                 :            :          * setting doesn't matter, because all the bits are zero anyway.
    1587                 :            :          * But it does matter for higher LUNs.
    1588                 :            :          */
    1589                 :          0 :         sdev->scsi_level = starget->scsi_level;
    1590         [ #  # ]:          0 :         if (sdev->scsi_level <= SCSI_2 &&
    1591         [ #  # ]:          0 :                         sdev->scsi_level != SCSI_UNKNOWN &&
    1592                 :          0 :                         !shost->no_scsi2_lun_in_cdb)
    1593                 :          0 :                 sdev->lun_in_cdb = 1;
    1594                 :            : 
    1595                 :          0 :         transport_setup_device(&sdev->sdev_gendev);
    1596                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
    1597                 :          0 :         list_add_tail(&sdev->same_target_siblings, &starget->devices);
    1598                 :          0 :         list_add_tail(&sdev->siblings, &shost->__devices);
    1599                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1600                 :            :         /*
    1601                 :            :          * device can now only be removed via __scsi_remove_device() so hold
    1602                 :            :          * the target.  Target will be held in CREATED state until something
    1603                 :            :          * beneath it becomes visible (in which case it moves to RUNNING)
    1604                 :            :          */
    1605                 :            :         kref_get(&starget->reap_ref);
    1606                 :          0 : }
    1607                 :            : 
    1608                 :          0 : int scsi_is_sdev_device(const struct device *dev)
    1609                 :            : {
    1610                 :          0 :         return dev->type == &scsi_dev_type;
    1611                 :            : }
    1612                 :            : EXPORT_SYMBOL(scsi_is_sdev_device);
    1613                 :            : 
    1614                 :            : /* A blank transport template that is used in drivers that don't
    1615                 :            :  * yet implement Transport Attributes */
    1616                 :            : struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };

Generated by: LCOV version 1.14