1// SPDX-License-Identifier: GPL-2.0+
   2/*******************************************************************************
   3 * Vhost kernel TCM fabric driver for virtio SCSI initiators
   4 *
   5 * (C) Copyright 2010-2013 Datera, Inc.
   6 * (C) Copyright 2010-2012 IBM Corp.
   7 *
 
 
   8 * Authors: Nicholas A. Bellinger <nab@daterainc.com>
   9 *          Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
 
 
 
 
 
 
 
 
 
 
 
  10 ****************************************************************************/
  11
  12#include <linux/module.h>
  13#include <linux/moduleparam.h>
  14#include <generated/utsrelease.h>
  15#include <linux/utsname.h>
  16#include <linux/init.h>
  17#include <linux/slab.h>
  18#include <linux/kthread.h>
  19#include <linux/types.h>
  20#include <linux/string.h>
  21#include <linux/configfs.h>
  22#include <linux/ctype.h>
  23#include <linux/compat.h>
  24#include <linux/eventfd.h>
  25#include <linux/fs.h>
  26#include <linux/vmalloc.h>
  27#include <linux/miscdevice.h>
  28#include <linux/blk_types.h>
  29#include <linux/bio.h>
  30#include <asm/unaligned.h>
  31#include <scsi/scsi_common.h>
  32#include <scsi/scsi_proto.h>
  33#include <target/target_core_base.h>
  34#include <target/target_core_fabric.h>
 
 
 
  35#include <linux/vhost.h>
  36#include <linux/virtio_scsi.h>
  37#include <linux/llist.h>
  38#include <linux/bitmap.h>
 
  39
  40#include "vhost.h"
  41
  42#define VHOST_SCSI_VERSION  "v0.1"
  43#define VHOST_SCSI_NAMELEN 256
  44#define VHOST_SCSI_MAX_CDB_SIZE 32
  45#define VHOST_SCSI_PREALLOC_SGLS 2048
  46#define VHOST_SCSI_PREALLOC_UPAGES 2048
  47#define VHOST_SCSI_PREALLOC_PROT_SGLS 2048
  48
  49/* Max number of requests before requeueing the job.
  50 * Using this limit prevents one virtqueue from starving others with
  51 * request.
  52 */
  53#define VHOST_SCSI_WEIGHT 256
  54
  55struct vhost_scsi_inflight {
  56	/* Wait for the flush operation to finish */
  57	struct completion comp;
  58	/* Refcount for the inflight reqs */
  59	struct kref kref;
  60};
  61
  62struct vhost_scsi_cmd {
  63	/* Descriptor from vhost_get_vq_desc() for virt_queue segment */
  64	int tvc_vq_desc;
  65	/* virtio-scsi initiator task attribute */
  66	int tvc_task_attr;
  67	/* virtio-scsi response incoming iovecs */
  68	int tvc_in_iovs;
  69	/* virtio-scsi initiator data direction */
  70	enum dma_data_direction tvc_data_direction;
  71	/* Expected data transfer length from virtio-scsi header */
  72	u32 tvc_exp_data_len;
  73	/* The Tag from include/linux/virtio_scsi.h:struct virtio_scsi_cmd_req */
  74	u64 tvc_tag;
  75	/* The number of scatterlists associated with this cmd */
  76	u32 tvc_sgl_count;
  77	u32 tvc_prot_sgl_count;
  78	/* Saved unpacked SCSI LUN for vhost_scsi_target_queue_cmd() */
  79	u32 tvc_lun;
  80	u32 copied_iov:1;
  81	const void *saved_iter_addr;
  82	struct iov_iter saved_iter;
  83	/* Pointer to the SGL formatted memory from virtio-scsi */
  84	struct scatterlist *tvc_sgl;
  85	struct scatterlist *tvc_prot_sgl;
  86	struct page **tvc_upages;
  87	/* Pointer to response header iovec */
  88	struct iovec *tvc_resp_iov;
  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 vhost_scsi_nexus *tvc_nexus;
  95	/* The TCM I/O descriptor that is accessed via container_of() */
  96	struct se_cmd tvc_se_cmd;
 
 
  97	/* Copy of the incoming SCSI command descriptor block (CDB) */
  98	unsigned char tvc_cdb[VHOST_SCSI_MAX_CDB_SIZE];
  99	/* Sense buffer that will be mapped into outgoing status */
 100	unsigned char tvc_sense_buf[TRANSPORT_SENSE_BUFFER];
 101	/* Completed commands list, serviced from vhost worker thread */
 102	struct llist_node tvc_completion_list;
 103	/* Used to track inflight cmd */
 104	struct vhost_scsi_inflight *inflight;
 105};
 106
 107struct vhost_scsi_nexus {
 108	/* Pointer to TCM session for I_T Nexus */
 109	struct se_session *tvn_se_sess;
 110};
 111
 112struct vhost_scsi_tpg {
 
 
 
 
 
 
 
 
 
 113	/* Vhost port target portal group tag for TCM */
 114	u16 tport_tpgt;
 115	/* Used to track number of TPG Port/Lun Links wrt to explict I_T Nexus shutdown */
 116	int tv_tpg_port_count;
 117	/* Used for vhost_scsi device reference to tpg_nexus, protected by tv_tpg_mutex */
 118	int tv_tpg_vhost_count;
 119	/* Used for enabling T10-PI with legacy devices */
 120	int tv_fabric_prot_type;
 121	/* list for vhost_scsi_list */
 122	struct list_head tv_tpg_list;
 123	/* Used to protect access for tpg_nexus */
 124	struct mutex tv_tpg_mutex;
 125	/* Pointer to the TCM VHost I_T Nexus for this TPG endpoint */
 126	struct vhost_scsi_nexus *tpg_nexus;
 127	/* Pointer back to vhost_scsi_tport */
 128	struct vhost_scsi_tport *tport;
 129	/* Returned by vhost_scsi_make_tpg() */
 130	struct se_portal_group se_tpg;
 131	/* Pointer back to vhost_scsi, protected by tv_tpg_mutex */
 132	struct vhost_scsi *vhost_scsi;
 133};
 134
 135struct vhost_scsi_tport {
 136	/* SCSI protocol the tport is providing */
 137	u8 tport_proto_id;
 138	/* Binary World Wide unique Port Name for Vhost Target port */
 139	u64 tport_wwpn;
 140	/* ASCII formatted WWPN for Vhost Target port */
 141	char tport_name[VHOST_SCSI_NAMELEN];
 142	/* Returned by vhost_scsi_make_tport() */
 143	struct se_wwn tport_wwn;
 144};
 145
 146struct vhost_scsi_evt {
 147	/* event to be sent to guest */
 148	struct virtio_scsi_event event;
 149	/* event list, serviced from vhost worker thread */
 150	struct llist_node list;
 151};
 152
 153enum {
 154	VHOST_SCSI_VQ_CTL = 0,
 155	VHOST_SCSI_VQ_EVT = 1,
 156	VHOST_SCSI_VQ_IO = 2,
 157};
 158
 159/* Note: can't set VIRTIO_F_VERSION_1 yet, since that implies ANY_LAYOUT. */
 160enum {
 161	VHOST_SCSI_FEATURES = VHOST_FEATURES | (1ULL << VIRTIO_SCSI_F_HOTPLUG) |
 162					       (1ULL << VIRTIO_SCSI_F_T10_PI)
 163};
 164
 165#define VHOST_SCSI_MAX_TARGET	256
 166#define VHOST_SCSI_MAX_IO_VQ	1024
 167#define VHOST_SCSI_MAX_EVENT	128
 168
 169static unsigned vhost_scsi_max_io_vqs = 128;
 170module_param_named(max_io_vqs, vhost_scsi_max_io_vqs, uint, 0644);
 171MODULE_PARM_DESC(max_io_vqs, "Set the max number of IO virtqueues a vhost scsi device can support. The default is 128. The max is 1024.");
 172
 173struct vhost_scsi_virtqueue {
 174	struct vhost_virtqueue vq;
 175	struct vhost_scsi *vs;
 176	/*
 177	 * Reference counting for inflight reqs, used for flush operation. At
 178	 * each time, one reference tracks new commands submitted, while we
 179	 * wait for another one to reach 0.
 180	 */
 181	struct vhost_scsi_inflight inflights[2];
 182	/*
 183	 * Indicate current inflight in use, protected by vq->mutex.
 184	 * Writers must also take dev mutex and flush under it.
 185	 */
 186	int inflight_idx;
 187	struct vhost_scsi_cmd *scsi_cmds;
 188	struct sbitmap scsi_tags;
 189	int max_cmds;
 190
 191	struct vhost_work completion_work;
 192	struct llist_head completion_list;
 193};
 194
 195struct vhost_scsi {
 196	/* Protected by vhost_scsi->dev.mutex */
 197	struct vhost_scsi_tpg **vs_tpg;
 198	char vs_vhost_wwpn[TRANSPORT_IQN_LEN];
 199
 200	struct vhost_dev dev;
 201	struct vhost_scsi_virtqueue *vqs;
 202	struct vhost_scsi_inflight **old_inflight;
 
 
 203
 204	struct vhost_work vs_event_work; /* evt injection work item */
 205	struct llist_head vs_event_list; /* evt injection queue */
 206
 207	bool vs_events_missed; /* any missed events, protected by vq->mutex */
 208	int vs_events_nr; /* num of pending events, protected by vq->mutex */
 209};
 210
 211struct vhost_scsi_tmf {
 212	struct vhost_work vwork;
 213	struct vhost_scsi *vhost;
 214	struct vhost_scsi_virtqueue *svq;
 215
 216	struct se_cmd se_cmd;
 217	u8 scsi_resp;
 218	struct vhost_scsi_inflight *inflight;
 219	struct iovec resp_iov;
 220	int in_iovs;
 221	int vq_desc;
 222};
 223
 224/*
 225 * Context for processing request and control queue operations.
 226 */
 227struct vhost_scsi_ctx {
 228	int head;
 229	unsigned int out, in;
 230	size_t req_size, rsp_size;
 231	size_t out_size, in_size;
 232	u8 *target, *lunp;
 233	void *req;
 234	struct iov_iter out_iter;
 235};
 236
 237/*
 238 * Global mutex to protect vhost_scsi TPG list for vhost IOCTLs and LIO
 239 * configfs management operations.
 240 */
 241static DEFINE_MUTEX(vhost_scsi_mutex);
 242static LIST_HEAD(vhost_scsi_list);
 243
 244static void vhost_scsi_done_inflight(struct kref *kref)
 245{
 246	struct vhost_scsi_inflight *inflight;
 247
 248	inflight = container_of(kref, struct vhost_scsi_inflight, kref);
 249	complete(&inflight->comp);
 250}
 251
 252static void vhost_scsi_init_inflight(struct vhost_scsi *vs,
 253				    struct vhost_scsi_inflight *old_inflight[])
 254{
 255	struct vhost_scsi_inflight *new_inflight;
 256	struct vhost_virtqueue *vq;
 257	int idx, i;
 258
 259	for (i = 0; i < vs->dev.nvqs;  i++) {
 260		vq = &vs->vqs[i].vq;
 261
 262		mutex_lock(&vq->mutex);
 263
 264		/* store old infight */
 265		idx = vs->vqs[i].inflight_idx;
 266		if (old_inflight)
 267			old_inflight[i] = &vs->vqs[i].inflights[idx];
 268
 269		/* setup new infight */
 270		vs->vqs[i].inflight_idx = idx ^ 1;
 271		new_inflight = &vs->vqs[i].inflights[idx ^ 1];
 272		kref_init(&new_inflight->kref);
 273		init_completion(&new_inflight->comp);
 274
 275		mutex_unlock(&vq->mutex);
 276	}
 277}
 278
 279static struct vhost_scsi_inflight *
 280vhost_scsi_get_inflight(struct vhost_virtqueue *vq)
 281{
 282	struct vhost_scsi_inflight *inflight;
 283	struct vhost_scsi_virtqueue *svq;
 284
 285	svq = container_of(vq, struct vhost_scsi_virtqueue, vq);
 286	inflight = &svq->inflights[svq->inflight_idx];
 287	kref_get(&inflight->kref);
 288
 289	return inflight;
 290}
 291
 292static void vhost_scsi_put_inflight(struct vhost_scsi_inflight *inflight)
 293{
 294	kref_put(&inflight->kref, vhost_scsi_done_inflight);
 295}
 296
 297static int vhost_scsi_check_true(struct se_portal_group *se_tpg)
 298{
 299	return 1;
 300}
 301
 302static char *vhost_scsi_get_fabric_wwn(struct se_portal_group *se_tpg)
 
 
 
 
 
 303{
 304	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
 305				struct vhost_scsi_tpg, se_tpg);
 306	struct vhost_scsi_tport *tport = tpg->tport;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 307
 308	return &tport->tport_name[0];
 309}
 310
 311static u16 vhost_scsi_get_tpgt(struct se_portal_group *se_tpg)
 312{
 313	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
 314				struct vhost_scsi_tpg, se_tpg);
 315	return tpg->tport_tpgt;
 316}
 317
 318static int vhost_scsi_check_prot_fabric_only(struct se_portal_group *se_tpg)
 319{
 320	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
 321				struct vhost_scsi_tpg, se_tpg);
 322
 323	return tpg->tv_fabric_prot_type;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 324}
 325
 326static void vhost_scsi_release_cmd_res(struct se_cmd *se_cmd)
 327{
 328	struct vhost_scsi_cmd *tv_cmd = container_of(se_cmd,
 329				struct vhost_scsi_cmd, tvc_se_cmd);
 330	struct vhost_scsi_virtqueue *svq = container_of(tv_cmd->tvc_vq,
 331				struct vhost_scsi_virtqueue, vq);
 332	struct vhost_scsi_inflight *inflight = tv_cmd->inflight;
 333	int i;
 
 334
 335	if (tv_cmd->tvc_sgl_count) {
 336		for (i = 0; i < tv_cmd->tvc_sgl_count; i++) {
 337			if (tv_cmd->copied_iov)
 338				__free_page(sg_page(&tv_cmd->tvc_sgl[i]));
 339			else
 340				put_page(sg_page(&tv_cmd->tvc_sgl[i]));
 341		}
 342		kfree(tv_cmd->saved_iter_addr);
 
 
 
 
 
 
 343	}
 344	if (tv_cmd->tvc_prot_sgl_count) {
 345		for (i = 0; i < tv_cmd->tvc_prot_sgl_count; i++)
 346			put_page(sg_page(&tv_cmd->tvc_prot_sgl[i]));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 347	}
 348
 349	sbitmap_clear_bit(&svq->scsi_tags, se_cmd->map_tag);
 350	vhost_scsi_put_inflight(inflight);
 351}
 352
 353static void vhost_scsi_release_tmf_res(struct vhost_scsi_tmf *tmf)
 
 354{
 355	struct vhost_scsi_inflight *inflight = tmf->inflight;
 356
 357	kfree(tmf);
 358	vhost_scsi_put_inflight(inflight);
 
 
 
 
 
 359}
 360
 361static void vhost_scsi_release_cmd(struct se_cmd *se_cmd)
 
 
 362{
 363	if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) {
 364		struct vhost_scsi_tmf *tmf = container_of(se_cmd,
 365					struct vhost_scsi_tmf, se_cmd);
 366		struct vhost_virtqueue *vq = &tmf->svq->vq;
 367
 368		vhost_vq_work_queue(vq, &tmf->vwork);
 369	} else {
 370		struct vhost_scsi_cmd *cmd = container_of(se_cmd,
 371					struct vhost_scsi_cmd, tvc_se_cmd);
 372		struct vhost_scsi_virtqueue *svq =  container_of(cmd->tvc_vq,
 373					struct vhost_scsi_virtqueue, vq);
 
 
 
 
 374
 375		llist_add(&cmd->tvc_completion_list, &svq->completion_list);
 376		vhost_vq_work_queue(&svq->vq, &svq->completion_work);
 
 
 377	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 378}
 379
 380static int vhost_scsi_write_pending(struct se_cmd *se_cmd)
 
 
 
 
 
 381{
 382	/* Go ahead and process the write immediately */
 383	target_execute_cmd(se_cmd);
 384	return 0;
 385}
 386
 387static int vhost_scsi_queue_data_in(struct se_cmd *se_cmd)
 388{
 389	transport_generic_free_cmd(se_cmd, 0);
 390	return 0;
 391}
 392
 393static int vhost_scsi_queue_status(struct se_cmd *se_cmd)
 
 
 
 
 
 394{
 395	transport_generic_free_cmd(se_cmd, 0);
 396	return 0;
 397}
 398
 399static void vhost_scsi_queue_tm_rsp(struct se_cmd *se_cmd)
 400{
 401	struct vhost_scsi_tmf *tmf = container_of(se_cmd, struct vhost_scsi_tmf,
 402						  se_cmd);
 
 
 
 
 
 
 403
 404	tmf->scsi_resp = se_cmd->se_tmr_req->response;
 405	transport_generic_free_cmd(&tmf->se_cmd, 0);
 406}
 407
 408static void vhost_scsi_aborted_task(struct se_cmd *se_cmd)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 409{
 410	return;
 411}
 412
 413static void vhost_scsi_free_evt(struct vhost_scsi *vs, struct vhost_scsi_evt *evt)
 
 
 
 
 
 414{
 415	vs->vs_events_nr--;
 416	kfree(evt);
 417}
 418
 419static struct vhost_scsi_evt *
 420vhost_scsi_allocate_evt(struct vhost_scsi *vs,
 421		       u32 event, u32 reason)
 422{
 423	struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
 424	struct vhost_scsi_evt *evt;
 425
 426	if (vs->vs_events_nr > VHOST_SCSI_MAX_EVENT) {
 427		vs->vs_events_missed = true;
 428		return NULL;
 429	}
 430
 431	evt = kzalloc(sizeof(*evt), GFP_KERNEL);
 432	if (!evt) {
 433		vq_err(vq, "Failed to allocate vhost_scsi_evt\n");
 434		vs->vs_events_missed = true;
 435		return NULL;
 436	}
 437
 438	evt->event.event = cpu_to_vhost32(vq, event);
 439	evt->event.reason = cpu_to_vhost32(vq, reason);
 440	vs->vs_events_nr++;
 441
 442	return evt;
 443}
 444
 
 
 
 
 
 
 
 
 
 445static int vhost_scsi_check_stop_free(struct se_cmd *se_cmd)
 446{
 447	return target_put_sess_cmd(se_cmd);
 448}
 449
 450static void
 451vhost_scsi_do_evt_work(struct vhost_scsi *vs, struct vhost_scsi_evt *evt)
 452{
 453	struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
 454	struct virtio_scsi_event *event = &evt->event;
 455	struct virtio_scsi_event __user *eventp;
 456	unsigned out, in;
 457	int head, ret;
 458
 459	if (!vhost_vq_get_backend(vq)) {
 460		vs->vs_events_missed = true;
 461		return;
 462	}
 463
 464again:
 465	vhost_disable_notify(&vs->dev, vq);
 466	head = vhost_get_vq_desc(vq, vq->iov,
 467			ARRAY_SIZE(vq->iov), &out, &in,
 468			NULL, NULL);
 469	if (head < 0) {
 470		vs->vs_events_missed = true;
 471		return;
 472	}
 473	if (head == vq->num) {
 474		if (vhost_enable_notify(&vs->dev, vq))
 475			goto again;
 476		vs->vs_events_missed = true;
 477		return;
 478	}
 479
 480	if ((vq->iov[out].iov_len != sizeof(struct virtio_scsi_event))) {
 481		vq_err(vq, "Expecting virtio_scsi_event, got %zu bytes\n",
 482				vq->iov[out].iov_len);
 483		vs->vs_events_missed = true;
 484		return;
 485	}
 486
 487	if (vs->vs_events_missed) {
 488		event->event |= cpu_to_vhost32(vq, VIRTIO_SCSI_T_EVENTS_MISSED);
 489		vs->vs_events_missed = false;
 490	}
 491
 492	eventp = vq->iov[out].iov_base;
 493	ret = __copy_to_user(eventp, event, sizeof(*event));
 494	if (!ret)
 495		vhost_add_used_and_signal(&vs->dev, vq, head, 0);
 496	else
 497		vq_err(vq, "Faulted on vhost_scsi_send_event\n");
 498}
 499
 500static void vhost_scsi_evt_work(struct vhost_work *work)
 501{
 502	struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
 503					vs_event_work);
 504	struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
 505	struct vhost_scsi_evt *evt, *t;
 506	struct llist_node *llnode;
 507
 508	mutex_lock(&vq->mutex);
 509	llnode = llist_del_all(&vs->vs_event_list);
 510	llist_for_each_entry_safe(evt, t, llnode, list) {
 511		vhost_scsi_do_evt_work(vs, evt);
 512		vhost_scsi_free_evt(vs, evt);
 
 
 513	}
 514	mutex_unlock(&vq->mutex);
 515}
 516
 517static int vhost_scsi_copy_sgl_to_iov(struct vhost_scsi_cmd *cmd)
 518{
 519	struct iov_iter *iter = &cmd->saved_iter;
 520	struct scatterlist *sg = cmd->tvc_sgl;
 521	struct page *page;
 522	size_t len;
 523	int i;
 524
 525	for (i = 0; i < cmd->tvc_sgl_count; i++) {
 526		page = sg_page(&sg[i]);
 527		len = sg[i].length;
 528
 529		if (copy_page_to_iter(page, 0, len, iter) != len) {
 530			pr_err("Could not copy data while handling misaligned cmd. Error %zu\n",
 531			       len);
 532			return -1;
 533		}
 534	}
 535
 536	return 0;
 537}
 538
 539/* Fill in status and signal that we are done processing this command
 540 *
 541 * This is scheduled in the vhost work queue so we are called with the owner
 542 * process mm and can access the vring.
 543 */
 544static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
 545{
 546	struct vhost_scsi_virtqueue *svq = container_of(work,
 547				struct vhost_scsi_virtqueue, completion_work);
 
 548	struct virtio_scsi_cmd_resp v_rsp;
 549	struct vhost_scsi_cmd *cmd, *t;
 550	struct llist_node *llnode;
 551	struct se_cmd *se_cmd;
 552	struct iov_iter iov_iter;
 553	bool signal = false;
 554	int ret;
 555
 556	llnode = llist_del_all(&svq->completion_list);
 557	llist_for_each_entry_safe(cmd, t, llnode, tvc_completion_list) {
 
 
 
 
 558		se_cmd = &cmd->tvc_se_cmd;
 559
 560		pr_debug("%s tv_cmd %p resid %u status %#02x\n", __func__,
 561			cmd, se_cmd->residual_count, se_cmd->scsi_status);
 562		memset(&v_rsp, 0, sizeof(v_rsp));
 563
 564		if (cmd->saved_iter_addr && vhost_scsi_copy_sgl_to_iov(cmd)) {
 565			v_rsp.response = VIRTIO_SCSI_S_BAD_TARGET;
 566		} else {
 567			v_rsp.resid = cpu_to_vhost32(cmd->tvc_vq,
 568						     se_cmd->residual_count);
 569			/* TODO is status_qualifier field needed? */
 570			v_rsp.status = se_cmd->scsi_status;
 571			v_rsp.sense_len = cpu_to_vhost32(cmd->tvc_vq,
 572							 se_cmd->scsi_sense_length);
 573			memcpy(v_rsp.sense, cmd->tvc_sense_buf,
 574			       se_cmd->scsi_sense_length);
 575		}
 576
 577		iov_iter_init(&iov_iter, ITER_DEST, cmd->tvc_resp_iov,
 578			      cmd->tvc_in_iovs, sizeof(v_rsp));
 579		ret = copy_to_iter(&v_rsp, sizeof(v_rsp), &iov_iter);
 580		if (likely(ret == sizeof(v_rsp))) {
 581			signal = true;
 582
 
 
 
 
 
 
 
 
 
 
 583			vhost_add_used(cmd->tvc_vq, cmd->tvc_vq_desc, 0);
 
 
 
 584		} else
 585			pr_err("Faulted on virtio_scsi_cmd_resp\n");
 586
 587		vhost_scsi_release_cmd_res(se_cmd);
 588	}
 589
 590	if (signal)
 591		vhost_signal(&svq->vs->dev, &svq->vq);
 
 
 592}
 593
 594static struct vhost_scsi_cmd *
 595vhost_scsi_get_cmd(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg,
 596		   unsigned char *cdb, u64 scsi_tag, u16 lun, u8 task_attr,
 597		   u32 exp_data_len, int data_direction)
 
 
 598{
 599	struct vhost_scsi_virtqueue *svq = container_of(vq,
 600					struct vhost_scsi_virtqueue, vq);
 601	struct vhost_scsi_cmd *cmd;
 602	struct vhost_scsi_nexus *tv_nexus;
 603	struct scatterlist *sg, *prot_sg;
 604	struct iovec *tvc_resp_iov;
 605	struct page **pages;
 606	int tag;
 607
 608	tv_nexus = tpg->tpg_nexus;
 609	if (!tv_nexus) {
 610		pr_err("Unable to locate active struct vhost_scsi_nexus\n");
 611		return ERR_PTR(-EIO);
 612	}
 
 613
 614	tag = sbitmap_get(&svq->scsi_tags);
 615	if (tag < 0) {
 616		pr_err("Unable to obtain tag for vhost_scsi_cmd\n");
 617		return ERR_PTR(-ENOMEM);
 618	}
 619
 620	cmd = &svq->scsi_cmds[tag];
 621	sg = cmd->tvc_sgl;
 622	prot_sg = cmd->tvc_prot_sgl;
 623	pages = cmd->tvc_upages;
 624	tvc_resp_iov = cmd->tvc_resp_iov;
 625	memset(cmd, 0, sizeof(*cmd));
 626	cmd->tvc_sgl = sg;
 627	cmd->tvc_prot_sgl = prot_sg;
 628	cmd->tvc_upages = pages;
 629	cmd->tvc_se_cmd.map_tag = tag;
 630	cmd->tvc_tag = scsi_tag;
 631	cmd->tvc_lun = lun;
 632	cmd->tvc_task_attr = task_attr;
 633	cmd->tvc_exp_data_len = exp_data_len;
 634	cmd->tvc_data_direction = data_direction;
 635	cmd->tvc_nexus = tv_nexus;
 636	cmd->inflight = vhost_scsi_get_inflight(vq);
 637	cmd->tvc_resp_iov = tvc_resp_iov;
 638
 639	memcpy(cmd->tvc_cdb, cdb, VHOST_SCSI_MAX_CDB_SIZE);
 640
 641	return cmd;
 642}
 643
 644/*
 645 * Map a user memory range into a scatterlist
 646 *
 647 * Returns the number of scatterlist entries used or -errno on error.
 648 */
 649static int
 650vhost_scsi_map_to_sgl(struct vhost_scsi_cmd *cmd,
 651		      struct iov_iter *iter,
 652		      struct scatterlist *sgl,
 653		      bool is_prot)
 
 
 654{
 655	struct page **pages = cmd->tvc_upages;
 656	struct scatterlist *sg = sgl;
 657	ssize_t bytes, mapped_bytes;
 658	size_t offset, mapped_offset;
 659	unsigned int npages = 0;
 660
 661	bytes = iov_iter_get_pages2(iter, pages, LONG_MAX,
 662				VHOST_SCSI_PREALLOC_UPAGES, &offset);
 663	/* No pages were pinned */
 664	if (bytes <= 0)
 665		return bytes < 0 ? bytes : -EFAULT;
 666
 667	mapped_bytes = bytes;
 668	mapped_offset = offset;
 669
 670	while (bytes) {
 671		unsigned n = min_t(unsigned, PAGE_SIZE - offset, bytes);
 672		/*
 673		 * The block layer requires bios/requests to be a multiple of
 674		 * 512 bytes, but Windows can send us vecs that are misaligned.
 675		 * This can result in bios and later requests with misaligned
 676		 * sizes if we have to break up a cmd/scatterlist into multiple
 677		 * bios.
 678		 *
 679		 * We currently only break up a command into multiple bios if
 680		 * we hit the vec/seg limit, so check if our sgl_count is
 681		 * greater than the max and if a vec in the cmd has a
 682		 * misaligned offset/size.
 683		 */
 684		if (!is_prot &&
 685		    (offset & (SECTOR_SIZE - 1) || n & (SECTOR_SIZE - 1)) &&
 686		    cmd->tvc_sgl_count > BIO_MAX_VECS) {
 687			WARN_ONCE(true,
 688				  "vhost-scsi detected misaligned IO. Performance may be degraded.");
 689			goto revert_iter_get_pages;
 690		}
 691
 692		sg_set_page(sg++, pages[npages++], n, offset);
 693		bytes -= n;
 694		offset = 0;
 
 
 695	}
 696
 697	return npages;
 698
 699revert_iter_get_pages:
 700	iov_iter_revert(iter, mapped_bytes);
 701
 702	npages = 0;
 703	while (mapped_bytes) {
 704		unsigned int n = min_t(unsigned int, PAGE_SIZE - mapped_offset,
 705				       mapped_bytes);
 706
 707		put_page(pages[npages++]);
 708
 709		mapped_bytes -= n;
 710		mapped_offset = 0;
 
 711	}
 712
 713	return -EINVAL;
 714}
 715
 716static int
 717vhost_scsi_calc_sgls(struct iov_iter *iter, size_t bytes, int max_sgls)
 718{
 719	int sgl_count = 0;
 720
 721	if (!iter || !iter_iov(iter)) {
 722		pr_err("%s: iter->iov is NULL, but expected bytes: %zu"
 723		       " present\n", __func__, bytes);
 724		return -EINVAL;
 725	}
 726
 727	sgl_count = iov_iter_npages(iter, 0xffff);
 728	if (sgl_count > max_sgls) {
 729		pr_err("%s: requested sgl_count: %d exceeds pre-allocated"
 730		       " max_sgls: %d\n", __func__, sgl_count, max_sgls);
 731		return -EINVAL;
 
 
 
 
 
 732	}
 733	return sgl_count;
 734}
 735
 736static int
 737vhost_scsi_copy_iov_to_sgl(struct vhost_scsi_cmd *cmd, struct iov_iter *iter,
 738			   struct scatterlist *sg, int sg_count)
 739{
 740	size_t len = iov_iter_count(iter);
 741	unsigned int nbytes = 0;
 742	struct page *page;
 743	int i;
 744
 745	if (cmd->tvc_data_direction == DMA_FROM_DEVICE) {
 746		cmd->saved_iter_addr = dup_iter(&cmd->saved_iter, iter,
 747						GFP_KERNEL);
 748		if (!cmd->saved_iter_addr)
 749			return -ENOMEM;
 750	}
 751
 752	for (i = 0; i < sg_count; i++) {
 753		page = alloc_page(GFP_KERNEL);
 754		if (!page) {
 755			i--;
 756			goto err;
 757		}
 758
 759		nbytes = min_t(unsigned int, PAGE_SIZE, len);
 760		sg_set_page(&sg[i], page, nbytes, 0);
 761
 762		if (cmd->tvc_data_direction == DMA_TO_DEVICE &&
 763		    copy_page_from_iter(page, 0, nbytes, iter) != nbytes)
 764			goto err;
 765
 
 
 
 
 
 766		len -= nbytes;
 
 
 767	}
 768
 769	cmd->copied_iov = 1;
 770	return 0;
 771
 772err:
 773	pr_err("Could not read %u bytes while handling misaligned cmd\n",
 774	       nbytes);
 775
 776	for (; i >= 0; i--)
 777		__free_page(sg_page(&sg[i]));
 778	kfree(cmd->saved_iter_addr);
 779	return -ENOMEM;
 780}
 781
 782static int
 783vhost_scsi_map_iov_to_sgl(struct vhost_scsi_cmd *cmd, struct iov_iter *iter,
 784			  struct scatterlist *sg, int sg_count, bool is_prot)
 
 
 785{
 786	struct scatterlist *p = sg;
 787	size_t revert_bytes;
 788	int ret;
 
 
 
 789
 790	while (iov_iter_count(iter)) {
 791		ret = vhost_scsi_map_to_sgl(cmd, iter, sg, is_prot);
 792		if (ret < 0) {
 793			revert_bytes = 0;
 794
 795			while (p < sg) {
 796				struct page *page = sg_page(p);
 797
 798				if (page) {
 799					put_page(page);
 800					revert_bytes += p->length;
 801				}
 802				p++;
 803			}
 804
 805			iov_iter_revert(iter, revert_bytes);
 806			return ret;
 807		}
 808		sg += ret;
 809	}
 810
 811	return 0;
 812}
 813
 814static int
 815vhost_scsi_mapal(struct vhost_scsi_cmd *cmd,
 816		 size_t prot_bytes, struct iov_iter *prot_iter,
 817		 size_t data_bytes, struct iov_iter *data_iter)
 818{
 819	int sgl_count, ret;
 820
 821	if (prot_bytes) {
 822		sgl_count = vhost_scsi_calc_sgls(prot_iter, prot_bytes,
 823						 VHOST_SCSI_PREALLOC_PROT_SGLS);
 824		if (sgl_count < 0)
 825			return sgl_count;
 826
 827		sg_init_table(cmd->tvc_prot_sgl, sgl_count);
 828		cmd->tvc_prot_sgl_count = sgl_count;
 829		pr_debug("%s prot_sg %p prot_sgl_count %u\n", __func__,
 830			 cmd->tvc_prot_sgl, cmd->tvc_prot_sgl_count);
 831
 832		ret = vhost_scsi_map_iov_to_sgl(cmd, prot_iter,
 833						cmd->tvc_prot_sgl,
 834						cmd->tvc_prot_sgl_count, true);
 835		if (ret < 0) {
 836			cmd->tvc_prot_sgl_count = 0;
 
 
 
 837			return ret;
 838		}
 839	}
 840	sgl_count = vhost_scsi_calc_sgls(data_iter, data_bytes,
 841					 VHOST_SCSI_PREALLOC_SGLS);
 842	if (sgl_count < 0)
 843		return sgl_count;
 844
 845	sg_init_table(cmd->tvc_sgl, sgl_count);
 846	cmd->tvc_sgl_count = sgl_count;
 847	pr_debug("%s data_sg %p data_sgl_count %u\n", __func__,
 848		  cmd->tvc_sgl, cmd->tvc_sgl_count);
 849
 850	ret = vhost_scsi_map_iov_to_sgl(cmd, data_iter, cmd->tvc_sgl,
 851					cmd->tvc_sgl_count, false);
 852	if (ret == -EINVAL) {
 853		sg_init_table(cmd->tvc_sgl, cmd->tvc_sgl_count);
 854		ret = vhost_scsi_copy_iov_to_sgl(cmd, data_iter, cmd->tvc_sgl,
 855						 cmd->tvc_sgl_count);
 856	}
 857
 858	if (ret < 0) {
 859		cmd->tvc_sgl_count = 0;
 860		return ret;
 861	}
 862	return 0;
 863}
 864
 865static int vhost_scsi_to_tcm_attr(int attr)
 866{
 867	switch (attr) {
 868	case VIRTIO_SCSI_S_SIMPLE:
 869		return TCM_SIMPLE_TAG;
 870	case VIRTIO_SCSI_S_ORDERED:
 871		return TCM_ORDERED_TAG;
 872	case VIRTIO_SCSI_S_HEAD:
 873		return TCM_HEAD_TAG;
 874	case VIRTIO_SCSI_S_ACA:
 875		return TCM_ACA_TAG;
 876	default:
 877		break;
 878	}
 879	return TCM_SIMPLE_TAG;
 880}
 881
 882static void vhost_scsi_target_queue_cmd(struct vhost_scsi_cmd *cmd)
 883{
 
 
 
 884	struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
 885	struct vhost_scsi_nexus *tv_nexus;
 886	struct scatterlist *sg_ptr, *sg_prot_ptr = NULL;
 887
 888	/* FIXME: BIDI operation */
 889	if (cmd->tvc_sgl_count) {
 890		sg_ptr = cmd->tvc_sgl;
 891
 892		if (cmd->tvc_prot_sgl_count)
 893			sg_prot_ptr = cmd->tvc_prot_sgl;
 894		else
 895			se_cmd->prot_pto = true;
 
 
 896	} else {
 897		sg_ptr = NULL;
 898	}
 899	tv_nexus = cmd->tvc_nexus;
 900
 901	se_cmd->tag = 0;
 902	target_init_cmd(se_cmd, tv_nexus->tvn_se_sess, &cmd->tvc_sense_buf[0],
 903			cmd->tvc_lun, cmd->tvc_exp_data_len,
 904			vhost_scsi_to_tcm_attr(cmd->tvc_task_attr),
 905			cmd->tvc_data_direction, TARGET_SCF_ACK_KREF);
 906
 907	if (target_submit_prep(se_cmd, cmd->tvc_cdb, sg_ptr,
 908			       cmd->tvc_sgl_count, NULL, 0, sg_prot_ptr,
 909			       cmd->tvc_prot_sgl_count, GFP_KERNEL))
 910		return;
 911
 912	target_submit(se_cmd);
 913}
 914
 915static void
 916vhost_scsi_send_bad_target(struct vhost_scsi *vs,
 917			   struct vhost_virtqueue *vq,
 918			   int head, unsigned out)
 919{
 920	struct virtio_scsi_cmd_resp __user *resp;
 921	struct virtio_scsi_cmd_resp rsp;
 922	int ret;
 923
 924	memset(&rsp, 0, sizeof(rsp));
 925	rsp.response = VIRTIO_SCSI_S_BAD_TARGET;
 926	resp = vq->iov[out].iov_base;
 927	ret = __copy_to_user(resp, &rsp, sizeof(rsp));
 928	if (!ret)
 929		vhost_add_used_and_signal(&vs->dev, vq, head, 0);
 930	else
 931		pr_err("Faulted on virtio_scsi_cmd_resp\n");
 932}
 933
 934static int
 935vhost_scsi_get_desc(struct vhost_scsi *vs, struct vhost_virtqueue *vq,
 936		    struct vhost_scsi_ctx *vc)
 937{
 938	int ret = -ENXIO;
 939
 940	vc->head = vhost_get_vq_desc(vq, vq->iov,
 941				     ARRAY_SIZE(vq->iov), &vc->out, &vc->in,
 942				     NULL, NULL);
 943
 944	pr_debug("vhost_get_vq_desc: head: %d, out: %u in: %u\n",
 945		 vc->head, vc->out, vc->in);
 946
 947	/* On error, stop handling until the next kick. */
 948	if (unlikely(vc->head < 0))
 949		goto done;
 950
 951	/* Nothing new?  Wait for eventfd to tell us they refilled. */
 952	if (vc->head == vq->num) {
 953		if (unlikely(vhost_enable_notify(&vs->dev, vq))) {
 954			vhost_disable_notify(&vs->dev, vq);
 955			ret = -EAGAIN;
 956		}
 957		goto done;
 958	}
 959
 960	/*
 961	 * Get the size of request and response buffers.
 962	 * FIXME: Not correct for BIDI operation
 963	 */
 964	vc->out_size = iov_length(vq->iov, vc->out);
 965	vc->in_size = iov_length(&vq->iov[vc->out], vc->in);
 966
 967	/*
 968	 * Copy over the virtio-scsi request header, which for a
 969	 * ANY_LAYOUT enabled guest may span multiple iovecs, or a
 970	 * single iovec may contain both the header + outgoing
 971	 * WRITE payloads.
 972	 *
 973	 * copy_from_iter() will advance out_iter, so that it will
 974	 * point at the start of the outgoing WRITE payload, if
 975	 * DMA_TO_DEVICE is set.
 976	 */
 977	iov_iter_init(&vc->out_iter, ITER_SOURCE, vq->iov, vc->out, vc->out_size);
 978	ret = 0;
 979
 980done:
 981	return ret;
 982}
 983
 984static int
 985vhost_scsi_chk_size(struct vhost_virtqueue *vq, struct vhost_scsi_ctx *vc)
 986{
 987	if (unlikely(vc->in_size < vc->rsp_size)) {
 988		vq_err(vq,
 989		       "Response buf too small, need min %zu bytes got %zu",
 990		       vc->rsp_size, vc->in_size);
 991		return -EINVAL;
 992	} else if (unlikely(vc->out_size < vc->req_size)) {
 993		vq_err(vq,
 994		       "Request buf too small, need min %zu bytes got %zu",
 995		       vc->req_size, vc->out_size);
 996		return -EIO;
 997	}
 998
 999	return 0;
1000}
1001
1002static int
1003vhost_scsi_get_req(struct vhost_virtqueue *vq, struct vhost_scsi_ctx *vc,
1004		   struct vhost_scsi_tpg **tpgp)
1005{
1006	int ret = -EIO;
1007
1008	if (unlikely(!copy_from_iter_full(vc->req, vc->req_size,
1009					  &vc->out_iter))) {
1010		vq_err(vq, "Faulted on copy_from_iter_full\n");
1011	} else if (unlikely(*vc->lunp != 1)) {
1012		/* virtio-scsi spec requires byte 0 of the lun to be 1 */
1013		vq_err(vq, "Illegal virtio-scsi lun: %u\n", *vc->lunp);
1014	} else {
1015		struct vhost_scsi_tpg **vs_tpg, *tpg;
1016
1017		vs_tpg = vhost_vq_get_backend(vq);	/* validated at handler entry */
1018
1019		tpg = READ_ONCE(vs_tpg[*vc->target]);
1020		if (unlikely(!tpg)) {
1021			vq_err(vq, "Target 0x%x does not exist\n", *vc->target);
1022		} else {
1023			if (tpgp)
1024				*tpgp = tpg;
1025			ret = 0;
1026		}
1027	}
1028
1029	return ret;
1030}
1031
1032static u16 vhost_buf_to_lun(u8 *lun_buf)
1033{
1034	return ((lun_buf[2] << 8) | lun_buf[3]) & 0x3FFF;
1035}
1036
1037static void
1038vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
1039{
1040	struct vhost_scsi_tpg **vs_tpg, *tpg;
1041	struct virtio_scsi_cmd_req v_req;
1042	struct virtio_scsi_cmd_req_pi v_req_pi;
1043	struct vhost_scsi_ctx vc;
1044	struct vhost_scsi_cmd *cmd;
1045	struct iov_iter in_iter, prot_iter, data_iter;
1046	u64 tag;
1047	u32 exp_data_len, data_direction;
1048	int ret, prot_bytes, i, c = 0;
1049	u16 lun;
1050	u8 task_attr;
1051	bool t10_pi = vhost_has_feature(vq, VIRTIO_SCSI_F_T10_PI);
1052	void *cdb;
1053
1054	mutex_lock(&vq->mutex);
1055	/*
1056	 * We can handle the vq only after the endpoint is setup by calling the
1057	 * VHOST_SCSI_SET_ENDPOINT ioctl.
1058	 */
1059	vs_tpg = vhost_vq_get_backend(vq);
1060	if (!vs_tpg)
1061		goto out;
1062
1063	memset(&vc, 0, sizeof(vc));
1064	vc.rsp_size = sizeof(struct virtio_scsi_cmd_resp);
1065
1066	vhost_disable_notify(&vs->dev, vq);
1067
1068	do {
1069		ret = vhost_scsi_get_desc(vs, vq, &vc);
1070		if (ret)
1071			goto err;
 
 
 
 
 
 
 
 
 
 
 
 
 
1072
1073		/*
1074		 * Setup pointers and values based upon different virtio-scsi
1075		 * request header if T10_PI is enabled in KVM guest.
1076		 */
1077		if (t10_pi) {
1078			vc.req = &v_req_pi;
1079			vc.req_size = sizeof(v_req_pi);
1080			vc.lunp = &v_req_pi.lun[0];
1081			vc.target = &v_req_pi.lun[1];
 
 
 
 
1082		} else {
1083			vc.req = &v_req;
1084			vc.req_size = sizeof(v_req);
1085			vc.lunp = &v_req.lun[0];
1086			vc.target = &v_req.lun[1];
1087		}
1088
1089		/*
1090		 * Validate the size of request and response buffers.
1091		 * Check for a sane response buffer so we can report
1092		 * early errors back to the guest.
1093		 */
1094		ret = vhost_scsi_chk_size(vq, &vc);
1095		if (ret)
1096			goto err;
1097
1098		ret = vhost_scsi_get_req(vq, &vc, &tpg);
1099		if (ret)
1100			goto err;
1101
1102		ret = -EIO;	/* bad target on any error from here on */
 
 
 
 
 
 
 
 
 
 
 
 
1103
1104		/*
1105		 * Determine data_direction by calculating the total outgoing
1106		 * iovec sizes + incoming iovec sizes vs. virtio-scsi request +
1107		 * response headers respectively.
1108		 *
1109		 * For DMA_TO_DEVICE this is out_iter, which is already pointing
1110		 * to the right place.
1111		 *
1112		 * For DMA_FROM_DEVICE, the iovec will be just past the end
1113		 * of the virtio-scsi response header in either the same
1114		 * or immediately following iovec.
1115		 *
1116		 * Any associated T10_PI bytes for the outgoing / incoming
1117		 * payloads are included in calculation of exp_data_len here.
1118		 */
1119		prot_bytes = 0;
1120
1121		if (vc.out_size > vc.req_size) {
1122			data_direction = DMA_TO_DEVICE;
1123			exp_data_len = vc.out_size - vc.req_size;
1124			data_iter = vc.out_iter;
1125		} else if (vc.in_size > vc.rsp_size) {
1126			data_direction = DMA_FROM_DEVICE;
1127			exp_data_len = vc.in_size - vc.rsp_size;
1128
1129			iov_iter_init(&in_iter, ITER_DEST, &vq->iov[vc.out], vc.in,
1130				      vc.rsp_size + exp_data_len);
1131			iov_iter_advance(&in_iter, vc.rsp_size);
1132			data_iter = in_iter;
1133		} else {
1134			data_direction = DMA_NONE;
1135			exp_data_len = 0;
 
 
 
 
 
 
 
 
 
1136		}
 
 
 
 
 
 
 
1137		/*
1138		 * If T10_PI header + payload is present, setup prot_iter values
1139		 * and recalculate data_iter for vhost_scsi_mapal() mapping to
1140		 * host scatterlists via get_user_pages_fast().
1141		 */
1142		if (t10_pi) {
1143			if (v_req_pi.pi_bytesout) {
1144				if (data_direction != DMA_TO_DEVICE) {
1145					vq_err(vq, "Received non zero pi_bytesout,"
1146						" but wrong data_direction\n");
1147					goto err;
1148				}
1149				prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesout);
1150			} else if (v_req_pi.pi_bytesin) {
1151				if (data_direction != DMA_FROM_DEVICE) {
1152					vq_err(vq, "Received non zero pi_bytesin,"
1153						" but wrong data_direction\n");
1154					goto err;
1155				}
1156				prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesin);
1157			}
1158			/*
1159			 * Set prot_iter to data_iter and truncate it to
1160			 * prot_bytes, and advance data_iter past any
1161			 * preceding prot_bytes that may be present.
1162			 *
1163			 * Also fix up the exp_data_len to reflect only the
1164			 * actual data payload length.
1165			 */
1166			if (prot_bytes) {
1167				exp_data_len -= prot_bytes;
1168				prot_iter = data_iter;
1169				iov_iter_truncate(&prot_iter, prot_bytes);
1170				iov_iter_advance(&data_iter, prot_bytes);
1171			}
1172			tag = vhost64_to_cpu(vq, v_req_pi.tag);
1173			task_attr = v_req_pi.task_attr;
1174			cdb = &v_req_pi.cdb[0];
1175			lun = vhost_buf_to_lun(v_req_pi.lun);
1176		} else {
1177			tag = vhost64_to_cpu(vq, v_req.tag);
1178			task_attr = v_req.task_attr;
1179			cdb = &v_req.cdb[0];
1180			lun = vhost_buf_to_lun(v_req.lun);
1181		}
1182		/*
1183		 * Check that the received CDB size does not exceeded our
1184		 * hardcoded max for vhost-scsi, then get a pre-allocated
1185		 * cmd descriptor for the new virtio-scsi tag.
1186		 *
1187		 * TODO what if cdb was too small for varlen cdb header?
1188		 */
1189		if (unlikely(scsi_command_size(cdb) > VHOST_SCSI_MAX_CDB_SIZE)) {
 
 
1190			vq_err(vq, "Received SCSI CDB with command_size: %d that"
1191				" exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
1192				scsi_command_size(cdb), VHOST_SCSI_MAX_CDB_SIZE);
1193				goto err;
1194		}
1195		cmd = vhost_scsi_get_cmd(vq, tpg, cdb, tag, lun, task_attr,
1196					 exp_data_len + prot_bytes,
1197					 data_direction);
1198		if (IS_ERR(cmd)) {
1199			vq_err(vq, "vhost_scsi_get_cmd failed %ld\n",
1200			       PTR_ERR(cmd));
1201			goto err;
1202		}
1203		cmd->tvc_vhost = vs;
1204		cmd->tvc_vq = vq;
1205		for (i = 0; i < vc.in ; i++)
1206			cmd->tvc_resp_iov[i] = vq->iov[vc.out + i];
1207		cmd->tvc_in_iovs = vc.in;
1208
1209		pr_debug("vhost_scsi got command opcode: %#02x, lun: %d\n",
1210			 cmd->tvc_cdb[0], cmd->tvc_lun);
1211		pr_debug("cmd: %p exp_data_len: %d, prot_bytes: %d data_direction:"
1212			 " %d\n", cmd, exp_data_len, prot_bytes, data_direction);
1213
1214		if (data_direction != DMA_NONE) {
1215			if (unlikely(vhost_scsi_mapal(cmd, prot_bytes,
1216						      &prot_iter, exp_data_len,
1217						      &data_iter))) {
 
1218				vq_err(vq, "Failed to map iov to sgl\n");
1219				vhost_scsi_release_cmd_res(&cmd->tvc_se_cmd);
1220				goto err;
1221			}
1222		}
 
