| 1 | /* |
| 2 | * vhost-user-scsi sample application |
| 3 | * |
| 4 | * Copyright (c) 2016 Nutanix Inc. All rights reserved. |
| 5 | * |
| 6 | * Author: |
| 7 | * Felipe Franciosi <felipe@nutanix.com> |
| 8 | * |
| 9 | * This work is licensed under the terms of the GNU GPL, version 2 only. |
| 10 | * See the COPYING file in the top-level directory. |
| 11 | */ |
| 12 | |
| 13 | #include "qemu/osdep.h" |
| 14 | #include <iscsi/iscsi.h> |
| 15 | #define inline __attribute__((gnu_inline)) /* required for libiscsi v1.9.0 */ |
| 16 | #include <iscsi/scsi-lowlevel.h> |
| 17 | #undef inline |
| 18 | #include "libvhost-user-glib.h" |
| 19 | #include "standard-headers/linux/virtio_scsi.h" |
| 20 | |
| 21 | |
| 22 | #define VUS_ISCSI_INITIATOR "iqn.2016-11.com.nutanix:vhost-user-scsi" |
| 23 | |
| 24 | enum { |
| 25 | VHOST_USER_SCSI_MAX_QUEUES = 8, |
| 26 | }; |
| 27 | |
| 28 | typedef struct VusIscsiLun { |
| 29 | struct iscsi_context *iscsi_ctx; |
| 30 | int iscsi_lun; |
| 31 | } VusIscsiLun; |
| 32 | |
| 33 | typedef struct VusDev { |
| 34 | VugDev parent; |
| 35 | |
| 36 | VusIscsiLun lun; |
| 37 | GMainLoop *loop; |
| 38 | } VusDev; |
| 39 | |
| 40 | /** libiscsi integration **/ |
| 41 | |
| 42 | typedef struct virtio_scsi_cmd_req VirtIOSCSICmdReq; |
| 43 | typedef struct virtio_scsi_cmd_resp VirtIOSCSICmdResp; |
| 44 | |
| 45 | static int vus_iscsi_add_lun(VusIscsiLun *lun, char *iscsi_uri) |
| 46 | { |
| 47 | struct iscsi_url *iscsi_url; |
| 48 | struct iscsi_context *iscsi_ctx; |
| 49 | int ret = 0; |
| 50 | |
| 51 | assert(lun); |
| 52 | assert(iscsi_uri); |
| 53 | assert(!lun->iscsi_ctx); |
| 54 | |
| 55 | iscsi_ctx = iscsi_create_context(VUS_ISCSI_INITIATOR); |
| 56 | if (!iscsi_ctx) { |
| 57 | g_warning("Unable to create iSCSI context"); |
| 58 | return -1; |
| 59 | } |
| 60 | |
| 61 | iscsi_url = iscsi_parse_full_url(iscsi_ctx, iscsi_uri); |
| 62 | if (!iscsi_url) { |
| 63 | g_warning("Unable to parse iSCSI URL: %s", iscsi_get_error(iscsi_ctx)); |
| 64 | goto fail; |
| 65 | } |
| 66 | |
| 67 | iscsi_set_session_type(iscsi_ctx, ISCSI_SESSION_NORMAL); |
| 68 | iscsi_set_header_digest(iscsi_ctx, ISCSI_HEADER_DIGEST_NONE_CRC32C); |
| 69 | if (iscsi_full_connect_sync(iscsi_ctx, iscsi_url->portal, iscsi_url->lun)) { |
| 70 | g_warning("Unable to login to iSCSI portal: %s", |
| 71 | iscsi_get_error(iscsi_ctx)); |
| 72 | goto fail; |
| 73 | } |
| 74 | |
| 75 | lun->iscsi_ctx = iscsi_ctx; |
| 76 | lun->iscsi_lun = iscsi_url->lun; |
| 77 | |
| 78 | g_debug("Context %p created for lun 0: %s", iscsi_ctx, iscsi_uri); |
| 79 | |
| 80 | out: |
| 81 | if (iscsi_url) { |
| 82 | iscsi_destroy_url(iscsi_url); |
| 83 | } |
| 84 | return ret; |
| 85 | |
| 86 | fail: |
| 87 | (void)iscsi_destroy_context(iscsi_ctx); |
| 88 | ret = -1; |
| 89 | goto out; |
| 90 | } |
| 91 | |
| 92 | static struct scsi_task *scsi_task_new(int cdb_len, uint8_t *cdb, int dir, |
| 93 | int xfer_len) |
| 94 | { |
| 95 | struct scsi_task *task; |
| 96 | |
| 97 | assert(cdb_len > 0); |
| 98 | assert(cdb); |
| 99 | |
| 100 | task = g_new0(struct scsi_task, 1); |
| 101 | memcpy(task->cdb, cdb, cdb_len); |
| 102 | task->cdb_size = cdb_len; |
| 103 | task->xfer_dir = dir; |
| 104 | task->expxferlen = xfer_len; |
| 105 | |
| 106 | return task; |
| 107 | } |
| 108 | |
| 109 | static int get_cdb_len(uint8_t *cdb) |
| 110 | { |
| 111 | assert(cdb); |
| 112 | |
| 113 | switch (cdb[0] >> 5) { |
| 114 | case 0: return 6; |
| 115 | case 1: /* fall through */ |
| 116 | case 2: return 10; |
| 117 | case 4: return 16; |
| 118 | case 5: return 12; |
| 119 | } |
| 120 | g_warning("Unable to determine cdb len (0x%02hhX)", (uint8_t)(cdb[0] >> 5)); |
| 121 | return -1; |
| 122 | } |
| 123 | |
| 124 | static int handle_cmd_sync(struct iscsi_context *ctx, |
| 125 | VirtIOSCSICmdReq *req, |
| 126 | struct iovec *out, unsigned int out_len, |
| 127 | VirtIOSCSICmdResp *rsp, |
| 128 | struct iovec *in, unsigned int in_len) |
| 129 | { |
| 130 | struct scsi_task *task; |
| 131 | uint32_t dir; |
| 132 | uint32_t len; |
| 133 | int cdb_len; |
| 134 | int i; |
| 135 | |
| 136 | assert(ctx); |
| 137 | assert(req); |
| 138 | assert(rsp); |
| 139 | |
| 140 | if (!(!req->lun[1] && req->lun[2] == 0x40 && !req->lun[3])) { |
| 141 | /* Ignore anything different than target=0, lun=0 */ |
| 142 | g_debug("Ignoring unconnected lun (0x%hhX, 0x%hhX)", |
| 143 | req->lun[1], req->lun[3]); |
| 144 | rsp->status = SCSI_STATUS_CHECK_CONDITION; |
| 145 | memset(rsp->sense, 0, sizeof(rsp->sense)); |
| 146 | rsp->sense_len = 18; |
| 147 | rsp->sense[0] = 0x70; |
| 148 | rsp->sense[2] = SCSI_SENSE_ILLEGAL_REQUEST; |
| 149 | rsp->sense[7] = 10; |
| 150 | rsp->sense[12] = 0x24; |
| 151 | |
| 152 | return 0; |
| 153 | } |
| 154 | |
| 155 | cdb_len = get_cdb_len(req->cdb); |
| 156 | if (cdb_len == -1) { |
| 157 | return -1; |
| 158 | } |
| 159 | |
| 160 | len = 0; |
| 161 | if (!out_len && !in_len) { |
| 162 | dir = SCSI_XFER_NONE; |
| 163 | } else if (out_len) { |
| 164 | dir = SCSI_XFER_WRITE; |
| 165 | for (i = 0; i < out_len; i++) { |
| 166 | len += out[i].iov_len; |
| 167 | } |
| 168 | } else { |
| 169 | dir = SCSI_XFER_READ; |
| 170 | for (i = 0; i < in_len; i++) { |
| 171 | len += in[i].iov_len; |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | task = scsi_task_new(cdb_len, req->cdb, dir, len); |
| 176 | |
| 177 | if (dir == SCSI_XFER_WRITE) { |
| 178 | task->iovector_out.iov = (struct scsi_iovec *)out; |
| 179 | task->iovector_out.niov = out_len; |
| 180 | } else if (dir == SCSI_XFER_READ) { |
| 181 | task->iovector_in.iov = (struct scsi_iovec *)in; |
| 182 | task->iovector_in.niov = in_len; |
| 183 | } |
| 184 | |
| 185 | g_debug("Sending iscsi cmd (cdb_len=%d, dir=%d, task=%p)", |
| 186 | cdb_len, dir, task); |
| 187 | if (!iscsi_scsi_command_sync(ctx, 0, task, NULL)) { |
| 188 | g_warning("Error serving SCSI command"); |
| 189 | g_free(task); |
| 190 | return -1; |
| 191 | } |
| 192 | |
| 193 | memset(rsp, 0, sizeof(*rsp)); |
| 194 | |
| 195 | rsp->status = task->status; |
| 196 | rsp->resid = task->residual; |
| 197 | |
| 198 | if (task->status == SCSI_STATUS_CHECK_CONDITION) { |
| 199 | rsp->response = VIRTIO_SCSI_S_FAILURE; |
| 200 | rsp->sense_len = task->datain.size - 2; |
| 201 | memcpy(rsp->sense, &task->datain.data[2], rsp->sense_len); |
| 202 | } |
| 203 | |
| 204 | g_free(task); |
| 205 | |
| 206 | g_debug("Filled in rsp: status=%hhX, resid=%u, response=%hhX, sense_len=%u", |
| 207 | rsp->status, rsp->resid, rsp->response, rsp->sense_len); |
| 208 | |
| 209 | return 0; |
| 210 | } |
| 211 | |
| 212 | /** libvhost-user callbacks **/ |
| 213 | |
| 214 | static void vus_panic_cb(VuDev *vu_dev, const char *buf) |
| 215 | { |
| 216 | VugDev *gdev; |
| 217 | VusDev *vdev_scsi; |
| 218 | |
| 219 | assert(vu_dev); |
| 220 | |
| 221 | gdev = container_of(vu_dev, VugDev, parent); |
| 222 | vdev_scsi = container_of(gdev, VusDev, parent); |
| 223 | if (buf) { |
| 224 | g_warning("vu_panic: %s", buf); |
| 225 | } |
| 226 | |
| 227 | g_main_loop_quit(vdev_scsi->loop); |
| 228 | } |
| 229 | |
| 230 | static void vus_proc_req(VuDev *vu_dev, int idx) |
| 231 | { |
| 232 | VugDev *gdev; |
| 233 | VusDev *vdev_scsi; |
| 234 | VuVirtq *vq; |
| 235 | VuVirtqElement *elem = NULL; |
| 236 | |
| 237 | assert(vu_dev); |
| 238 | |
| 239 | gdev = container_of(vu_dev, VugDev, parent); |
| 240 | vdev_scsi = container_of(gdev, VusDev, parent); |
| 241 | |
| 242 | vq = vu_get_queue(vu_dev, idx); |
| 243 | if (!vq) { |
| 244 | g_warning("Error fetching VQ (dev=%p, idx=%d)", vu_dev, idx); |
| 245 | vus_panic_cb(vu_dev, NULL); |
| 246 | return; |
| 247 | } |
| 248 | |
| 249 | g_debug("Got kicked on vq[%d]@%p", idx, vq); |
| 250 | |
| 251 | while (1) { |
| 252 | VirtIOSCSICmdReq *req; |
| 253 | VirtIOSCSICmdResp *rsp; |
| 254 | |
| 255 | elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement)); |
| 256 | if (!elem) { |
| 257 | g_debug("No more elements pending on vq[%d]@%p", idx, vq); |
| 258 | break; |
| 259 | } |
| 260 | g_debug("Popped elem@%p", elem); |
| 261 | |
| 262 | assert(!(elem->out_num > 1 && elem->in_num > 1)); |
| 263 | assert(elem->out_num > 0 && elem->in_num > 0); |
| 264 | |
| 265 | if (elem->out_sg[0].iov_len < sizeof(VirtIOSCSICmdReq)) { |
| 266 | g_warning("Invalid virtio-scsi req header"); |
| 267 | vus_panic_cb(vu_dev, NULL); |
| 268 | break; |
| 269 | } |
| 270 | req = (VirtIOSCSICmdReq *)elem->out_sg[0].iov_base; |
| 271 | |
| 272 | if (elem->in_sg[0].iov_len < sizeof(VirtIOSCSICmdResp)) { |
| 273 | g_warning("Invalid virtio-scsi rsp header"); |
| 274 | vus_panic_cb(vu_dev, NULL); |
| 275 | break; |
| 276 | } |
| 277 | rsp = (VirtIOSCSICmdResp *)elem->in_sg[0].iov_base; |
| 278 | |
| 279 | if (handle_cmd_sync(vdev_scsi->lun.iscsi_ctx, |
| 280 | req, &elem->out_sg[1], elem->out_num - 1, |
| 281 | rsp, &elem->in_sg[1], elem->in_num - 1) != 0) { |
| 282 | vus_panic_cb(vu_dev, NULL); |
| 283 | break; |
| 284 | } |
| 285 | |
| 286 | vu_queue_push(vu_dev, vq, elem, 0); |
| 287 | vu_queue_notify(vu_dev, vq); |
| 288 | |
| 289 | free(elem); |
| 290 | } |
| 291 | free(elem); |
| 292 | } |
| 293 | |
| 294 | static void vus_queue_set_started(VuDev *vu_dev, int idx, bool started) |
| 295 | { |
| 296 | VuVirtq *vq; |
| 297 | |
| 298 | assert(vu_dev); |
| 299 | |
| 300 | vq = vu_get_queue(vu_dev, idx); |
| 301 | |
| 302 | if (idx == 0 || idx == 1) { |
| 303 | g_debug("queue %d unimplemented", idx); |
| 304 | } else { |
| 305 | vu_set_queue_handler(vu_dev, vq, started ? vus_proc_req : NULL); |
| 306 | } |
| 307 | } |
| 308 | |
| 309 | static const VuDevIface vus_iface = { |
| 310 | .queue_set_started = vus_queue_set_started, |
| 311 | }; |
| 312 | |
| 313 | /** misc helpers **/ |
| 314 | |
| 315 | static int unix_sock_new(char *unix_fn) |
| 316 | { |
| 317 | int sock; |
| 318 | struct sockaddr_un un; |
| 319 | size_t len; |
| 320 | |
| 321 | assert(unix_fn); |
| 322 | |
| 323 | sock = socket(AF_UNIX, SOCK_STREAM, 0); |
| 324 | if (sock < 0) { |
| 325 | perror("socket"); |
| 326 | return -1; |
| 327 | } |
| 328 | |
| 329 | un.sun_family = AF_UNIX; |
| 330 | (void)snprintf(un.sun_path, sizeof(un.sun_path), "%s", unix_fn); |
| 331 | len = sizeof(un.sun_family) + strlen(un.sun_path); |
| 332 | |
| 333 | (void)unlink(unix_fn); |
| 334 | if (bind(sock, (struct sockaddr *)&un, len) < 0) { |
| 335 | perror("bind"); |
| 336 | goto fail; |
| 337 | } |
| 338 | |
| 339 | if (listen(sock, 1) < 0) { |
| 340 | perror("listen"); |
| 341 | goto fail; |
| 342 | } |
| 343 | |
| 344 | return sock; |
| 345 | |
| 346 | fail: |
| 347 | (void)close(sock); |
| 348 | |
| 349 | return -1; |
| 350 | } |
| 351 | |
| 352 | /** vhost-user-scsi **/ |
| 353 | |
| 354 | static int opt_fdnum = -1; |
| 355 | static char *opt_socket_path; |
| 356 | static gboolean opt_print_caps; |
| 357 | static char *iscsi_uri; |
| 358 | |
| 359 | static GOptionEntry entries[] = { |
| 360 | { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps, |
| 361 | "Print capabilities", NULL }, |
| 362 | { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum, |
| 363 | "Use inherited fd socket", "FDNUM" }, |
| 364 | { "iscsi-uri", 'i', 0, G_OPTION_ARG_FILENAME, &iscsi_uri, |
| 365 | "iSCSI URI to connect to", "FDNUM" }, |
| 366 | { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path, |
| 367 | "Use UNIX socket path", "PATH" }, |
| 368 | { NULL, } |
| 369 | }; |
| 370 | |
| 371 | int main(int argc, char **argv) |
| 372 | { |
| 373 | VusDev *vdev_scsi = NULL; |
| 374 | int lsock = -1, csock = -1, err = EXIT_SUCCESS; |
| 375 | |
| 376 | GError *error = NULL; |
| 377 | GOptionContext *context; |
| 378 | |
| 379 | context = g_option_context_new(NULL); |
| 380 | g_option_context_add_main_entries(context, entries, NULL); |
| 381 | if (!g_option_context_parse(context, &argc, &argv, &error)) { |
| 382 | g_printerr("Option parsing failed: %s\n", error->message); |
| 383 | exit(EXIT_FAILURE); |
| 384 | } |
| 385 | |
| 386 | if (opt_print_caps) { |
| 387 | g_print("{\n"); |
| 388 | g_print(" \"type\": \"scsi\"\n"); |
| 389 | g_print("}\n"); |
| 390 | goto out; |
| 391 | } |
| 392 | |
| 393 | if (!iscsi_uri) { |
| 394 | goto help; |
| 395 | } |
| 396 | |
| 397 | if (opt_socket_path) { |
| 398 | lsock = unix_sock_new(opt_socket_path); |
| 399 | if (lsock < 0) { |
| 400 | exit(EXIT_FAILURE); |
| 401 | } |
| 402 | } else if (opt_fdnum < 0) { |
| 403 | g_print("%s\n", g_option_context_get_help(context, true, NULL)); |
| 404 | exit(EXIT_FAILURE); |
| 405 | } else { |
| 406 | lsock = opt_fdnum; |
| 407 | } |
| 408 | |
| 409 | csock = accept(lsock, NULL, NULL); |
| 410 | if (csock < 0) { |
| 411 | perror("accept"); |
| 412 | goto err; |
| 413 | } |
| 414 | |
| 415 | vdev_scsi = g_new0(VusDev, 1); |
| 416 | vdev_scsi->loop = g_main_loop_new(NULL, FALSE); |
| 417 | |
| 418 | if (vus_iscsi_add_lun(&vdev_scsi->lun, iscsi_uri) != 0) { |
| 419 | goto err; |
| 420 | } |
| 421 | |
| 422 | if (!vug_init(&vdev_scsi->parent, VHOST_USER_SCSI_MAX_QUEUES, csock, |
| 423 | vus_panic_cb, &vus_iface)) { |
| 424 | g_printerr("Failed to initialize libvhost-user-glib\n"); |
| 425 | goto err; |
| 426 | } |
| 427 | |
| 428 | g_main_loop_run(vdev_scsi->loop); |
| 429 | |
| 430 | vug_deinit(&vdev_scsi->parent); |
| 431 | |
| 432 | out: |
| 433 | if (vdev_scsi) { |
| 434 | g_main_loop_unref(vdev_scsi->loop); |
| 435 | g_free(vdev_scsi); |
| 436 | } |
| 437 | if (csock >= 0) { |
| 438 | close(csock); |
| 439 | } |
| 440 | if (lsock >= 0) { |
| 441 | close(lsock); |
| 442 | |
| 443 | if (opt_socket_path) { |
| 444 | unlink(opt_socket_path); |
| 445 | } |
| 446 | } |
| 447 | g_free(opt_socket_path); |
| 448 | g_free(iscsi_uri); |
| 449 | |
| 450 | return err; |
| 451 | |
| 452 | err: |
| 453 | err = EXIT_FAILURE; |
| 454 | goto out; |
| 455 | |
| 456 | help: |
| 457 | fprintf(stderr, "Usage: %s [ -s socket-path -i iscsi-uri -f fd -p print-capabilities ] | [ -h ]\n", |
| 458 | argv[0]); |
| 459 | fprintf(stderr, " -s, --socket-path=SOCKET_PATH path to unix socket\n"); |
| 460 | fprintf(stderr, " -i, --iscsi-uri=ISCSI_URI iscsi uri for lun 0\n"); |
| 461 | fprintf(stderr, " -f, --fd=FILE_DESCRIPTOR file-descriptor\n"); |
| 462 | fprintf(stderr, " -p, --print-capabilities=PRINT_CAPABILITIES denotes print-capabilities\n"); |
| 463 | fprintf(stderr, " -h print help and quit\n"); |
| 464 | |
| 465 | goto err; |
| 466 | } |