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