1223		/*
1224		 * Save the descriptor from vhost_get_vq_desc() to be used to
1225		 * complete the virtio-scsi request in TCM callback context via
1226		 * vhost_scsi_queue_data_in() and vhost_scsi_queue_status()
1227		 */
1228		cmd->tvc_vq_desc = vc.head;
1229		vhost_scsi_target_queue_cmd(cmd);
1230		ret = 0;
1231err:
1232		/*
1233		 * ENXIO:  No more requests, or read error, wait for next kick
1234		 * EINVAL: Invalid response buffer, drop the request
1235		 * EIO:    Respond with bad target
1236		 * EAGAIN: Pending request
1237		 */
1238		if (ret == -ENXIO)
1239			break;
1240		else if (ret == -EIO)
1241			vhost_scsi_send_bad_target(vs, vq, vc.head, vc.out);
1242	} while (likely(!vhost_exceeds_weight(vq, ++c, 0)));
1243out:
1244	mutex_unlock(&vq->mutex);
1245}
1246
1247static void
1248vhost_scsi_send_tmf_resp(struct vhost_scsi *vs, struct vhost_virtqueue *vq,
1249			 int in_iovs, int vq_desc, struct iovec *resp_iov,
1250			 int tmf_resp_code)
1251{
1252	struct virtio_scsi_ctrl_tmf_resp rsp;
1253	struct iov_iter iov_iter;
1254	int ret;
1255
1256	pr_debug("%s\n", __func__);
1257	memset(&rsp, 0, sizeof(rsp));
1258	rsp.response = tmf_resp_code;
1259
1260	iov_iter_init(&iov_iter, ITER_DEST, resp_iov, in_iovs, sizeof(rsp));
1261
1262	ret = copy_to_iter(&rsp, sizeof(rsp), &iov_iter);
1263	if (likely(ret == sizeof(rsp)))
1264		vhost_add_used_and_signal(&vs->dev, vq, vq_desc, 0);
1265	else
1266		pr_err("Faulted on virtio_scsi_ctrl_tmf_resp\n");
1267}
1268
1269static void vhost_scsi_tmf_resp_work(struct vhost_work *work)
1270{
1271	struct vhost_scsi_tmf *tmf = container_of(work, struct vhost_scsi_tmf,
1272						  vwork);
1273	struct vhost_virtqueue *ctl_vq, *vq;
1274	int resp_code, i;
1275
1276	if (tmf->scsi_resp == TMR_FUNCTION_COMPLETE) {
1277		/*
1278		 * Flush IO vqs that don't share a worker with the ctl to make
1279		 * sure they have sent their responses before us.
1280		 */
1281		ctl_vq = &tmf->vhost->vqs[VHOST_SCSI_VQ_CTL].vq;
1282		for (i = VHOST_SCSI_VQ_IO; i < tmf->vhost->dev.nvqs; i++) {
1283			vq = &tmf->vhost->vqs[i].vq;
1284
1285			if (vhost_vq_is_setup(vq) &&
1286			    vq->worker != ctl_vq->worker)
1287				vhost_vq_flush(vq);
1288		}
1289
1290		resp_code = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED;
1291	} else {
1292		resp_code = VIRTIO_SCSI_S_FUNCTION_REJECTED;
1293	}
1294
1295	vhost_scsi_send_tmf_resp(tmf->vhost, &tmf->svq->vq, tmf->in_iovs,
1296				 tmf->vq_desc, &tmf->resp_iov, resp_code);
1297	vhost_scsi_release_tmf_res(tmf);
1298}
1299
1300static void
1301vhost_scsi_handle_tmf(struct vhost_scsi *vs, struct vhost_scsi_tpg *tpg,
1302		      struct vhost_virtqueue *vq,
1303		      struct virtio_scsi_ctrl_tmf_req *vtmf,
1304		      struct vhost_scsi_ctx *vc)
1305{
1306	struct vhost_scsi_virtqueue *svq = container_of(vq,
1307					struct vhost_scsi_virtqueue, vq);
1308	struct vhost_scsi_tmf *tmf;
1309
1310	if (vhost32_to_cpu(vq, vtmf->subtype) !=
1311	    VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET)
1312		goto send_reject;
1313
1314	if (!tpg->tpg_nexus || !tpg->tpg_nexus->tvn_se_sess) {
1315		pr_err("Unable to locate active struct vhost_scsi_nexus for LUN RESET.\n");
1316		goto send_reject;
1317	}
1318
1319	tmf = kzalloc(sizeof(*tmf), GFP_KERNEL);
1320	if (!tmf)
1321		goto send_reject;
1322
1323	vhost_work_init(&tmf->vwork, vhost_scsi_tmf_resp_work);
1324	tmf->vhost = vs;
1325	tmf->svq = svq;
1326	tmf->resp_iov = vq->iov[vc->out];
1327	tmf->vq_desc = vc->head;
1328	tmf->in_iovs = vc->in;
1329	tmf->inflight = vhost_scsi_get_inflight(vq);
1330
1331	if (target_submit_tmr(&tmf->se_cmd, tpg->tpg_nexus->tvn_se_sess, NULL,
1332			      vhost_buf_to_lun(vtmf->lun), NULL,
1333			      TMR_LUN_RESET, GFP_KERNEL, 0,
1334			      TARGET_SCF_ACK_KREF) < 0) {
1335		vhost_scsi_release_tmf_res(tmf);
1336		goto send_reject;
1337	}
1338
 
1339	return;
1340
1341send_reject:
1342	vhost_scsi_send_tmf_resp(vs, vq, vc->in, vc->head, &vq->iov[vc->out],
1343				 VIRTIO_SCSI_S_FUNCTION_REJECTED);
1344}
1345
1346static void
1347vhost_scsi_send_an_resp(struct vhost_scsi *vs,
1348			struct vhost_virtqueue *vq,
1349			struct vhost_scsi_ctx *vc)
1350{
1351	struct virtio_scsi_ctrl_an_resp rsp;
1352	struct iov_iter iov_iter;
1353	int ret;
1354
1355	pr_debug("%s\n", __func__);
1356	memset(&rsp, 0, sizeof(rsp));	/* event_actual = 0 */
1357	rsp.response = VIRTIO_SCSI_S_OK;
1358
1359	iov_iter_init(&iov_iter, ITER_DEST, &vq->iov[vc->out], vc->in, sizeof(rsp));
1360
1361	ret = copy_to_iter(&rsp, sizeof(rsp), &iov_iter);
1362	if (likely(ret == sizeof(rsp)))
1363		vhost_add_used_and_signal(&vs->dev, vq, vc->head, 0);
1364	else
1365		pr_err("Faulted on virtio_scsi_ctrl_an_resp\n");
1366}
1367
1368static void
1369vhost_scsi_ctl_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
1370{
1371	struct vhost_scsi_tpg *tpg;
1372	union {
1373		__virtio32 type;
1374		struct virtio_scsi_ctrl_an_req an;
1375		struct virtio_scsi_ctrl_tmf_req tmf;
1376	} v_req;
1377	struct vhost_scsi_ctx vc;
1378	size_t typ_size;
1379	int ret, c = 0;
1380
1381	mutex_lock(&vq->mutex);
1382	/*
1383	 * We can handle the vq only after the endpoint is setup by calling the
1384	 * VHOST_SCSI_SET_ENDPOINT ioctl.
1385	 */
1386	if (!vhost_vq_get_backend(vq))
1387		goto out;
1388
1389	memset(&vc, 0, sizeof(vc));
1390
1391	vhost_disable_notify(&vs->dev, vq);
1392
1393	do {
1394		ret = vhost_scsi_get_desc(vs, vq, &vc);
1395		if (ret)
1396			goto err;
1397
1398		/*
1399		 * Get the request type first in order to setup
1400		 * other parameters dependent on the type.
1401		 */
1402		vc.req = &v_req.type;
1403		typ_size = sizeof(v_req.type);
1404
1405		if (unlikely(!copy_from_iter_full(vc.req, typ_size,
1406						  &vc.out_iter))) {
1407			vq_err(vq, "Faulted on copy_from_iter tmf type\n");
1408			/*
1409			 * The size of the response buffer depends on the
1410			 * request type and must be validated against it.
1411			 * Since the request type is not known, don't send
1412			 * a response.
1413			 */
1414			continue;
1415		}
1416
1417		switch (vhost32_to_cpu(vq, v_req.type)) {
1418		case VIRTIO_SCSI_T_TMF:
1419			vc.req = &v_req.tmf;
1420			vc.req_size = sizeof(struct virtio_scsi_ctrl_tmf_req);
1421			vc.rsp_size = sizeof(struct virtio_scsi_ctrl_tmf_resp);
1422			vc.lunp = &v_req.tmf.lun[0];
1423			vc.target = &v_req.tmf.lun[1];
1424			break;
1425		case VIRTIO_SCSI_T_AN_QUERY:
1426		case VIRTIO_SCSI_T_AN_SUBSCRIBE:
1427			vc.req = &v_req.an;
1428			vc.req_size = sizeof(struct virtio_scsi_ctrl_an_req);
1429			vc.rsp_size = sizeof(struct virtio_scsi_ctrl_an_resp);
1430			vc.lunp = &v_req.an.lun[0];
1431			vc.target = NULL;
1432			break;
1433		default:
1434			vq_err(vq, "Unknown control request %d", v_req.type);
1435			continue;
1436		}
1437
1438		/*
1439		 * Validate the size of request and response buffers.
1440		 * Check for a sane response buffer so we can report
1441		 * early errors back to the guest.
1442		 */
1443		ret = vhost_scsi_chk_size(vq, &vc);
1444		if (ret)
1445			goto err;
1446
1447		/*
1448		 * Get the rest of the request now that its size is known.
1449		 */
1450		vc.req += typ_size;
1451		vc.req_size -= typ_size;
1452
1453		ret = vhost_scsi_get_req(vq, &vc, &tpg);
1454		if (ret)
1455			goto err;
1456
1457		if (v_req.type == VIRTIO_SCSI_T_TMF)
1458			vhost_scsi_handle_tmf(vs, tpg, vq, &v_req.tmf, &vc);
1459		else
1460			vhost_scsi_send_an_resp(vs, vq, &vc);
1461err:
1462		/*
1463		 * ENXIO:  No more requests, or read error, wait for next kick
1464		 * EINVAL: Invalid response buffer, drop the request
1465		 * EIO:    Respond with bad target
1466		 * EAGAIN: Pending request
1467		 */
1468		if (ret == -ENXIO)
1469			break;
1470		else if (ret == -EIO)
1471			vhost_scsi_send_bad_target(vs, vq, vc.head, vc.out);
1472	} while (likely(!vhost_exceeds_weight(vq, ++c, 0)));
1473out:
1474	mutex_unlock(&vq->mutex);
1475}
1476
1477static void vhost_scsi_ctl_handle_kick(struct vhost_work *work)
1478{
1479	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
1480						poll.work);
1481	struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev);
1482
1483	pr_debug("%s: The handling func for control queue.\n", __func__);
1484	vhost_scsi_ctl_handle_vq(vs, vq);
1485}
1486
1487static void
1488vhost_scsi_send_evt(struct vhost_scsi *vs, struct vhost_virtqueue *vq,
1489		    struct vhost_scsi_tpg *tpg, struct se_lun *lun,
1490		    u32 event, u32 reason)
 
 
1491{
1492	struct vhost_scsi_evt *evt;
1493
1494	evt = vhost_scsi_allocate_evt(vs, event, reason);
1495	if (!evt)
1496		return;
1497
1498	if (tpg && lun) {
1499		/* TODO: share lun setup code with virtio-scsi.ko */
1500		/*
1501		 * Note: evt->event is zeroed when we allocate it and
1502		 * lun[4-7] need to be zero according to virtio-scsi spec.
1503		 */
1504		evt->event.lun[0] = 0x01;
1505		evt->event.lun[1] = tpg->tport_tpgt;
1506		if (lun->unpacked_lun >= 256)
1507			evt->event.lun[2] = lun->unpacked_lun >> 8 | 0x40 ;
1508		evt->event.lun[3] = lun->unpacked_lun & 0xFF;
1509	}
1510
1511	llist_add(&evt->list, &vs->vs_event_list);
1512	vhost_vq_work_queue(vq, &vs->vs_event_work);
1513}
1514
1515static void vhost_scsi_evt_handle_kick(struct vhost_work *work)
1516{
1517	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
1518						poll.work);
1519	struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev);
1520
1521	mutex_lock(&vq->mutex);
1522	if (!vhost_vq_get_backend(vq))
1523		goto out;
1524
1525	if (vs->vs_events_missed)
1526		vhost_scsi_send_evt(vs, vq, NULL, NULL, VIRTIO_SCSI_T_NO_EVENT,
1527				    0);
1528out:
1529	mutex_unlock(&vq->mutex);
1530}
1531
1532static void vhost_scsi_handle_kick(struct vhost_work *work)
1533{
1534	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
1535						poll.work);
1536	struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev);
1537
1538	vhost_scsi_handle_vq(vs, vq);
1539}
1540
 
 
 
 
 
