1 /*- 2 * Copyright (c) 2003-2009 Silicon Graphics International Corp. 3 * Copyright (c) 2012 The FreeBSD Foundation 4 * Copyright (c) 2015 Alexander Motin <mav@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer, 12 * without modification, immediately at the beginning of the file. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/types.h> 36 #include <sys/lock.h> 37 #include <sys/module.h> 38 #include <sys/mutex.h> 39 #include <sys/condvar.h> 40 #include <sys/malloc.h> 41 #include <sys/conf.h> 42 #include <sys/queue.h> 43 #include <sys/sysctl.h> 44 45 #include <cam/cam.h> 46 #include <cam/scsi/scsi_all.h> 47 #include <cam/scsi/scsi_da.h> 48 #include <cam/ctl/ctl_io.h> 49 #include <cam/ctl/ctl.h> 50 #include <cam/ctl/ctl_frontend.h> 51 #include <cam/ctl/ctl_util.h> 52 #include <cam/ctl/ctl_backend.h> 53 #include <cam/ctl/ctl_ioctl.h> 54 #include <cam/ctl/ctl_ha.h> 55 #include <cam/ctl/ctl_private.h> 56 #include <cam/ctl/ctl_debug.h> 57 #include <cam/ctl/ctl_error.h> 58 59 typedef enum { 60 CTL_IOCTL_INPROG, 61 CTL_IOCTL_DATAMOVE, 62 CTL_IOCTL_DONE 63 } ctl_fe_ioctl_state; 64 65 struct ctl_fe_ioctl_params { 66 struct cv sem; 67 struct mtx ioctl_mtx; 68 ctl_fe_ioctl_state state; 69 }; 70 71 struct cfi_softc { 72 uint32_t cur_tag_num; 73 struct ctl_port port; 74 }; 75 76 static struct cfi_softc cfi_softc; 77 78 static int cfi_init(void); 79 static int cfi_shutdown(void); 80 static void cfi_datamove(union ctl_io *io); 81 static void cfi_done(union ctl_io *io); 82 83 static struct ctl_frontend cfi_frontend = 84 { 85 .name = "ioctl", 86 .init = cfi_init, 87 .shutdown = cfi_shutdown, 88 }; 89 CTL_FRONTEND_DECLARE(ctlioctl, cfi_frontend); 90 91 static int 92 cfi_init(void) 93 { 94 struct cfi_softc *isoftc = &cfi_softc; 95 struct ctl_port *port; 96 int error = 0; 97 98 memset(isoftc, 0, sizeof(*isoftc)); 99 100 port = &isoftc->port; 101 port->frontend = &cfi_frontend; 102 port->port_type = CTL_PORT_IOCTL; 103 port->num_requested_ctl_io = 100; 104 port->port_name = "ioctl"; 105 port->fe_datamove = cfi_datamove; 106 port->fe_done = cfi_done; 107 port->targ_port = -1; 108 port->max_initiators = 1; 109 110 if ((error = ctl_port_register(port)) != 0) { 111 printf("%s: ioctl port registration failed\n", __func__); 112 return (error); 113 } 114 ctl_port_online(port); 115 return (0); 116 } 117 118 static int 119 cfi_shutdown(void) 120 { 121 struct cfi_softc *isoftc = &cfi_softc; 122 struct ctl_port *port = &isoftc->port; 123 int error = 0; 124 125 ctl_port_offline(port); 126 if ((error = ctl_port_deregister(port)) != 0) 127 printf("%s: ioctl port deregistration failed\n", __func__); 128 return (error); 129 } 130 131 /* 132 * Data movement routine for the CTL ioctl frontend port. 133 */ 134 static int 135 ctl_ioctl_do_datamove(struct ctl_scsiio *ctsio) 136 { 137 struct ctl_sg_entry *ext_sglist, *kern_sglist; 138 struct ctl_sg_entry ext_entry, kern_entry; 139 int ext_sglen, ext_sg_entries, kern_sg_entries; 140 int ext_sg_start, ext_offset; 141 int len_to_copy; 142 int kern_watermark, ext_watermark; 143 int ext_sglist_malloced; 144 int i, j; 145 146 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove\n")); 147 148 /* 149 * If this flag is set, fake the data transfer. 150 */ 151 if (ctsio->io_hdr.flags & CTL_FLAG_NO_DATAMOVE) { 152 ext_sglist_malloced = 0; 153 ctsio->ext_data_filled += ctsio->kern_data_len; 154 ctsio->kern_data_resid = 0; 155 goto bailout; 156 } 157 158 /* 159 * To simplify things here, if we have a single buffer, stick it in 160 * a S/G entry and just make it a single entry S/G list. 161 */ 162 if (ctsio->ext_sg_entries > 0) { 163 int len_seen; 164 165 ext_sglen = ctsio->ext_sg_entries * sizeof(*ext_sglist); 166 ext_sglist = (struct ctl_sg_entry *)malloc(ext_sglen, M_CTL, 167 M_WAITOK); 168 ext_sglist_malloced = 1; 169 if (copyin(ctsio->ext_data_ptr, ext_sglist, ext_sglen) != 0) { 170 ctsio->io_hdr.port_status = 31343; 171 goto bailout; 172 } 173 ext_sg_entries = ctsio->ext_sg_entries; 174 ext_sg_start = ext_sg_entries; 175 ext_offset = 0; 176 len_seen = 0; 177 for (i = 0; i < ext_sg_entries; i++) { 178 if ((len_seen + ext_sglist[i].len) >= 179 ctsio->ext_data_filled) { 180 ext_sg_start = i; 181 ext_offset = ctsio->ext_data_filled - len_seen; 182 break; 183 } 184 len_seen += ext_sglist[i].len; 185 } 186 } else { 187 ext_sglist = &ext_entry; 188 ext_sglist_malloced = 0; 189 ext_sglist->addr = ctsio->ext_data_ptr; 190 ext_sglist->len = ctsio->ext_data_len; 191 ext_sg_entries = 1; 192 ext_sg_start = 0; 193 ext_offset = ctsio->ext_data_filled; 194 } 195 196 if (ctsio->kern_sg_entries > 0) { 197 kern_sglist = (struct ctl_sg_entry *)ctsio->kern_data_ptr; 198 kern_sg_entries = ctsio->kern_sg_entries; 199 } else { 200 kern_sglist = &kern_entry; 201 kern_sglist->addr = ctsio->kern_data_ptr; 202 kern_sglist->len = ctsio->kern_data_len; 203 kern_sg_entries = 1; 204 } 205 206 kern_watermark = 0; 207 ext_watermark = ext_offset; 208 for (i = ext_sg_start, j = 0; 209 i < ext_sg_entries && j < kern_sg_entries;) { 210 uint8_t *ext_ptr, *kern_ptr; 211 212 len_to_copy = MIN(ext_sglist[i].len - ext_watermark, 213 kern_sglist[j].len - kern_watermark); 214 215 ext_ptr = (uint8_t *)ext_sglist[i].addr; 216 ext_ptr = ext_ptr + ext_watermark; 217 if (ctsio->io_hdr.flags & CTL_FLAG_BUS_ADDR) { 218 /* 219 * XXX KDM fix this! 220 */ 221 panic("need to implement bus address support"); 222 #if 0 223 kern_ptr = bus_to_virt(kern_sglist[j].addr); 224 #endif 225 } else 226 kern_ptr = (uint8_t *)kern_sglist[j].addr; 227 kern_ptr = kern_ptr + kern_watermark; 228 229 if ((ctsio->io_hdr.flags & CTL_FLAG_DATA_MASK) == 230 CTL_FLAG_DATA_IN) { 231 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove: copying %d " 232 "bytes to user\n", len_to_copy)); 233 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove: from %p " 234 "to %p\n", kern_ptr, ext_ptr)); 235 if (copyout(kern_ptr, ext_ptr, len_to_copy) != 0) { 236 ctsio->io_hdr.port_status = 31344; 237 goto bailout; 238 } 239 } else { 240 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove: copying %d " 241 "bytes from user\n", len_to_copy)); 242 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove: from %p " 243 "to %p\n", ext_ptr, kern_ptr)); 244 if (copyin(ext_ptr, kern_ptr, len_to_copy)!= 0){ 245 ctsio->io_hdr.port_status = 31345; 246 goto bailout; 247 } 248 } 249 250 ctsio->ext_data_filled += len_to_copy; 251 ctsio->kern_data_resid -= len_to_copy; 252 253 ext_watermark += len_to_copy; 254 if (ext_sglist[i].len == ext_watermark) { 255 i++; 256 ext_watermark = 0; 257 } 258 259 kern_watermark += len_to_copy; 260 if (kern_sglist[j].len == kern_watermark) { 261 j++; 262 kern_watermark = 0; 263 } 264 } 265 266 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove: ext_sg_entries: %d, " 267 "kern_sg_entries: %d\n", ext_sg_entries, 268 kern_sg_entries)); 269 CTL_DEBUG_PRINT(("ctl_ioctl_do_datamove: ext_data_len = %d, " 270 "kern_data_len = %d\n", ctsio->ext_data_len, 271 ctsio->kern_data_len)); 272 273 bailout: 274 if (ext_sglist_malloced != 0) 275 free(ext_sglist, M_CTL); 276 277 return (CTL_RETVAL_COMPLETE); 278 } 279 280 static void 281 cfi_datamove(union ctl_io *io) 282 { 283 struct ctl_fe_ioctl_params *params; 284 285 params = (struct ctl_fe_ioctl_params *) 286 io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr; 287 288 mtx_lock(¶ms->ioctl_mtx); 289 params->state = CTL_IOCTL_DATAMOVE; 290 cv_broadcast(¶ms->sem); 291 mtx_unlock(¶ms->ioctl_mtx); 292 } 293 294 static void 295 cfi_done(union ctl_io *io) 296 { 297 struct ctl_fe_ioctl_params *params; 298 299 params = (struct ctl_fe_ioctl_params *) 300 io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr; 301 302 mtx_lock(¶ms->ioctl_mtx); 303 params->state = CTL_IOCTL_DONE; 304 cv_broadcast(¶ms->sem); 305 mtx_unlock(¶ms->ioctl_mtx); 306 } 307 308 static int 309 cfi_submit_wait(union ctl_io *io) 310 { 311 struct ctl_fe_ioctl_params params; 312 ctl_fe_ioctl_state last_state; 313 int done, retval; 314 315 bzero(¶ms, sizeof(params)); 316 mtx_init(¶ms.ioctl_mtx, "ctliocmtx", NULL, MTX_DEF); 317 cv_init(¶ms.sem, "ctlioccv"); 318 params.state = CTL_IOCTL_INPROG; 319 last_state = params.state; 320 321 io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = ¶ms; 322 323 CTL_DEBUG_PRINT(("cfi_submit_wait\n")); 324 325 /* This shouldn't happen */ 326 if ((retval = ctl_queue(io)) != CTL_RETVAL_COMPLETE) 327 return (retval); 328 329 done = 0; 330 331 do { 332 mtx_lock(¶ms.ioctl_mtx); 333 /* 334 * Check the state here, and don't sleep if the state has 335 * already changed (i.e. wakeup has already occurred, but we 336 * weren't waiting yet). 337 */ 338 if (params.state == last_state) { 339 /* XXX KDM cv_wait_sig instead? */ 340 cv_wait(¶ms.sem, ¶ms.ioctl_mtx); 341 } 342 last_state = params.state; 343 344 switch (params.state) { 345 case CTL_IOCTL_INPROG: 346 /* Why did we wake up? */ 347 /* XXX KDM error here? */ 348 mtx_unlock(¶ms.ioctl_mtx); 349 break; 350 case CTL_IOCTL_DATAMOVE: 351 CTL_DEBUG_PRINT(("got CTL_IOCTL_DATAMOVE\n")); 352 353 /* 354 * change last_state back to INPROG to avoid 355 * deadlock on subsequent data moves. 356 */ 357 params.state = last_state = CTL_IOCTL_INPROG; 358 359 mtx_unlock(¶ms.ioctl_mtx); 360 ctl_ioctl_do_datamove(&io->scsiio); 361 /* 362 * Note that in some cases, most notably writes, 363 * this will queue the I/O and call us back later. 364 * In other cases, generally reads, this routine 365 * will immediately call back and wake us up, 366 * probably using our own context. 367 */ 368 io->scsiio.be_move_done(io); 369 break; 370 case CTL_IOCTL_DONE: 371 mtx_unlock(¶ms.ioctl_mtx); 372 CTL_DEBUG_PRINT(("got CTL_IOCTL_DONE\n")); 373 done = 1; 374 break; 375 default: 376 mtx_unlock(¶ms.ioctl_mtx); 377 /* XXX KDM error here? */ 378 break; 379 } 380 } while (done == 0); 381 382 mtx_destroy(¶ms.ioctl_mtx); 383 cv_destroy(¶ms.sem); 384 385 return (CTL_RETVAL_COMPLETE); 386 } 387 388 int 389 ctl_ioctl_io(struct cdev *dev, u_long cmd, caddr_t addr, int flag, 390 struct thread *td) 391 { 392 union ctl_io *io; 393 void *pool_tmp, *sc_tmp; 394 int retval = 0; 395 396 /* 397 * If we haven't been "enabled", don't allow any SCSI I/O 398 * to this FETD. 399 */ 400 if ((cfi_softc.port.status & CTL_PORT_STATUS_ONLINE) == 0) 401 return (EPERM); 402 403 io = ctl_alloc_io(cfi_softc.port.ctl_pool_ref); 404 405 /* 406 * Need to save the pool reference so it doesn't get 407 * spammed by the user's ctl_io. 408 */ 409 pool_tmp = io->io_hdr.pool; 410 sc_tmp = CTL_SOFTC(io); 411 memcpy(io, (void *)addr, sizeof(*io)); 412 io->io_hdr.pool = pool_tmp; 413 CTL_SOFTC(io) = sc_tmp; 414 415 /* 416 * No status yet, so make sure the status is set properly. 417 */ 418 io->io_hdr.status = CTL_STATUS_NONE; 419 420 /* 421 * The user sets the initiator ID, target and LUN IDs. 422 */ 423 io->io_hdr.nexus.targ_port = cfi_softc.port.targ_port; 424 io->io_hdr.flags |= CTL_FLAG_USER_REQ; 425 if ((io->io_hdr.io_type == CTL_IO_SCSI) && 426 (io->scsiio.tag_type != CTL_TAG_UNTAGGED)) 427 io->scsiio.tag_num = cfi_softc.cur_tag_num++; 428 429 retval = cfi_submit_wait(io); 430 if (retval == 0) 431 memcpy((void *)addr, io, sizeof(*io)); 432 ctl_free_io(io); 433 return (retval); 434 } 435