1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2000 Matthew Jacob 5 * Copyright (c) 2010 Spectra Logic Corporation 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions, and the following disclaimer, 13 * without modification, immediately at the beginning of the file. 14 * 2. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /** 31 * \file scsi_enc_ses.c 32 * 33 * Structures and routines specific && private to SES only 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include <sys/param.h> 40 41 #include <sys/ctype.h> 42 #include <sys/errno.h> 43 #include <sys/kernel.h> 44 #include <sys/lock.h> 45 #include <sys/malloc.h> 46 #include <sys/mutex.h> 47 #include <sys/queue.h> 48 #include <sys/sbuf.h> 49 #include <sys/sx.h> 50 #include <sys/systm.h> 51 #include <sys/types.h> 52 53 #include <cam/cam.h> 54 #include <cam/cam_ccb.h> 55 #include <cam/cam_xpt_periph.h> 56 #include <cam/cam_periph.h> 57 58 #include <cam/scsi/scsi_message.h> 59 #include <cam/scsi/scsi_enc.h> 60 #include <cam/scsi/scsi_enc_internal.h> 61 62 /* SES Native Type Device Support */ 63 64 /* SES Diagnostic Page Codes */ 65 typedef enum { 66 SesSupportedPages = 0x0, 67 SesConfigPage = 0x1, 68 SesControlPage = 0x2, 69 SesStatusPage = SesControlPage, 70 SesHelpTxt = 0x3, 71 SesStringOut = 0x4, 72 SesStringIn = SesStringOut, 73 SesThresholdOut = 0x5, 74 SesThresholdIn = SesThresholdOut, 75 SesArrayControl = 0x6, /* Obsolete in SES v2 */ 76 SesArrayStatus = SesArrayControl, 77 SesElementDescriptor = 0x7, 78 SesShortStatus = 0x8, 79 SesEnclosureBusy = 0x9, 80 SesAddlElementStatus = 0xa 81 } SesDiagPageCodes; 82 83 typedef struct ses_type { 84 const struct ses_elm_type_desc *hdr; 85 const char *text; 86 } ses_type_t; 87 88 typedef struct ses_comstat { 89 uint8_t comstatus; 90 uint8_t comstat[3]; 91 } ses_comstat_t; 92 93 typedef union ses_addl_data { 94 struct ses_elm_sas_device_phy *sasdev_phys; 95 struct ses_elm_sas_expander_phy *sasexp_phys; 96 struct ses_elm_sas_port_phy *sasport_phys; 97 struct ses_fcobj_port *fc_ports; 98 } ses_add_data_t; 99 100 typedef struct ses_addl_status { 101 struct ses_elm_addlstatus_base_hdr *hdr; 102 union { 103 union ses_fcobj_hdr *fc; 104 union ses_elm_sas_hdr *sas; 105 struct ses_elm_ata_hdr *ata; 106 } proto_hdr; 107 union ses_addl_data proto_data; /* array sizes stored in header */ 108 } ses_add_status_t; 109 110 typedef struct ses_element { 111 uint8_t eip; /* eip bit is set */ 112 uint16_t descr_len; /* length of the descriptor */ 113 const char *descr; /* descriptor for this object */ 114 struct ses_addl_status addl; /* additional status info */ 115 } ses_element_t; 116 117 typedef struct ses_control_request { 118 int elm_idx; 119 ses_comstat_t elm_stat; 120 int result; 121 TAILQ_ENTRY(ses_control_request) links; 122 } ses_control_request_t; 123 TAILQ_HEAD(ses_control_reqlist, ses_control_request); 124 typedef struct ses_control_reqlist ses_control_reqlist_t; 125 enum { 126 SES_SETSTATUS_ENC_IDX = -1 127 }; 128 129 static void 130 ses_terminate_control_requests(ses_control_reqlist_t *reqlist, int result) 131 { 132 ses_control_request_t *req; 133 134 while ((req = TAILQ_FIRST(reqlist)) != NULL) { 135 TAILQ_REMOVE(reqlist, req, links); 136 req->result = result; 137 wakeup(req); 138 } 139 } 140 141 enum ses_iter_index_values { 142 /** 143 * \brief Value of an initialized but invalid index 144 * in a ses_iterator object. 145 * 146 * This value is used for the individual_element_index of 147 * overal status elements and for all index types when 148 * an iterator is first initialized. 149 */ 150 ITERATOR_INDEX_INVALID = -1, 151 152 /** 153 * \brief Value of an index in a ses_iterator object 154 * when the iterator has traversed past the last 155 * valid element.. 156 */ 157 ITERATOR_INDEX_END = INT_MAX 158 }; 159 160 /** 161 * \brief Structure encapsulating all data necessary to traverse the 162 * elements of a SES configuration. 163 * 164 * The ses_iterator object simplifies the task of iterating through all 165 * elements detected via the SES configuration page by tracking the numerous 166 * element indexes that, instead of memoizing in the softc, we calculate 167 * on the fly during the traversal of the element objects. The various 168 * indexes are necessary due to the varying needs of matching objects in 169 * the different SES pages. Some pages (e.g. Status/Control) contain all 170 * elements, while others (e.g. Additional Element Status) only contain 171 * individual elements (no overal status elements) of particular types. 172 * 173 * To use an iterator, initialize it with ses_iter_init(), and then 174 * use ses_iter_next() to traverse the elements (including the first) in 175 * the configuration. Once an iterator is initiailized with ses_iter_init(), 176 * you may also seek to any particular element by either it's global or 177 * individual element index via the ses_iter_seek_to() function. You may 178 * also return an iterator to the position just before the first element 179 * (i.e. the same state as after an ses_iter_init()), with ses_iter_reset(). 180 */ 181 struct ses_iterator { 182 /** 183 * \brief Backlink to the overal software configuration structure. 184 * 185 * This is included for convenience so the iteration functions 186 * need only take a single, struct ses_iterator *, argument. 187 */ 188 enc_softc_t *enc; 189 190 enc_cache_t *cache; 191 192 /** 193 * \brief Index of the type of the current element within the 194 * ses_cache's ses_types array. 195 */ 196 int type_index; 197 198 /** 199 * \brief The position (0 based) of this element relative to all other 200 * elements of this type. 201 * 202 * This index resets to zero every time the iterator transitions 203 * to elements of a new type in the configuration. 204 */ 205 int type_element_index; 206 207 /** 208 * \brief The position (0 based) of this element relative to all 209 * other individual status elements in the configuration. 210 * 211 * This index ranges from 0 through the number of individual 212 * elements in the configuration. When the iterator returns 213 * an overall status element, individual_element_index is 214 * set to ITERATOR_INDEX_INVALID, to indicate that it does 215 * not apply to the current element. 216 */ 217 int individual_element_index; 218 219 /** 220 * \brief The position (0 based) of this element relative to 221 * all elements in the configration. 222 * 223 * This index is appropriate for indexing into enc->ses_elm_map. 224 */ 225 int global_element_index; 226 227 /** 228 * \brief The last valid individual element index of this 229 * iterator. 230 * 231 * When an iterator traverses an overal status element, the 232 * individual element index is reset to ITERATOR_INDEX_INVALID 233 * to prevent unintential use of the individual_element_index 234 * field. The saved_individual_element_index allows the iterator 235 * to restore it's position in the individual elements upon 236 * reaching the next individual element. 237 */ 238 int saved_individual_element_index; 239 }; 240 241 typedef enum { 242 SES_UPDATE_NONE, 243 SES_UPDATE_PAGES, 244 SES_UPDATE_GETCONFIG, 245 SES_UPDATE_GETSTATUS, 246 SES_UPDATE_GETELMDESCS, 247 SES_UPDATE_GETELMADDLSTATUS, 248 SES_PROCESS_CONTROL_REQS, 249 SES_PUBLISH_PHYSPATHS, 250 SES_PUBLISH_CACHE, 251 SES_NUM_UPDATE_STATES 252 } ses_update_action; 253 254 static enc_softc_cleanup_t ses_softc_cleanup; 255 256 #define SCSZ 0x8000 257 258 static fsm_fill_handler_t ses_fill_rcv_diag_io; 259 static fsm_fill_handler_t ses_fill_control_request; 260 static fsm_done_handler_t ses_process_pages; 261 static fsm_done_handler_t ses_process_config; 262 static fsm_done_handler_t ses_process_status; 263 static fsm_done_handler_t ses_process_elm_descs; 264 static fsm_done_handler_t ses_process_elm_addlstatus; 265 static fsm_done_handler_t ses_process_control_request; 266 static fsm_done_handler_t ses_publish_physpaths; 267 static fsm_done_handler_t ses_publish_cache; 268 269 static struct enc_fsm_state enc_fsm_states[SES_NUM_UPDATE_STATES] = 270 { 271 { "SES_UPDATE_NONE", 0, 0, 0, NULL, NULL, NULL }, 272 { 273 "SES_UPDATE_PAGES", 274 SesSupportedPages, 275 SCSZ, 276 60 * 1000, 277 ses_fill_rcv_diag_io, 278 ses_process_pages, 279 enc_error 280 }, 281 { 282 "SES_UPDATE_GETCONFIG", 283 SesConfigPage, 284 SCSZ, 285 60 * 1000, 286 ses_fill_rcv_diag_io, 287 ses_process_config, 288 enc_error 289 }, 290 { 291 "SES_UPDATE_GETSTATUS", 292 SesStatusPage, 293 SCSZ, 294 60 * 1000, 295 ses_fill_rcv_diag_io, 296 ses_process_status, 297 enc_error 298 }, 299 { 300 "SES_UPDATE_GETELMDESCS", 301 SesElementDescriptor, 302 SCSZ, 303 60 * 1000, 304 ses_fill_rcv_diag_io, 305 ses_process_elm_descs, 306 enc_error 307 }, 308 { 309 "SES_UPDATE_GETELMADDLSTATUS", 310 SesAddlElementStatus, 311 SCSZ, 312 60 * 1000, 313 ses_fill_rcv_diag_io, 314 ses_process_elm_addlstatus, 315 enc_error 316 }, 317 { 318 "SES_PROCESS_CONTROL_REQS", 319 SesControlPage, 320 SCSZ, 321 60 * 1000, 322 ses_fill_control_request, 323 ses_process_control_request, 324 enc_error 325 }, 326 { 327 "SES_PUBLISH_PHYSPATHS", 328 0, 329 0, 330 0, 331 NULL, 332 ses_publish_physpaths, 333 NULL 334 }, 335 { 336 "SES_PUBLISH_CACHE", 337 0, 338 0, 339 0, 340 NULL, 341 ses_publish_cache, 342 NULL 343 } 344 }; 345 346 typedef struct ses_cache { 347 /* Source for all the configuration data pointers */ 348 const struct ses_cfg_page *cfg_page; 349 350 /* References into the config page. */ 351 int ses_nsubencs; 352 const struct ses_enc_desc * const *subencs; 353 int ses_ntypes; 354 const ses_type_t *ses_types; 355 356 /* Source for all the status pointers */ 357 const struct ses_status_page *status_page; 358 359 /* Source for all the object descriptor pointers */ 360 const struct ses_elem_descr_page *elm_descs_page; 361 362 /* Source for all the additional object status pointers */ 363 const struct ses_addl_elem_status_page *elm_addlstatus_page; 364 365 } ses_cache_t; 366 367 typedef struct ses_softc { 368 uint32_t ses_flags; 369 #define SES_FLAG_TIMEDCOMP 0x01 370 #define SES_FLAG_ADDLSTATUS 0x02 371 #define SES_FLAG_DESC 0x04 372 373 ses_control_reqlist_t ses_requests; 374 ses_control_reqlist_t ses_pending_requests; 375 } ses_softc_t; 376 377 static int ses_search_globally = 0; 378 SYSCTL_INT(_kern_cam_enc, OID_AUTO, search_globally, CTLFLAG_RWTUN, 379 &ses_search_globally, 0, "Search for disks on other buses"); 380 381 /** 382 * \brief Reset a SES iterator to just before the first element 383 * in the configuration. 384 * 385 * \param iter The iterator object to reset. 386 * 387 * The indexes within a reset iterator are invalid and will only 388 * become valid upon completion of a ses_iter_seek_to() or a 389 * ses_iter_next(). 390 */ 391 static void 392 ses_iter_reset(struct ses_iterator *iter) 393 { 394 /* 395 * Set our indexes to just before the first valid element 396 * of the first type (ITERATOR_INDEX_INVALID == -1). This 397 * simplifies the implementation of ses_iter_next(). 398 */ 399 iter->type_index = 0; 400 iter->type_element_index = ITERATOR_INDEX_INVALID; 401 iter->global_element_index = ITERATOR_INDEX_INVALID; 402 iter->individual_element_index = ITERATOR_INDEX_INVALID; 403 iter->saved_individual_element_index = ITERATOR_INDEX_INVALID; 404 } 405 406 /** 407 * \brief Initialize the storage of a SES iterator and reset it to 408 * the position just before the first element of the 409 * configuration. 410 * 411 * \param enc The SES softc for the SES instance whose configuration 412 * will be enumerated by this iterator. 413 * \param iter The iterator object to initialize. 414 */ 415 static void 416 ses_iter_init(enc_softc_t *enc, enc_cache_t *cache, struct ses_iterator *iter) 417 { 418 iter->enc = enc; 419 iter->cache = cache; 420 ses_iter_reset(iter); 421 } 422 423 /** 424 * \brief Traverse the provided SES iterator to the next element 425 * within the configuration. 426 * 427 * \param iter The iterator to move. 428 * 429 * \return If a valid next element exists, a pointer to it's enc_element_t. 430 * Otherwise NULL. 431 */ 432 static enc_element_t * 433 ses_iter_next(struct ses_iterator *iter) 434 { 435 ses_cache_t *ses_cache; 436 const ses_type_t *element_type; 437 438 ses_cache = iter->cache->private; 439 440 /* 441 * Note: Treat nelms as signed, so we will hit this case 442 * and immediately terminate the iteration if the 443 * configuration has 0 objects. 444 */ 445 if (iter->global_element_index >= (int)iter->cache->nelms - 1) { 446 /* Elements exhausted. */ 447 iter->type_index = ITERATOR_INDEX_END; 448 iter->type_element_index = ITERATOR_INDEX_END; 449 iter->global_element_index = ITERATOR_INDEX_END; 450 iter->individual_element_index = ITERATOR_INDEX_END; 451 iter->saved_individual_element_index = ITERATOR_INDEX_END; 452 return (NULL); 453 } 454 455 KASSERT((iter->type_index < ses_cache->ses_ntypes), 456 ("Corrupted element iterator. %d not less than %d", 457 iter->type_index, ses_cache->ses_ntypes)); 458 459 element_type = &ses_cache->ses_types[iter->type_index]; 460 iter->global_element_index++; 461 iter->type_element_index++; 462 463 /* 464 * There is an object for overal type status in addition 465 * to one for each allowed element, but only if the element 466 * count is non-zero. 467 */ 468 if (iter->type_element_index > element_type->hdr->etype_maxelt) { 469 /* 470 * We've exhausted the elements of this type. 471 * This next element belongs to the next type. 472 */ 473 iter->type_index++; 474 iter->type_element_index = 0; 475 iter->individual_element_index = ITERATOR_INDEX_INVALID; 476 } 477 478 if (iter->type_element_index > 0) { 479 iter->individual_element_index = 480 ++iter->saved_individual_element_index; 481 } 482 483 return (&iter->cache->elm_map[iter->global_element_index]); 484 } 485 486 /** 487 * Element index types tracked by a SES iterator. 488 */ 489 typedef enum { 490 /** 491 * Index relative to all elements (overall and individual) 492 * in the system. 493 */ 494 SES_ELEM_INDEX_GLOBAL, 495 496 /** 497 * \brief Index relative to all individual elements in the system. 498 * 499 * This index counts only individual elements, skipping overall 500 * status elements. This is the index space of the additional 501 * element status page (page 0xa). 502 */ 503 SES_ELEM_INDEX_INDIVIDUAL 504 } ses_elem_index_type_t; 505 506 /** 507 * \brief Move the provided iterator forwards or backwards to the object 508 * having the give index. 509 * 510 * \param iter The iterator on which to perform the seek. 511 * \param element_index The index of the element to find. 512 * \param index_type The type (global or individual) of element_index. 513 * 514 * \return If the element is found, a pointer to it's enc_element_t. 515 * Otherwise NULL. 516 */ 517 static enc_element_t * 518 ses_iter_seek_to(struct ses_iterator *iter, int element_index, 519 ses_elem_index_type_t index_type) 520 { 521 enc_element_t *element; 522 int *cur_index; 523 524 if (index_type == SES_ELEM_INDEX_GLOBAL) 525 cur_index = &iter->global_element_index; 526 else 527 cur_index = &iter->individual_element_index; 528 529 if (*cur_index == element_index) { 530 /* Already there. */ 531 return (&iter->cache->elm_map[iter->global_element_index]); 532 } 533 534 ses_iter_reset(iter); 535 while ((element = ses_iter_next(iter)) != NULL 536 && *cur_index != element_index) 537 ; 538 539 if (*cur_index != element_index) 540 return (NULL); 541 542 return (element); 543 } 544 545 #if 0 546 static int ses_encode(enc_softc_t *, uint8_t *, int, int, 547 struct ses_comstat *); 548 #endif 549 static int ses_set_timed_completion(enc_softc_t *, uint8_t); 550 #if 0 551 static int ses_putstatus(enc_softc_t *, int, struct ses_comstat *); 552 #endif 553 554 static void ses_poll_status(enc_softc_t *); 555 static void ses_print_addl_data(enc_softc_t *, enc_element_t *); 556 557 /*=========================== SES cleanup routines ===========================*/ 558 559 static void 560 ses_cache_free_elm_addlstatus(enc_softc_t *enc, enc_cache_t *cache) 561 { 562 ses_cache_t *ses_cache; 563 ses_cache_t *other_ses_cache; 564 enc_element_t *cur_elm; 565 enc_element_t *last_elm; 566 567 ENC_DLOG(enc, "%s: enter\n", __func__); 568 ses_cache = cache->private; 569 if (ses_cache->elm_addlstatus_page == NULL) 570 return; 571 572 for (cur_elm = cache->elm_map, 573 last_elm = &cache->elm_map[cache->nelms]; 574 cur_elm != last_elm; cur_elm++) { 575 ses_element_t *elmpriv; 576 577 elmpriv = cur_elm->elm_private; 578 579 /* Clear references to the additional status page. */ 580 bzero(&elmpriv->addl, sizeof(elmpriv->addl)); 581 } 582 583 other_ses_cache = enc_other_cache(enc, cache)->private; 584 if (other_ses_cache->elm_addlstatus_page 585 != ses_cache->elm_addlstatus_page) 586 ENC_FREE(ses_cache->elm_addlstatus_page); 587 ses_cache->elm_addlstatus_page = NULL; 588 } 589 590 static void 591 ses_cache_free_elm_descs(enc_softc_t *enc, enc_cache_t *cache) 592 { 593 ses_cache_t *ses_cache; 594 ses_cache_t *other_ses_cache; 595 enc_element_t *cur_elm; 596 enc_element_t *last_elm; 597 598 ENC_DLOG(enc, "%s: enter\n", __func__); 599 ses_cache = cache->private; 600 if (ses_cache->elm_descs_page == NULL) 601 return; 602 603 for (cur_elm = cache->elm_map, 604 last_elm = &cache->elm_map[cache->nelms]; 605 cur_elm != last_elm; cur_elm++) { 606 ses_element_t *elmpriv; 607 608 elmpriv = cur_elm->elm_private; 609 elmpriv->descr_len = 0; 610 elmpriv->descr = NULL; 611 } 612 613 other_ses_cache = enc_other_cache(enc, cache)->private; 614 if (other_ses_cache->elm_descs_page 615 != ses_cache->elm_descs_page) 616 ENC_FREE(ses_cache->elm_descs_page); 617 ses_cache->elm_descs_page = NULL; 618 } 619 620 static void 621 ses_cache_free_status(enc_softc_t *enc, enc_cache_t *cache) 622 { 623 ses_cache_t *ses_cache; 624 ses_cache_t *other_ses_cache; 625 626 ENC_DLOG(enc, "%s: enter\n", __func__); 627 ses_cache = cache->private; 628 if (ses_cache->status_page == NULL) 629 return; 630 631 other_ses_cache = enc_other_cache(enc, cache)->private; 632 if (other_ses_cache->status_page != ses_cache->status_page) 633 ENC_FREE(ses_cache->status_page); 634 ses_cache->status_page = NULL; 635 } 636 637 static void 638 ses_cache_free_elm_map(enc_softc_t *enc, enc_cache_t *cache) 639 { 640 enc_element_t *cur_elm; 641 enc_element_t *last_elm; 642 643 ENC_DLOG(enc, "%s: enter\n", __func__); 644 if (cache->elm_map == NULL) 645 return; 646 647 ses_cache_free_elm_descs(enc, cache); 648 ses_cache_free_elm_addlstatus(enc, cache); 649 for (cur_elm = cache->elm_map, 650 last_elm = &cache->elm_map[cache->nelms]; 651 cur_elm != last_elm; cur_elm++) { 652 ENC_FREE_AND_NULL(cur_elm->elm_private); 653 } 654 ENC_FREE_AND_NULL(cache->elm_map); 655 cache->nelms = 0; 656 ENC_DLOG(enc, "%s: exit\n", __func__); 657 } 658 659 static void 660 ses_cache_free(enc_softc_t *enc, enc_cache_t *cache) 661 { 662 ses_cache_t *other_ses_cache; 663 ses_cache_t *ses_cache; 664 665 ENC_DLOG(enc, "%s: enter\n", __func__); 666 ses_cache_free_elm_addlstatus(enc, cache); 667 ses_cache_free_status(enc, cache); 668 ses_cache_free_elm_map(enc, cache); 669 670 ses_cache = cache->private; 671 ses_cache->ses_ntypes = 0; 672 673 other_ses_cache = enc_other_cache(enc, cache)->private; 674 if (other_ses_cache->subencs != ses_cache->subencs) 675 ENC_FREE(ses_cache->subencs); 676 ses_cache->subencs = NULL; 677 678 if (other_ses_cache->ses_types != ses_cache->ses_types) 679 ENC_FREE(ses_cache->ses_types); 680 ses_cache->ses_types = NULL; 681 682 if (other_ses_cache->cfg_page != ses_cache->cfg_page) 683 ENC_FREE(ses_cache->cfg_page); 684 ses_cache->cfg_page = NULL; 685 686 ENC_DLOG(enc, "%s: exit\n", __func__); 687 } 688 689 static void 690 ses_cache_clone(enc_softc_t *enc, enc_cache_t *src, enc_cache_t *dst) 691 { 692 ses_cache_t *dst_ses_cache; 693 ses_cache_t *src_ses_cache; 694 enc_element_t *src_elm; 695 enc_element_t *dst_elm; 696 enc_element_t *last_elm; 697 698 ses_cache_free(enc, dst); 699 src_ses_cache = src->private; 700 dst_ses_cache = dst->private; 701 702 /* 703 * The cloned enclosure cache and ses specific cache are 704 * mostly identical to the source. 705 */ 706 *dst = *src; 707 *dst_ses_cache = *src_ses_cache; 708 709 /* 710 * But the ses cache storage is still independent. Restore 711 * the pointer that was clobbered by the structure copy above. 712 */ 713 dst->private = dst_ses_cache; 714 715 /* 716 * The element map is independent even though it starts out 717 * pointing to the same constant page data. 718 */ 719 dst->elm_map = malloc(dst->nelms * sizeof(enc_element_t), 720 M_SCSIENC, M_WAITOK); 721 memcpy(dst->elm_map, src->elm_map, dst->nelms * sizeof(enc_element_t)); 722 for (dst_elm = dst->elm_map, src_elm = src->elm_map, 723 last_elm = &src->elm_map[src->nelms]; 724 src_elm != last_elm; src_elm++, dst_elm++) { 725 dst_elm->elm_private = malloc(sizeof(ses_element_t), 726 M_SCSIENC, M_WAITOK); 727 memcpy(dst_elm->elm_private, src_elm->elm_private, 728 sizeof(ses_element_t)); 729 } 730 } 731 732 /* Structure accessors. These are strongly typed to avoid errors. */ 733 734 int 735 ses_elm_sas_descr_type(union ses_elm_sas_hdr *obj) 736 { 737 return ((obj)->base_hdr.byte1 >> 6); 738 } 739 int 740 ses_elm_addlstatus_proto(struct ses_elm_addlstatus_base_hdr *hdr) 741 { 742 return ((hdr)->byte0 & 0xf); 743 } 744 int 745 ses_elm_addlstatus_eip(struct ses_elm_addlstatus_base_hdr *hdr) 746 { 747 return ((hdr)->byte0 >> 4) & 0x1; 748 } 749 int 750 ses_elm_addlstatus_invalid(struct ses_elm_addlstatus_base_hdr *hdr) 751 { 752 return ((hdr)->byte0 >> 7); 753 } 754 int 755 ses_elm_sas_type0_not_all_phys(union ses_elm_sas_hdr *hdr) 756 { 757 return ((hdr)->type0_noneip.byte1 & 0x1); 758 } 759 int 760 ses_elm_sas_dev_phy_sata_dev(struct ses_elm_sas_device_phy *phy) 761 { 762 return ((phy)->target_ports & 0x1); 763 } 764 int 765 ses_elm_sas_dev_phy_sata_port(struct ses_elm_sas_device_phy *phy) 766 { 767 return ((phy)->target_ports >> 7); 768 } 769 int 770 ses_elm_sas_dev_phy_dev_type(struct ses_elm_sas_device_phy *phy) 771 { 772 return (((phy)->byte0 >> 4) & 0x7); 773 } 774 775 /** 776 * \brief Verify that the cached configuration data in our softc 777 * is valid for processing the page data corresponding to 778 * the provided page header. 779 * 780 * \param ses_cache The SES cache to validate. 781 * \param gen_code The 4 byte generation code from a SES diagnostic 782 * page header. 783 * 784 * \return non-zero if true, 0 if false. 785 */ 786 static int 787 ses_config_cache_valid(ses_cache_t *ses_cache, const uint8_t *gen_code) 788 { 789 uint32_t cache_gc; 790 uint32_t cur_gc; 791 792 if (ses_cache->cfg_page == NULL) 793 return (0); 794 795 cache_gc = scsi_4btoul(ses_cache->cfg_page->hdr.gen_code); 796 cur_gc = scsi_4btoul(gen_code); 797 return (cache_gc == cur_gc); 798 } 799 800 /** 801 * Function signature for consumers of the ses_devids_iter() interface. 802 */ 803 typedef void ses_devid_callback_t(enc_softc_t *, enc_element_t *, 804 struct scsi_vpd_id_descriptor *, void *); 805 806 /** 807 * \brief Iterate over and create vpd device id records from the 808 * additional element status data for elm, passing that data 809 * to the provided callback. 810 * 811 * \param enc SES instance containing elm 812 * \param elm Element for which to extract device ID data. 813 * \param callback The callback function to invoke on each generated 814 * device id descriptor for elm. 815 * \param callback_arg Argument passed through to callback on each invocation. 816 */ 817 static void 818 ses_devids_iter(enc_softc_t *enc, enc_element_t *elm, 819 ses_devid_callback_t *callback, void *callback_arg) 820 { 821 ses_element_t *elmpriv; 822 struct ses_addl_status *addl; 823 u_int i; 824 size_t devid_record_size; 825 826 elmpriv = elm->elm_private; 827 addl = &(elmpriv->addl); 828 829 devid_record_size = SVPD_DEVICE_ID_DESC_HDR_LEN 830 + sizeof(struct scsi_vpd_id_naa_ieee_reg); 831 for (i = 0; i < addl->proto_hdr.sas->base_hdr.num_phys; i++) { 832 uint8_t devid_buf[devid_record_size]; 833 struct scsi_vpd_id_descriptor *devid; 834 uint8_t *phy_addr; 835 836 devid = (struct scsi_vpd_id_descriptor *)devid_buf; 837 phy_addr = addl->proto_data.sasdev_phys[i].phy_addr; 838 devid->proto_codeset = (SCSI_PROTO_SAS << SVPD_ID_PROTO_SHIFT) 839 | SVPD_ID_CODESET_BINARY; 840 devid->id_type = SVPD_ID_PIV 841 | SVPD_ID_ASSOC_PORT 842 | SVPD_ID_TYPE_NAA; 843 devid->reserved = 0; 844 devid->length = sizeof(struct scsi_vpd_id_naa_ieee_reg); 845 memcpy(devid->identifier, phy_addr, devid->length); 846 847 callback(enc, elm, devid, callback_arg); 848 } 849 } 850 851 /** 852 * Function signature for consumers of the ses_paths_iter() interface. 853 */ 854 typedef void ses_path_callback_t(enc_softc_t *, enc_element_t *, 855 struct cam_path *, void *); 856 857 /** 858 * Argument package passed through ses_devids_iter() by 859 * ses_paths_iter() to ses_path_iter_devid_callback(). 860 */ 861 typedef struct ses_path_iter_args { 862 ses_path_callback_t *callback; 863 void *callback_arg; 864 } ses_path_iter_args_t; 865 866 /** 867 * ses_devids_iter() callback function used by ses_paths_iter() 868 * to map device ids to peripheral driver instances. 869 * 870 * \param enc SES instance containing elm 871 * \param elm Element on which device ID matching is active. 872 * \param periph A device ID corresponding to elm. 873 * \param arg Argument passed through to callback on each invocation. 874 */ 875 static void 876 ses_path_iter_devid_callback(enc_softc_t *enc, enc_element_t *elem, 877 struct scsi_vpd_id_descriptor *devid, 878 void *arg) 879 { 880 struct ccb_dev_match cdm; 881 struct dev_match_pattern match_pattern; 882 struct dev_match_result match_result; 883 struct device_match_result *device_match; 884 struct device_match_pattern *device_pattern; 885 ses_path_iter_args_t *args; 886 struct cam_path *path; 887 888 args = (ses_path_iter_args_t *)arg; 889 match_pattern.type = DEV_MATCH_DEVICE; 890 device_pattern = &match_pattern.pattern.device_pattern; 891 device_pattern->flags = DEV_MATCH_DEVID; 892 device_pattern->data.devid_pat.id_len = 893 offsetof(struct scsi_vpd_id_descriptor, identifier) 894 + devid->length; 895 memcpy(device_pattern->data.devid_pat.id, devid, 896 device_pattern->data.devid_pat.id_len); 897 if (!ses_search_globally) { 898 device_pattern->flags |= DEV_MATCH_PATH; 899 device_pattern->path_id = xpt_path_path_id(enc->periph->path); 900 } 901 902 memset(&cdm, 0, sizeof(cdm)); 903 if (xpt_create_path(&cdm.ccb_h.path, /*periph*/NULL, 904 CAM_XPT_PATH_ID, 905 CAM_TARGET_WILDCARD, 906 CAM_LUN_WILDCARD) != CAM_REQ_CMP) 907 return; 908 909 cdm.ccb_h.func_code = XPT_DEV_MATCH; 910 cdm.num_patterns = 1; 911 cdm.patterns = &match_pattern; 912 cdm.pattern_buf_len = sizeof(match_pattern); 913 cdm.match_buf_len = sizeof(match_result); 914 cdm.matches = &match_result; 915 916 do { 917 xpt_action((union ccb *)&cdm); 918 919 if ((cdm.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP || 920 (cdm.status != CAM_DEV_MATCH_LAST && 921 cdm.status != CAM_DEV_MATCH_MORE) || 922 cdm.num_matches == 0) 923 break; 924 925 device_match = &match_result.result.device_result; 926 if (xpt_create_path(&path, /*periph*/NULL, 927 device_match->path_id, 928 device_match->target_id, 929 device_match->target_lun) == CAM_REQ_CMP) { 930 args->callback(enc, elem, path, args->callback_arg); 931 932 xpt_free_path(path); 933 } 934 } while (cdm.status == CAM_DEV_MATCH_MORE); 935 936 xpt_free_path(cdm.ccb_h.path); 937 } 938 939 /** 940 * \brief Iterate over and find the matching periph objects for the 941 * specified element. 942 * 943 * \param enc SES instance containing elm 944 * \param elm Element for which to perform periph object matching. 945 * \param callback The callback function to invoke with each matching 946 * periph object. 947 * \param callback_arg Argument passed through to callback on each invocation. 948 */ 949 static void 950 ses_paths_iter(enc_softc_t *enc, enc_element_t *elm, 951 ses_path_callback_t *callback, void *callback_arg) 952 { 953 ses_element_t *elmpriv; 954 struct ses_addl_status *addl; 955 956 elmpriv = elm->elm_private; 957 addl = &(elmpriv->addl); 958 959 if (addl->hdr == NULL) 960 return; 961 962 switch(ses_elm_addlstatus_proto(addl->hdr)) { 963 case SPSP_PROTO_SAS: 964 if (addl->proto_hdr.sas != NULL && 965 addl->proto_data.sasdev_phys != NULL) { 966 ses_path_iter_args_t args; 967 968 args.callback = callback; 969 args.callback_arg = callback_arg; 970 ses_devids_iter(enc, elm, ses_path_iter_devid_callback, 971 &args); 972 } 973 break; 974 case SPSP_PROTO_ATA: 975 if (addl->proto_hdr.ata != NULL) { 976 struct cam_path *path; 977 struct ccb_getdev cgd; 978 979 if (xpt_create_path(&path, /*periph*/NULL, 980 scsi_4btoul(addl->proto_hdr.ata->bus), 981 scsi_4btoul(addl->proto_hdr.ata->target), 0) 982 != CAM_REQ_CMP) 983 return; 984 985 memset(&cgd, 0, sizeof(cgd)); 986 xpt_setup_ccb(&cgd.ccb_h, path, CAM_PRIORITY_NORMAL); 987 cgd.ccb_h.func_code = XPT_GDEV_TYPE; 988 xpt_action((union ccb *)&cgd); 989 if (cgd.ccb_h.status == CAM_REQ_CMP) 990 callback(enc, elm, path, callback_arg); 991 992 xpt_free_path(path); 993 } 994 break; 995 } 996 } 997 998 /** 999 * ses_paths_iter() callback function used by ses_get_elmdevname() 1000 * to record periph driver instance strings corresponding to a SES 1001 * element. 1002 * 1003 * \param enc SES instance containing elm 1004 * \param elm Element on which periph matching is active. 1005 * \param periph A periph instance that matches elm. 1006 * \param arg Argument passed through to callback on each invocation. 1007 */ 1008 static void 1009 ses_elmdevname_callback(enc_softc_t *enc, enc_element_t *elem, 1010 struct cam_path *path, void *arg) 1011 { 1012 struct sbuf *sb; 1013 1014 sb = (struct sbuf *)arg; 1015 cam_periph_list(path, sb); 1016 } 1017 1018 /** 1019 * Argument package passed through ses_paths_iter() to 1020 * ses_getcampath_callback. 1021 */ 1022 typedef struct ses_setphyspath_callback_args { 1023 struct sbuf *physpath; 1024 int num_set; 1025 } ses_setphyspath_callback_args_t; 1026 1027 /** 1028 * \brief ses_paths_iter() callback to set the physical path on the 1029 * CAM EDT entries corresponding to a given SES element. 1030 * 1031 * \param enc SES instance containing elm 1032 * \param elm Element on which periph matching is active. 1033 * \param periph A periph instance that matches elm. 1034 * \param arg Argument passed through to callback on each invocation. 1035 */ 1036 static void 1037 ses_setphyspath_callback(enc_softc_t *enc, enc_element_t *elm, 1038 struct cam_path *path, void *arg) 1039 { 1040 struct ccb_dev_advinfo cdai; 1041 ses_setphyspath_callback_args_t *args; 1042 char *old_physpath; 1043 1044 args = (ses_setphyspath_callback_args_t *)arg; 1045 old_physpath = malloc(MAXPATHLEN, M_SCSIENC, M_WAITOK|M_ZERO); 1046 xpt_path_lock(path); 1047 memset(&cdai, 0, sizeof(cdai)); 1048 xpt_setup_ccb(&cdai.ccb_h, path, CAM_PRIORITY_NORMAL); 1049 cdai.ccb_h.func_code = XPT_DEV_ADVINFO; 1050 cdai.buftype = CDAI_TYPE_PHYS_PATH; 1051 cdai.flags = CDAI_FLAG_NONE; 1052 cdai.bufsiz = MAXPATHLEN; 1053 cdai.buf = old_physpath; 1054 xpt_action((union ccb *)&cdai); 1055 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0) 1056 cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE); 1057 1058 if (strcmp(old_physpath, sbuf_data(args->physpath)) != 0) { 1059 xpt_setup_ccb(&cdai.ccb_h, path, CAM_PRIORITY_NORMAL); 1060 cdai.ccb_h.func_code = XPT_DEV_ADVINFO; 1061 cdai.buftype = CDAI_TYPE_PHYS_PATH; 1062 cdai.flags = CDAI_FLAG_STORE; 1063 cdai.bufsiz = sbuf_len(args->physpath); 1064 cdai.buf = sbuf_data(args->physpath); 1065 xpt_action((union ccb *)&cdai); 1066 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0) 1067 cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE); 1068 if (cdai.ccb_h.status == CAM_REQ_CMP) 1069 args->num_set++; 1070 } 1071 xpt_path_unlock(path); 1072 free(old_physpath, M_SCSIENC); 1073 } 1074 1075 /** 1076 * \brief Set a device's physical path string in CAM XPT. 1077 * 1078 * \param enc SES instance containing elm 1079 * \param elm Element to publish physical path string for 1080 * \param iter Iterator whose state corresponds to elm 1081 * 1082 * \return 0 on success, errno otherwise. 1083 */ 1084 static int 1085 ses_set_physpath(enc_softc_t *enc, enc_element_t *elm, 1086 struct ses_iterator *iter) 1087 { 1088 struct ccb_dev_advinfo cdai; 1089 ses_setphyspath_callback_args_t args; 1090 int i, ret; 1091 struct sbuf sb; 1092 struct scsi_vpd_id_descriptor *idd; 1093 uint8_t *devid; 1094 ses_element_t *elmpriv; 1095 const char *c; 1096 1097 ret = EIO; 1098 devid = NULL; 1099 1100 elmpriv = elm->elm_private; 1101 if (elmpriv->addl.hdr == NULL) 1102 goto out; 1103 1104 /* 1105 * Assemble the components of the physical path starting with 1106 * the device ID of the enclosure itself. 1107 */ 1108 memset(&cdai, 0, sizeof(cdai)); 1109 xpt_setup_ccb(&cdai.ccb_h, enc->periph->path, CAM_PRIORITY_NORMAL); 1110 cdai.ccb_h.func_code = XPT_DEV_ADVINFO; 1111 cdai.flags = CDAI_FLAG_NONE; 1112 cdai.buftype = CDAI_TYPE_SCSI_DEVID; 1113 cdai.bufsiz = CAM_SCSI_DEVID_MAXLEN; 1114 cdai.buf = devid = malloc(cdai.bufsiz, M_SCSIENC, M_WAITOK|M_ZERO); 1115 cam_periph_lock(enc->periph); 1116 xpt_action((union ccb *)&cdai); 1117 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0) 1118 cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE); 1119 cam_periph_unlock(enc->periph); 1120 if (cdai.ccb_h.status != CAM_REQ_CMP) 1121 goto out; 1122 1123 idd = scsi_get_devid((struct scsi_vpd_device_id *)cdai.buf, 1124 cdai.provsiz, scsi_devid_is_naa_ieee_reg); 1125 if (idd == NULL) 1126 goto out; 1127 1128 if (sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND) == NULL) { 1129 ret = ENOMEM; 1130 goto out; 1131 } 1132 /* Next, generate the physical path string */ 1133 sbuf_printf(&sb, "id1,enc@n%jx/type@%x/slot@%x", 1134 scsi_8btou64(idd->identifier), iter->type_index, 1135 iter->type_element_index); 1136 /* Append the element descriptor if one exists */ 1137 if (elmpriv->descr != NULL && elmpriv->descr_len > 0) { 1138 sbuf_cat(&sb, "/elmdesc@"); 1139 for (i = 0, c = elmpriv->descr; i < elmpriv->descr_len; 1140 i++, c++) { 1141 if (!isprint(*c) || isspace(*c) || *c == '/') 1142 sbuf_putc(&sb, '_'); 1143 else 1144 sbuf_putc(&sb, *c); 1145 } 1146 } 1147 sbuf_finish(&sb); 1148 1149 /* 1150 * Set this physical path on any CAM devices with a device ID 1151 * descriptor that matches one created from the SES additional 1152 * status data for this element. 1153 */ 1154 args.physpath= &sb; 1155 args.num_set = 0; 1156 ses_paths_iter(enc, elm, ses_setphyspath_callback, &args); 1157 sbuf_delete(&sb); 1158 1159 ret = args.num_set == 0 ? ENOENT : 0; 1160 1161 out: 1162 if (devid != NULL) 1163 ENC_FREE(devid); 1164 return (ret); 1165 } 1166 1167 /** 1168 * \brief Helper to set the CDB fields appropriately. 1169 * 1170 * \param cdb Buffer containing the cdb. 1171 * \param pagenum SES diagnostic page to query for. 1172 * \param dir Direction of query. 1173 */ 1174 static void 1175 ses_page_cdb(char *cdb, int bufsiz, SesDiagPageCodes pagenum, int dir) 1176 { 1177 1178 /* Ref: SPC-4 r25 Section 6.20 Table 223 */ 1179 if (dir == CAM_DIR_IN) { 1180 cdb[0] = RECEIVE_DIAGNOSTIC; 1181 cdb[1] = 1; /* Set page code valid bit */ 1182 cdb[2] = pagenum; 1183 } else { 1184 cdb[0] = SEND_DIAGNOSTIC; 1185 cdb[1] = 0x10; 1186 cdb[2] = pagenum; 1187 } 1188 cdb[3] = bufsiz >> 8; /* high bits */ 1189 cdb[4] = bufsiz & 0xff; /* low bits */ 1190 cdb[5] = 0; 1191 } 1192 1193 /** 1194 * \brief Discover whether this instance supports timed completion of a 1195 * RECEIVE DIAGNOSTIC RESULTS command requesting the Enclosure Status 1196 * page, and store the result in the softc, updating if necessary. 1197 * 1198 * \param enc SES instance to query and update. 1199 * \param tc_en Value of timed completion to set (see \return). 1200 * 1201 * \return 1 if timed completion enabled, 0 otherwise. 1202 */ 1203 static int 1204 ses_set_timed_completion(enc_softc_t *enc, uint8_t tc_en) 1205 { 1206 union ccb *ccb; 1207 struct cam_periph *periph; 1208 struct ses_mgmt_mode_page *mgmt; 1209 uint8_t *mode_buf; 1210 size_t mode_buf_len; 1211 ses_softc_t *ses; 1212 1213 periph = enc->periph; 1214 ses = enc->enc_private; 1215 ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL); 1216 1217 mode_buf_len = sizeof(struct ses_mgmt_mode_page); 1218 mode_buf = ENC_MALLOCZ(mode_buf_len); 1219 if (mode_buf == NULL) 1220 goto out; 1221 1222 scsi_mode_sense(&ccb->csio, /*retries*/4, NULL, MSG_SIMPLE_Q_TAG, 1223 /*dbd*/FALSE, SMS_PAGE_CTRL_CURRENT, SES_MGMT_MODE_PAGE_CODE, 1224 mode_buf, mode_buf_len, SSD_FULL_SIZE, /*timeout*/60 * 1000); 1225 1226 /* 1227 * Ignore illegal request errors, as they are quite common and we 1228 * will print something out in that case anyway. 1229 */ 1230 cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, 1231 ENC_FLAGS|SF_QUIET_IR, NULL); 1232 if (ccb->ccb_h.status != CAM_REQ_CMP) { 1233 ENC_VLOG(enc, "Timed Completion Unsupported\n"); 1234 goto release; 1235 } 1236 1237 /* Skip the mode select if the desired value is already set */ 1238 mgmt = (struct ses_mgmt_mode_page *)mode_buf; 1239 if ((mgmt->byte5 & SES_MGMT_TIMED_COMP_EN) == tc_en) 1240 goto done; 1241 1242 /* Value is not what we wanted, set it */ 1243 if (tc_en) 1244 mgmt->byte5 |= SES_MGMT_TIMED_COMP_EN; 1245 else 1246 mgmt->byte5 &= ~SES_MGMT_TIMED_COMP_EN; 1247 /* SES2r20: a completion time of zero means as long as possible */ 1248 bzero(&mgmt->max_comp_time, sizeof(mgmt->max_comp_time)); 1249 1250 scsi_mode_select(&ccb->csio, 5, NULL, MSG_SIMPLE_Q_TAG, 1251 /*page_fmt*/FALSE, /*save_pages*/TRUE, mode_buf, mode_buf_len, 1252 SSD_FULL_SIZE, /*timeout*/60 * 1000); 1253 1254 cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, ENC_FLAGS, NULL); 1255 if (ccb->ccb_h.status != CAM_REQ_CMP) { 1256 ENC_VLOG(enc, "Timed Completion Set Failed\n"); 1257 goto release; 1258 } 1259 1260 done: 1261 if ((mgmt->byte5 & SES_MGMT_TIMED_COMP_EN) != 0) { 1262 ENC_LOG(enc, "Timed Completion Enabled\n"); 1263 ses->ses_flags |= SES_FLAG_TIMEDCOMP; 1264 } else { 1265 ENC_LOG(enc, "Timed Completion Disabled\n"); 1266 ses->ses_flags &= ~SES_FLAG_TIMEDCOMP; 1267 } 1268 release: 1269 ENC_FREE(mode_buf); 1270 xpt_release_ccb(ccb); 1271 out: 1272 return (ses->ses_flags & SES_FLAG_TIMEDCOMP); 1273 } 1274 1275 /** 1276 * \brief Process the list of supported pages and update flags. 1277 * 1278 * \param enc SES device to query. 1279 * \param buf Buffer containing the config page. 1280 * \param xfer_len Length of the config page in the buffer. 1281 * 1282 * \return 0 on success, errno otherwise. 1283 */ 1284 static int 1285 ses_process_pages(enc_softc_t *enc, struct enc_fsm_state *state, 1286 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1287 { 1288 ses_softc_t *ses; 1289 struct scsi_diag_page *page; 1290 int err, i, length; 1291 1292 CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE, 1293 ("entering %s(%p, %d)\n", __func__, bufp, xfer_len)); 1294 ses = enc->enc_private; 1295 err = -1; 1296 1297 if (error != 0) { 1298 err = error; 1299 goto out; 1300 } 1301 if (xfer_len < sizeof(*page)) { 1302 ENC_VLOG(enc, "Unable to parse Diag Pages List Header\n"); 1303 err = EIO; 1304 goto out; 1305 } 1306 page = (struct scsi_diag_page *)*bufp; 1307 length = scsi_2btoul(page->length); 1308 if (length + offsetof(struct scsi_diag_page, params) > xfer_len) { 1309 ENC_VLOG(enc, "Diag Pages List Too Long\n"); 1310 goto out; 1311 } 1312 ENC_DLOG(enc, "%s: page length %d, xfer_len %d\n", 1313 __func__, length, xfer_len); 1314 1315 err = 0; 1316 for (i = 0; i < length; i++) { 1317 if (page->params[i] == SesElementDescriptor) 1318 ses->ses_flags |= SES_FLAG_DESC; 1319 else if (page->params[i] == SesAddlElementStatus) 1320 ses->ses_flags |= SES_FLAG_ADDLSTATUS; 1321 } 1322 1323 out: 1324 ENC_DLOG(enc, "%s: exiting with err %d\n", __func__, err); 1325 return (err); 1326 } 1327 1328 /** 1329 * \brief Process the config page and update associated structures. 1330 * 1331 * \param enc SES device to query. 1332 * \param buf Buffer containing the config page. 1333 * \param xfer_len Length of the config page in the buffer. 1334 * 1335 * \return 0 on success, errno otherwise. 1336 */ 1337 static int 1338 ses_process_config(enc_softc_t *enc, struct enc_fsm_state *state, 1339 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1340 { 1341 struct ses_iterator iter; 1342 ses_softc_t *ses; 1343 enc_cache_t *enc_cache; 1344 ses_cache_t *ses_cache; 1345 uint8_t *buf; 1346 int length; 1347 int err; 1348 int nelm; 1349 int ntype; 1350 struct ses_cfg_page *cfg_page; 1351 struct ses_enc_desc *buf_subenc; 1352 const struct ses_enc_desc **subencs; 1353 const struct ses_enc_desc **cur_subenc; 1354 const struct ses_enc_desc **last_subenc; 1355 ses_type_t *ses_types; 1356 ses_type_t *sestype; 1357 const struct ses_elm_type_desc *cur_buf_type; 1358 const struct ses_elm_type_desc *last_buf_type; 1359 uint8_t *last_valid_byte; 1360 enc_element_t *element; 1361 const char *type_text; 1362 1363 CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE, 1364 ("entering %s(%p, %d)\n", __func__, bufp, xfer_len)); 1365 ses = enc->enc_private; 1366 enc_cache = &enc->enc_daemon_cache; 1367 ses_cache = enc_cache->private; 1368 buf = *bufp; 1369 err = -1; 1370 1371 if (error != 0) { 1372 err = error; 1373 goto out; 1374 } 1375 if (xfer_len < sizeof(cfg_page->hdr)) { 1376 ENC_VLOG(enc, "Unable to parse SES Config Header\n"); 1377 err = EIO; 1378 goto out; 1379 } 1380 1381 cfg_page = (struct ses_cfg_page *)buf; 1382 length = ses_page_length(&cfg_page->hdr); 1383 if (length > xfer_len) { 1384 ENC_VLOG(enc, "Enclosure Config Page Too Long\n"); 1385 goto out; 1386 } 1387 last_valid_byte = &buf[length - 1]; 1388 1389 ENC_DLOG(enc, "%s: total page length %d, xfer_len %d\n", 1390 __func__, length, xfer_len); 1391 1392 err = 0; 1393 if (ses_config_cache_valid(ses_cache, cfg_page->hdr.gen_code)) { 1394 /* Our cache is still valid. Proceed to fetching status. */ 1395 goto out; 1396 } 1397 1398 /* Cache is no longer valid. Free old data to make way for new. */ 1399 ses_cache_free(enc, enc_cache); 1400 ENC_VLOG(enc, "Generation Code 0x%x has %d SubEnclosures\n", 1401 scsi_4btoul(cfg_page->hdr.gen_code), 1402 ses_cfg_page_get_num_subenc(cfg_page)); 1403 1404 /* Take ownership of the buffer. */ 1405 ses_cache->cfg_page = cfg_page; 1406 *bufp = NULL; 1407 1408 /* 1409 * Now waltz through all the subenclosures summing the number of 1410 * types available in each. 1411 */ 1412 subencs = malloc(ses_cfg_page_get_num_subenc(cfg_page) 1413 * sizeof(*subencs), M_SCSIENC, M_WAITOK|M_ZERO); 1414 /* 1415 * Sub-enclosure data is const after construction (i.e. when 1416 * accessed via our cache object. 1417 * 1418 * The cast here is not required in C++ but C99 is not so 1419 * sophisticated (see C99 6.5.16.1(1)). 1420 */ 1421 ses_cache->ses_nsubencs = ses_cfg_page_get_num_subenc(cfg_page); 1422 ses_cache->subencs = subencs; 1423 1424 buf_subenc = cfg_page->subencs; 1425 cur_subenc = subencs; 1426 last_subenc = &subencs[ses_cache->ses_nsubencs - 1]; 1427 ntype = 0; 1428 while (cur_subenc <= last_subenc) { 1429 if (!ses_enc_desc_is_complete(buf_subenc, last_valid_byte)) { 1430 ENC_VLOG(enc, "Enclosure %d Beyond End of " 1431 "Descriptors\n", cur_subenc - subencs); 1432 err = EIO; 1433 goto out; 1434 } 1435 1436 ENC_VLOG(enc, " SubEnclosure ID %d, %d Types With this ID, " 1437 "Descriptor Length %d, offset %d\n", buf_subenc->subenc_id, 1438 buf_subenc->num_types, buf_subenc->length, 1439 &buf_subenc->byte0 - buf); 1440 ENC_VLOG(enc, "WWN: %jx\n", 1441 (uintmax_t)scsi_8btou64(buf_subenc->logical_id)); 1442 1443 ntype += buf_subenc->num_types; 1444 *cur_subenc = buf_subenc; 1445 cur_subenc++; 1446 buf_subenc = ses_enc_desc_next(buf_subenc); 1447 } 1448 1449 /* Process the type headers. */ 1450 ses_types = malloc(ntype * sizeof(*ses_types), 1451 M_SCSIENC, M_WAITOK|M_ZERO); 1452 /* 1453 * Type data is const after construction (i.e. when accessed via 1454 * our cache object. 1455 */ 1456 ses_cache->ses_ntypes = ntype; 1457 ses_cache->ses_types = ses_types; 1458 1459 cur_buf_type = (const struct ses_elm_type_desc *) 1460 (&(*last_subenc)->length + (*last_subenc)->length + 1); 1461 last_buf_type = cur_buf_type + ntype - 1; 1462 type_text = (const uint8_t *)(last_buf_type + 1); 1463 nelm = 0; 1464 sestype = ses_types; 1465 while (cur_buf_type <= last_buf_type) { 1466 if (&cur_buf_type->etype_txt_len > last_valid_byte) { 1467 ENC_VLOG(enc, "Runt Enclosure Type Header %d\n", 1468 sestype - ses_types); 1469 err = EIO; 1470 goto out; 1471 } 1472 sestype->hdr = cur_buf_type; 1473 sestype->text = type_text; 1474 type_text += cur_buf_type->etype_txt_len; 1475 ENC_VLOG(enc, " Type Desc[%d]: Type 0x%x, MaxElt %d, In Subenc " 1476 "%d, Text Length %d: %.*s\n", sestype - ses_types, 1477 sestype->hdr->etype_elm_type, sestype->hdr->etype_maxelt, 1478 sestype->hdr->etype_subenc, sestype->hdr->etype_txt_len, 1479 sestype->hdr->etype_txt_len, sestype->text); 1480 1481 nelm += sestype->hdr->etype_maxelt 1482 + /*overall status element*/1; 1483 sestype++; 1484 cur_buf_type++; 1485 } 1486 1487 /* Create the object map. */ 1488 enc_cache->elm_map = malloc(nelm * sizeof(enc_element_t), 1489 M_SCSIENC, M_WAITOK|M_ZERO); 1490 enc_cache->nelms = nelm; 1491 1492 ses_iter_init(enc, enc_cache, &iter); 1493 while ((element = ses_iter_next(&iter)) != NULL) { 1494 const struct ses_elm_type_desc *thdr; 1495 1496 ENC_DLOG(enc, "%s: checking obj %d(%d,%d)\n", __func__, 1497 iter.global_element_index, iter.type_index, nelm, 1498 iter.type_element_index); 1499 thdr = ses_cache->ses_types[iter.type_index].hdr; 1500 element->elm_idx = iter.global_element_index; 1501 element->elm_type = thdr->etype_elm_type; 1502 element->subenclosure = thdr->etype_subenc; 1503 element->type_elm_idx = iter.type_element_index; 1504 element->elm_private = malloc(sizeof(ses_element_t), 1505 M_SCSIENC, M_WAITOK|M_ZERO); 1506 ENC_DLOG(enc, "%s: creating elmpriv %d(%d,%d) subenc %d " 1507 "type 0x%x\n", __func__, iter.global_element_index, 1508 iter.type_index, iter.type_element_index, 1509 thdr->etype_subenc, thdr->etype_elm_type); 1510 } 1511 1512 err = 0; 1513 1514 out: 1515 if (err) 1516 ses_cache_free(enc, enc_cache); 1517 else { 1518 ses_poll_status(enc); 1519 enc_update_request(enc, SES_PUBLISH_CACHE); 1520 } 1521 ENC_DLOG(enc, "%s: exiting with err %d\n", __func__, err); 1522 return (err); 1523 } 1524 1525 /** 1526 * \brief Update the status page and associated structures. 1527 * 1528 * \param enc SES softc to update for. 1529 * \param buf Buffer containing the status page. 1530 * \param bufsz Amount of data in the buffer. 1531 * 1532 * \return 0 on success, errno otherwise. 1533 */ 1534 static int 1535 ses_process_status(enc_softc_t *enc, struct enc_fsm_state *state, 1536 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1537 { 1538 struct ses_iterator iter; 1539 enc_element_t *element; 1540 ses_softc_t *ses; 1541 enc_cache_t *enc_cache; 1542 ses_cache_t *ses_cache; 1543 uint8_t *buf; 1544 int err = -1; 1545 int length; 1546 struct ses_status_page *page; 1547 union ses_status_element *cur_stat; 1548 union ses_status_element *last_stat; 1549 1550 ses = enc->enc_private; 1551 enc_cache = &enc->enc_daemon_cache; 1552 ses_cache = enc_cache->private; 1553 buf = *bufp; 1554 1555 ENC_DLOG(enc, "%s: enter (%p, %p, %d)\n", __func__, enc, buf, xfer_len); 1556 page = (struct ses_status_page *)buf; 1557 length = ses_page_length(&page->hdr); 1558 1559 if (error != 0) { 1560 err = error; 1561 goto out; 1562 } 1563 /* 1564 * Make sure the length fits in the buffer. 1565 * 1566 * XXX all this means is that the page is larger than the space 1567 * we allocated. Since we use a statically sized buffer, this 1568 * could happen... Need to use dynamic discovery of the size. 1569 */ 1570 if (length > xfer_len) { 1571 ENC_VLOG(enc, "Enclosure Status Page Too Long\n"); 1572 goto out; 1573 } 1574 1575 /* Check for simple enclosure reporting short enclosure status. */ 1576 if (length >= 4 && page->hdr.page_code == SesShortStatus) { 1577 ENC_DLOG(enc, "Got Short Enclosure Status page\n"); 1578 ses->ses_flags &= ~(SES_FLAG_ADDLSTATUS | SES_FLAG_DESC); 1579 ses_cache_free(enc, enc_cache); 1580 enc_cache->enc_status = page->hdr.page_specific_flags; 1581 enc_update_request(enc, SES_PUBLISH_CACHE); 1582 err = 0; 1583 goto out; 1584 } 1585 1586 /* Make sure the length contains at least one header and status */ 1587 if (length < (sizeof(*page) + sizeof(*page->elements))) { 1588 ENC_VLOG(enc, "Enclosure Status Page Too Short\n"); 1589 goto out; 1590 } 1591 1592 if (!ses_config_cache_valid(ses_cache, page->hdr.gen_code)) { 1593 ENC_DLOG(enc, "%s: Generation count change detected\n", 1594 __func__); 1595 enc_update_request(enc, SES_UPDATE_GETCONFIG); 1596 goto out; 1597 } 1598 1599 ses_cache_free_status(enc, enc_cache); 1600 ses_cache->status_page = page; 1601 *bufp = NULL; 1602 1603 enc_cache->enc_status = page->hdr.page_specific_flags; 1604 1605 /* 1606 * Read in individual element status. The element order 1607 * matches the order reported in the config page (i.e. the 1608 * order of an unfiltered iteration of the config objects).. 1609 */ 1610 ses_iter_init(enc, enc_cache, &iter); 1611 cur_stat = page->elements; 1612 last_stat = (union ses_status_element *) 1613 &buf[length - sizeof(*last_stat)]; 1614 ENC_DLOG(enc, "%s: total page length %d, xfer_len %d\n", 1615 __func__, length, xfer_len); 1616 while (cur_stat <= last_stat 1617 && (element = ses_iter_next(&iter)) != NULL) { 1618 ENC_DLOG(enc, "%s: obj %d(%d,%d) off=0x%tx status=%jx\n", 1619 __func__, iter.global_element_index, iter.type_index, 1620 iter.type_element_index, (uint8_t *)cur_stat - buf, 1621 scsi_4btoul(cur_stat->bytes)); 1622 1623 memcpy(&element->encstat, cur_stat, sizeof(element->encstat)); 1624 element->svalid = 1; 1625 cur_stat++; 1626 } 1627 1628 if (ses_iter_next(&iter) != NULL) { 1629 ENC_VLOG(enc, "Status page, length insufficient for " 1630 "expected number of objects\n"); 1631 } else { 1632 if (cur_stat <= last_stat) 1633 ENC_VLOG(enc, "Status page, exhausted objects before " 1634 "exhausing page\n"); 1635 enc_update_request(enc, SES_PUBLISH_CACHE); 1636 err = 0; 1637 } 1638 out: 1639 ENC_DLOG(enc, "%s: exiting with error %d\n", __func__, err); 1640 return (err); 1641 } 1642 1643 typedef enum { 1644 /** 1645 * The enclosure should not provide additional element 1646 * status for this element type in page 0x0A. 1647 * 1648 * \note This status is returned for any types not 1649 * listed SES3r02. Further types added in a 1650 * future specification will be incorrectly 1651 * classified. 1652 */ 1653 TYPE_ADDLSTATUS_NONE, 1654 1655 /** 1656 * The element type provides additional element status 1657 * in page 0x0A. 1658 */ 1659 TYPE_ADDLSTATUS_MANDATORY, 1660 1661 /** 1662 * The element type may provide additional element status 1663 * in page 0x0A, but i 1664 */ 1665 TYPE_ADDLSTATUS_OPTIONAL 1666 } ses_addlstatus_avail_t; 1667 1668 /** 1669 * \brief Check to see whether a given type (as obtained via type headers) is 1670 * supported by the additional status command. 1671 * 1672 * \param enc SES softc to check. 1673 * \param typidx Type index to check for. 1674 * 1675 * \return An enumeration indicating if additional status is mandatory, 1676 * optional, or not required for this type. 1677 */ 1678 static ses_addlstatus_avail_t 1679 ses_typehasaddlstatus(enc_softc_t *enc, uint8_t typidx) 1680 { 1681 enc_cache_t *enc_cache; 1682 ses_cache_t *ses_cache; 1683 1684 enc_cache = &enc->enc_daemon_cache; 1685 ses_cache = enc_cache->private; 1686 switch(ses_cache->ses_types[typidx].hdr->etype_elm_type) { 1687 case ELMTYP_DEVICE: 1688 case ELMTYP_ARRAY_DEV: 1689 case ELMTYP_SAS_EXP: 1690 return (TYPE_ADDLSTATUS_MANDATORY); 1691 case ELMTYP_SCSI_INI: 1692 case ELMTYP_SCSI_TGT: 1693 case ELMTYP_ESCC: 1694 return (TYPE_ADDLSTATUS_OPTIONAL); 1695 default: 1696 /* No additional status information available. */ 1697 break; 1698 } 1699 return (TYPE_ADDLSTATUS_NONE); 1700 } 1701 1702 static int ses_get_elm_addlstatus_fc(enc_softc_t *, enc_cache_t *, 1703 uint8_t *, int); 1704 static int ses_get_elm_addlstatus_sas(enc_softc_t *, enc_cache_t *, uint8_t *, 1705 int, int, int, int); 1706 static int ses_get_elm_addlstatus_ata(enc_softc_t *, enc_cache_t *, uint8_t *, 1707 int, int, int, int); 1708 1709 /** 1710 * \brief Parse the additional status element data for each object. 1711 * 1712 * \param enc The SES softc to update. 1713 * \param buf The buffer containing the additional status 1714 * element response. 1715 * \param xfer_len Size of the buffer. 1716 * 1717 * \return 0 on success, errno otherwise. 1718 */ 1719 static int 1720 ses_process_elm_addlstatus(enc_softc_t *enc, struct enc_fsm_state *state, 1721 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1722 { 1723 struct ses_iterator iter, titer; 1724 int eip; 1725 int err; 1726 int length; 1727 int offset; 1728 enc_cache_t *enc_cache; 1729 ses_cache_t *ses_cache; 1730 uint8_t *buf; 1731 ses_element_t *elmpriv; 1732 const struct ses_page_hdr *hdr; 1733 enc_element_t *element, *telement; 1734 1735 enc_cache = &enc->enc_daemon_cache; 1736 ses_cache = enc_cache->private; 1737 buf = *bufp; 1738 err = -1; 1739 1740 if (error != 0) { 1741 err = error; 1742 goto out; 1743 } 1744 ses_cache_free_elm_addlstatus(enc, enc_cache); 1745 ses_cache->elm_addlstatus_page = 1746 (struct ses_addl_elem_status_page *)buf; 1747 *bufp = NULL; 1748 1749 /* 1750 * The objects appear in the same order here as in Enclosure Status, 1751 * which itself is ordered by the Type Descriptors from the Config 1752 * page. However, it is necessary to skip elements that are not 1753 * supported by this page when counting them. 1754 */ 1755 hdr = &ses_cache->elm_addlstatus_page->hdr; 1756 length = ses_page_length(hdr); 1757 ENC_DLOG(enc, "Additional Element Status Page Length 0x%x\n", length); 1758 /* Make sure the length includes at least one header. */ 1759 if (length < sizeof(*hdr)+sizeof(struct ses_elm_addlstatus_base_hdr)) { 1760 ENC_VLOG(enc, "Runt Additional Element Status Page\n"); 1761 goto out; 1762 } 1763 if (length > xfer_len) { 1764 ENC_VLOG(enc, "Additional Element Status Page Too Long\n"); 1765 goto out; 1766 } 1767 1768 if (!ses_config_cache_valid(ses_cache, hdr->gen_code)) { 1769 ENC_DLOG(enc, "%s: Generation count change detected\n", 1770 __func__); 1771 enc_update_request(enc, SES_UPDATE_GETCONFIG); 1772 goto out; 1773 } 1774 1775 offset = sizeof(struct ses_page_hdr); 1776 ses_iter_init(enc, enc_cache, &iter); 1777 while (offset < length 1778 && (element = ses_iter_next(&iter)) != NULL) { 1779 struct ses_elm_addlstatus_base_hdr *elm_hdr; 1780 int proto_info_len; 1781 ses_addlstatus_avail_t status_type; 1782 1783 /* 1784 * Additional element status is only provided for 1785 * individual elements (i.e. overal status elements 1786 * are excluded) and those of the types specified 1787 * in the SES spec. 1788 */ 1789 status_type = ses_typehasaddlstatus(enc, iter.type_index); 1790 if (iter.individual_element_index == ITERATOR_INDEX_INVALID 1791 || status_type == TYPE_ADDLSTATUS_NONE) 1792 continue; 1793 1794 elm_hdr = (struct ses_elm_addlstatus_base_hdr *)&buf[offset]; 1795 eip = ses_elm_addlstatus_eip(elm_hdr); 1796 if (eip) { 1797 struct ses_elm_addlstatus_eip_hdr *eip_hdr; 1798 int expected_index, index; 1799 ses_elem_index_type_t index_type; 1800 1801 eip_hdr = (struct ses_elm_addlstatus_eip_hdr *)elm_hdr; 1802 if (SES_ADDL_EIP_EIIOE_EI_GLOB(eip_hdr->byte2)) { 1803 index_type = SES_ELEM_INDEX_GLOBAL; 1804 expected_index = iter.global_element_index; 1805 } else { 1806 index_type = SES_ELEM_INDEX_INDIVIDUAL; 1807 expected_index = iter.individual_element_index; 1808 } 1809 if (eip_hdr->element_index < expected_index) { 1810 ENC_VLOG(enc, "%s: provided %selement index " 1811 "%d is lower then expected %d\n", 1812 __func__, SES_ADDL_EIP_EIIOE_EI_GLOB( 1813 eip_hdr->byte2) ? "global " : "", 1814 eip_hdr->element_index, expected_index); 1815 goto badindex; 1816 } 1817 titer = iter; 1818 telement = ses_iter_seek_to(&titer, 1819 eip_hdr->element_index, index_type); 1820 if (telement == NULL) { 1821 ENC_VLOG(enc, "%s: provided %selement index " 1822 "%d does not exist\n", __func__, 1823 SES_ADDL_EIP_EIIOE_EI_GLOB(eip_hdr->byte2) ? 1824 "global " : "", eip_hdr->element_index); 1825 goto badindex; 1826 } 1827 if (ses_typehasaddlstatus(enc, titer.type_index) == 1828 TYPE_ADDLSTATUS_NONE) { 1829 ENC_VLOG(enc, "%s: provided %selement index " 1830 "%d can't have additional status\n", 1831 __func__, 1832 SES_ADDL_EIP_EIIOE_EI_GLOB(eip_hdr->byte2) ? 1833 "global " : "", eip_hdr->element_index); 1834 badindex: 1835 /* 1836 * If we expected mandatory element, we may 1837 * guess it was just a wrong index and we may 1838 * use the status. If element was optional, 1839 * then we have no idea where status belongs. 1840 */ 1841 if (status_type == TYPE_ADDLSTATUS_OPTIONAL) 1842 break; 1843 } else { 1844 iter = titer; 1845 element = telement; 1846 } 1847 1848 if (SES_ADDL_EIP_EIIOE_EI_GLOB(eip_hdr->byte2)) 1849 index = iter.global_element_index; 1850 else 1851 index = iter.individual_element_index; 1852 if (index > expected_index 1853 && status_type == TYPE_ADDLSTATUS_MANDATORY) { 1854 ENC_VLOG(enc, "%s: provided %s element" 1855 "index %d skips mandatory status " 1856 " element at index %d\n", 1857 __func__, SES_ADDL_EIP_EIIOE_EI_GLOB( 1858 eip_hdr->byte2) ? "global " : "", 1859 index, expected_index); 1860 } 1861 } 1862 elmpriv = element->elm_private; 1863 ENC_DLOG(enc, "%s: global element index=%d, type index=%d " 1864 "type element index=%d, offset=0x%x, " 1865 "byte0=0x%x, length=0x%x\n", __func__, 1866 iter.global_element_index, iter.type_index, 1867 iter.type_element_index, offset, elm_hdr->byte0, 1868 elm_hdr->length); 1869 1870 /* Skip to after the length field */ 1871 offset += sizeof(struct ses_elm_addlstatus_base_hdr); 1872 1873 /* Make sure the descriptor is within bounds */ 1874 if ((offset + elm_hdr->length) > length) { 1875 ENC_VLOG(enc, "Element %d Beyond End " 1876 "of Additional Element Status Descriptors\n", 1877 iter.global_element_index); 1878 break; 1879 } 1880 1881 /* Skip elements marked as invalid. */ 1882 if (ses_elm_addlstatus_invalid(elm_hdr)) { 1883 offset += elm_hdr->length; 1884 continue; 1885 } 1886 elmpriv->addl.hdr = elm_hdr; 1887 1888 /* Advance to the protocol data, skipping eip bytes if needed */ 1889 offset += (eip * SES_EIP_HDR_EXTRA_LEN); 1890 proto_info_len = elm_hdr->length 1891 - (eip * SES_EIP_HDR_EXTRA_LEN); 1892 1893 /* Errors in this block are ignored as they are non-fatal */ 1894 switch(ses_elm_addlstatus_proto(elm_hdr)) { 1895 case SPSP_PROTO_FC: 1896 if (elm_hdr->length == 0) 1897 break; 1898 ses_get_elm_addlstatus_fc(enc, enc_cache, 1899 &buf[offset], proto_info_len); 1900 break; 1901 case SPSP_PROTO_SAS: 1902 if (elm_hdr->length <= 2) 1903 break; 1904 ses_get_elm_addlstatus_sas(enc, enc_cache, 1905 &buf[offset], 1906 proto_info_len, 1907 eip, iter.type_index, 1908 iter.global_element_index); 1909 break; 1910 case SPSP_PROTO_ATA: 1911 ses_get_elm_addlstatus_ata(enc, enc_cache, 1912 &buf[offset], 1913 proto_info_len, 1914 eip, iter.type_index, 1915 iter.global_element_index); 1916 break; 1917 default: 1918 ENC_VLOG(enc, "Element %d: Unknown Additional Element " 1919 "Protocol 0x%x\n", iter.global_element_index, 1920 ses_elm_addlstatus_proto(elm_hdr)); 1921 break; 1922 } 1923 1924 offset += proto_info_len; 1925 } 1926 err = 0; 1927 out: 1928 if (err) 1929 ses_cache_free_elm_addlstatus(enc, enc_cache); 1930 enc_update_request(enc, SES_PUBLISH_PHYSPATHS); 1931 enc_update_request(enc, SES_PUBLISH_CACHE); 1932 return (err); 1933 } 1934 1935 static int 1936 ses_process_control_request(enc_softc_t *enc, struct enc_fsm_state *state, 1937 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1938 { 1939 ses_softc_t *ses; 1940 1941 ses = enc->enc_private; 1942 /* 1943 * Possible errors: 1944 * o Generation count wrong. 1945 * o Some SCSI status error. 1946 */ 1947 ses_terminate_control_requests(&ses->ses_pending_requests, error); 1948 ses_poll_status(enc); 1949 return (0); 1950 } 1951 1952 static int 1953 ses_publish_physpaths(enc_softc_t *enc, struct enc_fsm_state *state, 1954 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1955 { 1956 struct ses_iterator iter; 1957 enc_cache_t *enc_cache; 1958 enc_element_t *element; 1959 1960 enc_cache = &enc->enc_daemon_cache; 1961 1962 ses_iter_init(enc, enc_cache, &iter); 1963 while ((element = ses_iter_next(&iter)) != NULL) { 1964 /* 1965 * ses_set_physpath() returns success if we changed 1966 * the physpath of any element. This allows us to 1967 * only announce devices once regardless of how 1968 * many times we process additional element status. 1969 */ 1970 if (ses_set_physpath(enc, element, &iter) == 0) 1971 ses_print_addl_data(enc, element); 1972 } 1973 1974 return (0); 1975 } 1976 1977 static int 1978 ses_publish_cache(enc_softc_t *enc, struct enc_fsm_state *state, 1979 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 1980 { 1981 1982 sx_xlock(&enc->enc_cache_lock); 1983 ses_cache_clone(enc, /*src*/&enc->enc_daemon_cache, 1984 /*dst*/&enc->enc_cache); 1985 sx_xunlock(&enc->enc_cache_lock); 1986 1987 return (0); 1988 } 1989 1990 /* 1991 * \brief Sanitize an element descriptor 1992 * 1993 * The SES4r3 standard, sections 3.1.2 and 6.1.10, specifies that element 1994 * descriptors may only contain ASCII characters in the range 0x20 to 0x7e. 1995 * But some vendors violate that rule. Ensure that we only expose compliant 1996 * descriptors to userland. 1997 * 1998 * \param desc SES element descriptor as reported by the hardware 1999 * \param len Length of desc in bytes, not necessarily including 2000 * trailing NUL. It will be modified if desc is invalid. 2001 */ 2002 static const char* 2003 ses_sanitize_elm_desc(const char *desc, uint16_t *len) 2004 { 2005 const char *invalid = "<invalid>"; 2006 int i; 2007 2008 for (i = 0; i < *len; i++) { 2009 if (desc[i] == 0) { 2010 break; 2011 } else if (desc[i] < 0x20 || desc[i] > 0x7e) { 2012 *len = strlen(invalid); 2013 return (invalid); 2014 } 2015 } 2016 return (desc); 2017 } 2018 2019 /** 2020 * \brief Parse the descriptors for each object. 2021 * 2022 * \param enc The SES softc to update. 2023 * \param buf The buffer containing the descriptor list response. 2024 * \param xfer_len Size of the buffer. 2025 * 2026 * \return 0 on success, errno otherwise. 2027 */ 2028 static int 2029 ses_process_elm_descs(enc_softc_t *enc, struct enc_fsm_state *state, 2030 union ccb *ccb, uint8_t **bufp, int error, int xfer_len) 2031 { 2032 ses_softc_t *ses; 2033 struct ses_iterator iter; 2034 enc_element_t *element; 2035 int err; 2036 int offset; 2037 u_long length, plength; 2038 enc_cache_t *enc_cache; 2039 ses_cache_t *ses_cache; 2040 uint8_t *buf; 2041 ses_element_t *elmpriv; 2042 const struct ses_page_hdr *phdr; 2043 const struct ses_elm_desc_hdr *hdr; 2044 2045 ses = enc->enc_private; 2046 enc_cache = &enc->enc_daemon_cache; 2047 ses_cache = enc_cache->private; 2048 buf = *bufp; 2049 err = -1; 2050 2051 if (error != 0) { 2052 err = error; 2053 goto out; 2054 } 2055 ses_cache_free_elm_descs(enc, enc_cache); 2056 ses_cache->elm_descs_page = (struct ses_elem_descr_page *)buf; 2057 *bufp = NULL; 2058 2059 phdr = &ses_cache->elm_descs_page->hdr; 2060 plength = ses_page_length(phdr); 2061 if (xfer_len < sizeof(struct ses_page_hdr)) { 2062 ENC_VLOG(enc, "Runt Element Descriptor Page\n"); 2063 goto out; 2064 } 2065 if (plength > xfer_len) { 2066 ENC_VLOG(enc, "Element Descriptor Page Too Long\n"); 2067 goto out; 2068 } 2069 2070 if (!ses_config_cache_valid(ses_cache, phdr->gen_code)) { 2071 ENC_VLOG(enc, "%s: Generation count change detected\n", 2072 __func__); 2073 enc_update_request(enc, SES_UPDATE_GETCONFIG); 2074 goto out; 2075 } 2076 2077 offset = sizeof(struct ses_page_hdr); 2078 2079 ses_iter_init(enc, enc_cache, &iter); 2080 while (offset < plength 2081 && (element = ses_iter_next(&iter)) != NULL) { 2082 if ((offset + sizeof(struct ses_elm_desc_hdr)) > plength) { 2083 ENC_VLOG(enc, "Element %d Descriptor Header Past " 2084 "End of Buffer\n", iter.global_element_index); 2085 goto out; 2086 } 2087 hdr = (struct ses_elm_desc_hdr *)&buf[offset]; 2088 length = scsi_2btoul(hdr->length); 2089 ENC_DLOG(enc, "%s: obj %d(%d,%d) length=%d off=%d\n", __func__, 2090 iter.global_element_index, iter.type_index, 2091 iter.type_element_index, length, offset); 2092 if ((offset + sizeof(*hdr) + length) > plength) { 2093 ENC_VLOG(enc, "Element%d Descriptor Past " 2094 "End of Buffer\n", iter.global_element_index); 2095 goto out; 2096 } 2097 offset += sizeof(*hdr); 2098 2099 if (length > 0) { 2100 elmpriv = element->elm_private; 2101 elmpriv->descr_len = length; 2102 elmpriv->descr = ses_sanitize_elm_desc(&buf[offset], 2103 &elmpriv->descr_len); 2104 } 2105 2106 /* skip over the descriptor itself */ 2107 offset += length; 2108 } 2109 2110 err = 0; 2111 out: 2112 if (err == 0) { 2113 if (ses->ses_flags & SES_FLAG_ADDLSTATUS) 2114 enc_update_request(enc, SES_UPDATE_GETELMADDLSTATUS); 2115 } 2116 enc_update_request(enc, SES_PUBLISH_CACHE); 2117 return (err); 2118 } 2119 2120 static int 2121 ses_fill_rcv_diag_io(enc_softc_t *enc, struct enc_fsm_state *state, 2122 union ccb *ccb, uint8_t *buf) 2123 { 2124 2125 if (enc->enc_type == ENC_SEMB_SES) { 2126 semb_receive_diagnostic_results(&ccb->ataio, /*retries*/5, 2127 NULL, MSG_SIMPLE_Q_TAG, /*pcv*/1, 2128 state->page_code, buf, state->buf_size, 2129 state->timeout); 2130 } else { 2131 scsi_receive_diagnostic_results(&ccb->csio, /*retries*/5, 2132 NULL, MSG_SIMPLE_Q_TAG, /*pcv*/1, 2133 state->page_code, buf, state->buf_size, 2134 SSD_FULL_SIZE, state->timeout); 2135 } 2136 return (0); 2137 } 2138 2139 /** 2140 * \brief Encode the object status into the response buffer, which is 2141 * expected to contain the current enclosure status. This function 2142 * turns off all the 'select' bits for the objects except for the 2143 * object specified, then sends it back to the enclosure. 2144 * 2145 * \param enc SES enclosure the change is being applied to. 2146 * \param buf Buffer containing the current enclosure status response. 2147 * \param amt Length of the response in the buffer. 2148 * \param req The control request to be applied to buf. 2149 * 2150 * \return 0 on success, errno otherwise. 2151 */ 2152 static int 2153 ses_encode(enc_softc_t *enc, uint8_t *buf, int amt, ses_control_request_t *req) 2154 { 2155 struct ses_iterator iter; 2156 enc_element_t *element; 2157 int offset; 2158 struct ses_control_page_hdr *hdr; 2159 2160 ses_iter_init(enc, &enc->enc_cache, &iter); 2161 hdr = (struct ses_control_page_hdr *)buf; 2162 if (req->elm_idx == -1) { 2163 /* for enclosure status, at least 2 bytes are needed */ 2164 if (amt < 2) 2165 return EIO; 2166 hdr->control_flags = 2167 req->elm_stat.comstatus & SES_SET_STATUS_MASK; 2168 ENC_DLOG(enc, "Set EncStat %x\n", hdr->control_flags); 2169 return (0); 2170 } 2171 2172 element = ses_iter_seek_to(&iter, req->elm_idx, SES_ELEM_INDEX_GLOBAL); 2173 if (element == NULL) 2174 return (ENXIO); 2175 2176 /* 2177 * Seek to the type set that corresponds to the requested object. 2178 * The +1 is for the overall status element for the type. 2179 */ 2180 offset = sizeof(struct ses_control_page_hdr) 2181 + (iter.global_element_index * sizeof(struct ses_comstat)); 2182 2183 /* Check for buffer overflow. */ 2184 if (offset + sizeof(struct ses_comstat) > amt) 2185 return (EIO); 2186 2187 /* Set the status. */ 2188 memcpy(&buf[offset], &req->elm_stat, sizeof(struct ses_comstat)); 2189 2190 ENC_DLOG(enc, "Set Type 0x%x Obj 0x%x (offset %d) with %x %x %x %x\n", 2191 iter.type_index, iter.global_element_index, offset, 2192 req->elm_stat.comstatus, req->elm_stat.comstat[0], 2193 req->elm_stat.comstat[1], req->elm_stat.comstat[2]); 2194 2195 return (0); 2196 } 2197 2198 static int 2199 ses_fill_control_request(enc_softc_t *enc, struct enc_fsm_state *state, 2200 union ccb *ccb, uint8_t *buf) 2201 { 2202 ses_softc_t *ses; 2203 enc_cache_t *enc_cache; 2204 ses_cache_t *ses_cache; 2205 struct ses_control_page_hdr *hdr; 2206 ses_control_request_t *req; 2207 size_t plength; 2208 size_t offset; 2209 2210 ses = enc->enc_private; 2211 enc_cache = &enc->enc_daemon_cache; 2212 ses_cache = enc_cache->private; 2213 hdr = (struct ses_control_page_hdr *)buf; 2214 2215 if (ses_cache->status_page == NULL) { 2216 ses_terminate_control_requests(&ses->ses_requests, EIO); 2217 return (EIO); 2218 } 2219 2220 plength = ses_page_length(&ses_cache->status_page->hdr); 2221 memcpy(buf, ses_cache->status_page, plength); 2222 2223 /* Disable the select bits in all status entries. */ 2224 offset = sizeof(struct ses_control_page_hdr); 2225 for (offset = sizeof(struct ses_control_page_hdr); 2226 offset < plength; offset += sizeof(struct ses_comstat)) { 2227 buf[offset] &= ~SESCTL_CSEL; 2228 } 2229 2230 /* And make sure the INVOP bit is clear. */ 2231 hdr->control_flags &= ~SES_ENCSTAT_INVOP; 2232 2233 /* Apply incoming requests. */ 2234 while ((req = TAILQ_FIRST(&ses->ses_requests)) != NULL) { 2235 TAILQ_REMOVE(&ses->ses_requests, req, links); 2236 req->result = ses_encode(enc, buf, plength, req); 2237 if (req->result != 0) { 2238 wakeup(req); 2239 continue; 2240 } 2241 TAILQ_INSERT_TAIL(&ses->ses_pending_requests, req, links); 2242 } 2243 2244 if (TAILQ_EMPTY(&ses->ses_pending_requests) != 0) 2245 return (ENOENT); 2246 2247 /* Fill out the ccb */ 2248 if (enc->enc_type == ENC_SEMB_SES) { 2249 semb_send_diagnostic(&ccb->ataio, /*retries*/5, NULL, 2250 MSG_SIMPLE_Q_TAG, 2251 buf, ses_page_length(&ses_cache->status_page->hdr), 2252 state->timeout); 2253 } else { 2254 scsi_send_diagnostic(&ccb->csio, /*retries*/5, NULL, 2255 MSG_SIMPLE_Q_TAG, /*unit_offline*/0, 2256 /*device_offline*/0, /*self_test*/0, 2257 /*page_format*/1, /*self_test_code*/0, 2258 buf, ses_page_length(&ses_cache->status_page->hdr), 2259 SSD_FULL_SIZE, state->timeout); 2260 } 2261 return (0); 2262 } 2263 2264 static int 2265 ses_get_elm_addlstatus_fc(enc_softc_t *enc, enc_cache_t *enc_cache, 2266 uint8_t *buf, int bufsiz) 2267 { 2268 ENC_VLOG(enc, "FC Device Support Stubbed in Additional Status Page\n"); 2269 return (ENODEV); 2270 } 2271 2272 #define SES_PRINT_PORTS(p, type) do { \ 2273 if (((p) & SES_SASOBJ_DEV_PHY_PROTOMASK) != 0) { \ 2274 sbuf_printf(sbp, " %s (", type); \ 2275 if ((p) & SES_SASOBJ_DEV_PHY_SMP) \ 2276 sbuf_printf(sbp, " SMP"); \ 2277 if ((p) & SES_SASOBJ_DEV_PHY_STP) \ 2278 sbuf_printf(sbp, " STP"); \ 2279 if ((p) & SES_SASOBJ_DEV_PHY_SSP) \ 2280 sbuf_printf(sbp, " SSP"); \ 2281 sbuf_printf(sbp, " )"); \ 2282 } \ 2283 } while(0) 2284 2285 /** 2286 * \brief Print the additional element status data for this object, for SAS 2287 * type 0 objects. See SES2 r20 Section 6.1.13.3.2. 2288 * 2289 * \param sesname SES device name associated with the object. 2290 * \param sbp Sbuf to print to. 2291 * \param obj The object to print the data for. 2292 */ 2293 static void 2294 ses_print_addl_data_sas_type0(char *sesname, struct sbuf *sbp, 2295 enc_element_t *obj) 2296 { 2297 int i; 2298 ses_element_t *elmpriv; 2299 struct ses_addl_status *addl; 2300 struct ses_elm_sas_device_phy *phy; 2301 2302 elmpriv = obj->elm_private; 2303 addl = &(elmpriv->addl); 2304 sbuf_printf(sbp, ", SAS Slot: %d%s phys", 2305 addl->proto_hdr.sas->base_hdr.num_phys, 2306 ses_elm_sas_type0_not_all_phys(addl->proto_hdr.sas) ? "+" : ""); 2307 if (ses_elm_addlstatus_eip(addl->hdr)) 2308 sbuf_printf(sbp, " at slot %d", 2309 addl->proto_hdr.sas->type0_eip.dev_slot_num); 2310 sbuf_printf(sbp, "\n"); 2311 if (addl->proto_data.sasdev_phys == NULL) 2312 return; 2313 for (i = 0;i < addl->proto_hdr.sas->base_hdr.num_phys;i++) { 2314 phy = &addl->proto_data.sasdev_phys[i]; 2315 sbuf_printf(sbp, "%s: phy %d:", sesname, i); 2316 if (ses_elm_sas_dev_phy_sata_dev(phy)) 2317 /* Spec says all other fields are specific values */ 2318 sbuf_printf(sbp, " SATA device\n"); 2319 else { 2320 sbuf_printf(sbp, " SAS device type %d phy %d", 2321 ses_elm_sas_dev_phy_dev_type(phy), phy->phy_id); 2322 SES_PRINT_PORTS(phy->initiator_ports, "Initiator"); 2323 SES_PRINT_PORTS(phy->target_ports, "Target"); 2324 sbuf_printf(sbp, "\n"); 2325 } 2326 sbuf_printf(sbp, "%s: phy %d: parent %jx addr %jx\n", 2327 sesname, i, 2328 (uintmax_t)scsi_8btou64(phy->parent_addr), 2329 (uintmax_t)scsi_8btou64(phy->phy_addr)); 2330 } 2331 } 2332 #undef SES_PRINT_PORTS 2333 2334 /** 2335 * \brief Print the additional element status data for this object, for SAS 2336 * type 1 objects. See SES2 r20 Sections 6.1.13.3.3 and 6.1.13.3.4. 2337 * 2338 * \param sesname SES device name associated with the object. 2339 * \param sbp Sbuf to print to. 2340 * \param obj The object to print the data for. 2341 */ 2342 static void 2343 ses_print_addl_data_sas_type1(char *sesname, struct sbuf *sbp, 2344 enc_element_t *obj) 2345 { 2346 int i, num_phys; 2347 ses_element_t *elmpriv; 2348 struct ses_addl_status *addl; 2349 struct ses_elm_sas_expander_phy *exp_phy; 2350 struct ses_elm_sas_port_phy *port_phy; 2351 2352 elmpriv = obj->elm_private; 2353 addl = &(elmpriv->addl); 2354 sbuf_printf(sbp, ", SAS "); 2355 if (obj->elm_type == ELMTYP_SAS_EXP) { 2356 num_phys = addl->proto_hdr.sas->base_hdr.num_phys; 2357 sbuf_printf(sbp, "Expander: %d phys", num_phys); 2358 if (addl->proto_data.sasexp_phys == NULL) 2359 return; 2360 for (i = 0;i < num_phys;i++) { 2361 exp_phy = &addl->proto_data.sasexp_phys[i]; 2362 sbuf_printf(sbp, "%s: phy %d: connector %d other %d\n", 2363 sesname, i, exp_phy->connector_index, 2364 exp_phy->other_index); 2365 } 2366 } else { 2367 num_phys = addl->proto_hdr.sas->base_hdr.num_phys; 2368 sbuf_printf(sbp, "Port: %d phys", num_phys); 2369 if (addl->proto_data.sasport_phys == NULL) 2370 return; 2371 for (i = 0;i < num_phys;i++) { 2372 port_phy = &addl->proto_data.sasport_phys[i]; 2373 sbuf_printf(sbp, 2374 "%s: phy %d: id %d connector %d other %d\n", 2375 sesname, i, port_phy->phy_id, 2376 port_phy->connector_index, port_phy->other_index); 2377 sbuf_printf(sbp, "%s: phy %d: addr %jx\n", sesname, i, 2378 (uintmax_t)scsi_8btou64(port_phy->phy_addr)); 2379 } 2380 } 2381 } 2382 2383 /** 2384 * \brief Print the additional element status data for this object, for 2385 * ATA objects. 2386 * 2387 * \param sbp Sbuf to print to. 2388 * \param obj The object to print the data for. 2389 */ 2390 static void 2391 ses_print_addl_data_ata(struct sbuf *sbp, enc_element_t *obj) 2392 { 2393 ses_element_t *elmpriv = obj->elm_private; 2394 struct ses_addl_status *addl = &elmpriv->addl; 2395 struct ses_elm_ata_hdr *ata = addl->proto_hdr.ata; 2396 2397 sbuf_printf(sbp, ", SATA Slot: scbus%d target %d\n", 2398 scsi_4btoul(ata->bus), scsi_4btoul(ata->target)); 2399 } 2400 2401 /** 2402 * \brief Print the additional element status data for this object. 2403 * 2404 * \param enc SES softc associated with the object. 2405 * \param obj The object to print the data for. 2406 */ 2407 static void 2408 ses_print_addl_data(enc_softc_t *enc, enc_element_t *obj) 2409 { 2410 ses_element_t *elmpriv; 2411 struct ses_addl_status *addl; 2412 struct sbuf sesname, name, out; 2413 2414 elmpriv = obj->elm_private; 2415 if (elmpriv == NULL) 2416 return; 2417 2418 addl = &(elmpriv->addl); 2419 if (addl->hdr == NULL) 2420 return; 2421 2422 sbuf_new(&sesname, NULL, 16, SBUF_AUTOEXTEND); 2423 sbuf_new(&name, NULL, 16, SBUF_AUTOEXTEND); 2424 sbuf_new(&out, NULL, 512, SBUF_AUTOEXTEND); 2425 ses_paths_iter(enc, obj, ses_elmdevname_callback, &name); 2426 if (sbuf_len(&name) == 0) 2427 sbuf_printf(&name, "(none)"); 2428 sbuf_finish(&name); 2429 sbuf_printf(&sesname, "%s%d", enc->periph->periph_name, 2430 enc->periph->unit_number); 2431 sbuf_finish(&sesname); 2432 sbuf_printf(&out, "%s: %s in ", sbuf_data(&sesname), sbuf_data(&name)); 2433 if (elmpriv->descr != NULL) 2434 sbuf_printf(&out, "'%s'", elmpriv->descr); 2435 else { 2436 if (obj->elm_type <= ELMTYP_LAST) 2437 sbuf_cat(&out, elm_type_names[obj->elm_type]); 2438 else 2439 sbuf_printf(&out, "<Type 0x%02x>", obj->elm_type); 2440 sbuf_printf(&out, " %d", obj->type_elm_idx); 2441 if (obj->subenclosure != 0) 2442 sbuf_printf(&out, " of subenc %d", obj->subenclosure); 2443 } 2444 switch(ses_elm_addlstatus_proto(addl->hdr)) { 2445 case SPSP_PROTO_FC: 2446 goto noaddl; /* stubbed for now */ 2447 case SPSP_PROTO_SAS: 2448 if (addl->proto_hdr.sas == NULL) 2449 goto noaddl; 2450 switch(ses_elm_sas_descr_type(addl->proto_hdr.sas)) { 2451 case SES_SASOBJ_TYPE_SLOT: 2452 ses_print_addl_data_sas_type0(sbuf_data(&sesname), 2453 &out, obj); 2454 break; 2455 case SES_SASOBJ_TYPE_OTHER: 2456 ses_print_addl_data_sas_type1(sbuf_data(&sesname), 2457 &out, obj); 2458 break; 2459 default: 2460 goto noaddl; 2461 } 2462 break; 2463 case SPSP_PROTO_ATA: 2464 if (addl->proto_hdr.ata == NULL) 2465 goto noaddl; 2466 ses_print_addl_data_ata(&out, obj); 2467 break; 2468 default: 2469 noaddl: 2470 sbuf_cat(&out, "\n"); 2471 break; 2472 } 2473 sbuf_finish(&out); 2474 printf("%s", sbuf_data(&out)); 2475 sbuf_delete(&out); 2476 sbuf_delete(&name); 2477 sbuf_delete(&sesname); 2478 } 2479 2480 /** 2481 * \brief Update the softc with the additional element status data for this 2482 * object, for SAS type 0 objects. 2483 * 2484 * \param enc SES softc to be updated. 2485 * \param buf The additional element status response buffer. 2486 * \param bufsiz Size of the response buffer. 2487 * \param eip The EIP bit value. 2488 * \param nobj Number of objects attached to the SES softc. 2489 * 2490 * \return 0 on success, errno otherwise. 2491 */ 2492 static int 2493 ses_get_elm_addlstatus_sas_type0(enc_softc_t *enc, enc_cache_t *enc_cache, 2494 uint8_t *buf, int bufsiz, int eip, int nobj) 2495 { 2496 int err, offset, physz; 2497 enc_element_t *obj; 2498 ses_element_t *elmpriv; 2499 struct ses_addl_status *addl; 2500 2501 err = offset = 0; 2502 2503 /* basic object setup */ 2504 obj = &(enc_cache->elm_map[nobj]); 2505 elmpriv = obj->elm_private; 2506 addl = &(elmpriv->addl); 2507 2508 addl->proto_hdr.sas = (union ses_elm_sas_hdr *)&buf[offset]; 2509 2510 /* Don't assume this object has any phys */ 2511 bzero(&addl->proto_data, sizeof(addl->proto_data)); 2512 if (addl->proto_hdr.sas->base_hdr.num_phys == 0) 2513 goto out; 2514 2515 /* Skip forward to the phy list */ 2516 if (eip) 2517 offset += sizeof(struct ses_elm_sas_type0_eip_hdr); 2518 else 2519 offset += sizeof(struct ses_elm_sas_type0_base_hdr); 2520 2521 /* Make sure the phy list fits in the buffer */ 2522 physz = addl->proto_hdr.sas->base_hdr.num_phys; 2523 physz *= sizeof(struct ses_elm_sas_device_phy); 2524 if (physz > (bufsiz - offset + 4)) { 2525 ENC_VLOG(enc, "Element %d Device Phy List Beyond End Of Buffer\n", 2526 nobj); 2527 err = EIO; 2528 goto out; 2529 } 2530 2531 /* Point to the phy list */ 2532 addl->proto_data.sasdev_phys = 2533 (struct ses_elm_sas_device_phy *)&buf[offset]; 2534 2535 out: 2536 return (err); 2537 } 2538 2539 /** 2540 * \brief Update the softc with the additional element status data for this 2541 * object, for SAS type 1 objects. 2542 * 2543 * \param enc SES softc to be updated. 2544 * \param buf The additional element status response buffer. 2545 * \param bufsiz Size of the response buffer. 2546 * \param eip The EIP bit value. 2547 * \param nobj Number of objects attached to the SES softc. 2548 * 2549 * \return 0 on success, errno otherwise. 2550 */ 2551 static int 2552 ses_get_elm_addlstatus_sas_type1(enc_softc_t *enc, enc_cache_t *enc_cache, 2553 uint8_t *buf, int bufsiz, int eip, int nobj) 2554 { 2555 int err, offset, physz; 2556 enc_element_t *obj; 2557 ses_element_t *elmpriv; 2558 struct ses_addl_status *addl; 2559 2560 err = offset = 0; 2561 2562 /* basic object setup */ 2563 obj = &(enc_cache->elm_map[nobj]); 2564 elmpriv = obj->elm_private; 2565 addl = &(elmpriv->addl); 2566 2567 addl->proto_hdr.sas = (union ses_elm_sas_hdr *)&buf[offset]; 2568 2569 /* Don't assume this object has any phys */ 2570 bzero(&addl->proto_data, sizeof(addl->proto_data)); 2571 if (addl->proto_hdr.sas->base_hdr.num_phys == 0) 2572 goto out; 2573 2574 /* Process expanders differently from other type1 cases */ 2575 if (obj->elm_type == ELMTYP_SAS_EXP) { 2576 offset += sizeof(struct ses_elm_sas_type1_expander_hdr); 2577 physz = addl->proto_hdr.sas->base_hdr.num_phys * 2578 sizeof(struct ses_elm_sas_expander_phy); 2579 if (physz > (bufsiz - offset)) { 2580 ENC_VLOG(enc, "Element %d: Expander Phy List Beyond " 2581 "End Of Buffer\n", nobj); 2582 err = EIO; 2583 goto out; 2584 } 2585 addl->proto_data.sasexp_phys = 2586 (struct ses_elm_sas_expander_phy *)&buf[offset]; 2587 } else { 2588 offset += sizeof(struct ses_elm_sas_type1_nonexpander_hdr); 2589 physz = addl->proto_hdr.sas->base_hdr.num_phys * 2590 sizeof(struct ses_elm_sas_port_phy); 2591 if (physz > (bufsiz - offset + 4)) { 2592 ENC_VLOG(enc, "Element %d: Port Phy List Beyond End " 2593 "Of Buffer\n", nobj); 2594 err = EIO; 2595 goto out; 2596 } 2597 addl->proto_data.sasport_phys = 2598 (struct ses_elm_sas_port_phy *)&buf[offset]; 2599 } 2600 2601 out: 2602 return (err); 2603 } 2604 2605 /** 2606 * \brief Update the softc with the additional element status data for this 2607 * object, for SAS objects. 2608 * 2609 * \param enc SES softc to be updated. 2610 * \param buf The additional element status response buffer. 2611 * \param bufsiz Size of the response buffer. 2612 * \param eip The EIP bit value. 2613 * \param tidx Type index for this object. 2614 * \param nobj Number of objects attached to the SES softc. 2615 * 2616 * \return 0 on success, errno otherwise. 2617 */ 2618 static int 2619 ses_get_elm_addlstatus_sas(enc_softc_t *enc, enc_cache_t *enc_cache, 2620 uint8_t *buf, int bufsiz, int eip, int tidx, 2621 int nobj) 2622 { 2623 int dtype, err; 2624 ses_cache_t *ses_cache; 2625 union ses_elm_sas_hdr *hdr; 2626 2627 /* Need to be able to read the descriptor type! */ 2628 if (bufsiz < sizeof(union ses_elm_sas_hdr)) { 2629 err = EIO; 2630 goto out; 2631 } 2632 2633 ses_cache = enc_cache->private; 2634 2635 hdr = (union ses_elm_sas_hdr *)buf; 2636 dtype = ses_elm_sas_descr_type(hdr); 2637 switch(dtype) { 2638 case SES_SASOBJ_TYPE_SLOT: 2639 switch(ses_cache->ses_types[tidx].hdr->etype_elm_type) { 2640 case ELMTYP_DEVICE: 2641 case ELMTYP_ARRAY_DEV: 2642 break; 2643 default: 2644 ENC_VLOG(enc, "Element %d has Additional Status type 0, " 2645 "invalid for SES element type 0x%x\n", nobj, 2646 ses_cache->ses_types[tidx].hdr->etype_elm_type); 2647 err = ENODEV; 2648 goto out; 2649 } 2650 err = ses_get_elm_addlstatus_sas_type0(enc, enc_cache, 2651 buf, bufsiz, eip, 2652 nobj); 2653 break; 2654 case SES_SASOBJ_TYPE_OTHER: 2655 switch(ses_cache->ses_types[tidx].hdr->etype_elm_type) { 2656 case ELMTYP_SAS_EXP: 2657 case ELMTYP_SCSI_INI: 2658 case ELMTYP_SCSI_TGT: 2659 case ELMTYP_ESCC: 2660 break; 2661 default: 2662 ENC_VLOG(enc, "Element %d has Additional Status type 1, " 2663 "invalid for SES element type 0x%x\n", nobj, 2664 ses_cache->ses_types[tidx].hdr->etype_elm_type); 2665 err = ENODEV; 2666 goto out; 2667 } 2668 err = ses_get_elm_addlstatus_sas_type1(enc, enc_cache, buf, 2669 bufsiz, eip, nobj); 2670 break; 2671 default: 2672 ENC_VLOG(enc, "Element %d of type 0x%x has Additional Status " 2673 "of unknown type 0x%x\n", nobj, 2674 ses_cache->ses_types[tidx].hdr->etype_elm_type, dtype); 2675 err = ENODEV; 2676 break; 2677 } 2678 2679 out: 2680 return (err); 2681 } 2682 2683 /** 2684 * \brief Update the softc with the additional element status data for this 2685 * object, for ATA objects. 2686 * 2687 * \param enc SES softc to be updated. 2688 * \param buf The additional element status response buffer. 2689 * \param bufsiz Size of the response buffer. 2690 * \param eip The EIP bit value. 2691 * \param tidx Type index for this object. 2692 * \param nobj Number of objects attached to the SES softc. 2693 * 2694 * \return 0 on success, errno otherwise. 2695 */ 2696 static int 2697 ses_get_elm_addlstatus_ata(enc_softc_t *enc, enc_cache_t *enc_cache, 2698 uint8_t *buf, int bufsiz, int eip, int tidx, 2699 int nobj) 2700 { 2701 int err; 2702 ses_cache_t *ses_cache; 2703 2704 if (bufsiz < sizeof(struct ses_elm_ata_hdr)) { 2705 err = EIO; 2706 goto out; 2707 } 2708 2709 ses_cache = enc_cache->private; 2710 switch(ses_cache->ses_types[tidx].hdr->etype_elm_type) { 2711 case ELMTYP_DEVICE: 2712 case ELMTYP_ARRAY_DEV: 2713 break; 2714 default: 2715 ENC_VLOG(enc, "Element %d has Additional Status, " 2716 "invalid for SES element type 0x%x\n", nobj, 2717 ses_cache->ses_types[tidx].hdr->etype_elm_type); 2718 err = ENODEV; 2719 goto out; 2720 } 2721 2722 ((ses_element_t *)enc_cache->elm_map[nobj].elm_private) 2723 ->addl.proto_hdr.ata = (struct ses_elm_ata_hdr *)buf; 2724 err = 0; 2725 2726 out: 2727 return (err); 2728 } 2729 2730 static void 2731 ses_softc_invalidate(enc_softc_t *enc) 2732 { 2733 ses_softc_t *ses; 2734 2735 ses = enc->enc_private; 2736 ses_terminate_control_requests(&ses->ses_requests, ENXIO); 2737 } 2738 2739 static void 2740 ses_softc_cleanup(enc_softc_t *enc) 2741 { 2742 2743 ses_cache_free(enc, &enc->enc_cache); 2744 ses_cache_free(enc, &enc->enc_daemon_cache); 2745 ENC_FREE_AND_NULL(enc->enc_private); 2746 ENC_FREE_AND_NULL(enc->enc_cache.private); 2747 ENC_FREE_AND_NULL(enc->enc_daemon_cache.private); 2748 } 2749 2750 static int 2751 ses_init_enc(enc_softc_t *enc) 2752 { 2753 return (0); 2754 } 2755 2756 static int 2757 ses_get_enc_status(enc_softc_t *enc, int slpflag) 2758 { 2759 /* Automatically updated, caller checks enc_cache->encstat itself */ 2760 return (0); 2761 } 2762 2763 static int 2764 ses_set_enc_status(enc_softc_t *enc, uint8_t encstat, int slpflag) 2765 { 2766 ses_control_request_t req; 2767 ses_softc_t *ses; 2768 2769 ses = enc->enc_private; 2770 req.elm_idx = SES_SETSTATUS_ENC_IDX; 2771 req.elm_stat.comstatus = encstat & 0xf; 2772 2773 TAILQ_INSERT_TAIL(&ses->ses_requests, &req, links); 2774 enc_update_request(enc, SES_PROCESS_CONTROL_REQS); 2775 cam_periph_sleep(enc->periph, &req, PUSER, "encstat", 0); 2776 2777 return (req.result); 2778 } 2779 2780 static int 2781 ses_get_elm_status(enc_softc_t *enc, encioc_elm_status_t *elms, int slpflag) 2782 { 2783 unsigned int i = elms->elm_idx; 2784 2785 memcpy(elms->cstat, &enc->enc_cache.elm_map[i].encstat, 4); 2786 return (0); 2787 } 2788 2789 static int 2790 ses_set_elm_status(enc_softc_t *enc, encioc_elm_status_t *elms, int slpflag) 2791 { 2792 ses_control_request_t req; 2793 ses_softc_t *ses; 2794 2795 /* If this is clear, we don't do diddly. */ 2796 if ((elms->cstat[0] & SESCTL_CSEL) == 0) 2797 return (0); 2798 2799 ses = enc->enc_private; 2800 req.elm_idx = elms->elm_idx; 2801 memcpy(&req.elm_stat, elms->cstat, sizeof(req.elm_stat)); 2802 2803 TAILQ_INSERT_TAIL(&ses->ses_requests, &req, links); 2804 enc_update_request(enc, SES_PROCESS_CONTROL_REQS); 2805 cam_periph_sleep(enc->periph, &req, PUSER, "encstat", 0); 2806 2807 return (req.result); 2808 } 2809 2810 static int 2811 ses_get_elm_desc(enc_softc_t *enc, encioc_elm_desc_t *elmd) 2812 { 2813 int i = (int)elmd->elm_idx; 2814 ses_element_t *elmpriv; 2815 2816 /* Assume caller has already checked obj_id validity */ 2817 elmpriv = enc->enc_cache.elm_map[i].elm_private; 2818 /* object might not have a descriptor */ 2819 if (elmpriv == NULL || elmpriv->descr == NULL) { 2820 elmd->elm_desc_len = 0; 2821 return (0); 2822 } 2823 if (elmd->elm_desc_len > elmpriv->descr_len) 2824 elmd->elm_desc_len = elmpriv->descr_len; 2825 copyout(elmpriv->descr, elmd->elm_desc_str, elmd->elm_desc_len); 2826 return (0); 2827 } 2828 2829 /** 2830 * \brief Respond to ENCIOC_GETELMDEVNAME, providing a device name for the 2831 * given object id if one is available. 2832 * 2833 * \param enc SES softc to examine. 2834 * \param objdn ioctl structure to read/write device name info. 2835 * 2836 * \return 0 on success, errno otherwise. 2837 */ 2838 static int 2839 ses_get_elm_devnames(enc_softc_t *enc, encioc_elm_devnames_t *elmdn) 2840 { 2841 struct sbuf sb; 2842 int len; 2843 2844 len = elmdn->elm_names_size; 2845 if (len < 0) 2846 return (EINVAL); 2847 2848 cam_periph_unlock(enc->periph); 2849 sbuf_new(&sb, NULL, len, SBUF_FIXEDLEN); 2850 ses_paths_iter(enc, &enc->enc_cache.elm_map[elmdn->elm_idx], 2851 ses_elmdevname_callback, &sb); 2852 sbuf_finish(&sb); 2853 elmdn->elm_names_len = sbuf_len(&sb); 2854 copyout(sbuf_data(&sb), elmdn->elm_devnames, elmdn->elm_names_len + 1); 2855 sbuf_delete(&sb); 2856 cam_periph_lock(enc->periph); 2857 return (elmdn->elm_names_len > 0 ? 0 : ENODEV); 2858 } 2859 2860 /** 2861 * \brief Send a string to the primary subenclosure using the String Out 2862 * SES diagnostic page. 2863 * 2864 * \param enc SES enclosure to run the command on. 2865 * \param sstr SES string structure to operate on 2866 * \param ioc Ioctl being performed 2867 * 2868 * \return 0 on success, errno otherwise. 2869 */ 2870 static int 2871 ses_handle_string(enc_softc_t *enc, encioc_string_t *sstr, int ioc) 2872 { 2873 ses_softc_t *ses; 2874 enc_cache_t *enc_cache; 2875 ses_cache_t *ses_cache; 2876 const struct ses_enc_desc *enc_desc; 2877 int amt, payload, ret; 2878 char cdb[6]; 2879 char str[32]; 2880 char vendor[9]; 2881 char product[17]; 2882 char rev[5]; 2883 uint8_t *buf; 2884 size_t size, rsize; 2885 2886 ses = enc->enc_private; 2887 enc_cache = &enc->enc_daemon_cache; 2888 ses_cache = enc_cache->private; 2889 2890 /* Implement SES2r20 6.1.6 */ 2891 if (sstr->bufsiz > 0xffff) 2892 return (EINVAL); /* buffer size too large */ 2893 2894 switch (ioc) { 2895 case ENCIOC_SETSTRING: 2896 payload = sstr->bufsiz + 4; /* header for SEND DIAGNOSTIC */ 2897 amt = 0 - payload; 2898 buf = ENC_MALLOC(payload); 2899 if (buf == NULL) 2900 return (ENOMEM); 2901 ses_page_cdb(cdb, payload, 0, CAM_DIR_OUT); 2902 /* Construct the page request */ 2903 buf[0] = SesStringOut; 2904 buf[1] = 0; 2905 buf[2] = sstr->bufsiz >> 8; 2906 buf[3] = sstr->bufsiz & 0xff; 2907 ret = copyin(sstr->buf, &buf[4], sstr->bufsiz); 2908 if (ret != 0) { 2909 ENC_FREE(buf); 2910 return (ret); 2911 } 2912 break; 2913 case ENCIOC_GETSTRING: 2914 payload = sstr->bufsiz; 2915 amt = payload; 2916 buf = ENC_MALLOC(payload); 2917 if (buf == NULL) 2918 return (ENOMEM); 2919 ses_page_cdb(cdb, payload, SesStringIn, CAM_DIR_IN); 2920 break; 2921 case ENCIOC_GETENCNAME: 2922 if (ses_cache->ses_nsubencs < 1) 2923 return (ENODEV); 2924 enc_desc = ses_cache->subencs[0]; 2925 cam_strvis(vendor, enc_desc->vendor_id, 2926 sizeof(enc_desc->vendor_id), sizeof(vendor)); 2927 cam_strvis(product, enc_desc->product_id, 2928 sizeof(enc_desc->product_id), sizeof(product)); 2929 cam_strvis(rev, enc_desc->product_rev, 2930 sizeof(enc_desc->product_rev), sizeof(rev)); 2931 rsize = snprintf(str, sizeof(str), "%s %s %s", 2932 vendor, product, rev) + 1; 2933 if (rsize > sizeof(str)) 2934 rsize = sizeof(str); 2935 size = rsize; 2936 if (size > sstr->bufsiz) 2937 size = sstr->bufsiz; 2938 copyout(str, sstr->buf, size); 2939 sstr->bufsiz = rsize; 2940 return (size == rsize ? 0 : ENOMEM); 2941 case ENCIOC_GETENCID: 2942 if (ses_cache->ses_nsubencs < 1) 2943 return (ENODEV); 2944 enc_desc = ses_cache->subencs[0]; 2945 rsize = snprintf(str, sizeof(str), "%16jx", 2946 scsi_8btou64(enc_desc->logical_id)) + 1; 2947 if (rsize > sizeof(str)) 2948 rsize = sizeof(str); 2949 size = rsize; 2950 if (size > sstr->bufsiz) 2951 size = sstr->bufsiz; 2952 copyout(str, sstr->buf, size); 2953 sstr->bufsiz = rsize; 2954 return (size == rsize ? 0 : ENOMEM); 2955 default: 2956 return (EINVAL); 2957 } 2958 ret = enc_runcmd(enc, cdb, 6, buf, &amt); 2959 if (ret == 0 && ioc == ENCIOC_GETSTRING) 2960 ret = copyout(buf, sstr->buf, sstr->bufsiz); 2961 if (ioc == ENCIOC_SETSTRING || ioc == ENCIOC_GETSTRING) 2962 ENC_FREE(buf); 2963 return (ret); 2964 } 2965 2966 /** 2967 * \invariant Called with cam_periph mutex held. 2968 */ 2969 static void 2970 ses_poll_status(enc_softc_t *enc) 2971 { 2972 ses_softc_t *ses; 2973 2974 ses = enc->enc_private; 2975 enc_update_request(enc, SES_UPDATE_GETSTATUS); 2976 if (ses->ses_flags & SES_FLAG_DESC) 2977 enc_update_request(enc, SES_UPDATE_GETELMDESCS); 2978 if (ses->ses_flags & SES_FLAG_ADDLSTATUS) 2979 enc_update_request(enc, SES_UPDATE_GETELMADDLSTATUS); 2980 } 2981 2982 /** 2983 * \brief Notification received when CAM detects a new device in the 2984 * SCSI domain in which this SEP resides. 2985 * 2986 * \param enc SES enclosure instance. 2987 */ 2988 static void 2989 ses_device_found(enc_softc_t *enc) 2990 { 2991 ses_poll_status(enc); 2992 enc_update_request(enc, SES_PUBLISH_PHYSPATHS); 2993 } 2994 2995 static struct enc_vec ses_enc_vec = 2996 { 2997 .softc_invalidate = ses_softc_invalidate, 2998 .softc_cleanup = ses_softc_cleanup, 2999 .init_enc = ses_init_enc, 3000 .get_enc_status = ses_get_enc_status, 3001 .set_enc_status = ses_set_enc_status, 3002 .get_elm_status = ses_get_elm_status, 3003 .set_elm_status = ses_set_elm_status, 3004 .get_elm_desc = ses_get_elm_desc, 3005 .get_elm_devnames = ses_get_elm_devnames, 3006 .handle_string = ses_handle_string, 3007 .device_found = ses_device_found, 3008 .poll_status = ses_poll_status 3009 }; 3010 3011 /** 3012 * \brief Initialize a new SES instance. 3013 * 3014 * \param enc SES softc structure to set up the instance in. 3015 * \param doinit Do the initialization (see main driver). 3016 * 3017 * \return 0 on success, errno otherwise. 3018 */ 3019 int 3020 ses_softc_init(enc_softc_t *enc) 3021 { 3022 ses_softc_t *ses_softc; 3023 3024 CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE, 3025 ("entering enc_softc_init(%p)\n", enc)); 3026 3027 enc->enc_vec = ses_enc_vec; 3028 enc->enc_fsm_states = enc_fsm_states; 3029 3030 if (enc->enc_private == NULL) 3031 enc->enc_private = ENC_MALLOCZ(sizeof(ses_softc_t)); 3032 if (enc->enc_cache.private == NULL) 3033 enc->enc_cache.private = ENC_MALLOCZ(sizeof(ses_cache_t)); 3034 if (enc->enc_daemon_cache.private == NULL) 3035 enc->enc_daemon_cache.private = 3036 ENC_MALLOCZ(sizeof(ses_cache_t)); 3037 3038 if (enc->enc_private == NULL 3039 || enc->enc_cache.private == NULL 3040 || enc->enc_daemon_cache.private == NULL) { 3041 ENC_FREE_AND_NULL(enc->enc_private); 3042 ENC_FREE_AND_NULL(enc->enc_cache.private); 3043 ENC_FREE_AND_NULL(enc->enc_daemon_cache.private); 3044 return (ENOMEM); 3045 } 3046 3047 ses_softc = enc->enc_private; 3048 TAILQ_INIT(&ses_softc->ses_requests); 3049 TAILQ_INIT(&ses_softc->ses_pending_requests); 3050 3051 enc_update_request(enc, SES_UPDATE_PAGES); 3052 3053 // XXX: Move this to the FSM so it doesn't hang init 3054 if (0) (void) ses_set_timed_completion(enc, 1); 3055 3056 return (0); 3057 } 3058