LCOV - code coverage report
Current view: top level - lkbce/include/scsi - scsi_device.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 12 16 75.0 %
Date: 2017-01-25 Functions: 2 6 33.3 %

          Line data    Source code
       1             : #ifndef _SCSI_SCSI_DEVICE_H
       2             : #define _SCSI_SCSI_DEVICE_H
       3             : 
       4             : #include <linux/device.h>
       5             : #include <linux/list.h>
       6             : #include <linux/spinlock.h>
       7             : #include <linux/workqueue.h>
       8             : #include <linux/blkdev.h>
       9             : #include <scsi/scsi.h>
      10             : #include <asm/atomic.h>
      11             : 
      12             : struct request_queue;
      13             : struct scsi_cmnd;
      14             : struct scsi_lun;
      15             : struct scsi_sense_hdr;
      16             : 
      17             : struct scsi_mode_data {
      18             :         __u32   length;
      19             :         __u16   block_descriptor_length;
      20             :         __u8    medium_type;
      21             :         __u8    device_specific;
      22             :         __u8    header_length;
      23             :         __u8    longlba:1;
      24             : };
      25           1 : 
      26             : /*
      27             :  * sdev state: If you alter this, you also need to alter scsi_sysfs.c
      28             :  * (for the ascii descriptions) and the state model enforcer:
      29             :  * scsi_lib:scsi_device_set_state().
      30             :  */
      31             : enum scsi_device_state {
      32             :         SDEV_CREATED = 1,       /* device created but not added to sysfs
      33             :                                  * Only internal commands allowed (for inq) */
      34             :         SDEV_RUNNING,           /* device properly configured
      35             :                                  * All commands allowed */
      36           1 :         SDEV_CANCEL,            /* beginning to delete device
      37             :                                  * Only error handler commands allowed */
      38             :         SDEV_DEL,               /* device deleted 
      39             :                                  * no commands allowed */
      40             :         SDEV_QUIESCE,           /* Device quiescent.  No block commands
      41             :                                  * will be accepted, only specials (which
      42           1 :                                  * originate in the mid-layer) */
      43             :         SDEV_OFFLINE,           /* Device offlined (by error handling or
      44             :                                  * user request */
      45             :         SDEV_BLOCK,             /* Device blocked by scsi lld.  No
      46             :                                  * scsi commands from user or midlayer
      47             :                                  * should be issued to the scsi
      48             :                                  * lld. */
      49             :         SDEV_CREATED_BLOCK,     /* same as above but for created devices */
      50             : };
      51             : 
      52             : enum scsi_device_event {
      53             :         SDEV_EVT_MEDIA_CHANGE   = 1,    /* media has changed */
      54             : 
      55             :         SDEV_EVT_LAST           = SDEV_EVT_MEDIA_CHANGE,
      56             :         SDEV_EVT_MAXBITS        = SDEV_EVT_LAST + 1
      57             : };
      58             : 
      59             : struct scsi_event {
      60             :         enum scsi_device_event  evt_type;
      61             :         struct list_head        node;
      62             : 
      63           2 :         /* put union of data structures, for non-simple event types,
      64             :          * here
      65             :          */
      66             : };
      67             : 
      68             : struct scsi_device {
      69             :         struct Scsi_Host *host;
      70             :         struct request_queue *request_queue;
      71             : 
      72             :         /* the next two are protected by the host->host_lock */
      73             :         struct list_head    siblings;   /* list of all devices on this host */
      74             :         struct list_head    same_target_siblings; /* just the devices sharing same target id */
      75             : 
      76             :         /* this is now protected by the request_queue->queue_lock */
      77             :         unsigned int device_busy;       /* commands actually active on
      78             :                                          * low-level. protected by queue_lock. */
      79             :         spinlock_t list_lock;
      80             :         struct list_head cmd_list;      /* queue of in use SCSI Command structures */
      81             :         struct list_head starved_entry;
      82             :         struct scsi_cmnd *current_cmnd; /* currently active command */
      83             :         unsigned short queue_depth;     /* How deep of a queue we want */
      84             :         unsigned short max_queue_depth; /* max queue depth */
      85             :         unsigned short last_queue_full_depth; /* These two are used by */
      86             :         unsigned short last_queue_full_count; /* scsi_track_queue_full() */
      87             :         unsigned long last_queue_full_time;     /* last queue full time */
      88             :         unsigned long queue_ramp_up_period;     /* ramp up period in jiffies */
      89             : #define SCSI_DEFAULT_RAMP_UP_PERIOD     (120 * HZ)
      90             : 
      91             :         unsigned long last_queue_ramp_up;       /* last queue ramp up time */
      92             : 
      93             :         unsigned int id, lun, channel;
      94             : 
      95             :         unsigned int manufacturer;      /* Manufacturer of device, for using 
      96             :                                          * vendor-specific cmd's */
      97             :         unsigned sector_size;   /* size in bytes */
      98             : 
      99             :         void *hostdata;         /* available to low-level driver */
     100             :         char type;
     101             :         char scsi_level;
     102             :         char inq_periph_qual;   /* PQ from INQUIRY data */      
     103             :         unsigned char inquiry_len;      /* valid bytes in 'inquiry' */
     104             :         unsigned char * inquiry;        /* INQUIRY response data */
     105             :         const char * vendor;            /* [back_compat] point into 'inquiry' ... */
     106             :         const char * model;             /* ... after scan; point to static string */
     107             :         const char * rev;               /* ... "nullnullnullnull" before scan */
     108             :         unsigned char current_tag;      /* current tag */
     109             :         struct scsi_target      *sdev_target;   /* used only for single_lun */
     110             : 
     111             :         unsigned int    sdev_bflags; /* black/white flags as also found in
     112             :                                  * scsi_devinfo.[hc]. For now used only to
     113             :                                  * pass settings from slave_alloc to scsi
     114             :                                  * core. */
     115             :         unsigned writeable:1;
     116             :         unsigned removable:1;
     117             :         unsigned changed:1;     /* Data invalid due to media change */
     118             :         unsigned busy:1;        /* Used to prevent races */
     119             :         unsigned lockable:1;    /* Able to prevent media removal */
     120             :         unsigned locked:1;      /* Media removal disabled */
     121             :         unsigned borken:1;      /* Tell the Seagate driver to be 
     122             :                                  * painfully slow on this device */
     123             :         unsigned disconnect:1;  /* can disconnect */
     124             :         unsigned soft_reset:1;  /* Uses soft reset option */
     125             :         unsigned sdtr:1;        /* Device supports SDTR messages */
     126             :         unsigned wdtr:1;        /* Device supports WDTR messages */
     127             :         unsigned ppr:1;         /* Device supports PPR messages */
     128             :         unsigned tagged_supported:1;    /* Supports SCSI-II tagged queuing */
     129             :         unsigned simple_tags:1; /* simple queue tag messages are enabled */
     130             :         unsigned ordered_tags:1;/* ordered queue tag messages are enabled */
     131             :         unsigned was_reset:1;   /* There was a bus reset on the bus for 
     132             :                                  * this device */
     133             :         unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
     134             :                                      * because we did a bus reset. */
     135             :         unsigned use_10_for_rw:1; /* first try 10-byte read / write */
     136             :         unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
     137             :         unsigned skip_ms_page_8:1;      /* do not use MODE SENSE page 0x08 */
     138             :         unsigned skip_ms_page_3f:1;     /* do not use MODE SENSE page 0x3f */
     139             :         unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
     140             :         unsigned no_start_on_add:1;     /* do not issue start on add */
     141             :         unsigned allow_restart:1; /* issue START_UNIT in error handler */
     142             :         unsigned manage_start_stop:1;   /* Let HLD (sd) manage start/stop */
     143             :         unsigned start_stop_pwr_cond:1; /* Set power cond. in START_STOP_UNIT */
     144             :         unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
     145             :         unsigned select_no_atn:1;
     146             :         unsigned fix_capacity:1;        /* READ_CAPACITY is too high by 1 */
     147             :         unsigned guess_capacity:1;      /* READ_CAPACITY might be too high by 1 */
     148             :         unsigned retry_hwerror:1;       /* Retry HARDWARE_ERROR */
     149             :         unsigned last_sector_bug:1;     /* do not use multisector accesses on
     150             :                                            SD_LAST_BUGGY_SECTORS */
     151             :         unsigned is_visible:1;  /* is the device visible in sysfs */
     152             : 
     153             :         DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
     154             :         struct list_head event_list;    /* asserted events */
     155             :         struct work_struct event_work;
     156             : 
     157             :         unsigned int device_blocked;    /* Device returned QUEUE_FULL. */
     158             : 
     159             :         unsigned int max_device_blocked; /* what device_blocked counts down from  */
     160             : #define SCSI_DEFAULT_DEVICE_BLOCKED     3
     161             : 
     162             :         atomic_t iorequest_cnt;
     163             :         atomic_t iodone_cnt;
     164             :         atomic_t ioerr_cnt;
     165             : 
     166             :         struct device           sdev_gendev,
     167             :                                 sdev_dev;
     168             : 
     169             :         struct execute_work     ew; /* used to get process context on put */
     170             : 
     171             :         struct scsi_dh_data     *scsi_dh_data;
     172             :         enum scsi_device_state sdev_state;
     173             :         unsigned long           sdev_data[0];
     174             : } __attribute__((aligned(sizeof(unsigned long))));
     175           1 : 
     176             : struct scsi_dh_devlist {
     177             :         char *vendor;
     178             :         char *model;
     179             : };
     180             : 
     181             : typedef void (*activate_complete)(void *, int);
     182           1 : struct scsi_device_handler {
     183             :         /* Used by the infrastructure */
     184             :         struct list_head list; /* list of scsi_device_handlers */
     185             : 
     186             :         /* Filled by the hardware handler */
     187             :         struct module *module;
     188             :         const char *name;
     189             :         const struct scsi_dh_devlist *devlist;
     190             :         int (*check_sense)(struct scsi_device *, struct scsi_sense_hdr *);
     191             :         int (*attach)(struct scsi_device *);
     192             :         void (*detach)(struct scsi_device *);
     193             :         int (*activate)(struct scsi_device *, activate_complete, void *);
     194             :         int (*prep_fn)(struct scsi_device *, struct request *);
     195             :         int (*set_params)(struct scsi_device *, const char *);
     196             : };
     197           1 : 
     198             : struct scsi_dh_data {
     199             :         struct scsi_device_handler *scsi_dh;
     200             :         struct scsi_device *sdev;
     201             :         struct kref kref;
     202             :         char buf[0];
     203             : };
     204           1 : 
     205             : #define to_scsi_device(d)       \
     206             :         container_of(d, struct scsi_device, sdev_gendev)
     207             : #define class_to_sdev(d)        \
     208             :         container_of(d, struct scsi_device, sdev_dev)
     209             : #define transport_class_to_sdev(class_dev) \
     210           1 :         to_scsi_device(class_dev->parent)
     211             : 
     212             : #define sdev_printk(prefix, sdev, fmt, a...)    \
     213             :         dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
     214             : 
     215             : #define scmd_printk(prefix, scmd, fmt, a...)                            \
     216             :         (scmd)->request->rq_disk ?                                        \
     217             :         sdev_printk(prefix, (scmd)->device, "[%s] " fmt,           \
     218             :                     (scmd)->request->rq_disk->disk_name, ##a) :                \
     219             :         sdev_printk(prefix, (scmd)->device, fmt, ##a)
     220             : 
     221             : enum scsi_target_state {
     222             :         STARGET_CREATED = 1,
     223             :         STARGET_RUNNING,
     224             :         STARGET_DEL,
     225             : };
     226             : 
     227             : /*
     228             :  * scsi_target: representation of a scsi target, for now, this is only
     229             :  * used for single_lun devices. If no one has active IO to the target,
     230             :  * starget_sdev_user is NULL, else it points to the active sdev.
     231             :  */
     232             : struct scsi_target {
     233             :         struct scsi_device      *starget_sdev_user;
     234             :         struct list_head        siblings;
     235             :         struct list_head        devices;
     236             :         struct device           dev;
     237             :         unsigned int            reap_ref; /* protected by the host lock */
     238             :         unsigned int            channel;
     239             :         unsigned int            id; /* target id ... replace
     240             :                                      * scsi_device.id eventually */
     241             :         unsigned int            create:1; /* signal that it needs to be added */
     242             :         unsigned int            single_lun:1;   /* Indicates we should only
     243             :                                                  * allow I/O to one of the luns
     244             :                                                  * for the device at a time. */
     245             :         unsigned int            pdt_1f_for_no_lun;      /* PDT = 0x1f */
     246             :                                                 /* means no lun present */
     247             :         /* commands actually active on LLD. protected by host lock. */
     248             :         unsigned int            target_busy;
     249             :         /*
     250             :          * LLDs should set this in the slave_alloc host template callout.
     251             :          * If set to zero then there is not limit.
     252             :          */
     253             :         unsigned int            can_queue;
     254             :         unsigned int            target_blocked;
     255             :         unsigned int            max_target_blocked;
     256             : #define SCSI_DEFAULT_TARGET_BLOCKED     3
     257             : 
     258             :         char                    scsi_level;
     259             :         struct execute_work     ew;
     260             :         enum scsi_target_state  state;
     261             :         void                    *hostdata; /* available to low-level driver */
     262             :         unsigned long           starget_data[0]; /* for the transport */
     263             :         /* starget_data must be the last element!!!! */
     264             : } __attribute__((aligned(sizeof(unsigned long))));
     265             : 
     266             : #define to_scsi_target(d)       container_of(d, struct scsi_target, dev)
     267             : static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
     268             : {
     269         219 :         return to_scsi_target(sdev->sdev_gendev.parent);
     270             : }
     271             : #define transport_class_to_starget(class_dev) \
     272             :         to_scsi_target(class_dev->parent)
     273             : 
     274             : #define starget_printk(prefix, starget, fmt, a...)      \
     275             :         dev_printk(prefix, &(starget)->dev, fmt, ##a)
     276             : 
     277             : extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
     278             :                 uint, uint, uint, void *hostdata);
     279             : extern int scsi_add_device(struct Scsi_Host *host, uint channel,
     280             :                            uint target, uint lun);
     281             : extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh);
     282             : extern void scsi_remove_device(struct scsi_device *);
     283             : extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh);
     284             : 
     285             : extern int scsi_device_get(struct scsi_device *);
     286             : extern void scsi_device_put(struct scsi_device *);
     287             : extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
     288             :                                               uint, uint, uint);
     289             : extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
     290             :                                                 uint, uint, uint);
     291             : extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
     292             :                                                         uint);
     293             : extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
     294             :                                                           uint);
     295             : extern void starget_for_each_device(struct scsi_target *, void *,
     296             :                      void (*fn)(struct scsi_device *, void *));
     297             : extern void __starget_for_each_device(struct scsi_target *, void *,
     298             :                                       void (*fn)(struct scsi_device *,
     299             :                                                  void *));
     300             : 
     301             : /* only exposed to implement shost_for_each_device */
     302             : extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
     303             :                                                   struct scsi_device *);
     304             : 
     305             : /**
     306             :  * shost_for_each_device - iterate over all devices of a host
     307             :  * @sdev: the &struct scsi_device to use as a cursor
     308             :  * @shost: the &struct scsi_host to iterate over
     309             :  *
     310             :  * Iterator that returns each device attached to @shost.  This loop
     311             :  * takes a reference on each device and releases it at the end.  If
     312             :  * you break out of the loop, you must call scsi_device_put(sdev).
     313             :  */
     314             : #define shost_for_each_device(sdev, shost) \
     315             :         for ((sdev) = __scsi_iterate_devices((shost), NULL); \
     316             :              (sdev); \
     317             :              (sdev) = __scsi_iterate_devices((shost), (sdev)))
     318             : 
     319             : /**
     320             :  * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
     321             :  * @sdev: the &struct scsi_device to use as a cursor
     322             :  * @shost: the &struct scsi_host to iterate over
     323             :  *
     324             :  * Iterator that returns each device attached to @shost.  It does _not_
     325             :  * take a reference on the scsi_device, so the whole loop must be
     326             :  * protected by shost->host_lock.
     327             :  *
     328             :  * Note: The only reason to use this is because you need to access the
     329             :  * device list in interrupt context.  Otherwise you really want to use
     330             :  * shost_for_each_device instead.
     331             :  */
     332             : #define __shost_for_each_device(sdev, shost) \
     333             :         list_for_each_entry((sdev), &((shost)->__devices), siblings)
     334             : 
     335             : extern void scsi_adjust_queue_depth(struct scsi_device *, int, int);
     336             : extern int scsi_track_queue_full(struct scsi_device *, int);
     337             : 
     338             : extern int scsi_set_medium_removal(struct scsi_device *, char);
     339             : 
     340             : extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
     341             :                            unsigned char *buffer, int len, int timeout,
     342             :                            int retries, struct scsi_mode_data *data,
     343             :                            struct scsi_sense_hdr *);
     344             : extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
     345             :                             int modepage, unsigned char *buffer, int len,
     346             :                             int timeout, int retries,
     347             :                             struct scsi_mode_data *data,
     348             :                             struct scsi_sense_hdr *);
     349             : extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
     350             :                                 int retries, struct scsi_sense_hdr *sshdr);
     351             : extern unsigned char *scsi_get_vpd_page(struct scsi_device *, u8 page);
     352             : extern int scsi_device_set_state(struct scsi_device *sdev,
     353             :                                  enum scsi_device_state state);
     354             : extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
     355             :                                           gfp_t gfpflags);
     356             : extern void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt);
     357             : extern void sdev_evt_send_simple(struct scsi_device *sdev,
     358             :                           enum scsi_device_event evt_type, gfp_t gfpflags);
     359             : extern int scsi_device_quiesce(struct scsi_device *sdev);
     360             : extern void scsi_device_resume(struct scsi_device *sdev);
     361             : extern void scsi_target_quiesce(struct scsi_target *);
     362             : extern void scsi_target_resume(struct scsi_target *);
     363             : extern void scsi_scan_target(struct device *parent, unsigned int channel,
     364             :                              unsigned int id, unsigned int lun, int rescan);
     365             : extern void scsi_target_reap(struct scsi_target *);
     366             : extern void scsi_target_block(struct device *);
     367             : extern void scsi_target_unblock(struct device *);
     368             : extern void scsi_remove_target(struct device *);
     369             : extern void int_to_scsilun(unsigned int, struct scsi_lun *);
     370             : extern int scsilun_to_int(struct scsi_lun *);
     371             : extern const char *scsi_device_state_name(enum scsi_device_state);
     372             : extern int scsi_is_sdev_device(const struct device *);
     373             : extern int scsi_is_target_device(const struct device *);
     374             : extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
     375             :                         int data_direction, void *buffer, unsigned bufflen,
     376             :                         unsigned char *sense, int timeout, int retries,
     377             :                         int flag, int *resid);
     378             : extern int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
     379             :                             int data_direction, void *buffer, unsigned bufflen,
     380             :                             struct scsi_sense_hdr *, int timeout, int retries,
     381             :                             int *resid);
     382             : 
     383             : static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
     384             : {
     385             :         return device_reprobe(&sdev->sdev_gendev);
     386             : }
     387             : 
     388             : static inline unsigned int sdev_channel(struct scsi_device *sdev)
     389             : {
     390           0 :         return sdev->channel;
     391             : }
     392             : 
     393             : static inline unsigned int sdev_id(struct scsi_device *sdev)
     394             : {
     395           0 :         return sdev->id;
     396             : }
     397             : 
     398             : #define scmd_id(scmd) sdev_id((scmd)->device)
     399             : #define scmd_channel(scmd) sdev_channel((scmd)->device)
     400             : 
     401             : /*
     402             :  * checks for positions of the SCSI state machine
     403             :  */
     404             : static inline int scsi_device_online(struct scsi_device *sdev)
     405             : {
     406           0 :         return (sdev->sdev_state != SDEV_OFFLINE &&
     407             :                 sdev->sdev_state != SDEV_DEL);
     408             : }
     409             : static inline int scsi_device_blocked(struct scsi_device *sdev)
     410             : {
     411           0 :         return sdev->sdev_state == SDEV_BLOCK ||
     412             :                 sdev->sdev_state == SDEV_CREATED_BLOCK;
     413             : }
     414             : static inline int scsi_device_created(struct scsi_device *sdev)
     415             : {
     416         320 :         return sdev->sdev_state == SDEV_CREATED ||
     417             :                 sdev->sdev_state == SDEV_CREATED_BLOCK;
     418             : }
     419             : 
     420             : /* accessor functions for the SCSI parameters */
     421             : static inline int scsi_device_sync(struct scsi_device *sdev)
     422             : {
     423             :         return sdev->sdtr;
     424             : }
     425             : static inline int scsi_device_wide(struct scsi_device *sdev)
     426             : {
     427             :         return sdev->wdtr;
     428             : }
     429             : static inline int scsi_device_dt(struct scsi_device *sdev)
     430             : {
     431             :         return sdev->ppr;
     432             : }
     433             : static inline int scsi_device_dt_only(struct scsi_device *sdev)
     434             : {
     435             :         if (sdev->inquiry_len < 57)
     436             :                 return 0;
     437             :         return (sdev->inquiry[56] & 0x0c) == 0x04;
     438             : }
     439             : static inline int scsi_device_ius(struct scsi_device *sdev)
     440             : {
     441             :         if (sdev->inquiry_len < 57)
     442             :                 return 0;
     443             :         return sdev->inquiry[56] & 0x01;
     444             : }
     445             : static inline int scsi_device_qas(struct scsi_device *sdev)
     446             : {
     447             :         if (sdev->inquiry_len < 57)
     448             :                 return 0;
     449             :         return sdev->inquiry[56] & 0x02;
     450             : }
     451             : static inline int scsi_device_enclosure(struct scsi_device *sdev)
     452             : {
     453             :         return sdev->inquiry ? (sdev->inquiry[6] & (1<<6)) : 1;
     454             : }
     455             : 
     456             : static inline int scsi_device_protection(struct scsi_device *sdev)
     457             : {
     458             :         return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0);
     459             : }
     460           2 : 
     461             : #define MODULE_ALIAS_SCSI_DEVICE(type) \
     462             :         MODULE_ALIAS("scsi:t-" __stringify(type) "*")
     463             : #define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
     464             : 
     465             : #endif /* _SCSI_SCSI_DEVICE_H */

Generated by: LCOV version 1.10