1541/* Callers must hold dev mutex */
1542static void vhost_scsi_flush(struct vhost_scsi *vs)
1543{
 
1544	int i;
1545
1546	/* Init new inflight and remember the old inflight */
1547	vhost_scsi_init_inflight(vs, vs->old_inflight);
1548
1549	/*
1550	 * The inflight->kref was initialized to 1. We decrement it here to
1551	 * indicate the start of the flush operation so that it will reach 0
1552	 * when all the reqs are finished.
1553	 */
1554	for (i = 0; i < vs->dev.nvqs; i++)
1555		kref_put(&vs->old_inflight[i]->kref, vhost_scsi_done_inflight);
1556
1557	/* Flush both the vhost poll and vhost work */
1558	vhost_dev_flush(&vs->dev);
 
 
 
1559
1560	/* Wait for all reqs issued before the flush to be finished */
1561	for (i = 0; i < vs->dev.nvqs; i++)
1562		wait_for_completion(&vs->old_inflight[i]->comp);
1563}
1564
1565static void vhost_scsi_destroy_vq_cmds(struct vhost_virtqueue *vq)
1566{
1567	struct vhost_scsi_virtqueue *svq = container_of(vq,
1568					struct vhost_scsi_virtqueue, vq);
1569	struct vhost_scsi_cmd *tv_cmd;
1570	unsigned int i;
1571
1572	if (!svq->scsi_cmds)
1573		return;
1574
1575	for (i = 0; i < svq->max_cmds; i++) {
1576		tv_cmd = &svq->scsi_cmds[i];
1577
1578		kfree(tv_cmd->tvc_sgl);
1579		kfree(tv_cmd->tvc_prot_sgl);
1580		kfree(tv_cmd->tvc_upages);
1581		kfree(tv_cmd->tvc_resp_iov);
1582	}
1583
1584	sbitmap_free(&svq->scsi_tags);
1585	kfree(svq->scsi_cmds);
1586	svq->scsi_cmds = NULL;
1587}
1588
1589static int vhost_scsi_setup_vq_cmds(struct vhost_virtqueue *vq, int max_cmds)
1590{
1591	struct vhost_scsi_virtqueue *svq = container_of(vq,
1592					struct vhost_scsi_virtqueue, vq);
1593	struct vhost_scsi_cmd *tv_cmd;
1594	unsigned int i;
1595
1596	if (svq->scsi_cmds)
1597		return 0;
1598
1599	if (sbitmap_init_node(&svq->scsi_tags, max_cmds, -1, GFP_KERNEL,
1600			      NUMA_NO_NODE, false, true))
1601		return -ENOMEM;
1602	svq->max_cmds = max_cmds;
1603
1604	svq->scsi_cmds = kcalloc(max_cmds, sizeof(*tv_cmd), GFP_KERNEL);
1605	if (!svq->scsi_cmds) {
1606		sbitmap_free(&svq->scsi_tags);
1607		return -ENOMEM;
1608	}
1609
1610	for (i = 0; i < max_cmds; i++) {
1611		tv_cmd = &svq->scsi_cmds[i];
1612
1613		tv_cmd->tvc_sgl = kcalloc(VHOST_SCSI_PREALLOC_SGLS,
1614					  sizeof(struct scatterlist),
1615					  GFP_KERNEL);
1616		if (!tv_cmd->tvc_sgl) {
1617			pr_err("Unable to allocate tv_cmd->tvc_sgl\n");
1618			goto out;
1619		}
1620
1621		tv_cmd->tvc_upages = kcalloc(VHOST_SCSI_PREALLOC_UPAGES,
1622					     sizeof(struct page *),
1623					     GFP_KERNEL);
1624		if (!tv_cmd->tvc_upages) {
1625			pr_err("Unable to allocate tv_cmd->tvc_upages\n");
1626			goto out;
1627		}
1628
1629		tv_cmd->tvc_resp_iov = kcalloc(UIO_MAXIOV,
1630					       sizeof(struct iovec),
1631					       GFP_KERNEL);
1632		if (!tv_cmd->tvc_resp_iov) {
1633			pr_err("Unable to allocate tv_cmd->tvc_resp_iov\n");
1634			goto out;
1635		}
1636
1637		tv_cmd->tvc_prot_sgl = kcalloc(VHOST_SCSI_PREALLOC_PROT_SGLS,
1638					       sizeof(struct scatterlist),
1639					       GFP_KERNEL);
1640		if (!tv_cmd->tvc_prot_sgl) {
1641			pr_err("Unable to allocate tv_cmd->tvc_prot_sgl\n");
1642			goto out;
1643		}
1644	}
1645	return 0;
1646out:
1647	vhost_scsi_destroy_vq_cmds(vq);
1648	return -ENOMEM;
1649}
1650
1651/*
1652 * Called from vhost_scsi_ioctl() context to walk the list of available
1653 * vhost_scsi_tpg with an active struct vhost_scsi_nexus
1654 *
1655 *  The lock nesting rule is:
1656 *    vs->dev.mutex -> vhost_scsi_mutex -> tpg->tv_tpg_mutex -> vq->mutex
1657 */
1658static int
1659vhost_scsi_set_endpoint(struct vhost_scsi *vs,
1660			struct vhost_scsi_target *t)
1661{
1662	struct se_portal_group *se_tpg;
1663	struct vhost_scsi_tport *tv_tport;
1664	struct vhost_scsi_tpg *tpg;
1665	struct vhost_scsi_tpg **vs_tpg;
1666	struct vhost_virtqueue *vq;
1667	int index, ret, i, len;
1668	bool match = false;
1669
 
1670	mutex_lock(&vs->dev.mutex);
1671
1672	/* Verify that ring has been setup correctly. */
1673	for (index = 0; index < vs->dev.nvqs; ++index) {
1674		/* Verify that ring has been setup correctly. */
1675		if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
1676			ret = -EFAULT;
1677			goto out;
1678		}
1679	}
1680
1681	len = sizeof(vs_tpg[0]) * VHOST_SCSI_MAX_TARGET;
1682	vs_tpg = kzalloc(len, GFP_KERNEL);
1683	if (!vs_tpg) {
1684		ret = -ENOMEM;
1685		goto out;
1686	}
1687	if (vs->vs_tpg)
1688		memcpy(vs_tpg, vs->vs_tpg, len);
1689
1690	mutex_lock(&vhost_scsi_mutex);
1691	list_for_each_entry(tpg, &vhost_scsi_list, tv_tpg_list) {
1692		mutex_lock(&tpg->tv_tpg_mutex);
1693		if (!tpg->tpg_nexus) {
1694			mutex_unlock(&tpg->tv_tpg_mutex);
1695			continue;
1696		}
1697		if (tpg->tv_tpg_vhost_count != 0) {
1698			mutex_unlock(&tpg->tv_tpg_mutex);
1699			continue;
1700		}
1701		tv_tport = tpg->tport;
1702
1703		if (!strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
1704			if (vs->vs_tpg && vs->vs_tpg[tpg->tport_tpgt]) {
 
1705				mutex_unlock(&tpg->tv_tpg_mutex);
1706				mutex_unlock(&vhost_scsi_mutex);
1707				ret = -EEXIST;
1708				goto undepend;
1709			}
1710			/*
1711			 * In order to ensure individual vhost-scsi configfs
1712			 * groups cannot be removed while in use by vhost ioctl,
1713			 * go ahead and take an explicit se_tpg->tpg_group.cg_item
1714			 * dependency now.
1715			 */
1716			se_tpg = &tpg->se_tpg;
1717			ret = target_depend_item(&se_tpg->tpg_group.cg_item);
1718			if (ret) {
1719				pr_warn("target_depend_item() failed: %d\n", ret);
1720				mutex_unlock(&tpg->tv_tpg_mutex);
1721				mutex_unlock(&vhost_scsi_mutex);
1722				goto undepend;
1723			}
1724			tpg->tv_tpg_vhost_count++;
1725			tpg->vhost_scsi = vs;
1726			vs_tpg[tpg->tport_tpgt] = tpg;
 
1727			match = true;
1728		}
1729		mutex_unlock(&tpg->tv_tpg_mutex);
1730	}
1731	mutex_unlock(&vhost_scsi_mutex);
1732
1733	if (match) {
1734		memcpy(vs->vs_vhost_wwpn, t->vhost_wwpn,
1735		       sizeof(vs->vs_vhost_wwpn));
1736
1737		for (i = VHOST_SCSI_VQ_IO; i < vs->dev.nvqs; i++) {
1738			vq = &vs->vqs[i].vq;
1739			if (!vhost_vq_is_setup(vq))
1740				continue;
1741
1742			ret = vhost_scsi_setup_vq_cmds(vq, vq->num);
1743			if (ret)
1744				goto destroy_vq_cmds;
1745		}
1746
1747		for (i = 0; i < vs->dev.nvqs; i++) {
1748			vq = &vs->vqs[i].vq;
1749			mutex_lock(&vq->mutex);
1750			vhost_vq_set_backend(vq, vs_tpg);
1751			vhost_vq_init_access(vq);
1752			mutex_unlock(&vq->mutex);
1753		}
1754		ret = 0;
1755	} else {
1756		ret = -EEXIST;
1757	}
1758
1759	/*
1760	 * Act as synchronize_rcu to make sure access to
1761	 * old vs->vs_tpg is finished.
1762	 */
1763	vhost_scsi_flush(vs);
1764	kfree(vs->vs_tpg);
1765	vs->vs_tpg = vs_tpg;
1766	goto out;
1767
1768destroy_vq_cmds:
1769	for (i--; i >= VHOST_SCSI_VQ_IO; i--) {
1770		if (!vhost_vq_get_backend(&vs->vqs[i].vq))
1771			vhost_scsi_destroy_vq_cmds(&vs->vqs[i].vq);
1772	}
1773undepend:
1774	for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
1775		tpg = vs_tpg[i];
1776		if (tpg) {
1777			mutex_lock(&tpg->tv_tpg_mutex);
1778			tpg->vhost_scsi = NULL;
1779			tpg->tv_tpg_vhost_count--;
1780			mutex_unlock(&tpg->tv_tpg_mutex);
1781			target_undepend_item(&tpg->se_tpg.tpg_group.cg_item);
1782		}
1783	}
1784	kfree(vs_tpg);
1785out:
1786	mutex_unlock(&vs->dev.mutex);
 
