1130f4520SKenneth D. Merry /*-
24d846d26SWarner Losh * SPDX-License-Identifier: BSD-2-Clause
3bec9534dSPedro F. Giffuni *
4130f4520SKenneth D. Merry * Copyright (c) 2003, 2008 Silicon Graphics International Corp.
581177295SEdward Tomasz Napierala * Copyright (c) 2012 The FreeBSD Foundation
6e7037673SAlexander Motin * Copyright (c) 2014-2017 Alexander Motin <mav@FreeBSD.org>
7130f4520SKenneth D. Merry * All rights reserved.
8130f4520SKenneth D. Merry *
981177295SEdward Tomasz Napierala * Portions of this software were developed by Edward Tomasz Napierala
1081177295SEdward Tomasz Napierala * under sponsorship from the FreeBSD Foundation.
1181177295SEdward Tomasz Napierala *
12130f4520SKenneth D. Merry * Redistribution and use in source and binary forms, with or without
13130f4520SKenneth D. Merry * modification, are permitted provided that the following conditions
14130f4520SKenneth D. Merry * are met:
15130f4520SKenneth D. Merry * 1. Redistributions of source code must retain the above copyright
16130f4520SKenneth D. Merry * notice, this list of conditions, and the following disclaimer,
17130f4520SKenneth D. Merry * without modification.
18130f4520SKenneth D. Merry * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19130f4520SKenneth D. Merry * substantially similar to the "NO WARRANTY" disclaimer below
20130f4520SKenneth D. Merry * ("Disclaimer") and any redistribution must be conditioned upon
21130f4520SKenneth D. Merry * including a substantially similar Disclaimer requirement for further
22130f4520SKenneth D. Merry * binary redistribution.
23130f4520SKenneth D. Merry *
24130f4520SKenneth D. Merry * NO WARRANTY
25130f4520SKenneth D. Merry * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26130f4520SKenneth D. Merry * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27130f4520SKenneth D. Merry * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
28130f4520SKenneth D. Merry * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29130f4520SKenneth D. Merry * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30130f4520SKenneth D. Merry * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31130f4520SKenneth D. Merry * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32130f4520SKenneth D. Merry * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
33130f4520SKenneth D. Merry * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
34130f4520SKenneth D. Merry * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35130f4520SKenneth D. Merry * POSSIBILITY OF SUCH DAMAGES.
36130f4520SKenneth D. Merry *
37130f4520SKenneth D. Merry * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_backend_ramdisk.c#3 $
38130f4520SKenneth D. Merry */
39130f4520SKenneth D. Merry /*
40e7037673SAlexander Motin * CAM Target Layer black hole and RAM disk backend.
41130f4520SKenneth D. Merry *
42130f4520SKenneth D. Merry * Author: Ken Merry <ken@FreeBSD.org>
43130f4520SKenneth D. Merry */
44130f4520SKenneth D. Merry
45130f4520SKenneth D. Merry #include <sys/param.h>
46130f4520SKenneth D. Merry #include <sys/systm.h>
47130f4520SKenneth D. Merry #include <sys/kernel.h>
48130f4520SKenneth D. Merry #include <sys/condvar.h>
49130f4520SKenneth D. Merry #include <sys/types.h>
50e7037673SAlexander Motin #include <sys/limits.h>
51130f4520SKenneth D. Merry #include <sys/lock.h>
52130f4520SKenneth D. Merry #include <sys/mutex.h>
53130f4520SKenneth D. Merry #include <sys/malloc.h>
54e7037673SAlexander Motin #include <sys/sx.h>
5508a7cce5SAlexander Motin #include <sys/taskqueue.h>
56130f4520SKenneth D. Merry #include <sys/time.h>
57130f4520SKenneth D. Merry #include <sys/queue.h>
58130f4520SKenneth D. Merry #include <sys/conf.h>
59130f4520SKenneth D. Merry #include <sys/ioccom.h>
60130f4520SKenneth D. Merry #include <sys/module.h>
617ac58230SAlexander Motin #include <sys/sysctl.h>
628951f055SMarcelo Araujo #include <sys/nv.h>
638951f055SMarcelo Araujo #include <sys/dnv.h>
64130f4520SKenneth D. Merry
65130f4520SKenneth D. Merry #include <cam/scsi/scsi_all.h>
667ac58230SAlexander Motin #include <cam/scsi/scsi_da.h>
67130f4520SKenneth D. Merry #include <cam/ctl/ctl_io.h>
68130f4520SKenneth D. Merry #include <cam/ctl/ctl.h>
69130f4520SKenneth D. Merry #include <cam/ctl/ctl_util.h>
70130f4520SKenneth D. Merry #include <cam/ctl/ctl_backend.h>
71130f4520SKenneth D. Merry #include <cam/ctl/ctl_debug.h>
72130f4520SKenneth D. Merry #include <cam/ctl/ctl_ioctl.h>
737ac58230SAlexander Motin #include <cam/ctl/ctl_ha.h>
747ac58230SAlexander Motin #include <cam/ctl/ctl_private.h>
75130f4520SKenneth D. Merry #include <cam/ctl/ctl_error.h>
76130f4520SKenneth D. Merry
77e7037673SAlexander Motin #define PRIV(io) \
78e7037673SAlexander Motin ((struct ctl_ptr_len_flags *)&(io)->io_hdr.ctl_private[CTL_PRIV_BACKEND])
79e7037673SAlexander Motin #define ARGS(io) \
80e7037673SAlexander Motin ((struct ctl_lba_len_flags *)&(io)->io_hdr.ctl_private[CTL_PRIV_LBA_LEN])
81e7037673SAlexander Motin
82e7037673SAlexander Motin #define PPP (PAGE_SIZE / sizeof(uint8_t **))
83e7037673SAlexander Motin #ifdef __LP64__
84e7037673SAlexander Motin #define PPPS (PAGE_SHIFT - 3)
85e7037673SAlexander Motin #else
86e7037673SAlexander Motin #define PPPS (PAGE_SHIFT - 2)
87e7037673SAlexander Motin #endif
88e7037673SAlexander Motin #define SGPP (PAGE_SIZE / sizeof(struct ctl_sg_entry))
89e7037673SAlexander Motin
90e7037673SAlexander Motin #define P_UNMAPPED NULL /* Page is unmapped. */
91e7037673SAlexander Motin #define P_ANCHORED ((void *)(uintptr_t)1) /* Page is anchored. */
92e7037673SAlexander Motin
93e7037673SAlexander Motin typedef enum {
94e7037673SAlexander Motin GP_READ, /* Return data page or zero page. */
95e7037673SAlexander Motin GP_WRITE, /* Return data page, try allocate if none. */
96e7037673SAlexander Motin GP_ANCHOR, /* Return data page, try anchor if none. */
97e7037673SAlexander Motin GP_OTHER, /* Return what present, do not allocate/anchor. */
98e7037673SAlexander Motin } getpage_op_t;
99e7037673SAlexander Motin
100130f4520SKenneth D. Merry typedef enum {
101130f4520SKenneth D. Merry CTL_BE_RAMDISK_LUN_UNCONFIGURED = 0x01,
102130f4520SKenneth D. Merry CTL_BE_RAMDISK_LUN_WAITING = 0x04
103130f4520SKenneth D. Merry } ctl_be_ramdisk_lun_flags;
104130f4520SKenneth D. Merry
105130f4520SKenneth D. Merry struct ctl_be_ramdisk_lun {
106767300e8SAlexander Motin struct ctl_be_lun cbe_lun; /* Must be first element. */
107a3977beaSAlexander Motin struct ctl_lun_create_params params;
108e7037673SAlexander Motin int indir;
109e7037673SAlexander Motin uint8_t **pages;
110e7037673SAlexander Motin uint8_t *zero_page;
111e7037673SAlexander Motin struct sx page_lock;
112e7037673SAlexander Motin u_int pblocksize;
113e7037673SAlexander Motin u_int pblockmul;
114130f4520SKenneth D. Merry uint64_t size_bytes;
115130f4520SKenneth D. Merry uint64_t size_blocks;
116e7037673SAlexander Motin uint64_t cap_bytes;
117e7037673SAlexander Motin uint64_t cap_used;
118130f4520SKenneth D. Merry struct ctl_be_ramdisk_softc *softc;
119130f4520SKenneth D. Merry ctl_be_ramdisk_lun_flags flags;
12034144c2cSAlexander Motin SLIST_ENTRY(ctl_be_ramdisk_lun) links;
12108a7cce5SAlexander Motin struct taskqueue *io_taskqueue;
12208a7cce5SAlexander Motin struct task io_task;
12308a7cce5SAlexander Motin STAILQ_HEAD(, ctl_io_hdr) cont_queue;
12475c7a1d3SAlexander Motin struct mtx_padalign queue_lock;
125130f4520SKenneth D. Merry };
126130f4520SKenneth D. Merry
127130f4520SKenneth D. Merry struct ctl_be_ramdisk_softc {
12834144c2cSAlexander Motin struct sx modify_lock;
129130f4520SKenneth D. Merry struct mtx lock;
130130f4520SKenneth D. Merry int num_luns;
13134144c2cSAlexander Motin SLIST_HEAD(, ctl_be_ramdisk_lun) lun_list;
132130f4520SKenneth D. Merry };
133130f4520SKenneth D. Merry
134130f4520SKenneth D. Merry static struct ctl_be_ramdisk_softc rd_softc;
1357ac58230SAlexander Motin extern struct ctl_softc *control_softc;
136130f4520SKenneth D. Merry
1370c629e28SAlexander Motin static int ctl_backend_ramdisk_init(void);
1380c629e28SAlexander Motin static int ctl_backend_ramdisk_shutdown(void);
1392c7dc6baSAlexander Motin static int ctl_backend_ramdisk_move_done(union ctl_io *io, bool samethr);
140e7037673SAlexander Motin static void ctl_backend_ramdisk_compare(union ctl_io *io);
141e7037673SAlexander Motin static void ctl_backend_ramdisk_rw(union ctl_io *io);
142130f4520SKenneth D. Merry static int ctl_backend_ramdisk_submit(union ctl_io *io);
143e7037673SAlexander Motin static void ctl_backend_ramdisk_worker(void *context, int pending);
144e7037673SAlexander Motin static int ctl_backend_ramdisk_config_read(union ctl_io *io);
145e7037673SAlexander Motin static int ctl_backend_ramdisk_config_write(union ctl_io *io);
146767300e8SAlexander Motin static uint64_t ctl_backend_ramdisk_lun_attr(struct ctl_be_lun *cbe_lun, const char *attrname);
147130f4520SKenneth D. Merry static int ctl_backend_ramdisk_ioctl(struct cdev *dev, u_long cmd,
148130f4520SKenneth D. Merry caddr_t addr, int flag, struct thread *td);
149130f4520SKenneth D. Merry static int ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
150130f4520SKenneth D. Merry struct ctl_lun_req *req);
151130f4520SKenneth D. Merry static int ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
1520bcd4ab6SAlexander Motin struct ctl_lun_req *req);
15381177295SEdward Tomasz Napierala static int ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc *softc,
15481177295SEdward Tomasz Napierala struct ctl_lun_req *req);
155767300e8SAlexander Motin static void ctl_backend_ramdisk_lun_shutdown(struct ctl_be_lun *cbe_lun);
156130f4520SKenneth D. Merry
157130f4520SKenneth D. Merry static struct ctl_backend_driver ctl_be_ramdisk_driver =
158130f4520SKenneth D. Merry {
1592a2443d8SKenneth D. Merry .name = "ramdisk",
1602a2443d8SKenneth D. Merry .flags = CTL_BE_FLAG_HAS_CONFIG,
1612a2443d8SKenneth D. Merry .init = ctl_backend_ramdisk_init,
1620c629e28SAlexander Motin .shutdown = ctl_backend_ramdisk_shutdown,
1632a2443d8SKenneth D. Merry .data_submit = ctl_backend_ramdisk_submit,
1642a2443d8SKenneth D. Merry .config_read = ctl_backend_ramdisk_config_read,
1652a2443d8SKenneth D. Merry .config_write = ctl_backend_ramdisk_config_write,
166e7037673SAlexander Motin .ioctl = ctl_backend_ramdisk_ioctl,
167e7037673SAlexander Motin .lun_attr = ctl_backend_ramdisk_lun_attr,
168130f4520SKenneth D. Merry };
169130f4520SKenneth D. Merry
17034144c2cSAlexander Motin MALLOC_DEFINE(M_RAMDISK, "ctlramdisk", "Memory used for CTL RAMdisk");
171130f4520SKenneth D. Merry CTL_BACKEND_DECLARE(cbr, ctl_be_ramdisk_driver);
172130f4520SKenneth D. Merry
173e7037673SAlexander Motin static int
ctl_backend_ramdisk_init(void)174130f4520SKenneth D. Merry ctl_backend_ramdisk_init(void)
175130f4520SKenneth D. Merry {
17667cc546dSAlexander Motin struct ctl_be_ramdisk_softc *softc = &rd_softc;
177130f4520SKenneth D. Merry
178130f4520SKenneth D. Merry memset(softc, 0, sizeof(*softc));
17934144c2cSAlexander Motin sx_init(&softc->modify_lock, "ctlrammod");
18034144c2cSAlexander Motin mtx_init(&softc->lock, "ctlram", NULL, MTX_DEF);
18134144c2cSAlexander Motin SLIST_INIT(&softc->lun_list);
182130f4520SKenneth D. Merry return (0);
183130f4520SKenneth D. Merry }
184130f4520SKenneth D. Merry
1850c629e28SAlexander Motin static int
ctl_backend_ramdisk_shutdown(void)186130f4520SKenneth D. Merry ctl_backend_ramdisk_shutdown(void)
187130f4520SKenneth D. Merry {
18867cc546dSAlexander Motin struct ctl_be_ramdisk_softc *softc = &rd_softc;
18934144c2cSAlexander Motin struct ctl_be_ramdisk_lun *lun;
190130f4520SKenneth D. Merry
191130f4520SKenneth D. Merry mtx_lock(&softc->lock);
19234144c2cSAlexander Motin while ((lun = SLIST_FIRST(&softc->lun_list)) != NULL) {
19334144c2cSAlexander Motin SLIST_REMOVE_HEAD(&softc->lun_list, links);
19434144c2cSAlexander Motin softc->num_luns--;
195130f4520SKenneth D. Merry /*
19634144c2cSAlexander Motin * Drop our lock here. Since ctl_remove_lun() can call
197130f4520SKenneth D. Merry * back into us, this could potentially lead to a recursive
198130f4520SKenneth D. Merry * lock of the same mutex, which would cause a hang.
199130f4520SKenneth D. Merry */
200130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
20134144c2cSAlexander Motin ctl_remove_lun(&lun->cbe_lun);
202130f4520SKenneth D. Merry mtx_lock(&softc->lock);
203130f4520SKenneth D. Merry }
204130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
2050c629e28SAlexander Motin mtx_destroy(&softc->lock);
20634144c2cSAlexander Motin sx_destroy(&softc->modify_lock);
2070c629e28SAlexander Motin return (0);
208130f4520SKenneth D. Merry }
209130f4520SKenneth D. Merry
210e7037673SAlexander Motin static uint8_t *
ctl_backend_ramdisk_getpage(struct ctl_be_ramdisk_lun * be_lun,off_t pn,getpage_op_t op)211e7037673SAlexander Motin ctl_backend_ramdisk_getpage(struct ctl_be_ramdisk_lun *be_lun, off_t pn,
212e7037673SAlexander Motin getpage_op_t op)
213e7037673SAlexander Motin {
214e7037673SAlexander Motin uint8_t **p, ***pp;
215e7037673SAlexander Motin off_t i;
216e7037673SAlexander Motin int s;
217e7037673SAlexander Motin
218e7037673SAlexander Motin if (be_lun->cap_bytes == 0) {
219e7037673SAlexander Motin switch (op) {
220e7037673SAlexander Motin case GP_READ:
221e7037673SAlexander Motin return (be_lun->zero_page);
222e7037673SAlexander Motin case GP_WRITE:
223e7037673SAlexander Motin return ((uint8_t *)be_lun->pages);
224e7037673SAlexander Motin case GP_ANCHOR:
225e7037673SAlexander Motin return (P_ANCHORED);
226e7037673SAlexander Motin default:
227e7037673SAlexander Motin return (P_UNMAPPED);
228e7037673SAlexander Motin }
229e7037673SAlexander Motin }
230e7037673SAlexander Motin if (op == GP_WRITE || op == GP_ANCHOR) {
231e7037673SAlexander Motin sx_xlock(&be_lun->page_lock);
232e7037673SAlexander Motin pp = &be_lun->pages;
233e7037673SAlexander Motin for (s = (be_lun->indir - 1) * PPPS; s >= 0; s -= PPPS) {
234e7037673SAlexander Motin if (*pp == NULL) {
235e7037673SAlexander Motin *pp = malloc(PAGE_SIZE, M_RAMDISK,
236e7037673SAlexander Motin M_WAITOK|M_ZERO);
237e7037673SAlexander Motin }
238e7037673SAlexander Motin i = pn >> s;
239e7037673SAlexander Motin pp = (uint8_t ***)&(*pp)[i];
240e7037673SAlexander Motin pn -= i << s;
241e7037673SAlexander Motin }
242e7037673SAlexander Motin if (*pp == P_UNMAPPED && be_lun->cap_used < be_lun->cap_bytes) {
243e7037673SAlexander Motin if (op == GP_WRITE) {
244e7037673SAlexander Motin *pp = malloc(be_lun->pblocksize, M_RAMDISK,
245e7037673SAlexander Motin M_WAITOK|M_ZERO);
246e7037673SAlexander Motin } else
247e7037673SAlexander Motin *pp = P_ANCHORED;
248e7037673SAlexander Motin be_lun->cap_used += be_lun->pblocksize;
249e7037673SAlexander Motin } else if (*pp == P_ANCHORED && op == GP_WRITE) {
250e7037673SAlexander Motin *pp = malloc(be_lun->pblocksize, M_RAMDISK,
251e7037673SAlexander Motin M_WAITOK|M_ZERO);
252e7037673SAlexander Motin }
253e7037673SAlexander Motin sx_xunlock(&be_lun->page_lock);
254e7037673SAlexander Motin return ((uint8_t *)*pp);
255e7037673SAlexander Motin } else {
256e7037673SAlexander Motin sx_slock(&be_lun->page_lock);
257e7037673SAlexander Motin p = be_lun->pages;
258e7037673SAlexander Motin for (s = (be_lun->indir - 1) * PPPS; s >= 0; s -= PPPS) {
259e7037673SAlexander Motin if (p == NULL)
260e7037673SAlexander Motin break;
261e7037673SAlexander Motin i = pn >> s;
262e7037673SAlexander Motin p = (uint8_t **)p[i];
263e7037673SAlexander Motin pn -= i << s;
264e7037673SAlexander Motin }
265e7037673SAlexander Motin sx_sunlock(&be_lun->page_lock);
266e7037673SAlexander Motin if ((p == P_UNMAPPED || p == P_ANCHORED) && op == GP_READ)
267e7037673SAlexander Motin return (be_lun->zero_page);
268e7037673SAlexander Motin return ((uint8_t *)p);
269e7037673SAlexander Motin }
270e7037673SAlexander Motin };
271e7037673SAlexander Motin
272e7037673SAlexander Motin static void
ctl_backend_ramdisk_unmappage(struct ctl_be_ramdisk_lun * be_lun,off_t pn)273e7037673SAlexander Motin ctl_backend_ramdisk_unmappage(struct ctl_be_ramdisk_lun *be_lun, off_t pn)
274e7037673SAlexander Motin {
275e7037673SAlexander Motin uint8_t ***pp;
276e7037673SAlexander Motin off_t i;
277e7037673SAlexander Motin int s;
278e7037673SAlexander Motin
279e7037673SAlexander Motin if (be_lun->cap_bytes == 0)
280e7037673SAlexander Motin return;
281e7037673SAlexander Motin sx_xlock(&be_lun->page_lock);
282e7037673SAlexander Motin pp = &be_lun->pages;
283e7037673SAlexander Motin for (s = (be_lun->indir - 1) * PPPS; s >= 0; s -= PPPS) {
284e7037673SAlexander Motin if (*pp == NULL)
285e7037673SAlexander Motin goto noindir;
286e7037673SAlexander Motin i = pn >> s;
287e7037673SAlexander Motin pp = (uint8_t ***)&(*pp)[i];
288e7037673SAlexander Motin pn -= i << s;
289e7037673SAlexander Motin }
290e7037673SAlexander Motin if (*pp == P_ANCHORED) {
291e7037673SAlexander Motin be_lun->cap_used -= be_lun->pblocksize;
292e7037673SAlexander Motin *pp = P_UNMAPPED;
293e7037673SAlexander Motin } else if (*pp != P_UNMAPPED) {
294e7037673SAlexander Motin free(*pp, M_RAMDISK);
295e7037673SAlexander Motin be_lun->cap_used -= be_lun->pblocksize;
296e7037673SAlexander Motin *pp = P_UNMAPPED;
297e7037673SAlexander Motin }
298e7037673SAlexander Motin noindir:
299e7037673SAlexander Motin sx_xunlock(&be_lun->page_lock);
300e7037673SAlexander Motin };
301e7037673SAlexander Motin
302e7037673SAlexander Motin static void
ctl_backend_ramdisk_anchorpage(struct ctl_be_ramdisk_lun * be_lun,off_t pn)303e7037673SAlexander Motin ctl_backend_ramdisk_anchorpage(struct ctl_be_ramdisk_lun *be_lun, off_t pn)
304e7037673SAlexander Motin {
305e7037673SAlexander Motin uint8_t ***pp;
306e7037673SAlexander Motin off_t i;
307e7037673SAlexander Motin int s;
308e7037673SAlexander Motin
309e7037673SAlexander Motin if (be_lun->cap_bytes == 0)
310e7037673SAlexander Motin return;
311e7037673SAlexander Motin sx_xlock(&be_lun->page_lock);
312e7037673SAlexander Motin pp = &be_lun->pages;
313e7037673SAlexander Motin for (s = (be_lun->indir - 1) * PPPS; s >= 0; s -= PPPS) {
314e7037673SAlexander Motin if (*pp == NULL)
315e7037673SAlexander Motin goto noindir;
316e7037673SAlexander Motin i = pn >> s;
317e7037673SAlexander Motin pp = (uint8_t ***)&(*pp)[i];
318e7037673SAlexander Motin pn -= i << s;
319e7037673SAlexander Motin }
320e7037673SAlexander Motin if (*pp == P_UNMAPPED && be_lun->cap_used < be_lun->cap_bytes) {
321e7037673SAlexander Motin be_lun->cap_used += be_lun->pblocksize;
322e7037673SAlexander Motin *pp = P_ANCHORED;
323e7037673SAlexander Motin } else if (*pp != P_ANCHORED) {
324e7037673SAlexander Motin free(*pp, M_RAMDISK);
325e7037673SAlexander Motin *pp = P_ANCHORED;
326e7037673SAlexander Motin }
327e7037673SAlexander Motin noindir:
328e7037673SAlexander Motin sx_xunlock(&be_lun->page_lock);
329e7037673SAlexander Motin };
330e7037673SAlexander Motin
331e7037673SAlexander Motin static void
ctl_backend_ramdisk_freeallpages(uint8_t ** p,int indir)332e7037673SAlexander Motin ctl_backend_ramdisk_freeallpages(uint8_t **p, int indir)
333e7037673SAlexander Motin {
334e7037673SAlexander Motin int i;
335e7037673SAlexander Motin
336e7037673SAlexander Motin if (p == NULL)
337e7037673SAlexander Motin return;
338e7037673SAlexander Motin if (indir == 0) {
339e7037673SAlexander Motin free(p, M_RAMDISK);
340e7037673SAlexander Motin return;
341e7037673SAlexander Motin }
342e7037673SAlexander Motin for (i = 0; i < PPP; i++) {
343e7037673SAlexander Motin if (p[i] == NULL)
344e7037673SAlexander Motin continue;
345e7037673SAlexander Motin ctl_backend_ramdisk_freeallpages((uint8_t **)p[i], indir - 1);
346e7037673SAlexander Motin }
347e7037673SAlexander Motin free(p, M_RAMDISK);
348e7037673SAlexander Motin };
349e7037673SAlexander Motin
350e7037673SAlexander Motin static size_t
cmp(uint8_t * a,uint8_t * b,size_t size)351e7037673SAlexander Motin cmp(uint8_t *a, uint8_t *b, size_t size)
352e7037673SAlexander Motin {
353e7037673SAlexander Motin size_t i;
354e7037673SAlexander Motin
355e7037673SAlexander Motin for (i = 0; i < size; i++) {
356e7037673SAlexander Motin if (a[i] != b[i])
357e7037673SAlexander Motin break;
358e7037673SAlexander Motin }
359e7037673SAlexander Motin return (i);
360e7037673SAlexander Motin }
361e7037673SAlexander Motin
362e7037673SAlexander Motin static int
ctl_backend_ramdisk_cmp(union ctl_io * io)363e7037673SAlexander Motin ctl_backend_ramdisk_cmp(union ctl_io *io)
364e7037673SAlexander Motin {
365e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
366767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
367e7037673SAlexander Motin uint8_t *page;
368e7037673SAlexander Motin uint64_t lba;
369e7037673SAlexander Motin u_int lbaoff, lbas, res, off;
370e7037673SAlexander Motin
371ccaaee46SJohn Baldwin lbas = ctl_kern_data_len(io) / cbe_lun->blocksize;
372e7037673SAlexander Motin lba = ARGS(io)->lba + PRIV(io)->len - lbas;
373e7037673SAlexander Motin off = 0;
374e7037673SAlexander Motin for (; lbas > 0; lbas--, lba++) {
375e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun,
376e7037673SAlexander Motin lba >> cbe_lun->pblockexp, GP_READ);
377e7037673SAlexander Motin lbaoff = lba & ~(UINT_MAX << cbe_lun->pblockexp);
378e7037673SAlexander Motin page += lbaoff * cbe_lun->blocksize;
379ccaaee46SJohn Baldwin res = cmp(ctl_kern_data_ptr(io) + off, page,
380e7037673SAlexander Motin cbe_lun->blocksize);
381e7037673SAlexander Motin off += res;
382e7037673SAlexander Motin if (res < cbe_lun->blocksize)
383e7037673SAlexander Motin break;
384e7037673SAlexander Motin }
385bd6e8729SJohn Baldwin free(io->scsiio.kern_data_ptr, M_RAMDISK);
386e7037673SAlexander Motin if (lbas > 0) {
387ccaaee46SJohn Baldwin off += ctl_kern_rel_offset(io) - ctl_kern_data_len(io);
388ccaaee46SJohn Baldwin ctl_io_set_compare_failure(io, off);
389e7037673SAlexander Motin return (1);
390e7037673SAlexander Motin }
391e7037673SAlexander Motin return (0);
392e7037673SAlexander Motin }
393e7037673SAlexander Motin
394130f4520SKenneth D. Merry static int
ctl_backend_ramdisk_move_done(union ctl_io * io,bool samethr)3952c7dc6baSAlexander Motin ctl_backend_ramdisk_move_done(union ctl_io *io, bool samethr)
396130f4520SKenneth D. Merry {
397767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun =
398767300e8SAlexander Motin (struct ctl_be_ramdisk_lun *)CTL_BACKEND_LUN(io);
399130f4520SKenneth D. Merry
400130f4520SKenneth D. Merry CTL_DEBUG_PRINT(("ctl_backend_ramdisk_move_done\n"));
401ccaaee46SJohn Baldwin if (ctl_kern_sg_entries(io) > 0)
402ccaaee46SJohn Baldwin free(ctl_kern_data_ptr(io), M_RAMDISK);
403ccaaee46SJohn Baldwin ctl_add_kern_rel_offset(io, ctl_kern_data_len(io));
4042c7dc6baSAlexander Motin if ((io->io_hdr.flags & CTL_FLAG_ABORT) == 0 &&
4052c7dc6baSAlexander Motin (io->io_hdr.status & CTL_STATUS_MASK) == CTL_STATUS_NONE) {
406e7037673SAlexander Motin if (ARGS(io)->flags & CTL_LLF_COMPARE) {
407e7037673SAlexander Motin /* We have data block ready for comparison. */
408e7037673SAlexander Motin if (ctl_backend_ramdisk_cmp(io))
409e7037673SAlexander Motin goto done;
410e7037673SAlexander Motin }
411e7037673SAlexander Motin if (ARGS(io)->len > PRIV(io)->len) {
41275c7a1d3SAlexander Motin mtx_lock(&be_lun->queue_lock);
41308a7cce5SAlexander Motin STAILQ_INSERT_TAIL(&be_lun->cont_queue,
41408a7cce5SAlexander Motin &io->io_hdr, links);
41575c7a1d3SAlexander Motin mtx_unlock(&be_lun->queue_lock);
41608a7cce5SAlexander Motin taskqueue_enqueue(be_lun->io_taskqueue,
41708a7cce5SAlexander Motin &be_lun->io_task);
41808a7cce5SAlexander Motin return (0);
41908a7cce5SAlexander Motin }
420ccaaee46SJohn Baldwin ctl_io_set_success(io);
421130f4520SKenneth D. Merry }
422e7037673SAlexander Motin done:
42311b569f7SAlexander Motin ctl_data_submit_done(io);
424130f4520SKenneth D. Merry return(0);
425130f4520SKenneth D. Merry }
426130f4520SKenneth D. Merry
427e7037673SAlexander Motin static void
ctl_backend_ramdisk_compare(union ctl_io * io)428e7037673SAlexander Motin ctl_backend_ramdisk_compare(union ctl_io *io)
429e7037673SAlexander Motin {
430e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
431e7037673SAlexander Motin u_int lbas, len;
432e7037673SAlexander Motin
433e7037673SAlexander Motin lbas = ARGS(io)->len - PRIV(io)->len;
434e7037673SAlexander Motin lbas = MIN(lbas, 131072 / cbe_lun->blocksize);
435e7037673SAlexander Motin len = lbas * cbe_lun->blocksize;
436e7037673SAlexander Motin
437ccaaee46SJohn Baldwin ctl_set_be_move_done(io, ctl_backend_ramdisk_move_done);
438ccaaee46SJohn Baldwin ctl_set_kern_data_ptr(io, malloc(len, M_RAMDISK, M_WAITOK));
439ccaaee46SJohn Baldwin ctl_set_kern_data_len(io, len);
440ccaaee46SJohn Baldwin ctl_set_kern_sg_entries(io, 0);
441e7037673SAlexander Motin io->io_hdr.flags |= CTL_FLAG_ALLOCATED;
442e7037673SAlexander Motin PRIV(io)->len += lbas;
443e7037673SAlexander Motin ctl_datamove(io);
444e7037673SAlexander Motin }
445e7037673SAlexander Motin
446e7037673SAlexander Motin static void
ctl_backend_ramdisk_rw(union ctl_io * io)447e7037673SAlexander Motin ctl_backend_ramdisk_rw(union ctl_io *io)
448e7037673SAlexander Motin {
449e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
450767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
451e7037673SAlexander Motin struct ctl_sg_entry *sg_entries;
452e7037673SAlexander Motin uint8_t *page;
453e7037673SAlexander Motin uint64_t lba;
454e7037673SAlexander Motin u_int i, len, lbaoff, lbas, sgs, off;
455e7037673SAlexander Motin getpage_op_t op;
456e7037673SAlexander Motin
457e7037673SAlexander Motin lba = ARGS(io)->lba + PRIV(io)->len;
458e7037673SAlexander Motin lbaoff = lba & ~(UINT_MAX << cbe_lun->pblockexp);
459e7037673SAlexander Motin lbas = ARGS(io)->len - PRIV(io)->len;
460e7037673SAlexander Motin lbas = MIN(lbas, (SGPP << cbe_lun->pblockexp) - lbaoff);
461e7037673SAlexander Motin sgs = (lbas + lbaoff + be_lun->pblockmul - 1) >> cbe_lun->pblockexp;
462e7037673SAlexander Motin off = lbaoff * cbe_lun->blocksize;
463e7037673SAlexander Motin op = (ARGS(io)->flags & CTL_LLF_WRITE) ? GP_WRITE : GP_READ;
464e7037673SAlexander Motin if (sgs > 1) {
465ccaaee46SJohn Baldwin sg_entries = malloc(sizeof(struct ctl_sg_entry) * sgs,
466ccaaee46SJohn Baldwin M_RAMDISK, M_WAITOK);
467ccaaee46SJohn Baldwin ctl_set_kern_data_ptr(io, sg_entries);
468e7037673SAlexander Motin len = lbas * cbe_lun->blocksize;
469e7037673SAlexander Motin for (i = 0; i < sgs; i++) {
470e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun,
471e7037673SAlexander Motin (lba >> cbe_lun->pblockexp) + i, op);
472e7037673SAlexander Motin if (page == P_UNMAPPED || page == P_ANCHORED) {
473ccaaee46SJohn Baldwin free(sg_entries, M_RAMDISK);
474e7037673SAlexander Motin nospc:
475ccaaee46SJohn Baldwin ctl_io_set_space_alloc_fail(io);
476e7037673SAlexander Motin ctl_data_submit_done(io);
477e7037673SAlexander Motin return;
478e7037673SAlexander Motin }
479e7037673SAlexander Motin sg_entries[i].addr = page + off;
480e7037673SAlexander Motin sg_entries[i].len = MIN(len, be_lun->pblocksize - off);
481e7037673SAlexander Motin len -= sg_entries[i].len;
482e7037673SAlexander Motin off = 0;
483e7037673SAlexander Motin }
484e7037673SAlexander Motin } else {
485e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun,
486e7037673SAlexander Motin lba >> cbe_lun->pblockexp, op);
487e7037673SAlexander Motin if (page == P_UNMAPPED || page == P_ANCHORED)
488e7037673SAlexander Motin goto nospc;
489e7037673SAlexander Motin sgs = 0;
490ccaaee46SJohn Baldwin ctl_set_kern_data_ptr(io, page + off);
491e7037673SAlexander Motin }
492e7037673SAlexander Motin
493ccaaee46SJohn Baldwin ctl_set_be_move_done(io, ctl_backend_ramdisk_move_done);
494ccaaee46SJohn Baldwin ctl_set_kern_data_len(io, lbas * cbe_lun->blocksize);
495ccaaee46SJohn Baldwin ctl_set_kern_sg_entries(io, sgs);
496e7037673SAlexander Motin io->io_hdr.flags |= CTL_FLAG_ALLOCATED;
497e7037673SAlexander Motin PRIV(io)->len += lbas;
498e8583acfSAlexander Motin if ((ARGS(io)->flags & CTL_LLF_READ) &&
499e8583acfSAlexander Motin ARGS(io)->len <= PRIV(io)->len) {
500ccaaee46SJohn Baldwin ctl_io_set_success(io);
501ac503c19SAlexander Motin if (cbe_lun->serseq >= CTL_LUN_SERSEQ_SOFT)
502e8583acfSAlexander Motin ctl_serseq_done(io);
503e8583acfSAlexander Motin }
504e7037673SAlexander Motin ctl_datamove(io);
505e7037673SAlexander Motin }
506e7037673SAlexander Motin
507130f4520SKenneth D. Merry static int
ctl_backend_ramdisk_submit(union ctl_io * io)508130f4520SKenneth D. Merry ctl_backend_ramdisk_submit(union ctl_io *io)
509130f4520SKenneth D. Merry {
510e7037673SAlexander Motin struct ctl_lba_len_flags *lbalen = ARGS(io);
511130f4520SKenneth D. Merry
51211b569f7SAlexander Motin if (lbalen->flags & CTL_LLF_VERIFY) {
513ccaaee46SJohn Baldwin ctl_io_set_success(io);
51411b569f7SAlexander Motin ctl_data_submit_done(io);
51511b569f7SAlexander Motin return (CTL_RETVAL_COMPLETE);
51611b569f7SAlexander Motin }
517e7037673SAlexander Motin PRIV(io)->len = 0;
518e7037673SAlexander Motin if (lbalen->flags & CTL_LLF_COMPARE)
519e7037673SAlexander Motin ctl_backend_ramdisk_compare(io);
520e7037673SAlexander Motin else
521e7037673SAlexander Motin ctl_backend_ramdisk_rw(io);
522130f4520SKenneth D. Merry return (CTL_RETVAL_COMPLETE);
523130f4520SKenneth D. Merry }
524130f4520SKenneth D. Merry
52508a7cce5SAlexander Motin static void
ctl_backend_ramdisk_worker(void * context,int pending)52608a7cce5SAlexander Motin ctl_backend_ramdisk_worker(void *context, int pending)
52708a7cce5SAlexander Motin {
52808a7cce5SAlexander Motin struct ctl_be_ramdisk_lun *be_lun;
52908a7cce5SAlexander Motin union ctl_io *io;
53008a7cce5SAlexander Motin
53108a7cce5SAlexander Motin be_lun = (struct ctl_be_ramdisk_lun *)context;
53275c7a1d3SAlexander Motin mtx_lock(&be_lun->queue_lock);
53308a7cce5SAlexander Motin for (;;) {
53408a7cce5SAlexander Motin io = (union ctl_io *)STAILQ_FIRST(&be_lun->cont_queue);
53508a7cce5SAlexander Motin if (io != NULL) {
53605d882b7SAlexander Motin STAILQ_REMOVE_HEAD(&be_lun->cont_queue, links);
53775c7a1d3SAlexander Motin mtx_unlock(&be_lun->queue_lock);
538e7037673SAlexander Motin if (ARGS(io)->flags & CTL_LLF_COMPARE)
539e7037673SAlexander Motin ctl_backend_ramdisk_compare(io);
540e7037673SAlexander Motin else
541e7037673SAlexander Motin ctl_backend_ramdisk_rw(io);
54275c7a1d3SAlexander Motin mtx_lock(&be_lun->queue_lock);
54308a7cce5SAlexander Motin continue;
54408a7cce5SAlexander Motin }
54508a7cce5SAlexander Motin
54608a7cce5SAlexander Motin /*
54708a7cce5SAlexander Motin * If we get here, there is no work left in the queues, so
54808a7cce5SAlexander Motin * just break out and let the task queue go to sleep.
54908a7cce5SAlexander Motin */
55008a7cce5SAlexander Motin break;
55108a7cce5SAlexander Motin }
55275c7a1d3SAlexander Motin mtx_unlock(&be_lun->queue_lock);
553130f4520SKenneth D. Merry }
554130f4520SKenneth D. Merry
555130f4520SKenneth D. Merry static int
ctl_backend_ramdisk_gls(union ctl_io * io)556e7037673SAlexander Motin ctl_backend_ramdisk_gls(union ctl_io *io)
557e7037673SAlexander Motin {
558e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
559767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
560e7037673SAlexander Motin struct scsi_get_lba_status_data *data;
561e7037673SAlexander Motin uint8_t *page;
562e7037673SAlexander Motin u_int lbaoff;
563e7037673SAlexander Motin
564e7037673SAlexander Motin data = (struct scsi_get_lba_status_data *)io->scsiio.kern_data_ptr;
565e7037673SAlexander Motin scsi_u64to8b(ARGS(io)->lba, data->descr[0].addr);
566e7037673SAlexander Motin lbaoff = ARGS(io)->lba & ~(UINT_MAX << cbe_lun->pblockexp);
567e7037673SAlexander Motin scsi_ulto4b(be_lun->pblockmul - lbaoff, data->descr[0].length);
568e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun,
569e7037673SAlexander Motin ARGS(io)->lba >> cbe_lun->pblockexp, GP_OTHER);
570e7037673SAlexander Motin if (page == P_UNMAPPED)
571e7037673SAlexander Motin data->descr[0].status = 1;
572e7037673SAlexander Motin else if (page == P_ANCHORED)
573e7037673SAlexander Motin data->descr[0].status = 2;
574e7037673SAlexander Motin else
575e7037673SAlexander Motin data->descr[0].status = 0;
576e7037673SAlexander Motin ctl_config_read_done(io);
577e7037673SAlexander Motin return (CTL_RETVAL_COMPLETE);
578e7037673SAlexander Motin }
579e7037673SAlexander Motin
580e7037673SAlexander Motin static int
ctl_backend_ramdisk_scsi_config_read(union ctl_io * io)581*d5c21c68SJohn Baldwin ctl_backend_ramdisk_scsi_config_read(union ctl_io *io)
582e7037673SAlexander Motin {
583e7037673SAlexander Motin int retval = 0;
584e7037673SAlexander Motin
585e7037673SAlexander Motin switch (io->scsiio.cdb[0]) {
586e7037673SAlexander Motin case SERVICE_ACTION_IN:
587e7037673SAlexander Motin if (io->scsiio.cdb[1] == SGLS_SERVICE_ACTION) {
588e7037673SAlexander Motin retval = ctl_backend_ramdisk_gls(io);
589e7037673SAlexander Motin break;
590e7037673SAlexander Motin }
591e7037673SAlexander Motin ctl_set_invalid_field(&io->scsiio,
592e7037673SAlexander Motin /*sks_valid*/ 1,
593e7037673SAlexander Motin /*command*/ 1,
594e7037673SAlexander Motin /*field*/ 1,
595e7037673SAlexander Motin /*bit_valid*/ 1,
596e7037673SAlexander Motin /*bit*/ 4);
597e7037673SAlexander Motin ctl_config_read_done(io);
598e7037673SAlexander Motin retval = CTL_RETVAL_COMPLETE;
599e7037673SAlexander Motin break;
600e7037673SAlexander Motin default:
601e7037673SAlexander Motin ctl_set_invalid_opcode(&io->scsiio);
602e7037673SAlexander Motin ctl_config_read_done(io);
603e7037673SAlexander Motin retval = CTL_RETVAL_COMPLETE;
604e7037673SAlexander Motin break;
605e7037673SAlexander Motin }
606e7037673SAlexander Motin return (retval);
607e7037673SAlexander Motin }
608e7037673SAlexander Motin
609*d5c21c68SJohn Baldwin static int
ramdisk_namespace_data(union ctl_io * io)610*d5c21c68SJohn Baldwin ramdisk_namespace_data(union ctl_io *io)
611*d5c21c68SJohn Baldwin {
612*d5c21c68SJohn Baldwin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
613*d5c21c68SJohn Baldwin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
614*d5c21c68SJohn Baldwin struct nvme_namespace_data *nsdata;
615*d5c21c68SJohn Baldwin
616*d5c21c68SJohn Baldwin if (io->nvmeio.kern_data_len != sizeof(struct nvme_namespace_data) ||
617*d5c21c68SJohn Baldwin io->nvmeio.kern_sg_entries != 0)
618*d5c21c68SJohn Baldwin return (CTL_RETVAL_ERROR);
619*d5c21c68SJohn Baldwin
620*d5c21c68SJohn Baldwin nsdata = (struct nvme_namespace_data *)io->nvmeio.kern_data_ptr;
621*d5c21c68SJohn Baldwin memset(nsdata, 0, sizeof(*nsdata));
622*d5c21c68SJohn Baldwin nsdata->nsze = htole64(be_lun->size_blocks);
623*d5c21c68SJohn Baldwin nsdata->ncap = htole64(be_lun->cap_bytes / cbe_lun->blocksize);
624*d5c21c68SJohn Baldwin nsdata->nuse = htole64(be_lun->cap_used / cbe_lun->blocksize);
625*d5c21c68SJohn Baldwin nsdata->nsfeat = NVMEM(NVME_NS_DATA_NSFEAT_THIN_PROV) |
626*d5c21c68SJohn Baldwin NVMEM(NVME_NS_DATA_NSFEAT_DEALLOC);
627*d5c21c68SJohn Baldwin nsdata->nlbaf = 1 - 1;
628*d5c21c68SJohn Baldwin nsdata->dlfeat = NVMEM(NVME_NS_DATA_DLFEAT_DWZ) |
629*d5c21c68SJohn Baldwin NVMEF(NVME_NS_DATA_DLFEAT_READ, NVME_NS_DATA_DLFEAT_READ_00);
630*d5c21c68SJohn Baldwin nsdata->flbas = NVMEF(NVME_NS_DATA_FLBAS_FORMAT, 0);
631*d5c21c68SJohn Baldwin nsdata->lbaf[0] = NVMEF(NVME_NS_DATA_LBAF_LBADS,
632*d5c21c68SJohn Baldwin ffs(cbe_lun->blocksize) - 1);
633*d5c21c68SJohn Baldwin
634*d5c21c68SJohn Baldwin ctl_lun_nsdata_ids(cbe_lun, nsdata);
635*d5c21c68SJohn Baldwin ctl_config_read_done(io);
636*d5c21c68SJohn Baldwin return (CTL_RETVAL_COMPLETE);
637*d5c21c68SJohn Baldwin }
638*d5c21c68SJohn Baldwin
639*d5c21c68SJohn Baldwin static int
ramdisk_nvme_ids(union ctl_io * io)640*d5c21c68SJohn Baldwin ramdisk_nvme_ids(union ctl_io *io)
641*d5c21c68SJohn Baldwin {
642*d5c21c68SJohn Baldwin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
643*d5c21c68SJohn Baldwin
644*d5c21c68SJohn Baldwin if (io->nvmeio.kern_data_len != 4096 || io->nvmeio.kern_sg_entries != 0)
645*d5c21c68SJohn Baldwin return (CTL_RETVAL_ERROR);
646*d5c21c68SJohn Baldwin
647*d5c21c68SJohn Baldwin ctl_lun_nvme_ids(cbe_lun, io->nvmeio.kern_data_ptr);
648*d5c21c68SJohn Baldwin ctl_config_read_done(io);
649*d5c21c68SJohn Baldwin return (CTL_RETVAL_COMPLETE);
650*d5c21c68SJohn Baldwin }
651*d5c21c68SJohn Baldwin
652*d5c21c68SJohn Baldwin static int
ctl_backend_ramdisk_nvme_config_read(union ctl_io * io)653*d5c21c68SJohn Baldwin ctl_backend_ramdisk_nvme_config_read(union ctl_io *io)
654*d5c21c68SJohn Baldwin {
655*d5c21c68SJohn Baldwin switch (io->nvmeio.cmd.opc) {
656*d5c21c68SJohn Baldwin case NVME_OPC_IDENTIFY:
657*d5c21c68SJohn Baldwin {
658*d5c21c68SJohn Baldwin uint8_t cns;
659*d5c21c68SJohn Baldwin
660*d5c21c68SJohn Baldwin cns = le32toh(io->nvmeio.cmd.cdw10) & 0xff;
661*d5c21c68SJohn Baldwin switch (cns) {
662*d5c21c68SJohn Baldwin case 0:
663*d5c21c68SJohn Baldwin return (ramdisk_namespace_data(io));
664*d5c21c68SJohn Baldwin case 3:
665*d5c21c68SJohn Baldwin return (ramdisk_nvme_ids(io));
666*d5c21c68SJohn Baldwin default:
667*d5c21c68SJohn Baldwin ctl_nvme_set_invalid_field(&io->nvmeio);
668*d5c21c68SJohn Baldwin ctl_config_read_done(io);
669*d5c21c68SJohn Baldwin return (CTL_RETVAL_COMPLETE);
670*d5c21c68SJohn Baldwin }
671*d5c21c68SJohn Baldwin }
672*d5c21c68SJohn Baldwin default:
673*d5c21c68SJohn Baldwin ctl_nvme_set_invalid_opcode(&io->nvmeio);
674*d5c21c68SJohn Baldwin ctl_config_read_done(io);
675*d5c21c68SJohn Baldwin return (CTL_RETVAL_COMPLETE);
676*d5c21c68SJohn Baldwin }
677*d5c21c68SJohn Baldwin }
678*d5c21c68SJohn Baldwin
679*d5c21c68SJohn Baldwin static int
ctl_backend_ramdisk_config_read(union ctl_io * io)680*d5c21c68SJohn Baldwin ctl_backend_ramdisk_config_read(union ctl_io *io)
681*d5c21c68SJohn Baldwin {
682*d5c21c68SJohn Baldwin switch (io->io_hdr.io_type) {
683*d5c21c68SJohn Baldwin case CTL_IO_SCSI:
684*d5c21c68SJohn Baldwin return (ctl_backend_ramdisk_scsi_config_read(io));
685*d5c21c68SJohn Baldwin case CTL_IO_NVME_ADMIN:
686*d5c21c68SJohn Baldwin return (ctl_backend_ramdisk_nvme_config_read(io));
687*d5c21c68SJohn Baldwin default:
688*d5c21c68SJohn Baldwin __assert_unreachable();
689*d5c21c68SJohn Baldwin }
690*d5c21c68SJohn Baldwin }
691*d5c21c68SJohn Baldwin
692e7037673SAlexander Motin static void
ctl_backend_ramdisk_delete(struct ctl_be_lun * cbe_lun,off_t lba,off_t len,int anchor)693e7037673SAlexander Motin ctl_backend_ramdisk_delete(struct ctl_be_lun *cbe_lun, off_t lba, off_t len,
694e7037673SAlexander Motin int anchor)
695e7037673SAlexander Motin {
696767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
697e7037673SAlexander Motin uint8_t *page;
698e7037673SAlexander Motin uint64_t p, lp;
699e7037673SAlexander Motin u_int lbaoff;
700e7037673SAlexander Motin getpage_op_t op = anchor ? GP_ANCHOR : GP_OTHER;
701e7037673SAlexander Motin
702e7037673SAlexander Motin /* Partially zero first partial page. */
703e7037673SAlexander Motin p = lba >> cbe_lun->pblockexp;
704e7037673SAlexander Motin lbaoff = lba & ~(UINT_MAX << cbe_lun->pblockexp);
705e7037673SAlexander Motin if (lbaoff != 0) {
706e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun, p, op);
707e7037673SAlexander Motin if (page != P_UNMAPPED && page != P_ANCHORED) {
708e7037673SAlexander Motin memset(page + lbaoff * cbe_lun->blocksize, 0,
709e7037673SAlexander Motin min(len, be_lun->pblockmul - lbaoff) *
710e7037673SAlexander Motin cbe_lun->blocksize);
711e7037673SAlexander Motin }
712e7037673SAlexander Motin p++;
713e7037673SAlexander Motin }
714e7037673SAlexander Motin
715e7037673SAlexander Motin /* Partially zero last partial page. */
716e7037673SAlexander Motin lp = (lba + len) >> cbe_lun->pblockexp;
717e7037673SAlexander Motin lbaoff = (lba + len) & ~(UINT_MAX << cbe_lun->pblockexp);
718e7037673SAlexander Motin if (p <= lp && lbaoff != 0) {
719e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun, lp, op);
720e7037673SAlexander Motin if (page != P_UNMAPPED && page != P_ANCHORED)
721e7037673SAlexander Motin memset(page, 0, lbaoff * cbe_lun->blocksize);
722e7037673SAlexander Motin }
723e7037673SAlexander Motin
724e7037673SAlexander Motin /* Delete remaining full pages. */
725e7037673SAlexander Motin if (anchor) {
726e7037673SAlexander Motin for (; p < lp; p++)
727e7037673SAlexander Motin ctl_backend_ramdisk_anchorpage(be_lun, p);
728e7037673SAlexander Motin } else {
729e7037673SAlexander Motin for (; p < lp; p++)
730e7037673SAlexander Motin ctl_backend_ramdisk_unmappage(be_lun, p);
731e7037673SAlexander Motin }
732e7037673SAlexander Motin }
733e7037673SAlexander Motin
734e7037673SAlexander Motin static void
ctl_backend_ramdisk_ws(union ctl_io * io)735e7037673SAlexander Motin ctl_backend_ramdisk_ws(union ctl_io *io)
736e7037673SAlexander Motin {
737e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
738767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
739e7037673SAlexander Motin struct ctl_lba_len_flags *lbalen = ARGS(io);
740e7037673SAlexander Motin uint8_t *page;
741e7037673SAlexander Motin uint64_t lba;
742e7037673SAlexander Motin u_int lbaoff, lbas;
743e7037673SAlexander Motin
744*d5c21c68SJohn Baldwin CTL_IO_ASSERT(io, SCSI);
745*d5c21c68SJohn Baldwin
746e7037673SAlexander Motin if (lbalen->flags & ~(SWS_LBDATA | SWS_UNMAP | SWS_ANCHOR | SWS_NDOB)) {
747e7037673SAlexander Motin ctl_set_invalid_field(&io->scsiio,
748e7037673SAlexander Motin /*sks_valid*/ 1,
749e7037673SAlexander Motin /*command*/ 1,
750e7037673SAlexander Motin /*field*/ 1,
751e7037673SAlexander Motin /*bit_valid*/ 0,
752e7037673SAlexander Motin /*bit*/ 0);
753e7037673SAlexander Motin ctl_config_write_done(io);
754e7037673SAlexander Motin return;
755e7037673SAlexander Motin }
756e7037673SAlexander Motin if (lbalen->flags & SWS_UNMAP) {
757e7037673SAlexander Motin ctl_backend_ramdisk_delete(cbe_lun, lbalen->lba, lbalen->len,
758e7037673SAlexander Motin (lbalen->flags & SWS_ANCHOR) != 0);
759e7037673SAlexander Motin ctl_set_success(&io->scsiio);
760e7037673SAlexander Motin ctl_config_write_done(io);
761e7037673SAlexander Motin return;
762e7037673SAlexander Motin }
763e7037673SAlexander Motin
764e7037673SAlexander Motin for (lba = lbalen->lba, lbas = lbalen->len; lbas > 0; lba++, lbas--) {
765e7037673SAlexander Motin page = ctl_backend_ramdisk_getpage(be_lun,
766e7037673SAlexander Motin lba >> cbe_lun->pblockexp, GP_WRITE);
767e7037673SAlexander Motin if (page == P_UNMAPPED || page == P_ANCHORED) {
768e7037673SAlexander Motin ctl_set_space_alloc_fail(&io->scsiio);
769e7037673SAlexander Motin ctl_data_submit_done(io);
770e7037673SAlexander Motin return;
771e7037673SAlexander Motin }
772e7037673SAlexander Motin lbaoff = lba & ~(UINT_MAX << cbe_lun->pblockexp);
773e7037673SAlexander Motin page += lbaoff * cbe_lun->blocksize;
774e7037673SAlexander Motin if (lbalen->flags & SWS_NDOB) {
775e7037673SAlexander Motin memset(page, 0, cbe_lun->blocksize);
776e7037673SAlexander Motin } else {
777e7037673SAlexander Motin memcpy(page, io->scsiio.kern_data_ptr,
778e7037673SAlexander Motin cbe_lun->blocksize);
779e7037673SAlexander Motin }
780e7037673SAlexander Motin if (lbalen->flags & SWS_LBDATA)
781e7037673SAlexander Motin scsi_ulto4b(lba, page);
782e7037673SAlexander Motin }
783e7037673SAlexander Motin ctl_set_success(&io->scsiio);
784e7037673SAlexander Motin ctl_config_write_done(io);
785e7037673SAlexander Motin }
786e7037673SAlexander Motin
787e7037673SAlexander Motin static void
ctl_backend_ramdisk_unmap(union ctl_io * io)788e7037673SAlexander Motin ctl_backend_ramdisk_unmap(union ctl_io *io)
789e7037673SAlexander Motin {
790e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
791e7037673SAlexander Motin struct ctl_ptr_len_flags *ptrlen = (struct ctl_ptr_len_flags *)ARGS(io);
792e7037673SAlexander Motin struct scsi_unmap_desc *buf, *end;
793e7037673SAlexander Motin
794*d5c21c68SJohn Baldwin CTL_IO_ASSERT(io, SCSI);
795*d5c21c68SJohn Baldwin
796e7037673SAlexander Motin if ((ptrlen->flags & ~SU_ANCHOR) != 0) {
797e7037673SAlexander Motin ctl_set_invalid_field(&io->scsiio,
798e7037673SAlexander Motin /*sks_valid*/ 0,
799e7037673SAlexander Motin /*command*/ 0,
800e7037673SAlexander Motin /*field*/ 0,
801e7037673SAlexander Motin /*bit_valid*/ 0,
802e7037673SAlexander Motin /*bit*/ 0);
803e7037673SAlexander Motin ctl_config_write_done(io);
804e7037673SAlexander Motin return;
805e7037673SAlexander Motin }
806e7037673SAlexander Motin
807e7037673SAlexander Motin buf = (struct scsi_unmap_desc *)ptrlen->ptr;
808e7037673SAlexander Motin end = buf + ptrlen->len / sizeof(*buf);
809e7037673SAlexander Motin for (; buf < end; buf++) {
810e7037673SAlexander Motin ctl_backend_ramdisk_delete(cbe_lun,
811e7037673SAlexander Motin scsi_8btou64(buf->lba), scsi_4btoul(buf->length),
812e7037673SAlexander Motin (ptrlen->flags & SU_ANCHOR) != 0);
813e7037673SAlexander Motin }
814e7037673SAlexander Motin
815e7037673SAlexander Motin ctl_set_success(&io->scsiio);
816e7037673SAlexander Motin ctl_config_write_done(io);
817e7037673SAlexander Motin }
818e7037673SAlexander Motin
819e7037673SAlexander Motin static int
ctl_backend_ramdisk_scsi_config_write(union ctl_io * io)820*d5c21c68SJohn Baldwin ctl_backend_ramdisk_scsi_config_write(union ctl_io *io)
821e7037673SAlexander Motin {
822e7037673SAlexander Motin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
823e7037673SAlexander Motin int retval = 0;
824e7037673SAlexander Motin
825e7037673SAlexander Motin switch (io->scsiio.cdb[0]) {
826e7037673SAlexander Motin case SYNCHRONIZE_CACHE:
827e7037673SAlexander Motin case SYNCHRONIZE_CACHE_16:
828e7037673SAlexander Motin /* We have no cache to flush. */
829e7037673SAlexander Motin ctl_set_success(&io->scsiio);
830e7037673SAlexander Motin ctl_config_write_done(io);
831e7037673SAlexander Motin break;
832e7037673SAlexander Motin case START_STOP_UNIT: {
833e7037673SAlexander Motin struct scsi_start_stop_unit *cdb;
834e7037673SAlexander Motin
835e7037673SAlexander Motin cdb = (struct scsi_start_stop_unit *)io->scsiio.cdb;
836e7037673SAlexander Motin if ((cdb->how & SSS_PC_MASK) != 0) {
837e7037673SAlexander Motin ctl_set_success(&io->scsiio);
838e7037673SAlexander Motin ctl_config_write_done(io);
839e7037673SAlexander Motin break;
840e7037673SAlexander Motin }
841e7037673SAlexander Motin if (cdb->how & SSS_START) {
842e7037673SAlexander Motin if (cdb->how & SSS_LOEJ)
843e7037673SAlexander Motin ctl_lun_has_media(cbe_lun);
844e7037673SAlexander Motin ctl_start_lun(cbe_lun);
845e7037673SAlexander Motin } else {
846e7037673SAlexander Motin ctl_stop_lun(cbe_lun);
847e7037673SAlexander Motin if (cdb->how & SSS_LOEJ)
848e7037673SAlexander Motin ctl_lun_ejected(cbe_lun);
849e7037673SAlexander Motin }
850e7037673SAlexander Motin ctl_set_success(&io->scsiio);
851e7037673SAlexander Motin ctl_config_write_done(io);
852e7037673SAlexander Motin break;
853e7037673SAlexander Motin }
854e7037673SAlexander Motin case PREVENT_ALLOW:
855e7037673SAlexander Motin ctl_set_success(&io->scsiio);
856e7037673SAlexander Motin ctl_config_write_done(io);
857e7037673SAlexander Motin break;
858e7037673SAlexander Motin case WRITE_SAME_10:
859e7037673SAlexander Motin case WRITE_SAME_16:
860e7037673SAlexander Motin ctl_backend_ramdisk_ws(io);
861e7037673SAlexander Motin break;
862e7037673SAlexander Motin case UNMAP:
863e7037673SAlexander Motin ctl_backend_ramdisk_unmap(io);
864e7037673SAlexander Motin break;
865e7037673SAlexander Motin default:
866e7037673SAlexander Motin ctl_set_invalid_opcode(&io->scsiio);
867e7037673SAlexander Motin ctl_config_write_done(io);
868e7037673SAlexander Motin retval = CTL_RETVAL_COMPLETE;
869e7037673SAlexander Motin break;
870e7037673SAlexander Motin }
871e7037673SAlexander Motin
872e7037673SAlexander Motin return (retval);
873e7037673SAlexander Motin }
874e7037673SAlexander Motin
875*d5c21c68SJohn Baldwin static void
ctl_backend_ramdisk_wu(union ctl_io * io)876*d5c21c68SJohn Baldwin ctl_backend_ramdisk_wu(union ctl_io *io)
877*d5c21c68SJohn Baldwin {
878*d5c21c68SJohn Baldwin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
879*d5c21c68SJohn Baldwin struct ctl_lba_len_flags *lbalen = ARGS(io);
880*d5c21c68SJohn Baldwin
881*d5c21c68SJohn Baldwin CTL_IO_ASSERT(io, NVME);
882*d5c21c68SJohn Baldwin
883*d5c21c68SJohn Baldwin /*
884*d5c21c68SJohn Baldwin * XXX: Not quite right as reads will return zeroes rather
885*d5c21c68SJohn Baldwin * than failing.
886*d5c21c68SJohn Baldwin */
887*d5c21c68SJohn Baldwin ctl_backend_ramdisk_delete(cbe_lun, lbalen->lba, lbalen->len, 1);
888*d5c21c68SJohn Baldwin ctl_nvme_set_success(&io->nvmeio);
889*d5c21c68SJohn Baldwin ctl_config_write_done(io);
890*d5c21c68SJohn Baldwin }
891*d5c21c68SJohn Baldwin
892*d5c21c68SJohn Baldwin static void
ctl_backend_ramdisk_wz(union ctl_io * io)893*d5c21c68SJohn Baldwin ctl_backend_ramdisk_wz(union ctl_io *io)
894*d5c21c68SJohn Baldwin {
895*d5c21c68SJohn Baldwin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
896*d5c21c68SJohn Baldwin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
897*d5c21c68SJohn Baldwin struct ctl_lba_len_flags *lbalen = ARGS(io);
898*d5c21c68SJohn Baldwin uint8_t *page;
899*d5c21c68SJohn Baldwin uint64_t lba;
900*d5c21c68SJohn Baldwin u_int lbaoff, lbas;
901*d5c21c68SJohn Baldwin
902*d5c21c68SJohn Baldwin CTL_IO_ASSERT(io, NVME);
903*d5c21c68SJohn Baldwin
904*d5c21c68SJohn Baldwin if ((le32toh(io->nvmeio.cmd.cdw12) & (1U << 25)) != 0) {
905*d5c21c68SJohn Baldwin ctl_backend_ramdisk_delete(cbe_lun, lbalen->lba, lbalen->len,
906*d5c21c68SJohn Baldwin 0);
907*d5c21c68SJohn Baldwin ctl_nvme_set_success(&io->nvmeio);
908*d5c21c68SJohn Baldwin ctl_config_write_done(io);
909*d5c21c68SJohn Baldwin return;
910*d5c21c68SJohn Baldwin }
911*d5c21c68SJohn Baldwin
912*d5c21c68SJohn Baldwin for (lba = lbalen->lba, lbas = lbalen->len; lbas > 0; lba++, lbas--) {
913*d5c21c68SJohn Baldwin page = ctl_backend_ramdisk_getpage(be_lun,
914*d5c21c68SJohn Baldwin lba >> cbe_lun->pblockexp, GP_WRITE);
915*d5c21c68SJohn Baldwin if (page == P_UNMAPPED || page == P_ANCHORED) {
916*d5c21c68SJohn Baldwin ctl_nvme_set_space_alloc_fail(&io->nvmeio);
917*d5c21c68SJohn Baldwin ctl_data_submit_done(io);
918*d5c21c68SJohn Baldwin return;
919*d5c21c68SJohn Baldwin }
920*d5c21c68SJohn Baldwin lbaoff = lba & ~(UINT_MAX << cbe_lun->pblockexp);
921*d5c21c68SJohn Baldwin page += lbaoff * cbe_lun->blocksize;
922*d5c21c68SJohn Baldwin memset(page, 0, cbe_lun->blocksize);
923*d5c21c68SJohn Baldwin }
924*d5c21c68SJohn Baldwin ctl_nvme_set_success(&io->nvmeio);
925*d5c21c68SJohn Baldwin ctl_config_write_done(io);
926*d5c21c68SJohn Baldwin }
927*d5c21c68SJohn Baldwin
928*d5c21c68SJohn Baldwin static void
ctl_backend_ramdisk_dsm(union ctl_io * io)929*d5c21c68SJohn Baldwin ctl_backend_ramdisk_dsm(union ctl_io *io)
930*d5c21c68SJohn Baldwin {
931*d5c21c68SJohn Baldwin struct ctl_be_lun *cbe_lun = CTL_BACKEND_LUN(io);
932*d5c21c68SJohn Baldwin struct nvme_dsm_range *r;
933*d5c21c68SJohn Baldwin uint64_t lba;
934*d5c21c68SJohn Baldwin uint32_t num_blocks;
935*d5c21c68SJohn Baldwin u_int i, ranges;
936*d5c21c68SJohn Baldwin
937*d5c21c68SJohn Baldwin CTL_IO_ASSERT(io, NVME);
938*d5c21c68SJohn Baldwin
939*d5c21c68SJohn Baldwin ranges = le32toh(io->nvmeio.cmd.cdw10) & 0xff;
940*d5c21c68SJohn Baldwin r = (struct nvme_dsm_range *)io->nvmeio.kern_data_ptr;
941*d5c21c68SJohn Baldwin for (i = 0; i < ranges; i++) {
942*d5c21c68SJohn Baldwin lba = le64toh(r[i].starting_lba);
943*d5c21c68SJohn Baldwin num_blocks = le32toh(r[i].length);
944*d5c21c68SJohn Baldwin if ((le32toh(r[i].attributes) & (1U << 2)) != 0)
945*d5c21c68SJohn Baldwin ctl_backend_ramdisk_delete(cbe_lun, lba, num_blocks, 0);
946*d5c21c68SJohn Baldwin }
947*d5c21c68SJohn Baldwin
948*d5c21c68SJohn Baldwin ctl_nvme_set_success(&io->nvmeio);
949*d5c21c68SJohn Baldwin ctl_config_write_done(io);
950*d5c21c68SJohn Baldwin }
951*d5c21c68SJohn Baldwin
952*d5c21c68SJohn Baldwin static int
ctl_backend_ramdisk_nvme_config_write(union ctl_io * io)953*d5c21c68SJohn Baldwin ctl_backend_ramdisk_nvme_config_write(union ctl_io *io)
954*d5c21c68SJohn Baldwin {
955*d5c21c68SJohn Baldwin switch (io->nvmeio.cmd.opc) {
956*d5c21c68SJohn Baldwin case NVME_OPC_FLUSH:
957*d5c21c68SJohn Baldwin /* We have no cache to flush. */
958*d5c21c68SJohn Baldwin ctl_nvme_set_success(&io->nvmeio);
959*d5c21c68SJohn Baldwin ctl_config_write_done(io);
960*d5c21c68SJohn Baldwin break;
961*d5c21c68SJohn Baldwin case NVME_OPC_WRITE_UNCORRECTABLE:
962*d5c21c68SJohn Baldwin ctl_backend_ramdisk_wu(io);
963*d5c21c68SJohn Baldwin break;
964*d5c21c68SJohn Baldwin case NVME_OPC_WRITE_ZEROES:
965*d5c21c68SJohn Baldwin ctl_backend_ramdisk_wz(io);
966*d5c21c68SJohn Baldwin break;
967*d5c21c68SJohn Baldwin case NVME_OPC_DATASET_MANAGEMENT:
968*d5c21c68SJohn Baldwin ctl_backend_ramdisk_dsm(io);
969*d5c21c68SJohn Baldwin break;
970*d5c21c68SJohn Baldwin default:
971*d5c21c68SJohn Baldwin ctl_nvme_set_invalid_opcode(&io->nvmeio);
972*d5c21c68SJohn Baldwin ctl_config_write_done(io);
973*d5c21c68SJohn Baldwin break;
974*d5c21c68SJohn Baldwin }
975*d5c21c68SJohn Baldwin return (CTL_RETVAL_COMPLETE);
976*d5c21c68SJohn Baldwin }
977*d5c21c68SJohn Baldwin
978*d5c21c68SJohn Baldwin static int
ctl_backend_ramdisk_config_write(union ctl_io * io)979*d5c21c68SJohn Baldwin ctl_backend_ramdisk_config_write(union ctl_io *io)
980*d5c21c68SJohn Baldwin {
981*d5c21c68SJohn Baldwin switch (io->io_hdr.io_type) {
982*d5c21c68SJohn Baldwin case CTL_IO_SCSI:
983*d5c21c68SJohn Baldwin return (ctl_backend_ramdisk_scsi_config_write(io));
984*d5c21c68SJohn Baldwin case CTL_IO_NVME:
985*d5c21c68SJohn Baldwin return (ctl_backend_ramdisk_nvme_config_write(io));
986*d5c21c68SJohn Baldwin default:
987*d5c21c68SJohn Baldwin __assert_unreachable();
988*d5c21c68SJohn Baldwin }
989*d5c21c68SJohn Baldwin }
990*d5c21c68SJohn Baldwin
991e7037673SAlexander Motin static uint64_t
ctl_backend_ramdisk_lun_attr(struct ctl_be_lun * cbe_lun,const char * attrname)992767300e8SAlexander Motin ctl_backend_ramdisk_lun_attr(struct ctl_be_lun *cbe_lun, const char *attrname)
993e7037673SAlexander Motin {
994767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
995e7037673SAlexander Motin uint64_t val;
996e7037673SAlexander Motin
997e7037673SAlexander Motin val = UINT64_MAX;
998e7037673SAlexander Motin if (be_lun->cap_bytes == 0)
999e7037673SAlexander Motin return (val);
1000e7037673SAlexander Motin sx_slock(&be_lun->page_lock);
1001e7037673SAlexander Motin if (strcmp(attrname, "blocksused") == 0) {
1002e7037673SAlexander Motin val = be_lun->cap_used / be_lun->cbe_lun.blocksize;
1003e7037673SAlexander Motin } else if (strcmp(attrname, "blocksavail") == 0) {
1004e7037673SAlexander Motin val = (be_lun->cap_bytes - be_lun->cap_used) /
1005e7037673SAlexander Motin be_lun->cbe_lun.blocksize;
1006e7037673SAlexander Motin }
1007e7037673SAlexander Motin sx_sunlock(&be_lun->page_lock);
1008e7037673SAlexander Motin return (val);
1009e7037673SAlexander Motin }
1010e7037673SAlexander Motin
1011e7037673SAlexander Motin static int
ctl_backend_ramdisk_ioctl(struct cdev * dev,u_long cmd,caddr_t addr,int flag,struct thread * td)1012130f4520SKenneth D. Merry ctl_backend_ramdisk_ioctl(struct cdev *dev, u_long cmd, caddr_t addr,
1013130f4520SKenneth D. Merry int flag, struct thread *td)
1014130f4520SKenneth D. Merry {
101567cc546dSAlexander Motin struct ctl_be_ramdisk_softc *softc = &rd_softc;
101667cc546dSAlexander Motin struct ctl_lun_req *lun_req;
1017130f4520SKenneth D. Merry int retval;
1018130f4520SKenneth D. Merry
1019130f4520SKenneth D. Merry retval = 0;
1020130f4520SKenneth D. Merry switch (cmd) {
102167cc546dSAlexander Motin case CTL_LUN_REQ:
1022130f4520SKenneth D. Merry lun_req = (struct ctl_lun_req *)addr;
1023130f4520SKenneth D. Merry switch (lun_req->reqtype) {
1024130f4520SKenneth D. Merry case CTL_LUNREQ_CREATE:
10250bcd4ab6SAlexander Motin retval = ctl_backend_ramdisk_create(softc, lun_req);
1026130f4520SKenneth D. Merry break;
1027130f4520SKenneth D. Merry case CTL_LUNREQ_RM:
1028130f4520SKenneth D. Merry retval = ctl_backend_ramdisk_rm(softc, lun_req);
1029130f4520SKenneth D. Merry break;
103081177295SEdward Tomasz Napierala case CTL_LUNREQ_MODIFY:
103181177295SEdward Tomasz Napierala retval = ctl_backend_ramdisk_modify(softc, lun_req);
103281177295SEdward Tomasz Napierala break;
1033130f4520SKenneth D. Merry default:
1034130f4520SKenneth D. Merry lun_req->status = CTL_LUN_ERROR;
1035130f4520SKenneth D. Merry snprintf(lun_req->error_str, sizeof(lun_req->error_str),
1036130f4520SKenneth D. Merry "%s: invalid LUN request type %d", __func__,
1037130f4520SKenneth D. Merry lun_req->reqtype);
1038130f4520SKenneth D. Merry break;
1039130f4520SKenneth D. Merry }
1040130f4520SKenneth D. Merry break;
1041130f4520SKenneth D. Merry default:
1042130f4520SKenneth D. Merry retval = ENOTTY;
1043130f4520SKenneth D. Merry break;
1044130f4520SKenneth D. Merry }
1045130f4520SKenneth D. Merry
1046130f4520SKenneth D. Merry return (retval);
1047130f4520SKenneth D. Merry }
1048130f4520SKenneth D. Merry
1049130f4520SKenneth D. Merry static int
ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc * softc,struct ctl_lun_req * req)1050130f4520SKenneth D. Merry ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
1051130f4520SKenneth D. Merry struct ctl_lun_req *req)
1052130f4520SKenneth D. Merry {
1053130f4520SKenneth D. Merry struct ctl_be_ramdisk_lun *be_lun;
1054130f4520SKenneth D. Merry struct ctl_lun_rm_params *params;
1055130f4520SKenneth D. Merry int retval;
1056130f4520SKenneth D. Merry
1057130f4520SKenneth D. Merry params = &req->reqdata.rm;
105834144c2cSAlexander Motin sx_xlock(&softc->modify_lock);
1059130f4520SKenneth D. Merry mtx_lock(&softc->lock);
106034144c2cSAlexander Motin SLIST_FOREACH(be_lun, &softc->lun_list, links) {
106134144c2cSAlexander Motin if (be_lun->cbe_lun.lun_id == params->lun_id) {
106234144c2cSAlexander Motin SLIST_REMOVE(&softc->lun_list, be_lun,
106334144c2cSAlexander Motin ctl_be_ramdisk_lun, links);
106434144c2cSAlexander Motin softc->num_luns--;
1065130f4520SKenneth D. Merry break;
1066130f4520SKenneth D. Merry }
106734144c2cSAlexander Motin }
1068130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
106934144c2cSAlexander Motin sx_xunlock(&softc->modify_lock);
1070130f4520SKenneth D. Merry if (be_lun == NULL) {
1071130f4520SKenneth D. Merry snprintf(req->error_str, sizeof(req->error_str),
1072130f4520SKenneth D. Merry "%s: LUN %u is not managed by the ramdisk backend",
1073130f4520SKenneth D. Merry __func__, params->lun_id);
1074130f4520SKenneth D. Merry goto bailout_error;
1075130f4520SKenneth D. Merry }
1076130f4520SKenneth D. Merry
1077130f4520SKenneth D. Merry /*
1078130f4520SKenneth D. Merry * Set the waiting flag before we invalidate the LUN. Our shutdown
1079130f4520SKenneth D. Merry * routine can be called any time after we invalidate the LUN,
1080130f4520SKenneth D. Merry * and can be called from our context.
1081130f4520SKenneth D. Merry *
1082130f4520SKenneth D. Merry * This tells the shutdown routine that we're waiting, or we're
1083130f4520SKenneth D. Merry * going to wait for the shutdown to happen.
1084130f4520SKenneth D. Merry */
1085130f4520SKenneth D. Merry mtx_lock(&softc->lock);
1086130f4520SKenneth D. Merry be_lun->flags |= CTL_BE_RAMDISK_LUN_WAITING;
1087130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
1088130f4520SKenneth D. Merry
108934144c2cSAlexander Motin retval = ctl_remove_lun(&be_lun->cbe_lun);
1090130f4520SKenneth D. Merry if (retval != 0) {
1091130f4520SKenneth D. Merry snprintf(req->error_str, sizeof(req->error_str),
109234144c2cSAlexander Motin "%s: error %d returned from ctl_remove_lun() for "
1093130f4520SKenneth D. Merry "LUN %d", __func__, retval, params->lun_id);
1094ce300fbfSAlexander Motin mtx_lock(&softc->lock);
1095ce300fbfSAlexander Motin be_lun->flags &= ~CTL_BE_RAMDISK_LUN_WAITING;
1096ce300fbfSAlexander Motin mtx_unlock(&softc->lock);
1097130f4520SKenneth D. Merry goto bailout_error;
1098130f4520SKenneth D. Merry }
1099130f4520SKenneth D. Merry
1100130f4520SKenneth D. Merry mtx_lock(&softc->lock);
1101130f4520SKenneth D. Merry while ((be_lun->flags & CTL_BE_RAMDISK_LUN_UNCONFIGURED) == 0) {
110234144c2cSAlexander Motin retval = msleep(be_lun, &softc->lock, PCATCH, "ctlramrm", 0);
1103130f4520SKenneth D. Merry if (retval == EINTR)
1104130f4520SKenneth D. Merry break;
1105130f4520SKenneth D. Merry }
1106130f4520SKenneth D. Merry be_lun->flags &= ~CTL_BE_RAMDISK_LUN_WAITING;
110734144c2cSAlexander Motin if (be_lun->flags & CTL_BE_RAMDISK_LUN_UNCONFIGURED) {
1108130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
1109130f4520SKenneth D. Merry free(be_lun, M_RAMDISK);
111034144c2cSAlexander Motin } else {
111134144c2cSAlexander Motin mtx_unlock(&softc->lock);
111234144c2cSAlexander Motin return (EINTR);
111308a7cce5SAlexander Motin }
1114130f4520SKenneth D. Merry
1115130f4520SKenneth D. Merry req->status = CTL_LUN_OK;
1116130f4520SKenneth D. Merry return (retval);
1117130f4520SKenneth D. Merry
1118130f4520SKenneth D. Merry bailout_error:
1119130f4520SKenneth D. Merry req->status = CTL_LUN_ERROR;
1120130f4520SKenneth D. Merry return (0);
1121130f4520SKenneth D. Merry }
1122130f4520SKenneth D. Merry
1123130f4520SKenneth D. Merry static int
ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc * softc,struct ctl_lun_req * req)1124130f4520SKenneth D. Merry ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
11250bcd4ab6SAlexander Motin struct ctl_lun_req *req)
1126130f4520SKenneth D. Merry {
1127130f4520SKenneth D. Merry struct ctl_be_ramdisk_lun *be_lun;
11280bcd4ab6SAlexander Motin struct ctl_be_lun *cbe_lun;
1129130f4520SKenneth D. Merry struct ctl_lun_create_params *params;
11308951f055SMarcelo Araujo const char *value;
1131130f4520SKenneth D. Merry char tmpstr[32];
1132e7037673SAlexander Motin uint64_t t;
11330bcd4ab6SAlexander Motin int retval;
1134130f4520SKenneth D. Merry
1135130f4520SKenneth D. Merry retval = 0;
1136130f4520SKenneth D. Merry params = &req->reqdata.create;
1137130f4520SKenneth D. Merry
11380bcd4ab6SAlexander Motin be_lun = malloc(sizeof(*be_lun), M_RAMDISK, M_ZERO | M_WAITOK);
11390bcd4ab6SAlexander Motin cbe_lun = &be_lun->cbe_lun;
11408951f055SMarcelo Araujo cbe_lun->options = nvlist_clone(req->args_nvl);
1141a3977beaSAlexander Motin be_lun->params = req->reqdata.create;
11420bcd4ab6SAlexander Motin be_lun->softc = softc;
1143130f4520SKenneth D. Merry
1144130f4520SKenneth D. Merry if (params->flags & CTL_LUN_FLAG_DEV_TYPE)
11450bcd4ab6SAlexander Motin cbe_lun->lun_type = params->device_type;
1146130f4520SKenneth D. Merry else
11470bcd4ab6SAlexander Motin cbe_lun->lun_type = T_DIRECT;
114834144c2cSAlexander Motin be_lun->flags = 0;
11497ac58230SAlexander Motin cbe_lun->flags = 0;
11508951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "ha_role", NULL);
11517ac58230SAlexander Motin if (value != NULL) {
11527ac58230SAlexander Motin if (strcmp(value, "primary") == 0)
11537ac58230SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_PRIMARY;
11547ac58230SAlexander Motin } else if (control_softc->flags & CTL_FLAG_ACTIVE_SHELF)
11557ac58230SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_PRIMARY;
1156130f4520SKenneth D. Merry
1157e7037673SAlexander Motin be_lun->pblocksize = PAGE_SIZE;
11588951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "pblocksize", NULL);
1159e7037673SAlexander Motin if (value != NULL) {
1160e7037673SAlexander Motin ctl_expand_number(value, &t);
1161e7037673SAlexander Motin be_lun->pblocksize = t;
1162e7037673SAlexander Motin }
1163e7037673SAlexander Motin if (be_lun->pblocksize < 512 || be_lun->pblocksize > 131072) {
1164e7037673SAlexander Motin snprintf(req->error_str, sizeof(req->error_str),
1165e7037673SAlexander Motin "%s: unsupported pblocksize %u", __func__,
1166e7037673SAlexander Motin be_lun->pblocksize);
1167e7037673SAlexander Motin goto bailout_error;
1168e7037673SAlexander Motin }
1169e7037673SAlexander Motin
117091be33dcSAlexander Motin if (cbe_lun->lun_type == T_DIRECT ||
117191be33dcSAlexander Motin cbe_lun->lun_type == T_CDROM) {
11720bcd4ab6SAlexander Motin if (params->blocksize_bytes != 0)
11730bcd4ab6SAlexander Motin cbe_lun->blocksize = params->blocksize_bytes;
117491be33dcSAlexander Motin else if (cbe_lun->lun_type == T_CDROM)
117591be33dcSAlexander Motin cbe_lun->blocksize = 2048;
11760bcd4ab6SAlexander Motin else
11770bcd4ab6SAlexander Motin cbe_lun->blocksize = 512;
1178e7037673SAlexander Motin be_lun->pblockmul = be_lun->pblocksize / cbe_lun->blocksize;
1179e7037673SAlexander Motin if (be_lun->pblockmul < 1 || !powerof2(be_lun->pblockmul)) {
1180e7037673SAlexander Motin snprintf(req->error_str, sizeof(req->error_str),
1181e7037673SAlexander Motin "%s: pblocksize %u not exp2 of blocksize %u",
1182e7037673SAlexander Motin __func__,
1183e7037673SAlexander Motin be_lun->pblocksize, cbe_lun->blocksize);
1184e7037673SAlexander Motin goto bailout_error;
1185e7037673SAlexander Motin }
11860bcd4ab6SAlexander Motin if (params->lun_size_bytes < cbe_lun->blocksize) {
1187130f4520SKenneth D. Merry snprintf(req->error_str, sizeof(req->error_str),
1188130f4520SKenneth D. Merry "%s: LUN size %ju < blocksize %u", __func__,
11890bcd4ab6SAlexander Motin params->lun_size_bytes, cbe_lun->blocksize);
1190130f4520SKenneth D. Merry goto bailout_error;
1191130f4520SKenneth D. Merry }
11920bcd4ab6SAlexander Motin be_lun->size_blocks = params->lun_size_bytes / cbe_lun->blocksize;
11930bcd4ab6SAlexander Motin be_lun->size_bytes = be_lun->size_blocks * cbe_lun->blocksize;
1194e7037673SAlexander Motin be_lun->indir = 0;
1195e7037673SAlexander Motin t = be_lun->size_bytes / be_lun->pblocksize;
1196e7037673SAlexander Motin while (t > 1) {
1197e7037673SAlexander Motin t /= PPP;
1198e7037673SAlexander Motin be_lun->indir++;
1199e7037673SAlexander Motin }
12000bcd4ab6SAlexander Motin cbe_lun->maxlba = be_lun->size_blocks - 1;
1201e7037673SAlexander Motin cbe_lun->pblockexp = fls(be_lun->pblockmul) - 1;
1202e7037673SAlexander Motin cbe_lun->pblockoff = 0;
1203e7037673SAlexander Motin cbe_lun->ublockexp = cbe_lun->pblockexp;
1204e7037673SAlexander Motin cbe_lun->ublockoff = 0;
1205e7037673SAlexander Motin cbe_lun->atomicblock = be_lun->pblocksize;
1206e7037673SAlexander Motin cbe_lun->opttxferlen = SGPP * be_lun->pblocksize;
12078951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "capacity", NULL);
1208e7037673SAlexander Motin if (value != NULL)
1209e7037673SAlexander Motin ctl_expand_number(value, &be_lun->cap_bytes);
1210e7037673SAlexander Motin } else {
1211e7037673SAlexander Motin be_lun->pblockmul = 1;
1212e7037673SAlexander Motin cbe_lun->pblockexp = 0;
1213130f4520SKenneth D. Merry }
1214130f4520SKenneth D. Merry
1215130f4520SKenneth D. Merry /* Tell the user the blocksize we ended up using */
12160bcd4ab6SAlexander Motin params->blocksize_bytes = cbe_lun->blocksize;
1217130f4520SKenneth D. Merry params->lun_size_bytes = be_lun->size_bytes;
1218130f4520SKenneth D. Merry
12198951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "unmap", NULL);
12201173e5a7SAlexander Motin if (value == NULL || strcmp(value, "off") != 0)
12210bcd4ab6SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_UNMAP;
12228951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "readonly", NULL);
122391be33dcSAlexander Motin if (value != NULL) {
122491be33dcSAlexander Motin if (strcmp(value, "on") == 0)
122591be33dcSAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_READONLY;
122691be33dcSAlexander Motin } else if (cbe_lun->lun_type != T_DIRECT)
12270bcd4ab6SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_READONLY;
12280bcd4ab6SAlexander Motin cbe_lun->serseq = CTL_LUN_SERSEQ_OFF;
12298951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "serseq", NULL);
12300bcd4ab6SAlexander Motin if (value != NULL && strcmp(value, "on") == 0)
12310bcd4ab6SAlexander Motin cbe_lun->serseq = CTL_LUN_SERSEQ_ON;
12320bcd4ab6SAlexander Motin else if (value != NULL && strcmp(value, "read") == 0)
12330bcd4ab6SAlexander Motin cbe_lun->serseq = CTL_LUN_SERSEQ_READ;
1234ac503c19SAlexander Motin else if (value != NULL && strcmp(value, "soft") == 0)
1235ac503c19SAlexander Motin cbe_lun->serseq = CTL_LUN_SERSEQ_SOFT;
12360bcd4ab6SAlexander Motin else if (value != NULL && strcmp(value, "off") == 0)
12370bcd4ab6SAlexander Motin cbe_lun->serseq = CTL_LUN_SERSEQ_OFF;
1238130f4520SKenneth D. Merry
1239130f4520SKenneth D. Merry if (params->flags & CTL_LUN_FLAG_ID_REQ) {
12400bcd4ab6SAlexander Motin cbe_lun->req_lun_id = params->req_lun_id;
12410bcd4ab6SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_ID_REQ;
1242130f4520SKenneth D. Merry } else
12430bcd4ab6SAlexander Motin cbe_lun->req_lun_id = 0;
1244130f4520SKenneth D. Merry
12450bcd4ab6SAlexander Motin cbe_lun->lun_shutdown = ctl_backend_ramdisk_lun_shutdown;
12460bcd4ab6SAlexander Motin cbe_lun->be = &ctl_be_ramdisk_driver;
1247130f4520SKenneth D. Merry if ((params->flags & CTL_LUN_FLAG_SERIAL_NUM) == 0) {
124871cd87c6SAlan Somers snprintf(tmpstr, sizeof(tmpstr), "MYSERIAL%04d",
1249130f4520SKenneth D. Merry softc->num_luns);
12500bcd4ab6SAlexander Motin strncpy((char *)cbe_lun->serial_num, tmpstr,
12510bcd4ab6SAlexander Motin MIN(sizeof(cbe_lun->serial_num), sizeof(tmpstr)));
1252130f4520SKenneth D. Merry
1253130f4520SKenneth D. Merry /* Tell the user what we used for a serial number */
1254130f4520SKenneth D. Merry strncpy((char *)params->serial_num, tmpstr,
1255e7038eb7SAlexander Motin MIN(sizeof(params->serial_num), sizeof(tmpstr)));
1256130f4520SKenneth D. Merry } else {
12570bcd4ab6SAlexander Motin strncpy((char *)cbe_lun->serial_num, params->serial_num,
12580bcd4ab6SAlexander Motin MIN(sizeof(cbe_lun->serial_num),
1259130f4520SKenneth D. Merry sizeof(params->serial_num)));
1260130f4520SKenneth D. Merry }
1261130f4520SKenneth D. Merry if ((params->flags & CTL_LUN_FLAG_DEVID) == 0) {
126271cd87c6SAlan Somers snprintf(tmpstr, sizeof(tmpstr), "MYDEVID%04d", softc->num_luns);
12630bcd4ab6SAlexander Motin strncpy((char *)cbe_lun->device_id, tmpstr,
12640bcd4ab6SAlexander Motin MIN(sizeof(cbe_lun->device_id), sizeof(tmpstr)));
1265130f4520SKenneth D. Merry
1266130f4520SKenneth D. Merry /* Tell the user what we used for a device ID */
1267130f4520SKenneth D. Merry strncpy((char *)params->device_id, tmpstr,
1268e7038eb7SAlexander Motin MIN(sizeof(params->device_id), sizeof(tmpstr)));
1269130f4520SKenneth D. Merry } else {
12700bcd4ab6SAlexander Motin strncpy((char *)cbe_lun->device_id, params->device_id,
12710bcd4ab6SAlexander Motin MIN(sizeof(cbe_lun->device_id),
1272130f4520SKenneth D. Merry sizeof(params->device_id)));
1273130f4520SKenneth D. Merry }
1274130f4520SKenneth D. Merry
127508a7cce5SAlexander Motin STAILQ_INIT(&be_lun->cont_queue);
127634144c2cSAlexander Motin sx_init(&be_lun->page_lock, "ctlram page");
12772fb36370SAlexander Motin if (be_lun->cap_bytes == 0) {
12782fb36370SAlexander Motin be_lun->indir = 0;
1279e7037673SAlexander Motin be_lun->pages = malloc(be_lun->pblocksize, M_RAMDISK, M_WAITOK);
12802fb36370SAlexander Motin }
1281e7037673SAlexander Motin be_lun->zero_page = malloc(be_lun->pblocksize, M_RAMDISK,
1282e7037673SAlexander Motin M_WAITOK|M_ZERO);
128334144c2cSAlexander Motin mtx_init(&be_lun->queue_lock, "ctlram queue", NULL, MTX_DEF);
128408a7cce5SAlexander Motin TASK_INIT(&be_lun->io_task, /*priority*/0, ctl_backend_ramdisk_worker,
128508a7cce5SAlexander Motin be_lun);
128608a7cce5SAlexander Motin
128734144c2cSAlexander Motin be_lun->io_taskqueue = taskqueue_create("ctlramtq", M_WAITOK,
128808a7cce5SAlexander Motin taskqueue_thread_enqueue, /*context*/&be_lun->io_taskqueue);
128908a7cce5SAlexander Motin if (be_lun->io_taskqueue == NULL) {
129008a7cce5SAlexander Motin snprintf(req->error_str, sizeof(req->error_str),
129108a7cce5SAlexander Motin "%s: Unable to create taskqueue", __func__);
129208a7cce5SAlexander Motin goto bailout_error;
129308a7cce5SAlexander Motin }
129408a7cce5SAlexander Motin
129512373e95SAlexander Motin retval = taskqueue_start_threads_in_proc(&be_lun->io_taskqueue,
129608a7cce5SAlexander Motin /*num threads*/1,
1297053db1feSAlexander Motin /*priority*/PUSER,
129812373e95SAlexander Motin /*proc*/control_softc->ctl_proc,
129934144c2cSAlexander Motin /*thread name*/"ramdisk");
130008a7cce5SAlexander Motin if (retval != 0)
130108a7cce5SAlexander Motin goto bailout_error;
130208a7cce5SAlexander Motin
13030bcd4ab6SAlexander Motin retval = ctl_add_lun(&be_lun->cbe_lun);
1304130f4520SKenneth D. Merry if (retval != 0) {
1305130f4520SKenneth D. Merry snprintf(req->error_str, sizeof(req->error_str),
1306130f4520SKenneth D. Merry "%s: ctl_add_lun() returned error %d, see dmesg for "
1307130f4520SKenneth D. Merry "details", __func__, retval);
1308130f4520SKenneth D. Merry retval = 0;
1309130f4520SKenneth D. Merry goto bailout_error;
1310130f4520SKenneth D. Merry }
1311130f4520SKenneth D. Merry
1312130f4520SKenneth D. Merry mtx_lock(&softc->lock);
131334144c2cSAlexander Motin softc->num_luns++;
131434144c2cSAlexander Motin SLIST_INSERT_HEAD(&softc->lun_list, be_lun, links);
1315130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
131634144c2cSAlexander Motin
13170bcd4ab6SAlexander Motin params->req_lun_id = cbe_lun->lun_id;
1318130f4520SKenneth D. Merry
1319130f4520SKenneth D. Merry req->status = CTL_LUN_OK;
1320130f4520SKenneth D. Merry return (retval);
1321130f4520SKenneth D. Merry
1322130f4520SKenneth D. Merry bailout_error:
1323130f4520SKenneth D. Merry req->status = CTL_LUN_ERROR;
132408a7cce5SAlexander Motin if (be_lun != NULL) {
1325e7037673SAlexander Motin if (be_lun->io_taskqueue != NULL)
132608a7cce5SAlexander Motin taskqueue_free(be_lun->io_taskqueue);
13278951f055SMarcelo Araujo nvlist_destroy(cbe_lun->options);
1328e7037673SAlexander Motin free(be_lun->zero_page, M_RAMDISK);
1329e7037673SAlexander Motin ctl_backend_ramdisk_freeallpages(be_lun->pages, be_lun->indir);
1330e7037673SAlexander Motin sx_destroy(&be_lun->page_lock);
133175c7a1d3SAlexander Motin mtx_destroy(&be_lun->queue_lock);
1332130f4520SKenneth D. Merry free(be_lun, M_RAMDISK);
133308a7cce5SAlexander Motin }
1334130f4520SKenneth D. Merry return (retval);
1335130f4520SKenneth D. Merry }
1336130f4520SKenneth D. Merry
133781177295SEdward Tomasz Napierala static int
ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc * softc,struct ctl_lun_req * req)133881177295SEdward Tomasz Napierala ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc *softc,
133981177295SEdward Tomasz Napierala struct ctl_lun_req *req)
134081177295SEdward Tomasz Napierala {
134181177295SEdward Tomasz Napierala struct ctl_be_ramdisk_lun *be_lun;
1342a3977beaSAlexander Motin struct ctl_be_lun *cbe_lun;
134381177295SEdward Tomasz Napierala struct ctl_lun_modify_params *params;
13448951f055SMarcelo Araujo const char *value;
134581177295SEdward Tomasz Napierala uint32_t blocksize;
13467ac58230SAlexander Motin int wasprim;
134781177295SEdward Tomasz Napierala
134881177295SEdward Tomasz Napierala params = &req->reqdata.modify;
134934144c2cSAlexander Motin sx_xlock(&softc->modify_lock);
135081177295SEdward Tomasz Napierala mtx_lock(&softc->lock);
135134144c2cSAlexander Motin SLIST_FOREACH(be_lun, &softc->lun_list, links) {
13520bcd4ab6SAlexander Motin if (be_lun->cbe_lun.lun_id == params->lun_id)
135381177295SEdward Tomasz Napierala break;
135481177295SEdward Tomasz Napierala }
135581177295SEdward Tomasz Napierala mtx_unlock(&softc->lock);
135681177295SEdward Tomasz Napierala if (be_lun == NULL) {
135781177295SEdward Tomasz Napierala snprintf(req->error_str, sizeof(req->error_str),
135881177295SEdward Tomasz Napierala "%s: LUN %u is not managed by the ramdisk backend",
135981177295SEdward Tomasz Napierala __func__, params->lun_id);
136081177295SEdward Tomasz Napierala goto bailout_error;
136181177295SEdward Tomasz Napierala }
1362a3977beaSAlexander Motin cbe_lun = &be_lun->cbe_lun;
136381177295SEdward Tomasz Napierala
1364a3977beaSAlexander Motin if (params->lun_size_bytes != 0)
1365a3977beaSAlexander Motin be_lun->params.lun_size_bytes = params->lun_size_bytes;
13668951f055SMarcelo Araujo
1367efeedddcSAlexander Motin if (req->args_nvl != NULL) {
13688951f055SMarcelo Araujo nvlist_destroy(cbe_lun->options);
13698951f055SMarcelo Araujo cbe_lun->options = nvlist_clone(req->args_nvl);
1370efeedddcSAlexander Motin }
137181177295SEdward Tomasz Napierala
13727ac58230SAlexander Motin wasprim = (cbe_lun->flags & CTL_LUN_FLAG_PRIMARY);
13738951f055SMarcelo Araujo value = dnvlist_get_string(cbe_lun->options, "ha_role", NULL);
13747ac58230SAlexander Motin if (value != NULL) {
13757ac58230SAlexander Motin if (strcmp(value, "primary") == 0)
13767ac58230SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_PRIMARY;
13777ac58230SAlexander Motin else
13787ac58230SAlexander Motin cbe_lun->flags &= ~CTL_LUN_FLAG_PRIMARY;
13797ac58230SAlexander Motin } else if (control_softc->flags & CTL_FLAG_ACTIVE_SHELF)
13807ac58230SAlexander Motin cbe_lun->flags |= CTL_LUN_FLAG_PRIMARY;
13817ac58230SAlexander Motin else
13827ac58230SAlexander Motin cbe_lun->flags &= ~CTL_LUN_FLAG_PRIMARY;
13837ac58230SAlexander Motin if (wasprim != (cbe_lun->flags & CTL_LUN_FLAG_PRIMARY)) {
13847ac58230SAlexander Motin if (cbe_lun->flags & CTL_LUN_FLAG_PRIMARY)
13857ac58230SAlexander Motin ctl_lun_primary(cbe_lun);
13867ac58230SAlexander Motin else
13877ac58230SAlexander Motin ctl_lun_secondary(cbe_lun);
13887ac58230SAlexander Motin }
13897ac58230SAlexander Motin
13907ac58230SAlexander Motin blocksize = be_lun->cbe_lun.blocksize;
1391a3977beaSAlexander Motin if (be_lun->params.lun_size_bytes < blocksize) {
139281177295SEdward Tomasz Napierala snprintf(req->error_str, sizeof(req->error_str),
139381177295SEdward Tomasz Napierala "%s: LUN size %ju < blocksize %u", __func__,
1394a3977beaSAlexander Motin be_lun->params.lun_size_bytes, blocksize);
139581177295SEdward Tomasz Napierala goto bailout_error;
139681177295SEdward Tomasz Napierala }
1397a3977beaSAlexander Motin be_lun->size_blocks = be_lun->params.lun_size_bytes / blocksize;
139881177295SEdward Tomasz Napierala be_lun->size_bytes = be_lun->size_blocks * blocksize;
13990bcd4ab6SAlexander Motin be_lun->cbe_lun.maxlba = be_lun->size_blocks - 1;
14000bcd4ab6SAlexander Motin ctl_lun_capacity_changed(&be_lun->cbe_lun);
140181177295SEdward Tomasz Napierala
140281177295SEdward Tomasz Napierala /* Tell the user the exact size we ended up using */
140381177295SEdward Tomasz Napierala params->lun_size_bytes = be_lun->size_bytes;
140481177295SEdward Tomasz Napierala
140534144c2cSAlexander Motin sx_xunlock(&softc->modify_lock);
140681177295SEdward Tomasz Napierala req->status = CTL_LUN_OK;
140781177295SEdward Tomasz Napierala return (0);
140881177295SEdward Tomasz Napierala
140981177295SEdward Tomasz Napierala bailout_error:
141034144c2cSAlexander Motin sx_xunlock(&softc->modify_lock);
141181177295SEdward Tomasz Napierala req->status = CTL_LUN_ERROR;
141281177295SEdward Tomasz Napierala return (0);
141381177295SEdward Tomasz Napierala }
141481177295SEdward Tomasz Napierala
1415130f4520SKenneth D. Merry static void
ctl_backend_ramdisk_lun_shutdown(struct ctl_be_lun * cbe_lun)1416767300e8SAlexander Motin ctl_backend_ramdisk_lun_shutdown(struct ctl_be_lun *cbe_lun)
1417130f4520SKenneth D. Merry {
1418767300e8SAlexander Motin struct ctl_be_ramdisk_lun *be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun;
141934144c2cSAlexander Motin struct ctl_be_ramdisk_softc *softc = be_lun->softc;
142034144c2cSAlexander Motin
142134144c2cSAlexander Motin taskqueue_drain_all(be_lun->io_taskqueue);
142234144c2cSAlexander Motin taskqueue_free(be_lun->io_taskqueue);
142334144c2cSAlexander Motin nvlist_destroy(be_lun->cbe_lun.options);
142434144c2cSAlexander Motin free(be_lun->zero_page, M_RAMDISK);
142534144c2cSAlexander Motin ctl_backend_ramdisk_freeallpages(be_lun->pages, be_lun->indir);
142634144c2cSAlexander Motin sx_destroy(&be_lun->page_lock);
142734144c2cSAlexander Motin mtx_destroy(&be_lun->queue_lock);
1428130f4520SKenneth D. Merry
1429130f4520SKenneth D. Merry mtx_lock(&softc->lock);
143034144c2cSAlexander Motin be_lun->flags |= CTL_BE_RAMDISK_LUN_UNCONFIGURED;
143134144c2cSAlexander Motin if (be_lun->flags & CTL_BE_RAMDISK_LUN_WAITING)
143234144c2cSAlexander Motin wakeup(be_lun);
143334144c2cSAlexander Motin else
143468bf823fSAlexander Motin free(be_lun, M_RAMDISK);
1435130f4520SKenneth D. Merry mtx_unlock(&softc->lock);
1436130f4520SKenneth D. Merry }
1437