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