1787	return ret;
1788}
1789
1790static int
1791vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
1792			  struct vhost_scsi_target *t)
1793{
1794	struct se_portal_group *se_tpg;
1795	struct vhost_scsi_tport *tv_tport;
1796	struct vhost_scsi_tpg *tpg;
1797	struct vhost_virtqueue *vq;
1798	bool match = false;
1799	int index, ret, i;
1800	u8 target;
1801
 
1802	mutex_lock(&vs->dev.mutex);
1803	/* Verify that ring has been setup correctly. */
1804	for (index = 0; index < vs->dev.nvqs; ++index) {
1805		if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
1806			ret = -EFAULT;
1807			goto err_dev;
1808		}
1809	}
1810
1811	if (!vs->vs_tpg) {
1812		ret = 0;
1813		goto err_dev;
1814	}
1815
1816	for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
1817		target = i;
1818		tpg = vs->vs_tpg[target];
1819		if (!tpg)
1820			continue;
1821
 
1822		tv_tport = tpg->tport;
1823		if (!tv_tport) {
1824			ret = -ENODEV;
1825			goto err_dev;
1826		}
1827
1828		if (strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
1829			pr_warn("tv_tport->tport_name: %s, tpg->tport_tpgt: %hu"
1830				" does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
1831				tv_tport->tport_name, tpg->tport_tpgt,
1832				t->vhost_wwpn, t->vhost_tpgt);
1833			ret = -EINVAL;
1834			goto err_dev;
1835		}
1836		match = true;
1837	}
1838	if (!match)
1839		goto free_vs_tpg;
1840
1841	/* Prevent new cmds from starting and accessing the tpgs/sessions */
1842	for (i = 0; i < vs->dev.nvqs; i++) {
1843		vq = &vs->vqs[i].vq;
1844		mutex_lock(&vq->mutex);
1845		vhost_vq_set_backend(vq, NULL);
1846		mutex_unlock(&vq->mutex);
1847	}
1848	/* Make sure cmds are not running before tearing them down. */
1849	vhost_scsi_flush(vs);
1850
1851	for (i = 0; i < vs->dev.nvqs; i++) {
1852		vq = &vs->vqs[i].vq;
1853		vhost_scsi_destroy_vq_cmds(vq);
1854	}
1855
1856	/*
1857	 * We can now release our hold on the tpg and sessions and userspace
1858	 * can free them after this point.
1859	 */
1860	for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
1861		target = i;
1862		tpg = vs->vs_tpg[target];
1863		if (!tpg)
1864			continue;
1865
1866		mutex_lock(&tpg->tv_tpg_mutex);
1867
1868		tpg->tv_tpg_vhost_count--;
1869		tpg->vhost_scsi = NULL;
1870		vs->vs_tpg[target] = NULL;
1871
1872		mutex_unlock(&tpg->tv_tpg_mutex);
1873
1874		se_tpg = &tpg->se_tpg;
1875		target_undepend_item(&se_tpg->tpg_group.cg_item);
1876	}
1877
1878free_vs_tpg:
 
 
 
 
 
 
1879	/*
1880	 * Act as synchronize_rcu to make sure access to
1881	 * old vs->vs_tpg is finished.
1882	 */
1883	vhost_scsi_flush(vs);
1884	kfree(vs->vs_tpg);
1885	vs->vs_tpg = NULL;
1886	WARN_ON(vs->vs_events_nr);
1887	mutex_unlock(&vs->dev.mutex);
 
