LCOV - code coverage report
Current view: top level - lkbce/drivers/scsi - scsi_sysfs.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 383 494 77.5 %
Date: 2017-01-25 Functions: 55 66 83.3 %

          Line data    Source code
       1             : /*
       2             :  * scsi_sysfs.c
       3             :  *
       4             :  * SCSI sysfs interface routines.
       5             :  *
       6             :  * Created to pull SCSI mid layer sysfs routines into one file.
       7             :  */
       8             : 
       9             : #include <linux/module.h>
      10             : #include <linux/init.h>
      11             : #include <linux/blkdev.h>
      12             : #include <linux/device.h>
      13             : 
      14             : #include <scsi/scsi.h>
      15             : #include <scsi/scsi_device.h>
      16             : #include <scsi/scsi_host.h>
      17             : #include <scsi/scsi_tcq.h>
      18             : #include <scsi/scsi_transport.h>
      19             : #include <scsi/scsi_driver.h>
      20             : 
      21             : #include "scsi_priv.h"
      22             : #include "scsi_logging.h"
      23             : 
      24           1 : static struct device_type scsi_dev_type;
      25             : 
      26             : static const struct {
      27             :         enum scsi_device_state  value;
      28             :         char                    *name;
      29           2 : } sdev_states[] = {
      30             :         { SDEV_CREATED, "created" },
      31             :         { SDEV_RUNNING, "running" },
      32             :         { SDEV_CANCEL, "cancel" },
      33             :         { SDEV_DEL, "deleted" },
      34             :         { SDEV_QUIESCE, "quiesce" },
      35             :         { SDEV_OFFLINE, "offline" },
      36             :         { SDEV_BLOCK,   "blocked" },
      37             :         { SDEV_CREATED_BLOCK, "created-blocked" },
      38             : };
      39             : 
      40             : const char *scsi_device_state_name(enum scsi_device_state state)
      41             : {
      42          65 :         int i;
      43         130 :         char *name = NULL;
      44             : 
      45         325 :         for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
      46         260 :                 if (sdev_states[i].value == state) {
      47         130 :                         name = sdev_states[i].name;
      48          65 :                         break;
      49             :                 }
      50             :         }
      51         130 :         return name;
      52             : }
      53             : 
      54             : static const struct {
      55             :         enum scsi_host_state    value;
      56             :         char                    *name;
      57           2 : } shost_states[] = {
      58             :         { SHOST_CREATED, "created" },
      59             :         { SHOST_RUNNING, "running" },
      60             :         { SHOST_CANCEL, "cancel" },
      61             :         { SHOST_DEL, "deleted" },
      62             :         { SHOST_RECOVERY, "recovery" },
      63             :         { SHOST_CANCEL_RECOVERY, "cancel/recovery" },
      64             :         { SHOST_DEL_RECOVERY, "deleted/recovery", },
      65             : };
      66             : const char *scsi_host_state_name(enum scsi_host_state state)
      67             : {
      68           1 :         int i;
      69           2 :         char *name = NULL;
      70             : 
      71           5 :         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
      72           4 :                 if (shost_states[i].value == state) {
      73           2 :                         name = shost_states[i].name;
      74           1 :                         break;
      75             :                 }
      76             :         }
      77           2 :         return name;
      78             : }
      79             : 
      80             : static int check_set(unsigned int *val, char *src)
      81             : {
      82           3 :         char *last;
      83           3 : 
      84          12 :         if (strncmp(src, "-", 20) == 0) {
      85           3 :                 *val = SCAN_WILD_CARD;
      86             :         } else {
      87             :                 /*
      88             :                  * Doesn't check for int overflow
      89             :                  */
      90           6 :                 *val = simple_strtoul(src, &last, 0);
      91           6 :                 if (*last != '\0')
      92           3 :                         return 1;
      93             :         }
      94           3 :         return 0;
      95             : }
      96             : 
      97             : static int scsi_scan(struct Scsi_Host *shost, const char *str)
      98             : {
      99           1 :         char s1[15], s2[15], s3[15], junk;
     100           1 :         unsigned int channel, id, lun;
     101           1 :         int res;
     102           1 : 
     103           2 :         res = sscanf(str, "%10s %10s %10s %c", s1, s2, s3, &junk);
     104           3 :         if (res != 3)
     105           2 :                 return -EINVAL;
     106           5 :         if (check_set(&channel, s1))
     107           2 :                 return -EINVAL;
     108           5 :         if (check_set(&id, s2))
     109           2 :                 return -EINVAL;
     110           4 :         if (check_set(&lun, s3))
     111           1 :                 return -EINVAL;
     112           3 :         if (shost->transportt->user_scan)
     113           1 :                 res = shost->transportt->user_scan(shost, channel, id, lun);
     114             :         else
     115           5 :                 res = scsi_scan_host_selected(shost, channel, id, lun, 1);
     116           2 :         return res;
     117             : }
     118             : 
     119             : /*
     120             :  * shost_show_function: macro to create an attr function that can be used to
     121             :  * show a non-bit field.
     122             :  */
     123             : #define shost_show_function(name, field, format_string)                 \
     124             : static ssize_t                                                          \
     125             : show_##name (struct device *dev, struct device_attribute *attr,         \
     126             :              char *buf)                                                 \
     127             : {                                                                       \
     128             :         struct Scsi_Host *shost = class_to_shost(dev);                  \
     129             :         return snprintf (buf, 20, format_string, shost->field);              \
     130             : }
     131             : 
     132             : /*
     133             :  * shost_rd_attr: macro to create a function and attribute variable for a
     134             :  * read only field.
     135             :  */
     136             : #define shost_rd_attr2(name, field, format_string)                      \
     137             :         shost_show_function(name, field, format_string)                 \
     138             : static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
     139             : 
     140             : #define shost_rd_attr(field, format_string) \
     141             : shost_rd_attr2(field, field, format_string)
     142             : 
     143             : /*
     144             :  * Create the actual show/store functions and data structures.
     145             :  */
     146             : 
     147             : static ssize_t
     148             : store_scan(struct device *dev, struct device_attribute *attr,
     149             :            const char *buf, size_t count)
     150             : {
     151           3 :         struct Scsi_Host *shost = class_to_shost(dev);
     152           1 :         int res;
     153           1 : 
     154           6 :         res = scsi_scan(shost, buf);
     155           2 :         if (res == 0)
     156           1 :                 res = count;
     157           1 :         return res;
     158             : };
     159           1 : static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
     160             : 
     161             : static ssize_t
     162             : store_shost_state(struct device *dev, struct device_attribute *attr,
     163             :                   const char *buf, size_t count)
     164             : {
     165           1 :         int i;
     166           3 :         struct Scsi_Host *shost = class_to_shost(dev);
     167           2 :         enum scsi_host_state state = 0;
     168           1 : 
     169           6 :         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
     170           5 :                 const int len = strlen(shost_states[i].name);
     171           7 :                 if (strncmp(shost_states[i].name, buf, len) == 0 &&
     172           1 :                    buf[len] == '\n') {
     173           1 :                         state = shost_states[i].value;
     174           1 :                         break;
     175           1 :                 }
     176             :         }
     177           2 :         if (!state)
     178           1 :                 return -EINVAL;
     179             : 
     180           4 :         if (scsi_host_set_state(shost, state))
     181           1 :                 return -EINVAL;
     182           1 :         return count;
     183             : }
     184             : 
     185             : static ssize_t
     186             : show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
     187             : {
     188           2 :         struct Scsi_Host *shost = class_to_shost(dev);
     189           4 :         const char *name = scsi_host_state_name(shost->shost_state);
     190           1 : 
     191           3 :         if (!name)
     192           2 :                 return -EINVAL;
     193           1 : 
     194           2 :         return snprintf(buf, 20, "%s\n", name);
     195             : }
     196             : 
     197             : /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
     198           1 : struct device_attribute dev_attr_hstate =
     199             :         __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
     200             : 
     201             : static ssize_t
     202             : show_shost_mode(unsigned int mode, char *buf)
     203             : {
     204           4 :         ssize_t len = 0;
     205           2 : 
     206           6 :         if (mode & MODE_INITIATOR)
     207           6 :                 len = sprintf(buf, "%s", "Initiator");
     208             : 
     209           4 :         if (mode & MODE_TARGET)
     210          14 :                 len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
     211             : 
     212           4 :         len += sprintf(buf + len, "\n");
     213             : 
     214           2 :         return len;
     215             : }
     216             : 
     217             : static ssize_t
     218             : show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
     219             :                           char *buf)
     220             : {
     221           3 :         struct Scsi_Host *shost = class_to_shost(dev);
     222           2 :         unsigned int supported_mode = shost->hostt->supported_mode;
     223           1 : 
     224           3 :         if (supported_mode == MODE_UNKNOWN)
     225             :                 /* by default this should be initiator */
     226           1 :                 supported_mode = MODE_INITIATOR;
     227             : 
     228           3 :         return show_shost_mode(supported_mode, buf);
     229             : }
     230             : 
     231           1 : static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
     232             : 
     233             : static ssize_t
     234             : show_shost_active_mode(struct device *dev,
     235             :                        struct device_attribute *attr, char *buf)
     236             : {
     237           3 :         struct Scsi_Host *shost = class_to_shost(dev);
     238           1 : 
     239           3 :         if (shost->active_mode == MODE_UNKNOWN)
     240           3 :                 return snprintf(buf, 20, "unknown\n");
     241             :         else
     242           3 :                 return show_shost_mode(shost->active_mode, buf);
     243             : }
     244             : 
     245           1 : static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
     246             : 
     247           5 : shost_rd_attr(unique_id, "%u\n");
     248           5 : shost_rd_attr(host_busy, "%hu\n");
     249           6 : shost_rd_attr(cmd_per_lun, "%hd\n");
     250           6 : shost_rd_attr(can_queue, "%hd\n");
     251           8 : shost_rd_attr(sg_tablesize, "%hu\n");
     252           9 : shost_rd_attr(unchecked_isa_dma, "%d\n");
     253           8 : shost_rd_attr(prot_capabilities, "%u\n");
     254           9 : shost_rd_attr(prot_guard_type, "%hd\n");
     255           8 : shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
     256           3 : 
     257           4 : static struct attribute *scsi_sysfs_shost_attrs[] = {
     258           3 :         &dev_attr_unique_id.attr,
     259           2 :         &dev_attr_host_busy.attr,
     260           1 :         &dev_attr_cmd_per_lun.attr,
     261             :         &dev_attr_can_queue.attr,
     262             :         &dev_attr_sg_tablesize.attr,
     263             :         &dev_attr_unchecked_isa_dma.attr,
     264             :         &dev_attr_proc_name.attr,
     265             :         &dev_attr_scan.attr,
     266             :         &dev_attr_hstate.attr,
     267             :         &dev_attr_supported_mode.attr,
     268             :         &dev_attr_active_mode.attr,
     269             :         &dev_attr_prot_capabilities.attr,
     270             :         &dev_attr_prot_guard_type.attr,
     271             :         NULL
     272             : };
     273             : 
     274           1 : struct attribute_group scsi_shost_attr_group = {
     275             :         .attrs =        scsi_sysfs_shost_attrs,
     276             : };
     277             : 
     278           1 : const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
     279             :         &scsi_shost_attr_group,
     280             :         NULL
     281             : };
     282             : 
     283             : static void scsi_device_cls_release(struct device *class_dev)
     284             : {
     285           3 :         struct scsi_device *sdev;
     286           3 : 
     287           6 :         sdev = class_to_sdev(class_dev);
     288           3 :         put_device(&sdev->sdev_gendev);
     289           3 : }
     290             : 
     291             : static void scsi_device_dev_release_usercontext(struct work_struct *work)
     292             : {
     293           0 :         struct scsi_device *sdev;
     294           0 :         struct device *parent;
     295           0 :         struct scsi_target *starget;
     296           0 :         struct list_head *this, *tmp;
     297           0 :         unsigned long flags;
     298           0 : 
     299           0 :         sdev = container_of(work, struct scsi_device, ew.work);
     300           0 : 
     301           0 :         parent = sdev->sdev_gendev.parent;
     302           0 :         starget = to_scsi_target(parent);
     303           0 : 
     304           0 :         spin_lock_irqsave(sdev->host->host_lock, flags);
     305           0 :         starget->reap_ref++;
     306           0 :         list_del(&sdev->siblings);
     307           0 :         list_del(&sdev->same_target_siblings);
     308           0 :         list_del(&sdev->starved_entry);
     309           0 :         spin_unlock_irqrestore(sdev->host->host_lock, flags);
     310             : 
     311           0 :         cancel_work_sync(&sdev->event_work);
     312             : 
     313           0 :         list_for_each_safe(this, tmp, &sdev->event_list) {
     314           0 :                 struct scsi_event *evt;
     315           0 : 
     316           0 :                 evt = list_entry(this, struct scsi_event, node);
     317           0 :                 list_del(&evt->node);
     318           0 :                 kfree(evt);
     319             :         }
     320             : 
     321           0 :         blk_put_queue(sdev->request_queue);
     322             :         /* NULL queue means the device can't be used */
     323           0 :         sdev->request_queue = NULL;
     324             : 
     325           0 :         scsi_target_reap(scsi_target(sdev));
     326             : 
     327           0 :         kfree(sdev->inquiry);
     328           0 :         kfree(sdev);
     329             : 
     330           0 :         if (parent)
     331           0 :                 put_device(parent);
     332           0 : }
     333             : 
     334             : static void scsi_device_dev_release(struct device *dev)
     335             : {
     336           3 :         struct scsi_device *sdp = to_scsi_device(dev);
     337           2 :         execute_in_process_context(scsi_device_dev_release_usercontext,
     338             :                                    &sdp->ew);
     339           1 : }
     340             : 
     341           1 : static struct class sdev_class = {
     342             :         .name           = "scsi_device",
     343             :         .dev_release    = scsi_device_cls_release,
     344             : };
     345             : 
     346             : /* all probing is done in the individual ->probe routines */
     347             : static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
     348             : {
     349           0 :         struct scsi_device *sdp;
     350           0 : 
     351           0 :         if (dev->type != &scsi_dev_type)
     352           0 :                 return 0;
     353             : 
     354           0 :         sdp = to_scsi_device(dev);
     355           0 :         if (sdp->no_uld_attach)
     356           0 :                 return 0;
     357           0 :         return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
     358             : }
     359             : 
     360             : static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
     361             : {
     362           0 :         struct scsi_device *sdev;
     363           0 : 
     364           0 :         if (dev->type != &scsi_dev_type)
     365           0 :                 return 0;
     366             : 
     367           0 :         sdev = to_scsi_device(dev);
     368             : 
     369           0 :         add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
     370           0 :         return 0;
     371             : }
     372             : 
     373             : static int scsi_bus_suspend(struct device * dev, pm_message_t state)
     374             : {
     375           0 :         struct device_driver *drv;
     376           0 :         struct scsi_device *sdev;
     377           0 :         int err;
     378           0 : 
     379           0 :         if (dev->type != &scsi_dev_type)
     380           0 :                 return 0;
     381             : 
     382           0 :         drv = dev->driver;
     383           0 :         sdev = to_scsi_device(dev);
     384             : 
     385           0 :         err = scsi_device_quiesce(sdev);
     386           0 :         if (err)
     387           0 :                 return err;
     388             : 
     389           0 :         if (drv && drv->suspend) {
     390           0 :                 err = drv->suspend(dev, state);
     391           0 :                 if (err)
     392           0 :                         return err;
     393             :         }
     394             : 
     395           0 :         return 0;
     396             : }
     397             : 
     398             : static int scsi_bus_resume(struct device * dev)
     399             : {
     400           3 :         struct device_driver *drv;
     401           3 :         struct scsi_device *sdev;
     402           6 :         int err = 0;
     403           3 : 
     404           9 :         if (dev->type != &scsi_dev_type)
     405           3 :                 return 0;
     406             : 
     407           3 :         drv = dev->driver;
     408           6 :         sdev = to_scsi_device(dev);
     409             : 
     410          15 :         if (drv && drv->resume)
     411          12 :                 err = drv->resume(dev);
     412             : 
     413           9 :         scsi_device_resume(sdev);
     414             : 
     415           3 :         return err;
     416             : }
     417             : 
     418           1 : struct bus_type scsi_bus_type = {
     419             :         .name           = "scsi",
     420             :         .match          = scsi_bus_match,
     421             :         .uevent         = scsi_bus_uevent,
     422             :         .suspend        = scsi_bus_suspend,
     423             :         .resume         = scsi_bus_resume,
     424             : };
     425             : EXPORT_SYMBOL_GPL(scsi_bus_type);
     426             : 
     427             : int scsi_sysfs_register(void)
     428             : {
     429           1 :         int error;
     430           1 : 
     431           2 :         error = bus_register(&scsi_bus_type);
     432           2 :         if (!error) {
     433           2 :                 error = class_register(&sdev_class);
     434           2 :                 if (error)
     435           1 :                         bus_unregister(&scsi_bus_type);
     436             :         }
     437             : 
     438           1 :         return error;
     439             : }
     440             : 
     441             : void scsi_sysfs_unregister(void)
     442             : {
     443           2 :         class_unregister(&sdev_class);
     444           2 :         bus_unregister(&scsi_bus_type);
     445           2 : }
     446             : 
     447             : /*
     448             :  * sdev_show_function: macro to create an attr function that can be used to
     449             :  * show a non-bit field.
     450             :  */
     451             : #define sdev_show_function(field, format_string)                                \
     452             : static ssize_t                                                          \
     453             : sdev_show_##field (struct device *dev, struct device_attribute *attr,   \
     454             :                    char *buf)                                           \
     455             : {                                                                       \
     456             :         struct scsi_device *sdev;                                       \
     457             :         sdev = to_scsi_device(dev);                                     \
     458             :         return snprintf (buf, 20, format_string, sdev->field);               \
     459             : }                                                                       \
     460             : 
     461             : /*
     462             :  * sdev_rd_attr: macro to create a function and attribute variable for a
     463             :  * read only field.
     464             :  */
     465             : #define sdev_rd_attr(field, format_string)                              \
     466             :         sdev_show_function(field, format_string)                        \
     467             : static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
     468             : 
     469             : 
     470             : /*
     471             :  * sdev_rd_attr: create a function and attribute variable for a
     472             :  * read/write field.
     473             :  */
     474             : #define sdev_rw_attr(field, format_string)                              \
     475             :         sdev_show_function(field, format_string)                                \
     476             :                                                                         \
     477             : static ssize_t                                                          \
     478             : sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
     479             :                     const char *buf, size_t count)                      \
     480             : {                                                                       \
     481             :         struct scsi_device *sdev;                                       \
     482             :         sdev = to_scsi_device(dev);                                     \
     483             :         snscanf (buf, 20, format_string, &sdev->field);                  \
     484             :         return count;                                                   \
     485             : }                                                                       \
     486             : static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
     487             : 
     488             : /* Currently we don't export bit fields, but we might in future,
     489             :  * so leave this code in */
     490             : #if 0
     491             : /*
     492             :  * sdev_rd_attr: create a function and attribute variable for a
     493             :  * read/write bit field.
     494             :  */
     495             : #define sdev_rw_attr_bit(field)                                         \
     496             :         sdev_show_function(field, "%d\n")                                     \
     497             :                                                                         \
     498             : static ssize_t                                                          \
     499             : sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
     500             :                     const char *buf, size_t count)                      \
     501             : {                                                                       \
     502             :         int ret;                                                        \
     503             :         struct scsi_device *sdev;                                       \
     504             :         ret = scsi_sdev_check_buf_bit(buf);                             \
     505             :         if (ret >= 0)        {                                               \
     506             :                 sdev = to_scsi_device(dev);                             \
     507             :                 sdev->field = ret;                                   \
     508             :                 ret = count;                                            \
     509             :         }                                                               \
     510             :         return ret;                                                     \
     511             : }                                                                       \
     512             : static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
     513             : 
     514             : /*
     515             :  * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
     516             :  * else return -EINVAL.
     517             :  */
     518             : static int scsi_sdev_check_buf_bit(const char *buf)
     519             : {
     520             :         if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
     521             :                 if (buf[0] == '1')
     522             :                         return 1;
     523             :                 else if (buf[0] == '0')
     524             :                         return 0;
     525             :                 else 
     526             :                         return -EINVAL;
     527             :         } else
     528             :                 return -EINVAL;
     529             : }
     530             : #endif
     531             : /*
     532             :  * Create the actual show/store functions and data structures.
     533             :  */
     534           5 : sdev_rd_attr (device_blocked, "%d\n");
     535           6 : sdev_rd_attr (queue_depth, "%d\n");
     536           6 : sdev_rd_attr (type, "%d\n");
     537           7 : sdev_rd_attr (scsi_level, "%d\n");
     538           7 : sdev_rd_attr (vendor, "%.8s\n");
     539           8 : sdev_rd_attr (model, "%.16s\n");
     540           8 : sdev_rd_attr (rev, "%.4s\n");
     541           3 : 
     542           3 : /*
     543           3 :  * TODO: can we make these symlinks to the block layer ones?
     544           2 :  */
     545           1 : static ssize_t
     546             : sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
     547             : {
     548             :         struct scsi_device *sdev;
     549           3 :         sdev = to_scsi_device(dev);
     550           3 :         return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
     551           1 : }
     552             : 
     553             : static ssize_t
     554             : sdev_store_timeout (struct device *dev, struct device_attribute *attr,
     555             :                     const char *buf, size_t count)
     556             : {
     557           1 :         struct scsi_device *sdev;
     558           1 :         int timeout;
     559           3 :         sdev = to_scsi_device(dev);
     560           1 :         sscanf (buf, "%d\n", &timeout);
     561           1 :         blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
     562           1 :         return count;
     563             : }
     564           1 : static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
     565             : 
     566             : static ssize_t
     567             : store_rescan_field (struct device *dev, struct device_attribute *attr,
     568             :                     const char *buf, size_t count)
     569             : {
     570           4 :         scsi_rescan_device(dev);
     571           1 :         return count;
     572             : }
     573           1 : static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
     574             : 
     575             : static void sdev_store_delete_callback(struct device *dev)
     576             : {
     577          68 :         scsi_remove_device(to_scsi_device(dev));
     578             : }
     579          17 : 
     580             : static ssize_t
     581             : sdev_store_delete(struct device *dev, struct device_attribute *attr,
     582             :                   const char *buf, size_t count)
     583             : {
     584           1 :         int rc;
     585             : 
     586             :         /* An attribute cannot be unregistered by one of its own methods,
     587             :          * so we have to use this roundabout approach.
     588             :          */
     589           1 :         rc = device_schedule_callback(dev, sdev_store_delete_callback);
     590           2 :         if (rc)
     591           1 :                 count = rc;
     592           1 :         return count;
     593             : };
     594           1 : static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
     595             : 
     596             : static ssize_t
     597             : store_state_field(struct device *dev, struct device_attribute *attr,
     598             :                   const char *buf, size_t count)
     599             : {
     600           1 :         int i;
     601           3 :         struct scsi_device *sdev = to_scsi_device(dev);
     602           2 :         enum scsi_device_state state = 0;
     603           1 : 
     604           6 :         for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
     605           5 :                 const int len = strlen(sdev_states[i].name);
     606           7 :                 if (strncmp(sdev_states[i].name, buf, len) == 0 &&
     607           1 :                    buf[len] == '\n') {
     608           1 :                         state = sdev_states[i].value;
     609           1 :                         break;
     610           1 :                 }
     611             :         }
     612           2 :         if (!state)
     613           1 :                 return -EINVAL;
     614             : 
     615           4 :         if (scsi_device_set_state(sdev, state))
     616           1 :                 return -EINVAL;
     617           1 :         return count;
     618             : }
     619             : 
     620             : static ssize_t
     621             : show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
     622             : {
     623           2 :         struct scsi_device *sdev = to_scsi_device(dev);
     624           4 :         const char *name = scsi_device_state_name(sdev->sdev_state);
     625           1 : 
     626           3 :         if (!name)
     627           2 :                 return -EINVAL;
     628           1 : 
     629           2 :         return snprintf(buf, 20, "%s\n", name);
     630             : }
     631             : 
     632           1 : static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
     633             : 
     634             : static ssize_t
     635             : show_queue_type_field(struct device *dev, struct device_attribute *attr,
     636             :                       char *buf)
     637             : {
     638           3 :         struct scsi_device *sdev = to_scsi_device(dev);
     639           2 :         const char *name = "none";
     640           1 : 
     641           3 :         if (sdev->ordered_tags)
     642           1 :                 name = "ordered";
     643           2 :         else if (sdev->simple_tags)
     644           1 :                 name = "simple";
     645             : 
     646           2 :         return snprintf(buf, 20, "%s\n", name);
     647             : }
     648             : 
     649           1 : static DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL);
     650             : 
     651             : static ssize_t
     652             : show_iostat_counterbits(struct device *dev, struct device_attribute *attr,                              char *buf)
     653             : {
     654           2 :         return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
     655           1 : }
     656             : 
     657           1 : static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
     658             : 
     659             : #define show_sdev_iostat(field)                                         \
     660             : static ssize_t                                                          \
     661             : show_iostat_##field(struct device *dev, struct device_attribute *attr,  \
     662             :                     char *buf)                                          \
     663             : {                                                                       \
     664             :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     665             :         unsigned long long count = atomic_read(&sdev->field);            \
     666             :         return snprintf(buf, 20, "0x%llx\n", count);                  \
     667             : }                                                                       \
     668             : static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
     669             : 
     670           8 : show_sdev_iostat(iorequest_cnt);
     671           8 : show_sdev_iostat(iodone_cnt);
     672           8 : show_sdev_iostat(ioerr_cnt);
     673           1 : 
     674           2 : static ssize_t
     675           3 : sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
     676           3 : {
     677           3 :         struct scsi_device *sdev;
     678           5 :         sdev = to_scsi_device(dev);
     679           5 :         return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
     680           1 : }
     681           1 : static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
     682             : 
     683             : #define DECLARE_EVT_SHOW(name, Cap_name)                                \
     684             : static ssize_t                                                          \
     685             : sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
     686             :                      char *buf)                                         \
     687             : {                                                                       \
     688             :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     689             :         int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
     690             :         return snprintf(buf, 20, "%d\n", val);                                \
     691             : }
     692             : 
     693             : #define DECLARE_EVT_STORE(name, Cap_name)                               \
     694             : static ssize_t                                                          \
     695             : sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
     696             :                       const char *buf, size_t count)                    \
     697             : {                                                                       \
     698             :         struct scsi_device *sdev = to_scsi_device(dev);                 \
     699             :         int val = simple_strtoul(buf, NULL, 0);                         \
     700             :         if (val == 0)                                                   \
     701             :                 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events);      \
     702             :         else if (val == 1)                                              \
     703             :                 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);        \
     704             :         else                                                            \
     705             :                 return -EINVAL;                                         \
     706             :         return count;                                                   \
     707             : }
     708             : 
     709             : #define DECLARE_EVT(name, Cap_name)                                     \
     710             :         DECLARE_EVT_SHOW(name, Cap_name)                                \
     711             :         DECLARE_EVT_STORE(name, Cap_name)                               \
     712             :         static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,   \
     713             :                            sdev_store_evt_##name);
     714             : #define REF_EVT(name) &dev_attr_evt_##name.attr
     715             : 
     716          23 : DECLARE_EVT(media_change, MEDIA_CHANGE)
     717             : 
     718             : /* Default template for device attributes.  May NOT be modified */
     719           3 : static struct attribute *scsi_sdev_attrs[] = {
     720           2 :         &dev_attr_device_blocked.attr,
     721           2 :         &dev_attr_type.attr,
     722           2 :         &dev_attr_scsi_level.attr,
     723           1 :         &dev_attr_vendor.attr,
     724             :         &dev_attr_model.attr,
     725             :         &dev_attr_rev.attr,
     726             :         &dev_attr_rescan.attr,
     727             :         &dev_attr_delete.attr,
     728             :         &dev_attr_state.attr,
     729             :         &dev_attr_timeout.attr,
     730             :         &dev_attr_iocounterbits.attr,
     731             :         &dev_attr_iorequest_cnt.attr,
     732             :         &dev_attr_iodone_cnt.attr,
     733             :         &dev_attr_ioerr_cnt.attr,
     734             :         &dev_attr_modalias.attr,
     735             :         REF_EVT(media_change),
     736             :         NULL
     737             : };
     738             : 
     739           1 : static struct attribute_group scsi_sdev_attr_group = {
     740             :         .attrs =        scsi_sdev_attrs,
     741             : };
     742             : 
     743           1 : static const struct attribute_group *scsi_sdev_attr_groups[] = {
     744             :         &scsi_sdev_attr_group,
     745             :         NULL
     746             : };
     747             : 
     748             : static ssize_t
     749             : sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
     750             :                           const char *buf, size_t count)
     751             : {
     752           1 :         int depth, retval;
     753           3 :         struct scsi_device *sdev = to_scsi_device(dev);
     754           2 :         struct scsi_host_template *sht = sdev->host->hostt;
     755           1 : 
     756           4 :         if (!sht->change_queue_depth)
     757           2 :                 return -EINVAL;
     758             : 
     759           2 :         depth = simple_strtoul(buf, NULL, 0);
     760             : 
     761           2 :         if (depth < 1)
     762           1 :                 return -EINVAL;
     763             : 
     764           1 :         retval = sht->change_queue_depth(sdev, depth,
     765             :                                          SCSI_QDEPTH_DEFAULT);
     766           2 :         if (retval < 0)
     767           1 :                 return retval;
     768             : 
     769           1 :         sdev->max_queue_depth = sdev->queue_depth;
     770             : 
     771           1 :         return count;
     772             : }
     773             : 
     774           1 : static struct device_attribute sdev_attr_queue_depth_rw =
     775             :         __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
     776             :                sdev_store_queue_depth_rw);
     777             : 
     778             : static ssize_t
     779             : sdev_show_queue_ramp_up_period(struct device *dev,
     780             :                                struct device_attribute *attr,
     781             :                                char *buf)
     782           1 : {
     783           1 :         struct scsi_device *sdev;
     784           3 :         sdev = to_scsi_device(dev);
     785           4 :         return snprintf(buf, 20, "%u\n",
     786             :                         jiffies_to_msecs(sdev->queue_ramp_up_period));
     787             : }
     788             : 
     789             : static ssize_t
     790             : sdev_store_queue_ramp_up_period(struct device *dev,
     791             :                                 struct device_attribute *attr,
     792             :                                 const char *buf, size_t count)
     793           1 : {
     794           3 :         struct scsi_device *sdev = to_scsi_device(dev);
     795           1 :         unsigned long period;
     796           1 : 
     797           3 :         if (strict_strtoul(buf, 10, &period))
     798           1 :                 return -EINVAL;
     799             : 
     800           1 :         sdev->queue_ramp_up_period = msecs_to_jiffies(period);
     801           1 :         return period;
     802             : }
     803             : 
     804           1 : static struct device_attribute sdev_attr_queue_ramp_up_period =
     805             :         __ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
     806             :                sdev_show_queue_ramp_up_period,
     807             :                sdev_store_queue_ramp_up_period);
     808             : 
     809             : static ssize_t
     810             : sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
     811             :                          const char *buf, size_t count)
     812             : {
     813           3 :         struct scsi_device *sdev = to_scsi_device(dev);
     814           2 :         struct scsi_host_template *sht = sdev->host->hostt;
     815           2 :         int tag_type = 0, retval;
     816           4 :         int prev_tag_type = scsi_get_tag_type(sdev);
     817           1 : 
     818           6 :         if (!sdev->tagged_supported || !sht->change_queue_type)
     819           2 :                 return -EINVAL;
     820           1 : 
     821           4 :         if (strncmp(buf, "ordered", 7) == 0)
     822           2 :                 tag_type = MSG_ORDERED_TAG;
     823           3 :         else if (strncmp(buf, "simple", 6) == 0)
     824           1 :                 tag_type = MSG_SIMPLE_TAG;
     825           3 :         else if (strncmp(buf, "none", 4) != 0)
     826           1 :                 return -EINVAL;
     827             : 
     828           2 :         if (tag_type == prev_tag_type)
     829           1 :                 return count;
     830             : 
     831           1 :         retval = sht->change_queue_type(sdev, tag_type);
     832           2 :         if (retval < 0)
     833           1 :                 return retval;
     834             : 
     835           1 :         return count;
     836             : }
     837             : 
     838             : static int scsi_target_add(struct scsi_target *starget)
     839             : {
     840         128 :         int error;
     841         128 : 
     842         512 :         if (starget->state != STARGET_CREATED)
     843         128 :                 return 0;
     844             : 
     845         128 :         error = device_add(&starget->dev);
     846         256 :         if (error) {
     847         512 :                 dev_err(&starget->dev, "target device_add failed, error %d\n", error);
     848         128 :                 get_device(&starget->dev);
     849         512 :                 scsi_target_reap(starget);
     850         128 :                 put_device(&starget->dev);
     851         128 :                 return error;
     852             :         }
     853         128 :         transport_add_device(&starget->dev);
     854         128 :         starget->state = STARGET_RUNNING;
     855             : 
     856         128 :         return 0;
     857             : }
     858             : 
     859           1 : static struct device_attribute sdev_attr_queue_type_rw =
     860             :         __ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
     861             :                sdev_store_queue_type_rw);
     862             : 
     863             : /**
     864             :  * scsi_sysfs_add_sdev - add scsi device to sysfs
     865             :  * @sdev:       scsi_device to add
     866             :  *
     867             :  * Return value:
     868             :  *      0 on Success / non-zero on Failure
     869             :  **/
     870             : int scsi_sysfs_add_sdev(struct scsi_device *sdev)
     871             : {
     872         128 :         int error, i;
     873         256 :         struct request_queue *rq = sdev->request_queue;
     874         256 :         struct scsi_target *starget = sdev->sdev_target;
     875         128 : 
     876         384 :         error = scsi_device_set_state(sdev, SDEV_RUNNING);
     877         384 :         if (error)
     878         128 :                 return error;
     879             : 
     880         384 :         error = scsi_target_add(starget);
     881         256 :         if (error)
     882         128 :                 return error;
     883             : 
     884         128 :         transport_configure_device(&starget->dev);
     885         128 :         error = device_add(&sdev->sdev_gendev);
     886         256 :         if (error) {
     887         128 :                 printk(KERN_INFO "error 1\n");
     888         128 :                 return error;
     889             :         }
     890         128 :         error = device_add(&sdev->sdev_dev);
     891         256 :         if (error) {
     892         128 :                 printk(KERN_INFO "error 2\n");
     893         128 :                 device_del(&sdev->sdev_gendev);
     894         128 :                 return error;
     895             :         }
     896         128 :         transport_add_device(&sdev->sdev_gendev);
     897         128 :         sdev->is_visible = 1;
     898             : 
     899             :         /* create queue files, which may be writable, depending on the host */
     900         384 :         if (sdev->host->hostt->change_queue_depth) {
     901         128 :                 error = device_create_file(&sdev->sdev_gendev,
     902             :                                            &sdev_attr_queue_depth_rw);
     903         128 :                 error = device_create_file(&sdev->sdev_gendev,
     904             :                                            &sdev_attr_queue_ramp_up_period);
     905             :         }
     906             :         else
     907         128 :                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
     908         256 :         if (error)
     909         128 :                 return error;
     910             : 
     911         384 :         if (sdev->host->hostt->change_queue_type)
     912         128 :                 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
     913             :         else
     914         128 :                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
     915         256 :         if (error)
     916         128 :                 return error;
     917             : 
     918         128 :         error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
     919             : 
     920         256 :         if (error)
     921             :                 /* we're treating error on bsg register as non-fatal,
     922             :                  * so pretend nothing went wrong */
     923         512 :                 sdev_printk(KERN_INFO, sdev,
     924             :                             "Failed to register bsg queue, errno=%d\n", error);
     925             : 
     926             :         /* add additional host specific attributes */
     927         768 :         if (sdev->host->hostt->sdev_attrs) {
     928         896 :                 for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
     929         384 :                         error = device_create_file(&sdev->sdev_gendev,
     930         128 :                                         sdev->host->hostt->sdev_attrs[i]);
     931         256 :                         if (error)
     932         128 :                                 return error;
     933             :                 }
     934             :         }
     935             : 
     936         384 :         return error;
     937             : }
     938             : 
     939             : void __scsi_remove_device(struct scsi_device *sdev)
     940             : {
     941         452 :         struct device *dev = &sdev->sdev_gendev;
     942         226 : 
     943         452 :         if (sdev->is_visible) {
     944         904 :                 if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
     945         226 :                         return;
     946             : 
     947         226 :                 bsg_unregister_queue(sdev->request_queue);
     948         226 :                 device_unregister(&sdev->sdev_dev);
     949         226 :                 transport_remove_device(dev);
     950         226 :                 device_del(dev);
     951             :         } else
     952         226 :                 put_device(&sdev->sdev_dev);
     953         904 :         scsi_device_set_state(sdev, SDEV_DEL);
     954         678 :         if (sdev->host->hostt->slave_destroy)
     955         226 :                 sdev->host->hostt->slave_destroy(sdev);
     956         226 :         transport_destroy_device(dev);
     957             : 
     958             :         /* cause the request function to reject all I/O requests */
     959         226 :         sdev->request_queue->queuedata = NULL;
     960             : 
     961             :         /* Freeing the queue signals to block that we're done */
     962         452 :         scsi_free_queue(sdev->request_queue);
     963         226 :         put_device(dev);
     964         226 : }
     965             : 
     966             : /**
     967             :  * scsi_remove_device - unregister a device from the scsi bus
     968             :  * @sdev:       scsi_device to unregister
     969             :  **/
     970             : void scsi_remove_device(struct scsi_device *sdev)
     971             : {
     972          36 :         struct Scsi_Host *shost = sdev->host;
     973             : 
     974          18 :         mutex_lock(&shost->scan_mutex);
     975          54 :         __scsi_remove_device(sdev);
     976          18 :         mutex_unlock(&shost->scan_mutex);
     977          18 : }
     978             : EXPORT_SYMBOL(scsi_remove_device);
     979             : 
     980             : static void __scsi_remove_target(struct scsi_target *starget)
     981             : {
     982           0 :         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
     983           0 :         unsigned long flags;
     984           0 :         struct scsi_device *sdev;
     985           0 : 
     986           0 :         spin_lock_irqsave(shost->host_lock, flags);
     987           0 :         starget->reap_ref++;
     988           0 :  restart:
     989           0 :         list_for_each_entry(sdev, &shost->__devices, siblings) {
     990           0 :                 if (sdev->channel != starget->channel ||
     991           0 :                     sdev->id != starget->id ||
     992             :                     scsi_device_get(sdev))
     993           0 :                         continue;
     994           0 :                 spin_unlock_irqrestore(shost->host_lock, flags);
     995           0 :                 scsi_remove_device(sdev);
     996           0 :                 scsi_device_put(sdev);
     997           0 :                 spin_lock_irqsave(shost->host_lock, flags);
     998           0 :                 goto restart;
     999           0 :         }
    1000           0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1001           0 :         scsi_target_reap(starget);
    1002           0 : }
    1003             : 
    1004             : static int __remove_child (struct device * dev, void * data)
    1005             : {
    1006           0 :         if (scsi_is_target_device(dev))
    1007           0 :                 __scsi_remove_target(to_scsi_target(dev));
    1008           0 :         return 0;
    1009             : }
    1010             : 
    1011             : /**
    1012             :  * scsi_remove_target - try to remove a target and all its devices
    1013             :  * @dev: generic starget or parent of generic stargets to be removed
    1014             :  *
    1015             :  * Note: This is slightly racy.  It is possible that if the user
    1016             :  * requests the addition of another device then the target won't be
    1017             :  * removed.
    1018             :  */
    1019             : void scsi_remove_target(struct device *dev)
    1020             : {
    1021           0 :         struct device *rdev;
    1022           0 : 
    1023           0 :         if (scsi_is_target_device(dev)) {
    1024           0 :                 __scsi_remove_target(to_scsi_target(dev));
    1025           0 :                 return;
    1026             :         }
    1027             : 
    1028           0 :         rdev = get_device(dev);
    1029           0 :         device_for_each_child(dev, NULL, __remove_child);
    1030           0 :         put_device(rdev);
    1031           0 : }
    1032             : EXPORT_SYMBOL(scsi_remove_target);
    1033             : 
    1034             : int scsi_register_driver(struct device_driver *drv)
    1035             : {
    1036           0 :         drv->bus = &scsi_bus_type;
    1037             : 
    1038           0 :         return driver_register(drv);
    1039             : }
    1040             : EXPORT_SYMBOL(scsi_register_driver);
    1041             : 
    1042             : int scsi_register_interface(struct class_interface *intf)
    1043             : {
    1044           0 :         intf->class = &sdev_class;
    1045             : 
    1046           0 :         return class_interface_register(intf);
    1047             : }
    1048             : EXPORT_SYMBOL(scsi_register_interface);
    1049             : 
    1050             : /**
    1051             :  * scsi_sysfs_add_host - add scsi host to subsystem
    1052             :  * @shost:     scsi host struct to add to subsystem
    1053             :  **/
    1054             : int scsi_sysfs_add_host(struct Scsi_Host *shost)
    1055             : {
    1056           0 :         int error, i;
    1057           0 : 
    1058             :         /* add host specific attributes */
    1059           0 :         if (shost->hostt->shost_attrs) {
    1060           0 :                 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
    1061           0 :                         error = device_create_file(&shost->shost_dev,
    1062           0 :                                         shost->hostt->shost_attrs[i]);
    1063           0 :                         if (error)
    1064           0 :                                 return error;
    1065             :                 }
    1066             :         }
    1067             : 
    1068           0 :         transport_register_device(&shost->shost_gendev);
    1069           0 :         transport_configure_device(&shost->shost_gendev);
    1070           0 :         return 0;
    1071             : }
    1072             : 
    1073           1 : static struct device_type scsi_dev_type = {
    1074             :         .name =         "scsi_device",
    1075             :         .release =      scsi_device_dev_release,
    1076             :         .groups =       scsi_sdev_attr_groups,
    1077             : };
    1078             : 
    1079             : void scsi_sysfs_device_initialize(struct scsi_device *sdev)
    1080             : {
    1081          40 :         unsigned long flags;
    1082          80 :         struct Scsi_Host *shost = sdev->host;
    1083          80 :         struct scsi_target  *starget = sdev->sdev_target;
    1084          40 : 
    1085          40 :         device_initialize(&sdev->sdev_gendev);
    1086          40 :         sdev->sdev_gendev.bus = &scsi_bus_type;
    1087          40 :         sdev->sdev_gendev.type = &scsi_dev_type;
    1088          40 :         dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%d",
    1089             :                      sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
    1090             : 
    1091          40 :         device_initialize(&sdev->sdev_dev);
    1092          40 :         sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
    1093          40 :         sdev->sdev_dev.class = &sdev_class;
    1094          40 :         dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%d",
    1095             :                      sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
    1096          40 :         sdev->scsi_level = starget->scsi_level;
    1097          40 :         transport_setup_device(&sdev->sdev_gendev);
    1098         120 :         spin_lock_irqsave(shost->host_lock, flags);
    1099          80 :         list_add_tail(&sdev->same_target_siblings, &starget->devices);
    1100          80 :         list_add_tail(&sdev->siblings, &shost->__devices);
    1101          80 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1102          40 : }
    1103             : 
    1104             : int scsi_is_sdev_device(const struct device *dev)
    1105             : {
    1106           0 :         return dev->type == &scsi_dev_type;
    1107             : }
    1108             : EXPORT_SYMBOL(scsi_is_sdev_device);
    1109             : 
    1110             : /* A blank transport template that is used in drivers that don't
    1111             :  * yet implement Transport Attributes */
    1112           1 : struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };

Generated by: LCOV version 1.10