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