1 /*******************************************************************************
2 * Vhost kernel TCM fabric driver for virtio SCSI initiators
4 * (C) Copyright 2010-2013 Datera, Inc.
5 * (C) Copyright 2010-2012 IBM Corp.
7 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
9 * Authors: Nicholas A. Bellinger <nab@daterainc.com>
10 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
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.
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.
22 ****************************************************************************/
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>
38 #include <linux/miscdevice.h>
39 #include <asm/unaligned.h>
40 #include <scsi/scsi.h>
41 #include <scsi/scsi_tcq.h>
42 #include <target/target_core_base.h>
43 #include <target/target_core_fabric.h>
44 #include <target/target_core_fabric_configfs.h>
45 #include <target/target_core_configfs.h>
46 #include <target/configfs_macros.h>
47 #include <linux/vhost.h>
48 #include <linux/virtio_scsi.h>
49 #include <linux/llist.h>
50 #include <linux/bitmap.h>
51 #include <linux/percpu_ida.h>
55 #define TCM_VHOST_VERSION "v0.1"
56 #define TCM_VHOST_NAMELEN 256
57 #define TCM_VHOST_MAX_CDB_SIZE 32
58 #define TCM_VHOST_DEFAULT_TAGS 256
59 #define TCM_VHOST_PREALLOC_SGLS 2048
60 #define TCM_VHOST_PREALLOC_UPAGES 2048
61 #define TCM_VHOST_PREALLOC_PROT_SGLS 512
63 struct vhost_scsi_inflight
{
64 /* Wait for the flush operation to finish */
65 struct completion comp
;
66 /* Refcount for the inflight reqs */
70 struct tcm_vhost_cmd
{
71 /* Descriptor from vhost_get_vq_desc() for virt_queue segment */
73 /* virtio-scsi initiator task attribute */
75 /* virtio-scsi response incoming iovecs */
77 /* virtio-scsi initiator data direction */
78 enum dma_data_direction tvc_data_direction
;
79 /* Expected data transfer length from virtio-scsi header */
81 /* The Tag from include/linux/virtio_scsi.h:struct virtio_scsi_cmd_req */
83 /* The number of scatterlists associated with this cmd */
85 u32 tvc_prot_sgl_count
;
86 /* Saved unpacked SCSI LUN for tcm_vhost_submission_work() */
88 /* Pointer to the SGL formatted memory from virtio-scsi */
89 struct scatterlist
*tvc_sgl
;
90 struct scatterlist
*tvc_prot_sgl
;
91 struct page
**tvc_upages
;
92 /* Pointer to response header iovec */
93 struct iovec
*tvc_resp_iov
;
94 /* 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 */
99 struct tcm_vhost_nexus
*tvc_nexus
;
100 /* The TCM I/O descriptor that is accessed via container_of() */
101 struct se_cmd tvc_se_cmd
;
102 /* work item used for cmwq dispatch to tcm_vhost_submission_work() */
103 struct work_struct work
;
104 /* Copy of the incoming SCSI command descriptor block (CDB) */
105 unsigned char tvc_cdb
[TCM_VHOST_MAX_CDB_SIZE
];
106 /* 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
;
114 struct tcm_vhost_nexus
{
115 /* Pointer to TCM session for I_T Nexus */
116 struct se_session
*tvn_se_sess
;
119 struct tcm_vhost_nacl
{
120 /* Binary World Wide unique Port Name for Vhost Initiator port */
122 /* ASCII formatted WWPN for Sas Initiator port */
123 char iport_name
[TCM_VHOST_NAMELEN
];
124 /* Returned by tcm_vhost_make_nodeacl() */
125 struct se_node_acl se_node_acl
;
128 struct tcm_vhost_tpg
{
129 /* Vhost port target portal group tag for TCM */
131 /* Used to track number of TPG Port/Lun Links wrt to explict I_T Nexus shutdown */
132 int tv_tpg_port_count
;
133 /* Used for vhost_scsi device reference to tpg_nexus, protected by tv_tpg_mutex */
134 int tv_tpg_vhost_count
;
135 /* list for tcm_vhost_list */
136 struct list_head tv_tpg_list
;
137 /* Used to protect access for tpg_nexus */
138 struct mutex tv_tpg_mutex
;
139 /* Pointer to the TCM VHost I_T Nexus for this TPG endpoint */
140 struct tcm_vhost_nexus
*tpg_nexus
;
141 /* Pointer back to tcm_vhost_tport */
142 struct tcm_vhost_tport
*tport
;
143 /* Returned by tcm_vhost_make_tpg() */
144 struct se_portal_group se_tpg
;
145 /* Pointer back to vhost_scsi, protected by tv_tpg_mutex */
146 struct vhost_scsi
*vhost_scsi
;
149 struct tcm_vhost_tport
{
150 /* SCSI protocol the tport is providing */
152 /* Binary World Wide unique Port Name for Vhost Target port */
154 /* ASCII formatted WWPN for Vhost Target port */
155 char tport_name
[TCM_VHOST_NAMELEN
];
156 /* Returned by tcm_vhost_make_tport() */
157 struct se_wwn tport_wwn
;
160 struct tcm_vhost_evt
{
161 /* event to be sent to guest */
162 struct virtio_scsi_event event
;
163 /* event list, serviced from vhost worker thread */
164 struct llist_node list
;
168 VHOST_SCSI_VQ_CTL
= 0,
169 VHOST_SCSI_VQ_EVT
= 1,
170 VHOST_SCSI_VQ_IO
= 2,
173 /* Note: can't set VIRTIO_F_VERSION_1 yet, since that implies ANY_LAYOUT. */
175 VHOST_SCSI_FEATURES
= VHOST_FEATURES
| (1ULL << VIRTIO_SCSI_F_HOTPLUG
) |
176 (1ULL << VIRTIO_SCSI_F_T10_PI
)
179 #define VHOST_SCSI_MAX_TARGET 256
180 #define VHOST_SCSI_MAX_VQ 128
181 #define VHOST_SCSI_MAX_EVENT 128
183 struct vhost_scsi_virtqueue
{
184 struct vhost_virtqueue vq
;
186 * Reference counting for inflight reqs, used for flush operation. At
187 * each time, one reference tracks new commands submitted, while we
188 * wait for another one to reach 0.
190 struct vhost_scsi_inflight inflights
[2];
192 * Indicate current inflight in use, protected by vq->mutex.
193 * Writers must also take dev mutex and flush under it.
199 /* Protected by vhost_scsi->dev.mutex */
200 struct tcm_vhost_tpg
**vs_tpg
;
201 char vs_vhost_wwpn
[TRANSPORT_IQN_LEN
];
203 struct vhost_dev dev
;
204 struct vhost_scsi_virtqueue vqs
[VHOST_SCSI_MAX_VQ
];
206 struct vhost_work vs_completion_work
; /* cmd completion work item */
207 struct llist_head vs_completion_list
; /* cmd completion queue */
209 struct vhost_work vs_event_work
; /* evt injection work item */
210 struct llist_head vs_event_list
; /* evt injection queue */
212 bool vs_events_missed
; /* any missed events, protected by vq->mutex */
213 int vs_events_nr
; /* num of pending events, protected by vq->mutex */
216 /* Local pointer to allocated TCM configfs fabric module */
217 static struct target_fabric_configfs
*tcm_vhost_fabric_configfs
;
219 static struct workqueue_struct
*tcm_vhost_workqueue
;
221 /* Global spinlock to protect tcm_vhost TPG list for vhost IOCTL access */
222 static DEFINE_MUTEX(tcm_vhost_mutex
);
223 static LIST_HEAD(tcm_vhost_list
);
225 static int iov_num_pages(void __user
*iov_base
, size_t iov_len
)
227 return (PAGE_ALIGN((unsigned long)iov_base
+ iov_len
) -
228 ((unsigned long)iov_base
& PAGE_MASK
)) >> PAGE_SHIFT
;
231 static void tcm_vhost_done_inflight(struct kref
*kref
)
233 struct vhost_scsi_inflight
*inflight
;
235 inflight
= container_of(kref
, struct vhost_scsi_inflight
, kref
);
236 complete(&inflight
->comp
);
239 static void tcm_vhost_init_inflight(struct vhost_scsi
*vs
,
240 struct vhost_scsi_inflight
*old_inflight
[])
242 struct vhost_scsi_inflight
*new_inflight
;
243 struct vhost_virtqueue
*vq
;
246 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++) {
249 mutex_lock(&vq
->mutex
);
251 /* store old infight */
252 idx
= vs
->vqs
[i
].inflight_idx
;
254 old_inflight
[i
] = &vs
->vqs
[i
].inflights
[idx
];
256 /* setup new infight */
257 vs
->vqs
[i
].inflight_idx
= idx
^ 1;
258 new_inflight
= &vs
->vqs
[i
].inflights
[idx
^ 1];
259 kref_init(&new_inflight
->kref
);
260 init_completion(&new_inflight
->comp
);
262 mutex_unlock(&vq
->mutex
);
266 static struct vhost_scsi_inflight
*
267 tcm_vhost_get_inflight(struct vhost_virtqueue
*vq
)
269 struct vhost_scsi_inflight
*inflight
;
270 struct vhost_scsi_virtqueue
*svq
;
272 svq
= container_of(vq
, struct vhost_scsi_virtqueue
, vq
);
273 inflight
= &svq
->inflights
[svq
->inflight_idx
];
274 kref_get(&inflight
->kref
);
279 static void tcm_vhost_put_inflight(struct vhost_scsi_inflight
*inflight
)
281 kref_put(&inflight
->kref
, tcm_vhost_done_inflight
);
284 static int tcm_vhost_check_true(struct se_portal_group
*se_tpg
)
289 static int tcm_vhost_check_false(struct se_portal_group
*se_tpg
)
294 static char *tcm_vhost_get_fabric_name(void)
299 static u8
tcm_vhost_get_fabric_proto_ident(struct se_portal_group
*se_tpg
)
301 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
302 struct tcm_vhost_tpg
, se_tpg
);
303 struct tcm_vhost_tport
*tport
= tpg
->tport
;
305 switch (tport
->tport_proto_id
) {
306 case SCSI_PROTOCOL_SAS
:
307 return sas_get_fabric_proto_ident(se_tpg
);
308 case SCSI_PROTOCOL_FCP
:
309 return fc_get_fabric_proto_ident(se_tpg
);
310 case SCSI_PROTOCOL_ISCSI
:
311 return iscsi_get_fabric_proto_ident(se_tpg
);
313 pr_err("Unknown tport_proto_id: 0x%02x, using"
314 " SAS emulation\n", tport
->tport_proto_id
);
318 return sas_get_fabric_proto_ident(se_tpg
);
321 static char *tcm_vhost_get_fabric_wwn(struct se_portal_group
*se_tpg
)
323 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
324 struct tcm_vhost_tpg
, se_tpg
);
325 struct tcm_vhost_tport
*tport
= tpg
->tport
;
327 return &tport
->tport_name
[0];
330 static u16
tcm_vhost_get_tag(struct se_portal_group
*se_tpg
)
332 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
333 struct tcm_vhost_tpg
, se_tpg
);
334 return tpg
->tport_tpgt
;
337 static u32
tcm_vhost_get_default_depth(struct se_portal_group
*se_tpg
)
343 tcm_vhost_get_pr_transport_id(struct se_portal_group
*se_tpg
,
344 struct se_node_acl
*se_nacl
,
345 struct t10_pr_registration
*pr_reg
,
349 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
350 struct tcm_vhost_tpg
, se_tpg
);
351 struct tcm_vhost_tport
*tport
= tpg
->tport
;
353 switch (tport
->tport_proto_id
) {
354 case SCSI_PROTOCOL_SAS
:
355 return sas_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
357 case SCSI_PROTOCOL_FCP
:
358 return fc_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
360 case SCSI_PROTOCOL_ISCSI
:
361 return iscsi_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
364 pr_err("Unknown tport_proto_id: 0x%02x, using"
365 " SAS emulation\n", tport
->tport_proto_id
);
369 return sas_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
374 tcm_vhost_get_pr_transport_id_len(struct se_portal_group
*se_tpg
,
375 struct se_node_acl
*se_nacl
,
376 struct t10_pr_registration
*pr_reg
,
379 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
380 struct tcm_vhost_tpg
, se_tpg
);
381 struct tcm_vhost_tport
*tport
= tpg
->tport
;
383 switch (tport
->tport_proto_id
) {
384 case SCSI_PROTOCOL_SAS
:
385 return sas_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
387 case SCSI_PROTOCOL_FCP
:
388 return fc_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
390 case SCSI_PROTOCOL_ISCSI
:
391 return iscsi_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
394 pr_err("Unknown tport_proto_id: 0x%02x, using"
395 " SAS emulation\n", tport
->tport_proto_id
);
399 return sas_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
404 tcm_vhost_parse_pr_out_transport_id(struct se_portal_group
*se_tpg
,
407 char **port_nexus_ptr
)
409 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
410 struct tcm_vhost_tpg
, se_tpg
);
411 struct tcm_vhost_tport
*tport
= tpg
->tport
;
413 switch (tport
->tport_proto_id
) {
414 case SCSI_PROTOCOL_SAS
:
415 return sas_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
417 case SCSI_PROTOCOL_FCP
:
418 return fc_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
420 case SCSI_PROTOCOL_ISCSI
:
421 return iscsi_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
424 pr_err("Unknown tport_proto_id: 0x%02x, using"
425 " SAS emulation\n", tport
->tport_proto_id
);
429 return sas_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
433 static struct se_node_acl
*
434 tcm_vhost_alloc_fabric_acl(struct se_portal_group
*se_tpg
)
436 struct tcm_vhost_nacl
*nacl
;
438 nacl
= kzalloc(sizeof(struct tcm_vhost_nacl
), GFP_KERNEL
);
440 pr_err("Unable to allocate struct tcm_vhost_nacl\n");
444 return &nacl
->se_node_acl
;
448 tcm_vhost_release_fabric_acl(struct se_portal_group
*se_tpg
,
449 struct se_node_acl
*se_nacl
)
451 struct tcm_vhost_nacl
*nacl
= container_of(se_nacl
,
452 struct tcm_vhost_nacl
, se_node_acl
);
456 static u32
tcm_vhost_tpg_get_inst_index(struct se_portal_group
*se_tpg
)
461 static void tcm_vhost_release_cmd(struct se_cmd
*se_cmd
)
463 struct tcm_vhost_cmd
*tv_cmd
= container_of(se_cmd
,
464 struct tcm_vhost_cmd
, tvc_se_cmd
);
465 struct se_session
*se_sess
= tv_cmd
->tvc_nexus
->tvn_se_sess
;
468 if (tv_cmd
->tvc_sgl_count
) {
469 for (i
= 0; i
< tv_cmd
->tvc_sgl_count
; i
++)
470 put_page(sg_page(&tv_cmd
->tvc_sgl
[i
]));
472 if (tv_cmd
->tvc_prot_sgl_count
) {
473 for (i
= 0; i
< tv_cmd
->tvc_prot_sgl_count
; i
++)
474 put_page(sg_page(&tv_cmd
->tvc_prot_sgl
[i
]));
477 tcm_vhost_put_inflight(tv_cmd
->inflight
);
478 percpu_ida_free(&se_sess
->sess_tag_pool
, se_cmd
->map_tag
);
481 static int tcm_vhost_shutdown_session(struct se_session
*se_sess
)
486 static void tcm_vhost_close_session(struct se_session
*se_sess
)
491 static u32
tcm_vhost_sess_get_index(struct se_session
*se_sess
)
496 static int tcm_vhost_write_pending(struct se_cmd
*se_cmd
)
498 /* Go ahead and process the write immediately */
499 target_execute_cmd(se_cmd
);
503 static int tcm_vhost_write_pending_status(struct se_cmd
*se_cmd
)
508 static void tcm_vhost_set_default_node_attrs(struct se_node_acl
*nacl
)
513 static u32
tcm_vhost_get_task_tag(struct se_cmd
*se_cmd
)
518 static int tcm_vhost_get_cmd_state(struct se_cmd
*se_cmd
)
523 static void vhost_scsi_complete_cmd(struct tcm_vhost_cmd
*cmd
)
525 struct vhost_scsi
*vs
= cmd
->tvc_vhost
;
527 llist_add(&cmd
->tvc_completion_list
, &vs
->vs_completion_list
);
529 vhost_work_queue(&vs
->dev
, &vs
->vs_completion_work
);
532 static int tcm_vhost_queue_data_in(struct se_cmd
*se_cmd
)
534 struct tcm_vhost_cmd
*cmd
= container_of(se_cmd
,
535 struct tcm_vhost_cmd
, tvc_se_cmd
);
536 vhost_scsi_complete_cmd(cmd
);
540 static int tcm_vhost_queue_status(struct se_cmd
*se_cmd
)
542 struct tcm_vhost_cmd
*cmd
= container_of(se_cmd
,
543 struct tcm_vhost_cmd
, tvc_se_cmd
);
544 vhost_scsi_complete_cmd(cmd
);
548 static void tcm_vhost_queue_tm_rsp(struct se_cmd
*se_cmd
)
553 static void tcm_vhost_aborted_task(struct se_cmd
*se_cmd
)
558 static void tcm_vhost_free_evt(struct vhost_scsi
*vs
, struct tcm_vhost_evt
*evt
)
564 static struct tcm_vhost_evt
*
565 tcm_vhost_allocate_evt(struct vhost_scsi
*vs
,
566 u32 event
, u32 reason
)
568 struct vhost_virtqueue
*vq
= &vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
;
569 struct tcm_vhost_evt
*evt
;
571 if (vs
->vs_events_nr
> VHOST_SCSI_MAX_EVENT
) {
572 vs
->vs_events_missed
= true;
576 evt
= kzalloc(sizeof(*evt
), GFP_KERNEL
);
578 vq_err(vq
, "Failed to allocate tcm_vhost_evt\n");
579 vs
->vs_events_missed
= true;
583 evt
->event
.event
= cpu_to_vhost32(vq
, event
);
584 evt
->event
.reason
= cpu_to_vhost32(vq
, reason
);
590 static void vhost_scsi_free_cmd(struct tcm_vhost_cmd
*cmd
)
592 struct se_cmd
*se_cmd
= &cmd
->tvc_se_cmd
;
594 /* TODO locking against target/backend threads? */
595 transport_generic_free_cmd(se_cmd
, 0);
599 static int vhost_scsi_check_stop_free(struct se_cmd
*se_cmd
)
601 return target_put_sess_cmd(se_cmd
->se_sess
, se_cmd
);
605 tcm_vhost_do_evt_work(struct vhost_scsi
*vs
, struct tcm_vhost_evt
*evt
)
607 struct vhost_virtqueue
*vq
= &vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
;
608 struct virtio_scsi_event
*event
= &evt
->event
;
609 struct virtio_scsi_event __user
*eventp
;
613 if (!vq
->private_data
) {
614 vs
->vs_events_missed
= true;
619 vhost_disable_notify(&vs
->dev
, vq
);
620 head
= vhost_get_vq_desc(vq
, vq
->iov
,
621 ARRAY_SIZE(vq
->iov
), &out
, &in
,
624 vs
->vs_events_missed
= true;
627 if (head
== vq
->num
) {
628 if (vhost_enable_notify(&vs
->dev
, vq
))
630 vs
->vs_events_missed
= true;
634 if ((vq
->iov
[out
].iov_len
!= sizeof(struct virtio_scsi_event
))) {
635 vq_err(vq
, "Expecting virtio_scsi_event, got %zu bytes\n",
636 vq
->iov
[out
].iov_len
);
637 vs
->vs_events_missed
= true;
641 if (vs
->vs_events_missed
) {
642 event
->event
|= cpu_to_vhost32(vq
, VIRTIO_SCSI_T_EVENTS_MISSED
);
643 vs
->vs_events_missed
= false;
646 eventp
= vq
->iov
[out
].iov_base
;
647 ret
= __copy_to_user(eventp
, event
, sizeof(*event
));
649 vhost_add_used_and_signal(&vs
->dev
, vq
, head
, 0);
651 vq_err(vq
, "Faulted on tcm_vhost_send_event\n");
654 static void tcm_vhost_evt_work(struct vhost_work
*work
)
656 struct vhost_scsi
*vs
= container_of(work
, struct vhost_scsi
,
658 struct vhost_virtqueue
*vq
= &vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
;
659 struct tcm_vhost_evt
*evt
;
660 struct llist_node
*llnode
;
662 mutex_lock(&vq
->mutex
);
663 llnode
= llist_del_all(&vs
->vs_event_list
);
665 evt
= llist_entry(llnode
, struct tcm_vhost_evt
, list
);
666 llnode
= llist_next(llnode
);
667 tcm_vhost_do_evt_work(vs
, evt
);
668 tcm_vhost_free_evt(vs
, evt
);
670 mutex_unlock(&vq
->mutex
);
673 /* Fill in status and signal that we are done processing this command
675 * This is scheduled in the vhost work queue so we are called with the owner
676 * process mm and can access the vring.
678 static void vhost_scsi_complete_cmd_work(struct vhost_work
*work
)
680 struct vhost_scsi
*vs
= container_of(work
, struct vhost_scsi
,
682 DECLARE_BITMAP(signal
, VHOST_SCSI_MAX_VQ
);
683 struct virtio_scsi_cmd_resp v_rsp
;
684 struct tcm_vhost_cmd
*cmd
;
685 struct llist_node
*llnode
;
686 struct se_cmd
*se_cmd
;
687 struct iov_iter iov_iter
;
690 bitmap_zero(signal
, VHOST_SCSI_MAX_VQ
);
691 llnode
= llist_del_all(&vs
->vs_completion_list
);
693 cmd
= llist_entry(llnode
, struct tcm_vhost_cmd
,
694 tvc_completion_list
);
695 llnode
= llist_next(llnode
);
696 se_cmd
= &cmd
->tvc_se_cmd
;
698 pr_debug("%s tv_cmd %p resid %u status %#02x\n", __func__
,
699 cmd
, se_cmd
->residual_count
, se_cmd
->scsi_status
);
701 memset(&v_rsp
, 0, sizeof(v_rsp
));
702 v_rsp
.resid
= cpu_to_vhost32(cmd
->tvc_vq
, se_cmd
->residual_count
);
703 /* TODO is status_qualifier field needed? */
704 v_rsp
.status
= se_cmd
->scsi_status
;
705 v_rsp
.sense_len
= cpu_to_vhost32(cmd
->tvc_vq
,
706 se_cmd
->scsi_sense_length
);
707 memcpy(v_rsp
.sense
, cmd
->tvc_sense_buf
,
708 se_cmd
->scsi_sense_length
);
710 iov_iter_init(&iov_iter
, READ
, cmd
->tvc_resp_iov
,
711 cmd
->tvc_in_iovs
, sizeof(v_rsp
));
712 ret
= copy_to_iter(&v_rsp
, sizeof(v_rsp
), &iov_iter
);
713 if (likely(ret
== sizeof(v_rsp
))) {
714 struct vhost_scsi_virtqueue
*q
;
715 vhost_add_used(cmd
->tvc_vq
, cmd
->tvc_vq_desc
, 0);
716 q
= container_of(cmd
->tvc_vq
, struct vhost_scsi_virtqueue
, vq
);
718 __set_bit(vq
, signal
);
720 pr_err("Faulted on virtio_scsi_cmd_resp\n");
722 vhost_scsi_free_cmd(cmd
);
726 while ((vq
= find_next_bit(signal
, VHOST_SCSI_MAX_VQ
, vq
+ 1))
728 vhost_signal(&vs
->dev
, &vs
->vqs
[vq
].vq
);
731 static struct tcm_vhost_cmd
*
732 vhost_scsi_get_tag(struct vhost_virtqueue
*vq
, struct tcm_vhost_tpg
*tpg
,
733 unsigned char *cdb
, u64 scsi_tag
, u16 lun
, u8 task_attr
,
734 u32 exp_data_len
, int data_direction
)
736 struct tcm_vhost_cmd
*cmd
;
737 struct tcm_vhost_nexus
*tv_nexus
;
738 struct se_session
*se_sess
;
739 struct scatterlist
*sg
, *prot_sg
;
743 tv_nexus
= tpg
->tpg_nexus
;
745 pr_err("Unable to locate active struct tcm_vhost_nexus\n");
746 return ERR_PTR(-EIO
);
748 se_sess
= tv_nexus
->tvn_se_sess
;
750 tag
= percpu_ida_alloc(&se_sess
->sess_tag_pool
, TASK_RUNNING
);
752 pr_err("Unable to obtain tag for tcm_vhost_cmd\n");
753 return ERR_PTR(-ENOMEM
);
756 cmd
= &((struct tcm_vhost_cmd
*)se_sess
->sess_cmd_map
)[tag
];
758 prot_sg
= cmd
->tvc_prot_sgl
;
759 pages
= cmd
->tvc_upages
;
760 memset(cmd
, 0, sizeof(struct tcm_vhost_cmd
));
763 cmd
->tvc_prot_sgl
= prot_sg
;
764 cmd
->tvc_upages
= pages
;
765 cmd
->tvc_se_cmd
.map_tag
= tag
;
766 cmd
->tvc_tag
= scsi_tag
;
768 cmd
->tvc_task_attr
= task_attr
;
769 cmd
->tvc_exp_data_len
= exp_data_len
;
770 cmd
->tvc_data_direction
= data_direction
;
771 cmd
->tvc_nexus
= tv_nexus
;
772 cmd
->inflight
= tcm_vhost_get_inflight(vq
);
774 memcpy(cmd
->tvc_cdb
, cdb
, TCM_VHOST_MAX_CDB_SIZE
);
780 * Map a user memory range into a scatterlist
782 * Returns the number of scatterlist entries used or -errno on error.
785 vhost_scsi_map_to_sgl(struct tcm_vhost_cmd
*cmd
,
788 struct scatterlist
*sgl
,
791 unsigned int npages
= 0, offset
, nbytes
;
792 unsigned int pages_nr
= iov_num_pages(ptr
, len
);
793 struct scatterlist
*sg
= sgl
;
794 struct page
**pages
= cmd
->tvc_upages
;
797 if (pages_nr
> TCM_VHOST_PREALLOC_UPAGES
) {
798 pr_err("vhost_scsi_map_to_sgl() pages_nr: %u greater than"
799 " preallocated TCM_VHOST_PREALLOC_UPAGES: %u\n",
800 pages_nr
, TCM_VHOST_PREALLOC_UPAGES
);
804 ret
= get_user_pages_fast((unsigned long)ptr
, pages_nr
, write
, pages
);
805 /* No pages were pinned */
808 /* Less pages pinned than wanted */
809 if (ret
!= pages_nr
) {
810 for (i
= 0; i
< ret
; i
++)
817 offset
= (uintptr_t)ptr
& ~PAGE_MASK
;
818 nbytes
= min_t(unsigned int, PAGE_SIZE
- offset
, len
);
819 sg_set_page(sg
, pages
[npages
], nbytes
, offset
);
831 vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd
*cmd
,
836 struct scatterlist
*sg
= cmd
->tvc_sgl
;
837 unsigned int sgl_count
= 0;
840 for (i
= 0; i
< niov
; i
++)
841 sgl_count
+= iov_num_pages(iov
[i
].iov_base
, iov
[i
].iov_len
);
843 if (sgl_count
> TCM_VHOST_PREALLOC_SGLS
) {
844 pr_err("vhost_scsi_map_iov_to_sgl() sgl_count: %u greater than"
845 " preallocated TCM_VHOST_PREALLOC_SGLS: %u\n",
846 sgl_count
, TCM_VHOST_PREALLOC_SGLS
);
850 pr_debug("%s sg %p sgl_count %u\n", __func__
, sg
, sgl_count
);
851 sg_init_table(sg
, sgl_count
);
852 cmd
->tvc_sgl_count
= sgl_count
;
854 pr_debug("Mapping iovec %p for %u pages\n", &iov
[0], sgl_count
);
856 for (i
= 0; i
< niov
; i
++) {
857 ret
= vhost_scsi_map_to_sgl(cmd
, iov
[i
].iov_base
, iov
[i
].iov_len
,
860 for (i
= 0; i
< cmd
->tvc_sgl_count
; i
++) {
861 struct page
*page
= sg_page(&cmd
->tvc_sgl
[i
]);
865 cmd
->tvc_sgl_count
= 0;
875 vhost_scsi_map_iov_to_prot(struct tcm_vhost_cmd
*cmd
,
880 struct scatterlist
*prot_sg
= cmd
->tvc_prot_sgl
;
881 unsigned int prot_sgl_count
= 0;
884 for (i
= 0; i
< niov
; i
++)
885 prot_sgl_count
+= iov_num_pages(iov
[i
].iov_base
, iov
[i
].iov_len
);
887 if (prot_sgl_count
> TCM_VHOST_PREALLOC_PROT_SGLS
) {
888 pr_err("vhost_scsi_map_iov_to_prot() sgl_count: %u greater than"
889 " preallocated TCM_VHOST_PREALLOC_PROT_SGLS: %u\n",
890 prot_sgl_count
, TCM_VHOST_PREALLOC_PROT_SGLS
);
894 pr_debug("%s prot_sg %p prot_sgl_count %u\n", __func__
,
895 prot_sg
, prot_sgl_count
);
896 sg_init_table(prot_sg
, prot_sgl_count
);
897 cmd
->tvc_prot_sgl_count
= prot_sgl_count
;
899 for (i
= 0; i
< niov
; i
++) {
900 ret
= vhost_scsi_map_to_sgl(cmd
, iov
[i
].iov_base
, iov
[i
].iov_len
,
903 for (i
= 0; i
< cmd
->tvc_prot_sgl_count
; i
++) {
904 struct page
*page
= sg_page(&cmd
->tvc_prot_sgl
[i
]);
908 cmd
->tvc_prot_sgl_count
= 0;
912 prot_sgl_count
-= ret
;
917 static void tcm_vhost_submission_work(struct work_struct
*work
)
919 struct tcm_vhost_cmd
*cmd
=
920 container_of(work
, struct tcm_vhost_cmd
, work
);
921 struct tcm_vhost_nexus
*tv_nexus
;
922 struct se_cmd
*se_cmd
= &cmd
->tvc_se_cmd
;
923 struct scatterlist
*sg_ptr
, *sg_prot_ptr
= NULL
;
926 /* FIXME: BIDI operation */
927 if (cmd
->tvc_sgl_count
) {
928 sg_ptr
= cmd
->tvc_sgl
;
930 if (cmd
->tvc_prot_sgl_count
)
931 sg_prot_ptr
= cmd
->tvc_prot_sgl
;
933 se_cmd
->prot_pto
= true;
937 tv_nexus
= cmd
->tvc_nexus
;
939 rc
= target_submit_cmd_map_sgls(se_cmd
, tv_nexus
->tvn_se_sess
,
940 cmd
->tvc_cdb
, &cmd
->tvc_sense_buf
[0],
941 cmd
->tvc_lun
, cmd
->tvc_exp_data_len
,
942 cmd
->tvc_task_attr
, cmd
->tvc_data_direction
,
943 TARGET_SCF_ACK_KREF
, sg_ptr
, cmd
->tvc_sgl_count
,
944 NULL
, 0, sg_prot_ptr
, cmd
->tvc_prot_sgl_count
);
946 transport_send_check_condition_and_sense(se_cmd
,
947 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE
, 0);
948 transport_generic_free_cmd(se_cmd
, 0);
953 vhost_scsi_send_bad_target(struct vhost_scsi
*vs
,
954 struct vhost_virtqueue
*vq
,
955 int head
, unsigned out
)
957 struct virtio_scsi_cmd_resp __user
*resp
;
958 struct virtio_scsi_cmd_resp rsp
;
961 memset(&rsp
, 0, sizeof(rsp
));
962 rsp
.response
= VIRTIO_SCSI_S_BAD_TARGET
;
963 resp
= vq
->iov
[out
].iov_base
;
964 ret
= __copy_to_user(resp
, &rsp
, sizeof(rsp
));
966 vhost_add_used_and_signal(&vs
->dev
, vq
, head
, 0);
968 pr_err("Faulted on virtio_scsi_cmd_resp\n");
972 vhost_scsi_handle_vq(struct vhost_scsi
*vs
, struct vhost_virtqueue
*vq
)
974 struct tcm_vhost_tpg
**vs_tpg
;
975 struct virtio_scsi_cmd_req v_req
;
976 struct virtio_scsi_cmd_req_pi v_req_pi
;
977 struct tcm_vhost_tpg
*tpg
;
978 struct tcm_vhost_cmd
*cmd
;
980 u32 exp_data_len
, data_first
, data_num
, data_direction
, prot_first
;
982 int head
, ret
, data_niov
, prot_niov
, prot_bytes
;
985 u8
*target
, *lunp
, task_attr
;
989 mutex_lock(&vq
->mutex
);
991 * We can handle the vq only after the endpoint is setup by calling the
992 * VHOST_SCSI_SET_ENDPOINT ioctl.
994 vs_tpg
= vq
->private_data
;
998 vhost_disable_notify(&vs
->dev
, vq
);
1001 head
= vhost_get_vq_desc(vq
, vq
->iov
,
1002 ARRAY_SIZE(vq
->iov
), &out
, &in
,
1004 pr_debug("vhost_get_vq_desc: head: %d, out: %u in: %u\n",
1006 /* On error, stop handling until the next kick. */
1007 if (unlikely(head
< 0))
1009 /* Nothing new? Wait for eventfd to tell us they refilled. */
1010 if (head
== vq
->num
) {
1011 if (unlikely(vhost_enable_notify(&vs
->dev
, vq
))) {
1012 vhost_disable_notify(&vs
->dev
, vq
);
1018 /* FIXME: BIDI operation */
1019 if (out
== 1 && in
== 1) {
1020 data_direction
= DMA_NONE
;
1023 } else if (out
== 1 && in
> 1) {
1024 data_direction
= DMA_FROM_DEVICE
;
1025 data_first
= out
+ 1;
1027 } else if (out
> 1 && in
== 1) {
1028 data_direction
= DMA_TO_DEVICE
;
1032 vq_err(vq
, "Invalid buffer layout out: %u in: %u\n",
1038 * Check for a sane resp buffer so we can report errors to
1041 if (unlikely(vq
->iov
[out
].iov_len
!=
1042 sizeof(struct virtio_scsi_cmd_resp
))) {
1043 vq_err(vq
, "Expecting virtio_scsi_cmd_resp, got %zu"
1044 " bytes\n", vq
->iov
[out
].iov_len
);
1048 if (vhost_has_feature(vq
, VIRTIO_SCSI_F_T10_PI
)) {
1050 lunp
= &v_req_pi
.lun
[0];
1051 target
= &v_req_pi
.lun
[1];
1052 req_size
= sizeof(v_req_pi
);
1056 lunp
= &v_req
.lun
[0];
1057 target
= &v_req
.lun
[1];
1058 req_size
= sizeof(v_req
);
1062 if (unlikely(vq
->iov
[0].iov_len
< req_size
)) {
1063 pr_err("Expecting virtio-scsi header: %zu, got %zu\n",
1064 req_size
, vq
->iov
[0].iov_len
);
1065 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1068 ret
= memcpy_fromiovecend(req
, &vq
->iov
[0], 0, req_size
);
1069 if (unlikely(ret
)) {
1070 vq_err(vq
, "Faulted on virtio_scsi_cmd_req\n");
1071 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1075 /* virtio-scsi spec requires byte 0 of the lun to be 1 */
1076 if (unlikely(*lunp
!= 1)) {
1077 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1081 tpg
= ACCESS_ONCE(vs_tpg
[*target
]);
1083 /* Target does not exist, fail the request */
1084 if (unlikely(!tpg
)) {
1085 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1089 data_niov
= data_num
;
1090 prot_niov
= prot_first
= prot_bytes
= 0;
1092 * Determine if any protection information iovecs are preceeding
1093 * the actual data payload, and adjust data_first + data_niov
1094 * values accordingly for vhost_scsi_map_iov_to_sgl() below.
1096 * Also extract virtio_scsi header bits for vhost_scsi_get_tag()
1099 if (v_req_pi
.pi_bytesout
) {
1100 if (data_direction
!= DMA_TO_DEVICE
) {
1101 vq_err(vq
, "Received non zero do_pi_niov"
1102 ", but wrong data_direction\n");
1103 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1106 prot_bytes
= vhost32_to_cpu(vq
, v_req_pi
.pi_bytesout
);
1107 } else if (v_req_pi
.pi_bytesin
) {
1108 if (data_direction
!= DMA_FROM_DEVICE
) {
1109 vq_err(vq
, "Received non zero di_pi_niov"
1110 ", but wrong data_direction\n");
1111 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1114 prot_bytes
= vhost32_to_cpu(vq
, v_req_pi
.pi_bytesin
);
1119 for (i
= 0; i
< data_num
; i
++) {
1120 tmp
+= vq
->iov
[data_first
+ i
].iov_len
;
1122 if (tmp
>= prot_bytes
)
1125 prot_first
= data_first
;
1126 data_first
+= prot_niov
;
1127 data_niov
= data_num
- prot_niov
;
1129 tag
= vhost64_to_cpu(vq
, v_req_pi
.tag
);
1130 task_attr
= v_req_pi
.task_attr
;
1131 cdb
= &v_req_pi
.cdb
[0];
1132 lun
= ((v_req_pi
.lun
[2] << 8) | v_req_pi
.lun
[3]) & 0x3FFF;
1134 tag
= vhost64_to_cpu(vq
, v_req
.tag
);
1135 task_attr
= v_req
.task_attr
;
1136 cdb
= &v_req
.cdb
[0];
1137 lun
= ((v_req
.lun
[2] << 8) | v_req
.lun
[3]) & 0x3FFF;
1140 for (i
= 0; i
< data_niov
; i
++)
1141 exp_data_len
+= vq
->iov
[data_first
+ i
].iov_len
;
1143 * Check that the recieved CDB size does not exceeded our
1144 * hardcoded max for vhost-scsi
1146 * TODO what if cdb was too small for varlen cdb header?
1148 if (unlikely(scsi_command_size(cdb
) > TCM_VHOST_MAX_CDB_SIZE
)) {
1149 vq_err(vq
, "Received SCSI CDB with command_size: %d that"
1150 " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
1151 scsi_command_size(cdb
), TCM_VHOST_MAX_CDB_SIZE
);
1152 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1156 cmd
= vhost_scsi_get_tag(vq
, tpg
, cdb
, tag
, lun
, task_attr
,
1157 exp_data_len
+ prot_bytes
,
1160 vq_err(vq
, "vhost_scsi_get_tag failed %ld\n",
1162 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1166 pr_debug("Allocated tv_cmd: %p exp_data_len: %d, data_direction"
1167 ": %d\n", cmd
, exp_data_len
, data_direction
);
1169 cmd
->tvc_vhost
= vs
;
1171 cmd
->tvc_resp_iov
= &vq
->iov
[out
];
1172 cmd
->tvc_in_iovs
= in
;
1174 pr_debug("vhost_scsi got command opcode: %#02x, lun: %d\n",
1175 cmd
->tvc_cdb
[0], cmd
->tvc_lun
);
1178 ret
= vhost_scsi_map_iov_to_prot(cmd
,
1179 &vq
->iov
[prot_first
], prot_niov
,
1180 data_direction
== DMA_FROM_DEVICE
);
1181 if (unlikely(ret
)) {
1182 vq_err(vq
, "Failed to map iov to"
1184 tcm_vhost_release_cmd(&cmd
->tvc_se_cmd
);
1185 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1189 if (data_direction
!= DMA_NONE
) {
1190 ret
= vhost_scsi_map_iov_to_sgl(cmd
,
1191 &vq
->iov
[data_first
], data_niov
,
1192 data_direction
== DMA_FROM_DEVICE
);
1193 if (unlikely(ret
)) {
1194 vq_err(vq
, "Failed to map iov to sgl\n");
1195 tcm_vhost_release_cmd(&cmd
->tvc_se_cmd
);
1196 vhost_scsi_send_bad_target(vs
, vq
, head
, out
);
1201 * Save the descriptor from vhost_get_vq_desc() to be used to
1202 * complete the virtio-scsi request in TCM callback context via
1203 * tcm_vhost_queue_data_in() and tcm_vhost_queue_status()
1205 cmd
->tvc_vq_desc
= head
;
1207 * Dispatch tv_cmd descriptor for cmwq execution in process
1208 * context provided by tcm_vhost_workqueue. This also ensures
1209 * tv_cmd is executed on the same kworker CPU as this vhost
1210 * thread to gain positive L2 cache locality effects..
1212 INIT_WORK(&cmd
->work
, tcm_vhost_submission_work
);
1213 queue_work(tcm_vhost_workqueue
, &cmd
->work
);
1216 mutex_unlock(&vq
->mutex
);
1219 static void vhost_scsi_ctl_handle_kick(struct vhost_work
*work
)
1221 pr_debug("%s: The handling func for control queue.\n", __func__
);
1225 tcm_vhost_send_evt(struct vhost_scsi
*vs
,
1226 struct tcm_vhost_tpg
*tpg
,
1231 struct tcm_vhost_evt
*evt
;
1233 evt
= tcm_vhost_allocate_evt(vs
, event
, reason
);
1238 /* TODO: share lun setup code with virtio-scsi.ko */
1240 * Note: evt->event is zeroed when we allocate it and
1241 * lun[4-7] need to be zero according to virtio-scsi spec.
1243 evt
->event
.lun
[0] = 0x01;
1244 evt
->event
.lun
[1] = tpg
->tport_tpgt
& 0xFF;
1245 if (lun
->unpacked_lun
>= 256)
1246 evt
->event
.lun
[2] = lun
->unpacked_lun
>> 8 | 0x40 ;
1247 evt
->event
.lun
[3] = lun
->unpacked_lun
& 0xFF;
1250 llist_add(&evt
->list
, &vs
->vs_event_list
);
1251 vhost_work_queue(&vs
->dev
, &vs
->vs_event_work
);
1254 static void vhost_scsi_evt_handle_kick(struct vhost_work
*work
)
1256 struct vhost_virtqueue
*vq
= container_of(work
, struct vhost_virtqueue
,
1258 struct vhost_scsi
*vs
= container_of(vq
->dev
, struct vhost_scsi
, dev
);
1260 mutex_lock(&vq
->mutex
);
1261 if (!vq
->private_data
)
1264 if (vs
->vs_events_missed
)
1265 tcm_vhost_send_evt(vs
, NULL
, NULL
, VIRTIO_SCSI_T_NO_EVENT
, 0);
1267 mutex_unlock(&vq
->mutex
);
1270 static void vhost_scsi_handle_kick(struct vhost_work
*work
)
1272 struct vhost_virtqueue
*vq
= container_of(work
, struct vhost_virtqueue
,
1274 struct vhost_scsi
*vs
= container_of(vq
->dev
, struct vhost_scsi
, dev
);
1276 vhost_scsi_handle_vq(vs
, vq
);
1279 static void vhost_scsi_flush_vq(struct vhost_scsi
*vs
, int index
)
1281 vhost_poll_flush(&vs
->vqs
[index
].vq
.poll
);
1284 /* Callers must hold dev mutex */
1285 static void vhost_scsi_flush(struct vhost_scsi
*vs
)
1287 struct vhost_scsi_inflight
*old_inflight
[VHOST_SCSI_MAX_VQ
];
1290 /* Init new inflight and remember the old inflight */
1291 tcm_vhost_init_inflight(vs
, old_inflight
);
1294 * The inflight->kref was initialized to 1. We decrement it here to
1295 * indicate the start of the flush operation so that it will reach 0
1296 * when all the reqs are finished.
1298 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++)
1299 kref_put(&old_inflight
[i
]->kref
, tcm_vhost_done_inflight
);
1301 /* Flush both the vhost poll and vhost work */
1302 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++)
1303 vhost_scsi_flush_vq(vs
, i
);
1304 vhost_work_flush(&vs
->dev
, &vs
->vs_completion_work
);
1305 vhost_work_flush(&vs
->dev
, &vs
->vs_event_work
);
1307 /* Wait for all reqs issued before the flush to be finished */
1308 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++)
1309 wait_for_completion(&old_inflight
[i
]->comp
);
1313 * Called from vhost_scsi_ioctl() context to walk the list of available
1314 * tcm_vhost_tpg with an active struct tcm_vhost_nexus
1316 * The lock nesting rule is:
1317 * tcm_vhost_mutex -> vs->dev.mutex -> tpg->tv_tpg_mutex -> vq->mutex
1320 vhost_scsi_set_endpoint(struct vhost_scsi
*vs
,
1321 struct vhost_scsi_target
*t
)
1323 struct se_portal_group
*se_tpg
;
1324 struct tcm_vhost_tport
*tv_tport
;
1325 struct tcm_vhost_tpg
*tpg
;
1326 struct tcm_vhost_tpg
**vs_tpg
;
1327 struct vhost_virtqueue
*vq
;
1328 int index
, ret
, i
, len
;
1331 mutex_lock(&tcm_vhost_mutex
);
1332 mutex_lock(&vs
->dev
.mutex
);
1334 /* Verify that ring has been setup correctly. */
1335 for (index
= 0; index
< vs
->dev
.nvqs
; ++index
) {
1336 /* Verify that ring has been setup correctly. */
1337 if (!vhost_vq_access_ok(&vs
->vqs
[index
].vq
)) {
1343 len
= sizeof(vs_tpg
[0]) * VHOST_SCSI_MAX_TARGET
;
1344 vs_tpg
= kzalloc(len
, GFP_KERNEL
);
1350 memcpy(vs_tpg
, vs
->vs_tpg
, len
);
1352 list_for_each_entry(tpg
, &tcm_vhost_list
, tv_tpg_list
) {
1353 mutex_lock(&tpg
->tv_tpg_mutex
);
1354 if (!tpg
->tpg_nexus
) {
1355 mutex_unlock(&tpg
->tv_tpg_mutex
);
1358 if (tpg
->tv_tpg_vhost_count
!= 0) {
1359 mutex_unlock(&tpg
->tv_tpg_mutex
);
1362 tv_tport
= tpg
->tport
;
1364 if (!strcmp(tv_tport
->tport_name
, t
->vhost_wwpn
)) {
1365 if (vs
->vs_tpg
&& vs
->vs_tpg
[tpg
->tport_tpgt
]) {
1367 mutex_unlock(&tpg
->tv_tpg_mutex
);
1372 * In order to ensure individual vhost-scsi configfs
1373 * groups cannot be removed while in use by vhost ioctl,
1374 * go ahead and take an explicit se_tpg->tpg_group.cg_item
1377 se_tpg
= &tpg
->se_tpg
;
1378 ret
= configfs_depend_item(se_tpg
->se_tpg_tfo
->tf_subsys
,
1379 &se_tpg
->tpg_group
.cg_item
);
1381 pr_warn("configfs_depend_item() failed: %d\n", ret
);
1383 mutex_unlock(&tpg
->tv_tpg_mutex
);
1386 tpg
->tv_tpg_vhost_count
++;
1387 tpg
->vhost_scsi
= vs
;
1388 vs_tpg
[tpg
->tport_tpgt
] = tpg
;
1389 smp_mb__after_atomic();
1392 mutex_unlock(&tpg
->tv_tpg_mutex
);
1396 memcpy(vs
->vs_vhost_wwpn
, t
->vhost_wwpn
,
1397 sizeof(vs
->vs_vhost_wwpn
));
1398 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++) {
1399 vq
= &vs
->vqs
[i
].vq
;
1400 mutex_lock(&vq
->mutex
);
1401 vq
->private_data
= vs_tpg
;
1402 vhost_init_used(vq
);
1403 mutex_unlock(&vq
->mutex
);
1411 * Act as synchronize_rcu to make sure access to
1412 * old vs->vs_tpg is finished.
1414 vhost_scsi_flush(vs
);
1416 vs
->vs_tpg
= vs_tpg
;
1419 mutex_unlock(&vs
->dev
.mutex
);
1420 mutex_unlock(&tcm_vhost_mutex
);
1425 vhost_scsi_clear_endpoint(struct vhost_scsi
*vs
,
1426 struct vhost_scsi_target
*t
)
1428 struct se_portal_group
*se_tpg
;
1429 struct tcm_vhost_tport
*tv_tport
;
1430 struct tcm_vhost_tpg
*tpg
;
1431 struct vhost_virtqueue
*vq
;
1436 mutex_lock(&tcm_vhost_mutex
);
1437 mutex_lock(&vs
->dev
.mutex
);
1438 /* Verify that ring has been setup correctly. */
1439 for (index
= 0; index
< vs
->dev
.nvqs
; ++index
) {
1440 if (!vhost_vq_access_ok(&vs
->vqs
[index
].vq
)) {
1451 for (i
= 0; i
< VHOST_SCSI_MAX_TARGET
; i
++) {
1453 tpg
= vs
->vs_tpg
[target
];
1457 mutex_lock(&tpg
->tv_tpg_mutex
);
1458 tv_tport
= tpg
->tport
;
1464 if (strcmp(tv_tport
->tport_name
, t
->vhost_wwpn
)) {
1465 pr_warn("tv_tport->tport_name: %s, tpg->tport_tpgt: %hu"
1466 " does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
1467 tv_tport
->tport_name
, tpg
->tport_tpgt
,
1468 t
->vhost_wwpn
, t
->vhost_tpgt
);
1472 tpg
->tv_tpg_vhost_count
--;
1473 tpg
->vhost_scsi
= NULL
;
1474 vs
->vs_tpg
[target
] = NULL
;
1476 mutex_unlock(&tpg
->tv_tpg_mutex
);
1478 * Release se_tpg->tpg_group.cg_item configfs dependency now
1479 * to allow vhost-scsi WWPN se_tpg->tpg_group shutdown to occur.
1481 se_tpg
= &tpg
->se_tpg
;
1482 configfs_undepend_item(se_tpg
->se_tpg_tfo
->tf_subsys
,
1483 &se_tpg
->tpg_group
.cg_item
);
1486 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++) {
1487 vq
= &vs
->vqs
[i
].vq
;
1488 mutex_lock(&vq
->mutex
);
1489 vq
->private_data
= NULL
;
1490 mutex_unlock(&vq
->mutex
);
1494 * Act as synchronize_rcu to make sure access to
1495 * old vs->vs_tpg is finished.
1497 vhost_scsi_flush(vs
);
1500 WARN_ON(vs
->vs_events_nr
);
1501 mutex_unlock(&vs
->dev
.mutex
);
1502 mutex_unlock(&tcm_vhost_mutex
);
1506 mutex_unlock(&tpg
->tv_tpg_mutex
);
1508 mutex_unlock(&vs
->dev
.mutex
);
1509 mutex_unlock(&tcm_vhost_mutex
);
1513 static int vhost_scsi_set_features(struct vhost_scsi
*vs
, u64 features
)
1515 struct vhost_virtqueue
*vq
;
1518 if (features
& ~VHOST_SCSI_FEATURES
)
1521 mutex_lock(&vs
->dev
.mutex
);
1522 if ((features
& (1 << VHOST_F_LOG_ALL
)) &&
1523 !vhost_log_access_ok(&vs
->dev
)) {
1524 mutex_unlock(&vs
->dev
.mutex
);
1528 for (i
= 0; i
< VHOST_SCSI_MAX_VQ
; i
++) {
1529 vq
= &vs
->vqs
[i
].vq
;
1530 mutex_lock(&vq
->mutex
);
1531 vq
->acked_features
= features
;
1532 mutex_unlock(&vq
->mutex
);
1534 mutex_unlock(&vs
->dev
.mutex
);
1538 static int vhost_scsi_open(struct inode
*inode
, struct file
*f
)
1540 struct vhost_scsi
*vs
;
1541 struct vhost_virtqueue
**vqs
;
1544 vs
= kzalloc(sizeof(*vs
), GFP_KERNEL
| __GFP_NOWARN
| __GFP_REPEAT
);
1546 vs
= vzalloc(sizeof(*vs
));
1551 vqs
= kmalloc(VHOST_SCSI_MAX_VQ
* sizeof(*vqs
), GFP_KERNEL
);
1555 vhost_work_init(&vs
->vs_completion_work
, vhost_scsi_complete_cmd_work
);
1556 vhost_work_init(&vs
->vs_event_work
, tcm_vhost_evt_work
);
1558 vs
->vs_events_nr
= 0;
1559 vs
->vs_events_missed
= false;
1561 vqs
[VHOST_SCSI_VQ_CTL
] = &vs
->vqs
[VHOST_SCSI_VQ_CTL
].vq
;
1562 vqs
[VHOST_SCSI_VQ_EVT
] = &vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
;
1563 vs
->vqs
[VHOST_SCSI_VQ_CTL
].vq
.handle_kick
= vhost_scsi_ctl_handle_kick
;
1564 vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
.handle_kick
= vhost_scsi_evt_handle_kick
;
1565 for (i
= VHOST_SCSI_VQ_IO
; i
< VHOST_SCSI_MAX_VQ
; i
++) {
1566 vqs
[i
] = &vs
->vqs
[i
].vq
;
1567 vs
->vqs
[i
].vq
.handle_kick
= vhost_scsi_handle_kick
;
1569 vhost_dev_init(&vs
->dev
, vqs
, VHOST_SCSI_MAX_VQ
);
1571 tcm_vhost_init_inflight(vs
, NULL
);
1573 f
->private_data
= vs
;
1582 static int vhost_scsi_release(struct inode
*inode
, struct file
*f
)
1584 struct vhost_scsi
*vs
= f
->private_data
;
1585 struct vhost_scsi_target t
;
1587 mutex_lock(&vs
->dev
.mutex
);
1588 memcpy(t
.vhost_wwpn
, vs
->vs_vhost_wwpn
, sizeof(t
.vhost_wwpn
));
1589 mutex_unlock(&vs
->dev
.mutex
);
1590 vhost_scsi_clear_endpoint(vs
, &t
);
1591 vhost_dev_stop(&vs
->dev
);
1592 vhost_dev_cleanup(&vs
->dev
, false);
1593 /* Jobs can re-queue themselves in evt kick handler. Do extra flush. */
1594 vhost_scsi_flush(vs
);
1601 vhost_scsi_ioctl(struct file
*f
,
1605 struct vhost_scsi
*vs
= f
->private_data
;
1606 struct vhost_scsi_target backend
;
1607 void __user
*argp
= (void __user
*)arg
;
1608 u64 __user
*featurep
= argp
;
1609 u32 __user
*eventsp
= argp
;
1612 int r
, abi_version
= VHOST_SCSI_ABI_VERSION
;
1613 struct vhost_virtqueue
*vq
= &vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
;
1616 case VHOST_SCSI_SET_ENDPOINT
:
1617 if (copy_from_user(&backend
, argp
, sizeof backend
))
1619 if (backend
.reserved
!= 0)
1622 return vhost_scsi_set_endpoint(vs
, &backend
);
1623 case VHOST_SCSI_CLEAR_ENDPOINT
:
1624 if (copy_from_user(&backend
, argp
, sizeof backend
))
1626 if (backend
.reserved
!= 0)
1629 return vhost_scsi_clear_endpoint(vs
, &backend
);
1630 case VHOST_SCSI_GET_ABI_VERSION
:
1631 if (copy_to_user(argp
, &abi_version
, sizeof abi_version
))
1634 case VHOST_SCSI_SET_EVENTS_MISSED
:
1635 if (get_user(events_missed
, eventsp
))
1637 mutex_lock(&vq
->mutex
);
1638 vs
->vs_events_missed
= events_missed
;
1639 mutex_unlock(&vq
->mutex
);
1641 case VHOST_SCSI_GET_EVENTS_MISSED
:
1642 mutex_lock(&vq
->mutex
);
1643 events_missed
= vs
->vs_events_missed
;
1644 mutex_unlock(&vq
->mutex
);
1645 if (put_user(events_missed
, eventsp
))
1648 case VHOST_GET_FEATURES
:
1649 features
= VHOST_SCSI_FEATURES
;
1650 if (copy_to_user(featurep
, &features
, sizeof features
))
1653 case VHOST_SET_FEATURES
:
1654 if (copy_from_user(&features
, featurep
, sizeof features
))
1656 return vhost_scsi_set_features(vs
, features
);
1658 mutex_lock(&vs
->dev
.mutex
);
1659 r
= vhost_dev_ioctl(&vs
->dev
, ioctl
, argp
);
1660 /* TODO: flush backend after dev ioctl. */
1661 if (r
== -ENOIOCTLCMD
)
1662 r
= vhost_vring_ioctl(&vs
->dev
, ioctl
, argp
);
1663 mutex_unlock(&vs
->dev
.mutex
);
1668 #ifdef CONFIG_COMPAT
1669 static long vhost_scsi_compat_ioctl(struct file
*f
, unsigned int ioctl
,
1672 return vhost_scsi_ioctl(f
, ioctl
, (unsigned long)compat_ptr(arg
));
1676 static const struct file_operations vhost_scsi_fops
= {
1677 .owner
= THIS_MODULE
,
1678 .release
= vhost_scsi_release
,
1679 .unlocked_ioctl
= vhost_scsi_ioctl
,
1680 #ifdef CONFIG_COMPAT
1681 .compat_ioctl
= vhost_scsi_compat_ioctl
,
1683 .open
= vhost_scsi_open
,
1684 .llseek
= noop_llseek
,
1687 static struct miscdevice vhost_scsi_misc
= {
1693 static int __init
vhost_scsi_register(void)
1695 return misc_register(&vhost_scsi_misc
);
1698 static int vhost_scsi_deregister(void)
1700 return misc_deregister(&vhost_scsi_misc
);
1703 static char *tcm_vhost_dump_proto_id(struct tcm_vhost_tport
*tport
)
1705 switch (tport
->tport_proto_id
) {
1706 case SCSI_PROTOCOL_SAS
:
1708 case SCSI_PROTOCOL_FCP
:
1710 case SCSI_PROTOCOL_ISCSI
:
1720 tcm_vhost_do_plug(struct tcm_vhost_tpg
*tpg
,
1721 struct se_lun
*lun
, bool plug
)
1724 struct vhost_scsi
*vs
= tpg
->vhost_scsi
;
1725 struct vhost_virtqueue
*vq
;
1731 mutex_lock(&vs
->dev
.mutex
);
1734 reason
= VIRTIO_SCSI_EVT_RESET_RESCAN
;
1736 reason
= VIRTIO_SCSI_EVT_RESET_REMOVED
;
1738 vq
= &vs
->vqs
[VHOST_SCSI_VQ_EVT
].vq
;
1739 mutex_lock(&vq
->mutex
);
1740 if (vhost_has_feature(vq
, VIRTIO_SCSI_F_HOTPLUG
))
1741 tcm_vhost_send_evt(vs
, tpg
, lun
,
1742 VIRTIO_SCSI_T_TRANSPORT_RESET
, reason
);
1743 mutex_unlock(&vq
->mutex
);
1744 mutex_unlock(&vs
->dev
.mutex
);
1747 static void tcm_vhost_hotplug(struct tcm_vhost_tpg
*tpg
, struct se_lun
*lun
)
1749 tcm_vhost_do_plug(tpg
, lun
, true);
1752 static void tcm_vhost_hotunplug(struct tcm_vhost_tpg
*tpg
, struct se_lun
*lun
)
1754 tcm_vhost_do_plug(tpg
, lun
, false);
1757 static int tcm_vhost_port_link(struct se_portal_group
*se_tpg
,
1760 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
1761 struct tcm_vhost_tpg
, se_tpg
);
1763 mutex_lock(&tcm_vhost_mutex
);
1765 mutex_lock(&tpg
->tv_tpg_mutex
);
1766 tpg
->tv_tpg_port_count
++;
1767 mutex_unlock(&tpg
->tv_tpg_mutex
);
1769 tcm_vhost_hotplug(tpg
, lun
);
1771 mutex_unlock(&tcm_vhost_mutex
);
1776 static void tcm_vhost_port_unlink(struct se_portal_group
*se_tpg
,
1779 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
1780 struct tcm_vhost_tpg
, se_tpg
);
1782 mutex_lock(&tcm_vhost_mutex
);
1784 mutex_lock(&tpg
->tv_tpg_mutex
);
1785 tpg
->tv_tpg_port_count
--;
1786 mutex_unlock(&tpg
->tv_tpg_mutex
);
1788 tcm_vhost_hotunplug(tpg
, lun
);
1790 mutex_unlock(&tcm_vhost_mutex
);
1793 static struct se_node_acl
*
1794 tcm_vhost_make_nodeacl(struct se_portal_group
*se_tpg
,
1795 struct config_group
*group
,
1798 struct se_node_acl
*se_nacl
, *se_nacl_new
;
1799 struct tcm_vhost_nacl
*nacl
;
1803 /* tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
1804 return ERR_PTR(-EINVAL); */
1805 se_nacl_new
= tcm_vhost_alloc_fabric_acl(se_tpg
);
1807 return ERR_PTR(-ENOMEM
);
1811 * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
1812 * when converting a NodeACL from demo mode -> explict
1814 se_nacl
= core_tpg_add_initiator_node_acl(se_tpg
, se_nacl_new
,
1816 if (IS_ERR(se_nacl
)) {
1817 tcm_vhost_release_fabric_acl(se_tpg
, se_nacl_new
);
1821 * Locate our struct tcm_vhost_nacl and set the FC Nport WWPN
1823 nacl
= container_of(se_nacl
, struct tcm_vhost_nacl
, se_node_acl
);
1824 nacl
->iport_wwpn
= wwpn
;
1829 static void tcm_vhost_drop_nodeacl(struct se_node_acl
*se_acl
)
1831 struct tcm_vhost_nacl
*nacl
= container_of(se_acl
,
1832 struct tcm_vhost_nacl
, se_node_acl
);
1833 core_tpg_del_initiator_node_acl(se_acl
->se_tpg
, se_acl
, 1);
1837 static void tcm_vhost_free_cmd_map_res(struct tcm_vhost_nexus
*nexus
,
1838 struct se_session
*se_sess
)
1840 struct tcm_vhost_cmd
*tv_cmd
;
1843 if (!se_sess
->sess_cmd_map
)
1846 for (i
= 0; i
< TCM_VHOST_DEFAULT_TAGS
; i
++) {
1847 tv_cmd
= &((struct tcm_vhost_cmd
*)se_sess
->sess_cmd_map
)[i
];
1849 kfree(tv_cmd
->tvc_sgl
);
1850 kfree(tv_cmd
->tvc_prot_sgl
);
1851 kfree(tv_cmd
->tvc_upages
);
1855 static int tcm_vhost_make_nexus(struct tcm_vhost_tpg
*tpg
,
1858 struct se_portal_group
*se_tpg
;
1859 struct se_session
*se_sess
;
1860 struct tcm_vhost_nexus
*tv_nexus
;
1861 struct tcm_vhost_cmd
*tv_cmd
;
1864 mutex_lock(&tpg
->tv_tpg_mutex
);
1865 if (tpg
->tpg_nexus
) {
1866 mutex_unlock(&tpg
->tv_tpg_mutex
);
1867 pr_debug("tpg->tpg_nexus already exists\n");
1870 se_tpg
= &tpg
->se_tpg
;
1872 tv_nexus
= kzalloc(sizeof(struct tcm_vhost_nexus
), GFP_KERNEL
);
1874 mutex_unlock(&tpg
->tv_tpg_mutex
);
1875 pr_err("Unable to allocate struct tcm_vhost_nexus\n");
1879 * Initialize the struct se_session pointer and setup tagpool
1880 * for struct tcm_vhost_cmd descriptors
1882 tv_nexus
->tvn_se_sess
= transport_init_session_tags(
1883 TCM_VHOST_DEFAULT_TAGS
,
1884 sizeof(struct tcm_vhost_cmd
),
1885 TARGET_PROT_DIN_PASS
| TARGET_PROT_DOUT_PASS
);
1886 if (IS_ERR(tv_nexus
->tvn_se_sess
)) {
1887 mutex_unlock(&tpg
->tv_tpg_mutex
);
1891 se_sess
= tv_nexus
->tvn_se_sess
;
1892 for (i
= 0; i
< TCM_VHOST_DEFAULT_TAGS
; i
++) {
1893 tv_cmd
= &((struct tcm_vhost_cmd
*)se_sess
->sess_cmd_map
)[i
];
1895 tv_cmd
->tvc_sgl
= kzalloc(sizeof(struct scatterlist
) *
1896 TCM_VHOST_PREALLOC_SGLS
, GFP_KERNEL
);
1897 if (!tv_cmd
->tvc_sgl
) {
1898 mutex_unlock(&tpg
->tv_tpg_mutex
);
1899 pr_err("Unable to allocate tv_cmd->tvc_sgl\n");
1903 tv_cmd
->tvc_upages
= kzalloc(sizeof(struct page
*) *
1904 TCM_VHOST_PREALLOC_UPAGES
, GFP_KERNEL
);
1905 if (!tv_cmd
->tvc_upages
) {
1906 mutex_unlock(&tpg
->tv_tpg_mutex
);
1907 pr_err("Unable to allocate tv_cmd->tvc_upages\n");
1911 tv_cmd
->tvc_prot_sgl
= kzalloc(sizeof(struct scatterlist
) *
1912 TCM_VHOST_PREALLOC_PROT_SGLS
, GFP_KERNEL
);
1913 if (!tv_cmd
->tvc_prot_sgl
) {
1914 mutex_unlock(&tpg
->tv_tpg_mutex
);
1915 pr_err("Unable to allocate tv_cmd->tvc_prot_sgl\n");
1920 * Since we are running in 'demo mode' this call with generate a
1921 * struct se_node_acl for the tcm_vhost struct se_portal_group with
1922 * the SCSI Initiator port name of the passed configfs group 'name'.
1924 tv_nexus
->tvn_se_sess
->se_node_acl
= core_tpg_check_initiator_node_acl(
1925 se_tpg
, (unsigned char *)name
);
1926 if (!tv_nexus
->tvn_se_sess
->se_node_acl
) {
1927 mutex_unlock(&tpg
->tv_tpg_mutex
);
1928 pr_debug("core_tpg_check_initiator_node_acl() failed"
1933 * Now register the TCM vhost virtual I_T Nexus as active with the
1934 * call to __transport_register_session()
1936 __transport_register_session(se_tpg
, tv_nexus
->tvn_se_sess
->se_node_acl
,
1937 tv_nexus
->tvn_se_sess
, tv_nexus
);
1938 tpg
->tpg_nexus
= tv_nexus
;
1940 mutex_unlock(&tpg
->tv_tpg_mutex
);
1944 tcm_vhost_free_cmd_map_res(tv_nexus
, se_sess
);
1945 transport_free_session(se_sess
);
1950 static int tcm_vhost_drop_nexus(struct tcm_vhost_tpg
*tpg
)
1952 struct se_session
*se_sess
;
1953 struct tcm_vhost_nexus
*tv_nexus
;
1955 mutex_lock(&tpg
->tv_tpg_mutex
);
1956 tv_nexus
= tpg
->tpg_nexus
;
1958 mutex_unlock(&tpg
->tv_tpg_mutex
);
1962 se_sess
= tv_nexus
->tvn_se_sess
;
1964 mutex_unlock(&tpg
->tv_tpg_mutex
);
1968 if (tpg
->tv_tpg_port_count
!= 0) {
1969 mutex_unlock(&tpg
->tv_tpg_mutex
);
1970 pr_err("Unable to remove TCM_vhost I_T Nexus with"
1971 " active TPG port count: %d\n",
1972 tpg
->tv_tpg_port_count
);
1976 if (tpg
->tv_tpg_vhost_count
!= 0) {
1977 mutex_unlock(&tpg
->tv_tpg_mutex
);
1978 pr_err("Unable to remove TCM_vhost I_T Nexus with"
1979 " active TPG vhost count: %d\n",
1980 tpg
->tv_tpg_vhost_count
);
1984 pr_debug("TCM_vhost_ConfigFS: Removing I_T Nexus to emulated"
1985 " %s Initiator Port: %s\n", tcm_vhost_dump_proto_id(tpg
->tport
),
1986 tv_nexus
->tvn_se_sess
->se_node_acl
->initiatorname
);
1988 tcm_vhost_free_cmd_map_res(tv_nexus
, se_sess
);
1990 * Release the SCSI I_T Nexus to the emulated vhost Target Port
1992 transport_deregister_session(tv_nexus
->tvn_se_sess
);
1993 tpg
->tpg_nexus
= NULL
;
1994 mutex_unlock(&tpg
->tv_tpg_mutex
);
2000 static ssize_t
tcm_vhost_tpg_show_nexus(struct se_portal_group
*se_tpg
,
2003 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
2004 struct tcm_vhost_tpg
, se_tpg
);
2005 struct tcm_vhost_nexus
*tv_nexus
;
2008 mutex_lock(&tpg
->tv_tpg_mutex
);
2009 tv_nexus
= tpg
->tpg_nexus
;
2011 mutex_unlock(&tpg
->tv_tpg_mutex
);
2014 ret
= snprintf(page
, PAGE_SIZE
, "%s\n",
2015 tv_nexus
->tvn_se_sess
->se_node_acl
->initiatorname
);
2016 mutex_unlock(&tpg
->tv_tpg_mutex
);
2021 static ssize_t
tcm_vhost_tpg_store_nexus(struct se_portal_group
*se_tpg
,
2025 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
2026 struct tcm_vhost_tpg
, se_tpg
);
2027 struct tcm_vhost_tport
*tport_wwn
= tpg
->tport
;
2028 unsigned char i_port
[TCM_VHOST_NAMELEN
], *ptr
, *port_ptr
;
2031 * Shutdown the active I_T nexus if 'NULL' is passed..
2033 if (!strncmp(page
, "NULL", 4)) {
2034 ret
= tcm_vhost_drop_nexus(tpg
);
2035 return (!ret
) ? count
: ret
;
2038 * Otherwise make sure the passed virtual Initiator port WWN matches
2039 * the fabric protocol_id set in tcm_vhost_make_tport(), and call
2040 * tcm_vhost_make_nexus().
2042 if (strlen(page
) >= TCM_VHOST_NAMELEN
) {
2043 pr_err("Emulated NAA Sas Address: %s, exceeds"
2044 " max: %d\n", page
, TCM_VHOST_NAMELEN
);
2047 snprintf(&i_port
[0], TCM_VHOST_NAMELEN
, "%s", page
);
2049 ptr
= strstr(i_port
, "naa.");
2051 if (tport_wwn
->tport_proto_id
!= SCSI_PROTOCOL_SAS
) {
2052 pr_err("Passed SAS Initiator Port %s does not"
2053 " match target port protoid: %s\n", i_port
,
2054 tcm_vhost_dump_proto_id(tport_wwn
));
2057 port_ptr
= &i_port
[0];
2060 ptr
= strstr(i_port
, "fc.");
2062 if (tport_wwn
->tport_proto_id
!= SCSI_PROTOCOL_FCP
) {
2063 pr_err("Passed FCP Initiator Port %s does not"
2064 " match target port protoid: %s\n", i_port
,
2065 tcm_vhost_dump_proto_id(tport_wwn
));
2068 port_ptr
= &i_port
[3]; /* Skip over "fc." */
2071 ptr
= strstr(i_port
, "iqn.");
2073 if (tport_wwn
->tport_proto_id
!= SCSI_PROTOCOL_ISCSI
) {
2074 pr_err("Passed iSCSI Initiator Port %s does not"
2075 " match target port protoid: %s\n", i_port
,
2076 tcm_vhost_dump_proto_id(tport_wwn
));
2079 port_ptr
= &i_port
[0];
2082 pr_err("Unable to locate prefix for emulated Initiator Port:"
2086 * Clear any trailing newline for the NAA WWN
2089 if (i_port
[strlen(i_port
)-1] == '\n')
2090 i_port
[strlen(i_port
)-1] = '\0';
2092 ret
= tcm_vhost_make_nexus(tpg
, port_ptr
);
2099 TF_TPG_BASE_ATTR(tcm_vhost
, nexus
, S_IRUGO
| S_IWUSR
);
2101 static struct configfs_attribute
*tcm_vhost_tpg_attrs
[] = {
2102 &tcm_vhost_tpg_nexus
.attr
,
2106 static struct se_portal_group
*
2107 tcm_vhost_make_tpg(struct se_wwn
*wwn
,
2108 struct config_group
*group
,
2111 struct tcm_vhost_tport
*tport
= container_of(wwn
,
2112 struct tcm_vhost_tport
, tport_wwn
);
2114 struct tcm_vhost_tpg
*tpg
;
2118 if (strstr(name
, "tpgt_") != name
)
2119 return ERR_PTR(-EINVAL
);
2120 if (kstrtoul(name
+ 5, 10, &tpgt
) || tpgt
> UINT_MAX
)
2121 return ERR_PTR(-EINVAL
);
2123 tpg
= kzalloc(sizeof(struct tcm_vhost_tpg
), GFP_KERNEL
);
2125 pr_err("Unable to allocate struct tcm_vhost_tpg");
2126 return ERR_PTR(-ENOMEM
);
2128 mutex_init(&tpg
->tv_tpg_mutex
);
2129 INIT_LIST_HEAD(&tpg
->tv_tpg_list
);
2131 tpg
->tport_tpgt
= tpgt
;
2133 ret
= core_tpg_register(&tcm_vhost_fabric_configfs
->tf_ops
, wwn
,
2134 &tpg
->se_tpg
, tpg
, TRANSPORT_TPG_TYPE_NORMAL
);
2139 mutex_lock(&tcm_vhost_mutex
);
2140 list_add_tail(&tpg
->tv_tpg_list
, &tcm_vhost_list
);
2141 mutex_unlock(&tcm_vhost_mutex
);
2143 return &tpg
->se_tpg
;
2146 static void tcm_vhost_drop_tpg(struct se_portal_group
*se_tpg
)
2148 struct tcm_vhost_tpg
*tpg
= container_of(se_tpg
,
2149 struct tcm_vhost_tpg
, se_tpg
);
2151 mutex_lock(&tcm_vhost_mutex
);
2152 list_del(&tpg
->tv_tpg_list
);
2153 mutex_unlock(&tcm_vhost_mutex
);
2155 * Release the virtual I_T Nexus for this vhost TPG
2157 tcm_vhost_drop_nexus(tpg
);
2159 * Deregister the se_tpg from TCM..
2161 core_tpg_deregister(se_tpg
);
2165 static struct se_wwn
*
2166 tcm_vhost_make_tport(struct target_fabric_configfs
*tf
,
2167 struct config_group
*group
,
2170 struct tcm_vhost_tport
*tport
;
2175 /* if (tcm_vhost_parse_wwn(name, &wwpn, 1) < 0)
2176 return ERR_PTR(-EINVAL); */
2178 tport
= kzalloc(sizeof(struct tcm_vhost_tport
), GFP_KERNEL
);
2180 pr_err("Unable to allocate struct tcm_vhost_tport");
2181 return ERR_PTR(-ENOMEM
);
2183 tport
->tport_wwpn
= wwpn
;
2185 * Determine the emulated Protocol Identifier and Target Port Name
2186 * based on the incoming configfs directory name.
2188 ptr
= strstr(name
, "naa.");
2190 tport
->tport_proto_id
= SCSI_PROTOCOL_SAS
;
2193 ptr
= strstr(name
, "fc.");
2195 tport
->tport_proto_id
= SCSI_PROTOCOL_FCP
;
2196 off
= 3; /* Skip over "fc." */
2199 ptr
= strstr(name
, "iqn.");
2201 tport
->tport_proto_id
= SCSI_PROTOCOL_ISCSI
;
2205 pr_err("Unable to locate prefix for emulated Target Port:"
2208 return ERR_PTR(-EINVAL
);
2211 if (strlen(name
) >= TCM_VHOST_NAMELEN
) {
2212 pr_err("Emulated %s Address: %s, exceeds"
2213 " max: %d\n", name
, tcm_vhost_dump_proto_id(tport
),
2216 return ERR_PTR(-EINVAL
);
2218 snprintf(&tport
->tport_name
[0], TCM_VHOST_NAMELEN
, "%s", &name
[off
]);
2220 pr_debug("TCM_VHost_ConfigFS: Allocated emulated Target"
2221 " %s Address: %s\n", tcm_vhost_dump_proto_id(tport
), name
);
2223 return &tport
->tport_wwn
;
2226 static void tcm_vhost_drop_tport(struct se_wwn
*wwn
)
2228 struct tcm_vhost_tport
*tport
= container_of(wwn
,
2229 struct tcm_vhost_tport
, tport_wwn
);
2231 pr_debug("TCM_VHost_ConfigFS: Deallocating emulated Target"
2232 " %s Address: %s\n", tcm_vhost_dump_proto_id(tport
),
2239 tcm_vhost_wwn_show_attr_version(struct target_fabric_configfs
*tf
,
2242 return sprintf(page
, "TCM_VHOST fabric module %s on %s/%s"
2243 "on "UTS_RELEASE
"\n", TCM_VHOST_VERSION
, utsname()->sysname
,
2244 utsname()->machine
);
2247 TF_WWN_ATTR_RO(tcm_vhost
, version
);
2249 static struct configfs_attribute
*tcm_vhost_wwn_attrs
[] = {
2250 &tcm_vhost_wwn_version
.attr
,
2254 static struct target_core_fabric_ops tcm_vhost_ops
= {
2255 .get_fabric_name
= tcm_vhost_get_fabric_name
,
2256 .get_fabric_proto_ident
= tcm_vhost_get_fabric_proto_ident
,
2257 .tpg_get_wwn
= tcm_vhost_get_fabric_wwn
,
2258 .tpg_get_tag
= tcm_vhost_get_tag
,
2259 .tpg_get_default_depth
= tcm_vhost_get_default_depth
,
2260 .tpg_get_pr_transport_id
= tcm_vhost_get_pr_transport_id
,
2261 .tpg_get_pr_transport_id_len
= tcm_vhost_get_pr_transport_id_len
,
2262 .tpg_parse_pr_out_transport_id
= tcm_vhost_parse_pr_out_transport_id
,
2263 .tpg_check_demo_mode
= tcm_vhost_check_true
,
2264 .tpg_check_demo_mode_cache
= tcm_vhost_check_true
,
2265 .tpg_check_demo_mode_write_protect
= tcm_vhost_check_false
,
2266 .tpg_check_prod_mode_write_protect
= tcm_vhost_check_false
,
2267 .tpg_alloc_fabric_acl
= tcm_vhost_alloc_fabric_acl
,
2268 .tpg_release_fabric_acl
= tcm_vhost_release_fabric_acl
,
2269 .tpg_get_inst_index
= tcm_vhost_tpg_get_inst_index
,
2270 .release_cmd
= tcm_vhost_release_cmd
,
2271 .check_stop_free
= vhost_scsi_check_stop_free
,
2272 .shutdown_session
= tcm_vhost_shutdown_session
,
2273 .close_session
= tcm_vhost_close_session
,
2274 .sess_get_index
= tcm_vhost_sess_get_index
,
2275 .sess_get_initiator_sid
= NULL
,
2276 .write_pending
= tcm_vhost_write_pending
,
2277 .write_pending_status
= tcm_vhost_write_pending_status
,
2278 .set_default_node_attributes
= tcm_vhost_set_default_node_attrs
,
2279 .get_task_tag
= tcm_vhost_get_task_tag
,
2280 .get_cmd_state
= tcm_vhost_get_cmd_state
,
2281 .queue_data_in
= tcm_vhost_queue_data_in
,
2282 .queue_status
= tcm_vhost_queue_status
,
2283 .queue_tm_rsp
= tcm_vhost_queue_tm_rsp
,
2284 .aborted_task
= tcm_vhost_aborted_task
,
2286 * Setup callers for generic logic in target_core_fabric_configfs.c
2288 .fabric_make_wwn
= tcm_vhost_make_tport
,
2289 .fabric_drop_wwn
= tcm_vhost_drop_tport
,
2290 .fabric_make_tpg
= tcm_vhost_make_tpg
,
2291 .fabric_drop_tpg
= tcm_vhost_drop_tpg
,
2292 .fabric_post_link
= tcm_vhost_port_link
,
2293 .fabric_pre_unlink
= tcm_vhost_port_unlink
,
2294 .fabric_make_np
= NULL
,
2295 .fabric_drop_np
= NULL
,
2296 .fabric_make_nodeacl
= tcm_vhost_make_nodeacl
,
2297 .fabric_drop_nodeacl
= tcm_vhost_drop_nodeacl
,
2300 static int tcm_vhost_register_configfs(void)
2302 struct target_fabric_configfs
*fabric
;
2305 pr_debug("TCM_VHOST fabric module %s on %s/%s"
2306 " on "UTS_RELEASE
"\n", TCM_VHOST_VERSION
, utsname()->sysname
,
2307 utsname()->machine
);
2309 * Register the top level struct config_item_type with TCM core
2311 fabric
= target_fabric_configfs_init(THIS_MODULE
, "vhost");
2312 if (IS_ERR(fabric
)) {
2313 pr_err("target_fabric_configfs_init() failed\n");
2314 return PTR_ERR(fabric
);
2317 * Setup fabric->tf_ops from our local tcm_vhost_ops
2319 fabric
->tf_ops
= tcm_vhost_ops
;
2321 * Setup default attribute lists for various fabric->tf_cit_tmpl
2323 fabric
->tf_cit_tmpl
.tfc_wwn_cit
.ct_attrs
= tcm_vhost_wwn_attrs
;
2324 fabric
->tf_cit_tmpl
.tfc_tpg_base_cit
.ct_attrs
= tcm_vhost_tpg_attrs
;
2325 fabric
->tf_cit_tmpl
.tfc_tpg_attrib_cit
.ct_attrs
= NULL
;
2326 fabric
->tf_cit_tmpl
.tfc_tpg_param_cit
.ct_attrs
= NULL
;
2327 fabric
->tf_cit_tmpl
.tfc_tpg_np_base_cit
.ct_attrs
= NULL
;
2328 fabric
->tf_cit_tmpl
.tfc_tpg_nacl_base_cit
.ct_attrs
= NULL
;
2329 fabric
->tf_cit_tmpl
.tfc_tpg_nacl_attrib_cit
.ct_attrs
= NULL
;
2330 fabric
->tf_cit_tmpl
.tfc_tpg_nacl_auth_cit
.ct_attrs
= NULL
;
2331 fabric
->tf_cit_tmpl
.tfc_tpg_nacl_param_cit
.ct_attrs
= NULL
;
2333 * Register the fabric for use within TCM
2335 ret
= target_fabric_configfs_register(fabric
);
2337 pr_err("target_fabric_configfs_register() failed"
2338 " for TCM_VHOST\n");
2342 * Setup our local pointer to *fabric
2344 tcm_vhost_fabric_configfs
= fabric
;
2345 pr_debug("TCM_VHOST[0] - Set fabric -> tcm_vhost_fabric_configfs\n");
2349 static void tcm_vhost_deregister_configfs(void)
2351 if (!tcm_vhost_fabric_configfs
)
2354 target_fabric_configfs_deregister(tcm_vhost_fabric_configfs
);
2355 tcm_vhost_fabric_configfs
= NULL
;
2356 pr_debug("TCM_VHOST[0] - Cleared tcm_vhost_fabric_configfs\n");
2359 static int __init
tcm_vhost_init(void)
2363 * Use our own dedicated workqueue for submitting I/O into
2364 * target core to avoid contention within system_wq.
2366 tcm_vhost_workqueue
= alloc_workqueue("tcm_vhost", 0, 0);
2367 if (!tcm_vhost_workqueue
)
2370 ret
= vhost_scsi_register();
2372 goto out_destroy_workqueue
;
2374 ret
= tcm_vhost_register_configfs();
2376 goto out_vhost_scsi_deregister
;
2380 out_vhost_scsi_deregister
:
2381 vhost_scsi_deregister();
2382 out_destroy_workqueue
:
2383 destroy_workqueue(tcm_vhost_workqueue
);
2388 static void tcm_vhost_exit(void)
2390 tcm_vhost_deregister_configfs();
2391 vhost_scsi_deregister();
2392 destroy_workqueue(tcm_vhost_workqueue
);
2395 MODULE_DESCRIPTION("VHOST_SCSI series fabric driver");
2396 MODULE_ALIAS("tcm_vhost");
2397 MODULE_LICENSE("GPL");
2398 module_init(tcm_vhost_init
);
2399 module_exit(tcm_vhost_exit
);