1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2000 Matthew Jacob 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. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 34 #include <sys/conf.h> 35 #include <sys/errno.h> 36 #include <sys/fcntl.h> 37 #include <sys/kernel.h> 38 #include <sys/kthread.h> 39 #include <sys/lock.h> 40 #include <sys/malloc.h> 41 #include <sys/mutex.h> 42 #include <sys/queue.h> 43 #include <sys/sbuf.h> 44 #include <sys/sx.h> 45 #include <sys/systm.h> 46 #include <sys/sysctl.h> 47 #include <sys/types.h> 48 49 #include <machine/stdarg.h> 50 51 #include <cam/cam.h> 52 #include <cam/cam_ccb.h> 53 #include <cam/cam_debug.h> 54 #include <cam/cam_periph.h> 55 #include <cam/cam_xpt_periph.h> 56 57 #include <cam/scsi/scsi_all.h> 58 #include <cam/scsi/scsi_message.h> 59 #include <cam/scsi/scsi_enc.h> 60 #include <cam/scsi/scsi_enc_internal.h> 61 62 #include "opt_ses.h" 63 64 MALLOC_DEFINE(M_SCSIENC, "SCSI ENC", "SCSI ENC buffers"); 65 66 /* Enclosure type independent driver */ 67 68 static d_open_t enc_open; 69 static d_close_t enc_close; 70 static d_ioctl_t enc_ioctl; 71 static periph_init_t enc_init; 72 static periph_ctor_t enc_ctor; 73 static periph_oninv_t enc_oninvalidate; 74 static periph_dtor_t enc_dtor; 75 76 static void enc_async(void *, uint32_t, struct cam_path *, void *); 77 static enctyp enc_type(struct ccb_getdev *); 78 79 SYSCTL_NODE(_kern_cam, OID_AUTO, enc, CTLFLAG_RD, 0, 80 "CAM Enclosure Services driver"); 81 82 static struct periph_driver encdriver = { 83 enc_init, "ses", 84 TAILQ_HEAD_INITIALIZER(encdriver.units), /* generation */ 0 85 }; 86 87 PERIPHDRIVER_DECLARE(enc, encdriver); 88 89 static struct cdevsw enc_cdevsw = { 90 .d_version = D_VERSION, 91 .d_open = enc_open, 92 .d_close = enc_close, 93 .d_ioctl = enc_ioctl, 94 .d_name = "ses", 95 .d_flags = D_TRACKCLOSE, 96 }; 97 98 static void 99 enc_init(void) 100 { 101 cam_status status; 102 103 /* 104 * Install a global async callback. This callback will 105 * receive async callbacks like "new device found". 106 */ 107 status = xpt_register_async(AC_FOUND_DEVICE, enc_async, NULL, NULL); 108 109 if (status != CAM_REQ_CMP) { 110 printf("enc: Failed to attach master async callback " 111 "due to status 0x%x!\n", status); 112 } 113 } 114 115 static void 116 enc_devgonecb(void *arg) 117 { 118 struct cam_periph *periph; 119 struct enc_softc *enc; 120 struct mtx *mtx; 121 int i; 122 123 periph = (struct cam_periph *)arg; 124 mtx = cam_periph_mtx(periph); 125 mtx_lock(mtx); 126 enc = (struct enc_softc *)periph->softc; 127 128 /* 129 * When we get this callback, we will get no more close calls from 130 * devfs. So if we have any dangling opens, we need to release the 131 * reference held for that particular context. 132 */ 133 for (i = 0; i < enc->open_count; i++) 134 cam_periph_release_locked(periph); 135 136 enc->open_count = 0; 137 138 /* 139 * Release the reference held for the device node, it is gone now. 140 */ 141 cam_periph_release_locked(periph); 142 143 /* 144 * We reference the lock directly here, instead of using 145 * cam_periph_unlock(). The reason is that the final call to 146 * cam_periph_release_locked() above could result in the periph 147 * getting freed. If that is the case, dereferencing the periph 148 * with a cam_periph_unlock() call would cause a page fault. 149 */ 150 mtx_unlock(mtx); 151 } 152 153 static void 154 enc_oninvalidate(struct cam_periph *periph) 155 { 156 struct enc_softc *enc; 157 158 enc = periph->softc; 159 160 enc->enc_flags |= ENC_FLAG_INVALID; 161 162 /* If the sub-driver has an invalidate routine, call it */ 163 if (enc->enc_vec.softc_invalidate != NULL) 164 enc->enc_vec.softc_invalidate(enc); 165 166 /* 167 * Unregister any async callbacks. 168 */ 169 xpt_register_async(0, enc_async, periph, periph->path); 170 171 /* 172 * Shutdown our daemon. 173 */ 174 enc->enc_flags |= ENC_FLAG_SHUTDOWN; 175 if (enc->enc_daemon != NULL) { 176 /* Signal the ses daemon to terminate. */ 177 wakeup(enc->enc_daemon); 178 } 179 callout_drain(&enc->status_updater); 180 181 destroy_dev_sched_cb(enc->enc_dev, enc_devgonecb, periph); 182 } 183 184 static void 185 enc_dtor(struct cam_periph *periph) 186 { 187 struct enc_softc *enc; 188 189 enc = periph->softc; 190 191 /* If the sub-driver has a cleanup routine, call it */ 192 if (enc->enc_vec.softc_cleanup != NULL) 193 enc->enc_vec.softc_cleanup(enc); 194 195 if (enc->enc_boot_hold_ch.ich_func != NULL) { 196 config_intrhook_disestablish(&enc->enc_boot_hold_ch); 197 enc->enc_boot_hold_ch.ich_func = NULL; 198 } 199 200 ENC_FREE(enc); 201 } 202 203 static void 204 enc_async(void *callback_arg, uint32_t code, struct cam_path *path, void *arg) 205 { 206 struct cam_periph *periph; 207 208 periph = (struct cam_periph *)callback_arg; 209 210 switch(code) { 211 case AC_FOUND_DEVICE: 212 { 213 struct ccb_getdev *cgd; 214 cam_status status; 215 path_id_t path_id; 216 217 cgd = (struct ccb_getdev *)arg; 218 if (arg == NULL) { 219 break; 220 } 221 222 if (enc_type(cgd) == ENC_NONE) { 223 /* 224 * Schedule announcement of the ENC bindings for 225 * this device if it is managed by a SEP. 226 */ 227 path_id = xpt_path_path_id(path); 228 xpt_lock_buses(); 229 TAILQ_FOREACH(periph, &encdriver.units, unit_links) { 230 struct enc_softc *softc; 231 232 softc = (struct enc_softc *)periph->softc; 233 if (xpt_path_path_id(periph->path) != path_id 234 || softc == NULL 235 || (softc->enc_flags & ENC_FLAG_INITIALIZED) 236 == 0 237 || softc->enc_vec.device_found == NULL) 238 continue; 239 240 softc->enc_vec.device_found(softc); 241 } 242 xpt_unlock_buses(); 243 return; 244 } 245 246 status = cam_periph_alloc(enc_ctor, enc_oninvalidate, 247 enc_dtor, NULL, "ses", CAM_PERIPH_BIO, 248 path, enc_async, AC_FOUND_DEVICE, cgd); 249 250 if (status != CAM_REQ_CMP && status != CAM_REQ_INPROG) { 251 printf("enc_async: Unable to probe new device due to " 252 "status 0x%x\n", status); 253 } 254 break; 255 } 256 default: 257 cam_periph_async(periph, code, path, arg); 258 break; 259 } 260 } 261 262 static int 263 enc_open(struct cdev *dev, int flags, int fmt, struct thread *td) 264 { 265 struct cam_periph *periph; 266 struct enc_softc *softc; 267 int error = 0; 268 269 periph = (struct cam_periph *)dev->si_drv1; 270 if (cam_periph_acquire(periph) != 0) 271 return (ENXIO); 272 273 cam_periph_lock(periph); 274 275 softc = (struct enc_softc *)periph->softc; 276 277 if ((softc->enc_flags & ENC_FLAG_INITIALIZED) == 0) { 278 error = ENXIO; 279 goto out; 280 } 281 if (softc->enc_flags & ENC_FLAG_INVALID) { 282 error = ENXIO; 283 goto out; 284 } 285 out: 286 if (error != 0) 287 cam_periph_release_locked(periph); 288 else 289 softc->open_count++; 290 291 cam_periph_unlock(periph); 292 293 return (error); 294 } 295 296 static int 297 enc_close(struct cdev *dev, int flag, int fmt, struct thread *td) 298 { 299 struct cam_periph *periph; 300 struct enc_softc *enc; 301 struct mtx *mtx; 302 303 periph = (struct cam_periph *)dev->si_drv1; 304 mtx = cam_periph_mtx(periph); 305 mtx_lock(mtx); 306 307 enc = periph->softc; 308 enc->open_count--; 309 310 cam_periph_release_locked(periph); 311 312 /* 313 * We reference the lock directly here, instead of using 314 * cam_periph_unlock(). The reason is that the call to 315 * cam_periph_release_locked() above could result in the periph 316 * getting freed. If that is the case, dereferencing the periph 317 * with a cam_periph_unlock() call would cause a page fault. 318 * 319 * cam_periph_release() avoids this problem using the same method, 320 * but we're manually acquiring and dropping the lock here to 321 * protect the open count and avoid another lock acquisition and 322 * release. 323 */ 324 mtx_unlock(mtx); 325 326 return (0); 327 } 328 329 int 330 enc_error(union ccb *ccb, uint32_t cflags, uint32_t sflags) 331 { 332 struct enc_softc *softc; 333 struct cam_periph *periph; 334 335 periph = xpt_path_periph(ccb->ccb_h.path); 336 softc = (struct enc_softc *)periph->softc; 337 338 return (cam_periph_error(ccb, cflags, sflags)); 339 } 340 341 static int 342 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag, 343 struct thread *td) 344 { 345 struct cam_periph *periph; 346 encioc_enc_status_t tmp; 347 encioc_string_t sstr; 348 encioc_elm_status_t elms; 349 encioc_elm_desc_t elmd; 350 encioc_elm_devnames_t elmdn; 351 encioc_element_t *uelm; 352 enc_softc_t *enc; 353 enc_cache_t *cache; 354 void *addr; 355 int error, i; 356 357 358 if (arg_addr) 359 addr = *((caddr_t *) arg_addr); 360 else 361 addr = NULL; 362 363 periph = (struct cam_periph *)dev->si_drv1; 364 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering encioctl\n")); 365 366 cam_periph_lock(periph); 367 enc = (struct enc_softc *)periph->softc; 368 cache = &enc->enc_cache; 369 370 /* 371 * Now check to see whether we're initialized or not. 372 * This actually should never fail as we're not supposed 373 * to get past enc_open w/o successfully initializing 374 * things. 375 */ 376 if ((enc->enc_flags & ENC_FLAG_INITIALIZED) == 0) { 377 cam_periph_unlock(periph); 378 return (ENXIO); 379 } 380 cam_periph_unlock(periph); 381 382 error = 0; 383 384 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, 385 ("trying to do ioctl %#lx\n", cmd)); 386 387 /* 388 * If this command can change the device's state, 389 * we must have the device open for writing. 390 * 391 * For commands that get information about the 392 * device- we don't need to lock the peripheral 393 * if we aren't running a command. The periph 394 * also can't go away while a user process has 395 * it open. 396 */ 397 switch (cmd) { 398 case ENCIOC_GETNELM: 399 case ENCIOC_GETELMMAP: 400 case ENCIOC_GETENCSTAT: 401 case ENCIOC_GETELMSTAT: 402 case ENCIOC_GETELMDESC: 403 case ENCIOC_GETELMDEVNAMES: 404 case ENCIOC_GETENCNAME: 405 case ENCIOC_GETENCID: 406 break; 407 default: 408 if ((flag & FWRITE) == 0) { 409 return (EBADF); 410 } 411 } 412 413 /* 414 * XXX The values read here are only valid for the current 415 * configuration generation. We need these ioctls 416 * to also pass in/out a generation number. 417 */ 418 sx_slock(&enc->enc_cache_lock); 419 switch (cmd) { 420 case ENCIOC_GETNELM: 421 error = copyout(&cache->nelms, addr, sizeof (cache->nelms)); 422 break; 423 424 case ENCIOC_GETELMMAP: 425 for (uelm = addr, i = 0; i != cache->nelms; i++) { 426 encioc_element_t kelm; 427 kelm.elm_idx = i; 428 kelm.elm_subenc_id = cache->elm_map[i].subenclosure; 429 kelm.elm_type = cache->elm_map[i].enctype; 430 error = copyout(&kelm, &uelm[i], sizeof(kelm)); 431 if (error) 432 break; 433 } 434 break; 435 436 case ENCIOC_GETENCSTAT: 437 cam_periph_lock(periph); 438 error = enc->enc_vec.get_enc_status(enc, 1); 439 if (error) { 440 cam_periph_unlock(periph); 441 break; 442 } 443 tmp = cache->enc_status; 444 cam_periph_unlock(periph); 445 error = copyout(&tmp, addr, sizeof(tmp)); 446 cache->enc_status = tmp; 447 break; 448 449 case ENCIOC_SETENCSTAT: 450 error = copyin(addr, &tmp, sizeof(tmp)); 451 if (error) 452 break; 453 cam_periph_lock(periph); 454 error = enc->enc_vec.set_enc_status(enc, tmp, 1); 455 cam_periph_unlock(periph); 456 break; 457 458 case ENCIOC_GETSTRING: 459 case ENCIOC_SETSTRING: 460 case ENCIOC_GETENCNAME: 461 case ENCIOC_GETENCID: 462 if (enc->enc_vec.handle_string == NULL) { 463 error = EINVAL; 464 break; 465 } 466 error = copyin(addr, &sstr, sizeof(sstr)); 467 if (error) 468 break; 469 cam_periph_lock(periph); 470 error = enc->enc_vec.handle_string(enc, &sstr, cmd); 471 cam_periph_unlock(periph); 472 break; 473 474 case ENCIOC_GETELMSTAT: 475 error = copyin(addr, &elms, sizeof(elms)); 476 if (error) 477 break; 478 if (elms.elm_idx >= cache->nelms) { 479 error = EINVAL; 480 break; 481 } 482 cam_periph_lock(periph); 483 error = enc->enc_vec.get_elm_status(enc, &elms, 1); 484 cam_periph_unlock(periph); 485 if (error) 486 break; 487 error = copyout(&elms, addr, sizeof(elms)); 488 break; 489 490 case ENCIOC_GETELMDESC: 491 error = copyin(addr, &elmd, sizeof(elmd)); 492 if (error) 493 break; 494 if (elmd.elm_idx >= cache->nelms) { 495 error = EINVAL; 496 break; 497 } 498 if (enc->enc_vec.get_elm_desc != NULL) { 499 error = enc->enc_vec.get_elm_desc(enc, &elmd); 500 if (error) 501 break; 502 } else 503 elmd.elm_desc_len = 0; 504 error = copyout(&elmd, addr, sizeof(elmd)); 505 break; 506 507 case ENCIOC_GETELMDEVNAMES: 508 if (enc->enc_vec.get_elm_devnames == NULL) { 509 error = EINVAL; 510 break; 511 } 512 error = copyin(addr, &elmdn, sizeof(elmdn)); 513 if (error) 514 break; 515 if (elmdn.elm_idx >= cache->nelms) { 516 error = EINVAL; 517 break; 518 } 519 cam_periph_lock(periph); 520 error = (*enc->enc_vec.get_elm_devnames)(enc, &elmdn); 521 cam_periph_unlock(periph); 522 if (error) 523 break; 524 error = copyout(&elmdn, addr, sizeof(elmdn)); 525 break; 526 527 case ENCIOC_SETELMSTAT: 528 error = copyin(addr, &elms, sizeof(elms)); 529 if (error) 530 break; 531 532 if (elms.elm_idx >= cache->nelms) { 533 error = EINVAL; 534 break; 535 } 536 cam_periph_lock(periph); 537 error = enc->enc_vec.set_elm_status(enc, &elms, 1); 538 cam_periph_unlock(periph); 539 540 break; 541 542 case ENCIOC_INIT: 543 544 cam_periph_lock(periph); 545 error = enc->enc_vec.init_enc(enc); 546 cam_periph_unlock(periph); 547 break; 548 549 default: 550 cam_periph_lock(periph); 551 error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error); 552 cam_periph_unlock(periph); 553 break; 554 } 555 sx_sunlock(&enc->enc_cache_lock); 556 return (error); 557 } 558 559 int 560 enc_runcmd(struct enc_softc *enc, char *cdb, int cdbl, char *dptr, int *dlenp) 561 { 562 int error, dlen, tdlen; 563 ccb_flags ddf; 564 union ccb *ccb; 565 566 CAM_DEBUG(enc->periph->path, CAM_DEBUG_TRACE, 567 ("entering enc_runcmd\n")); 568 if (dptr) { 569 if ((dlen = *dlenp) < 0) { 570 dlen = -dlen; 571 ddf = CAM_DIR_OUT; 572 } else { 573 ddf = CAM_DIR_IN; 574 } 575 } else { 576 dlen = 0; 577 ddf = CAM_DIR_NONE; 578 } 579 580 if (cdbl > IOCDBLEN) { 581 cdbl = IOCDBLEN; 582 } 583 584 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL); 585 if (enc->enc_type == ENC_SEMB_SES || enc->enc_type == ENC_SEMB_SAFT) { 586 tdlen = min(dlen, 1020); 587 tdlen = (tdlen + 3) & ~3; 588 cam_fill_ataio(&ccb->ataio, 0, NULL, ddf, 0, dptr, tdlen, 589 30 * 1000); 590 if (cdb[0] == RECEIVE_DIAGNOSTIC) 591 ata_28bit_cmd(&ccb->ataio, 592 ATA_SEP_ATTN, cdb[2], 0x02, tdlen / 4); 593 else if (cdb[0] == SEND_DIAGNOSTIC) 594 ata_28bit_cmd(&ccb->ataio, 595 ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0, 596 0x82, tdlen / 4); 597 else if (cdb[0] == READ_BUFFER) 598 ata_28bit_cmd(&ccb->ataio, 599 ATA_SEP_ATTN, cdb[2], 0x00, tdlen / 4); 600 else 601 ata_28bit_cmd(&ccb->ataio, 602 ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0, 603 0x80, tdlen / 4); 604 } else { 605 tdlen = dlen; 606 cam_fill_csio(&ccb->csio, 0, NULL, ddf, MSG_SIMPLE_Q_TAG, 607 dptr, dlen, sizeof (struct scsi_sense_data), cdbl, 608 60 * 1000); 609 bcopy(cdb, ccb->csio.cdb_io.cdb_bytes, cdbl); 610 } 611 612 error = cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, ENC_FLAGS, NULL); 613 if (error) { 614 if (dptr) { 615 *dlenp = dlen; 616 } 617 } else { 618 if (dptr) { 619 if (ccb->ccb_h.func_code == XPT_ATA_IO) 620 *dlenp = ccb->ataio.resid; 621 else 622 *dlenp = ccb->csio.resid; 623 *dlenp += tdlen - dlen; 624 } 625 } 626 xpt_release_ccb(ccb); 627 CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE, 628 ("exiting enc_runcmd: *dlenp = %d\n", *dlenp)); 629 return (error); 630 } 631 632 void 633 enc_log(struct enc_softc *enc, const char *fmt, ...) 634 { 635 va_list ap; 636 637 printf("%s%d: ", enc->periph->periph_name, enc->periph->unit_number); 638 va_start(ap, fmt); 639 vprintf(fmt, ap); 640 va_end(ap); 641 } 642 643 /* 644 * The code after this point runs on many platforms, 645 * so forgive the slightly awkward and nonconforming 646 * appearance. 647 */ 648 649 /* 650 * Is this a device that supports enclosure services? 651 * 652 * It's a pretty simple ruleset- if it is device type 653 * 0x0D (13), it's an ENCLOSURE device. 654 */ 655 656 #define SAFTE_START 44 657 #define SAFTE_END 50 658 #define SAFTE_LEN SAFTE_END-SAFTE_START 659 660 static enctyp 661 enc_type(struct ccb_getdev *cgd) 662 { 663 int buflen; 664 unsigned char *iqd; 665 666 if (cgd->protocol == PROTO_SEMB) { 667 iqd = (unsigned char *)&cgd->ident_data; 668 if (STRNCMP(iqd + 43, "S-E-S", 5) == 0) 669 return (ENC_SEMB_SES); 670 else if (STRNCMP(iqd + 43, "SAF-TE", 6) == 0) 671 return (ENC_SEMB_SAFT); 672 return (ENC_NONE); 673 674 } else if (cgd->protocol != PROTO_SCSI) 675 return (ENC_NONE); 676 677 iqd = (unsigned char *)&cgd->inq_data; 678 buflen = min(sizeof(cgd->inq_data), 679 SID_ADDITIONAL_LENGTH(&cgd->inq_data)); 680 681 if ((iqd[0] & 0x1f) == T_ENCLOSURE) { 682 if ((iqd[2] & 0x7) > 2) { 683 return (ENC_SES); 684 } else { 685 return (ENC_SES_SCSI2); 686 } 687 return (ENC_NONE); 688 } 689 690 #ifdef SES_ENABLE_PASSTHROUGH 691 if ((iqd[6] & 0x40) && (iqd[2] & 0x7) >= 2) { 692 /* 693 * PassThrough Device. 694 */ 695 return (ENC_SES_PASSTHROUGH); 696 } 697 #endif 698 699 /* 700 * The comparison is short for a reason- 701 * some vendors were chopping it short. 702 */ 703 704 if (buflen < SAFTE_END - 2) { 705 return (ENC_NONE); 706 } 707 708 if (STRNCMP((char *)&iqd[SAFTE_START], "SAF-TE", SAFTE_LEN - 2) == 0) { 709 return (ENC_SAFT); 710 } 711 return (ENC_NONE); 712 } 713 714 /*================== Enclosure Monitoring/Processing Daemon ==================*/ 715 /** 716 * \brief Queue an update request for a given action, if needed. 717 * 718 * \param enc SES softc to queue the request for. 719 * \param action Action requested. 720 */ 721 void 722 enc_update_request(enc_softc_t *enc, uint32_t action) 723 { 724 if ((enc->pending_actions & (0x1 << action)) == 0) { 725 enc->pending_actions |= (0x1 << action); 726 ENC_DLOG(enc, "%s: queing requested action %d\n", 727 __func__, action); 728 if (enc->current_action == ENC_UPDATE_NONE) 729 wakeup(enc->enc_daemon); 730 } else { 731 ENC_DLOG(enc, "%s: ignoring requested action %d - " 732 "Already queued\n", __func__, action); 733 } 734 } 735 736 /** 737 * \brief Invoke the handler of the highest priority pending 738 * state in the SES state machine. 739 * 740 * \param enc The SES instance invoking the state machine. 741 */ 742 static void 743 enc_fsm_step(enc_softc_t *enc) 744 { 745 union ccb *ccb; 746 uint8_t *buf; 747 struct enc_fsm_state *cur_state; 748 int error; 749 uint32_t xfer_len; 750 751 ENC_DLOG(enc, "%s enter %p\n", __func__, enc); 752 753 enc->current_action = ffs(enc->pending_actions) - 1; 754 enc->pending_actions &= ~(0x1 << enc->current_action); 755 756 cur_state = &enc->enc_fsm_states[enc->current_action]; 757 758 buf = NULL; 759 if (cur_state->buf_size != 0) { 760 cam_periph_unlock(enc->periph); 761 buf = malloc(cur_state->buf_size, M_SCSIENC, M_WAITOK|M_ZERO); 762 cam_periph_lock(enc->periph); 763 } 764 765 error = 0; 766 ccb = NULL; 767 if (cur_state->fill != NULL) { 768 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL); 769 770 error = cur_state->fill(enc, cur_state, ccb, buf); 771 if (error != 0) 772 goto done; 773 774 error = cam_periph_runccb(ccb, cur_state->error, 775 ENC_CFLAGS, 776 ENC_FLAGS|SF_QUIET_IR, NULL); 777 } 778 779 if (ccb != NULL) { 780 if (ccb->ccb_h.func_code == XPT_ATA_IO) 781 xfer_len = ccb->ataio.dxfer_len - ccb->ataio.resid; 782 else 783 xfer_len = ccb->csio.dxfer_len - ccb->csio.resid; 784 } else 785 xfer_len = 0; 786 787 cam_periph_unlock(enc->periph); 788 cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len); 789 cam_periph_lock(enc->periph); 790 791 done: 792 ENC_DLOG(enc, "%s exit - result %d\n", __func__, error); 793 ENC_FREE_AND_NULL(buf); 794 if (ccb != NULL) 795 xpt_release_ccb(ccb); 796 } 797 798 /** 799 * \invariant Called with cam_periph mutex held. 800 */ 801 static void 802 enc_status_updater(void *arg) 803 { 804 enc_softc_t *enc; 805 806 enc = arg; 807 if (enc->enc_vec.poll_status != NULL) 808 enc->enc_vec.poll_status(enc); 809 } 810 811 static void 812 enc_daemon(void *arg) 813 { 814 enc_softc_t *enc; 815 816 enc = arg; 817 818 cam_periph_lock(enc->periph); 819 while ((enc->enc_flags & ENC_FLAG_SHUTDOWN) == 0) { 820 if (enc->pending_actions == 0) { 821 struct intr_config_hook *hook; 822 823 /* 824 * Reset callout and msleep, or 825 * issue timed task completion 826 * status command. 827 */ 828 enc->current_action = ENC_UPDATE_NONE; 829 830 /* 831 * We've been through our state machine at least 832 * once. Allow the transition to userland. 833 */ 834 hook = &enc->enc_boot_hold_ch; 835 if (hook->ich_func != NULL) { 836 config_intrhook_disestablish(hook); 837 hook->ich_func = NULL; 838 } 839 840 callout_reset(&enc->status_updater, 60*hz, 841 enc_status_updater, enc); 842 843 cam_periph_sleep(enc->periph, enc->enc_daemon, 844 PUSER, "idle", 0); 845 } else { 846 enc_fsm_step(enc); 847 } 848 } 849 enc->enc_daemon = NULL; 850 cam_periph_unlock(enc->periph); 851 cam_periph_release(enc->periph); 852 kproc_exit(0); 853 } 854 855 static int 856 enc_kproc_init(enc_softc_t *enc) 857 { 858 int result; 859 860 callout_init_mtx(&enc->status_updater, cam_periph_mtx(enc->periph), 0); 861 862 if (cam_periph_acquire(enc->periph) != 0) 863 return (ENXIO); 864 865 result = kproc_create(enc_daemon, enc, &enc->enc_daemon, /*flags*/0, 866 /*stackpgs*/0, "enc_daemon%d", 867 enc->periph->unit_number); 868 if (result == 0) { 869 /* Do an initial load of all page data. */ 870 cam_periph_lock(enc->periph); 871 enc->enc_vec.poll_status(enc); 872 cam_periph_unlock(enc->periph); 873 } else 874 cam_periph_release(enc->periph); 875 return (result); 876 } 877 878 /** 879 * \brief Interrupt configuration hook callback associated with 880 * enc_boot_hold_ch. 881 * 882 * Since interrupts are always functional at the time of enclosure 883 * configuration, there is nothing to be done when the callback occurs. 884 * This hook is only registered to hold up boot processing while initial 885 * eclosure processing occurs. 886 * 887 * \param arg The enclosure softc, but currently unused in this callback. 888 */ 889 static void 890 enc_nop_confighook_cb(void *arg __unused) 891 { 892 } 893 894 static cam_status 895 enc_ctor(struct cam_periph *periph, void *arg) 896 { 897 cam_status status = CAM_REQ_CMP_ERR; 898 int err; 899 enc_softc_t *enc; 900 struct ccb_getdev *cgd; 901 char *tname; 902 struct make_dev_args args; 903 struct sbuf sb; 904 905 cgd = (struct ccb_getdev *)arg; 906 if (cgd == NULL) { 907 printf("enc_ctor: no getdev CCB, can't register device\n"); 908 goto out; 909 } 910 911 enc = ENC_MALLOCZ(sizeof(*enc)); 912 if (enc == NULL) { 913 printf("enc_ctor: Unable to probe new device. " 914 "Unable to allocate enc\n"); 915 goto out; 916 } 917 enc->periph = periph; 918 enc->current_action = ENC_UPDATE_INVALID; 919 920 enc->enc_type = enc_type(cgd); 921 sx_init(&enc->enc_cache_lock, "enccache"); 922 923 switch (enc->enc_type) { 924 case ENC_SES: 925 case ENC_SES_SCSI2: 926 case ENC_SES_PASSTHROUGH: 927 case ENC_SEMB_SES: 928 err = ses_softc_init(enc); 929 break; 930 case ENC_SAFT: 931 case ENC_SEMB_SAFT: 932 err = safte_softc_init(enc); 933 break; 934 case ENC_NONE: 935 default: 936 ENC_FREE(enc); 937 return (CAM_REQ_CMP_ERR); 938 } 939 940 if (err) { 941 xpt_print(periph->path, "error %d initializing\n", err); 942 goto out; 943 } 944 945 /* 946 * Hold off userland until we have made at least one pass 947 * through our state machine so that physical path data is 948 * present. 949 */ 950 if (enc->enc_vec.poll_status != NULL) { 951 enc->enc_boot_hold_ch.ich_func = enc_nop_confighook_cb; 952 enc->enc_boot_hold_ch.ich_arg = enc; 953 config_intrhook_establish(&enc->enc_boot_hold_ch); 954 } 955 956 /* 957 * The softc field is set only once the enc is fully initialized 958 * so that we can rely on this field to detect partially 959 * initialized periph objects in the AC_FOUND_DEVICE handler. 960 */ 961 periph->softc = enc; 962 963 cam_periph_unlock(periph); 964 if (enc->enc_vec.poll_status != NULL) { 965 err = enc_kproc_init(enc); 966 if (err) { 967 xpt_print(periph->path, 968 "error %d starting enc_daemon\n", err); 969 goto out; 970 } 971 } 972 973 /* 974 * Acquire a reference to the periph before we create the devfs 975 * instance for it. We'll release this reference once the devfs 976 * instance has been freed. 977 */ 978 if (cam_periph_acquire(periph) != 0) { 979 xpt_print(periph->path, "%s: lost periph during " 980 "registration!\n", __func__); 981 cam_periph_lock(periph); 982 983 return (CAM_REQ_CMP_ERR); 984 } 985 986 make_dev_args_init(&args); 987 args.mda_devsw = &enc_cdevsw; 988 args.mda_unit = periph->unit_number; 989 args.mda_uid = UID_ROOT; 990 args.mda_gid = GID_OPERATOR; 991 args.mda_mode = 0600; 992 args.mda_si_drv1 = periph; 993 err = make_dev_s(&args, &enc->enc_dev, "%s%d", periph->periph_name, 994 periph->unit_number); 995 cam_periph_lock(periph); 996 if (err != 0) { 997 cam_periph_release_locked(periph); 998 return (CAM_REQ_CMP_ERR); 999 } 1000 1001 enc->enc_flags |= ENC_FLAG_INITIALIZED; 1002 1003 /* 1004 * Add an async callback so that we get notified if this 1005 * device goes away. 1006 */ 1007 xpt_register_async(AC_LOST_DEVICE, enc_async, periph, periph->path); 1008 1009 switch (enc->enc_type) { 1010 default: 1011 case ENC_NONE: 1012 tname = "No ENC device"; 1013 break; 1014 case ENC_SES_SCSI2: 1015 tname = "SCSI-2 ENC Device"; 1016 break; 1017 case ENC_SES: 1018 tname = "SCSI-3 ENC Device"; 1019 break; 1020 case ENC_SES_PASSTHROUGH: 1021 tname = "ENC Passthrough Device"; 1022 break; 1023 case ENC_SAFT: 1024 tname = "SAF-TE Compliant Device"; 1025 break; 1026 case ENC_SEMB_SES: 1027 tname = "SEMB SES Device"; 1028 break; 1029 case ENC_SEMB_SAFT: 1030 tname = "SEMB SAF-TE Device"; 1031 break; 1032 } 1033 1034 sbuf_new(&sb, enc->announce_buf, ENC_ANNOUNCE_SZ, SBUF_FIXEDLEN); 1035 xpt_announce_periph_sbuf(periph, &sb, tname); 1036 sbuf_finish(&sb); 1037 sbuf_putbuf(&sb); 1038 1039 status = CAM_REQ_CMP; 1040 1041 out: 1042 if (status != CAM_REQ_CMP) 1043 enc_dtor(periph); 1044 return (status); 1045 } 1046 1047