drivers/vhost/scsi.c

   1 /*******************************************************************************
   2  * Vhost kernel TCM fabric driver for virtio SCSI initiators
   3  *
   4  * (C) Copyright 2010-2013 Datera, Inc.
   5  * (C) Copyright 2010-2012 IBM Corp.
   6  *
   7  * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
   8  *
   9  * Authors: Nicholas A. Bellinger <nab@daterainc.com>
  10  *          Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  ****************************************************************************/
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <generated/utsrelease.h>
  27 #include <linux/utsname.h>
  28 #include <linux/init.h>
  29 #include <linux/slab.h>
  30 #include <linux/kthread.h>
  31 #include <linux/types.h>
  32 #include <linux/string.h>
  33 #include <linux/configfs.h>
  34 #include <linux/ctype.h>
  35 #include <linux/compat.h>
  36 #include <linux/eventfd.h>
  37 #include <linux/fs.h>
  38 #include <linux/miscdevice.h>
  39 #include <asm/unaligned.h>
  40 #include <scsi/scsi.h>
  41 #include <scsi/scsi_tcq.h>
  42 #include <target/target_core_base.h>
  43 #include <target/target_core_fabric.h>
  44 #include <target/target_core_fabric_configfs.h>
  45 #include <target/target_core_configfs.h>
  46 #include <target/configfs_macros.h>
  47 #include <linux/vhost.h>
  48 #include <linux/virtio_scsi.h>
  49 #include <linux/llist.h>
  50 #include <linux/bitmap.h>
  51 #include <linux/percpu_ida.h>
  52
  53 #include "vhost.h"
  54
  55 #define TCM_VHOST_VERSION  "v0.1"
  56 #define TCM_VHOST_NAMELEN 256
  57 #define TCM_VHOST_MAX_CDB_SIZE 32
  58 #define TCM_VHOST_DEFAULT_TAGS 256
  59 #define TCM_VHOST_PREALLOC_SGLS 2048
  60 #define TCM_VHOST_PREALLOC_PAGES 2048
  61
  62 struct vhost_scsi_inflight {
  63         /* Wait for the flush operation to finish */
  64         struct completion comp;
  65         /* Refcount for the inflight reqs */
  66         struct kref kref;
  67 };
  68
  69 struct tcm_vhost_cmd {
  70         /* Descriptor from vhost_get_vq_desc() for virt_queue segment */
  71         int tvc_vq_desc;
  72         /* virtio-scsi initiator task attribute */
  73         int tvc_task_attr;
  74         /* virtio-scsi initiator data direction */
  75         enum dma_data_direction tvc_data_direction;
  76         /* Expected data transfer length from virtio-scsi header */
  77         u32 tvc_exp_data_len;
  78         /* The Tag from include/linux/virtio_scsi.h:struct virtio_scsi_cmd_req */
  79         u64 tvc_tag;
  80         /* The number of scatterlists associated with this cmd */
  81         u32 tvc_sgl_count;
  82         /* Saved unpacked SCSI LUN for tcm_vhost_submission_work() */
  83         u32 tvc_lun;
  84         /* Pointer to the SGL formatted memory from virtio-scsi */
  85         struct scatterlist *tvc_sgl;
  86         struct page **tvc_upages;
  87         /* Pointer to response */
  88         struct virtio_scsi_cmd_resp __user *tvc_resp;
  89         /* Pointer to vhost_scsi for our device */
  90         struct vhost_scsi *tvc_vhost;
  91         /* Pointer to vhost_virtqueue for the cmd */
  92         struct vhost_virtqueue *tvc_vq;
  93         /* Pointer to vhost nexus memory */
  94         struct tcm_vhost_nexus *tvc_nexus;
  95         /* The TCM I/O descriptor that is accessed via container_of() */
  96         struct se_cmd tvc_se_cmd;
  97         /* work item used for cmwq dispatch to tcm_vhost_submission_work() */
  98         struct work_struct work;
  99         /* Copy of the incoming SCSI command descriptor block (CDB) */
 100         unsigned char tvc_cdb[TCM_VHOST_MAX_CDB_SIZE];
 101         /* Sense buffer that will be mapped into outgoing status */
 102         unsigned char tvc_sense_buf[TRANSPORT_SENSE_BUFFER];
 103         /* Completed commands list, serviced from vhost worker thread */
 104         struct llist_node tvc_completion_list;
 105         /* Used to track inflight cmd */
 106         struct vhost_scsi_inflight *inflight;
 107 };
 108
 109 struct tcm_vhost_nexus {
 110         /* Pointer to TCM session for I_T Nexus */
 111         struct se_session *tvn_se_sess;
 112 };
 113
 114 struct tcm_vhost_nacl {
 115         /* Binary World Wide unique Port Name for Vhost Initiator port */
 116         u64 iport_wwpn;
 117         /* ASCII formatted WWPN for Sas Initiator port */
 118         char iport_name[TCM_VHOST_NAMELEN];
 119         /* Returned by tcm_vhost_make_nodeacl() */
 120         struct se_node_acl se_node_acl;
 121 };
 122
 123 struct tcm_vhost_tpg {
 124         /* Vhost port target portal group tag for TCM */
 125         u16 tport_tpgt;
 126         /* Used to track number of TPG Port/Lun Links wrt to explict I_T Nexus shutdown */
 127         int tv_tpg_port_count;
 128         /* Used for vhost_scsi device reference to tpg_nexus, protected by tv_tpg_mutex */
 129         int tv_tpg_vhost_count;
 130         /* list for tcm_vhost_list */
 131         struct list_head tv_tpg_list;
 132         /* Used to protect access for tpg_nexus */
 133         struct mutex tv_tpg_mutex;
 134         /* Pointer to the TCM VHost I_T Nexus for this TPG endpoint */
 135         struct tcm_vhost_nexus *tpg_nexus;
 136         /* Pointer back to tcm_vhost_tport */
 137         struct tcm_vhost_tport *tport;
 138         /* Returned by tcm_vhost_make_tpg() */
 139         struct se_portal_group se_tpg;
 140         /* Pointer back to vhost_scsi, protected by tv_tpg_mutex */
 141         struct vhost_scsi *vhost_scsi;
 142 };
 143
 144 struct tcm_vhost_tport {
 145         /* SCSI protocol the tport is providing */
 146         u8 tport_proto_id;
 147         /* Binary World Wide unique Port Name for Vhost Target port */
 148         u64 tport_wwpn;
 149         /* ASCII formatted WWPN for Vhost Target port */
 150         char tport_name[TCM_VHOST_NAMELEN];
 151         /* Returned by tcm_vhost_make_tport() */
 152         struct se_wwn tport_wwn;
 153 };
 154
 155 struct tcm_vhost_evt {
 156         /* event to be sent to guest */
 157         struct virtio_scsi_event event;
 158         /* event list, serviced from vhost worker thread */
 159         struct llist_node list;
 160 };
 161
 162 enum {
 163         VHOST_SCSI_VQ_CTL = 0,
 164         VHOST_SCSI_VQ_EVT = 1,
 165         VHOST_SCSI_VQ_IO = 2,
 166 };
 167
 168 enum {
 169         VHOST_SCSI_FEATURES = VHOST_FEATURES | (1ULL << VIRTIO_SCSI_F_HOTPLUG)
 170 };
 171
 172 #define VHOST_SCSI_MAX_TARGET   256
 173 #define VHOST_SCSI_MAX_VQ       128
 174 #define VHOST_SCSI_MAX_EVENT    128
 175
 176 struct vhost_scsi_virtqueue {
 177         struct vhost_virtqueue vq;
 178         /*
 179          * Reference counting for inflight reqs, used for flush operation. At
 180          * each time, one reference tracks new commands submitted, while we
 181          * wait for another one to reach 0.
 182          */
 183         struct vhost_scsi_inflight inflights[2];
 184         /*
 185          * Indicate current inflight in use, protected by vq->mutex.
 186          * Writers must also take dev mutex and flush under it.
 187          */
 188         int inflight_idx;
 189 };
 190
 191 struct vhost_scsi {
 192         /* Protected by vhost_scsi->dev.mutex */
 193         struct tcm_vhost_tpg **vs_tpg;
 194         char vs_vhost_wwpn[TRANSPORT_IQN_LEN];
 195
 196         struct vhost_dev dev;
 197         struct vhost_scsi_virtqueue vqs[VHOST_SCSI_MAX_VQ];
 198
 199         struct vhost_work vs_completion_work; /* cmd completion work item */
 200         struct llist_head vs_completion_list; /* cmd completion queue */
 201
 202         struct vhost_work vs_event_work; /* evt injection work item */
 203         struct llist_head vs_event_list; /* evt injection queue */
 204
 205         bool vs_events_missed; /* any missed events, protected by vq->mutex */
 206         int vs_events_nr; /* num of pending events, protected by vq->mutex */
 207 };
 208
 209 /* Local pointer to allocated TCM configfs fabric module */
 210 static struct target_fabric_configfs *tcm_vhost_fabric_configfs;
 211
 212 static struct workqueue_struct *tcm_vhost_workqueue;
 213
 214 /* Global spinlock to protect tcm_vhost TPG list for vhost IOCTL access */
 215 static DEFINE_MUTEX(tcm_vhost_mutex);
 216 static LIST_HEAD(tcm_vhost_list);
 217
 218 static int iov_num_pages(struct iovec *iov)
 219 {
 220         return (PAGE_ALIGN((unsigned long)iov->iov_base + iov->iov_len) -
 221                ((unsigned long)iov->iov_base & PAGE_MASK)) >> PAGE_SHIFT;
 222 }
 223
 224 static void tcm_vhost_done_inflight(struct kref *kref)
 225 {
 226         struct vhost_scsi_inflight *inflight;
 227
 228         inflight = container_of(kref, struct vhost_scsi_inflight, kref);
 229         complete(&inflight->comp);
 230 }
 231
 232 static void tcm_vhost_init_inflight(struct vhost_scsi *vs,
 233                                     struct vhost_scsi_inflight *old_inflight[])
 234 {
 235         struct vhost_scsi_inflight *new_inflight;
 236         struct vhost_virtqueue *vq;
 237         int idx, i;
 238
 239         for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
 240                 vq = &vs->vqs[i].vq;
 241
 242                 mutex_lock(&vq->mutex);
 243
 244                 /* store old infight */
 245                 idx = vs->vqs[i].inflight_idx;
 246                 if (old_inflight)
 247                         old_inflight[i] = &vs->vqs[i].inflights[idx];
 248
 249                 /* setup new infight */
 250                 vs->vqs[i].inflight_idx = idx ^ 1;
 251                 new_inflight = &vs->vqs[i].inflights[idx ^ 1];
 252                 kref_init(&new_inflight->kref);
 253                 init_completion(&new_inflight->comp);
 254
 255                 mutex_unlock(&vq->mutex);
 256         }
 257 }
 258
 259 static struct vhost_scsi_inflight *
 260 tcm_vhost_get_inflight(struct vhost_virtqueue *vq)
 261 {
 262         struct vhost_scsi_inflight *inflight;
 263         struct vhost_scsi_virtqueue *svq;
 264
 265         svq = container_of(vq, struct vhost_scsi_virtqueue, vq);
 266         inflight = &svq->inflights[svq->inflight_idx];
 267         kref_get(&inflight->kref);
 268
 269         return inflight;
 270 }
 271
 272 static void tcm_vhost_put_inflight(struct vhost_scsi_inflight *inflight)
 273 {
 274         kref_put(&inflight->kref, tcm_vhost_done_inflight);
 275 }
 276
 277 static int tcm_vhost_check_true(struct se_portal_group *se_tpg)
 278 {
 279         return 1;
 280 }
 281
 282 static int tcm_vhost_check_false(struct se_portal_group *se_tpg)
 283 {
 284         return 0;
 285 }
 286
 287 static char *tcm_vhost_get_fabric_name(void)
 288 {
 289         return "vhost";
 290 }
 291
 292 static u8 tcm_vhost_get_fabric_proto_ident(struct se_portal_group *se_tpg)
 293 {
 294         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
 295                                 struct tcm_vhost_tpg, se_tpg);
 296         struct tcm_vhost_tport *tport = tpg->tport;
 297
 298         switch (tport->tport_proto_id) {
 299         case SCSI_PROTOCOL_SAS:
 300                 return sas_get_fabric_proto_ident(se_tpg);
 301         case SCSI_PROTOCOL_FCP:
 302                 return fc_get_fabric_proto_ident(se_tpg);
 303         case SCSI_PROTOCOL_ISCSI:
 304                 return iscsi_get_fabric_proto_ident(se_tpg);
 305         default:
 306                 pr_err("Unknown tport_proto_id: 0x%02x, using"
 307                         " SAS emulation\n", tport->tport_proto_id);
 308                 break;
 309         }
 310
 311         return sas_get_fabric_proto_ident(se_tpg);
 312 }
 313
 314 static char *tcm_vhost_get_fabric_wwn(struct se_portal_group *se_tpg)
 315 {
 316         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
 317                                 struct tcm_vhost_tpg, se_tpg);
 318         struct tcm_vhost_tport *tport = tpg->tport;
 319
 320         return &tport->tport_name[0];
 321 }
 322
 323 static u16 tcm_vhost_get_tag(struct se_portal_group *se_tpg)
 324 {
 325         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
 326                                 struct tcm_vhost_tpg, se_tpg);
 327         return tpg->tport_tpgt;
 328 }
 329
 330 static u32 tcm_vhost_get_default_depth(struct se_portal_group *se_tpg)
 331 {
 332         return 1;
 333 }
 334
 335 static u32
 336 tcm_vhost_get_pr_transport_id(struct se_portal_group *se_tpg,
 337                               struct se_node_acl *se_nacl,
 338                               struct t10_pr_registration *pr_reg,
 339                               int *format_code,
 340                               unsigned char *buf)
 341 {
 342         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
 343                                 struct tcm_vhost_tpg, se_tpg);
 344         struct tcm_vhost_tport *tport = tpg->tport;
 345
 346         switch (tport->tport_proto_id) {
 347         case SCSI_PROTOCOL_SAS:
 348                 return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
 349                                         format_code, buf);
 350         case SCSI_PROTOCOL_FCP:
 351                 return fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
 352                                         format_code, buf);
 353         case SCSI_PROTOCOL_ISCSI:
 354                 return iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
 355                                         format_code, buf);
 356         default:
 357                 pr_err("Unknown tport_proto_id: 0x%02x, using"
 358                         " SAS emulation\n", tport->tport_proto_id);
 359                 break;
 360         }
 361
 362         return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
 363                         format_code, buf);
 364 }
 365
 366 static u32
 367 tcm_vhost_get_pr_transport_id_len(struct se_portal_group *se_tpg,
 368                                   struct se_node_acl *se_nacl,
 369                                   struct t10_pr_registration *pr_reg,
 370                                   int *format_code)
 371 {
 372         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
 373                                 struct tcm_vhost_tpg, se_tpg);
 374         struct tcm_vhost_tport *tport = tpg->tport;
 375
 376         switch (tport->tport_proto_id) {
 377         case SCSI_PROTOCOL_SAS:
 378                 return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
 379                                         format_code);
 380         case SCSI_PROTOCOL_FCP:
 381                 return fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
 382                                         format_code);
 383         case SCSI_PROTOCOL_ISCSI:
 384                 return iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
 385                                         format_code);
 386         default:
 387                 pr_err("Unknown tport_proto_id: 0x%02x, using"
 388                         " SAS emulation\n", tport->tport_proto_id);
 389                 break;
 390         }
 391
 392         return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
 393                         format_code);
 394 }
 395
 396 static char *
 397 tcm_vhost_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
 398                                     const char *buf,
 399                                     u32 *out_tid_len,
 400                                     char **port_nexus_ptr)
 401 {
 402         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
 403                                 struct tcm_vhost_tpg, se_tpg);
 404         struct tcm_vhost_tport *tport = tpg->tport;
 405
 406         switch (tport->tport_proto_id) {
 407         case SCSI_PROTOCOL_SAS:
 408                 return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
 409                                         port_nexus_ptr);
 410         case SCSI_PROTOCOL_FCP:
 411                 return fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
 412                                         port_nexus_ptr);
 413         case SCSI_PROTOCOL_ISCSI:
 414                 return iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
 415                                         port_nexus_ptr);
 416         default:
 417                 pr_err("Unknown tport_proto_id: 0x%02x, using"
 418                         " SAS emulation\n", tport->tport_proto_id);
 419                 break;
 420         }
 421
 422         return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
 423                         port_nexus_ptr);
 424 }
 425
 426 static struct se_node_acl *
 427 tcm_vhost_alloc_fabric_acl(struct se_portal_group *se_tpg)
 428 {
 429         struct tcm_vhost_nacl *nacl;
 430
 431         nacl = kzalloc(sizeof(struct tcm_vhost_nacl), GFP_KERNEL);
 432         if (!nacl) {
 433                 pr_err("Unable to allocate struct tcm_vhost_nacl\n");
 434                 return NULL;
 435         }
 436
 437         return &nacl->se_node_acl;
 438 }
 439
 440 static void
 441 tcm_vhost_release_fabric_acl(struct se_portal_group *se_tpg,
 442                              struct se_node_acl *se_nacl)
 443 {
 444         struct tcm_vhost_nacl *nacl = container_of(se_nacl,
 445                         struct tcm_vhost_nacl, se_node_acl);
 446         kfree(nacl);
 447 }
 448
 449 static u32 tcm_vhost_tpg_get_inst_index(struct se_portal_group *se_tpg)
 450 {
 451         return 1;
 452 }
 453
 454 static void tcm_vhost_release_cmd(struct se_cmd *se_cmd)
 455 {
 456         struct tcm_vhost_cmd *tv_cmd = container_of(se_cmd,
 457                                 struct tcm_vhost_cmd, tvc_se_cmd);
 458         struct se_session *se_sess = se_cmd->se_sess;
 459
 460         if (tv_cmd->tvc_sgl_count) {
 461                 u32 i;
 462                 for (i = 0; i < tv_cmd->tvc_sgl_count; i++)
 463                         put_page(sg_page(&tv_cmd->tvc_sgl[i]));
 464         }
 465
 466         tcm_vhost_put_inflight(tv_cmd->inflight);
 467         percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag);
 468 }
 469
 470 static int tcm_vhost_shutdown_session(struct se_session *se_sess)
 471 {
 472         return 0;
 473 }
 474
 475 static void tcm_vhost_close_session(struct se_session *se_sess)
 476 {
 477         return;
 478 }
 479
 480 static u32 tcm_vhost_sess_get_index(struct se_session *se_sess)
 481 {
 482         return 0;
 483 }
 484
 485 static int tcm_vhost_write_pending(struct se_cmd *se_cmd)
 486 {
 487         /* Go ahead and process the write immediately */
 488         target_execute_cmd(se_cmd);
 489         return 0;
 490 }
 491
 492 static int tcm_vhost_write_pending_status(struct se_cmd *se_cmd)
 493 {
 494         return 0;
 495 }
 496
 497 static void tcm_vhost_set_default_node_attrs(struct se_node_acl *nacl)
 498 {
 499         return;
 500 }
 501
 502 static u32 tcm_vhost_get_task_tag(struct se_cmd *se_cmd)
 503 {
 504         return 0;
 505 }
 506
 507 static int tcm_vhost_get_cmd_state(struct se_cmd *se_cmd)
 508 {
 509         return 0;
 510 }
 511
 512 static void vhost_scsi_complete_cmd(struct tcm_vhost_cmd *cmd)
 513 {
 514         struct vhost_scsi *vs = cmd->tvc_vhost;
 515
 516         llist_add(&cmd->tvc_completion_list, &vs->vs_completion_list);
 517
 518         vhost_work_queue(&vs->dev, &vs->vs_completion_work);
 519 }
 520
 521 static int tcm_vhost_queue_data_in(struct se_cmd *se_cmd)
 522 {
 523         struct tcm_vhost_cmd *cmd = container_of(se_cmd,
 524                                 struct tcm_vhost_cmd, tvc_se_cmd);
 525         vhost_scsi_complete_cmd(cmd);
 526         return 0;
 527 }
 528
 529 static int tcm_vhost_queue_status(struct se_cmd *se_cmd)
 530 {
 531         struct tcm_vhost_cmd *cmd = container_of(se_cmd,
 532                                 struct tcm_vhost_cmd, tvc_se_cmd);
 533         vhost_scsi_complete_cmd(cmd);
 534         return 0;
 535 }
 536
 537 static void tcm_vhost_queue_tm_rsp(struct se_cmd *se_cmd)
 538 {
 539         return;
 540 }
 541
 542 static void tcm_vhost_free_evt(struct vhost_scsi *vs, struct tcm_vhost_evt *evt)
 543 {
 544         vs->vs_events_nr--;
 545         kfree(evt);
 546 }
 547
 548 static struct tcm_vhost_evt *
 549 tcm_vhost_allocate_evt(struct vhost_scsi *vs,
 550                        u32 event, u32 reason)
 551 {
 552         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
 553         struct tcm_vhost_evt *evt;
 554
 555         if (vs->vs_events_nr > VHOST_SCSI_MAX_EVENT) {
 556                 vs->vs_events_missed = true;
 557                 return NULL;
 558         }
 559
 560         evt = kzalloc(sizeof(*evt), GFP_KERNEL);
 561         if (!evt) {
 562                 vq_err(vq, "Failed to allocate tcm_vhost_evt\n");
 563                 vs->vs_events_missed = true;
 564                 return NULL;
 565         }
 566
 567         evt->event.event = event;
 568         evt->event.reason = reason;
 569         vs->vs_events_nr++;
 570
 571         return evt;
 572 }
 573
 574 static void vhost_scsi_free_cmd(struct tcm_vhost_cmd *cmd)
 575 {
 576         struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
 577
 578         /* TODO locking against target/backend threads? */
 579         transport_generic_free_cmd(se_cmd, 0);
 580
 581 }
 582
 583 static int vhost_scsi_check_stop_free(struct se_cmd *se_cmd)
 584 {
 585         return target_put_sess_cmd(se_cmd->se_sess, se_cmd);
 586 }
 587
 588 static void
 589 tcm_vhost_do_evt_work(struct vhost_scsi *vs, struct tcm_vhost_evt *evt)
 590 {
 591         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
 592         struct virtio_scsi_event *event = &evt->event;
 593         struct virtio_scsi_event __user *eventp;
 594         unsigned out, in;
 595         int head, ret;
 596
 597         if (!vq->private_data) {
 598                 vs->vs_events_missed = true;
 599                 return;
 600         }
 601
 602 again:
 603         vhost_disable_notify(&vs->dev, vq);
 604         head = vhost_get_vq_desc(&vs->dev, vq, vq->iov,
 605                         ARRAY_SIZE(vq->iov), &out, &in,
 606                         NULL, NULL);
 607         if (head < 0) {
 608                 vs->vs_events_missed = true;
 609                 return;
 610         }
 611         if (head == vq->num) {
 612                 if (vhost_enable_notify(&vs->dev, vq))
 613                         goto again;
 614                 vs->vs_events_missed = true;
 615                 return;
 616         }
 617
 618         if ((vq->iov[out].iov_len != sizeof(struct virtio_scsi_event))) {
 619                 vq_err(vq, "Expecting virtio_scsi_event, got %zu bytes\n",
 620                                 vq->iov[out].iov_len);
 621                 vs->vs_events_missed = true;
 622                 return;
 623         }
 624
 625         if (vs->vs_events_missed) {
 626                 event->event |= VIRTIO_SCSI_T_EVENTS_MISSED;
 627                 vs->vs_events_missed = false;
 628         }
 629
 630         eventp = vq->iov[out].iov_base;
 631         ret = __copy_to_user(eventp, event, sizeof(*event));
 632         if (!ret)
 633                 vhost_add_used_and_signal(&vs->dev, vq, head, 0);
 634         else
 635                 vq_err(vq, "Faulted on tcm_vhost_send_event\n");
 636 }
 637
 638 static void tcm_vhost_evt_work(struct vhost_work *work)
 639 {
 640         struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
 641                                         vs_event_work);
 642         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
 643         struct tcm_vhost_evt *evt;
 644         struct llist_node *llnode;
 645
 646         mutex_lock(&vq->mutex);
 647         llnode = llist_del_all(&vs->vs_event_list);
 648         while (llnode) {
 649                 evt = llist_entry(llnode, struct tcm_vhost_evt, list);
 650                 llnode = llist_next(llnode);
 651                 tcm_vhost_do_evt_work(vs, evt);
 652                 tcm_vhost_free_evt(vs, evt);
 653         }
 654         mutex_unlock(&vq->mutex);
 655 }
 656
 657 /* Fill in status and signal that we are done processing this command
 658  *
 659  * This is scheduled in the vhost work queue so we are called with the owner
 660  * process mm and can access the vring.
 661  */
 662 static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
 663 {
 664         struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
 665                                         vs_completion_work);
 666         DECLARE_BITMAP(signal, VHOST_SCSI_MAX_VQ);
 667         struct virtio_scsi_cmd_resp v_rsp;
 668         struct tcm_vhost_cmd *cmd;
 669         struct llist_node *llnode;
 670         struct se_cmd *se_cmd;
 671         int ret, vq;
 672
 673         bitmap_zero(signal, VHOST_SCSI_MAX_VQ);
 674         llnode = llist_del_all(&vs->vs_completion_list);
 675         while (llnode) {
 676                 cmd = llist_entry(llnode, struct tcm_vhost_cmd,
 677                                      tvc_completion_list);
 678                 llnode = llist_next(llnode);
 679                 se_cmd = &cmd->tvc_se_cmd;
 680
 681                 pr_debug("%s tv_cmd %p resid %u status %#02x\n", __func__,
 682                         cmd, se_cmd->residual_count, se_cmd->scsi_status);
 683
 684                 memset(&v_rsp, 0, sizeof(v_rsp));
 685                 v_rsp.resid = se_cmd->residual_count;
 686                 /* TODO is status_qualifier field needed? */
 687                 v_rsp.status = se_cmd->scsi_status;
 688                 v_rsp.sense_len = se_cmd->scsi_sense_length;
 689                 memcpy(v_rsp.sense, cmd->tvc_sense_buf,
 690                        v_rsp.sense_len);
 691                 ret = copy_to_user(cmd->tvc_resp, &v_rsp, sizeof(v_rsp));
 692                 if (likely(ret == 0)) {
 693                         struct vhost_scsi_virtqueue *q;
 694                         vhost_add_used(cmd->tvc_vq, cmd->tvc_vq_desc, 0);
 695                         q = container_of(cmd->tvc_vq, struct vhost_scsi_virtqueue, vq);
 696                         vq = q - vs->vqs;
 697                         __set_bit(vq, signal);
 698                 } else
 699                         pr_err("Faulted on virtio_scsi_cmd_resp\n");
 700
 701                 vhost_scsi_free_cmd(cmd);
 702         }
 703
 704         vq = -1;
 705         while ((vq = find_next_bit(signal, VHOST_SCSI_MAX_VQ, vq + 1))
 706                 < VHOST_SCSI_MAX_VQ)
 707                 vhost_signal(&vs->dev, &vs->vqs[vq].vq);
 708 }
 709
 710 static struct tcm_vhost_cmd *
 711 vhost_scsi_get_tag(struct vhost_virtqueue *vq,
 712                         struct tcm_vhost_tpg *tpg,
 713                         struct virtio_scsi_cmd_req *v_req,
 714                         u32 exp_data_len,
 715                         int data_direction)
 716 {
 717         struct tcm_vhost_cmd *cmd;
 718         struct tcm_vhost_nexus *tv_nexus;
 719         struct se_session *se_sess;
 720         struct scatterlist *sg;
 721         struct page **pages;
 722         int tag;
 723
 724         tv_nexus = tpg->tpg_nexus;
 725         if (!tv_nexus) {
 726                 pr_err("Unable to locate active struct tcm_vhost_nexus\n");
 727                 return ERR_PTR(-EIO);
 728         }
 729         se_sess = tv_nexus->tvn_se_sess;
 730
 731         tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING);
 732         if (tag < 0) {
 733                 pr_err("Unable to obtain tag for tcm_vhost_cmd\n");
 734                 return ERR_PTR(-ENOMEM);
 735         }
 736
 737         cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[tag];
 738         sg = cmd->tvc_sgl;
 739         pages = cmd->tvc_upages;
 740         memset(cmd, 0, sizeof(struct tcm_vhost_cmd));
 741
 742         cmd->tvc_sgl = sg;
 743         cmd->tvc_upages = pages;
 744         cmd->tvc_se_cmd.map_tag = tag;
 745         cmd->tvc_tag = v_req->tag;
 746         cmd->tvc_task_attr = v_req->task_attr;
 747         cmd->tvc_exp_data_len = exp_data_len;
 748         cmd->tvc_data_direction = data_direction;
 749         cmd->tvc_nexus = tv_nexus;
 750         cmd->inflight = tcm_vhost_get_inflight(vq);
 751
 752         return cmd;
 753 }
 754
 755 /*
 756  * Map a user memory range into a scatterlist
 757  *
 758  * Returns the number of scatterlist entries used or -errno on error.
 759  */
 760 static int
 761 vhost_scsi_map_to_sgl(struct tcm_vhost_cmd *tv_cmd,
 762                       struct scatterlist *sgl,
 763                       unsigned int sgl_count,
 764                       struct iovec *iov,
 765                       int write)
 766 {
 767         unsigned int npages = 0, pages_nr, offset, nbytes;
 768         struct scatterlist *sg = sgl;
 769         void __user *ptr = iov->iov_base;
 770         size_t len = iov->iov_len;
 771         struct page **pages;
 772         int ret, i;
 773
 774         if (sgl_count > TCM_VHOST_PREALLOC_SGLS) {
 775                 pr_err("vhost_scsi_map_to_sgl() psgl_count: %u greater than"
 776                        " preallocated TCM_VHOST_PREALLOC_SGLS: %u\n",
 777                         sgl_count, TCM_VHOST_PREALLOC_SGLS);
 778                 return -ENOBUFS;
 779         }
 780
 781         pages_nr = iov_num_pages(iov);
 782         if (pages_nr > sgl_count)
 783                 return -ENOBUFS;
 784
 785         if (pages_nr > TCM_VHOST_PREALLOC_PAGES) {
 786                 pr_err("vhost_scsi_map_to_sgl() pages_nr: %u greater than"
 787                        " preallocated TCM_VHOST_PREALLOC_PAGES: %u\n",
 788                         pages_nr, TCM_VHOST_PREALLOC_PAGES);
 789                 return -ENOBUFS;
 790         }
 791
 792         pages = tv_cmd->tvc_upages;
 793
 794         ret = get_user_pages_fast((unsigned long)ptr, pages_nr, write, pages);
 795         /* No pages were pinned */
 796         if (ret < 0)
 797                 goto out;
 798         /* Less pages pinned than wanted */
 799         if (ret != pages_nr) {
 800                 for (i = 0; i < ret; i++)
 801                         put_page(pages[i]);
 802                 ret = -EFAULT;
 803                 goto out;
 804         }
 805
 806         while (len > 0) {
 807                 offset = (uintptr_t)ptr & ~PAGE_MASK;
 808                 nbytes = min_t(unsigned int, PAGE_SIZE - offset, len);
 809                 sg_set_page(sg, pages[npages], nbytes, offset);
 810                 ptr += nbytes;
 811                 len -= nbytes;
 812                 sg++;
 813                 npages++;
 814         }
 815
 816 out:
 817         return ret;
 818 }
 819
 820 static int
 821 vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd *cmd,
 822                           struct iovec *iov,
 823                           unsigned int niov,
 824                           int write)
 825 {
 826         int ret;
 827         unsigned int i;
 828         u32 sgl_count;
 829         struct scatterlist *sg;
 830
 831         /*
 832          * Find out how long sglist needs to be
 833          */
 834         sgl_count = 0;
 835         for (i = 0; i < niov; i++)
 836                 sgl_count += iov_num_pages(&iov[i]);
 837
 838         /* TODO overflow checking */
 839
 840         sg = cmd->tvc_sgl;
 841         pr_debug("%s sg %p sgl_count %u\n", __func__, sg, sgl_count);
 842         sg_init_table(sg, sgl_count);
 843
 844         cmd->tvc_sgl_count = sgl_count;
 845
 846         pr_debug("Mapping %u iovecs for %u pages\n", niov, sgl_count);
 847         for (i = 0; i < niov; i++) {
 848                 ret = vhost_scsi_map_to_sgl(cmd, sg, sgl_count, &iov[i],
 849                                             write);
 850                 if (ret < 0) {
 851                         for (i = 0; i < cmd->tvc_sgl_count; i++)
 852                                 put_page(sg_page(&cmd->tvc_sgl[i]));
 853
 854                         cmd->tvc_sgl_count = 0;
 855                         return ret;
 856                 }
 857
 858                 sg += ret;
 859                 sgl_count -= ret;
 860         }
 861         return 0;
 862 }
 863
 864 static void tcm_vhost_submission_work(struct work_struct *work)
 865 {
 866         struct tcm_vhost_cmd *cmd =
 867                 container_of(work, struct tcm_vhost_cmd, work);
 868         struct tcm_vhost_nexus *tv_nexus;
 869         struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
 870         struct scatterlist *sg_ptr, *sg_bidi_ptr = NULL;
 871         int rc, sg_no_bidi = 0;
 872
 873         if (cmd->tvc_sgl_count) {
 874                 sg_ptr = cmd->tvc_sgl;
 875 /* FIXME: Fix BIDI operation in tcm_vhost_submission_work() */
 876 #if 0
 877                 if (se_cmd->se_cmd_flags & SCF_BIDI) {
 878                         sg_bidi_ptr = NULL;
 879                         sg_no_bidi = 0;
 880                 }
 881 #endif
 882         } else {
 883                 sg_ptr = NULL;
 884         }
 885         tv_nexus = cmd->tvc_nexus;
 886
 887         rc = target_submit_cmd_map_sgls(se_cmd, tv_nexus->tvn_se_sess,
 888                         cmd->tvc_cdb, &cmd->tvc_sense_buf[0],
 889                         cmd->tvc_lun, cmd->tvc_exp_data_len,
 890                         cmd->tvc_task_attr, cmd->tvc_data_direction,
 891                         TARGET_SCF_ACK_KREF, sg_ptr, cmd->tvc_sgl_count,
 892                         sg_bidi_ptr, sg_no_bidi, NULL, 0);
 893         if (rc < 0) {
 894                 transport_send_check_condition_and_sense(se_cmd,
 895                                 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
 896                 transport_generic_free_cmd(se_cmd, 0);
 897         }
 898 }
 899
 900 static void
 901 vhost_scsi_send_bad_target(struct vhost_scsi *vs,
 902                            struct vhost_virtqueue *vq,
 903                            int head, unsigned out)
 904 {
 905         struct virtio_scsi_cmd_resp __user *resp;
 906         struct virtio_scsi_cmd_resp rsp;
 907         int ret;
 908
 909         memset(&rsp, 0, sizeof(rsp));
 910         rsp.response = VIRTIO_SCSI_S_BAD_TARGET;
 911         resp = vq->iov[out].iov_base;
 912         ret = __copy_to_user(resp, &rsp, sizeof(rsp));
 913         if (!ret)
 914                 vhost_add_used_and_signal(&vs->dev, vq, head, 0);
 915         else
 916                 pr_err("Faulted on virtio_scsi_cmd_resp\n");
 917 }
 918
 919 static void
 920 vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
 921 {
 922         struct tcm_vhost_tpg **vs_tpg;
 923         struct virtio_scsi_cmd_req v_req;
 924         struct tcm_vhost_tpg *tpg;
 925         struct tcm_vhost_cmd *cmd;
 926         u32 exp_data_len, data_first, data_num, data_direction;
 927         unsigned out, in, i;
 928         int head, ret;
 929         u8 target;
 930
 931         mutex_lock(&vq->mutex);
 932         /*
 933          * We can handle the vq only after the endpoint is setup by calling the
 934          * VHOST_SCSI_SET_ENDPOINT ioctl.
 935          */
 936         vs_tpg = vq->private_data;
 937         if (!vs_tpg)
 938                 goto out;
 939
 940         vhost_disable_notify(&vs->dev, vq);
 941
 942         for (;;) {
 943                 head = vhost_get_vq_desc(&vs->dev, vq, vq->iov,
 944                                         ARRAY_SIZE(vq->iov), &out, &in,
 945                                         NULL, NULL);
 946                 pr_debug("vhost_get_vq_desc: head: %d, out: %u in: %u\n",
 947                                         head, out, in);
 948                 /* On error, stop handling until the next kick. */
 949                 if (unlikely(head < 0))
 950                         break;
 951                 /* Nothing new?  Wait for eventfd to tell us they refilled. */
 952                 if (head == vq->num) {
 953                         if (unlikely(vhost_enable_notify(&vs->dev, vq))) {
 954                                 vhost_disable_notify(&vs->dev, vq);
 955                                 continue;
 956                         }
 957                         break;
 958                 }
 959
 960 /* FIXME: BIDI operation */
 961                 if (out == 1 && in == 1) {
 962                         data_direction = DMA_NONE;
 963                         data_first = 0;
 964                         data_num = 0;
 965                 } else if (out == 1 && in > 1) {
 966                         data_direction = DMA_FROM_DEVICE;
 967                         data_first = out + 1;
 968                         data_num = in - 1;
 969                 } else if (out > 1 && in == 1) {
 970                         data_direction = DMA_TO_DEVICE;
 971                         data_first = 1;
 972                         data_num = out - 1;
 973                 } else {
 974                         vq_err(vq, "Invalid buffer layout out: %u in: %u\n",
 975                                         out, in);
 976                         break;
 977                 }
 978
 979                 /*
 980                  * Check for a sane resp buffer so we can report errors to
 981                  * the guest.
 982                  */
 983                 if (unlikely(vq->iov[out].iov_len !=
 984                                         sizeof(struct virtio_scsi_cmd_resp))) {
 985                         vq_err(vq, "Expecting virtio_scsi_cmd_resp, got %zu"
 986                                 " bytes\n", vq->iov[out].iov_len);
 987                         break;
 988                 }
 989
 990                 if (unlikely(vq->iov[0].iov_len != sizeof(v_req))) {
 991                         vq_err(vq, "Expecting virtio_scsi_cmd_req, got %zu"
 992                                 " bytes\n", vq->iov[0].iov_len);
 993                         break;
 994                 }
 995                 pr_debug("Calling __copy_from_user: vq->iov[0].iov_base: %p,"
 996                         " len: %zu\n", vq->iov[0].iov_base, sizeof(v_req));
 997                 ret = __copy_from_user(&v_req, vq->iov[0].iov_base,
 998                                 sizeof(v_req));
 999                 if (unlikely(ret)) {
1000                         vq_err(vq, "Faulted on virtio_scsi_cmd_req\n");
1001                         break;
1002                 }
1003
1004                 /* virtio-scsi spec requires byte 0 of the lun to be 1 */
1005                 if (unlikely(v_req.lun[0] != 1)) {
1006                         vhost_scsi_send_bad_target(vs, vq, head, out);
1007                         continue;
1008                 }
1009
1010                 /* Extract the tpgt */
1011                 target = v_req.lun[1];
1012                 tpg = ACCESS_ONCE(vs_tpg[target]);
1013
1014                 /* Target does not exist, fail the request */
1015                 if (unlikely(!tpg)) {
1016                         vhost_scsi_send_bad_target(vs, vq, head, out);
1017                         continue;
1018                 }
1019
1020                 exp_data_len = 0;
1021                 for (i = 0; i < data_num; i++)
1022                         exp_data_len += vq->iov[data_first + i].iov_len;
1023
1024                 cmd = vhost_scsi_get_tag(vq, tpg, &v_req,
1025                                          exp_data_len, data_direction);
1026                 if (IS_ERR(cmd)) {
1027                         vq_err(vq, "vhost_scsi_get_tag failed %ld\n",
1028                                         PTR_ERR(cmd));
1029                         goto err_cmd;
1030                 }
1031                 pr_debug("Allocated tv_cmd: %p exp_data_len: %d, data_direction"
1032                         ": %d\n", cmd, exp_data_len, data_direction);
1033
1034                 cmd->tvc_vhost = vs;
1035                 cmd->tvc_vq = vq;
1036                 cmd->tvc_resp = vq->iov[out].iov_base;
1037
1038                 /*
1039                  * Copy in the recieved CDB descriptor into cmd->tvc_cdb
1040                  * that will be used by tcm_vhost_new_cmd_map() and down into
1041                  * target_setup_cmd_from_cdb()
1042                  */
1043                 memcpy(cmd->tvc_cdb, v_req.cdb, TCM_VHOST_MAX_CDB_SIZE);
1044                 /*
1045                  * Check that the recieved CDB size does not exceeded our
1046                  * hardcoded max for tcm_vhost
1047                  */
1048                 /* TODO what if cdb was too small for varlen cdb header? */
1049                 if (unlikely(scsi_command_size(cmd->tvc_cdb) >
1050                                         TCM_VHOST_MAX_CDB_SIZE)) {
1051                         vq_err(vq, "Received SCSI CDB with command_size: %d that"
1052                                 " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
1053                                 scsi_command_size(cmd->tvc_cdb),
1054                                 TCM_VHOST_MAX_CDB_SIZE);
1055                         goto err_free;
1056                 }
1057                 cmd->tvc_lun = ((v_req.lun[2] << 8) | v_req.lun[3]) & 0x3FFF;
1058
1059                 pr_debug("vhost_scsi got command opcode: %#02x, lun: %d\n",
1060                         cmd->tvc_cdb[0], cmd->tvc_lun);
1061
1062                 if (data_direction != DMA_NONE) {
1063                         ret = vhost_scsi_map_iov_to_sgl(cmd,
1064                                         &vq->iov[data_first], data_num,
1065                                         data_direction == DMA_FROM_DEVICE);
1066                         if (unlikely(ret)) {
1067                                 vq_err(vq, "Failed to map iov to sgl\n");
1068                                 goto err_free;
1069                         }
1070                 }
1071
1072                 /*
1073                  * Save the descriptor from vhost_get_vq_desc() to be used to
1074                  * complete the virtio-scsi request in TCM callback context via
1075                  * tcm_vhost_queue_data_in() and tcm_vhost_queue_status()
1076                  */
1077                 cmd->tvc_vq_desc = head;
1078                 /*
1079                  * Dispatch tv_cmd descriptor for cmwq execution in process
1080                  * context provided by tcm_vhost_workqueue.  This also ensures
1081                  * tv_cmd is executed on the same kworker CPU as this vhost
1082                  * thread to gain positive L2 cache locality effects..
1083                  */
1084                 INIT_WORK(&cmd->work, tcm_vhost_submission_work);
1085                 queue_work(tcm_vhost_workqueue, &cmd->work);
1086         }
1087
1088         mutex_unlock(&vq->mutex);
1089         return;
1090
1091 err_free:
1092         vhost_scsi_free_cmd(cmd);
1093 err_cmd:
1094         vhost_scsi_send_bad_target(vs, vq, head, out);
1095 out:
1096         mutex_unlock(&vq->mutex);
1097 }
1098
1099 static void vhost_scsi_ctl_handle_kick(struct vhost_work *work)
1100 {
1101         pr_debug("%s: The handling func for control queue.\n", __func__);
1102 }
1103
1104 static void
1105 tcm_vhost_send_evt(struct vhost_scsi *vs,
1106                    struct tcm_vhost_tpg *tpg,
1107                    struct se_lun *lun,
1108                    u32 event,
1109                    u32 reason)
1110 {
1111         struct tcm_vhost_evt *evt;
1112
1113         evt = tcm_vhost_allocate_evt(vs, event, reason);
1114         if (!evt)
1115                 return;
1116
1117         if (tpg && lun) {
1118                 /* TODO: share lun setup code with virtio-scsi.ko */
1119                 /*
1120                  * Note: evt->event is zeroed when we allocate it and
1121                  * lun[4-7] need to be zero according to virtio-scsi spec.
1122                  */
1123                 evt->event.lun[0] = 0x01;
1124                 evt->event.lun[1] = tpg->tport_tpgt & 0xFF;
1125                 if (lun->unpacked_lun >= 256)
1126                         evt->event.lun[2] = lun->unpacked_lun >> 8 | 0x40 ;
1127                 evt->event.lun[3] = lun->unpacked_lun & 0xFF;
1128         }
1129
1130         llist_add(&evt->list, &vs->vs_event_list);
1131         vhost_work_queue(&vs->dev, &vs->vs_event_work);
1132 }
1133
1134 static void vhost_scsi_evt_handle_kick(struct vhost_work *work)
1135 {
1136         struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
1137                                                 poll.work);
1138         struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev);
1139
1140         mutex_lock(&vq->mutex);
1141         if (!vq->private_data)
1142                 goto out;
1143
1144         if (vs->vs_events_missed)
1145                 tcm_vhost_send_evt(vs, NULL, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
1146 out:
1147         mutex_unlock(&vq->mutex);
1148 }
1149
1150 static void vhost_scsi_handle_kick(struct vhost_work *work)
1151 {
1152         struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
1153                                                 poll.work);
1154         struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev);
1155
1156         vhost_scsi_handle_vq(vs, vq);
1157 }
1158
1159 static void vhost_scsi_flush_vq(struct vhost_scsi *vs, int index)
1160 {
1161         vhost_poll_flush(&vs->vqs[index].vq.poll);
1162 }
1163
1164 /* Callers must hold dev mutex */
1165 static void vhost_scsi_flush(struct vhost_scsi *vs)
1166 {
1167         struct vhost_scsi_inflight *old_inflight[VHOST_SCSI_MAX_VQ];
1168         int i;
1169
1170         /* Init new inflight and remember the old inflight */
1171         tcm_vhost_init_inflight(vs, old_inflight);
1172
1173         /*
1174          * The inflight->kref was initialized to 1. We decrement it here to
1175          * indicate the start of the flush operation so that it will reach 0
1176          * when all the reqs are finished.
1177          */
1178         for (i = 0; i < VHOST_SCSI_MAX_VQ; i++)
1179                 kref_put(&old_inflight[i]->kref, tcm_vhost_done_inflight);
1180
1181         /* Flush both the vhost poll and vhost work */
1182         for (i = 0; i < VHOST_SCSI_MAX_VQ; i++)
1183                 vhost_scsi_flush_vq(vs, i);
1184         vhost_work_flush(&vs->dev, &vs->vs_completion_work);
1185         vhost_work_flush(&vs->dev, &vs->vs_event_work);
1186
1187         /* Wait for all reqs issued before the flush to be finished */
1188         for (i = 0; i < VHOST_SCSI_MAX_VQ; i++)
1189                 wait_for_completion(&old_inflight[i]->comp);
1190 }
1191
1192 /*
1193  * Called from vhost_scsi_ioctl() context to walk the list of available
1194  * tcm_vhost_tpg with an active struct tcm_vhost_nexus
1195  *
1196  *  The lock nesting rule is:
1197  *    tcm_vhost_mutex -> vs->dev.mutex -> tpg->tv_tpg_mutex -> vq->mutex
1198  */
1199 static int
1200 vhost_scsi_set_endpoint(struct vhost_scsi *vs,
1201                         struct vhost_scsi_target *t)
1202 {
1203         struct se_portal_group *se_tpg;
1204         struct tcm_vhost_tport *tv_tport;
1205         struct tcm_vhost_tpg *tpg;
1206         struct tcm_vhost_tpg **vs_tpg;
1207         struct vhost_virtqueue *vq;
1208         int index, ret, i, len;
1209         bool match = false;
1210
1211         mutex_lock(&tcm_vhost_mutex);
1212         mutex_lock(&vs->dev.mutex);
1213
1214         /* Verify that ring has been setup correctly. */
1215         for (index = 0; index < vs->dev.nvqs; ++index) {
1216                 /* Verify that ring has been setup correctly. */
1217                 if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
1218                         ret = -EFAULT;
1219                         goto out;
1220                 }
1221         }
1222
1223         len = sizeof(vs_tpg[0]) * VHOST_SCSI_MAX_TARGET;
1224         vs_tpg = kzalloc(len, GFP_KERNEL);
1225         if (!vs_tpg) {
1226                 ret = -ENOMEM;
1227                 goto out;
1228         }
1229         if (vs->vs_tpg)
1230                 memcpy(vs_tpg, vs->vs_tpg, len);
1231
1232         list_for_each_entry(tpg, &tcm_vhost_list, tv_tpg_list) {
1233                 mutex_lock(&tpg->tv_tpg_mutex);
1234                 if (!tpg->tpg_nexus) {
1235                         mutex_unlock(&tpg->tv_tpg_mutex);
1236                         continue;
1237                 }
1238                 if (tpg->tv_tpg_vhost_count != 0) {
1239                         mutex_unlock(&tpg->tv_tpg_mutex);
1240                         continue;
1241                 }
1242                 tv_tport = tpg->tport;
1243
1244                 if (!strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
1245                         if (vs->vs_tpg && vs->vs_tpg[tpg->tport_tpgt]) {
1246                                 kfree(vs_tpg);
1247                                 mutex_unlock(&tpg->tv_tpg_mutex);
1248                                 ret = -EEXIST;
1249                                 goto out;
1250                         }
1251                         /*
1252                          * In order to ensure individual vhost-scsi configfs
1253                          * groups cannot be removed while in use by vhost ioctl,
1254                          * go ahead and take an explicit se_tpg->tpg_group.cg_item
1255                          * dependency now.
1256                          */
1257                         se_tpg = &tpg->se_tpg;
1258                         ret = configfs_depend_item(se_tpg->se_tpg_tfo->tf_subsys,
1259                                                    &se_tpg->tpg_group.cg_item);
1260                         if (ret) {
1261                                 pr_warn("configfs_depend_item() failed: %d\n", ret);
1262                                 kfree(vs_tpg);
1263                                 mutex_unlock(&tpg->tv_tpg_mutex);
1264                                 goto out;
1265                         }
1266                         tpg->tv_tpg_vhost_count++;
1267                         tpg->vhost_scsi = vs;
1268                         vs_tpg[tpg->tport_tpgt] = tpg;
1269                         smp_mb__after_atomic_inc();
1270                         match = true;
1271                 }
1272                 mutex_unlock(&tpg->tv_tpg_mutex);
1273         }
1274
1275         if (match) {
1276                 memcpy(vs->vs_vhost_wwpn, t->vhost_wwpn,
1277                        sizeof(vs->vs_vhost_wwpn));
1278                 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
1279                         vq = &vs->vqs[i].vq;
1280                         mutex_lock(&vq->mutex);
1281                         vq->private_data = vs_tpg;
1282                         vhost_init_used(vq);
1283                         mutex_unlock(&vq->mutex);
1284                 }
1285                 ret = 0;
1286         } else {
1287                 ret = -EEXIST;
1288         }
1289
1290         /*
1291          * Act as synchronize_rcu to make sure access to
1292          * old vs->vs_tpg is finished.
1293          */
1294         vhost_scsi_flush(vs);
1295         kfree(vs->vs_tpg);
1296         vs->vs_tpg = vs_tpg;
1297
1298 out:
1299         mutex_unlock(&vs->dev.mutex);
1300         mutex_unlock(&tcm_vhost_mutex);
1301         return ret;
1302 }
1303
1304 static int
1305 vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
1306                           struct vhost_scsi_target *t)
1307 {
1308         struct se_portal_group *se_tpg;
1309         struct tcm_vhost_tport *tv_tport;
1310         struct tcm_vhost_tpg *tpg;
1311         struct vhost_virtqueue *vq;
1312         bool match = false;
1313         int index, ret, i;
1314         u8 target;
1315
1316         mutex_lock(&tcm_vhost_mutex);
1317         mutex_lock(&vs->dev.mutex);
1318         /* Verify that ring has been setup correctly. */
1319         for (index = 0; index < vs->dev.nvqs; ++index) {
1320                 if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
1321                         ret = -EFAULT;
1322                         goto err_dev;
1323                 }
1324         }
1325
1326         if (!vs->vs_tpg) {
1327                 ret = 0;
1328                 goto err_dev;
1329         }
1330
1331         for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
1332                 target = i;
1333                 tpg = vs->vs_tpg[target];
1334                 if (!tpg)
1335                         continue;
1336
1337                 mutex_lock(&tpg->tv_tpg_mutex);
1338                 tv_tport = tpg->tport;
1339                 if (!tv_tport) {
1340                         ret = -ENODEV;
1341                         goto err_tpg;
1342                 }
1343
1344                 if (strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
1345                         pr_warn("tv_tport->tport_name: %s, tpg->tport_tpgt: %hu"
1346                                 " does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
1347                                 tv_tport->tport_name, tpg->tport_tpgt,
1348                                 t->vhost_wwpn, t->vhost_tpgt);
1349                         ret = -EINVAL;
1350                         goto err_tpg;
1351                 }
1352                 tpg->tv_tpg_vhost_count--;
1353                 tpg->vhost_scsi = NULL;
1354                 vs->vs_tpg[target] = NULL;
1355                 match = true;
1356                 mutex_unlock(&tpg->tv_tpg_mutex);
1357                 /*
1358                  * Release se_tpg->tpg_group.cg_item configfs dependency now
1359                  * to allow vhost-scsi WWPN se_tpg->tpg_group shutdown to occur.
1360                  */
1361                 se_tpg = &tpg->se_tpg;
1362                 configfs_undepend_item(se_tpg->se_tpg_tfo->tf_subsys,
1363                                        &se_tpg->tpg_group.cg_item);
1364         }
1365         if (match) {
1366                 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
1367                         vq = &vs->vqs[i].vq;
1368                         mutex_lock(&vq->mutex);
1369                         vq->private_data = NULL;
1370                         mutex_unlock(&vq->mutex);
1371                 }
1372         }
1373         /*
1374          * Act as synchronize_rcu to make sure access to
1375          * old vs->vs_tpg is finished.
1376          */
1377         vhost_scsi_flush(vs);
1378         kfree(vs->vs_tpg);
1379         vs->vs_tpg = NULL;
1380         WARN_ON(vs->vs_events_nr);
1381         mutex_unlock(&vs->dev.mutex);
1382         mutex_unlock(&tcm_vhost_mutex);
1383         return 0;
1384
1385 err_tpg:
1386         mutex_unlock(&tpg->tv_tpg_mutex);
1387 err_dev:
1388         mutex_unlock(&vs->dev.mutex);
1389         mutex_unlock(&tcm_vhost_mutex);
1390         return ret;
1391 }
1392
1393 static int vhost_scsi_set_features(struct vhost_scsi *vs, u64 features)
1394 {
1395         if (features & ~VHOST_SCSI_FEATURES)
1396                 return -EOPNOTSUPP;
1397
1398         mutex_lock(&vs->dev.mutex);
1399         if ((features & (1 << VHOST_F_LOG_ALL)) &&
1400             !vhost_log_access_ok(&vs->dev)) {
1401                 mutex_unlock(&vs->dev.mutex);
1402                 return -EFAULT;
1403         }
1404         vs->dev.acked_features = features;
1405         smp_wmb();
1406         vhost_scsi_flush(vs);
1407         mutex_unlock(&vs->dev.mutex);
1408         return 0;
1409 }
1410
1411 static void vhost_scsi_free(struct vhost_scsi *vs)
1412 {
1413         if (is_vmalloc_addr(vs))
1414                 vfree(vs);
1415         else
1416                 kfree(vs);
1417 }
1418
1419 static int vhost_scsi_open(struct inode *inode, struct file *f)
1420 {
1421         struct vhost_scsi *vs;
1422         struct vhost_virtqueue **vqs;
1423         int r = -ENOMEM, i;
1424
1425         vs = kzalloc(sizeof(*vs), GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
1426         if (!vs) {
1427                 vs = vzalloc(sizeof(*vs));
1428                 if (!vs)
1429                         goto err_vs;
1430         }
1431
1432         vqs = kmalloc(VHOST_SCSI_MAX_VQ * sizeof(*vqs), GFP_KERNEL);
1433         if (!vqs)
1434                 goto err_vqs;
1435
1436         vhost_work_init(&vs->vs_completion_work, vhost_scsi_complete_cmd_work);
1437         vhost_work_init(&vs->vs_event_work, tcm_vhost_evt_work);
1438
1439         vs->vs_events_nr = 0;
1440         vs->vs_events_missed = false;
1441
1442         vqs[VHOST_SCSI_VQ_CTL] = &vs->vqs[VHOST_SCSI_VQ_CTL].vq;
1443         vqs[VHOST_SCSI_VQ_EVT] = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1444         vs->vqs[VHOST_SCSI_VQ_CTL].vq.handle_kick = vhost_scsi_ctl_handle_kick;
1445         vs->vqs[VHOST_SCSI_VQ_EVT].vq.handle_kick = vhost_scsi_evt_handle_kick;
1446         for (i = VHOST_SCSI_VQ_IO; i < VHOST_SCSI_MAX_VQ; i++) {
1447                 vqs[i] = &vs->vqs[i].vq;
1448                 vs->vqs[i].vq.handle_kick = vhost_scsi_handle_kick;
1449         }
1450         vhost_dev_init(&vs->dev, vqs, VHOST_SCSI_MAX_VQ);
1451
1452         tcm_vhost_init_inflight(vs, NULL);
1453
1454         f->private_data = vs;
1455         return 0;
1456
1457 err_vqs:
1458         vhost_scsi_free(vs);
1459 err_vs:
1460         return r;
1461 }
1462
1463 static int vhost_scsi_release(struct inode *inode, struct file *f)
1464 {
1465         struct vhost_scsi *vs = f->private_data;
1466         struct vhost_scsi_target t;
1467
1468         mutex_lock(&vs->dev.mutex);
1469         memcpy(t.vhost_wwpn, vs->vs_vhost_wwpn, sizeof(t.vhost_wwpn));
1470         mutex_unlock(&vs->dev.mutex);
1471         vhost_scsi_clear_endpoint(vs, &t);
1472         vhost_dev_stop(&vs->dev);
1473         vhost_dev_cleanup(&vs->dev, false);
1474         /* Jobs can re-queue themselves in evt kick handler. Do extra flush. */
1475         vhost_scsi_flush(vs);
1476         kfree(vs->dev.vqs);
1477         vhost_scsi_free(vs);
1478         return 0;
1479 }
1480
1481 static long
1482 vhost_scsi_ioctl(struct file *f,
1483                  unsigned int ioctl,
1484                  unsigned long arg)
1485 {
1486         struct vhost_scsi *vs = f->private_data;
1487         struct vhost_scsi_target backend;
1488         void __user *argp = (void __user *)arg;
1489         u64 __user *featurep = argp;
1490         u32 __user *eventsp = argp;
1491         u32 events_missed;
1492         u64 features;
1493         int r, abi_version = VHOST_SCSI_ABI_VERSION;
1494         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1495
1496         switch (ioctl) {
1497         case VHOST_SCSI_SET_ENDPOINT:
1498                 if (copy_from_user(&backend, argp, sizeof backend))
1499                         return -EFAULT;
1500                 if (backend.reserved != 0)
1501                         return -EOPNOTSUPP;
1502
1503                 return vhost_scsi_set_endpoint(vs, &backend);
1504         case VHOST_SCSI_CLEAR_ENDPOINT:
1505                 if (copy_from_user(&backend, argp, sizeof backend))
1506                         return -EFAULT;
1507                 if (backend.reserved != 0)
1508                         return -EOPNOTSUPP;
1509
1510                 return vhost_scsi_clear_endpoint(vs, &backend);
1511         case VHOST_SCSI_GET_ABI_VERSION:
1512                 if (copy_to_user(argp, &abi_version, sizeof abi_version))
1513                         return -EFAULT;
1514                 return 0;
1515         case VHOST_SCSI_SET_EVENTS_MISSED:
1516                 if (get_user(events_missed, eventsp))
1517                         return -EFAULT;
1518                 mutex_lock(&vq->mutex);
1519                 vs->vs_events_missed = events_missed;
1520                 mutex_unlock(&vq->mutex);
1521                 return 0;
1522         case VHOST_SCSI_GET_EVENTS_MISSED:
1523                 mutex_lock(&vq->mutex);
1524                 events_missed = vs->vs_events_missed;
1525                 mutex_unlock(&vq->mutex);
1526                 if (put_user(events_missed, eventsp))
1527                         return -EFAULT;
1528                 return 0;
1529         case VHOST_GET_FEATURES:
1530                 features = VHOST_SCSI_FEATURES;
1531                 if (copy_to_user(featurep, &features, sizeof features))
1532                         return -EFAULT;
1533                 return 0;
1534         case VHOST_SET_FEATURES:
1535                 if (copy_from_user(&features, featurep, sizeof features))
1536                         return -EFAULT;
1537                 return vhost_scsi_set_features(vs, features);
1538         default:
1539                 mutex_lock(&vs->dev.mutex);
1540                 r = vhost_dev_ioctl(&vs->dev, ioctl, argp);
1541                 /* TODO: flush backend after dev ioctl. */
1542                 if (r == -ENOIOCTLCMD)
1543                         r = vhost_vring_ioctl(&vs->dev, ioctl, argp);
1544                 mutex_unlock(&vs->dev.mutex);
1545                 return r;
1546         }
1547 }
1548
1549 #ifdef CONFIG_COMPAT
1550 static long vhost_scsi_compat_ioctl(struct file *f, unsigned int ioctl,
1551                                 unsigned long arg)
1552 {
1553         return vhost_scsi_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
1554 }
1555 #endif
1556
1557 static const struct file_operations vhost_scsi_fops = {
1558         .owner          = THIS_MODULE,
1559         .release        = vhost_scsi_release,
1560         .unlocked_ioctl = vhost_scsi_ioctl,
1561 #ifdef CONFIG_COMPAT
1562         .compat_ioctl   = vhost_scsi_compat_ioctl,
1563 #endif
1564         .open           = vhost_scsi_open,
1565         .llseek         = noop_llseek,
1566 };
1567
1568 static struct miscdevice vhost_scsi_misc = {
1569         MISC_DYNAMIC_MINOR,
1570         "vhost-scsi",
1571         &vhost_scsi_fops,
1572 };
1573
1574 static int __init vhost_scsi_register(void)
1575 {
1576         return misc_register(&vhost_scsi_misc);
1577 }
1578
1579 static int vhost_scsi_deregister(void)
1580 {
1581         return misc_deregister(&vhost_scsi_misc);
1582 }
1583
1584 static char *tcm_vhost_dump_proto_id(struct tcm_vhost_tport *tport)
1585 {
1586         switch (tport->tport_proto_id) {
1587         case SCSI_PROTOCOL_SAS:
1588                 return "SAS";
1589         case SCSI_PROTOCOL_FCP:
1590                 return "FCP";
1591         case SCSI_PROTOCOL_ISCSI:
1592                 return "iSCSI";
1593         default:
1594                 break;
1595         }
1596
1597         return "Unknown";
1598 }
1599
1600 static void
1601 tcm_vhost_do_plug(struct tcm_vhost_tpg *tpg,
1602                   struct se_lun *lun, bool plug)
1603 {
1604
1605         struct vhost_scsi *vs = tpg->vhost_scsi;
1606         struct vhost_virtqueue *vq;
1607         u32 reason;
1608
1609         if (!vs)
1610                 return;
1611
1612         mutex_lock(&vs->dev.mutex);
1613         if (!vhost_has_feature(&vs->dev, VIRTIO_SCSI_F_HOTPLUG)) {
1614                 mutex_unlock(&vs->dev.mutex);
1615                 return;
1616         }
1617
1618         if (plug)
1619                 reason = VIRTIO_SCSI_EVT_RESET_RESCAN;
1620         else
1621                 reason = VIRTIO_SCSI_EVT_RESET_REMOVED;
1622
1623         vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1624         mutex_lock(&vq->mutex);
1625         tcm_vhost_send_evt(vs, tpg, lun,
1626                         VIRTIO_SCSI_T_TRANSPORT_RESET, reason);
1627         mutex_unlock(&vq->mutex);
1628         mutex_unlock(&vs->dev.mutex);
1629 }
1630
1631 static void tcm_vhost_hotplug(struct tcm_vhost_tpg *tpg, struct se_lun *lun)
1632 {
1633         tcm_vhost_do_plug(tpg, lun, true);
1634 }
1635
1636 static void tcm_vhost_hotunplug(struct tcm_vhost_tpg *tpg, struct se_lun *lun)
1637 {
1638         tcm_vhost_do_plug(tpg, lun, false);
1639 }
1640
1641 static int tcm_vhost_port_link(struct se_portal_group *se_tpg,
1642                                struct se_lun *lun)
1643 {
1644         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1645                                 struct tcm_vhost_tpg, se_tpg);
1646
1647         mutex_lock(&tcm_vhost_mutex);
1648
1649         mutex_lock(&tpg->tv_tpg_mutex);
1650         tpg->tv_tpg_port_count++;
1651         mutex_unlock(&tpg->tv_tpg_mutex);
1652
1653         tcm_vhost_hotplug(tpg, lun);
1654
1655         mutex_unlock(&tcm_vhost_mutex);
1656
1657         return 0;
1658 }
1659
1660 static void tcm_vhost_port_unlink(struct se_portal_group *se_tpg,
1661                                   struct se_lun *lun)
1662 {
1663         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1664                                 struct tcm_vhost_tpg, se_tpg);
1665
1666         mutex_lock(&tcm_vhost_mutex);
1667
1668         mutex_lock(&tpg->tv_tpg_mutex);
1669         tpg->tv_tpg_port_count--;
1670         mutex_unlock(&tpg->tv_tpg_mutex);
1671
1672         tcm_vhost_hotunplug(tpg, lun);
1673
1674         mutex_unlock(&tcm_vhost_mutex);
1675 }
1676
1677 static struct se_node_acl *
1678 tcm_vhost_make_nodeacl(struct se_portal_group *se_tpg,
1679                        struct config_group *group,
1680                        const char *name)
1681 {
1682         struct se_node_acl *se_nacl, *se_nacl_new;
1683         struct tcm_vhost_nacl *nacl;
1684         u64 wwpn = 0;
1685         u32 nexus_depth;
1686
1687         /* tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
1688                 return ERR_PTR(-EINVAL); */
1689         se_nacl_new = tcm_vhost_alloc_fabric_acl(se_tpg);
1690         if (!se_nacl_new)
1691                 return ERR_PTR(-ENOMEM);
1692
1693         nexus_depth = 1;
1694         /*
1695          * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
1696          * when converting a NodeACL from demo mode -> explict
1697          */
1698         se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
1699                                 name, nexus_depth);
1700         if (IS_ERR(se_nacl)) {
1701                 tcm_vhost_release_fabric_acl(se_tpg, se_nacl_new);
1702                 return se_nacl;
1703         }
1704         /*
1705          * Locate our struct tcm_vhost_nacl and set the FC Nport WWPN
1706          */
1707         nacl = container_of(se_nacl, struct tcm_vhost_nacl, se_node_acl);
1708         nacl->iport_wwpn = wwpn;
1709
1710         return se_nacl;
1711 }
1712
1713 static void tcm_vhost_drop_nodeacl(struct se_node_acl *se_acl)
1714 {
1715         struct tcm_vhost_nacl *nacl = container_of(se_acl,
1716                                 struct tcm_vhost_nacl, se_node_acl);
1717         core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
1718         kfree(nacl);
1719 }
1720
1721 static void tcm_vhost_free_cmd_map_res(struct tcm_vhost_nexus *nexus,
1722                                        struct se_session *se_sess)
1723 {
1724         struct tcm_vhost_cmd *tv_cmd;
1725         unsigned int i;
1726
1727         if (!se_sess->sess_cmd_map)
1728                 return;
1729
1730         for (i = 0; i < TCM_VHOST_DEFAULT_TAGS; i++) {
1731                 tv_cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[i];
1732
1733                 kfree(tv_cmd->tvc_sgl);
1734                 kfree(tv_cmd->tvc_upages);
1735         }
1736 }
1737
1738 static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
1739                                 const char *name)
1740 {
1741         struct se_portal_group *se_tpg;
1742         struct se_session *se_sess;
1743         struct tcm_vhost_nexus *tv_nexus;
1744         struct tcm_vhost_cmd *tv_cmd;
1745         unsigned int i;
1746
1747         mutex_lock(&tpg->tv_tpg_mutex);
1748         if (tpg->tpg_nexus) {
1749                 mutex_unlock(&tpg->tv_tpg_mutex);
1750                 pr_debug("tpg->tpg_nexus already exists\n");
1751                 return -EEXIST;
1752         }
1753         se_tpg = &tpg->se_tpg;
1754
1755         tv_nexus = kzalloc(sizeof(struct tcm_vhost_nexus), GFP_KERNEL);
1756         if (!tv_nexus) {
1757                 mutex_unlock(&tpg->tv_tpg_mutex);
1758                 pr_err("Unable to allocate struct tcm_vhost_nexus\n");
1759                 return -ENOMEM;
1760         }
1761         /*
1762          *  Initialize the struct se_session pointer and setup tagpool
1763          *  for struct tcm_vhost_cmd descriptors
1764          */
1765         tv_nexus->tvn_se_sess = transport_init_session_tags(
1766                                         TCM_VHOST_DEFAULT_TAGS,
1767                                         sizeof(struct tcm_vhost_cmd));
1768         if (IS_ERR(tv_nexus->tvn_se_sess)) {
1769                 mutex_unlock(&tpg->tv_tpg_mutex);
1770                 kfree(tv_nexus);
1771                 return -ENOMEM;
1772         }
1773         se_sess = tv_nexus->tvn_se_sess;
1774         for (i = 0; i < TCM_VHOST_DEFAULT_TAGS; i++) {
1775                 tv_cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[i];
1776
1777                 tv_cmd->tvc_sgl = kzalloc(sizeof(struct scatterlist) *
1778                                         TCM_VHOST_PREALLOC_SGLS, GFP_KERNEL);
1779                 if (!tv_cmd->tvc_sgl) {
1780                         mutex_unlock(&tpg->tv_tpg_mutex);
1781                         pr_err("Unable to allocate tv_cmd->tvc_sgl\n");
1782                         goto out;
1783                 }
1784
1785                 tv_cmd->tvc_upages = kzalloc(sizeof(struct page *) *
1786                                         TCM_VHOST_PREALLOC_PAGES, GFP_KERNEL);
1787                 if (!tv_cmd->tvc_upages) {
1788                         mutex_unlock(&tpg->tv_tpg_mutex);
1789                         pr_err("Unable to allocate tv_cmd->tvc_upages\n");
1790                         goto out;
1791                 }
1792         }
1793         /*
1794          * Since we are running in 'demo mode' this call with generate a
1795          * struct se_node_acl for the tcm_vhost struct se_portal_group with
1796          * the SCSI Initiator port name of the passed configfs group 'name'.
1797          */
1798         tv_nexus->tvn_se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
1799                                 se_tpg, (unsigned char *)name);
1800         if (!tv_nexus->tvn_se_sess->se_node_acl) {
1801                 mutex_unlock(&tpg->tv_tpg_mutex);
1802                 pr_debug("core_tpg_check_initiator_node_acl() failed"
1803                                 " for %s\n", name);
1804                 goto out;
1805         }
1806         /*
1807          * Now register the TCM vhost virtual I_T Nexus as active with the
1808          * call to __transport_register_session()
1809          */
1810         __transport_register_session(se_tpg, tv_nexus->tvn_se_sess->se_node_acl,
1811                         tv_nexus->tvn_se_sess, tv_nexus);
1812         tpg->tpg_nexus = tv_nexus;
1813
1814         mutex_unlock(&tpg->tv_tpg_mutex);
1815         return 0;
1816
1817 out:
1818         tcm_vhost_free_cmd_map_res(tv_nexus, se_sess);
1819         transport_free_session(se_sess);
1820         kfree(tv_nexus);
1821         return -ENOMEM;
1822 }
1823
1824 static int tcm_vhost_drop_nexus(struct tcm_vhost_tpg *tpg)
1825 {
1826         struct se_session *se_sess;
1827         struct tcm_vhost_nexus *tv_nexus;
1828
1829         mutex_lock(&tpg->tv_tpg_mutex);
1830         tv_nexus = tpg->tpg_nexus;
1831         if (!tv_nexus) {
1832                 mutex_unlock(&tpg->tv_tpg_mutex);
1833                 return -ENODEV;
1834         }
1835
1836         se_sess = tv_nexus->tvn_se_sess;
1837         if (!se_sess) {
1838                 mutex_unlock(&tpg->tv_tpg_mutex);
1839                 return -ENODEV;
1840         }
1841
1842         if (tpg->tv_tpg_port_count != 0) {
1843                 mutex_unlock(&tpg->tv_tpg_mutex);
1844                 pr_err("Unable to remove TCM_vhost I_T Nexus with"
1845                         " active TPG port count: %d\n",
1846                         tpg->tv_tpg_port_count);
1847                 return -EBUSY;
1848         }
1849
1850         if (tpg->tv_tpg_vhost_count != 0) {
1851                 mutex_unlock(&tpg->tv_tpg_mutex);
1852                 pr_err("Unable to remove TCM_vhost I_T Nexus with"
1853                         " active TPG vhost count: %d\n",
1854                         tpg->tv_tpg_vhost_count);
1855                 return -EBUSY;
1856         }
1857
1858         pr_debug("TCM_vhost_ConfigFS: Removing I_T Nexus to emulated"
1859                 " %s Initiator Port: %s\n", tcm_vhost_dump_proto_id(tpg->tport),
1860                 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
1861
1862         tcm_vhost_free_cmd_map_res(tv_nexus, se_sess);
1863         /*
1864          * Release the SCSI I_T Nexus to the emulated vhost Target Port
1865          */
1866         transport_deregister_session(tv_nexus->tvn_se_sess);
1867         tpg->tpg_nexus = NULL;
1868         mutex_unlock(&tpg->tv_tpg_mutex);
1869
1870         kfree(tv_nexus);
1871         return 0;
1872 }
1873
1874 static ssize_t tcm_vhost_tpg_show_nexus(struct se_portal_group *se_tpg,
1875                                         char *page)
1876 {
1877         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1878                                 struct tcm_vhost_tpg, se_tpg);
1879         struct tcm_vhost_nexus *tv_nexus;
1880         ssize_t ret;
1881
1882         mutex_lock(&tpg->tv_tpg_mutex);
1883         tv_nexus = tpg->tpg_nexus;
1884         if (!tv_nexus) {
1885                 mutex_unlock(&tpg->tv_tpg_mutex);
1886                 return -ENODEV;
1887         }
1888         ret = snprintf(page, PAGE_SIZE, "%s\n",
1889                         tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
1890         mutex_unlock(&tpg->tv_tpg_mutex);
1891
1892         return ret;
1893 }
1894
1895 static ssize_t tcm_vhost_tpg_store_nexus(struct se_portal_group *se_tpg,
1896                                          const char *page,
1897                                          size_t count)
1898 {
1899         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1900                                 struct tcm_vhost_tpg, se_tpg);
1901         struct tcm_vhost_tport *tport_wwn = tpg->tport;
1902         unsigned char i_port[TCM_VHOST_NAMELEN], *ptr, *port_ptr;
1903         int ret;
1904         /*
1905          * Shutdown the active I_T nexus if 'NULL' is passed..
1906          */
1907         if (!strncmp(page, "NULL", 4)) {
1908                 ret = tcm_vhost_drop_nexus(tpg);
1909                 return (!ret) ? count : ret;
1910         }
1911         /*
1912          * Otherwise make sure the passed virtual Initiator port WWN matches
1913          * the fabric protocol_id set in tcm_vhost_make_tport(), and call
1914          * tcm_vhost_make_nexus().
1915          */
1916         if (strlen(page) >= TCM_VHOST_NAMELEN) {
1917                 pr_err("Emulated NAA Sas Address: %s, exceeds"
1918                                 " max: %d\n", page, TCM_VHOST_NAMELEN);
1919                 return -EINVAL;
1920         }
1921         snprintf(&i_port[0], TCM_VHOST_NAMELEN, "%s", page);
1922
1923         ptr = strstr(i_port, "naa.");
1924         if (ptr) {
1925                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_SAS) {
1926                         pr_err("Passed SAS Initiator Port %s does not"
1927                                 " match target port protoid: %s\n", i_port,
1928                                 tcm_vhost_dump_proto_id(tport_wwn));
1929                         return -EINVAL;
1930                 }
1931                 port_ptr = &i_port[0];
1932                 goto check_newline;
1933         }
1934         ptr = strstr(i_port, "fc.");
1935         if (ptr) {
1936                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_FCP) {
1937                         pr_err("Passed FCP Initiator Port %s does not"
1938                                 " match target port protoid: %s\n", i_port,
1939                                 tcm_vhost_dump_proto_id(tport_wwn));
1940                         return -EINVAL;
1941                 }
1942                 port_ptr = &i_port[3]; /* Skip over "fc." */
1943                 goto check_newline;
1944         }
1945         ptr = strstr(i_port, "iqn.");
1946         if (ptr) {
1947                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_ISCSI) {
1948                         pr_err("Passed iSCSI Initiator Port %s does not"
1949                                 " match target port protoid: %s\n", i_port,
1950                                 tcm_vhost_dump_proto_id(tport_wwn));
1951                         return -EINVAL;
1952                 }
1953                 port_ptr = &i_port[0];
1954                 goto check_newline;
1955         }
1956         pr_err("Unable to locate prefix for emulated Initiator Port:"
1957                         " %s\n", i_port);
1958         return -EINVAL;
1959         /*
1960          * Clear any trailing newline for the NAA WWN
1961          */
1962 check_newline:
1963         if (i_port[strlen(i_port)-1] == '\n')
1964                 i_port[strlen(i_port)-1] = '\0';
1965
1966         ret = tcm_vhost_make_nexus(tpg, port_ptr);
1967         if (ret < 0)
1968                 return ret;
1969
1970         return count;
1971 }
1972
1973 TF_TPG_BASE_ATTR(tcm_vhost, nexus, S_IRUGO | S_IWUSR);
1974
1975 static struct configfs_attribute *tcm_vhost_tpg_attrs[] = {
1976         &tcm_vhost_tpg_nexus.attr,
1977         NULL,
1978 };
1979
1980 static struct se_portal_group *
1981 tcm_vhost_make_tpg(struct se_wwn *wwn,
1982                    struct config_group *group,
1983                    const char *name)
1984 {
1985         struct tcm_vhost_tport *tport = container_of(wwn,
1986                         struct tcm_vhost_tport, tport_wwn);
1987
1988         struct tcm_vhost_tpg *tpg;
1989         unsigned long tpgt;
1990         int ret;
1991
1992         if (strstr(name, "tpgt_") != name)
1993                 return ERR_PTR(-EINVAL);
1994         if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
1995                 return ERR_PTR(-EINVAL);
1996
1997         tpg = kzalloc(sizeof(struct tcm_vhost_tpg), GFP_KERNEL);
1998         if (!tpg) {
1999                 pr_err("Unable to allocate struct tcm_vhost_tpg");
2000                 return ERR_PTR(-ENOMEM);
2001         }
2002         mutex_init(&tpg->tv_tpg_mutex);
2003         INIT_LIST_HEAD(&tpg->tv_tpg_list);
2004         tpg->tport = tport;
2005         tpg->tport_tpgt = tpgt;
2006
2007         ret = core_tpg_register(&tcm_vhost_fabric_configfs->tf_ops, wwn,
2008                                 &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
2009         if (ret < 0) {
2010                 kfree(tpg);
2011                 return NULL;
2012         }
2013         mutex_lock(&tcm_vhost_mutex);
2014         list_add_tail(&tpg->tv_tpg_list, &tcm_vhost_list);
2015         mutex_unlock(&tcm_vhost_mutex);
2016
2017         return &tpg->se_tpg;
2018 }
2019
2020 static void tcm_vhost_drop_tpg(struct se_portal_group *se_tpg)
2021 {
2022         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
2023                                 struct tcm_vhost_tpg, se_tpg);
2024
2025         mutex_lock(&tcm_vhost_mutex);
2026         list_del(&tpg->tv_tpg_list);
2027         mutex_unlock(&tcm_vhost_mutex);
2028         /*
2029          * Release the virtual I_T Nexus for this vhost TPG
2030          */
2031         tcm_vhost_drop_nexus(tpg);
2032         /*
2033          * Deregister the se_tpg from TCM..
2034          */
2035         core_tpg_deregister(se_tpg);
2036         kfree(tpg);
2037 }
2038
2039 static struct se_wwn *
2040 tcm_vhost_make_tport(struct target_fabric_configfs *tf,
2041                      struct config_group *group,
2042                      const char *name)
2043 {
2044         struct tcm_vhost_tport *tport;
2045         char *ptr;
2046         u64 wwpn = 0;
2047         int off = 0;
2048
2049         /* if (tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
2050                 return ERR_PTR(-EINVAL); */
2051
2052         tport = kzalloc(sizeof(struct tcm_vhost_tport), GFP_KERNEL);
2053         if (!tport) {
2054                 pr_err("Unable to allocate struct tcm_vhost_tport");
2055                 return ERR_PTR(-ENOMEM);
2056         }
2057         tport->tport_wwpn = wwpn;
2058         /*
2059          * Determine the emulated Protocol Identifier and Target Port Name
2060          * based on the incoming configfs directory name.
2061          */
2062         ptr = strstr(name, "naa.");
2063         if (ptr) {
2064                 tport->tport_proto_id = SCSI_PROTOCOL_SAS;
2065                 goto check_len;
2066         }
2067         ptr = strstr(name, "fc.");
2068         if (ptr) {
2069                 tport->tport_proto_id = SCSI_PROTOCOL_FCP;
2070                 off = 3; /* Skip over "fc." */
2071                 goto check_len;
2072         }
2073         ptr = strstr(name, "iqn.");
2074         if (ptr) {
2075                 tport->tport_proto_id = SCSI_PROTOCOL_ISCSI;
2076                 goto check_len;
2077         }
2078
2079         pr_err("Unable to locate prefix for emulated Target Port:"
2080                         " %s\n", name);
2081         kfree(tport);
2082         return ERR_PTR(-EINVAL);
2083
2084 check_len:
2085         if (strlen(name) >= TCM_VHOST_NAMELEN) {
2086                 pr_err("Emulated %s Address: %s, exceeds"
2087                         " max: %d\n", name, tcm_vhost_dump_proto_id(tport),
2088                         TCM_VHOST_NAMELEN);
2089                 kfree(tport);
2090                 return ERR_PTR(-EINVAL);
2091         }
2092         snprintf(&tport->tport_name[0], TCM_VHOST_NAMELEN, "%s", &name[off]);
2093
2094         pr_debug("TCM_VHost_ConfigFS: Allocated emulated Target"
2095                 " %s Address: %s\n", tcm_vhost_dump_proto_id(tport), name);
2096
2097         return &tport->tport_wwn;
2098 }
2099
2100 static void tcm_vhost_drop_tport(struct se_wwn *wwn)
2101 {
2102         struct tcm_vhost_tport *tport = container_of(wwn,
2103                                 struct tcm_vhost_tport, tport_wwn);
2104
2105         pr_debug("TCM_VHost_ConfigFS: Deallocating emulated Target"
2106                 " %s Address: %s\n", tcm_vhost_dump_proto_id(tport),
2107                 tport->tport_name);
2108
2109         kfree(tport);
2110 }
2111
2112 static ssize_t
2113 tcm_vhost_wwn_show_attr_version(struct target_fabric_configfs *tf,
2114                                 char *page)
2115 {
2116         return sprintf(page, "TCM_VHOST fabric module %s on %s/%s"
2117                 "on "UTS_RELEASE"\n", TCM_VHOST_VERSION, utsname()->sysname,
2118                 utsname()->machine);
2119 }
2120
2121 TF_WWN_ATTR_RO(tcm_vhost, version);
2122
2123 static struct configfs_attribute *tcm_vhost_wwn_attrs[] = {
2124         &tcm_vhost_wwn_version.attr,
2125         NULL,
2126 };
2127
2128 static struct target_core_fabric_ops tcm_vhost_ops = {
2129         .get_fabric_name                = tcm_vhost_get_fabric_name,
2130         .get_fabric_proto_ident         = tcm_vhost_get_fabric_proto_ident,
2131         .tpg_get_wwn                    = tcm_vhost_get_fabric_wwn,
2132         .tpg_get_tag                    = tcm_vhost_get_tag,
2133         .tpg_get_default_depth          = tcm_vhost_get_default_depth,
2134         .tpg_get_pr_transport_id        = tcm_vhost_get_pr_transport_id,
2135         .tpg_get_pr_transport_id_len    = tcm_vhost_get_pr_transport_id_len,
2136         .tpg_parse_pr_out_transport_id  = tcm_vhost_parse_pr_out_transport_id,
2137         .tpg_check_demo_mode            = tcm_vhost_check_true,
2138         .tpg_check_demo_mode_cache      = tcm_vhost_check_true,
2139         .tpg_check_demo_mode_write_protect = tcm_vhost_check_false,
2140         .tpg_check_prod_mode_write_protect = tcm_vhost_check_false,
2141         .tpg_alloc_fabric_acl           = tcm_vhost_alloc_fabric_acl,
2142         .tpg_release_fabric_acl         = tcm_vhost_release_fabric_acl,
2143         .tpg_get_inst_index             = tcm_vhost_tpg_get_inst_index,
2144         .release_cmd                    = tcm_vhost_release_cmd,
2145         .check_stop_free                = vhost_scsi_check_stop_free,
2146         .shutdown_session               = tcm_vhost_shutdown_session,
2147         .close_session                  = tcm_vhost_close_session,
2148         .sess_get_index                 = tcm_vhost_sess_get_index,
2149         .sess_get_initiator_sid         = NULL,
2150         .write_pending                  = tcm_vhost_write_pending,
2151         .write_pending_status           = tcm_vhost_write_pending_status,
2152         .set_default_node_attributes    = tcm_vhost_set_default_node_attrs,
2153         .get_task_tag                   = tcm_vhost_get_task_tag,
2154         .get_cmd_state                  = tcm_vhost_get_cmd_state,
2155         .queue_data_in                  = tcm_vhost_queue_data_in,
2156         .queue_status                   = tcm_vhost_queue_status,
2157         .queue_tm_rsp                   = tcm_vhost_queue_tm_rsp,
2158         /*
2159          * Setup callers for generic logic in target_core_fabric_configfs.c
2160          */
2161         .fabric_make_wwn                = tcm_vhost_make_tport,
2162         .fabric_drop_wwn                = tcm_vhost_drop_tport,
2163         .fabric_make_tpg                = tcm_vhost_make_tpg,
2164         .fabric_drop_tpg                = tcm_vhost_drop_tpg,
2165         .fabric_post_link               = tcm_vhost_port_link,
2166         .fabric_pre_unlink              = tcm_vhost_port_unlink,
2167         .fabric_make_np                 = NULL,
2168         .fabric_drop_np                 = NULL,
2169         .fabric_make_nodeacl            = tcm_vhost_make_nodeacl,
2170         .fabric_drop_nodeacl            = tcm_vhost_drop_nodeacl,
2171 };
2172
2173 static int tcm_vhost_register_configfs(void)
2174 {
2175         struct target_fabric_configfs *fabric;
2176         int ret;
2177
2178         pr_debug("TCM_VHOST fabric module %s on %s/%s"
2179                 " on "UTS_RELEASE"\n", TCM_VHOST_VERSION, utsname()->sysname,
2180                 utsname()->machine);
2181         /*
2182          * Register the top level struct config_item_type with TCM core
2183          */
2184         fabric = target_fabric_configfs_init(THIS_MODULE, "vhost");
2185         if (IS_ERR(fabric)) {
2186                 pr_err("target_fabric_configfs_init() failed\n");
2187                 return PTR_ERR(fabric);
2188         }
2189         /*
2190          * Setup fabric->tf_ops from our local tcm_vhost_ops
2191          */
2192         fabric->tf_ops = tcm_vhost_ops;
2193         /*
2194          * Setup default attribute lists for various fabric->tf_cit_tmpl
2195          */
2196         fabric->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = tcm_vhost_wwn_attrs;
2197         fabric->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = tcm_vhost_tpg_attrs;
2198         fabric->tf_cit_tmpl.tfc_tpg_attrib_cit.ct_attrs = NULL;
2199         fabric->tf_cit_tmpl.tfc_tpg_param_cit.ct_attrs = NULL;
2200         fabric->tf_cit_tmpl.tfc_tpg_np_base_cit.ct_attrs = NULL;
2201         fabric->tf_cit_tmpl.tfc_tpg_nacl_base_cit.ct_attrs = NULL;
2202         fabric->tf_cit_tmpl.tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
2203         fabric->tf_cit_tmpl.tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
2204         fabric->tf_cit_tmpl.tfc_tpg_nacl_param_cit.ct_attrs = NULL;
2205         /*
2206          * Register the fabric for use within TCM
2207          */
2208         ret = target_fabric_configfs_register(fabric);
2209         if (ret < 0) {
2210                 pr_err("target_fabric_configfs_register() failed"
2211                                 " for TCM_VHOST\n");
2212                 return ret;
2213         }
2214         /*
2215          * Setup our local pointer to *fabric
2216          */
2217         tcm_vhost_fabric_configfs = fabric;
2218         pr_debug("TCM_VHOST[0] - Set fabric -> tcm_vhost_fabric_configfs\n");
2219         return 0;
2220 };
2221
2222 static void tcm_vhost_deregister_configfs(void)
2223 {
2224         if (!tcm_vhost_fabric_configfs)
2225                 return;
2226
2227         target_fabric_configfs_deregister(tcm_vhost_fabric_configfs);
2228         tcm_vhost_fabric_configfs = NULL;
2229         pr_debug("TCM_VHOST[0] - Cleared tcm_vhost_fabric_configfs\n");
2230 };
2231
2232 static int __init tcm_vhost_init(void)
2233 {
2234         int ret = -ENOMEM;
2235         /*
2236          * Use our own dedicated workqueue for submitting I/O into
2237          * target core to avoid contention within system_wq.
2238          */
2239         tcm_vhost_workqueue = alloc_workqueue("tcm_vhost", 0, 0);
2240         if (!tcm_vhost_workqueue)
2241                 goto out;
2242
2243         ret = vhost_scsi_register();
2244         if (ret < 0)
2245                 goto out_destroy_workqueue;
2246
2247         ret = tcm_vhost_register_configfs();
2248         if (ret < 0)
2249                 goto out_vhost_scsi_deregister;
2250
2251         return 0;
2252
2253 out_vhost_scsi_deregister:
2254         vhost_scsi_deregister();
2255 out_destroy_workqueue:
2256         destroy_workqueue(tcm_vhost_workqueue);
2257 out:
2258         return ret;
2259 };
2260
2261 static void tcm_vhost_exit(void)
2262 {
2263         tcm_vhost_deregister_configfs();
2264         vhost_scsi_deregister();
2265         destroy_workqueue(tcm_vhost_workqueue);
2266 };
2267
2268 MODULE_DESCRIPTION("VHOST_SCSI series fabric driver");
2269 MODULE_ALIAS("tcm_vhost");
2270 MODULE_LICENSE("GPL");
2271 module_init(tcm_vhost_init);
2272 module_exit(tcm_vhost_exit);