1888	return 0;
1889
 
 
1890err_dev:
1891	mutex_unlock(&vs->dev.mutex);
 
1892	return ret;
1893}
1894
1895static int vhost_scsi_set_features(struct vhost_scsi *vs, u64 features)
1896{
1897	struct vhost_virtqueue *vq;
1898	int i;
1899
1900	if (features & ~VHOST_SCSI_FEATURES)
1901		return -EOPNOTSUPP;
1902
1903	mutex_lock(&vs->dev.mutex);
1904	if ((features & (1 << VHOST_F_LOG_ALL)) &&
1905	    !vhost_log_access_ok(&vs->dev)) {
1906		mutex_unlock(&vs->dev.mutex);
1907		return -EFAULT;
1908	}
1909
1910	for (i = 0; i < vs->dev.nvqs; i++) {
1911		vq = &vs->vqs[i].vq;
1912		mutex_lock(&vq->mutex);
1913		vq->acked_features = features;
1914		mutex_unlock(&vq->mutex);
1915	}
1916	mutex_unlock(&vs->dev.mutex);
1917	return 0;
1918}
1919
 
 
 
 
 
 
 
 
1920static int vhost_scsi_open(struct inode *inode, struct file *f)
1921{
1922	struct vhost_scsi_virtqueue *svq;
1923	struct vhost_scsi *vs;
1924	struct vhost_virtqueue **vqs;
1925	int r = -ENOMEM, i, nvqs = vhost_scsi_max_io_vqs;
1926
1927	vs = kvzalloc(sizeof(*vs), GFP_KERNEL);
1928	if (!vs)
1929		goto err_vs;
1930
1931	if (nvqs > VHOST_SCSI_MAX_IO_VQ) {
1932		pr_err("Invalid max_io_vqs of %d. Using %d.\n", nvqs,
1933		       VHOST_SCSI_MAX_IO_VQ);
1934		nvqs = VHOST_SCSI_MAX_IO_VQ;
1935	} else if (nvqs == 0) {
1936		pr_err("Invalid max_io_vqs of %d. Using 1.\n", nvqs);
1937		nvqs = 1;
1938	}
1939	nvqs += VHOST_SCSI_VQ_IO;
1940
1941	vs->old_inflight = kmalloc_array(nvqs, sizeof(*vs->old_inflight),
1942					 GFP_KERNEL | __GFP_ZERO);
1943	if (!vs->old_inflight)
1944		goto err_inflight;
1945
1946	vs->vqs = kmalloc_array(nvqs, sizeof(*vs->vqs),
1947				GFP_KERNEL | __GFP_ZERO);
1948	if (!vs->vqs)
1949		goto err_vqs;
1950
1951	vqs = kmalloc_array(nvqs, sizeof(*vqs), GFP_KERNEL);
1952	if (!vqs)
1953		goto err_local_vqs;
1954
1955	vhost_work_init(&vs->vs_event_work, vhost_scsi_evt_work);
 
1956
1957	vs->vs_events_nr = 0;
1958	vs->vs_events_missed = false;
1959
1960	vqs[VHOST_SCSI_VQ_CTL] = &vs->vqs[VHOST_SCSI_VQ_CTL].vq;
1961	vqs[VHOST_SCSI_VQ_EVT] = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1962	vs->vqs[VHOST_SCSI_VQ_CTL].vq.handle_kick = vhost_scsi_ctl_handle_kick;
1963	vs->vqs[VHOST_SCSI_VQ_EVT].vq.handle_kick = vhost_scsi_evt_handle_kick;
1964	for (i = VHOST_SCSI_VQ_IO; i < nvqs; i++) {
1965		svq = &vs->vqs[i];
1966
1967		vqs[i] = &svq->vq;
1968		svq->vs = vs;
1969		init_llist_head(&svq->completion_list);
1970		vhost_work_init(&svq->completion_work,
1971				vhost_scsi_complete_cmd_work);
1972		svq->vq.handle_kick = vhost_scsi_handle_kick;
1973	}
1974	vhost_dev_init(&vs->dev, vqs, nvqs, UIO_MAXIOV,
1975		       VHOST_SCSI_WEIGHT, 0, true, NULL);
1976
1977	vhost_scsi_init_inflight(vs, NULL);
1978
1979	f->private_data = vs;
1980	return 0;
1981
1982err_local_vqs:
1983	kfree(vs->vqs);
1984err_vqs:
1985	kfree(vs->old_inflight);
1986err_inflight:
1987	kvfree(vs);
1988err_vs:
1989	return r;
1990}
1991
1992static int vhost_scsi_release(struct inode *inode, struct file *f)
1993{
1994	struct vhost_scsi *vs = f->private_data;
1995	struct vhost_scsi_target t;
1996
1997	mutex_lock(&vs->dev.mutex);
1998	memcpy(t.vhost_wwpn, vs->vs_vhost_wwpn, sizeof(t.vhost_wwpn));
1999	mutex_unlock(&vs->dev.mutex);
2000	vhost_scsi_clear_endpoint(vs, &t);
2001	vhost_dev_stop(&vs->dev);
2002	vhost_dev_cleanup(&vs->dev);
 
 
2003	kfree(vs->dev.vqs);
2004	kfree(vs->vqs);
2005	kfree(vs->old_inflight);
2006	kvfree(vs);
2007	return 0;
2008}
2009
2010static long
2011vhost_scsi_ioctl(struct file *f,
2012		 unsigned int ioctl,
2013		 unsigned long arg)
2014{
2015	struct vhost_scsi *vs = f->private_data;
2016	struct vhost_scsi_target backend;
2017	void __user *argp = (void __user *)arg;
2018	u64 __user *featurep = argp;
2019	u32 __user *eventsp = argp;
2020	u32 events_missed;
2021	u64 features;
2022	int r, abi_version = VHOST_SCSI_ABI_VERSION;
2023	struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
2024
2025	switch (ioctl) {
2026	case VHOST_SCSI_SET_ENDPOINT:
2027		if (copy_from_user(&backend, argp, sizeof backend))
2028			return -EFAULT;
2029		if (backend.reserved != 0)
2030			return -EOPNOTSUPP;
2031
2032		return vhost_scsi_set_endpoint(vs, &backend);
2033	case VHOST_SCSI_CLEAR_ENDPOINT:
2034		if (copy_from_user(&backend, argp, sizeof backend))
2035			return -EFAULT;
2036		if (backend.reserved != 0)
2037			return -EOPNOTSUPP;
2038
2039		return vhost_scsi_clear_endpoint(vs, &backend);
2040	case VHOST_SCSI_GET_ABI_VERSION:
2041		if (copy_to_user(argp, &abi_version, sizeof abi_version))
2042			return -EFAULT;
2043		return 0;
2044	case VHOST_SCSI_SET_EVENTS_MISSED:
2045		if (get_user(events_missed, eventsp))
2046			return -EFAULT;
2047		mutex_lock(&vq->mutex);
2048		vs->vs_events_missed = events_missed;
2049		mutex_unlock(&vq->mutex);
2050		return 0;
2051	case VHOST_SCSI_GET_EVENTS_MISSED:
2052		mutex_lock(&vq->mutex);
2053		events_missed = vs->vs_events_missed;
2054		mutex_unlock(&vq->mutex);
2055		if (put_user(events_missed, eventsp))
2056			return -EFAULT;
2057		return 0;
2058	case VHOST_GET_FEATURES:
2059		features = VHOST_SCSI_FEATURES;
2060		if (copy_to_user(featurep, &features, sizeof features))
2061			return -EFAULT;
2062		return 0;
2063	case VHOST_SET_FEATURES:
2064		if (copy_from_user(&features, featurep, sizeof features))
2065			return -EFAULT;
2066		return vhost_scsi_set_features(vs, features);
2067	case VHOST_NEW_WORKER:
2068	case VHOST_FREE_WORKER:
2069	case VHOST_ATTACH_VRING_WORKER:
2070	case VHOST_GET_VRING_WORKER:
2071		mutex_lock(&vs->dev.mutex);
2072		r = vhost_worker_ioctl(&vs->dev, ioctl, argp);
2073		mutex_unlock(&vs->dev.mutex);
2074		return r;
2075	default:
2076		mutex_lock(&vs->dev.mutex);
2077		r = vhost_dev_ioctl(&vs->dev, ioctl, argp);
2078		/* TODO: flush backend after dev ioctl. */
2079		if (r == -ENOIOCTLCMD)
2080			r = vhost_vring_ioctl(&vs->dev, ioctl, argp);
2081		mutex_unlock(&vs->dev.mutex);
2082		return r;
2083	}
2084}
2085
 
 
 
 
 
 
 
 
2086static const struct file_operations vhost_scsi_fops = {
2087	.owner          = THIS_MODULE,
2088	.release        = vhost_scsi_release,
2089	.unlocked_ioctl = vhost_scsi_ioctl,
2090	.compat_ioctl	= compat_ptr_ioctl,
 
 
2091	.open           = vhost_scsi_open,
2092	.llseek		= noop_llseek,
2093};
2094
2095static struct miscdevice vhost_scsi_misc = {
2096	MISC_DYNAMIC_MINOR,
2097	"vhost-scsi",
2098	&vhost_scsi_fops,
2099};
2100
2101static int __init vhost_scsi_register(void)
2102{
2103	return misc_register(&vhost_scsi_misc);
2104}
2105
2106static void vhost_scsi_deregister(void)
2107{
2108	misc_deregister(&vhost_scsi_misc);
2109}
2110
2111static char *vhost_scsi_dump_proto_id(struct vhost_scsi_tport *tport)
2112{
2113	switch (tport->tport_proto_id) {
2114	case SCSI_PROTOCOL_SAS:
2115		return "SAS";
2116	case SCSI_PROTOCOL_FCP:
2117		return "FCP";
2118	case SCSI_PROTOCOL_ISCSI:
2119		return "iSCSI";
2120	default:
2121		break;
2122	}
2123
2124	return "Unknown";
2125}
2126
2127static void
2128vhost_scsi_do_plug(struct vhost_scsi_tpg *tpg,
2129		  struct se_lun *lun, bool plug)
2130{
2131
2132	struct vhost_scsi *vs = tpg->vhost_scsi;
2133	struct vhost_virtqueue *vq;
2134	u32 reason;
2135
2136	if (!vs)
2137		return;
2138
 
 
 
 
 
 
2139	if (plug)
2140		reason = VIRTIO_SCSI_EVT_RESET_RESCAN;
2141	else
2142		reason = VIRTIO_SCSI_EVT_RESET_REMOVED;
2143
2144	vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
2145	mutex_lock(&vq->mutex);
2146	/*
2147	 * We can't queue events if the backend has been cleared, because
2148	 * we could end up queueing an event after the flush.
2149	 */
2150	if (!vhost_vq_get_backend(vq))
2151		goto unlock;
2152
2153	if (vhost_has_feature(vq, VIRTIO_SCSI_F_HOTPLUG))
2154		vhost_scsi_send_evt(vs, vq, tpg, lun,
2155				   VIRTIO_SCSI_T_TRANSPORT_RESET, reason);
2156unlock:
2157	mutex_unlock(&vq->mutex);
 
2158}
2159
2160static void vhost_scsi_hotplug(struct vhost_scsi_tpg *tpg, struct se_lun *lun)
2161{
2162	vhost_scsi_do_plug(tpg, lun, true);
2163}
2164
2165static void vhost_scsi_hotunplug(struct vhost_scsi_tpg *tpg, struct se_lun *lun)
2166{
2167	vhost_scsi_do_plug(tpg, lun, false);
2168}
2169
2170static int vhost_scsi_port_link(struct se_portal_group *se_tpg,
2171			       struct se_lun *lun)
2172{
2173	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2174				struct vhost_scsi_tpg, se_tpg);
 
 
2175
2176	mutex_lock(&tpg->tv_tpg_mutex);
2177	tpg->tv_tpg_port_count++;
2178	vhost_scsi_hotplug(tpg, lun);
2179	mutex_unlock(&tpg->tv_tpg_mutex);
2180
 
 
 
 
2181	return 0;
2182}
2183
2184static void vhost_scsi_port_unlink(struct se_portal_group *se_tpg,
2185				  struct se_lun *lun)
2186{
2187	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2188				struct vhost_scsi_tpg, se_tpg);
 
 
2189
2190	mutex_lock(&tpg->tv_tpg_mutex);
2191	tpg->tv_tpg_port_count--;
2192	vhost_scsi_hotunplug(tpg, lun);
2193	mutex_unlock(&tpg->tv_tpg_mutex);
 
 
 
 
2194}
2195
2196static ssize_t vhost_scsi_tpg_attrib_fabric_prot_type_store(
2197		struct config_item *item, const char *page, size_t count)
 
 
2198{
2199	struct se_portal_group *se_tpg = attrib_to_tpg(item);
2200	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2201				struct vhost_scsi_tpg, se_tpg);
2202	unsigned long val;
2203	int ret = kstrtoul(page, 0, &val);
2204
2205	if (ret) {
2206		pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret);
2207		return ret;
2208	}
2209	if (val != 0 && val != 1 && val != 3) {
2210		pr_err("Invalid vhost_scsi fabric_prot_type: %lu\n", val);
2211		return -EINVAL;
 
 
 
 
 
 
 
 
 
2212	}
2213	tpg->tv_fabric_prot_type = val;
 
 
 
 
2214
2215	return count;
2216}
2217
2218static ssize_t vhost_scsi_tpg_attrib_fabric_prot_type_show(
2219		struct config_item *item, char *page)
2220{
2221	struct se_portal_group *se_tpg = attrib_to_tpg(item);
2222	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2223				struct vhost_scsi_tpg, se_tpg);
2224
2225	return sysfs_emit(page, "%d\n", tpg->tv_fabric_prot_type);
2226}
2227
2228CONFIGFS_ATTR(vhost_scsi_tpg_attrib_, fabric_prot_type);
 
 
 
 
2229
2230static struct configfs_attribute *vhost_scsi_tpg_attrib_attrs[] = {
2231	&vhost_scsi_tpg_attrib_attr_fabric_prot_type,
2232	NULL,
2233};
 
