blob: dfcc02c936485199c44d1545bf95b73bfe23ff97 [file] [log] [blame]
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001/*******************************************************************************
2 * Vhost kernel TCM fabric driver for virtio SCSI initiators
3 *
Nicholas Bellinger4c762512013-09-05 15:29:12 -07004 * (C) Copyright 2010-2013 Datera, Inc.
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07005 * (C) Copyright 2010-2012 IBM Corp.
6 *
7 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
8 *
Nicholas Bellinger4c762512013-09-05 15:29:12 -07009 * Authors: Nicholas A. Bellinger <nab@daterainc.com>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070010 * 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>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070037#include <linux/fs.h>
David S. Miller5538d292015-05-28 11:35:41 -070038#include <linux/vmalloc.h>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070039#include <linux/miscdevice.h>
40#include <asm/unaligned.h>
Bart Van Asscheba929992015-05-08 10:11:12 +020041#include <scsi/scsi_common.h>
42#include <scsi/scsi_proto.h>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070043#include <target/target_core_base.h>
44#include <target/target_core_fabric.h>
45#include <target/target_core_fabric_configfs.h>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070046#include <target/configfs_macros.h>
47#include <linux/vhost.h>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070048#include <linux/virtio_scsi.h>
Asias He9d6064a2013-01-06 14:36:13 +080049#include <linux/llist.h>
Asias He1b7f3902013-02-06 13:20:59 +080050#include <linux/bitmap.h>
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -070051#include <linux/percpu_ida.h>
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070052
Nicholas Bellinger057cbf42012-07-18 14:31:32 -070053#include "vhost.h"
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +030054
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -080055#define VHOST_SCSI_VERSION "v0.1"
56#define VHOST_SCSI_NAMELEN 256
57#define VHOST_SCSI_MAX_CDB_SIZE 32
58#define VHOST_SCSI_DEFAULT_TAGS 256
59#define VHOST_SCSI_PREALLOC_SGLS 2048
60#define VHOST_SCSI_PREALLOC_UPAGES 2048
61#define VHOST_SCSI_PREALLOC_PROT_SGLS 512
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +030062
63struct vhost_scsi_inflight {
64 /* Wait for the flush operation to finish */
65 struct completion comp;
66 /* Refcount for the inflight reqs */
67 struct kref kref;
68};
69
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -080070struct vhost_scsi_cmd {
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +030071 /* Descriptor from vhost_get_vq_desc() for virt_queue segment */
72 int tvc_vq_desc;
73 /* virtio-scsi initiator task attribute */
74 int tvc_task_attr;
Nicholas Bellinger79c14142015-01-27 13:13:12 -080075 /* virtio-scsi response incoming iovecs */
76 int tvc_in_iovs;
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +030077 /* virtio-scsi initiator data direction */
78 enum dma_data_direction tvc_data_direction;
79 /* Expected data transfer length from virtio-scsi header */
80 u32 tvc_exp_data_len;
81 /* The Tag from include/linux/virtio_scsi.h:struct virtio_scsi_cmd_req */
82 u64 tvc_tag;
83 /* The number of scatterlists associated with this cmd */
84 u32 tvc_sgl_count;
Nicholas Bellingere31885d2014-02-22 18:34:43 -080085 u32 tvc_prot_sgl_count;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -080086 /* Saved unpacked SCSI LUN for vhost_scsi_submission_work() */
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +030087 u32 tvc_lun;
88 /* Pointer to the SGL formatted memory from virtio-scsi */
89 struct scatterlist *tvc_sgl;
Nicholas Bellingerb1935f62014-02-22 18:08:24 -080090 struct scatterlist *tvc_prot_sgl;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -070091 struct page **tvc_upages;
Nicholas Bellinger79c14142015-01-27 13:13:12 -080092 /* Pointer to response header iovec */
93 struct iovec *tvc_resp_iov;
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +030094 /* Pointer to vhost_scsi for our device */
95 struct vhost_scsi *tvc_vhost;
96 /* Pointer to vhost_virtqueue for the cmd */
97 struct vhost_virtqueue *tvc_vq;
98 /* Pointer to vhost nexus memory */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -080099 struct vhost_scsi_nexus *tvc_nexus;
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300100 /* The TCM I/O descriptor that is accessed via container_of() */
101 struct se_cmd tvc_se_cmd;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800102 /* work item used for cmwq dispatch to vhost_scsi_submission_work() */
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300103 struct work_struct work;
104 /* Copy of the incoming SCSI command descriptor block (CDB) */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800105 unsigned char tvc_cdb[VHOST_SCSI_MAX_CDB_SIZE];
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300106 /* Sense buffer that will be mapped into outgoing status */
107 unsigned char tvc_sense_buf[TRANSPORT_SENSE_BUFFER];
108 /* Completed commands list, serviced from vhost worker thread */
109 struct llist_node tvc_completion_list;
110 /* Used to track inflight cmd */
111 struct vhost_scsi_inflight *inflight;
112};
113
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800114struct vhost_scsi_nexus {
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300115 /* Pointer to TCM session for I_T Nexus */
116 struct se_session *tvn_se_sess;
117};
118
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800119struct vhost_scsi_tpg {
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300120 /* Vhost port target portal group tag for TCM */
121 u16 tport_tpgt;
122 /* Used to track number of TPG Port/Lun Links wrt to explict I_T Nexus shutdown */
123 int tv_tpg_port_count;
124 /* Used for vhost_scsi device reference to tpg_nexus, protected by tv_tpg_mutex */
125 int tv_tpg_vhost_count;
Nicholas Bellingerb1d75fe2015-03-28 00:03:51 -0700126 /* Used for enabling T10-PI with legacy devices */
127 int tv_fabric_prot_type;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800128 /* list for vhost_scsi_list */
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300129 struct list_head tv_tpg_list;
130 /* Used to protect access for tpg_nexus */
131 struct mutex tv_tpg_mutex;
132 /* Pointer to the TCM VHost I_T Nexus for this TPG endpoint */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800133 struct vhost_scsi_nexus *tpg_nexus;
134 /* Pointer back to vhost_scsi_tport */
135 struct vhost_scsi_tport *tport;
136 /* Returned by vhost_scsi_make_tpg() */
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300137 struct se_portal_group se_tpg;
138 /* Pointer back to vhost_scsi, protected by tv_tpg_mutex */
139 struct vhost_scsi *vhost_scsi;
140};
141
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800142struct vhost_scsi_tport {
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300143 /* SCSI protocol the tport is providing */
144 u8 tport_proto_id;
145 /* Binary World Wide unique Port Name for Vhost Target port */
146 u64 tport_wwpn;
147 /* ASCII formatted WWPN for Vhost Target port */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800148 char tport_name[VHOST_SCSI_NAMELEN];
149 /* Returned by vhost_scsi_make_tport() */
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300150 struct se_wwn tport_wwn;
151};
152
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800153struct vhost_scsi_evt {
Michael S. Tsirkin5012a3a2013-05-02 03:50:34 +0300154 /* event to be sent to guest */
155 struct virtio_scsi_event event;
156 /* event list, serviced from vhost worker thread */
157 struct llist_node list;
158};
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700159
Nicholas Bellinger101998f2012-07-30 13:30:00 -0700160enum {
161 VHOST_SCSI_VQ_CTL = 0,
162 VHOST_SCSI_VQ_EVT = 1,
163 VHOST_SCSI_VQ_IO = 2,
164};
165
Michael S. Tsirkine72fd722014-11-23 18:01:34 +0200166/* Note: can't set VIRTIO_F_VERSION_1 yet, since that implies ANY_LAYOUT. */
Nicholas Bellinger5dade712013-03-27 17:23:41 -0700167enum {
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800168 VHOST_SCSI_FEATURES = VHOST_FEATURES | (1ULL << VIRTIO_SCSI_F_HOTPLUG) |
Nicholas Bellinger664ed902015-01-28 01:31:52 -0800169 (1ULL << VIRTIO_SCSI_F_T10_PI) |
170 (1ULL << VIRTIO_F_ANY_LAYOUT) |
171 (1ULL << VIRTIO_F_VERSION_1)
Nicholas Bellinger5dade712013-03-27 17:23:41 -0700172};
173
Asias He1b7f3902013-02-06 13:20:59 +0800174#define VHOST_SCSI_MAX_TARGET 256
175#define VHOST_SCSI_MAX_VQ 128
Asias Hea6c9af82013-04-25 15:35:21 +0800176#define VHOST_SCSI_MAX_EVENT 128
Asias He67e18cf2013-02-05 12:31:57 +0800177
Asias He3ab2e422013-04-27 11:16:48 +0800178struct vhost_scsi_virtqueue {
179 struct vhost_virtqueue vq;
Michael S. Tsirkin3dfbff32013-04-28 15:38:52 +0300180 /*
181 * Reference counting for inflight reqs, used for flush operation. At
182 * each time, one reference tracks new commands submitted, while we
183 * wait for another one to reach 0.
184 */
Asias Hef2f0173d2013-04-27 11:16:49 +0800185 struct vhost_scsi_inflight inflights[2];
Michael S. Tsirkin3dfbff32013-04-28 15:38:52 +0300186 /*
187 * Indicate current inflight in use, protected by vq->mutex.
188 * Writers must also take dev mutex and flush under it.
189 */
Asias Hef2f0173d2013-04-27 11:16:49 +0800190 int inflight_idx;
Asias He3ab2e422013-04-27 11:16:48 +0800191};
192
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700193struct vhost_scsi {
Asias He67e18cf2013-02-05 12:31:57 +0800194 /* Protected by vhost_scsi->dev.mutex */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800195 struct vhost_scsi_tpg **vs_tpg;
Asias He67e18cf2013-02-05 12:31:57 +0800196 char vs_vhost_wwpn[TRANSPORT_IQN_LEN];
Asias He67e18cf2013-02-05 12:31:57 +0800197
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700198 struct vhost_dev dev;
Asias He3ab2e422013-04-27 11:16:48 +0800199 struct vhost_scsi_virtqueue vqs[VHOST_SCSI_MAX_VQ];
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700200
201 struct vhost_work vs_completion_work; /* cmd completion work item */
Asias He9d6064a2013-01-06 14:36:13 +0800202 struct llist_head vs_completion_list; /* cmd completion queue */
Asias Hea6c9af82013-04-25 15:35:21 +0800203
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 */
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700209};
210
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800211static struct workqueue_struct *vhost_scsi_workqueue;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700212
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800213/* Global spinlock to protect vhost_scsi TPG list for vhost IOCTL access */
214static DEFINE_MUTEX(vhost_scsi_mutex);
215static LIST_HEAD(vhost_scsi_list);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700216
Nicholas Bellingerb4078b52015-01-28 13:10:51 -0800217static int iov_num_pages(void __user *iov_base, size_t iov_len)
Asias He765b34f2013-01-22 11:20:25 +0800218{
Nicholas Bellingerb4078b52015-01-28 13:10:51 -0800219 return (PAGE_ALIGN((unsigned long)iov_base + iov_len) -
220 ((unsigned long)iov_base & PAGE_MASK)) >> PAGE_SHIFT;
Asias He765b34f2013-01-22 11:20:25 +0800221}
222
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800223static void vhost_scsi_done_inflight(struct kref *kref)
Asias Hef2f0173d2013-04-27 11:16:49 +0800224{
225 struct vhost_scsi_inflight *inflight;
226
227 inflight = container_of(kref, struct vhost_scsi_inflight, kref);
228 complete(&inflight->comp);
229}
230
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800231static void vhost_scsi_init_inflight(struct vhost_scsi *vs,
Asias Hef2f0173d2013-04-27 11:16:49 +0800232 struct vhost_scsi_inflight *old_inflight[])
233{
234 struct vhost_scsi_inflight *new_inflight;
235 struct vhost_virtqueue *vq;
236 int idx, i;
237
238 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
239 vq = &vs->vqs[i].vq;
240
241 mutex_lock(&vq->mutex);
242
243 /* store old infight */
244 idx = vs->vqs[i].inflight_idx;
245 if (old_inflight)
246 old_inflight[i] = &vs->vqs[i].inflights[idx];
247
248 /* setup new infight */
249 vs->vqs[i].inflight_idx = idx ^ 1;
250 new_inflight = &vs->vqs[i].inflights[idx ^ 1];
251 kref_init(&new_inflight->kref);
252 init_completion(&new_inflight->comp);
253
254 mutex_unlock(&vq->mutex);
255 }
256}
257
258static struct vhost_scsi_inflight *
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800259vhost_scsi_get_inflight(struct vhost_virtqueue *vq)
Asias Hef2f0173d2013-04-27 11:16:49 +0800260{
261 struct vhost_scsi_inflight *inflight;
262 struct vhost_scsi_virtqueue *svq;
263
264 svq = container_of(vq, struct vhost_scsi_virtqueue, vq);
265 inflight = &svq->inflights[svq->inflight_idx];
266 kref_get(&inflight->kref);
267
268 return inflight;
269}
270
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800271static void vhost_scsi_put_inflight(struct vhost_scsi_inflight *inflight)
Asias Hef2f0173d2013-04-27 11:16:49 +0800272{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800273 kref_put(&inflight->kref, vhost_scsi_done_inflight);
Asias Hef2f0173d2013-04-27 11:16:49 +0800274}
275
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800276static int vhost_scsi_check_true(struct se_portal_group *se_tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700277{
278 return 1;
279}
280
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800281static int vhost_scsi_check_false(struct se_portal_group *se_tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700282{
283 return 0;
284}
285
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800286static char *vhost_scsi_get_fabric_name(void)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700287{
288 return "vhost";
289}
290
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800291static char *vhost_scsi_get_fabric_wwn(struct se_portal_group *se_tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700292{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800293 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
294 struct vhost_scsi_tpg, se_tpg);
295 struct vhost_scsi_tport *tport = tpg->tport;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700296
297 return &tport->tport_name[0];
298}
299
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800300static u16 vhost_scsi_get_tpgt(struct se_portal_group *se_tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700301{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800302 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
303 struct vhost_scsi_tpg, se_tpg);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700304 return tpg->tport_tpgt;
305}
306
Nicholas Bellingerb1d75fe2015-03-28 00:03:51 -0700307static int vhost_scsi_check_prot_fabric_only(struct se_portal_group *se_tpg)
308{
309 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
310 struct vhost_scsi_tpg, se_tpg);
311
312 return tpg->tv_fabric_prot_type;
313}
314
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800315static u32 vhost_scsi_tpg_get_inst_index(struct se_portal_group *se_tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700316{
317 return 1;
318}
319
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800320static void vhost_scsi_release_cmd(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700321{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800322 struct vhost_scsi_cmd *tv_cmd = container_of(se_cmd,
323 struct vhost_scsi_cmd, tvc_se_cmd);
Nicholas Bellingerde1419e2015-01-29 17:21:13 -0800324 struct se_session *se_sess = tv_cmd->tvc_nexus->tvn_se_sess;
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800325 int i;
Nicholas Bellinger084ed452013-06-06 02:20:41 -0700326
327 if (tv_cmd->tvc_sgl_count) {
Nicholas Bellinger084ed452013-06-06 02:20:41 -0700328 for (i = 0; i < tv_cmd->tvc_sgl_count; i++)
329 put_page(sg_page(&tv_cmd->tvc_sgl[i]));
Michael S. Tsirkind3d665a2013-09-17 22:54:31 +0300330 }
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800331 if (tv_cmd->tvc_prot_sgl_count) {
332 for (i = 0; i < tv_cmd->tvc_prot_sgl_count; i++)
333 put_page(sg_page(&tv_cmd->tvc_prot_sgl[i]));
334 }
Nicholas Bellinger084ed452013-06-06 02:20:41 -0700335
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800336 vhost_scsi_put_inflight(tv_cmd->inflight);
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -0700337 percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700338}
339
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800340static int vhost_scsi_shutdown_session(struct se_session *se_sess)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700341{
342 return 0;
343}
344
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800345static void vhost_scsi_close_session(struct se_session *se_sess)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700346{
347 return;
348}
349
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800350static u32 vhost_scsi_sess_get_index(struct se_session *se_sess)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700351{
352 return 0;
353}
354
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800355static int vhost_scsi_write_pending(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700356{
357 /* Go ahead and process the write immediately */
358 target_execute_cmd(se_cmd);
359 return 0;
360}
361
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800362static int vhost_scsi_write_pending_status(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700363{
364 return 0;
365}
366
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800367static void vhost_scsi_set_default_node_attrs(struct se_node_acl *nacl)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700368{
369 return;
370}
371
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800372static int vhost_scsi_get_cmd_state(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700373{
374 return 0;
375}
376
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800377static void vhost_scsi_complete_cmd(struct vhost_scsi_cmd *cmd)
Nicholas Bellinger101998f2012-07-30 13:30:00 -0700378{
Asias He3c63f662013-05-06 16:38:29 +0800379 struct vhost_scsi *vs = cmd->tvc_vhost;
Nicholas Bellinger101998f2012-07-30 13:30:00 -0700380
Asias He3c63f662013-05-06 16:38:29 +0800381 llist_add(&cmd->tvc_completion_list, &vs->vs_completion_list);
Nicholas Bellinger101998f2012-07-30 13:30:00 -0700382
383 vhost_work_queue(&vs->dev, &vs->vs_completion_work);
384}
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700385
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800386static int vhost_scsi_queue_data_in(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700387{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800388 struct vhost_scsi_cmd *cmd = container_of(se_cmd,
389 struct vhost_scsi_cmd, tvc_se_cmd);
Asias He3c63f662013-05-06 16:38:29 +0800390 vhost_scsi_complete_cmd(cmd);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700391 return 0;
392}
393
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800394static int vhost_scsi_queue_status(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700395{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800396 struct vhost_scsi_cmd *cmd = container_of(se_cmd,
397 struct vhost_scsi_cmd, tvc_se_cmd);
Asias He3c63f662013-05-06 16:38:29 +0800398 vhost_scsi_complete_cmd(cmd);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700399 return 0;
400}
401
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800402static void vhost_scsi_queue_tm_rsp(struct se_cmd *se_cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700403{
Joern Engelb79fafa2013-07-03 11:22:17 -0400404 return;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700405}
406
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800407static void vhost_scsi_aborted_task(struct se_cmd *se_cmd)
Nicholas Bellinger131e6ab2014-03-22 14:55:56 -0700408{
409 return;
410}
411
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800412static void vhost_scsi_free_evt(struct vhost_scsi *vs, struct vhost_scsi_evt *evt)
Asias Hea6c9af82013-04-25 15:35:21 +0800413{
414 vs->vs_events_nr--;
415 kfree(evt);
416}
417
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800418static struct vhost_scsi_evt *
419vhost_scsi_allocate_evt(struct vhost_scsi *vs,
Asias He683bd962013-05-06 16:38:27 +0800420 u32 event, u32 reason)
Asias Hea6c9af82013-04-25 15:35:21 +0800421{
Asias He3ab2e422013-04-27 11:16:48 +0800422 struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800423 struct vhost_scsi_evt *evt;
Asias Hea6c9af82013-04-25 15:35:21 +0800424
425 if (vs->vs_events_nr > VHOST_SCSI_MAX_EVENT) {
426 vs->vs_events_missed = true;
427 return NULL;
428 }
429
430 evt = kzalloc(sizeof(*evt), GFP_KERNEL);
431 if (!evt) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800432 vq_err(vq, "Failed to allocate vhost_scsi_evt\n");
Asias Hea6c9af82013-04-25 15:35:21 +0800433 vs->vs_events_missed = true;
434 return NULL;
435 }
436
Michael S. Tsirkine72fd722014-11-23 18:01:34 +0200437 evt->event.event = cpu_to_vhost32(vq, event);
438 evt->event.reason = cpu_to_vhost32(vq, reason);
Asias Hea6c9af82013-04-25 15:35:21 +0800439 vs->vs_events_nr++;
440
441 return evt;
442}
443
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800444static void vhost_scsi_free_cmd(struct vhost_scsi_cmd *cmd)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700445{
Asias He3c63f662013-05-06 16:38:29 +0800446 struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700447
448 /* TODO locking against target/backend threads? */
Nicholas Bellinger6c131d02013-06-06 01:44:48 -0700449 transport_generic_free_cmd(se_cmd, 0);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700450
Nicholas Bellinger084ed452013-06-06 02:20:41 -0700451}
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700452
Nicholas Bellinger084ed452013-06-06 02:20:41 -0700453static int vhost_scsi_check_stop_free(struct se_cmd *se_cmd)
454{
Bart Van Asscheafc16602015-04-27 13:52:36 +0200455 return target_put_sess_cmd(se_cmd);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700456}
457
Asias He683bd962013-05-06 16:38:27 +0800458static void
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800459vhost_scsi_do_evt_work(struct vhost_scsi *vs, struct vhost_scsi_evt *evt)
Asias Hea6c9af82013-04-25 15:35:21 +0800460{
Asias He3ab2e422013-04-27 11:16:48 +0800461 struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
Asias Hea6c9af82013-04-25 15:35:21 +0800462 struct virtio_scsi_event *event = &evt->event;
463 struct virtio_scsi_event __user *eventp;
464 unsigned out, in;
465 int head, ret;
466
467 if (!vq->private_data) {
468 vs->vs_events_missed = true;
469 return;
470 }
471
472again:
473 vhost_disable_notify(&vs->dev, vq);
Michael S. Tsirkin47283be2014-06-05 15:20:27 +0300474 head = vhost_get_vq_desc(vq, vq->iov,
Asias Hea6c9af82013-04-25 15:35:21 +0800475 ARRAY_SIZE(vq->iov), &out, &in,
476 NULL, NULL);
477 if (head < 0) {
478 vs->vs_events_missed = true;
479 return;
480 }
481 if (head == vq->num) {
482 if (vhost_enable_notify(&vs->dev, vq))
483 goto again;
484 vs->vs_events_missed = true;
485 return;
486 }
487
488 if ((vq->iov[out].iov_len != sizeof(struct virtio_scsi_event))) {
489 vq_err(vq, "Expecting virtio_scsi_event, got %zu bytes\n",
490 vq->iov[out].iov_len);
491 vs->vs_events_missed = true;
492 return;
493 }
494
495 if (vs->vs_events_missed) {
Michael S. Tsirkine72fd722014-11-23 18:01:34 +0200496 event->event |= cpu_to_vhost32(vq, VIRTIO_SCSI_T_EVENTS_MISSED);
Asias Hea6c9af82013-04-25 15:35:21 +0800497 vs->vs_events_missed = false;
498 }
499
500 eventp = vq->iov[out].iov_base;
501 ret = __copy_to_user(eventp, event, sizeof(*event));
502 if (!ret)
503 vhost_add_used_and_signal(&vs->dev, vq, head, 0);
504 else
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800505 vq_err(vq, "Faulted on vhost_scsi_send_event\n");
Asias Hea6c9af82013-04-25 15:35:21 +0800506}
507
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800508static void vhost_scsi_evt_work(struct vhost_work *work)
Asias Hea6c9af82013-04-25 15:35:21 +0800509{
510 struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
511 vs_event_work);
Asias He3ab2e422013-04-27 11:16:48 +0800512 struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800513 struct vhost_scsi_evt *evt;
Asias Hea6c9af82013-04-25 15:35:21 +0800514 struct llist_node *llnode;
515
516 mutex_lock(&vq->mutex);
517 llnode = llist_del_all(&vs->vs_event_list);
518 while (llnode) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800519 evt = llist_entry(llnode, struct vhost_scsi_evt, list);
Asias Hea6c9af82013-04-25 15:35:21 +0800520 llnode = llist_next(llnode);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800521 vhost_scsi_do_evt_work(vs, evt);
522 vhost_scsi_free_evt(vs, evt);
Asias Hea6c9af82013-04-25 15:35:21 +0800523 }
524 mutex_unlock(&vq->mutex);
525}
526
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700527/* Fill in status and signal that we are done processing this command
528 *
529 * This is scheduled in the vhost work queue so we are called with the owner
530 * process mm and can access the vring.
531 */
532static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
533{
534 struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
535 vs_completion_work);
Asias He1b7f3902013-02-06 13:20:59 +0800536 DECLARE_BITMAP(signal, VHOST_SCSI_MAX_VQ);
Asias He9d6064a2013-01-06 14:36:13 +0800537 struct virtio_scsi_cmd_resp v_rsp;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800538 struct vhost_scsi_cmd *cmd;
Asias He9d6064a2013-01-06 14:36:13 +0800539 struct llist_node *llnode;
540 struct se_cmd *se_cmd;
Nicholas Bellinger79c14142015-01-27 13:13:12 -0800541 struct iov_iter iov_iter;
Asias He1b7f3902013-02-06 13:20:59 +0800542 int ret, vq;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700543
Asias He1b7f3902013-02-06 13:20:59 +0800544 bitmap_zero(signal, VHOST_SCSI_MAX_VQ);
Asias He9d6064a2013-01-06 14:36:13 +0800545 llnode = llist_del_all(&vs->vs_completion_list);
546 while (llnode) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800547 cmd = llist_entry(llnode, struct vhost_scsi_cmd,
Asias He9d6064a2013-01-06 14:36:13 +0800548 tvc_completion_list);
549 llnode = llist_next(llnode);
Asias He3c63f662013-05-06 16:38:29 +0800550 se_cmd = &cmd->tvc_se_cmd;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700551
552 pr_debug("%s tv_cmd %p resid %u status %#02x\n", __func__,
Asias He3c63f662013-05-06 16:38:29 +0800553 cmd, se_cmd->residual_count, se_cmd->scsi_status);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700554
555 memset(&v_rsp, 0, sizeof(v_rsp));
Michael S. Tsirkine72fd722014-11-23 18:01:34 +0200556 v_rsp.resid = cpu_to_vhost32(cmd->tvc_vq, se_cmd->residual_count);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700557 /* TODO is status_qualifier field needed? */
558 v_rsp.status = se_cmd->scsi_status;
Michael S. Tsirkine72fd722014-11-23 18:01:34 +0200559 v_rsp.sense_len = cpu_to_vhost32(cmd->tvc_vq,
560 se_cmd->scsi_sense_length);
Asias He3c63f662013-05-06 16:38:29 +0800561 memcpy(v_rsp.sense, cmd->tvc_sense_buf,
Michael S. Tsirkine72fd722014-11-23 18:01:34 +0200562 se_cmd->scsi_sense_length);
Nicholas Bellinger79c14142015-01-27 13:13:12 -0800563
564 iov_iter_init(&iov_iter, READ, cmd->tvc_resp_iov,
565 cmd->tvc_in_iovs, sizeof(v_rsp));
566 ret = copy_to_iter(&v_rsp, sizeof(v_rsp), &iov_iter);
567 if (likely(ret == sizeof(v_rsp))) {
Asias He3ab2e422013-04-27 11:16:48 +0800568 struct vhost_scsi_virtqueue *q;
Asias He3c63f662013-05-06 16:38:29 +0800569 vhost_add_used(cmd->tvc_vq, cmd->tvc_vq_desc, 0);
570 q = container_of(cmd->tvc_vq, struct vhost_scsi_virtqueue, vq);
Asias He3ab2e422013-04-27 11:16:48 +0800571 vq = q - vs->vqs;
Asias He1b7f3902013-02-06 13:20:59 +0800572 __set_bit(vq, signal);
573 } else
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700574 pr_err("Faulted on virtio_scsi_cmd_resp\n");
575
Asias He3c63f662013-05-06 16:38:29 +0800576 vhost_scsi_free_cmd(cmd);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700577 }
578
Asias He1b7f3902013-02-06 13:20:59 +0800579 vq = -1;
580 while ((vq = find_next_bit(signal, VHOST_SCSI_MAX_VQ, vq + 1))
581 < VHOST_SCSI_MAX_VQ)
Asias He3ab2e422013-04-27 11:16:48 +0800582 vhost_signal(&vs->dev, &vs->vqs[vq].vq);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700583}
584
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800585static struct vhost_scsi_cmd *
586vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg,
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800587 unsigned char *cdb, u64 scsi_tag, u16 lun, u8 task_attr,
588 u32 exp_data_len, int data_direction)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700589{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800590 struct vhost_scsi_cmd *cmd;
591 struct vhost_scsi_nexus *tv_nexus;
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -0700592 struct se_session *se_sess;
Nicholas Bellingerb1935f62014-02-22 18:08:24 -0800593 struct scatterlist *sg, *prot_sg;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700594 struct page **pages;
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -0700595 int tag;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700596
Asias He98718312013-05-06 16:38:28 +0800597 tv_nexus = tpg->tpg_nexus;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700598 if (!tv_nexus) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800599 pr_err("Unable to locate active struct vhost_scsi_nexus\n");
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700600 return ERR_PTR(-EIO);
601 }
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -0700602 se_sess = tv_nexus->tvn_se_sess;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700603
Kent Overstreet6f6b5d12014-01-19 08:26:37 +0000604 tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING);
Nicholas Bellinger4a47d3a2013-09-23 11:42:28 -0700605 if (tag < 0) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800606 pr_err("Unable to obtain tag for vhost_scsi_cmd\n");
Nicholas Bellinger4a47d3a2013-09-23 11:42:28 -0700607 return ERR_PTR(-ENOMEM);
608 }
609
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800610 cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[tag];
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700611 sg = cmd->tvc_sgl;
Nicholas Bellingerb1935f62014-02-22 18:08:24 -0800612 prot_sg = cmd->tvc_prot_sgl;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700613 pages = cmd->tvc_upages;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800614 memset(cmd, 0, sizeof(struct vhost_scsi_cmd));
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -0700615
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700616 cmd->tvc_sgl = sg;
Nicholas Bellingerb1935f62014-02-22 18:08:24 -0800617 cmd->tvc_prot_sgl = prot_sg;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700618 cmd->tvc_upages = pages;
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -0700619 cmd->tvc_se_cmd.map_tag = tag;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800620 cmd->tvc_tag = scsi_tag;
621 cmd->tvc_lun = lun;
622 cmd->tvc_task_attr = task_attr;
Asias He3c63f662013-05-06 16:38:29 +0800623 cmd->tvc_exp_data_len = exp_data_len;
624 cmd->tvc_data_direction = data_direction;
625 cmd->tvc_nexus = tv_nexus;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800626 cmd->inflight = vhost_scsi_get_inflight(vq);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700627
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800628 memcpy(cmd->tvc_cdb, cdb, VHOST_SCSI_MAX_CDB_SIZE);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800629
Asias He3c63f662013-05-06 16:38:29 +0800630 return cmd;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700631}
632
633/*
634 * Map a user memory range into a scatterlist
635 *
636 * Returns the number of scatterlist entries used or -errno on error.
637 */
Asias He683bd962013-05-06 16:38:27 +0800638static int
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800639vhost_scsi_map_to_sgl(struct vhost_scsi_cmd *cmd,
Nicholas Bellingerb4078b52015-01-28 13:10:51 -0800640 void __user *ptr,
641 size_t len,
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700642 struct scatterlist *sgl,
Nicholas Bellinger5a01d082014-02-22 18:34:08 -0800643 bool write)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700644{
Nicholas Bellingerb4078b52015-01-28 13:10:51 -0800645 unsigned int npages = 0, offset, nbytes;
646 unsigned int pages_nr = iov_num_pages(ptr, len);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700647 struct scatterlist *sg = sgl;
Nicholas Bellingerb4078b52015-01-28 13:10:51 -0800648 struct page **pages = cmd->tvc_upages;
Asias He18100532013-01-22 11:20:27 +0800649 int ret, i;
650
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800651 if (pages_nr > VHOST_SCSI_PREALLOC_UPAGES) {
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -0700652 pr_err("vhost_scsi_map_to_sgl() pages_nr: %u greater than"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800653 " preallocated VHOST_SCSI_PREALLOC_UPAGES: %u\n",
654 pages_nr, VHOST_SCSI_PREALLOC_UPAGES);
Nicholas Bellinger5a01d082014-02-22 18:34:08 -0800655 return -ENOBUFS;
656 }
Asias He18100532013-01-22 11:20:27 +0800657
658 ret = get_user_pages_fast((unsigned long)ptr, pages_nr, write, pages);
659 /* No pages were pinned */
660 if (ret < 0)
661 goto out;
662 /* Less pages pinned than wanted */
663 if (ret != pages_nr) {
664 for (i = 0; i < ret; i++)
665 put_page(pages[i]);
666 ret = -EFAULT;
667 goto out;
668 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700669
670 while (len > 0) {
Asias He18100532013-01-22 11:20:27 +0800671 offset = (uintptr_t)ptr & ~PAGE_MASK;
672 nbytes = min_t(unsigned int, PAGE_SIZE - offset, len);
673 sg_set_page(sg, pages[npages], nbytes, offset);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700674 ptr += nbytes;
675 len -= nbytes;
676 sg++;
677 npages++;
678 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700679
Asias He18100532013-01-22 11:20:27 +0800680out:
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700681 return ret;
682}
683
Asias He683bd962013-05-06 16:38:27 +0800684static int
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800685vhost_scsi_calc_sgls(struct iov_iter *iter, size_t bytes, int max_sgls)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700686{
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800687 int sgl_count = 0;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700688
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800689 if (!iter || !iter->iov) {
690 pr_err("%s: iter->iov is NULL, but expected bytes: %zu"
691 " present\n", __func__, bytes);
692 return -EINVAL;
Nicholas Bellinger5a01d082014-02-22 18:34:08 -0800693 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700694
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800695 sgl_count = iov_iter_npages(iter, 0xffff);
696 if (sgl_count > max_sgls) {
697 pr_err("%s: requested sgl_count: %d exceeds pre-allocated"
698 " max_sgls: %d\n", __func__, sgl_count, max_sgls);
699 return -EINVAL;
700 }
701 return sgl_count;
702}
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700703
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800704static int
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800705vhost_scsi_iov_to_sgl(struct vhost_scsi_cmd *cmd, bool write,
706 struct iov_iter *iter,
707 struct scatterlist *sg, int sg_count)
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800708{
709 size_t off = iter->iov_offset;
710 int i, ret;
Nicholas Bellinger5a01d082014-02-22 18:34:08 -0800711
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800712 for (i = 0; i < iter->nr_segs; i++) {
713 void __user *base = iter->iov[i].iov_base + off;
714 size_t len = iter->iov[i].iov_len - off;
715
716 ret = vhost_scsi_map_to_sgl(cmd, base, len, sg, write);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700717 if (ret < 0) {
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800718 for (i = 0; i < sg_count; i++) {
719 struct page *page = sg_page(&sg[i]);
720 if (page)
721 put_page(page);
722 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700723 return ret;
724 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700725 sg += ret;
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800726 off = 0;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700727 }
728 return 0;
729}
730
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800731static int
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800732vhost_scsi_mapal(struct vhost_scsi_cmd *cmd,
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800733 size_t prot_bytes, struct iov_iter *prot_iter,
734 size_t data_bytes, struct iov_iter *data_iter)
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800735{
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800736 int sgl_count, ret;
737 bool write = (cmd->tvc_data_direction == DMA_FROM_DEVICE);
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800738
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800739 if (prot_bytes) {
740 sgl_count = vhost_scsi_calc_sgls(prot_iter, prot_bytes,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800741 VHOST_SCSI_PREALLOC_PROT_SGLS);
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800742 if (sgl_count < 0)
743 return sgl_count;
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800744
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800745 sg_init_table(cmd->tvc_prot_sgl, sgl_count);
746 cmd->tvc_prot_sgl_count = sgl_count;
747 pr_debug("%s prot_sg %p prot_sgl_count %u\n", __func__,
748 cmd->tvc_prot_sgl, cmd->tvc_prot_sgl_count);
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800749
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800750 ret = vhost_scsi_iov_to_sgl(cmd, write, prot_iter,
751 cmd->tvc_prot_sgl,
752 cmd->tvc_prot_sgl_count);
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800753 if (ret < 0) {
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800754 cmd->tvc_prot_sgl_count = 0;
755 return ret;
756 }
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800757 }
758 sgl_count = vhost_scsi_calc_sgls(data_iter, data_bytes,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800759 VHOST_SCSI_PREALLOC_SGLS);
Nicholas Bellingere8de56b2015-01-28 00:15:00 -0800760 if (sgl_count < 0)
761 return sgl_count;
762
763 sg_init_table(cmd->tvc_sgl, sgl_count);
764 cmd->tvc_sgl_count = sgl_count;
765 pr_debug("%s data_sg %p data_sgl_count %u\n", __func__,
766 cmd->tvc_sgl, cmd->tvc_sgl_count);
767
768 ret = vhost_scsi_iov_to_sgl(cmd, write, data_iter,
769 cmd->tvc_sgl, cmd->tvc_sgl_count);
770 if (ret < 0) {
771 cmd->tvc_sgl_count = 0;
772 return ret;
Nicholas Bellingere31885d2014-02-22 18:34:43 -0800773 }
774 return 0;
775}
776
Nicholas Bellinger46243862014-12-21 10:42:08 -0800777static int vhost_scsi_to_tcm_attr(int attr)
778{
779 switch (attr) {
780 case VIRTIO_SCSI_S_SIMPLE:
781 return TCM_SIMPLE_TAG;
782 case VIRTIO_SCSI_S_ORDERED:
783 return TCM_ORDERED_TAG;
784 case VIRTIO_SCSI_S_HEAD:
785 return TCM_HEAD_TAG;
786 case VIRTIO_SCSI_S_ACA:
787 return TCM_ACA_TAG;
788 default:
789 break;
790 }
791 return TCM_SIMPLE_TAG;
792}
793
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800794static void vhost_scsi_submission_work(struct work_struct *work)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700795{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800796 struct vhost_scsi_cmd *cmd =
797 container_of(work, struct vhost_scsi_cmd, work);
798 struct vhost_scsi_nexus *tv_nexus;
Asias He3c63f662013-05-06 16:38:29 +0800799 struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800800 struct scatterlist *sg_ptr, *sg_prot_ptr = NULL;
801 int rc;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700802
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800803 /* FIXME: BIDI operation */
Asias He3c63f662013-05-06 16:38:29 +0800804 if (cmd->tvc_sgl_count) {
805 sg_ptr = cmd->tvc_sgl;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800806
807 if (cmd->tvc_prot_sgl_count)
808 sg_prot_ptr = cmd->tvc_prot_sgl;
809 else
810 se_cmd->prot_pto = true;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700811 } else {
812 sg_ptr = NULL;
813 }
Asias He3c63f662013-05-06 16:38:29 +0800814 tv_nexus = cmd->tvc_nexus;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700815
Bart Van Assche649ee052015-04-14 13:26:44 +0200816 se_cmd->tag = 0;
Nicholas Bellinger9f0abc12012-10-01 18:40:55 -0700817 rc = target_submit_cmd_map_sgls(se_cmd, tv_nexus->tvn_se_sess,
Asias He3c63f662013-05-06 16:38:29 +0800818 cmd->tvc_cdb, &cmd->tvc_sense_buf[0],
819 cmd->tvc_lun, cmd->tvc_exp_data_len,
Nicholas Bellinger46243862014-12-21 10:42:08 -0800820 vhost_scsi_to_tcm_attr(cmd->tvc_task_attr),
821 cmd->tvc_data_direction, TARGET_SCF_ACK_KREF,
822 sg_ptr, cmd->tvc_sgl_count, NULL, 0, sg_prot_ptr,
823 cmd->tvc_prot_sgl_count);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700824 if (rc < 0) {
825 transport_send_check_condition_and_sense(se_cmd,
Nicholas Bellinger9f0abc12012-10-01 18:40:55 -0700826 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700827 transport_generic_free_cmd(se_cmd, 0);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700828 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700829}
830
Asias He683bd962013-05-06 16:38:27 +0800831static void
832vhost_scsi_send_bad_target(struct vhost_scsi *vs,
833 struct vhost_virtqueue *vq,
834 int head, unsigned out)
Asias He637ab212013-04-10 15:06:15 +0800835{
836 struct virtio_scsi_cmd_resp __user *resp;
837 struct virtio_scsi_cmd_resp rsp;
838 int ret;
839
840 memset(&rsp, 0, sizeof(rsp));
841 rsp.response = VIRTIO_SCSI_S_BAD_TARGET;
842 resp = vq->iov[out].iov_base;
843 ret = __copy_to_user(resp, &rsp, sizeof(rsp));
844 if (!ret)
845 vhost_add_used_and_signal(&vs->dev, vq, head, 0);
846 else
847 pr_err("Faulted on virtio_scsi_cmd_resp\n");
848}
849
Asias He683bd962013-05-06 16:38:27 +0800850static void
851vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700852{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800853 struct vhost_scsi_tpg **vs_tpg, *tpg;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700854 struct virtio_scsi_cmd_req v_req;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800855 struct virtio_scsi_cmd_req_pi v_req_pi;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -0800856 struct vhost_scsi_cmd *cmd;
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800857 struct iov_iter out_iter, in_iter, prot_iter, data_iter;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800858 u64 tag;
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800859 u32 exp_data_len, data_direction;
860 unsigned out, in;
861 int head, ret, prot_bytes;
862 size_t req_size, rsp_size = sizeof(struct virtio_scsi_cmd_resp);
863 size_t out_size, in_size;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800864 u16 lun;
865 u8 *target, *lunp, task_attr;
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800866 bool t10_pi = vhost_has_feature(vq, VIRTIO_SCSI_F_T10_PI);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800867 void *req, *cdb;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700868
Asias Hee7802212013-05-07 14:54:35 +0800869 mutex_lock(&vq->mutex);
Asias He4f7f46d2013-04-03 14:17:37 +0800870 /*
871 * We can handle the vq only after the endpoint is setup by calling the
872 * VHOST_SCSI_SET_ENDPOINT ioctl.
Asias He4f7f46d2013-04-03 14:17:37 +0800873 */
Asias Hee7802212013-05-07 14:54:35 +0800874 vs_tpg = vq->private_data;
Asias He4f7f46d2013-04-03 14:17:37 +0800875 if (!vs_tpg)
Asias Hee7802212013-05-07 14:54:35 +0800876 goto out;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700877
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700878 vhost_disable_notify(&vs->dev, vq);
879
880 for (;;) {
Michael S. Tsirkin47283be2014-06-05 15:20:27 +0300881 head = vhost_get_vq_desc(vq, vq->iov,
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800882 ARRAY_SIZE(vq->iov), &out, &in,
883 NULL, NULL);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700884 pr_debug("vhost_get_vq_desc: head: %d, out: %u in: %u\n",
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800885 head, out, in);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700886 /* On error, stop handling until the next kick. */
887 if (unlikely(head < 0))
888 break;
889 /* Nothing new? Wait for eventfd to tell us they refilled. */
890 if (head == vq->num) {
891 if (unlikely(vhost_enable_notify(&vs->dev, vq))) {
892 vhost_disable_notify(&vs->dev, vq);
893 continue;
894 }
895 break;
896 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700897 /*
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800898 * Check for a sane response buffer so we can report early
899 * errors back to the guest.
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700900 */
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800901 if (unlikely(vq->iov[out].iov_len < rsp_size)) {
902 vq_err(vq, "Expecting at least virtio_scsi_cmd_resp"
903 " size, got %zu bytes\n", vq->iov[out].iov_len);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700904 break;
905 }
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800906 /*
907 * Setup pointers and values based upon different virtio-scsi
908 * request header if T10_PI is enabled in KVM guest.
909 */
910 if (t10_pi) {
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800911 req = &v_req_pi;
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800912 req_size = sizeof(v_req_pi);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800913 lunp = &v_req_pi.lun[0];
914 target = &v_req_pi.lun[1];
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800915 } else {
916 req = &v_req;
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800917 req_size = sizeof(v_req);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800918 lunp = &v_req.lun[0];
919 target = &v_req.lun[1];
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800920 }
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800921 /*
922 * FIXME: Not correct for BIDI operation
923 */
924 out_size = iov_length(vq->iov, out);
925 in_size = iov_length(&vq->iov[out], in);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800926
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800927 /*
928 * Copy over the virtio-scsi request header, which for a
929 * ANY_LAYOUT enabled guest may span multiple iovecs, or a
930 * single iovec may contain both the header + outgoing
931 * WRITE payloads.
932 *
933 * copy_from_iter() will advance out_iter, so that it will
934 * point at the start of the outgoing WRITE payload, if
935 * DMA_TO_DEVICE is set.
936 */
937 iov_iter_init(&out_iter, WRITE, vq->iov, out, out_size);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700938
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800939 ret = copy_from_iter(req, req_size, &out_iter);
940 if (unlikely(ret != req_size)) {
941 vq_err(vq, "Faulted on copy_from_iter\n");
Nicholas Bellingerde1419e2015-01-29 17:21:13 -0800942 vhost_scsi_send_bad_target(vs, vq, head, out);
943 continue;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -0700944 }
Venkatesh Srinivas7fe412d2014-02-24 14:13:32 -0800945 /* virtio-scsi spec requires byte 0 of the lun to be 1 */
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800946 if (unlikely(*lunp != 1)) {
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800947 vq_err(vq, "Illegal virtio-scsi lun: %u\n", *lunp);
Venkatesh Srinivas7fe412d2014-02-24 14:13:32 -0800948 vhost_scsi_send_bad_target(vs, vq, head, out);
949 continue;
950 }
951
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800952 tpg = ACCESS_ONCE(vs_tpg[*target]);
Asias He98718312013-05-06 16:38:28 +0800953 if (unlikely(!tpg)) {
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800954 /* Target does not exist, fail the request */
Asias He637ab212013-04-10 15:06:15 +0800955 vhost_scsi_send_bad_target(vs, vq, head, out);
Asias He67e18cf2013-02-05 12:31:57 +0800956 continue;
957 }
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800958 /*
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800959 * Determine data_direction by calculating the total outgoing
960 * iovec sizes + incoming iovec sizes vs. virtio-scsi request +
961 * response headers respectively.
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800962 *
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800963 * For DMA_TO_DEVICE this is out_iter, which is already pointing
964 * to the right place.
965 *
966 * For DMA_FROM_DEVICE, the iovec will be just past the end
967 * of the virtio-scsi response header in either the same
968 * or immediately following iovec.
969 *
970 * Any associated T10_PI bytes for the outgoing / incoming
971 * payloads are included in calculation of exp_data_len here.
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800972 */
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800973 prot_bytes = 0;
974
975 if (out_size > req_size) {
976 data_direction = DMA_TO_DEVICE;
977 exp_data_len = out_size - req_size;
978 data_iter = out_iter;
979 } else if (in_size > rsp_size) {
980 data_direction = DMA_FROM_DEVICE;
981 exp_data_len = in_size - rsp_size;
982
983 iov_iter_init(&in_iter, READ, &vq->iov[out], in,
984 rsp_size + exp_data_len);
985 iov_iter_advance(&in_iter, rsp_size);
986 data_iter = in_iter;
987 } else {
988 data_direction = DMA_NONE;
989 exp_data_len = 0;
990 }
991 /*
992 * If T10_PI header + payload is present, setup prot_iter values
993 * and recalculate data_iter for vhost_scsi_mapal() mapping to
994 * host scatterlists via get_user_pages_fast().
995 */
996 if (t10_pi) {
Nicholas Bellinger95e7c432014-02-22 18:22:31 -0800997 if (v_req_pi.pi_bytesout) {
998 if (data_direction != DMA_TO_DEVICE) {
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -0800999 vq_err(vq, "Received non zero pi_bytesout,"
1000 " but wrong data_direction\n");
Nicholas Bellingerde1419e2015-01-29 17:21:13 -08001001 vhost_scsi_send_bad_target(vs, vq, head, out);
1002 continue;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001003 }
Michael S. Tsirkine72fd722014-11-23 18:01:34 +02001004 prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesout);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001005 } else if (v_req_pi.pi_bytesin) {
1006 if (data_direction != DMA_FROM_DEVICE) {
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001007 vq_err(vq, "Received non zero pi_bytesin,"
1008 " but wrong data_direction\n");
Nicholas Bellingerde1419e2015-01-29 17:21:13 -08001009 vhost_scsi_send_bad_target(vs, vq, head, out);
1010 continue;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001011 }
Michael S. Tsirkine72fd722014-11-23 18:01:34 +02001012 prot_bytes = vhost32_to_cpu(vq, v_req_pi.pi_bytesin);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001013 }
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001014 /*
1015 * Set prot_iter to data_iter, and advance past any
1016 * preceeding prot_bytes that may be present.
1017 *
1018 * Also fix up the exp_data_len to reflect only the
1019 * actual data payload length.
1020 */
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001021 if (prot_bytes) {
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001022 exp_data_len -= prot_bytes;
1023 prot_iter = data_iter;
1024 iov_iter_advance(&data_iter, prot_bytes);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001025 }
Michael S. Tsirkine72fd722014-11-23 18:01:34 +02001026 tag = vhost64_to_cpu(vq, v_req_pi.tag);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001027 task_attr = v_req_pi.task_attr;
1028 cdb = &v_req_pi.cdb[0];
1029 lun = ((v_req_pi.lun[2] << 8) | v_req_pi.lun[3]) & 0x3FFF;
1030 } else {
Michael S. Tsirkine72fd722014-11-23 18:01:34 +02001031 tag = vhost64_to_cpu(vq, v_req.tag);
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001032 task_attr = v_req.task_attr;
1033 cdb = &v_req.cdb[0];
1034 lun = ((v_req.lun[2] << 8) | v_req.lun[3]) & 0x3FFF;
1035 }
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001036 /*
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001037 * Check that the received CDB size does not exceeded our
1038 * hardcoded max for vhost-scsi, then get a pre-allocated
1039 * cmd descriptor for the new virtio-scsi tag.
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001040 *
1041 * TODO what if cdb was too small for varlen cdb header?
1042 */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001043 if (unlikely(scsi_command_size(cdb) > VHOST_SCSI_MAX_CDB_SIZE)) {
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001044 vq_err(vq, "Received SCSI CDB with command_size: %d that"
1045 " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001046 scsi_command_size(cdb), VHOST_SCSI_MAX_CDB_SIZE);
Nicholas Bellingerde1419e2015-01-29 17:21:13 -08001047 vhost_scsi_send_bad_target(vs, vq, head, out);
1048 continue;
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001049 }
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001050 cmd = vhost_scsi_get_tag(vq, tpg, cdb, tag, lun, task_attr,
Nicholas Bellinger9f977ef2014-06-10 01:19:38 -07001051 exp_data_len + prot_bytes,
1052 data_direction);
Asias He3c63f662013-05-06 16:38:29 +08001053 if (IS_ERR(cmd)) {
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -07001054 vq_err(vq, "vhost_scsi_get_tag failed %ld\n",
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001055 PTR_ERR(cmd));
Nicholas Bellingerde1419e2015-01-29 17:21:13 -08001056 vhost_scsi_send_bad_target(vs, vq, head, out);
1057 continue;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001058 }
Asias He3c63f662013-05-06 16:38:29 +08001059 cmd->tvc_vhost = vs;
1060 cmd->tvc_vq = vq;
Nicholas Bellinger79c14142015-01-27 13:13:12 -08001061 cmd->tvc_resp_iov = &vq->iov[out];
1062 cmd->tvc_in_iovs = in;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001063
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001064 pr_debug("vhost_scsi got command opcode: %#02x, lun: %d\n",
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001065 cmd->tvc_cdb[0], cmd->tvc_lun);
1066 pr_debug("cmd: %p exp_data_len: %d, prot_bytes: %d data_direction:"
1067 " %d\n", cmd, exp_data_len, prot_bytes, data_direction);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001068
1069 if (data_direction != DMA_NONE) {
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001070 ret = vhost_scsi_mapal(cmd,
1071 prot_bytes, &prot_iter,
1072 exp_data_len, &data_iter);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001073 if (unlikely(ret)) {
1074 vq_err(vq, "Failed to map iov to sgl\n");
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001075 vhost_scsi_release_cmd(&cmd->tvc_se_cmd);
Nicholas Bellingerde1419e2015-01-29 17:21:13 -08001076 vhost_scsi_send_bad_target(vs, vq, head, out);
1077 continue;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001078 }
1079 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001080 /*
1081 * Save the descriptor from vhost_get_vq_desc() to be used to
1082 * complete the virtio-scsi request in TCM callback context via
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001083 * vhost_scsi_queue_data_in() and vhost_scsi_queue_status()
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001084 */
Asias He3c63f662013-05-06 16:38:29 +08001085 cmd->tvc_vq_desc = head;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001086 /*
Nicholas Bellinger09b13fa2015-01-25 21:14:58 -08001087 * Dispatch cmd descriptor for cmwq execution in process
1088 * context provided by vhost_scsi_workqueue. This also ensures
1089 * cmd is executed on the same kworker CPU as this vhost
1090 * thread to gain positive L2 cache locality effects.
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001091 */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001092 INIT_WORK(&cmd->work, vhost_scsi_submission_work);
1093 queue_work(vhost_scsi_workqueue, &cmd->work);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001094 }
Asias Hee7802212013-05-07 14:54:35 +08001095out:
Asias He7ea206c2013-04-10 15:06:14 +08001096 mutex_unlock(&vq->mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001097}
1098
1099static void vhost_scsi_ctl_handle_kick(struct vhost_work *work)
1100{
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001101 pr_debug("%s: The handling func for control queue.\n", __func__);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001102}
1103
Asias He683bd962013-05-06 16:38:27 +08001104static void
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001105vhost_scsi_send_evt(struct vhost_scsi *vs,
1106 struct vhost_scsi_tpg *tpg,
Asias He683bd962013-05-06 16:38:27 +08001107 struct se_lun *lun,
1108 u32 event,
1109 u32 reason)
Asias Hea6c9af82013-04-25 15:35:21 +08001110{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001111 struct vhost_scsi_evt *evt;
Asias Hea6c9af82013-04-25 15:35:21 +08001112
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001113 evt = vhost_scsi_allocate_evt(vs, event, reason);
Asias Hea6c9af82013-04-25 15:35:21 +08001114 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;
Dan Carpenter59c816c2015-02-05 10:37:33 +03001124 evt->event.lun[1] = tpg->tport_tpgt;
Asias Hea6c9af82013-04-25 15:35:21 +08001125 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
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001134static void vhost_scsi_evt_handle_kick(struct vhost_work *work)
1135{
Asias Hea6c9af82013-04-25 15:35:21 +08001136 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)
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001145 vhost_scsi_send_evt(vs, NULL, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
Asias Hea6c9af82013-04-25 15:35:21 +08001146out:
1147 mutex_unlock(&vq->mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001148}
1149
1150static 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
Asias He1b7f3902013-02-06 13:20:59 +08001156 vhost_scsi_handle_vq(vs, vq);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001157}
1158
Asias He4f7f46d2013-04-03 14:17:37 +08001159static void vhost_scsi_flush_vq(struct vhost_scsi *vs, int index)
1160{
Asias He3ab2e422013-04-27 11:16:48 +08001161 vhost_poll_flush(&vs->vqs[index].vq.poll);
Asias He4f7f46d2013-04-03 14:17:37 +08001162}
1163
Michael S. Tsirkin3dfbff32013-04-28 15:38:52 +03001164/* Callers must hold dev mutex */
Asias He4f7f46d2013-04-03 14:17:37 +08001165static void vhost_scsi_flush(struct vhost_scsi *vs)
1166{
Asias Hef2f0173d2013-04-27 11:16:49 +08001167 struct vhost_scsi_inflight *old_inflight[VHOST_SCSI_MAX_VQ];
Asias He4f7f46d2013-04-03 14:17:37 +08001168 int i;
1169
Asias Hef2f0173d2013-04-27 11:16:49 +08001170 /* Init new inflight and remember the old inflight */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001171 vhost_scsi_init_inflight(vs, old_inflight);
Asias Hef2f0173d2013-04-27 11:16:49 +08001172
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++)
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001179 kref_put(&old_inflight[i]->kref, vhost_scsi_done_inflight);
Asias Hef2f0173d2013-04-27 11:16:49 +08001180
1181 /* Flush both the vhost poll and vhost work */
Asias He4f7f46d2013-04-03 14:17:37 +08001182 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);
Asias Hea6c9af82013-04-25 15:35:21 +08001185 vhost_work_flush(&vs->dev, &vs->vs_event_work);
Asias Hef2f0173d2013-04-27 11:16:49 +08001186
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);
Asias He4f7f46d2013-04-03 14:17:37 +08001190}
1191
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001192/*
1193 * Called from vhost_scsi_ioctl() context to walk the list of available
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001194 * vhost_scsi_tpg with an active struct vhost_scsi_nexus
Asias Hef2b7daf2013-04-25 15:35:20 +08001195 *
1196 * The lock nesting rule is:
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001197 * vhost_scsi_mutex -> vs->dev.mutex -> tpg->tv_tpg_mutex -> vq->mutex
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001198 */
Asias He683bd962013-05-06 16:38:27 +08001199static int
1200vhost_scsi_set_endpoint(struct vhost_scsi *vs,
1201 struct vhost_scsi_target *t)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001202{
Nicholas Bellingerab8edab2014-10-08 06:19:20 +00001203 struct se_portal_group *se_tpg;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001204 struct vhost_scsi_tport *tv_tport;
1205 struct vhost_scsi_tpg *tpg;
1206 struct vhost_scsi_tpg **vs_tpg;
Asias He4f7f46d2013-04-03 14:17:37 +08001207 struct vhost_virtqueue *vq;
1208 int index, ret, i, len;
Asias He67e18cf2013-02-05 12:31:57 +08001209 bool match = false;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001210
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001211 mutex_lock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001212 mutex_lock(&vs->dev.mutex);
Asias Hef2b7daf2013-04-25 15:35:20 +08001213
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001214 /* Verify that ring has been setup correctly. */
1215 for (index = 0; index < vs->dev.nvqs; ++index) {
1216 /* Verify that ring has been setup correctly. */
Asias He3ab2e422013-04-27 11:16:48 +08001217 if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
Asias Hef2b7daf2013-04-25 15:35:20 +08001218 ret = -EFAULT;
1219 goto out;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001220 }
1221 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001222
Asias He4f7f46d2013-04-03 14:17:37 +08001223 len = sizeof(vs_tpg[0]) * VHOST_SCSI_MAX_TARGET;
1224 vs_tpg = kzalloc(len, GFP_KERNEL);
1225 if (!vs_tpg) {
Asias Hef2b7daf2013-04-25 15:35:20 +08001226 ret = -ENOMEM;
1227 goto out;
Asias He4f7f46d2013-04-03 14:17:37 +08001228 }
1229 if (vs->vs_tpg)
1230 memcpy(vs_tpg, vs->vs_tpg, len);
1231
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001232 list_for_each_entry(tpg, &vhost_scsi_list, tv_tpg_list) {
Asias He98718312013-05-06 16:38:28 +08001233 mutex_lock(&tpg->tv_tpg_mutex);
1234 if (!tpg->tpg_nexus) {
1235 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001236 continue;
1237 }
Asias He98718312013-05-06 16:38:28 +08001238 if (tpg->tv_tpg_vhost_count != 0) {
1239 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001240 continue;
1241 }
Asias He98718312013-05-06 16:38:28 +08001242 tv_tport = tpg->tport;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001243
Asias He67e18cf2013-02-05 12:31:57 +08001244 if (!strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
Asias He98718312013-05-06 16:38:28 +08001245 if (vs->vs_tpg && vs->vs_tpg[tpg->tport_tpgt]) {
Asias He4f7f46d2013-04-03 14:17:37 +08001246 kfree(vs_tpg);
Asias He98718312013-05-06 16:38:28 +08001247 mutex_unlock(&tpg->tv_tpg_mutex);
Asias Hef2b7daf2013-04-25 15:35:20 +08001248 ret = -EEXIST;
1249 goto out;
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001250 }
Nicholas Bellingerab8edab2014-10-08 06:19:20 +00001251 /*
1252 * In order to ensure individual vhost-scsi configfs
1253 * groups cannot be removed while in use by vhost ioctl,
1254 * go ahead and take an explicit se_tpg->tpg_group.cg_item
1255 * dependency now.
1256 */
1257 se_tpg = &tpg->se_tpg;
Christoph Hellwigd588cf82015-05-03 08:50:52 +02001258 ret = target_depend_item(&se_tpg->tpg_group.cg_item);
Nicholas Bellingerab8edab2014-10-08 06:19:20 +00001259 if (ret) {
1260 pr_warn("configfs_depend_item() failed: %d\n", ret);
1261 kfree(vs_tpg);
1262 mutex_unlock(&tpg->tv_tpg_mutex);
1263 goto out;
1264 }
Asias He98718312013-05-06 16:38:28 +08001265 tpg->tv_tpg_vhost_count++;
1266 tpg->vhost_scsi = vs;
1267 vs_tpg[tpg->tport_tpgt] = tpg;
Peter Zijlstra4e857c52014-03-17 18:06:10 +01001268 smp_mb__after_atomic();
Asias He67e18cf2013-02-05 12:31:57 +08001269 match = true;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001270 }
Asias He98718312013-05-06 16:38:28 +08001271 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001272 }
Asias He67e18cf2013-02-05 12:31:57 +08001273
1274 if (match) {
1275 memcpy(vs->vs_vhost_wwpn, t->vhost_wwpn,
1276 sizeof(vs->vs_vhost_wwpn));
Asias He4f7f46d2013-04-03 14:17:37 +08001277 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
Asias He3ab2e422013-04-27 11:16:48 +08001278 vq = &vs->vqs[i].vq;
Asias He4f7f46d2013-04-03 14:17:37 +08001279 mutex_lock(&vq->mutex);
Asias He22fa90c2013-05-07 14:54:36 +08001280 vq->private_data = vs_tpg;
Asias Hedfd5d562013-04-03 14:17:38 +08001281 vhost_init_used(vq);
Asias He4f7f46d2013-04-03 14:17:37 +08001282 mutex_unlock(&vq->mutex);
1283 }
Asias He67e18cf2013-02-05 12:31:57 +08001284 ret = 0;
1285 } else {
1286 ret = -EEXIST;
1287 }
1288
Asias He4f7f46d2013-04-03 14:17:37 +08001289 /*
1290 * Act as synchronize_rcu to make sure access to
1291 * old vs->vs_tpg is finished.
1292 */
1293 vhost_scsi_flush(vs);
1294 kfree(vs->vs_tpg);
1295 vs->vs_tpg = vs_tpg;
1296
Asias Hef2b7daf2013-04-25 15:35:20 +08001297out:
Asias He67e18cf2013-02-05 12:31:57 +08001298 mutex_unlock(&vs->dev.mutex);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001299 mutex_unlock(&vhost_scsi_mutex);
Asias He67e18cf2013-02-05 12:31:57 +08001300 return ret;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001301}
1302
Asias He683bd962013-05-06 16:38:27 +08001303static int
1304vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
1305 struct vhost_scsi_target *t)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001306{
Nicholas Bellingerab8edab2014-10-08 06:19:20 +00001307 struct se_portal_group *se_tpg;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001308 struct vhost_scsi_tport *tv_tport;
1309 struct vhost_scsi_tpg *tpg;
Asias He4f7f46d2013-04-03 14:17:37 +08001310 struct vhost_virtqueue *vq;
1311 bool match = false;
Asias He67e18cf2013-02-05 12:31:57 +08001312 int index, ret, i;
1313 u8 target;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001314
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001315 mutex_lock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001316 mutex_lock(&vs->dev.mutex);
1317 /* Verify that ring has been setup correctly. */
1318 for (index = 0; index < vs->dev.nvqs; ++index) {
Asias He3ab2e422013-04-27 11:16:48 +08001319 if (!vhost_vq_access_ok(&vs->vqs[index].vq)) {
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001320 ret = -EFAULT;
Asias He038e0af2013-03-15 09:14:05 +08001321 goto err_dev;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001322 }
1323 }
Asias He4f7f46d2013-04-03 14:17:37 +08001324
1325 if (!vs->vs_tpg) {
Asias Hef2b7daf2013-04-25 15:35:20 +08001326 ret = 0;
1327 goto err_dev;
Asias He4f7f46d2013-04-03 14:17:37 +08001328 }
1329
Asias He67e18cf2013-02-05 12:31:57 +08001330 for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
1331 target = i;
Asias He98718312013-05-06 16:38:28 +08001332 tpg = vs->vs_tpg[target];
1333 if (!tpg)
Asias He67e18cf2013-02-05 12:31:57 +08001334 continue;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001335
Asias He98718312013-05-06 16:38:28 +08001336 mutex_lock(&tpg->tv_tpg_mutex);
1337 tv_tport = tpg->tport;
Asias He67e18cf2013-02-05 12:31:57 +08001338 if (!tv_tport) {
1339 ret = -ENODEV;
Asias He038e0af2013-03-15 09:14:05 +08001340 goto err_tpg;
Asias He67e18cf2013-02-05 12:31:57 +08001341 }
1342
1343 if (strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
Asias He98718312013-05-06 16:38:28 +08001344 pr_warn("tv_tport->tport_name: %s, tpg->tport_tpgt: %hu"
Asias He67e18cf2013-02-05 12:31:57 +08001345 " does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
Asias He98718312013-05-06 16:38:28 +08001346 tv_tport->tport_name, tpg->tport_tpgt,
Asias He67e18cf2013-02-05 12:31:57 +08001347 t->vhost_wwpn, t->vhost_tpgt);
1348 ret = -EINVAL;
Asias He038e0af2013-03-15 09:14:05 +08001349 goto err_tpg;
Asias He67e18cf2013-02-05 12:31:57 +08001350 }
Asias He98718312013-05-06 16:38:28 +08001351 tpg->tv_tpg_vhost_count--;
1352 tpg->vhost_scsi = NULL;
Asias He67e18cf2013-02-05 12:31:57 +08001353 vs->vs_tpg[target] = NULL;
Asias He4f7f46d2013-04-03 14:17:37 +08001354 match = true;
Asias He98718312013-05-06 16:38:28 +08001355 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellingerab8edab2014-10-08 06:19:20 +00001356 /*
1357 * Release se_tpg->tpg_group.cg_item configfs dependency now
1358 * to allow vhost-scsi WWPN se_tpg->tpg_group shutdown to occur.
1359 */
1360 se_tpg = &tpg->se_tpg;
Christoph Hellwigd588cf82015-05-03 08:50:52 +02001361 target_undepend_item(&se_tpg->tpg_group.cg_item);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001362 }
Asias He4f7f46d2013-04-03 14:17:37 +08001363 if (match) {
1364 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
Asias He3ab2e422013-04-27 11:16:48 +08001365 vq = &vs->vqs[i].vq;
Asias He4f7f46d2013-04-03 14:17:37 +08001366 mutex_lock(&vq->mutex);
Asias He22fa90c2013-05-07 14:54:36 +08001367 vq->private_data = NULL;
Asias He4f7f46d2013-04-03 14:17:37 +08001368 mutex_unlock(&vq->mutex);
1369 }
1370 }
1371 /*
1372 * Act as synchronize_rcu to make sure access to
1373 * old vs->vs_tpg is finished.
1374 */
1375 vhost_scsi_flush(vs);
1376 kfree(vs->vs_tpg);
1377 vs->vs_tpg = NULL;
Asias Hea6c9af82013-04-25 15:35:21 +08001378 WARN_ON(vs->vs_events_nr);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001379 mutex_unlock(&vs->dev.mutex);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001380 mutex_unlock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001381 return 0;
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001382
Asias He038e0af2013-03-15 09:14:05 +08001383err_tpg:
Asias He98718312013-05-06 16:38:28 +08001384 mutex_unlock(&tpg->tv_tpg_mutex);
Asias He038e0af2013-03-15 09:14:05 +08001385err_dev:
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001386 mutex_unlock(&vs->dev.mutex);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001387 mutex_unlock(&vhost_scsi_mutex);
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001388 return ret;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001389}
1390
Asias He4f7f46d2013-04-03 14:17:37 +08001391static int vhost_scsi_set_features(struct vhost_scsi *vs, u64 features)
1392{
Michael S. Tsirkinea16c512014-06-05 15:20:23 +03001393 struct vhost_virtqueue *vq;
1394 int i;
1395
Asias He4f7f46d2013-04-03 14:17:37 +08001396 if (features & ~VHOST_SCSI_FEATURES)
1397 return -EOPNOTSUPP;
1398
1399 mutex_lock(&vs->dev.mutex);
1400 if ((features & (1 << VHOST_F_LOG_ALL)) &&
1401 !vhost_log_access_ok(&vs->dev)) {
1402 mutex_unlock(&vs->dev.mutex);
1403 return -EFAULT;
1404 }
Michael S. Tsirkinea16c512014-06-05 15:20:23 +03001405
1406 for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {
1407 vq = &vs->vqs[i].vq;
1408 mutex_lock(&vq->mutex);
1409 vq->acked_features = features;
1410 mutex_unlock(&vq->mutex);
1411 }
Asias He4f7f46d2013-04-03 14:17:37 +08001412 mutex_unlock(&vs->dev.mutex);
1413 return 0;
1414}
1415
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001416static int vhost_scsi_open(struct inode *inode, struct file *f)
1417{
Asias Hec7289312013-05-06 16:38:26 +08001418 struct vhost_scsi *vs;
Asias He3ab2e422013-04-27 11:16:48 +08001419 struct vhost_virtqueue **vqs;
Michael S. Tsirkin595cb752013-09-17 09:30:34 +03001420 int r = -ENOMEM, i;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001421
Michael S. Tsirkin595cb752013-09-17 09:30:34 +03001422 vs = kzalloc(sizeof(*vs), GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
1423 if (!vs) {
1424 vs = vzalloc(sizeof(*vs));
1425 if (!vs)
1426 goto err_vs;
1427 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001428
Asias He3ab2e422013-04-27 11:16:48 +08001429 vqs = kmalloc(VHOST_SCSI_MAX_VQ * sizeof(*vqs), GFP_KERNEL);
Michael S. Tsirkin595cb752013-09-17 09:30:34 +03001430 if (!vqs)
1431 goto err_vqs;
Asias He3ab2e422013-04-27 11:16:48 +08001432
Asias Hec7289312013-05-06 16:38:26 +08001433 vhost_work_init(&vs->vs_completion_work, vhost_scsi_complete_cmd_work);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001434 vhost_work_init(&vs->vs_event_work, vhost_scsi_evt_work);
Asias Hea6c9af82013-04-25 15:35:21 +08001435
Asias Hec7289312013-05-06 16:38:26 +08001436 vs->vs_events_nr = 0;
1437 vs->vs_events_missed = false;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001438
Asias Hec7289312013-05-06 16:38:26 +08001439 vqs[VHOST_SCSI_VQ_CTL] = &vs->vqs[VHOST_SCSI_VQ_CTL].vq;
1440 vqs[VHOST_SCSI_VQ_EVT] = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
1441 vs->vqs[VHOST_SCSI_VQ_CTL].vq.handle_kick = vhost_scsi_ctl_handle_kick;
1442 vs->vqs[VHOST_SCSI_VQ_EVT].vq.handle_kick = vhost_scsi_evt_handle_kick;
Asias He3ab2e422013-04-27 11:16:48 +08001443 for (i = VHOST_SCSI_VQ_IO; i < VHOST_SCSI_MAX_VQ; i++) {
Asias Hec7289312013-05-06 16:38:26 +08001444 vqs[i] = &vs->vqs[i].vq;
1445 vs->vqs[i].vq.handle_kick = vhost_scsi_handle_kick;
Asias He3ab2e422013-04-27 11:16:48 +08001446 }
Zhi Yong Wu59566b6e2013-12-07 04:13:03 +08001447 vhost_dev_init(&vs->dev, vqs, VHOST_SCSI_MAX_VQ);
Asias Hef2f0173d2013-04-27 11:16:49 +08001448
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001449 vhost_scsi_init_inflight(vs, NULL);
Asias Hef2f0173d2013-04-27 11:16:49 +08001450
Asias Hec7289312013-05-06 16:38:26 +08001451 f->private_data = vs;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001452 return 0;
Michael S. Tsirkin595cb752013-09-17 09:30:34 +03001453
Michael S. Tsirkin595cb752013-09-17 09:30:34 +03001454err_vqs:
Michael S. Tsirkin684044412014-06-12 19:00:01 +03001455 kvfree(vs);
Michael S. Tsirkin595cb752013-09-17 09:30:34 +03001456err_vs:
1457 return r;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001458}
1459
1460static int vhost_scsi_release(struct inode *inode, struct file *f)
1461{
Asias Hec7289312013-05-06 16:38:26 +08001462 struct vhost_scsi *vs = f->private_data;
Asias He67e18cf2013-02-05 12:31:57 +08001463 struct vhost_scsi_target t;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001464
Asias Hec7289312013-05-06 16:38:26 +08001465 mutex_lock(&vs->dev.mutex);
1466 memcpy(t.vhost_wwpn, vs->vs_vhost_wwpn, sizeof(t.vhost_wwpn));
1467 mutex_unlock(&vs->dev.mutex);
1468 vhost_scsi_clear_endpoint(vs, &t);
1469 vhost_dev_stop(&vs->dev);
1470 vhost_dev_cleanup(&vs->dev, false);
Asias Hea6c9af82013-04-25 15:35:21 +08001471 /* Jobs can re-queue themselves in evt kick handler. Do extra flush. */
Asias Hec7289312013-05-06 16:38:26 +08001472 vhost_scsi_flush(vs);
1473 kfree(vs->dev.vqs);
Michael S. Tsirkin684044412014-06-12 19:00:01 +03001474 kvfree(vs);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001475 return 0;
1476}
1477
Asias He683bd962013-05-06 16:38:27 +08001478static long
1479vhost_scsi_ioctl(struct file *f,
1480 unsigned int ioctl,
1481 unsigned long arg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001482{
1483 struct vhost_scsi *vs = f->private_data;
1484 struct vhost_scsi_target backend;
1485 void __user *argp = (void __user *)arg;
1486 u64 __user *featurep = argp;
Asias He11c634182013-04-25 15:35:22 +08001487 u32 __user *eventsp = argp;
1488 u32 events_missed;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001489 u64 features;
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001490 int r, abi_version = VHOST_SCSI_ABI_VERSION;
Asias He3ab2e422013-04-27 11:16:48 +08001491 struct vhost_virtqueue *vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001492
1493 switch (ioctl) {
1494 case VHOST_SCSI_SET_ENDPOINT:
1495 if (copy_from_user(&backend, argp, sizeof backend))
1496 return -EFAULT;
Michael S. Tsirkin6de71452012-08-18 15:44:09 -07001497 if (backend.reserved != 0)
1498 return -EOPNOTSUPP;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001499
1500 return vhost_scsi_set_endpoint(vs, &backend);
1501 case VHOST_SCSI_CLEAR_ENDPOINT:
1502 if (copy_from_user(&backend, argp, sizeof backend))
1503 return -EFAULT;
Michael S. Tsirkin6de71452012-08-18 15:44:09 -07001504 if (backend.reserved != 0)
1505 return -EOPNOTSUPP;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001506
1507 return vhost_scsi_clear_endpoint(vs, &backend);
1508 case VHOST_SCSI_GET_ABI_VERSION:
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001509 if (copy_to_user(argp, &abi_version, sizeof abi_version))
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001510 return -EFAULT;
1511 return 0;
Asias He11c634182013-04-25 15:35:22 +08001512 case VHOST_SCSI_SET_EVENTS_MISSED:
1513 if (get_user(events_missed, eventsp))
1514 return -EFAULT;
1515 mutex_lock(&vq->mutex);
1516 vs->vs_events_missed = events_missed;
1517 mutex_unlock(&vq->mutex);
1518 return 0;
1519 case VHOST_SCSI_GET_EVENTS_MISSED:
1520 mutex_lock(&vq->mutex);
1521 events_missed = vs->vs_events_missed;
1522 mutex_unlock(&vq->mutex);
1523 if (put_user(events_missed, eventsp))
1524 return -EFAULT;
1525 return 0;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001526 case VHOST_GET_FEATURES:
Nicholas Bellinger5dade712013-03-27 17:23:41 -07001527 features = VHOST_SCSI_FEATURES;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001528 if (copy_to_user(featurep, &features, sizeof features))
1529 return -EFAULT;
1530 return 0;
1531 case VHOST_SET_FEATURES:
1532 if (copy_from_user(&features, featurep, sizeof features))
1533 return -EFAULT;
1534 return vhost_scsi_set_features(vs, features);
1535 default:
1536 mutex_lock(&vs->dev.mutex);
Michael S. Tsirkin935cdee2012-12-06 14:03:34 +02001537 r = vhost_dev_ioctl(&vs->dev, ioctl, argp);
1538 /* TODO: flush backend after dev ioctl. */
1539 if (r == -ENOIOCTLCMD)
1540 r = vhost_vring_ioctl(&vs->dev, ioctl, argp);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001541 mutex_unlock(&vs->dev.mutex);
1542 return r;
1543 }
1544}
1545
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001546#ifdef CONFIG_COMPAT
1547static long vhost_scsi_compat_ioctl(struct file *f, unsigned int ioctl,
1548 unsigned long arg)
1549{
1550 return vhost_scsi_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
1551}
1552#endif
1553
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001554static const struct file_operations vhost_scsi_fops = {
1555 .owner = THIS_MODULE,
1556 .release = vhost_scsi_release,
1557 .unlocked_ioctl = vhost_scsi_ioctl,
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001558#ifdef CONFIG_COMPAT
1559 .compat_ioctl = vhost_scsi_compat_ioctl,
1560#endif
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001561 .open = vhost_scsi_open,
1562 .llseek = noop_llseek,
1563};
1564
1565static struct miscdevice vhost_scsi_misc = {
1566 MISC_DYNAMIC_MINOR,
1567 "vhost-scsi",
1568 &vhost_scsi_fops,
1569};
1570
1571static int __init vhost_scsi_register(void)
1572{
1573 return misc_register(&vhost_scsi_misc);
1574}
1575
1576static int vhost_scsi_deregister(void)
1577{
1578 return misc_deregister(&vhost_scsi_misc);
1579}
1580
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001581static char *vhost_scsi_dump_proto_id(struct vhost_scsi_tport *tport)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001582{
1583 switch (tport->tport_proto_id) {
1584 case SCSI_PROTOCOL_SAS:
1585 return "SAS";
1586 case SCSI_PROTOCOL_FCP:
1587 return "FCP";
1588 case SCSI_PROTOCOL_ISCSI:
1589 return "iSCSI";
1590 default:
1591 break;
1592 }
1593
1594 return "Unknown";
1595}
1596
Asias He683bd962013-05-06 16:38:27 +08001597static void
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001598vhost_scsi_do_plug(struct vhost_scsi_tpg *tpg,
Asias He683bd962013-05-06 16:38:27 +08001599 struct se_lun *lun, bool plug)
Asias Hea6c9af82013-04-25 15:35:21 +08001600{
1601
1602 struct vhost_scsi *vs = tpg->vhost_scsi;
1603 struct vhost_virtqueue *vq;
1604 u32 reason;
1605
1606 if (!vs)
1607 return;
1608
1609 mutex_lock(&vs->dev.mutex);
Asias Hea6c9af82013-04-25 15:35:21 +08001610
1611 if (plug)
1612 reason = VIRTIO_SCSI_EVT_RESET_RESCAN;
1613 else
1614 reason = VIRTIO_SCSI_EVT_RESET_REMOVED;
1615
Asias He3ab2e422013-04-27 11:16:48 +08001616 vq = &vs->vqs[VHOST_SCSI_VQ_EVT].vq;
Asias Hea6c9af82013-04-25 15:35:21 +08001617 mutex_lock(&vq->mutex);
Michael S. Tsirkinea16c512014-06-05 15:20:23 +03001618 if (vhost_has_feature(vq, VIRTIO_SCSI_F_HOTPLUG))
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001619 vhost_scsi_send_evt(vs, tpg, lun,
Michael S. Tsirkinea16c512014-06-05 15:20:23 +03001620 VIRTIO_SCSI_T_TRANSPORT_RESET, reason);
Asias Hea6c9af82013-04-25 15:35:21 +08001621 mutex_unlock(&vq->mutex);
1622 mutex_unlock(&vs->dev.mutex);
1623}
1624
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001625static void vhost_scsi_hotplug(struct vhost_scsi_tpg *tpg, struct se_lun *lun)
Asias Hea6c9af82013-04-25 15:35:21 +08001626{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001627 vhost_scsi_do_plug(tpg, lun, true);
Asias Hea6c9af82013-04-25 15:35:21 +08001628}
1629
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001630static void vhost_scsi_hotunplug(struct vhost_scsi_tpg *tpg, struct se_lun *lun)
Asias Hea6c9af82013-04-25 15:35:21 +08001631{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001632 vhost_scsi_do_plug(tpg, lun, false);
Asias Hea6c9af82013-04-25 15:35:21 +08001633}
1634
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001635static int vhost_scsi_port_link(struct se_portal_group *se_tpg,
Asias He683bd962013-05-06 16:38:27 +08001636 struct se_lun *lun)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001637{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001638 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
1639 struct vhost_scsi_tpg, se_tpg);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001640
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001641 mutex_lock(&vhost_scsi_mutex);
Asias Hea6c9af82013-04-25 15:35:21 +08001642
Asias He98718312013-05-06 16:38:28 +08001643 mutex_lock(&tpg->tv_tpg_mutex);
1644 tpg->tv_tpg_port_count++;
1645 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001646
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001647 vhost_scsi_hotplug(tpg, lun);
Asias Hea6c9af82013-04-25 15:35:21 +08001648
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001649 mutex_unlock(&vhost_scsi_mutex);
Asias Hea6c9af82013-04-25 15:35:21 +08001650
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001651 return 0;
1652}
1653
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001654static void vhost_scsi_port_unlink(struct se_portal_group *se_tpg,
Asias He683bd962013-05-06 16:38:27 +08001655 struct se_lun *lun)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001656{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001657 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
1658 struct vhost_scsi_tpg, se_tpg);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001659
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001660 mutex_lock(&vhost_scsi_mutex);
Asias Hea6c9af82013-04-25 15:35:21 +08001661
Asias He98718312013-05-06 16:38:28 +08001662 mutex_lock(&tpg->tv_tpg_mutex);
1663 tpg->tv_tpg_port_count--;
1664 mutex_unlock(&tpg->tv_tpg_mutex);
Asias Hea6c9af82013-04-25 15:35:21 +08001665
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001666 vhost_scsi_hotunplug(tpg, lun);
Asias Hea6c9af82013-04-25 15:35:21 +08001667
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001668 mutex_unlock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001669}
1670
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001671static void vhost_scsi_free_cmd_map_res(struct vhost_scsi_nexus *nexus,
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001672 struct se_session *se_sess)
1673{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001674 struct vhost_scsi_cmd *tv_cmd;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001675 unsigned int i;
1676
1677 if (!se_sess->sess_cmd_map)
1678 return;
1679
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001680 for (i = 0; i < VHOST_SCSI_DEFAULT_TAGS; i++) {
1681 tv_cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[i];
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001682
1683 kfree(tv_cmd->tvc_sgl);
Nicholas Bellingerb1935f62014-02-22 18:08:24 -08001684 kfree(tv_cmd->tvc_prot_sgl);
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001685 kfree(tv_cmd->tvc_upages);
1686 }
1687}
1688
Nicholas Bellingerb1d75fe2015-03-28 00:03:51 -07001689static ssize_t vhost_scsi_tpg_attrib_store_fabric_prot_type(
1690 struct se_portal_group *se_tpg,
1691 const char *page,
1692 size_t count)
1693{
1694 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
1695 struct vhost_scsi_tpg, se_tpg);
1696 unsigned long val;
1697 int ret = kstrtoul(page, 0, &val);
1698
1699 if (ret) {
1700 pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret);
1701 return ret;
1702 }
1703 if (val != 0 && val != 1 && val != 3) {
1704 pr_err("Invalid vhost_scsi fabric_prot_type: %lu\n", val);
1705 return -EINVAL;
1706 }
1707 tpg->tv_fabric_prot_type = val;
1708
1709 return count;
1710}
1711
1712static ssize_t vhost_scsi_tpg_attrib_show_fabric_prot_type(
1713 struct se_portal_group *se_tpg,
1714 char *page)
1715{
1716 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
1717 struct vhost_scsi_tpg, se_tpg);
1718
1719 return sprintf(page, "%d\n", tpg->tv_fabric_prot_type);
1720}
1721TF_TPG_ATTRIB_ATTR(vhost_scsi, fabric_prot_type, S_IRUGO | S_IWUSR);
1722
1723static struct configfs_attribute *vhost_scsi_tpg_attrib_attrs[] = {
1724 &vhost_scsi_tpg_attrib_fabric_prot_type.attr,
1725 NULL,
1726};
1727
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001728static int vhost_scsi_make_nexus(struct vhost_scsi_tpg *tpg,
Asias He683bd962013-05-06 16:38:27 +08001729 const char *name)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001730{
1731 struct se_portal_group *se_tpg;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001732 struct se_session *se_sess;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001733 struct vhost_scsi_nexus *tv_nexus;
1734 struct vhost_scsi_cmd *tv_cmd;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001735 unsigned int i;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001736
Asias He98718312013-05-06 16:38:28 +08001737 mutex_lock(&tpg->tv_tpg_mutex);
1738 if (tpg->tpg_nexus) {
1739 mutex_unlock(&tpg->tv_tpg_mutex);
1740 pr_debug("tpg->tpg_nexus already exists\n");
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001741 return -EEXIST;
1742 }
Asias He98718312013-05-06 16:38:28 +08001743 se_tpg = &tpg->se_tpg;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001744
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001745 tv_nexus = kzalloc(sizeof(struct vhost_scsi_nexus), GFP_KERNEL);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001746 if (!tv_nexus) {
Asias He98718312013-05-06 16:38:28 +08001747 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001748 pr_err("Unable to allocate struct vhost_scsi_nexus\n");
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001749 return -ENOMEM;
1750 }
1751 /*
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -07001752 * Initialize the struct se_session pointer and setup tagpool
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001753 * for struct vhost_scsi_cmd descriptors
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001754 */
Nicholas Bellinger4824d3b2013-06-07 17:47:46 -07001755 tv_nexus->tvn_se_sess = transport_init_session_tags(
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001756 VHOST_SCSI_DEFAULT_TAGS,
1757 sizeof(struct vhost_scsi_cmd),
Nicholas Bellinger95e7c432014-02-22 18:22:31 -08001758 TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001759 if (IS_ERR(tv_nexus->tvn_se_sess)) {
Asias He98718312013-05-06 16:38:28 +08001760 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001761 kfree(tv_nexus);
1762 return -ENOMEM;
1763 }
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001764 se_sess = tv_nexus->tvn_se_sess;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001765 for (i = 0; i < VHOST_SCSI_DEFAULT_TAGS; i++) {
1766 tv_cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[i];
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001767
1768 tv_cmd->tvc_sgl = kzalloc(sizeof(struct scatterlist) *
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001769 VHOST_SCSI_PREALLOC_SGLS, GFP_KERNEL);
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001770 if (!tv_cmd->tvc_sgl) {
1771 mutex_unlock(&tpg->tv_tpg_mutex);
1772 pr_err("Unable to allocate tv_cmd->tvc_sgl\n");
1773 goto out;
1774 }
1775
1776 tv_cmd->tvc_upages = kzalloc(sizeof(struct page *) *
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001777 VHOST_SCSI_PREALLOC_UPAGES, GFP_KERNEL);
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001778 if (!tv_cmd->tvc_upages) {
1779 mutex_unlock(&tpg->tv_tpg_mutex);
1780 pr_err("Unable to allocate tv_cmd->tvc_upages\n");
1781 goto out;
1782 }
Nicholas Bellingerb1935f62014-02-22 18:08:24 -08001783
1784 tv_cmd->tvc_prot_sgl = kzalloc(sizeof(struct scatterlist) *
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001785 VHOST_SCSI_PREALLOC_PROT_SGLS, GFP_KERNEL);
Nicholas Bellingerb1935f62014-02-22 18:08:24 -08001786 if (!tv_cmd->tvc_prot_sgl) {
1787 mutex_unlock(&tpg->tv_tpg_mutex);
1788 pr_err("Unable to allocate tv_cmd->tvc_prot_sgl\n");
1789 goto out;
1790 }
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001791 }
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001792 /*
1793 * Since we are running in 'demo mode' this call with generate a
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001794 * struct se_node_acl for the vhost_scsi struct se_portal_group with
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001795 * the SCSI Initiator port name of the passed configfs group 'name'.
1796 */
1797 tv_nexus->tvn_se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
1798 se_tpg, (unsigned char *)name);
1799 if (!tv_nexus->tvn_se_sess->se_node_acl) {
Asias He98718312013-05-06 16:38:28 +08001800 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001801 pr_debug("core_tpg_check_initiator_node_acl() failed"
1802 " for %s\n", name);
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001803 goto out;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001804 }
1805 /*
Bart Van Assche2f450cc2015-02-12 11:48:49 +01001806 * Now register the TCM vhost virtual I_T Nexus as active.
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001807 */
Bart Van Assche2f450cc2015-02-12 11:48:49 +01001808 transport_register_session(se_tpg, tv_nexus->tvn_se_sess->se_node_acl,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001809 tv_nexus->tvn_se_sess, tv_nexus);
Asias He98718312013-05-06 16:38:28 +08001810 tpg->tpg_nexus = tv_nexus;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001811
Asias He98718312013-05-06 16:38:28 +08001812 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001813 return 0;
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001814
1815out:
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001816 vhost_scsi_free_cmd_map_res(tv_nexus, se_sess);
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001817 transport_free_session(se_sess);
1818 kfree(tv_nexus);
1819 return -ENOMEM;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001820}
1821
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001822static int vhost_scsi_drop_nexus(struct vhost_scsi_tpg *tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001823{
1824 struct se_session *se_sess;
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001825 struct vhost_scsi_nexus *tv_nexus;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001826
1827 mutex_lock(&tpg->tv_tpg_mutex);
1828 tv_nexus = tpg->tpg_nexus;
1829 if (!tv_nexus) {
1830 mutex_unlock(&tpg->tv_tpg_mutex);
1831 return -ENODEV;
1832 }
1833
1834 se_sess = tv_nexus->tvn_se_sess;
1835 if (!se_sess) {
1836 mutex_unlock(&tpg->tv_tpg_mutex);
1837 return -ENODEV;
1838 }
1839
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001840 if (tpg->tv_tpg_port_count != 0) {
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001841 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001842 pr_err("Unable to remove TCM_vhost I_T Nexus with"
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001843 " active TPG port count: %d\n",
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001844 tpg->tv_tpg_port_count);
1845 return -EBUSY;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001846 }
1847
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001848 if (tpg->tv_tpg_vhost_count != 0) {
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001849 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001850 pr_err("Unable to remove TCM_vhost I_T Nexus with"
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001851 " active TPG vhost count: %d\n",
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001852 tpg->tv_tpg_vhost_count);
1853 return -EBUSY;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001854 }
1855
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001856 pr_debug("TCM_vhost_ConfigFS: Removing I_T Nexus to emulated"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001857 " %s Initiator Port: %s\n", vhost_scsi_dump_proto_id(tpg->tport),
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001858 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
Nicholas Bellinger3aee26b2013-06-21 14:32:04 -07001859
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001860 vhost_scsi_free_cmd_map_res(tv_nexus, se_sess);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001861 /*
Nicholas Bellinger101998f2012-07-30 13:30:00 -07001862 * Release the SCSI I_T Nexus to the emulated vhost Target Port
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001863 */
1864 transport_deregister_session(tv_nexus->tvn_se_sess);
1865 tpg->tpg_nexus = NULL;
1866 mutex_unlock(&tpg->tv_tpg_mutex);
1867
1868 kfree(tv_nexus);
1869 return 0;
1870}
1871
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001872static ssize_t vhost_scsi_tpg_show_nexus(struct se_portal_group *se_tpg,
Asias He683bd962013-05-06 16:38:27 +08001873 char *page)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001874{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001875 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
1876 struct vhost_scsi_tpg, se_tpg);
1877 struct vhost_scsi_nexus *tv_nexus;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001878 ssize_t ret;
1879
Asias He98718312013-05-06 16:38:28 +08001880 mutex_lock(&tpg->tv_tpg_mutex);
1881 tv_nexus = tpg->tpg_nexus;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001882 if (!tv_nexus) {
Asias He98718312013-05-06 16:38:28 +08001883 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001884 return -ENODEV;
1885 }
1886 ret = snprintf(page, PAGE_SIZE, "%s\n",
1887 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
Asias He98718312013-05-06 16:38:28 +08001888 mutex_unlock(&tpg->tv_tpg_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001889
1890 return ret;
1891}
1892
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001893static ssize_t vhost_scsi_tpg_store_nexus(struct se_portal_group *se_tpg,
Asias He683bd962013-05-06 16:38:27 +08001894 const char *page,
1895 size_t count)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001896{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001897 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
1898 struct vhost_scsi_tpg, se_tpg);
1899 struct vhost_scsi_tport *tport_wwn = tpg->tport;
1900 unsigned char i_port[VHOST_SCSI_NAMELEN], *ptr, *port_ptr;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001901 int ret;
1902 /*
1903 * Shutdown the active I_T nexus if 'NULL' is passed..
1904 */
1905 if (!strncmp(page, "NULL", 4)) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001906 ret = vhost_scsi_drop_nexus(tpg);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001907 return (!ret) ? count : ret;
1908 }
1909 /*
1910 * Otherwise make sure the passed virtual Initiator port WWN matches
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001911 * the fabric protocol_id set in vhost_scsi_make_tport(), and call
1912 * vhost_scsi_make_nexus().
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001913 */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001914 if (strlen(page) >= VHOST_SCSI_NAMELEN) {
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001915 pr_err("Emulated NAA Sas Address: %s, exceeds"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001916 " max: %d\n", page, VHOST_SCSI_NAMELEN);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001917 return -EINVAL;
1918 }
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001919 snprintf(&i_port[0], VHOST_SCSI_NAMELEN, "%s", page);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001920
1921 ptr = strstr(i_port, "naa.");
1922 if (ptr) {
1923 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_SAS) {
1924 pr_err("Passed SAS Initiator Port %s does not"
1925 " match target port protoid: %s\n", i_port,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001926 vhost_scsi_dump_proto_id(tport_wwn));
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001927 return -EINVAL;
1928 }
1929 port_ptr = &i_port[0];
1930 goto check_newline;
1931 }
1932 ptr = strstr(i_port, "fc.");
1933 if (ptr) {
1934 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_FCP) {
1935 pr_err("Passed FCP Initiator Port %s does not"
1936 " match target port protoid: %s\n", i_port,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001937 vhost_scsi_dump_proto_id(tport_wwn));
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001938 return -EINVAL;
1939 }
1940 port_ptr = &i_port[3]; /* Skip over "fc." */
1941 goto check_newline;
1942 }
1943 ptr = strstr(i_port, "iqn.");
1944 if (ptr) {
1945 if (tport_wwn->tport_proto_id != SCSI_PROTOCOL_ISCSI) {
1946 pr_err("Passed iSCSI Initiator Port %s does not"
1947 " match target port protoid: %s\n", i_port,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001948 vhost_scsi_dump_proto_id(tport_wwn));
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001949 return -EINVAL;
1950 }
1951 port_ptr = &i_port[0];
1952 goto check_newline;
1953 }
1954 pr_err("Unable to locate prefix for emulated Initiator Port:"
1955 " %s\n", i_port);
1956 return -EINVAL;
1957 /*
1958 * Clear any trailing newline for the NAA WWN
1959 */
1960check_newline:
1961 if (i_port[strlen(i_port)-1] == '\n')
1962 i_port[strlen(i_port)-1] = '\0';
1963
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001964 ret = vhost_scsi_make_nexus(tpg, port_ptr);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001965 if (ret < 0)
1966 return ret;
1967
1968 return count;
1969}
1970
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001971TF_TPG_BASE_ATTR(vhost_scsi, nexus, S_IRUGO | S_IWUSR);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001972
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001973static struct configfs_attribute *vhost_scsi_tpg_attrs[] = {
1974 &vhost_scsi_tpg_nexus.attr,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001975 NULL,
1976};
1977
Asias He683bd962013-05-06 16:38:27 +08001978static struct se_portal_group *
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001979vhost_scsi_make_tpg(struct se_wwn *wwn,
Asias He683bd962013-05-06 16:38:27 +08001980 struct config_group *group,
1981 const char *name)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001982{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001983 struct vhost_scsi_tport *tport = container_of(wwn,
1984 struct vhost_scsi_tport, tport_wwn);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001985
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001986 struct vhost_scsi_tpg *tpg;
Dan Carpenter59c816c2015-02-05 10:37:33 +03001987 u16 tpgt;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001988 int ret;
1989
1990 if (strstr(name, "tpgt_") != name)
1991 return ERR_PTR(-EINVAL);
Dan Carpenter59c816c2015-02-05 10:37:33 +03001992 if (kstrtou16(name + 5, 10, &tpgt) || tpgt >= VHOST_SCSI_MAX_TARGET)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001993 return ERR_PTR(-EINVAL);
1994
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001995 tpg = kzalloc(sizeof(struct vhost_scsi_tpg), GFP_KERNEL);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001996 if (!tpg) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08001997 pr_err("Unable to allocate struct vhost_scsi_tpg");
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07001998 return ERR_PTR(-ENOMEM);
1999 }
2000 mutex_init(&tpg->tv_tpg_mutex);
2001 INIT_LIST_HEAD(&tpg->tv_tpg_list);
2002 tpg->tport = tport;
2003 tpg->tport_tpgt = tpgt;
2004
Nicholas Bellingerbc0c94b2015-05-20 21:48:03 -07002005 ret = core_tpg_register(wwn, &tpg->se_tpg, tport->tport_proto_id);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002006 if (ret < 0) {
2007 kfree(tpg);
2008 return NULL;
2009 }
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002010 mutex_lock(&vhost_scsi_mutex);
2011 list_add_tail(&tpg->tv_tpg_list, &vhost_scsi_list);
2012 mutex_unlock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002013
2014 return &tpg->se_tpg;
2015}
2016
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002017static void vhost_scsi_drop_tpg(struct se_portal_group *se_tpg)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002018{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002019 struct vhost_scsi_tpg *tpg = container_of(se_tpg,
2020 struct vhost_scsi_tpg, se_tpg);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002021
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002022 mutex_lock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002023 list_del(&tpg->tv_tpg_list);
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002024 mutex_unlock(&vhost_scsi_mutex);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002025 /*
Nicholas Bellinger101998f2012-07-30 13:30:00 -07002026 * Release the virtual I_T Nexus for this vhost TPG
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002027 */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002028 vhost_scsi_drop_nexus(tpg);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002029 /*
2030 * Deregister the se_tpg from TCM..
2031 */
2032 core_tpg_deregister(se_tpg);
2033 kfree(tpg);
2034}
2035
Asias He683bd962013-05-06 16:38:27 +08002036static struct se_wwn *
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002037vhost_scsi_make_tport(struct target_fabric_configfs *tf,
Asias He683bd962013-05-06 16:38:27 +08002038 struct config_group *group,
2039 const char *name)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002040{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002041 struct vhost_scsi_tport *tport;
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002042 char *ptr;
2043 u64 wwpn = 0;
2044 int off = 0;
2045
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002046 /* if (vhost_scsi_parse_wwn(name, &wwpn, 1) < 0)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002047 return ERR_PTR(-EINVAL); */
2048
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002049 tport = kzalloc(sizeof(struct vhost_scsi_tport), GFP_KERNEL);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002050 if (!tport) {
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002051 pr_err("Unable to allocate struct vhost_scsi_tport");
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002052 return ERR_PTR(-ENOMEM);
2053 }
2054 tport->tport_wwpn = wwpn;
2055 /*
2056 * Determine the emulated Protocol Identifier and Target Port Name
2057 * based on the incoming configfs directory name.
2058 */
2059 ptr = strstr(name, "naa.");
2060 if (ptr) {
2061 tport->tport_proto_id = SCSI_PROTOCOL_SAS;
2062 goto check_len;
2063 }
2064 ptr = strstr(name, "fc.");
2065 if (ptr) {
2066 tport->tport_proto_id = SCSI_PROTOCOL_FCP;
2067 off = 3; /* Skip over "fc." */
2068 goto check_len;
2069 }
2070 ptr = strstr(name, "iqn.");
2071 if (ptr) {
2072 tport->tport_proto_id = SCSI_PROTOCOL_ISCSI;
2073 goto check_len;
2074 }
2075
2076 pr_err("Unable to locate prefix for emulated Target Port:"
2077 " %s\n", name);
2078 kfree(tport);
2079 return ERR_PTR(-EINVAL);
2080
2081check_len:
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002082 if (strlen(name) >= VHOST_SCSI_NAMELEN) {
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002083 pr_err("Emulated %s Address: %s, exceeds"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002084 " max: %d\n", name, vhost_scsi_dump_proto_id(tport),
2085 VHOST_SCSI_NAMELEN);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002086 kfree(tport);
2087 return ERR_PTR(-EINVAL);
2088 }
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002089 snprintf(&tport->tport_name[0], VHOST_SCSI_NAMELEN, "%s", &name[off]);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002090
2091 pr_debug("TCM_VHost_ConfigFS: Allocated emulated Target"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002092 " %s Address: %s\n", vhost_scsi_dump_proto_id(tport), name);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002093
2094 return &tport->tport_wwn;
2095}
2096
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002097static void vhost_scsi_drop_tport(struct se_wwn *wwn)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002098{
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002099 struct vhost_scsi_tport *tport = container_of(wwn,
2100 struct vhost_scsi_tport, tport_wwn);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002101
2102 pr_debug("TCM_VHost_ConfigFS: Deallocating emulated Target"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002103 " %s Address: %s\n", vhost_scsi_dump_proto_id(tport),
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002104 tport->tport_name);
2105
2106 kfree(tport);
2107}
2108
Asias He683bd962013-05-06 16:38:27 +08002109static ssize_t
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002110vhost_scsi_wwn_show_attr_version(struct target_fabric_configfs *tf,
Asias He683bd962013-05-06 16:38:27 +08002111 char *page)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002112{
2113 return sprintf(page, "TCM_VHOST fabric module %s on %s/%s"
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002114 "on "UTS_RELEASE"\n", VHOST_SCSI_VERSION, utsname()->sysname,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002115 utsname()->machine);
2116}
2117
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002118TF_WWN_ATTR_RO(vhost_scsi, version);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002119
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002120static struct configfs_attribute *vhost_scsi_wwn_attrs[] = {
2121 &vhost_scsi_wwn_version.attr,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002122 NULL,
2123};
2124
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002125static struct target_core_fabric_ops vhost_scsi_ops = {
Christoph Hellwig9ac89282015-04-08 20:01:35 +02002126 .module = THIS_MODULE,
2127 .name = "vhost",
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002128 .get_fabric_name = vhost_scsi_get_fabric_name,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002129 .tpg_get_wwn = vhost_scsi_get_fabric_wwn,
2130 .tpg_get_tag = vhost_scsi_get_tpgt,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002131 .tpg_check_demo_mode = vhost_scsi_check_true,
2132 .tpg_check_demo_mode_cache = vhost_scsi_check_true,
2133 .tpg_check_demo_mode_write_protect = vhost_scsi_check_false,
2134 .tpg_check_prod_mode_write_protect = vhost_scsi_check_false,
Nicholas Bellingerb1d75fe2015-03-28 00:03:51 -07002135 .tpg_check_prot_fabric_only = vhost_scsi_check_prot_fabric_only,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002136 .tpg_get_inst_index = vhost_scsi_tpg_get_inst_index,
2137 .release_cmd = vhost_scsi_release_cmd,
Nicholas Bellinger084ed452013-06-06 02:20:41 -07002138 .check_stop_free = vhost_scsi_check_stop_free,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002139 .shutdown_session = vhost_scsi_shutdown_session,
2140 .close_session = vhost_scsi_close_session,
2141 .sess_get_index = vhost_scsi_sess_get_index,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002142 .sess_get_initiator_sid = NULL,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002143 .write_pending = vhost_scsi_write_pending,
2144 .write_pending_status = vhost_scsi_write_pending_status,
2145 .set_default_node_attributes = vhost_scsi_set_default_node_attrs,
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002146 .get_cmd_state = vhost_scsi_get_cmd_state,
2147 .queue_data_in = vhost_scsi_queue_data_in,
2148 .queue_status = vhost_scsi_queue_status,
2149 .queue_tm_rsp = vhost_scsi_queue_tm_rsp,
2150 .aborted_task = vhost_scsi_aborted_task,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002151 /*
2152 * Setup callers for generic logic in target_core_fabric_configfs.c
2153 */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002154 .fabric_make_wwn = vhost_scsi_make_tport,
2155 .fabric_drop_wwn = vhost_scsi_drop_tport,
2156 .fabric_make_tpg = vhost_scsi_make_tpg,
2157 .fabric_drop_tpg = vhost_scsi_drop_tpg,
2158 .fabric_post_link = vhost_scsi_port_link,
2159 .fabric_pre_unlink = vhost_scsi_port_unlink,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002160
Christoph Hellwig9ac89282015-04-08 20:01:35 +02002161 .tfc_wwn_attrs = vhost_scsi_wwn_attrs,
2162 .tfc_tpg_base_attrs = vhost_scsi_tpg_attrs,
2163 .tfc_tpg_attrib_attrs = vhost_scsi_tpg_attrib_attrs,
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002164};
2165
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002166static int __init vhost_scsi_init(void)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002167{
2168 int ret = -ENOMEM;
Christoph Hellwig9ac89282015-04-08 20:01:35 +02002169
2170 pr_debug("TCM_VHOST fabric module %s on %s/%s"
2171 " on "UTS_RELEASE"\n", VHOST_SCSI_VERSION, utsname()->sysname,
2172 utsname()->machine);
2173
Nicholas Bellinger101998f2012-07-30 13:30:00 -07002174 /*
2175 * Use our own dedicated workqueue for submitting I/O into
2176 * target core to avoid contention within system_wq.
2177 */
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002178 vhost_scsi_workqueue = alloc_workqueue("vhost_scsi", 0, 0);
2179 if (!vhost_scsi_workqueue)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002180 goto out;
2181
2182 ret = vhost_scsi_register();
2183 if (ret < 0)
2184 goto out_destroy_workqueue;
2185
Christoph Hellwig9ac89282015-04-08 20:01:35 +02002186 ret = target_register_template(&vhost_scsi_ops);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002187 if (ret < 0)
2188 goto out_vhost_scsi_deregister;
2189
2190 return 0;
2191
2192out_vhost_scsi_deregister:
2193 vhost_scsi_deregister();
2194out_destroy_workqueue:
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002195 destroy_workqueue(vhost_scsi_workqueue);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002196out:
2197 return ret;
2198};
2199
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002200static void vhost_scsi_exit(void)
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002201{
Christoph Hellwig9ac89282015-04-08 20:01:35 +02002202 target_unregister_template(&vhost_scsi_ops);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002203 vhost_scsi_deregister();
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002204 destroy_workqueue(vhost_scsi_workqueue);
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002205};
2206
Michael S. Tsirkin181c04a2013-05-02 03:52:59 +03002207MODULE_DESCRIPTION("VHOST_SCSI series fabric driver");
2208MODULE_ALIAS("tcm_vhost");
Nicholas Bellinger057cbf42012-07-18 14:31:32 -07002209MODULE_LICENSE("GPL");
Nicholas Bellinger1a1ff822015-01-31 23:56:53 -08002210module_init(vhost_scsi_init);
2211module_exit(vhost_scsi_exit);