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