include/hw/scsi/scsi.h

   1 #ifndef QEMU_HW_SCSI_H
   2 #define QEMU_HW_SCSI_H
   3
   4 #include "block/aio.h"
   5 #include "hw/block/block.h"
   6 #include "hw/qdev-core.h"
   7 #include "scsi/utils.h"
   8 #include "qemu/notify.h"
   9
  10 #define MAX_SCSI_DEVS   255
  11
  12 typedef struct SCSIBus SCSIBus;
  13 typedef struct SCSIBusInfo SCSIBusInfo;
  14 typedef struct SCSIDevice SCSIDevice;
  15 typedef struct SCSIRequest SCSIRequest;
  16 typedef struct SCSIReqOps SCSIReqOps;
  17
  18 #define SCSI_SENSE_BUF_SIZE_OLD 96
  19 #define SCSI_SENSE_BUF_SIZE 252
  20
  21 struct SCSIRequest {
  22     SCSIBus           *bus;
  23     SCSIDevice        *dev;
  24     const SCSIReqOps  *ops;
  25     uint32_t          refcount;
  26     uint32_t          tag;
  27     uint32_t          lun;
  28     uint32_t          status;
  29     void              *hba_private;
  30     size_t            resid;
  31     SCSICommand       cmd;
  32     NotifierList      cancel_notifiers;
  33
  34     /* Note:
  35      * - fields before sense are initialized by scsi_req_alloc;
  36      * - sense[] is uninitialized;
  37      * - fields after sense are memset to 0 by scsi_req_alloc.
  38      * */
  39
  40     uint8_t           sense[SCSI_SENSE_BUF_SIZE];
  41     uint32_t          sense_len;
  42     bool              enqueued;
  43     bool              io_canceled;
  44     bool              retry;
  45     bool              dma_started;
  46     BlockAIOCB        *aiocb;
  47     QEMUSGList        *sg;
  48     QTAILQ_ENTRY(SCSIRequest) next;
  49 };
  50
  51 #define TYPE_SCSI_DEVICE "scsi-device"
  52 #define SCSI_DEVICE(obj) \
  53      OBJECT_CHECK(SCSIDevice, (obj), TYPE_SCSI_DEVICE)
  54 #define SCSI_DEVICE_CLASS(klass) \
  55      OBJECT_CLASS_CHECK(SCSIDeviceClass, (klass), TYPE_SCSI_DEVICE)
  56 #define SCSI_DEVICE_GET_CLASS(obj) \
  57      OBJECT_GET_CLASS(SCSIDeviceClass, (obj), TYPE_SCSI_DEVICE)
  58
  59 typedef struct SCSIDeviceClass {
  60     DeviceClass parent_class;
  61     void (*realize)(SCSIDevice *dev, Error **errp);
  62     void (*unrealize)(SCSIDevice *dev);
  63     int (*parse_cdb)(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf,
  64                      void *hba_private);
  65     SCSIRequest *(*alloc_req)(SCSIDevice *s, uint32_t tag, uint32_t lun,
  66                               uint8_t *buf, void *hba_private);
  67     void (*unit_attention_reported)(SCSIDevice *s);
  68 } SCSIDeviceClass;
  69
  70 struct SCSIDevice
  71 {
  72     DeviceState qdev;
  73     VMChangeStateEntry *vmsentry;
  74     QEMUBH *bh;
  75     uint32_t id;
  76     BlockConf conf;
  77     SCSISense unit_attention;
  78     bool sense_is_ua;
  79     uint8_t sense[SCSI_SENSE_BUF_SIZE];
  80     uint32_t sense_len;
  81     QTAILQ_HEAD(, SCSIRequest) requests;
  82     uint32_t channel;
  83     uint32_t lun;
  84     int blocksize;
  85     int type;
  86     uint64_t max_lba;
  87     uint64_t wwn;
  88     uint64_t port_wwn;
  89     int scsi_version;
  90     int default_scsi_version;
  91     bool needs_vpd_bl_emulation;
  92     bool hba_supports_iothread;
  93 };
  94
  95 extern const VMStateDescription vmstate_scsi_device;
  96
  97 #define VMSTATE_SCSI_DEVICE(_field, _state) {                        \
  98     .name       = (stringify(_field)),                               \
  99     .size       = sizeof(SCSIDevice),                                \
 100     .vmsd       = &vmstate_scsi_device,                              \
 101     .flags      = VMS_STRUCT,                                        \
 102     .offset     = vmstate_offset_value(_state, _field, SCSIDevice),  \
 103 }
 104
 105 /* cdrom.c */
 106 int cdrom_read_toc(int nb_sectors, uint8_t *buf, int msf, int start_track);
 107 int cdrom_read_toc_raw(int nb_sectors, uint8_t *buf, int msf, int session_num);
 108
 109 /* scsi-bus.c */
 110 struct SCSIReqOps {
 111     size_t size;
 112     void (*free_req)(SCSIRequest *req);
 113     int32_t (*send_command)(SCSIRequest *req, uint8_t *buf);
 114     void (*read_data)(SCSIRequest *req);
 115     void (*write_data)(SCSIRequest *req);
 116     uint8_t *(*get_buf)(SCSIRequest *req);
 117
 118     void (*save_request)(QEMUFile *f, SCSIRequest *req);
 119     void (*load_request)(QEMUFile *f, SCSIRequest *req);
 120 };
 121
 122 struct SCSIBusInfo {
 123     int tcq;
 124     int max_channel, max_target, max_lun;
 125     int (*parse_cdb)(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf,
 126                      void *hba_private);
 127     void (*transfer_data)(SCSIRequest *req, uint32_t arg);
 128     void (*complete)(SCSIRequest *req, uint32_t arg, size_t resid);
 129     void (*cancel)(SCSIRequest *req);
 130     void (*change)(SCSIBus *bus, SCSIDevice *dev, SCSISense sense);
 131     QEMUSGList *(*get_sg_list)(SCSIRequest *req);
 132
 133     void (*save_request)(QEMUFile *f, SCSIRequest *req);
 134     void *(*load_request)(QEMUFile *f, SCSIRequest *req);
 135     void (*free_request)(SCSIBus *bus, void *priv);
 136 };
 137
 138 #define TYPE_SCSI_BUS "SCSI"
 139 #define SCSI_BUS(obj) OBJECT_CHECK(SCSIBus, (obj), TYPE_SCSI_BUS)
 140
 141 struct SCSIBus {
 142     BusState qbus;
 143     int busnr;
 144
 145     SCSISense unit_attention;
 146     const SCSIBusInfo *info;
 147 };
 148
 149 void scsi_bus_new(SCSIBus *bus, size_t bus_size, DeviceState *host,
 150                   const SCSIBusInfo *info, const char *bus_name);
 151
 152 static inline SCSIBus *scsi_bus_from_device(SCSIDevice *d)
 153 {
 154     return DO_UPCAST(SCSIBus, qbus, d->qdev.parent_bus);
 155 }
 156
 157 SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockBackend *blk,
 158                                       int unit, bool removable, int bootindex,
 159                                       bool share_rw,
 160                                       BlockdevOnError rerror,
 161                                       BlockdevOnError werror,
 162                                       const char *serial, Error **errp);
 163 void scsi_bus_legacy_handle_cmdline(SCSIBus *bus);
 164 void scsi_legacy_handle_cmdline(void);
 165
 166 SCSIRequest *scsi_req_alloc(const SCSIReqOps *reqops, SCSIDevice *d,
 167                             uint32_t tag, uint32_t lun, void *hba_private);
 168 SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun,
 169                           uint8_t *buf, void *hba_private);
 170 int32_t scsi_req_enqueue(SCSIRequest *req);
 171 SCSIRequest *scsi_req_ref(SCSIRequest *req);
 172 void scsi_req_unref(SCSIRequest *req);
 173
 174 int scsi_bus_parse_cdb(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf,
 175                        void *hba_private);
 176 int scsi_req_parse_cdb(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf);
 177 void scsi_req_build_sense(SCSIRequest *req, SCSISense sense);
 178 void scsi_req_print(SCSIRequest *req);
 179 void scsi_req_continue(SCSIRequest *req);
 180 void scsi_req_data(SCSIRequest *req, int len);
 181 void scsi_req_complete(SCSIRequest *req, int status);
 182 uint8_t *scsi_req_get_buf(SCSIRequest *req);
 183 int scsi_req_get_sense(SCSIRequest *req, uint8_t *buf, int len);
 184 void scsi_req_cancel_complete(SCSIRequest *req);
 185 void scsi_req_cancel(SCSIRequest *req);
 186 void scsi_req_cancel_async(SCSIRequest *req, Notifier *notifier);
 187 void scsi_req_retry(SCSIRequest *req);
 188 void scsi_device_purge_requests(SCSIDevice *sdev, SCSISense sense);
 189 void scsi_device_set_ua(SCSIDevice *sdev, SCSISense sense);
 190 void scsi_device_report_change(SCSIDevice *dev, SCSISense sense);
 191 void scsi_device_unit_attention_reported(SCSIDevice *dev);
 192 void scsi_generic_read_device_inquiry(SCSIDevice *dev);
 193 int scsi_device_get_sense(SCSIDevice *dev, uint8_t *buf, int len, bool fixed);
 194 int scsi_SG_IO_FROM_DEV(BlockBackend *blk, uint8_t *cmd, uint8_t cmd_size,
 195                         uint8_t *buf, uint8_t buf_size);
 196 SCSIDevice *scsi_device_find(SCSIBus *bus, int channel, int target, int lun);
 197
 198 /* scsi-generic.c. */
 199 extern const SCSIReqOps scsi_generic_req_ops;
 200
 201 #endif