Pileus Git - ~andy/linux/blob - 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 tcm_vhost_tport *tv_tport;
1204         struct tcm_vhost_tpg *tpg;
1205         struct tcm_vhost_tpg **vs_tpg;
1206         struct vhost_virtqueue *vq;
1207         int index, ret, i, len;
1208         bool match = false;
1209
1210         mutex_lock(&tcm_vhost_mutex);
1211         mutex_lock(&vs->dev.mutex);
1212
1213         /* Verify that ring has been setup correctly. */
1214         for (index = 0; index < vs->dev.nvqs; ++index) {
1215                 /* Verify that ring has been setup correctly. */
1216                 if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
1217                         ret = -EFAULT;
1218                         goto out;
1219                 }
1220         }
1221
1222         len = sizeof(vs_tpg[0]) * VHOST_SCSI_MAX_TARGET;
1223         vs_tpg = kzalloc(len, GFP_KERNEL);
1224         if (!vs_tpg) {
1225                 ret = -ENOMEM;
1226                 goto out;
1227         }
1228         if (vs->vs_tpg)
1229                 memcpy(vs_tpg, vs->vs_tpg, len);
1230
1231         list_for_each_entry(tpg, &tcm_vhost_list, tv_tpg_list) {
1232                 mutex_lock(&tpg->tv_tpg_mutex);
1233                 if (!tpg->tpg_nexus) {
1234                         mutex_unlock(&tpg->tv_tpg_mutex);
1235                         continue;
1236                 }
1237                 if (tpg->tv_tpg_vhost_count != 0) {
1238                         mutex_unlock(&tpg->tv_tpg_mutex);
1239                         continue;
1240                 }
1241                 tv_tport = tpg->tport;
1242
1243                 if (!strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
1244                         if (vs->vs_tpg && vs->vs_tpg[tpg->tport_tpgt]) {
1245                                 kfree(vs_tpg);
1246                                 mutex_unlock(&tpg->tv_tpg_mutex);
1247                                 ret = -EEXIST;
1248                                 goto out;
1249                         }
1250                         tpg->tv_tpg_vhost_count++;
1251                         tpg->vhost_scsi = vs;
1252                         vs_tpg[tpg->tport_tpgt] = tpg;
1253                         smp_mb__after_atomic_inc();
1254                         match = true;
1255                 }
1256                 mutex_unlock(&tpg->tv_tpg_mutex);
1257         }
1258
1259         if (match) {
1260                 memcpy(vs->vs_vhost_wwpn, t->vhost_wwpn,
1261                        sizeof(vs->vs_vhost_wwpn));
1262                 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
1263                         vq = &vs->vqs[i].vq;
1264                         mutex_lock(&vq->mutex);
1265                         vq->private_data = vs_tpg;
1266                         vhost_init_used(vq);
1267                         mutex_unlock(&vq->mutex);
1268                 }
1269                 ret = 0;
1270         } else {
1271                 ret = -EEXIST;
1272         }
1273
1274         /*
1275          * Act as synchronize_rcu to make sure access to
1276          * old vs->vs_tpg is finished.
1277          */
1278         vhost_scsi_flush(vs);
1279         kfree(vs->vs_tpg);
1280         vs->vs_tpg = vs_tpg;
1281
1282 out:
1283         mutex_unlock(&vs->dev.mutex);
1284         mutex_unlock(&tcm_vhost_mutex);
1285         return ret;
1286 }
1287
1288 static int
1289 vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
1290                           struct vhost_scsi_target *t)
1291 {
1292         struct tcm_vhost_tport *tv_tport;
1293         struct tcm_vhost_tpg *tpg;
1294         struct vhost_virtqueue *vq;
1295         bool match = false;
1296         int index, ret, i;
1297         u8 target;
1298
1299         mutex_lock(&tcm_vhost_mutex);
1300         mutex_lock(&vs->dev.mutex);
1301         /* Verify that ring has been setup correctly. */
1302         for (index = 0; index < vs->dev.nvqs; ++index) {
1303                 if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
1304                         ret = -EFAULT;
1305                         goto err_dev;
1306                 }
1307         }
1308
1309         if (!vs->vs_tpg) {
1310                 ret = 0;
1311                 goto err_dev;
1312         }
1313
1314         for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
1315                 target = i;
1316                 tpg = vs->vs_tpg[target];
1317                 if (!tpg)
1318                         continue;
1319
1320                 mutex_lock(&tpg->tv_tpg_mutex);
1321                 tv_tport = tpg->tport;
1322                 if (!tv_tport) {
1323                         ret = -ENODEV;
1324                         goto err_tpg;
1325                 }
1326
1327                 if (strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
1328                         pr_warn("tv_tport->tport_name: %s, tpg->tport_tpgt: %hu"
1329                                 " does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
1330                                 tv_tport->tport_name, tpg->tport_tpgt,
1331                                 t->vhost_wwpn, t->vhost_tpgt);
1332                         ret = -EINVAL;
1333                         goto err_tpg;
1334                 }
1335                 tpg->tv_tpg_vhost_count--;
1336                 tpg->vhost_scsi = NULL;
1337                 vs->vs_tpg[target] = NULL;
1338                 match = true;
1339                 mutex_unlock(&tpg->tv_tpg_mutex);
1340         }
1341         if (match) {
1342                 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
1343                         vq = &vs->vqs[i].vq;
1344                         mutex_lock(&vq->mutex);
1345                         vq->private_data = NULL;
1346                         mutex_unlock(&vq->mutex);
1347                 }
1348         }
1349         /*
1350          * Act as synchronize_rcu to make sure access to
1351          * old vs->vs_tpg is finished.
1352          */
1353         vhost_scsi_flush(vs);
1354         kfree(vs->vs_tpg);
1355         vs->vs_tpg = NULL;
1356         WARN_ON(vs->vs_events_nr);
1357         mutex_unlock(&vs->dev.mutex);
1358         mutex_unlock(&tcm_vhost_mutex);
1359         return 0;
1360
1361 err_tpg:
1362         mutex_unlock(&tpg->tv_tpg_mutex);
1363 err_dev:
1364         mutex_unlock(&vs->dev.mutex);
1365         mutex_unlock(&tcm_vhost_mutex);
1366         return ret;
1367 }
1368
1369 static int vhost_scsi_set_features(struct vhost_scsi *vs, u64 features)
1370 {
1371         if (features & ~VHOST_SCSI_FEATURES)
1372                 return -EOPNOTSUPP;
1373
1374         mutex_lock(&vs->dev.mutex);
1375         if ((features & (1 << VHOST_F_LOG_ALL)) &&
1376             !vhost_log_access_ok(&vs->dev)) {
1377                 mutex_unlock(&vs->dev.mutex);
1378                 return -EFAULT;
1379         }
1380         vs->dev.acked_features = features;
1381         smp_wmb();
1382         vhost_scsi_flush(vs);
1383         mutex_unlock(&vs->dev.mutex);
1384         return 0;
1385 }
1386
1387 static void vhost_scsi_free(struct vhost_scsi *vs)
1388 {
1389         if (is_vmalloc_addr(vs))
1390                 vfree(vs);
1391         else
1392                 kfree(vs);
1393 }
1394
1395 static int vhost_scsi_open(struct inode *inode, struct file *f)
1396 {
1397         struct vhost_scsi *vs;
1398         struct vhost_virtqueue **vqs;
1399         int r = -ENOMEM, i;
1400
1401         vs = kzalloc(sizeof(*vs), GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
1402         if (!vs) {
1403                 vs = vzalloc(sizeof(*vs));
1404                 if (!vs)
1405                         goto err_vs;
1406         }
1407
1408         vqs = kmalloc(VHOST_SCSI_MAX_VQ * sizeof(*vqs), GFP_KERNEL);
1409         if (!vqs)
1410                 goto err_vqs;
1411
1412         vhost_work_init(&vs->vs_completion_work, vhost_scsi_complete_cmd_work);
1413         vhost_work_init(&vs->vs_event_work, tcm_vhost_evt_work);
1414
1415         vs->vs_events_nr = 0;
1416         vs->vs_events_missed = false;
1417
1418         vqs[VHOST_SCSI_VQ_CTL] = &vs->vqs[VHOST_SCSI_VQ_CTL].vq;
1419         vqs[VHOST_SCSI_VQ_EVT] = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1420         vs->vqs[VHOST_SCSI_VQ_CTL].vq.handle_kick = vhost_scsi_ctl_handle_kick;
1421         vs->vqs[VHOST_SCSI_VQ_EVT].vq.handle_kick = vhost_scsi_evt_handle_kick;
1422         for (i = VHOST_SCSI_VQ_IO; i < VHOST_SCSI_MAX_VQ; i++) {
1423                 vqs[i] = &vs->vqs[i].vq;
1424                 vs->vqs[i].vq.handle_kick = vhost_scsi_handle_kick;
1425         }
1426         vhost_dev_init(&vs->dev, vqs, VHOST_SCSI_MAX_VQ);
1427
1428         tcm_vhost_init_inflight(vs, NULL);
1429
1430         f->private_data = vs;
1431         return 0;
1432
1433 err_vqs:
1434         vhost_scsi_free(vs);
1435 err_vs:
1436         return r;
1437 }
1438
1439 static int vhost_scsi_release(struct inode *inode, struct file *f)
1440 {
1441         struct vhost_scsi *vs = f->private_data;
1442         struct vhost_scsi_target t;
1443
1444         mutex_lock(&vs->dev.mutex);
1445         memcpy(t.vhost_wwpn, vs->vs_vhost_wwpn, sizeof(t.vhost_wwpn));
1446         mutex_unlock(&vs->dev.mutex);
1447         vhost_scsi_clear_endpoint(vs, &t);
1448         vhost_dev_stop(&vs->dev);
1449         vhost_dev_cleanup(&vs->dev, false);
1450         /* Jobs can re-queue themselves in evt kick handler. Do extra flush. */
1451         vhost_scsi_flush(vs);
1452         kfree(vs->dev.vqs);
1453         vhost_scsi_free(vs);
1454         return 0;
1455 }
1456
1457 static long
1458 vhost_scsi_ioctl(struct file *f,
1459                  unsigned int ioctl,
1460                  unsigned long arg)
1461 {
1462         struct vhost_scsi *vs = f->private_data;
1463         struct vhost_scsi_target backend;
1464         void __user *argp = (void __user *)arg;
1465         u64 __user *featurep = argp;
1466         u32 __user *eventsp = argp;
1467         u32 events_missed;
1468         u64 features;
1469         int r, abi_version = VHOST_SCSI_ABI_VERSION;
1470         struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1471
1472         switch (ioctl) {
1473         case VHOST_SCSI_SET_ENDPOINT:
1474                 if (copy_from_user(&backend, argp, sizeof backend))
1475                         return -EFAULT;
1476                 if (backend.reserved != 0)
1477                         return -EOPNOTSUPP;
1478
1479                 return vhost_scsi_set_endpoint(vs, &backend);
1480         case VHOST_SCSI_CLEAR_ENDPOINT:
1481                 if (copy_from_user(&backend, argp, sizeof backend))
1482                         return -EFAULT;
1483                 if (backend.reserved != 0)
1484                         return -EOPNOTSUPP;
1485
1486                 return vhost_scsi_clear_endpoint(vs, &backend);
1487         case VHOST_SCSI_GET_ABI_VERSION:
1488                 if (copy_to_user(argp, &abi_version, sizeof abi_version))
1489                         return -EFAULT;
1490                 return 0;
1491         case VHOST_SCSI_SET_EVENTS_MISSED:
1492                 if (get_user(events_missed, eventsp))
1493                         return -EFAULT;
1494                 mutex_lock(&vq->mutex);
1495                 vs->vs_events_missed = events_missed;
1496                 mutex_unlock(&vq->mutex);
1497                 return 0;
1498         case VHOST_SCSI_GET_EVENTS_MISSED:
1499                 mutex_lock(&vq->mutex);
1500                 events_missed = vs->vs_events_missed;
1501                 mutex_unlock(&vq->mutex);
1502                 if (put_user(events_missed, eventsp))
1503                         return -EFAULT;
1504                 return 0;
1505         case VHOST_GET_FEATURES:
1506                 features = VHOST_SCSI_FEATURES;
1507                 if (copy_to_user(featurep, &features, sizeof features))
1508                         return -EFAULT;
1509                 return 0;
1510         case VHOST_SET_FEATURES:
1511                 if (copy_from_user(&features, featurep, sizeof features))
1512                         return -EFAULT;
1513                 return vhost_scsi_set_features(vs, features);
1514         default:
1515                 mutex_lock(&vs->dev.mutex);
1516                 r = vhost_dev_ioctl(&vs->dev, ioctl, argp);
1517                 /* TODO: flush backend after dev ioctl. */
1518                 if (r == -ENOIOCTLCMD)
1519                         r = vhost_vring_ioctl(&vs->dev, ioctl, argp);
1520                 mutex_unlock(&vs->dev.mutex);
1521                 return r;
1522         }
1523 }
1524
1525 #ifdef CONFIG_COMPAT
1526 static long vhost_scsi_compat_ioctl(struct file *f, unsigned int ioctl,
1527                                 unsigned long arg)
1528 {
1529         return vhost_scsi_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
1530 }
1531 #endif
1532
1533 static const struct file_operations vhost_scsi_fops = {
1534         .owner          = THIS_MODULE,
1535         .release        = vhost_scsi_release,
1536         .unlocked_ioctl = vhost_scsi_ioctl,
1537 #ifdef CONFIG_COMPAT
1538         .compat_ioctl   = vhost_scsi_compat_ioctl,
1539 #endif
1540         .open           = vhost_scsi_open,
1541         .llseek         = noop_llseek,
1542 };
1543
1544 static struct miscdevice vhost_scsi_misc = {
1545         MISC_DYNAMIC_MINOR,
1546         "vhost-scsi",
1547         &vhost_scsi_fops,
1548 };
1549
1550 static int __init vhost_scsi_register(void)
1551 {
1552         return misc_register(&vhost_scsi_misc);
1553 }
1554
1555 static int vhost_scsi_deregister(void)
1556 {
1557         return misc_deregister(&vhost_scsi_misc);
1558 }
1559
1560 static char *tcm_vhost_dump_proto_id(struct tcm_vhost_tport *tport)
1561 {
1562         switch (tport->tport_proto_id) {
1563         case SCSI_PROTOCOL_SAS:
1564                 return "SAS";
1565         case SCSI_PROTOCOL_FCP:
1566                 return "FCP";
1567         case SCSI_PROTOCOL_ISCSI:
1568                 return "iSCSI";
1569         default:
1570                 break;
1571         }
1572
1573         return "Unknown";
1574 }
1575
1576 static void
1577 tcm_vhost_do_plug(struct tcm_vhost_tpg *tpg,
1578                   struct se_lun *lun, bool plug)
1579 {
1580
1581         struct vhost_scsi *vs = tpg->vhost_scsi;
1582         struct vhost_virtqueue *vq;
1583         u32 reason;
1584
1585         if (!vs)
1586                 return;
1587
1588         mutex_lock(&vs->dev.mutex);
1589         if (!vhost_has_feature(&vs->dev, VIRTIO_SCSI_F_HOTPLUG)) {
1590                 mutex_unlock(&vs->dev.mutex);
1591                 return;
1592         }
1593
1594         if (plug)
1595                 reason = VIRTIO_SCSI_EVT_RESET_RESCAN;
1596         else
1597                 reason = VIRTIO_SCSI_EVT_RESET_REMOVED;
1598
1599         vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1600         mutex_lock(&vq->mutex);
1601         tcm_vhost_send_evt(vs, tpg, lun,
1602                         VIRTIO_SCSI_T_TRANSPORT_RESET, reason);
1603         mutex_unlock(&vq->mutex);
1604         mutex_unlock(&vs->dev.mutex);
1605 }
1606
1607 static void tcm_vhost_hotplug(struct tcm_vhost_tpg *tpg, struct se_lun *lun)
1608 {
1609         tcm_vhost_do_plug(tpg, lun, true);
1610 }
1611
1612 static void tcm_vhost_hotunplug(struct tcm_vhost_tpg *tpg, struct se_lun *lun)
1613 {
1614         tcm_vhost_do_plug(tpg, lun, false);
1615 }
1616
1617 static int tcm_vhost_port_link(struct se_portal_group *se_tpg,
1618                                struct se_lun *lun)
1619 {
1620         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1621                                 struct tcm_vhost_tpg, se_tpg);
1622
1623         mutex_lock(&tcm_vhost_mutex);
1624
1625         mutex_lock(&tpg->tv_tpg_mutex);
1626         tpg->tv_tpg_port_count++;
1627         mutex_unlock(&tpg->tv_tpg_mutex);
1628
1629         tcm_vhost_hotplug(tpg, lun);
1630
1631         mutex_unlock(&tcm_vhost_mutex);
1632
1633         return 0;
1634 }
1635
1636 static void tcm_vhost_port_unlink(struct se_portal_group *se_tpg,
1637                                   struct se_lun *lun)
1638 {
1639         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1640                                 struct tcm_vhost_tpg, se_tpg);
1641
1642         mutex_lock(&tcm_vhost_mutex);
1643
1644         mutex_lock(&tpg->tv_tpg_mutex);
1645         tpg->tv_tpg_port_count--;
1646         mutex_unlock(&tpg->tv_tpg_mutex);
1647
1648         tcm_vhost_hotunplug(tpg, lun);
1649
1650         mutex_unlock(&tcm_vhost_mutex);
1651 }
1652
1653 static struct se_node_acl *
1654 tcm_vhost_make_nodeacl(struct se_portal_group *se_tpg,
1655                        struct config_group *group,
1656                        const char *name)
1657 {
1658         struct se_node_acl *se_nacl, *se_nacl_new;
1659         struct tcm_vhost_nacl *nacl;
1660         u64 wwpn = 0;
1661         u32 nexus_depth;
1662
1663         /* tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
1664                 return ERR_PTR(-EINVAL); */
1665         se_nacl_new = tcm_vhost_alloc_fabric_acl(se_tpg);
1666         if (!se_nacl_new)
1667                 return ERR_PTR(-ENOMEM);
1668
1669         nexus_depth = 1;
1670         /*
1671          * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
1672          * when converting a NodeACL from demo mode -> explict
1673          */
1674         se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
1675                                 name, nexus_depth);
1676         if (IS_ERR(se_nacl)) {
1677                 tcm_vhost_release_fabric_acl(se_tpg, se_nacl_new);
1678                 return se_nacl;
1679         }
1680         /*
1681          * Locate our struct tcm_vhost_nacl and set the FC Nport WWPN
1682          */
1683         nacl = container_of(se_nacl, struct tcm_vhost_nacl, se_node_acl);
1684         nacl->iport_wwpn = wwpn;
1685
1686         return se_nacl;
1687 }
1688
1689 static void tcm_vhost_drop_nodeacl(struct se_node_acl *se_acl)
1690 {
1691         struct tcm_vhost_nacl *nacl = container_of(se_acl,
1692                                 struct tcm_vhost_nacl, se_node_acl);
1693         core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
1694         kfree(nacl);
1695 }
1696
1697 static void tcm_vhost_free_cmd_map_res(struct tcm_vhost_nexus *nexus,
1698                                        struct se_session *se_sess)
1699 {
1700         struct tcm_vhost_cmd *tv_cmd;
1701         unsigned int i;
1702
1703         if (!se_sess->sess_cmd_map)
1704                 return;
1705
1706         for (i = 0; i < TCM_VHOST_DEFAULT_TAGS; i++) {
1707                 tv_cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[i];
1708
1709                 kfree(tv_cmd->tvc_sgl);
1710                 kfree(tv_cmd->tvc_upages);
1711         }
1712 }
1713
1714 static int tcm_vhost_make_nexus(struct tcm_vhost_tpg *tpg,
1715                                 const char *name)
1716 {
1717         struct se_portal_group *se_tpg;
1718         struct se_session *se_sess;
1719         struct tcm_vhost_nexus *tv_nexus;
1720         struct tcm_vhost_cmd *tv_cmd;
1721         unsigned int i;
1722
1723         mutex_lock(&tpg->tv_tpg_mutex);
1724         if (tpg->tpg_nexus) {
1725                 mutex_unlock(&tpg->tv_tpg_mutex);
1726                 pr_debug("tpg->tpg_nexus already exists\n");
1727                 return -EEXIST;
1728         }
1729         se_tpg = &tpg->se_tpg;
1730
1731         tv_nexus = kzalloc(sizeof(struct tcm_vhost_nexus), GFP_KERNEL);
1732         if (!tv_nexus) {
1733                 mutex_unlock(&tpg->tv_tpg_mutex);
1734                 pr_err("Unable to allocate struct tcm_vhost_nexus\n");
1735                 return -ENOMEM;
1736         }
1737         /*
1738          *  Initialize the struct se_session pointer and setup tagpool
1739          *  for struct tcm_vhost_cmd descriptors
1740          */
1741         tv_nexus->tvn_se_sess = transport_init_session_tags(
1742                                         TCM_VHOST_DEFAULT_TAGS,
1743                                         sizeof(struct tcm_vhost_cmd));
1744         if (IS_ERR(tv_nexus->tvn_se_sess)) {
1745                 mutex_unlock(&tpg->tv_tpg_mutex);
1746                 kfree(tv_nexus);
1747                 return -ENOMEM;
1748         }
1749         se_sess = tv_nexus->tvn_se_sess;
1750         for (i = 0; i < TCM_VHOST_DEFAULT_TAGS; i++) {
1751                 tv_cmd = &((struct tcm_vhost_cmd *)se_sess->sess_cmd_map)[i];
1752
1753                 tv_cmd->tvc_sgl = kzalloc(sizeof(struct scatterlist) *
1754                                         TCM_VHOST_PREALLOC_SGLS, GFP_KERNEL);
1755                 if (!tv_cmd->tvc_sgl) {
1756                         mutex_unlock(&tpg->tv_tpg_mutex);
1757                         pr_err("Unable to allocate tv_cmd->tvc_sgl\n");
1758                         goto out;
1759                 }
1760
1761                 tv_cmd->tvc_upages = kzalloc(sizeof(struct page *) *
1762                                         TCM_VHOST_PREALLOC_PAGES, GFP_KERNEL);
1763                 if (!tv_cmd->tvc_upages) {
1764                         mutex_unlock(&tpg->tv_tpg_mutex);
1765                         pr_err("Unable to allocate tv_cmd->tvc_upages\n");
1766                         goto out;
1767                 }
1768         }
1769         /*
1770          * Since we are running in 'demo mode' this call with generate a
1771          * struct se_node_acl for the tcm_vhost struct se_portal_group with
1772          * the SCSI Initiator port name of the passed configfs group 'name'.
1773          */
1774         tv_nexus->tvn_se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
1775                                 se_tpg, (unsigned char *)name);
1776         if (!tv_nexus->tvn_se_sess->se_node_acl) {
1777                 mutex_unlock(&tpg->tv_tpg_mutex);
1778                 pr_debug("core_tpg_check_initiator_node_acl() failed"
1779                                 " for %s\n", name);
1780                 goto out;
1781         }
1782         /*
1783          * Now register the TCM vhost virtual I_T Nexus as active with the
1784          * call to __transport_register_session()
1785          */
1786         __transport_register_session(se_tpg, tv_nexus->tvn_se_sess->se_node_acl,
1787                         tv_nexus->tvn_se_sess, tv_nexus);
1788         tpg->tpg_nexus = tv_nexus;
1789
1790         mutex_unlock(&tpg->tv_tpg_mutex);
1791         return 0;
1792
1793 out:
1794         tcm_vhost_free_cmd_map_res(tv_nexus, se_sess);
1795         transport_free_session(se_sess);
1796         kfree(tv_nexus);
1797         return -ENOMEM;
1798 }
1799
1800 static int tcm_vhost_drop_nexus(struct tcm_vhost_tpg *tpg)
1801 {
1802         struct se_session *se_sess;
1803         struct tcm_vhost_nexus *tv_nexus;
1804
1805         mutex_lock(&tpg->tv_tpg_mutex);
1806         tv_nexus = tpg->tpg_nexus;
1807         if (!tv_nexus) {
1808                 mutex_unlock(&tpg->tv_tpg_mutex);
1809                 return -ENODEV;
1810         }
1811
1812         se_sess = tv_nexus->tvn_se_sess;
1813         if (!se_sess) {
1814                 mutex_unlock(&tpg->tv_tpg_mutex);
1815                 return -ENODEV;
1816         }
1817
1818         if (tpg->tv_tpg_port_count != 0) {
1819                 mutex_unlock(&tpg->tv_tpg_mutex);
1820                 pr_err("Unable to remove TCM_vhost I_T Nexus with"
1821                         " active TPG port count: %d\n",
1822                         tpg->tv_tpg_port_count);
1823                 return -EBUSY;
1824         }
1825
1826         if (tpg->tv_tpg_vhost_count != 0) {
1827                 mutex_unlock(&tpg->tv_tpg_mutex);
1828                 pr_err("Unable to remove TCM_vhost I_T Nexus with"
1829                         " active TPG vhost count: %d\n",
1830                         tpg->tv_tpg_vhost_count);
1831                 return -EBUSY;
1832         }
1833
1834         pr_debug("TCM_vhost_ConfigFS: Removing I_T Nexus to emulated"
1835                 " %s Initiator Port: %s\n", tcm_vhost_dump_proto_id(tpg->tport),
1836                 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
1837
1838         tcm_vhost_free_cmd_map_res(tv_nexus, se_sess);
1839         /*
1840          * Release the SCSI I_T Nexus to the emulated vhost Target Port
1841          */
1842         transport_deregister_session(tv_nexus->tvn_se_sess);
1843         tpg->tpg_nexus = NULL;
1844         mutex_unlock(&tpg->tv_tpg_mutex);
1845
1846         kfree(tv_nexus);
1847         return 0;
1848 }
1849
1850 static ssize_t tcm_vhost_tpg_show_nexus(struct se_portal_group *se_tpg,
1851                                         char *page)
1852 {
1853         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1854                                 struct tcm_vhost_tpg, se_tpg);
1855         struct tcm_vhost_nexus *tv_nexus;
1856         ssize_t ret;
1857
1858         mutex_lock(&tpg->tv_tpg_mutex);
1859         tv_nexus = tpg->tpg_nexus;
1860         if (!tv_nexus) {
1861                 mutex_unlock(&tpg->tv_tpg_mutex);
1862                 return -ENODEV;
1863         }
1864         ret = snprintf(page, PAGE_SIZE, "%s\n",
1865                         tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
1866         mutex_unlock(&tpg->tv_tpg_mutex);
1867
1868         return ret;
1869 }
1870
1871 static ssize_t tcm_vhost_tpg_store_nexus(struct se_portal_group *se_tpg,
1872                                          const char *page,
1873                                          size_t count)
1874 {
1875         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1876                                 struct tcm_vhost_tpg, se_tpg);
1877         struct tcm_vhost_tport *tport_wwn = tpg->tport;
1878         unsigned char i_port[TCM_VHOST_NAMELEN], *ptr, *port_ptr;
1879         int ret;
1880         /*
1881          * Shutdown the active I_T nexus if 'NULL' is passed..
1882          */
1883         if (!strncmp(page, "NULL", 4)) {
1884                 ret = tcm_vhost_drop_nexus(tpg);
1885                 return (!ret) ? count : ret;
1886         }
1887         /*
1888          * Otherwise make sure the passed virtual Initiator port WWN matches
1889          * the fabric protocol_id set in tcm_vhost_make_tport(), and call
1890          * tcm_vhost_make_nexus().
1891          */
1892         if (strlen(page) >= TCM_VHOST_NAMELEN) {
1893                 pr_err("Emulated NAA Sas Address: %s, exceeds"
1894                                 " max: %d\n", page, TCM_VHOST_NAMELEN);
1895                 return -EINVAL;
1896         }
1897         snprintf(&i_port[0], TCM_VHOST_NAMELEN, "%s", page);
1898
1899         ptr = strstr(i_port, "naa.");
1900         if (ptr) {
1901                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_SAS) {
1902                         pr_err("Passed SAS Initiator Port %s does not"
1903                                 " match target port protoid: %s\n", i_port,
1904                                 tcm_vhost_dump_proto_id(tport_wwn));
1905                         return -EINVAL;
1906                 }
1907                 port_ptr = &i_port[0];
1908                 goto check_newline;
1909         }
1910         ptr = strstr(i_port, "fc.");
1911         if (ptr) {
1912                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_FCP) {
1913                         pr_err("Passed FCP Initiator Port %s does not"
1914                                 " match target port protoid: %s\n", i_port,
1915                                 tcm_vhost_dump_proto_id(tport_wwn));
1916                         return -EINVAL;
1917                 }
1918                 port_ptr = &i_port[3]; /* Skip over "fc." */
1919                 goto check_newline;
1920         }
1921         ptr = strstr(i_port, "iqn.");
1922         if (ptr) {
1923                 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_ISCSI) {
1924                         pr_err("Passed iSCSI Initiator Port %s does not"
1925                                 " match target port protoid: %s\n", i_port,
1926                                 tcm_vhost_dump_proto_id(tport_wwn));
1927                         return -EINVAL;
1928                 }
1929                 port_ptr = &i_port[0];
1930                 goto check_newline;
1931         }
1932         pr_err("Unable to locate prefix for emulated Initiator Port:"
1933                         " %s\n", i_port);
1934         return -EINVAL;
1935         /*
1936          * Clear any trailing newline for the NAA WWN
1937          */
1938 check_newline:
1939         if (i_port[strlen(i_port)-1] == '\n')
1940                 i_port[strlen(i_port)-1] = '\0';
1941
1942         ret = tcm_vhost_make_nexus(tpg, port_ptr);
1943         if (ret < 0)
1944                 return ret;
1945
1946         return count;
1947 }
1948
1949 TF_TPG_BASE_ATTR(tcm_vhost, nexus, S_IRUGO | S_IWUSR);
1950
1951 static struct configfs_attribute *tcm_vhost_tpg_attrs[] = {
1952         &tcm_vhost_tpg_nexus.attr,
1953         NULL,
1954 };
1955
1956 static struct se_portal_group *
1957 tcm_vhost_make_tpg(struct se_wwn *wwn,
1958                    struct config_group *group,
1959                    const char *name)
1960 {
1961         struct tcm_vhost_tport *tport = container_of(wwn,
1962                         struct tcm_vhost_tport, tport_wwn);
1963
1964         struct tcm_vhost_tpg *tpg;
1965         unsigned long tpgt;
1966         int ret;
1967
1968         if (strstr(name, "tpgt_") != name)
1969                 return ERR_PTR(-EINVAL);
1970         if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
1971                 return ERR_PTR(-EINVAL);
1972
1973         tpg = kzalloc(sizeof(struct tcm_vhost_tpg), GFP_KERNEL);
1974         if (!tpg) {
1975                 pr_err("Unable to allocate struct tcm_vhost_tpg");
1976                 return ERR_PTR(-ENOMEM);
1977         }
1978         mutex_init(&tpg->tv_tpg_mutex);
1979         INIT_LIST_HEAD(&tpg->tv_tpg_list);
1980         tpg->tport = tport;
1981         tpg->tport_tpgt = tpgt;
1982
1983         ret = core_tpg_register(&tcm_vhost_fabric_configfs->tf_ops, wwn,
1984                                 &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
1985         if (ret < 0) {
1986                 kfree(tpg);
1987                 return NULL;
1988         }
1989         mutex_lock(&tcm_vhost_mutex);
1990         list_add_tail(&tpg->tv_tpg_list, &tcm_vhost_list);
1991         mutex_unlock(&tcm_vhost_mutex);
1992
1993         return &tpg->se_tpg;
1994 }
1995
1996 static void tcm_vhost_drop_tpg(struct se_portal_group *se_tpg)
1997 {
1998         struct tcm_vhost_tpg *tpg = container_of(se_tpg,
1999                                 struct tcm_vhost_tpg, se_tpg);
2000
2001         mutex_lock(&tcm_vhost_mutex);
2002         list_del(&tpg->tv_tpg_list);
2003         mutex_unlock(&tcm_vhost_mutex);
2004         /*
2005          * Release the virtual I_T Nexus for this vhost TPG
2006          */
2007         tcm_vhost_drop_nexus(tpg);
2008         /*
2009          * Deregister the se_tpg from TCM..
2010          */
2011         core_tpg_deregister(se_tpg);
2012         kfree(tpg);
2013 }
2014
2015 static struct se_wwn *
2016 tcm_vhost_make_tport(struct target_fabric_configfs *tf,
2017                      struct config_group *group,
2018                      const char *name)
2019 {
2020         struct tcm_vhost_tport *tport;
2021         char *ptr;
2022         u64 wwpn = 0;
2023         int off = 0;
2024
2025         /* if (tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
2026                 return ERR_PTR(-EINVAL); */
2027
2028         tport = kzalloc(sizeof(struct tcm_vhost_tport), GFP_KERNEL);
2029         if (!tport) {
2030                 pr_err("Unable to allocate struct tcm_vhost_tport");
2031                 return ERR_PTR(-ENOMEM);
2032         }
2033         tport->tport_wwpn = wwpn;
2034         /*
2035          * Determine the emulated Protocol Identifier and Target Port Name
2036          * based on the incoming configfs directory name.
2037          */
2038         ptr = strstr(name, "naa.");
2039         if (ptr) {
2040                 tport->tport_proto_id = SCSI_PROTOCOL_SAS;
2041                 goto check_len;
2042         }
2043         ptr = strstr(name, "fc.");
2044         if (ptr) {
2045                 tport->tport_proto_id = SCSI_PROTOCOL_FCP;
2046                 off = 3; /* Skip over "fc." */
2047                 goto check_len;
2048         }
2049         ptr = strstr(name, "iqn.");
2050         if (ptr) {
2051                 tport->tport_proto_id = SCSI_PROTOCOL_ISCSI;
2052                 goto check_len;
2053         }
2054
2055         pr_err("Unable to locate prefix for emulated Target Port:"
2056                         " %s\n", name);
2057         kfree(tport);
2058         return ERR_PTR(-EINVAL);
2059
2060 check_len:
2061         if (strlen(name) >= TCM_VHOST_NAMELEN) {
2062                 pr_err("Emulated %s Address: %s, exceeds"
2063                         " max: %d\n", name, tcm_vhost_dump_proto_id(tport),
2064                         TCM_VHOST_NAMELEN);
2065                 kfree(tport);
2066                 return ERR_PTR(-EINVAL);
2067         }
2068         snprintf(&tport->tport_name[0], TCM_VHOST_NAMELEN, "%s", &name[off]);
2069
2070         pr_debug("TCM_VHost_ConfigFS: Allocated emulated Target"
2071                 " %s Address: %s\n", tcm_vhost_dump_proto_id(tport), name);
2072
2073         return &tport->tport_wwn;
2074 }
2075
2076 static void tcm_vhost_drop_tport(struct se_wwn *wwn)
2077 {
2078         struct tcm_vhost_tport *tport = container_of(wwn,
2079                                 struct tcm_vhost_tport, tport_wwn);
2080
2081         pr_debug("TCM_VHost_ConfigFS: Deallocating emulated Target"
2082                 " %s Address: %s\n", tcm_vhost_dump_proto_id(tport),
2083                 tport->tport_name);
2084
2085         kfree(tport);
2086 }
2087
2088 static ssize_t
2089 tcm_vhost_wwn_show_attr_version(struct target_fabric_configfs *tf,
2090                                 char *page)
2091 {
2092         return sprintf(page, "TCM_VHOST fabric module %s on %s/%s"
2093                 "on "UTS_RELEASE"\n", TCM_VHOST_VERSION, utsname()->sysname,
2094                 utsname()->machine);
2095 }
2096
2097 TF_WWN_ATTR_RO(tcm_vhost, version);
2098
2099 static struct configfs_attribute *tcm_vhost_wwn_attrs[] = {
2100         &tcm_vhost_wwn_version.attr,
2101         NULL,
2102 };
2103
2104 static struct target_core_fabric_ops tcm_vhost_ops = {
2105         .get_fabric_name                = tcm_vhost_get_fabric_name,
2106         .get_fabric_proto_ident         = tcm_vhost_get_fabric_proto_ident,
2107         .tpg_get_wwn                    = tcm_vhost_get_fabric_wwn,
2108         .tpg_get_tag                    = tcm_vhost_get_tag,
2109         .tpg_get_default_depth          = tcm_vhost_get_default_depth,
2110         .tpg_get_pr_transport_id        = tcm_vhost_get_pr_transport_id,
2111         .tpg_get_pr_transport_id_len    = tcm_vhost_get_pr_transport_id_len,
2112         .tpg_parse_pr_out_transport_id  = tcm_vhost_parse_pr_out_transport_id,
2113         .tpg_check_demo_mode            = tcm_vhost_check_true,
2114         .tpg_check_demo_mode_cache      = tcm_vhost_check_true,
2115         .tpg_check_demo_mode_write_protect = tcm_vhost_check_false,
2116         .tpg_check_prod_mode_write_protect = tcm_vhost_check_false,
2117         .tpg_alloc_fabric_acl           = tcm_vhost_alloc_fabric_acl,
2118         .tpg_release_fabric_acl         = tcm_vhost_release_fabric_acl,
2119         .tpg_get_inst_index             = tcm_vhost_tpg_get_inst_index,
2120         .release_cmd                    = tcm_vhost_release_cmd,
2121         .check_stop_free                = vhost_scsi_check_stop_free,
2122         .shutdown_session               = tcm_vhost_shutdown_session,
2123         .close_session                  = tcm_vhost_close_session,
2124         .sess_get_index                 = tcm_vhost_sess_get_index,
2125         .sess_get_initiator_sid         = NULL,
2126         .write_pending                  = tcm_vhost_write_pending,
2127         .write_pending_status           = tcm_vhost_write_pending_status,
2128         .set_default_node_attributes    = tcm_vhost_set_default_node_attrs,
2129         .get_task_tag                   = tcm_vhost_get_task_tag,
2130         .get_cmd_state                  = tcm_vhost_get_cmd_state,
2131         .queue_data_in                  = tcm_vhost_queue_data_in,
2132         .queue_status                   = tcm_vhost_queue_status,
2133         .queue_tm_rsp                   = tcm_vhost_queue_tm_rsp,
2134         /*
2135          * Setup callers for generic logic in target_core_fabric_configfs.c
2136          */
2137         .fabric_make_wwn                = tcm_vhost_make_tport,
2138         .fabric_drop_wwn                = tcm_vhost_drop_tport,
2139         .fabric_make_tpg                = tcm_vhost_make_tpg,
2140         .fabric_drop_tpg                = tcm_vhost_drop_tpg,
2141         .fabric_post_link               = tcm_vhost_port_link,
2142         .fabric_pre_unlink              = tcm_vhost_port_unlink,
2143         .fabric_make_np                 = NULL,
2144         .fabric_drop_np                 = NULL,
2145         .fabric_make_nodeacl            = tcm_vhost_make_nodeacl,
2146         .fabric_drop_nodeacl            = tcm_vhost_drop_nodeacl,
2147 };
2148
2149 static int tcm_vhost_register_configfs(void)
2150 {
2151         struct target_fabric_configfs *fabric;
2152         int ret;
2153
2154         pr_debug("TCM_VHOST fabric module %s on %s/%s"
2155                 " on "UTS_RELEASE"\n", TCM_VHOST_VERSION, utsname()->sysname,
2156                 utsname()->machine);
2157         /*
2158          * Register the top level struct config_item_type with TCM core
2159          */
2160         fabric = target_fabric_configfs_init(THIS_MODULE, "vhost");
2161         if (IS_ERR(fabric)) {
2162                 pr_err("target_fabric_configfs_init() failed\n");
2163                 return PTR_ERR(fabric);
2164         }
2165         /*
2166          * Setup fabric->tf_ops from our local tcm_vhost_ops
2167          */
2168         fabric->tf_ops = tcm_vhost_ops;
2169         /*
2170          * Setup default attribute lists for various fabric->tf_cit_tmpl
2171          */
2172         fabric->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = tcm_vhost_wwn_attrs;
2173         fabric->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = tcm_vhost_tpg_attrs;
2174         fabric->tf_cit_tmpl.tfc_tpg_attrib_cit.ct_attrs = NULL;
2175         fabric->tf_cit_tmpl.tfc_tpg_param_cit.ct_attrs = NULL;
2176         fabric->tf_cit_tmpl.tfc_tpg_np_base_cit.ct_attrs = NULL;
2177         fabric->tf_cit_tmpl.tfc_tpg_nacl_base_cit.ct_attrs = NULL;
2178         fabric->tf_cit_tmpl.tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
2179         fabric->tf_cit_tmpl.tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
2180         fabric->tf_cit_tmpl.tfc_tpg_nacl_param_cit.ct_attrs = NULL;
2181         /*
2182          * Register the fabric for use within TCM
2183          */
2184         ret = target_fabric_configfs_register(fabric);
2185         if (ret < 0) {
2186                 pr_err("target_fabric_configfs_register() failed"
2187                                 " for TCM_VHOST\n");
2188                 return ret;
2189         }
2190         /*
2191          * Setup our local pointer to *fabric
2192          */
2193         tcm_vhost_fabric_configfs = fabric;
2194         pr_debug("TCM_VHOST[0] - Set fabric -> tcm_vhost_fabric_configfs\n");
2195         return 0;
2196 };
2197
2198 static void tcm_vhost_deregister_configfs(void)
2199 {
2200         if (!tcm_vhost_fabric_configfs)
2201                 return;
2202
2203         target_fabric_configfs_deregister(tcm_vhost_fabric_configfs);
2204         tcm_vhost_fabric_configfs = NULL;
2205         pr_debug("TCM_VHOST[0] - Cleared tcm_vhost_fabric_configfs\n");
2206 };
2207
2208 static int __init tcm_vhost_init(void)
2209 {
2210         int ret = -ENOMEM;
2211         /*
2212          * Use our own dedicated workqueue for submitting I/O into
2213          * target core to avoid contention within system_wq.
2214          */
2215         tcm_vhost_workqueue = alloc_workqueue("tcm_vhost", 0, 0);
2216         if (!tcm_vhost_workqueue)
2217                 goto out;
2218
2219         ret = vhost_scsi_register();
2220         if (ret < 0)
2221                 goto out_destroy_workqueue;
2222
2223         ret = tcm_vhost_register_configfs();
2224         if (ret < 0)
2225                 goto out_vhost_scsi_deregister;
2226
2227         return 0;
2228
2229 out_vhost_scsi_deregister:
2230         vhost_scsi_deregister();
2231 out_destroy_workqueue:
2232         destroy_workqueue(tcm_vhost_workqueue);
2233 out:
2234         return ret;
2235 };
2236
2237 static void tcm_vhost_exit(void)
2238 {
2239         tcm_vhost_deregister_configfs();
2240         vhost_scsi_deregister();
2241         destroy_workqueue(tcm_vhost_workqueue);
2242 };
2243
2244 MODULE_DESCRIPTION("VHOST_SCSI series fabric driver");
2245 MODULE_ALIAS("tcm_vhost");
2246 MODULE_LICENSE("GPL");
2247 module_init(tcm_vhost_init);
2248 module_exit(tcm_vhost_exit);