2234
2235static int vhost_scsi_make_nexus(struct vhost_scsi_tpg *tpg,
 
 
 
 
 
2236				const char *name)
2237{
2238	struct vhost_scsi_nexus *tv_nexus;
 
 
 
 
2239
2240	mutex_lock(&tpg->tv_tpg_mutex);
2241	if (tpg->tpg_nexus) {
2242		mutex_unlock(&tpg->tv_tpg_mutex);
2243		pr_debug("tpg->tpg_nexus already exists\n");
2244		return -EEXIST;
2245	}
 
2246
2247	tv_nexus = kzalloc(sizeof(*tv_nexus), GFP_KERNEL);
2248	if (!tv_nexus) {
2249		mutex_unlock(&tpg->tv_tpg_mutex);
2250		pr_err("Unable to allocate struct vhost_scsi_nexus\n");
2251		return -ENOMEM;
2252	}
2253	/*
2254	 * Since we are running in 'demo mode' this call with generate a
2255	 * struct se_node_acl for the vhost_scsi struct se_portal_group with
2256	 * the SCSI Initiator port name of the passed configfs group 'name'.
2257	 */
2258	tv_nexus->tvn_se_sess = target_setup_session(&tpg->se_tpg, 0, 0,
2259					TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS,
2260					(unsigned char *)name, tv_nexus, NULL);
 
2261	if (IS_ERR(tv_nexus->tvn_se_sess)) {
2262		mutex_unlock(&tpg->tv_tpg_mutex);
2263		kfree(tv_nexus);
2264		return -ENOMEM;
2265	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2266	tpg->tpg_nexus = tv_nexus;
2267
2268	mutex_unlock(&tpg->tv_tpg_mutex);
2269	return 0;
 
 
 
 
 
 
2270}
2271
2272static int vhost_scsi_drop_nexus(struct vhost_scsi_tpg *tpg)
2273{
2274	struct se_session *se_sess;
2275	struct vhost_scsi_nexus *tv_nexus;
2276
2277	mutex_lock(&tpg->tv_tpg_mutex);
2278	tv_nexus = tpg->tpg_nexus;
2279	if (!tv_nexus) {
2280		mutex_unlock(&tpg->tv_tpg_mutex);
2281		return -ENODEV;
2282	}
2283
2284	se_sess = tv_nexus->tvn_se_sess;
2285	if (!se_sess) {
2286		mutex_unlock(&tpg->tv_tpg_mutex);
2287		return -ENODEV;
2288	}
2289
2290	if (tpg->tv_tpg_port_count != 0) {
2291		mutex_unlock(&tpg->tv_tpg_mutex);
2292		pr_err("Unable to remove TCM_vhost I_T Nexus with"
2293			" active TPG port count: %d\n",
2294			tpg->tv_tpg_port_count);
2295		return -EBUSY;
2296	}
2297
2298	if (tpg->tv_tpg_vhost_count != 0) {
2299		mutex_unlock(&tpg->tv_tpg_mutex);
2300		pr_err("Unable to remove TCM_vhost I_T Nexus with"
2301			" active TPG vhost count: %d\n",
2302			tpg->tv_tpg_vhost_count);
2303		return -EBUSY;
2304	}
2305
2306	pr_debug("TCM_vhost_ConfigFS: Removing I_T Nexus to emulated"
2307		" %s Initiator Port: %s\n", vhost_scsi_dump_proto_id(tpg->tport),
2308		tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
2309
 
2310	/*
2311	 * Release the SCSI I_T Nexus to the emulated vhost Target Port
2312	 */
2313	target_remove_session(se_sess);
2314	tpg->tpg_nexus = NULL;
2315	mutex_unlock(&tpg->tv_tpg_mutex);
2316
2317	kfree(tv_nexus);
2318	return 0;
2319}
2320
2321static ssize_t vhost_scsi_tpg_nexus_show(struct config_item *item, char *page)
 
2322{
2323	struct se_portal_group *se_tpg = to_tpg(item);
2324	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2325				struct vhost_scsi_tpg, se_tpg);
2326	struct vhost_scsi_nexus *tv_nexus;
2327	ssize_t ret;
2328
2329	mutex_lock(&tpg->tv_tpg_mutex);
2330	tv_nexus = tpg->tpg_nexus;
2331	if (!tv_nexus) {
2332		mutex_unlock(&tpg->tv_tpg_mutex);
2333		return -ENODEV;
2334	}
2335	ret = sysfs_emit(page, "%s\n",
2336			tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
2337	mutex_unlock(&tpg->tv_tpg_mutex);
2338
2339	return ret;
2340}
2341
2342static ssize_t vhost_scsi_tpg_nexus_store(struct config_item *item,
2343		const char *page, size_t count)
2344{
2345	struct se_portal_group *se_tpg = to_tpg(item);
2346	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2347				struct vhost_scsi_tpg, se_tpg);
2348	struct vhost_scsi_tport *tport_wwn = tpg->tport;
2349	unsigned char i_port[VHOST_SCSI_NAMELEN], *ptr, *port_ptr;
2350	int ret;
2351	/*
2352	 * Shutdown the active I_T nexus if 'NULL' is passed..
2353	 */
2354	if (!strncmp(page, "NULL", 4)) {
2355		ret = vhost_scsi_drop_nexus(tpg);
2356		return (!ret) ? count : ret;
2357	}
2358	/*
2359	 * Otherwise make sure the passed virtual Initiator port WWN matches
2360	 * the fabric protocol_id set in vhost_scsi_make_tport(), and call
2361	 * vhost_scsi_make_nexus().
2362	 */
2363	if (strlen(page) >= VHOST_SCSI_NAMELEN) {
2364		pr_err("Emulated NAA Sas Address: %s, exceeds"
2365				" max: %d\n", page, VHOST_SCSI_NAMELEN);
2366		return -EINVAL;
2367	}
2368	snprintf(&i_port[0], VHOST_SCSI_NAMELEN, "%s", page);
2369
2370	ptr = strstr(i_port, "naa.");
2371	if (ptr) {
2372		if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_SAS) {
2373			pr_err("Passed SAS Initiator Port %s does not"
2374				" match target port protoid: %s\n", i_port,
2375				vhost_scsi_dump_proto_id(tport_wwn));
2376			return -EINVAL;
2377		}
2378		port_ptr = &i_port[0];
2379		goto check_newline;
2380	}
2381	ptr = strstr(i_port, "fc.");
2382	if (ptr) {
2383		if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_FCP) {
2384			pr_err("Passed FCP Initiator Port %s does not"
2385				" match target port protoid: %s\n", i_port,
2386				vhost_scsi_dump_proto_id(tport_wwn));
2387			return -EINVAL;
2388		}
2389		port_ptr = &i_port[3]; /* Skip over "fc." */
2390		goto check_newline;
2391	}
2392	ptr = strstr(i_port, "iqn.");
2393	if (ptr) {
2394		if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_ISCSI) {
2395			pr_err("Passed iSCSI Initiator Port %s does not"
2396				" match target port protoid: %s\n", i_port,
2397				vhost_scsi_dump_proto_id(tport_wwn));
2398			return -EINVAL;
2399		}
2400		port_ptr = &i_port[0];
2401		goto check_newline;
2402	}
2403	pr_err("Unable to locate prefix for emulated Initiator Port:"
2404			" %s\n", i_port);
2405	return -EINVAL;
2406	/*
2407	 * Clear any trailing newline for the NAA WWN
2408	 */
2409check_newline:
2410	if (i_port[strlen(i_port)-1] == '\n')
2411		i_port[strlen(i_port)-1] = '\0';
2412
2413	ret = vhost_scsi_make_nexus(tpg, port_ptr);
2414	if (ret < 0)
2415		return ret;
2416
2417	return count;
2418}
2419
2420CONFIGFS_ATTR(vhost_scsi_tpg_, nexus);
2421
2422static struct configfs_attribute *vhost_scsi_tpg_attrs[] = {
2423	&vhost_scsi_tpg_attr_nexus,
2424	NULL,
2425};
2426
2427static struct se_portal_group *
2428vhost_scsi_make_tpg(struct se_wwn *wwn, const char *name)
 
 
2429{
2430	struct vhost_scsi_tport *tport = container_of(wwn,
2431			struct vhost_scsi_tport, tport_wwn);
2432
2433	struct vhost_scsi_tpg *tpg;
2434	u16 tpgt;
2435	int ret;
2436
2437	if (strstr(name, "tpgt_") != name)
2438		return ERR_PTR(-EINVAL);
2439	if (kstrtou16(name + 5, 10, &tpgt) || tpgt >= VHOST_SCSI_MAX_TARGET)
2440		return ERR_PTR(-EINVAL);
2441
2442	tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
2443	if (!tpg) {
2444		pr_err("Unable to allocate struct vhost_scsi_tpg");
2445		return ERR_PTR(-ENOMEM);
2446	}
2447	mutex_init(&tpg->tv_tpg_mutex);
2448	INIT_LIST_HEAD(&tpg->tv_tpg_list);
2449	tpg->tport = tport;
2450	tpg->tport_tpgt = tpgt;
2451
2452	ret = core_tpg_register(wwn, &tpg->se_tpg, tport->tport_proto_id);
 
2453	if (ret < 0) {
2454		kfree(tpg);
2455		return NULL;
2456	}
2457	mutex_lock(&vhost_scsi_mutex);
2458	list_add_tail(&tpg->tv_tpg_list, &vhost_scsi_list);
2459	mutex_unlock(&vhost_scsi_mutex);
2460
2461	return &tpg->se_tpg;
2462}
2463
2464static void vhost_scsi_drop_tpg(struct se_portal_group *se_tpg)
2465{
2466	struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2467				struct vhost_scsi_tpg, se_tpg);
2468
2469	mutex_lock(&vhost_scsi_mutex);
2470	list_del(&tpg->tv_tpg_list);
2471	mutex_unlock(&vhost_scsi_mutex);
2472	/*
2473	 * Release the virtual I_T Nexus for this vhost TPG
2474	 */
2475	vhost_scsi_drop_nexus(tpg);
2476	/*
2477	 * Deregister the se_tpg from TCM..
2478	 */
2479	core_tpg_deregister(se_tpg);
2480	kfree(tpg);
2481}
2482
2483static struct se_wwn *
2484vhost_scsi_make_tport(struct target_fabric_configfs *tf,
2485		     struct config_group *group,
2486		     const char *name)
2487{
2488	struct vhost_scsi_tport *tport;
2489	char *ptr;
2490	u64 wwpn = 0;
2491	int off = 0;
2492
2493	/* if (vhost_scsi_parse_wwn(name, &wwpn, 1) < 0)
2494		return ERR_PTR(-EINVAL); */
2495
2496	tport = kzalloc(sizeof(*tport), GFP_KERNEL);
2497	if (!tport) {
2498		pr_err("Unable to allocate struct vhost_scsi_tport");
2499		return ERR_PTR(-ENOMEM);
2500	}
2501	tport->tport_wwpn = wwpn;
2502	/*
2503	 * Determine the emulated Protocol Identifier and Target Port Name
2504	 * based on the incoming configfs directory name.
2505	 */
2506	ptr = strstr(name, "naa.");
2507	if (ptr) {
2508		tport->tport_proto_id = SCSI_PROTOCOL_SAS;
2509		goto check_len;
2510	}
2511	ptr = strstr(name, "fc.");
2512	if (ptr) {
2513		tport->tport_proto_id = SCSI_PROTOCOL_FCP;
2514		off = 3; /* Skip over "fc." */
2515		goto check_len;
2516	}
2517	ptr = strstr(name, "iqn.");
2518	if (ptr) {
2519		tport->tport_proto_id = SCSI_PROTOCOL_ISCSI;
2520		goto check_len;
2521	}
2522
2523	pr_err("Unable to locate prefix for emulated Target Port:"
2524			" %s\n", name);
2525	kfree(tport);
2526	return ERR_PTR(-EINVAL);
2527
2528check_len:
2529	if (strlen(name) >= VHOST_SCSI_NAMELEN) {
2530		pr_err("Emulated %s Address: %s, exceeds"
2531			" max: %d\n", name, vhost_scsi_dump_proto_id(tport),
2532			VHOST_SCSI_NAMELEN);
2533		kfree(tport);
2534		return ERR_PTR(-EINVAL);
2535	}
2536	snprintf(&tport->tport_name[0], VHOST_SCSI_NAMELEN, "%s", &name[off]);
2537
2538	pr_debug("TCM_VHost_ConfigFS: Allocated emulated Target"
2539		" %s Address: %s\n", vhost_scsi_dump_proto_id(tport), name);
2540
2541	return &tport->tport_wwn;
2542}
2543
2544static void vhost_scsi_drop_tport(struct se_wwn *wwn)
2545{
2546	struct vhost_scsi_tport *tport = container_of(wwn,
2547				struct vhost_scsi_tport, tport_wwn);
2548
2549	pr_debug("TCM_VHost_ConfigFS: Deallocating emulated Target"
2550		" %s Address: %s\n", vhost_scsi_dump_proto_id(tport),
2551		tport->tport_name);
2552
2553	kfree(tport);
2554}
2555
2556static ssize_t
2557vhost_scsi_wwn_version_show(struct config_item *item, char *page)
 
2558{
2559	return sysfs_emit(page, "TCM_VHOST fabric module %s on %s/%s"
2560		"on "UTS_RELEASE"\n", VHOST_SCSI_VERSION, utsname()->sysname,
2561		utsname()->machine);
2562}
2563
2564CONFIGFS_ATTR_RO(vhost_scsi_wwn_, version);
2565
2566static struct configfs_attribute *vhost_scsi_wwn_attrs[] = {
2567	&vhost_scsi_wwn_attr_version,
2568	NULL,
2569};
2570
2571static const struct target_core_fabric_ops vhost_scsi_ops = {
2572	.module				= THIS_MODULE,
2573	.fabric_name			= "vhost",
2574	.max_data_sg_nents		= VHOST_SCSI_PREALLOC_SGLS,
2575	.tpg_get_wwn			= vhost_scsi_get_fabric_wwn,
2576	.tpg_get_tag			= vhost_scsi_get_tpgt,
2577	.tpg_check_demo_mode		= vhost_scsi_check_true,
2578	.tpg_check_demo_mode_cache	= vhost_scsi_check_true,
2579	.tpg_check_prot_fabric_only	= vhost_scsi_check_prot_fabric_only,
2580	.release_cmd			= vhost_scsi_release_cmd,
 
 
 
 
 
 
 
2581	.check_stop_free		= vhost_scsi_check_stop_free,
 
 
 
2582	.sess_get_initiator_sid		= NULL,
2583	.write_pending			= vhost_scsi_write_pending,
2584	.queue_data_in			= vhost_scsi_queue_data_in,
2585	.queue_status			= vhost_scsi_queue_status,
2586	.queue_tm_rsp			= vhost_scsi_queue_tm_rsp,
2587	.aborted_task			= vhost_scsi_aborted_task,
 
 
 
 
2588	/*
2589	 * Setup callers for generic logic in target_core_fabric_configfs.c
2590	 */
2591	.fabric_make_wwn		= vhost_scsi_make_tport,
2592	.fabric_drop_wwn		= vhost_scsi_drop_tport,
2593	.fabric_make_tpg		= vhost_scsi_make_tpg,
2594	.fabric_drop_tpg		= vhost_scsi_drop_tpg,
2595	.fabric_post_link		= vhost_scsi_port_link,
2596	.fabric_pre_unlink		= vhost_scsi_port_unlink,
2597
2598	.tfc_wwn_attrs			= vhost_scsi_wwn_attrs,
2599	.tfc_tpg_base_attrs		= vhost_scsi_tpg_attrs,
2600	.tfc_tpg_attrib_attrs		= vhost_scsi_tpg_attrib_attrs,
2601
2602	.default_submit_type		= TARGET_QUEUE_SUBMIT,
2603	.direct_submit_supp		= 1,
2604};
2605
2606static int __init vhost_scsi_init(void)
2607{
2608	int ret = -ENOMEM;
 
2609
2610	pr_debug("TCM_VHOST fabric module %s on %s/%s"
2611		" on "UTS_RELEASE"\n", VHOST_SCSI_VERSION, utsname()->sysname,
2612		utsname()->machine);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2613
2614	ret = vhost_scsi_register();
2615	if (ret < 0)
2616		goto out;
2617
2618	ret = target_register_template(&vhost_scsi_ops);
2619	if (ret < 0)
2620		goto out_vhost_scsi_deregister;
2621
2622	return 0;
2623
2624out_vhost_scsi_deregister:
2625	vhost_scsi_deregister();
 
 
2626out:
2627	return ret;
2628};
2629
2630static void vhost_scsi_exit(void)
2631{
2632	target_unregister_template(&vhost_scsi_ops);
2633	vhost_scsi_deregister();
 
2634};
2635
2636MODULE_DESCRIPTION("VHOST_SCSI series fabric driver");
2637MODULE_ALIAS("tcm_vhost");
2638MODULE_LICENSE("GPL");
2639module_init(vhost_scsi_init);
2640module_exit(vhost_scsi_exit);