1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <alloca.h> 29 #include <sys/byteorder.h> 30 #include "fru_access_impl.h" 31 #include "fruraw.h" 32 33 #pragma init(initialize_raw_access) 34 35 static hash_obj_t *hash_table[TABLE_SIZE]; 36 extern raw_list_t *g_raw; 37 38 static void 39 initialize_raw_access(void) 40 { 41 int count; 42 43 for (count = 0; count < TABLE_SIZE; count++) { 44 hash_table[count] = NULL; 45 } 46 } 47 48 49 static hash_obj_t * 50 lookup_handle_object(handle_t handle, int object_type) 51 { 52 handle_t index_to_hash; 53 hash_obj_t *first_hash_obj; 54 hash_obj_t *next_hash_obj; 55 56 index_to_hash = (handle % TABLE_SIZE); 57 58 first_hash_obj = hash_table[index_to_hash]; 59 for (next_hash_obj = first_hash_obj; next_hash_obj != NULL; 60 next_hash_obj = next_hash_obj->next) { 61 if ((handle == next_hash_obj->obj_hdl) && 62 (object_type == next_hash_obj->object_type)) { 63 return (next_hash_obj); 64 } 65 } 66 return (NULL); 67 } 68 69 70 static void 71 add_hashobject_to_hashtable(hash_obj_t *hash_obj) 72 { 73 handle_t index_to_hash; 74 static uint64_t handle_count = 0; 75 76 hash_obj->obj_hdl = ++handle_count; /* store the handle */ 77 78 /* where to add ? */ 79 index_to_hash = ((hash_obj->obj_hdl) % TABLE_SIZE); 80 81 hash_obj->next = hash_table[index_to_hash]; 82 hash_table[index_to_hash] = hash_obj; /* hash obj. added */ 83 84 if (hash_obj->next != NULL) { 85 hash_obj->next->prev = hash_obj; 86 } 87 } 88 89 90 static hash_obj_t * 91 create_container_hash_object(void) 92 { 93 hash_obj_t *hash_obj; 94 container_obj_t *cont_obj; 95 96 cont_obj = malloc(sizeof (container_obj_t)); 97 if (cont_obj == NULL) { 98 return (NULL); 99 } 100 101 hash_obj = malloc(sizeof (hash_obj_t)); 102 if (hash_obj == NULL) { 103 free(cont_obj); 104 return (NULL); 105 } 106 107 cont_obj->sec_obj_list = NULL; 108 109 hash_obj->object_type = CONTAINER_TYPE; 110 hash_obj->u.cont_obj = cont_obj; 111 hash_obj->next = NULL; 112 hash_obj->prev = NULL; 113 114 return (hash_obj); 115 } 116 117 118 static hash_obj_t * 119 create_section_hash_object(void) 120 { 121 hash_obj_t *hash_obj; 122 section_obj_t *sec_obj; 123 124 sec_obj = malloc(sizeof (section_obj_t)); 125 if (sec_obj == NULL) { 126 return (NULL); 127 } 128 129 hash_obj = malloc(sizeof (hash_obj_t)); 130 if (hash_obj == NULL) { 131 free(sec_obj); 132 return (NULL); 133 } 134 135 sec_obj->next = NULL; 136 sec_obj->seg_obj_list = NULL; 137 138 hash_obj->u.sec_obj = sec_obj; 139 hash_obj->object_type = SECTION_TYPE; 140 hash_obj->next = NULL; 141 hash_obj->prev = NULL; 142 143 return (hash_obj); 144 } 145 146 147 static hash_obj_t * 148 create_segment_hash_object(void) 149 { 150 hash_obj_t *hash_obj; 151 segment_obj_t *seg_obj; 152 153 seg_obj = malloc(sizeof (segment_obj_t)); 154 if (seg_obj == NULL) { 155 return (NULL); 156 } 157 158 hash_obj = malloc(sizeof (hash_obj_t)); 159 if (hash_obj == NULL) { 160 free(seg_obj); 161 return (NULL); 162 } 163 164 seg_obj->next = NULL; 165 seg_obj->pkt_obj_list = NULL; 166 167 hash_obj->object_type = SEGMENT_TYPE; 168 hash_obj->u.seg_obj = seg_obj; 169 hash_obj->next = NULL; 170 hash_obj->prev = NULL; 171 172 return (hash_obj); 173 } 174 175 176 static hash_obj_t * 177 create_packet_hash_object(void) 178 { 179 hash_obj_t *hash_obj; 180 packet_obj_t *pkt_obj; 181 182 pkt_obj = malloc(sizeof (packet_obj_t)); 183 if (pkt_obj == NULL) { 184 return (NULL); 185 } 186 187 hash_obj = malloc(sizeof (hash_obj_t)); 188 if (hash_obj == NULL) { 189 free(pkt_obj); 190 return (NULL); 191 } 192 193 pkt_obj->next = NULL; 194 195 hash_obj->object_type = PACKET_TYPE; 196 hash_obj->u.pkt_obj = pkt_obj; 197 hash_obj->next = NULL; 198 hash_obj->prev = NULL; 199 200 return (hash_obj); 201 } 202 203 204 205 static hash_obj_t * 206 get_container_hash_object(int object_type, handle_t handle) 207 { 208 hash_obj_t *hash_obj; 209 210 switch (object_type) { 211 case CONTAINER_TYPE: 212 break; 213 case SECTION_TYPE: 214 hash_obj = lookup_handle_object(handle, CONTAINER_TYPE); 215 if (hash_obj == NULL) { 216 return (NULL); 217 } 218 break; 219 case SEGMENT_TYPE: 220 hash_obj = lookup_handle_object(handle, SECTION_TYPE); 221 if (hash_obj == NULL) { 222 return (NULL); 223 } 224 hash_obj = lookup_handle_object(hash_obj->u.sec_obj->cont_hdl, 225 CONTAINER_TYPE); 226 break; 227 case PACKET_TYPE: 228 break; 229 default: 230 return (NULL); 231 } 232 233 return (hash_obj); 234 } 235 236 237 static void 238 add_to_pkt_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj) 239 { 240 hash_obj_t *next_hash; 241 242 /* add the packet object in the end of list */ 243 child_obj->u.pkt_obj->segment_hdl = parent_obj->obj_hdl; 244 245 if (parent_obj->u.seg_obj->pkt_obj_list == NULL) { 246 parent_obj->u.seg_obj->pkt_obj_list = child_obj; 247 return; 248 } 249 250 for (next_hash = parent_obj->u.seg_obj->pkt_obj_list; 251 next_hash->u.pkt_obj->next != NULL; 252 next_hash = next_hash->u.pkt_obj->next) { 253 ; 254 } 255 256 next_hash->u.pkt_obj->next = child_obj; 257 } 258 259 260 static void 261 free_pkt_object_list(hash_obj_t *hash_obj) 262 { 263 hash_obj_t *next_obj; 264 hash_obj_t *free_obj; 265 266 next_obj = hash_obj->u.seg_obj->pkt_obj_list; 267 while (next_obj != NULL) { 268 free_obj = next_obj; 269 next_obj = next_obj->u.pkt_obj->next; 270 /* if prev is NULL it's the first object in the list */ 271 if (free_obj->prev == NULL) { 272 hash_table[(free_obj->obj_hdl % TABLE_SIZE)] = 273 free_obj->next; 274 if (free_obj->next != NULL) { 275 free_obj->next->prev = free_obj->prev; 276 } 277 } else { 278 free_obj->prev->next = free_obj->next; 279 if (free_obj->next != NULL) { 280 free_obj->next->prev = free_obj->prev; 281 } 282 } 283 284 free(free_obj->u.pkt_obj->payload); 285 free(free_obj->u.pkt_obj); 286 free(free_obj); 287 } 288 289 hash_obj->u.seg_obj->pkt_obj_list = NULL; 290 } 291 292 293 static void 294 free_segment_hash(handle_t handle, hash_obj_t *sec_hash) 295 { 296 hash_obj_t *seg_hash; 297 hash_obj_t *next_hash; 298 299 seg_hash = sec_hash->u.sec_obj->seg_obj_list; 300 if (seg_hash == NULL) { 301 return; 302 } 303 304 if (seg_hash->obj_hdl == handle) { 305 sec_hash->u.sec_obj->seg_obj_list = seg_hash->u.seg_obj->next; 306 } else { 307 while (seg_hash->obj_hdl != handle) { 308 next_hash = seg_hash; 309 seg_hash = seg_hash->u.seg_obj->next; 310 if (seg_hash == NULL) { 311 return; 312 } 313 } 314 next_hash->u.seg_obj->next = seg_hash->u.seg_obj->next; 315 } 316 317 if (seg_hash->prev == NULL) { 318 hash_table[(seg_hash->obj_hdl % TABLE_SIZE)] = seg_hash->next; 319 if (seg_hash->next != NULL) { 320 seg_hash->next->prev = NULL; 321 } 322 } else { 323 seg_hash->prev->next = seg_hash->next; 324 if (seg_hash->next != NULL) { 325 seg_hash->next->prev = seg_hash->prev; 326 } 327 } 328 329 free_pkt_object_list(seg_hash); 330 free(seg_hash->u.seg_obj); 331 free(seg_hash); 332 } 333 334 335 336 static void 337 add_to_sec_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj) 338 { 339 hash_obj_t *next_hash; 340 341 child_obj->u.sec_obj->cont_hdl = parent_obj->obj_hdl; 342 if (parent_obj->u.cont_obj->sec_obj_list == NULL) { 343 parent_obj->u.cont_obj->sec_obj_list = child_obj; 344 return; 345 } 346 347 for (next_hash = parent_obj->u.cont_obj->sec_obj_list; 348 next_hash->u.sec_obj->next != NULL; 349 next_hash = next_hash->u.sec_obj->next) { 350 ; 351 } 352 353 next_hash->u.sec_obj->next = child_obj; 354 } 355 356 357 static void 358 add_to_seg_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj) 359 { 360 hash_obj_t *next_hash; 361 362 child_obj->u.seg_obj->section_hdl = parent_obj->obj_hdl; 363 if (parent_obj->u.sec_obj->seg_obj_list == NULL) { 364 parent_obj->u.sec_obj->seg_obj_list = child_obj; 365 return; 366 } 367 368 for (next_hash = parent_obj->u.sec_obj->seg_obj_list; 369 next_hash->u.seg_obj->next != NULL; 370 next_hash = next_hash->u.seg_obj->next) { 371 ; 372 } 373 374 next_hash->u.seg_obj->next = child_obj; 375 } 376 377 378 static char * 379 tokenizer(char *buf, char *separator, char **nextBuf, char *matched) 380 { 381 int i = 0; 382 int j = 0; 383 384 for (i = 0; buf[i] != '\0'; i++) { 385 for (j = 0; j < strlen(separator); j++) { 386 if (buf[i] == separator[j]) { 387 buf[i] = '\0'; 388 *nextBuf = &(buf[i+1]); 389 *matched = separator[j]; 390 return (buf); 391 } 392 } 393 } 394 395 *nextBuf = buf; 396 *matched = '\0'; 397 return (NULL); 398 } 399 400 401 static void 402 copy_segment_layout(segment_t *seghdr, void *layout) 403 { 404 segment_layout_t *seg_layout; 405 406 seg_layout = (segment_layout_t *)layout; 407 (void) memcpy(seghdr->name, &seg_layout->name, SEG_NAME_LEN); 408 seghdr->descriptor = GET_SEGMENT_DESCRIPTOR; 409 seghdr->offset = BE_16(seg_layout->offset); 410 seghdr->length = BE_16(seg_layout->length); 411 } 412 413 414 static int 415 get_container_info(const char *def_file, const char *cont_desc_str, 416 container_info_t *cont_info) 417 { 418 char *item; 419 char *token; 420 char *field; 421 char matched; 422 char buf[1024]; 423 int foundIt = 0; 424 FILE *file = fopen(def_file, "r"); 425 426 if (file == NULL) 427 return (-1); 428 429 cont_info->num_sections = 0; 430 431 while (fgets(buf, sizeof (buf), file) != NULL) { 432 /* ignore all comments */ 433 token = tokenizer(buf, "#", &field, &matched); 434 /* find the names */ 435 token = tokenizer(buf, ":", &field, &matched); 436 if (token != NULL) { 437 token = tokenizer(token, "|", &item, &matched); 438 while (token != NULL) { 439 if (strcmp(token, cont_desc_str) == 0) { 440 foundIt = 1; 441 goto found; 442 } 443 token = tokenizer(item, "|", &item, &matched); 444 } 445 /* check the last remaining item */ 446 if ((item != NULL) && 447 (strcmp(item, cont_desc_str) == 0)) { 448 foundIt = 1; 449 goto found; 450 } 451 } 452 } 453 454 found : 455 if (foundIt == 1) { 456 token = tokenizer(field, ":", &field, &matched); 457 if (token == NULL) { 458 (void) fclose(file); 459 return (-1); 460 } 461 cont_info->header_ver = (headerrev_t)atoi(token); 462 463 token = tokenizer(field, ":\n", &field, &matched); 464 while (token != NULL) { 465 token = tokenizer(token, ",", &item, &matched); 466 if (token == NULL) { 467 (void) fclose(file); 468 return (-1); 469 } 470 if (atoi(token) == 1) { 471 cont_info->section_info[cont_info-> 472 num_sections].description.field.read_only 473 = 1; 474 } else if (atoi(token) == 0) { 475 cont_info->section_info[cont_info-> 476 num_sections].description.field.read_only 477 = 0; 478 } else { 479 (void) fclose(file); 480 return (-1); 481 } 482 483 token = tokenizer(item, ",", &item, &matched); 484 if (token == NULL) { 485 (void) fclose(file); 486 return (-1); 487 } 488 489 cont_info->section_info[cont_info-> 490 num_sections].address = atoi(token); 491 if (item == NULL) { 492 (void) fclose(file); 493 return (-1); 494 } 495 cont_info->section_info[cont_info->num_sections].size = 496 atoi(item); 497 (cont_info->num_sections)++; 498 499 token = tokenizer(field, ":\n ", &field, &matched); 500 } 501 } 502 (void) fclose(file); 503 504 return (0); 505 } 506 507 508 /* ARGSUSED */ 509 int 510 fru_get_segments(section_hdl_t section, segment_t *segment, int maxseg, 511 door_cred_t *cred) 512 { 513 int count; 514 hash_obj_t *sec_object; 515 hash_obj_t *seg_object; 516 section_obj_t *sec_obj; 517 518 sec_object = lookup_handle_object(section, SECTION_TYPE); 519 if (sec_object == NULL) { 520 return (-1); 521 } 522 523 sec_obj = sec_object->u.sec_obj; 524 if (sec_obj == NULL) { 525 return (-1); 526 } 527 528 if (sec_obj->num_of_segment > maxseg) { 529 return (-1); 530 } 531 532 seg_object = sec_object->u.sec_obj->seg_obj_list; 533 if (seg_object == NULL) { 534 return (-1); 535 } 536 537 for (count = 0; count < sec_obj->num_of_segment; count++) { 538 539 /* populate segment_t */ 540 segment->handle = seg_object->obj_hdl; 541 (void) memcpy(segment->name, 542 seg_object->u.seg_obj->segment.name, SEG_NAME_LEN); 543 segment->descriptor = seg_object->u.seg_obj->segment.descriptor; 544 545 segment->offset = seg_object->u.seg_obj->segment.offset; 546 segment->length = seg_object->u.seg_obj->segment.length; 547 seg_object = seg_object->u.seg_obj->next; 548 segment++; 549 } 550 return (0); 551 } 552 553 554 static int 555 raw_memcpy(void *buffer, raw_list_t *rawlist, int offset, int size) 556 { 557 if (offset + size > rawlist->size) { 558 size = rawlist->size - offset; 559 } 560 561 (void) memcpy(buffer, &rawlist->raw[offset], size); 562 563 return (size); 564 } 565 566 567 static int 568 verify_header_crc8(headerrev_t head_ver, unsigned char *bytes, int length) 569 { 570 int crc_offset = 0; 571 unsigned char orig_crc8 = 0; 572 unsigned char calc_crc8 = 0; 573 574 switch (head_ver) { 575 case SECTION_HDR_VER: 576 crc_offset = 4; 577 break; 578 default: 579 errno = EINVAL; 580 return (0); 581 } 582 583 orig_crc8 = bytes[crc_offset]; 584 bytes[crc_offset] = 0x00; /* clear for calc */ 585 calc_crc8 = compute_crc8(bytes, length); 586 bytes[crc_offset] = orig_crc8; /* restore */ 587 588 return (orig_crc8 == calc_crc8); 589 } 590 591 592 static int 593 get_section(raw_list_t *rawlist, hash_obj_t *sec_hash, section_t *section) 594 { 595 int retval; 596 int size; 597 int count; 598 uint16_t hdrver; 599 hash_obj_t *seg_hash; 600 unsigned char *buffer; 601 section_obj_t *sec_obj; 602 section_layout_t sec_hdr; 603 segment_layout_t *seg_hdr; 604 segment_layout_t *seg_buf; 605 606 sec_obj = sec_hash->u.sec_obj; 607 if (sec_obj == NULL) { 608 return (-1); 609 } 610 611 /* populate section_t */ 612 section->handle = sec_hash->obj_hdl; 613 section->offset = sec_obj->section.offset; 614 section->length = sec_obj->section.length; 615 section->protection = sec_obj->section.protection; 616 section->version = sec_obj->section.version; 617 618 /* read section header layout */ 619 retval = raw_memcpy(&sec_hdr, rawlist, sec_obj->section.offset, 620 sizeof (sec_hdr)); 621 622 if (retval != sizeof (sec_hdr)) { 623 return (-1); 624 } 625 626 627 hdrver = GET_SECTION_HDR_VERSION; 628 629 if ((sec_hdr.headertag != SECTION_HDR_TAG) && 630 (hdrver != section->version)) { 631 return (-1); 632 } 633 634 /* size = section layout + total sizeof segment header */ 635 size = sizeof (sec_hdr) + ((sec_hdr.segmentcount) 636 * sizeof (segment_layout_t)); 637 638 buffer = alloca(size); 639 if (buffer == NULL) { 640 return (-1); 641 } 642 643 /* segment header buffer */ 644 seg_buf = alloca(size - sizeof (sec_hdr)); 645 if (seg_buf == NULL) { 646 return (-1); 647 } 648 649 /* read segment header */ 650 retval = raw_memcpy(seg_buf, rawlist, 651 sec_obj->section.offset + sizeof (sec_hdr), 652 size - sizeof (sec_hdr)); 653 654 if (retval != (size - sizeof (sec_hdr))) { 655 return (-1); 656 } 657 658 /* copy section header layout */ 659 (void) memcpy(buffer, &sec_hdr, sizeof (sec_hdr)); 660 661 /* copy segment header layout */ 662 (void) memcpy(buffer + sizeof (sec_hdr), seg_buf, size - 663 sizeof (sec_hdr)); 664 665 /* verify crc8 */ 666 retval = verify_header_crc8(hdrver, buffer, size); 667 if (retval != TRUE) { 668 return (-1); 669 } 670 671 section->version = hdrver; 672 sec_obj->section.version = hdrver; 673 674 seg_hdr = (segment_layout_t *)seg_buf; 675 676 /* bug fix for frutool */ 677 if (sec_hash->u.sec_obj->seg_obj_list != NULL) { 678 return (0); 679 } else { 680 sec_obj->num_of_segment = 0; 681 } 682 for (count = 0; count < sec_hdr.segmentcount; count++, seg_hdr++) { 683 684 seg_hash = create_segment_hash_object(); 685 if (seg_hash == NULL) { 686 return (-1); 687 } 688 add_hashobject_to_hashtable(seg_hash); 689 copy_segment_layout(&seg_hash->u.seg_obj->segment, seg_hdr); 690 add_to_seg_object_list(sec_hash, seg_hash); 691 sec_obj->num_of_segment++; 692 } 693 return (0); 694 } 695 696 /* ARGSUSED */ 697 int 698 fru_get_sections(container_hdl_t container, section_t *section, int maxsec, 699 door_cred_t *cred) 700 { 701 int count; 702 int num_sec = 0; 703 hash_obj_t *cont_object; 704 hash_obj_t *sec_hash; 705 706 cont_object = lookup_handle_object(container, CONTAINER_TYPE); 707 if (cont_object == NULL) { 708 return (-1); 709 } 710 711 if (cont_object->u.cont_obj->num_of_section > maxsec) { 712 return (-1); 713 } 714 715 sec_hash = cont_object->u.cont_obj->sec_obj_list; 716 if (sec_hash == NULL) { 717 return (-1); 718 } 719 720 for (count = 0; count < cont_object->u.cont_obj->num_of_section; 721 count++) { 722 section->version = -1; 723 /* populate section_t */ 724 if (get_section(g_raw, sec_hash, section) == 0) { 725 section++; 726 num_sec++; 727 } 728 sec_hash = sec_hash->u.sec_obj->next; 729 } 730 return (num_sec); 731 } 732 733 734 static uint32_t 735 get_checksum_crc(hash_obj_t *seg_hash, int data_size) 736 { 737 int protection; 738 int offset = 0; 739 uint32_t crc; 740 hash_obj_t *sec_hash; 741 hash_obj_t *pkt_hash; 742 unsigned char *buffer; 743 744 sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl, 745 SECTION_TYPE); 746 if (sec_hash == NULL) { 747 return ((uint32_t)-1); 748 } 749 750 buffer = alloca(data_size); 751 if (buffer == NULL) { 752 return ((uint32_t)-1); 753 } 754 755 /* traverse the packet object list for all the tags and payload */ 756 for (pkt_hash = seg_hash->u.seg_obj->pkt_obj_list; pkt_hash != NULL; 757 pkt_hash = pkt_hash->u.pkt_obj->next) { 758 (void) memcpy(buffer + offset, &pkt_hash->u.pkt_obj->tag, 759 pkt_hash->u.pkt_obj->tag_size); 760 offset += pkt_hash->u.pkt_obj->tag_size; 761 (void) memcpy(buffer + offset, pkt_hash->u.pkt_obj->payload, 762 pkt_hash->u.pkt_obj->paylen); 763 offset += pkt_hash->u.pkt_obj->paylen; 764 } 765 766 protection = sec_hash->u.sec_obj->section.protection; 767 768 if (protection == READ_ONLY_SECTION) { /* read-only section */ 769 crc = compute_crc32(buffer, data_size); 770 } else { /* read/write section */ 771 crc = compute_checksum32(buffer, data_size); 772 } 773 return (crc); /* computed crc */ 774 } 775 776 777 static int 778 get_packet(raw_list_t *rawlist, void *buffer, int size, int offset) 779 { 780 int retval; 781 782 retval = raw_memcpy(buffer, rawlist, offset, size); 783 784 if (retval != -1) { 785 return (0); 786 } 787 return (-1); 788 } 789 790 791 static int 792 get_packets(hash_obj_t *seg_hash, raw_list_t *rawlist, int offset, int length) 793 { 794 int tag_size; 795 int paylen; 796 int retval; 797 int seg_limit = 0; 798 int pktcnt = 0; 799 char *data; 800 uint32_t crc; 801 uint32_t origcrc; 802 fru_tag_t tag; 803 hash_obj_t *pkt_hash_obj; 804 hash_obj_t *sec_hash; 805 fru_segdesc_t *segdesc; 806 fru_tagtype_t tagtype; 807 char *ignore_flag; 808 809 retval = get_packet(rawlist, &tag, sizeof (fru_tag_t), offset); 810 if (retval == -1) { 811 return (-1); 812 } 813 814 /* section hash object */ 815 sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl, 816 SECTION_TYPE); 817 818 if (sec_hash == NULL) { 819 return (-1); 820 } 821 822 seg_hash->u.seg_obj->trailer_offset = offset; 823 824 data = (char *)&tag; 825 while (data[0] != SEG_TRAILER_TAG) { 826 tagtype = get_tag_type(&tag); /* verify tag type */ 827 if (tagtype == -1) { 828 return (-1); 829 } 830 831 tag_size = get_tag_size(tagtype); 832 if (tag_size == -1) { 833 return (-1); 834 } 835 836 seg_limit += tag_size; 837 if (seg_limit > length) { 838 return (-1); 839 } 840 841 paylen = get_payload_length((void *)&tag); 842 if (paylen == -1) { 843 return (-1); 844 } 845 846 seg_limit += paylen; 847 if (seg_limit > length) { 848 return (-1); 849 } 850 if ((offset + tag_size + paylen) > 851 (sec_hash->u.sec_obj->section.offset + 852 sec_hash->u.sec_obj->section.length)) { 853 return (-1); 854 } 855 856 pkt_hash_obj = create_packet_hash_object(); 857 if (pkt_hash_obj == NULL) { 858 return (-1); 859 } 860 861 pkt_hash_obj->u.pkt_obj->payload = malloc(paylen); 862 if (pkt_hash_obj->u.pkt_obj->payload == NULL) { 863 free(pkt_hash_obj); 864 return (-1); 865 } 866 867 offset += tag_size; 868 869 retval = raw_memcpy(pkt_hash_obj->u.pkt_obj->payload, rawlist, 870 offset, paylen); 871 872 if (retval != paylen) { 873 free(pkt_hash_obj->u.pkt_obj->payload); 874 free(pkt_hash_obj); 875 return (-1); 876 } 877 878 /* don't change this */ 879 pkt_hash_obj->u.pkt_obj->tag.raw_data = 0; 880 (void) memcpy(&pkt_hash_obj->u.pkt_obj->tag, &tag, tag_size); 881 pkt_hash_obj->u.pkt_obj->paylen = paylen; 882 pkt_hash_obj->u.pkt_obj->tag_size = tag_size; 883 pkt_hash_obj->u.pkt_obj->payload_offset = offset; 884 885 offset += paylen; 886 887 add_hashobject_to_hashtable(pkt_hash_obj); 888 add_to_pkt_object_list(seg_hash, pkt_hash_obj); 889 890 pktcnt++; 891 892 retval = get_packet(rawlist, &tag, sizeof (fru_tag_t), 893 offset); 894 if (retval == -1) { 895 return (retval); 896 } 897 898 data = (char *)&tag; 899 } 900 901 segdesc = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor; 902 903 seg_hash->u.seg_obj->trailer_offset = offset; 904 905 if (!segdesc->field.ignore_checksum) { 906 crc = get_checksum_crc(seg_hash, seg_limit); 907 offset = seg_hash->u.seg_obj->segment.offset; 908 909 retval = raw_memcpy(&origcrc, rawlist, offset + seg_limit + 1, 910 sizeof (origcrc)); 911 912 ignore_flag = getenv(IGNORE_CHECK); 913 if (ignore_flag != NULL) { 914 return (pktcnt); 915 } 916 917 if (retval != sizeof (origcrc)) { 918 return (-1); 919 } 920 921 origcrc = BE_32(origcrc); 922 if (origcrc != crc) { 923 seg_hash->u.seg_obj->trailer_offset = offset; 924 return (-1); 925 } 926 } 927 928 return (pktcnt); 929 } 930 931 /* ARGSUSED */ 932 int 933 fru_get_num_sections(container_hdl_t container, door_cred_t *cred) 934 { 935 hash_obj_t *hash_object; 936 937 hash_object = lookup_handle_object(container, CONTAINER_TYPE); 938 if (hash_object == NULL) { 939 return (-1); 940 } 941 942 return (hash_object->u.cont_obj->num_of_section); 943 } 944 945 /* ARGSUSED */ 946 int 947 fru_get_num_segments(section_hdl_t section, door_cred_t *cred) 948 { 949 hash_obj_t *sec_object; 950 section_obj_t *sec_obj; 951 952 sec_object = lookup_handle_object(section, SECTION_TYPE); 953 if (sec_object == NULL) { 954 return (-1); 955 } 956 957 sec_obj = sec_object->u.sec_obj; 958 if (sec_obj == NULL) { 959 return (-1); 960 } 961 962 return (sec_obj->num_of_segment); 963 } 964 965 /* ARGSUSED */ 966 int 967 fru_get_num_packets(segment_hdl_t segment, door_cred_t *cred) 968 { 969 int pktcnt; 970 int length; 971 uint16_t offset; 972 hash_obj_t *cont_hash_obj; 973 hash_obj_t *seg_hash; 974 hash_obj_t *sec_hash; 975 fru_segdesc_t *segdesc; 976 segment_obj_t *segment_object; 977 978 seg_hash = lookup_handle_object(segment, SEGMENT_TYPE); 979 if (seg_hash == NULL) { 980 return (-1); 981 } 982 983 segment_object = seg_hash->u.seg_obj; 984 if (segment_object == NULL) { 985 return (-1); 986 } 987 988 segdesc = (fru_segdesc_t *)&segment_object->segment.descriptor; 989 if (segdesc->field.opaque) { 990 return (0); 991 } 992 993 offset = segment_object->segment.offset; 994 length = segment_object->segment.length; 995 996 cont_hash_obj = get_container_hash_object(SEGMENT_TYPE, 997 segment_object->section_hdl); 998 999 if (cont_hash_obj == NULL) { 1000 return (-1); 1001 } 1002 1003 if (seg_hash->u.seg_obj->pkt_obj_list != NULL) { 1004 return (segment_object->num_of_packets); 1005 } 1006 /* section hash object */ 1007 sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl, 1008 SECTION_TYPE); 1009 if (sec_hash == NULL) { 1010 return (-1); 1011 } 1012 1013 /* valid segment header b'cos crc8 already validated */ 1014 if (offset < sec_hash->u.sec_obj->section.offset) { 1015 return (-1); 1016 } 1017 1018 segment_object->num_of_packets = 0; 1019 1020 pktcnt = get_packets(seg_hash, g_raw, offset, length); 1021 if (pktcnt == -1) { 1022 free_pkt_object_list(seg_hash); 1023 seg_hash->u.seg_obj->pkt_obj_list = NULL; 1024 } 1025 1026 segment_object->num_of_packets = pktcnt; 1027 1028 return (segment_object->num_of_packets); 1029 } 1030 1031 /* ARGSUSED */ 1032 int 1033 fru_get_packets(segment_hdl_t segment, packet_t *packet, int maxpackets, 1034 door_cred_t *cred) 1035 { 1036 int count; 1037 hash_obj_t *seg_hash_obj; 1038 hash_obj_t *pkt_hash_obj; 1039 1040 /* segment hash object */ 1041 seg_hash_obj = lookup_handle_object(segment, SEGMENT_TYPE); 1042 if (seg_hash_obj == NULL) { 1043 return (-1); 1044 } 1045 1046 if (seg_hash_obj->u.seg_obj->num_of_packets != maxpackets) { 1047 return (-1); 1048 } 1049 1050 pkt_hash_obj = seg_hash_obj->u.seg_obj->pkt_obj_list; 1051 if (pkt_hash_obj == NULL) { 1052 return (-1); 1053 } 1054 1055 for (count = 0; count < maxpackets; count++, packet++) { 1056 packet->handle = pkt_hash_obj->obj_hdl; 1057 packet->tag = 0; 1058 (void) memcpy(&packet->tag, &pkt_hash_obj->u.pkt_obj->tag, 1059 pkt_hash_obj->u.pkt_obj->tag_size); 1060 pkt_hash_obj = pkt_hash_obj->u.pkt_obj->next; 1061 } 1062 1063 return (0); 1064 } 1065 1066 /* ARGSUSED */ 1067 ssize_t 1068 fru_get_payload(packet_hdl_t packet, void *buffer, size_t nbytes, 1069 door_cred_t *cred) 1070 { 1071 hash_obj_t *packet_hash_obj; 1072 1073 /* packet hash object */ 1074 packet_hash_obj = lookup_handle_object(packet, PACKET_TYPE); 1075 if (packet_hash_obj == NULL) { 1076 return (-1); 1077 } 1078 1079 /* verify payload length */ 1080 if (nbytes != packet_hash_obj->u.pkt_obj->paylen) { 1081 return (-1); 1082 } 1083 1084 (void) memcpy(buffer, packet_hash_obj->u.pkt_obj->payload, nbytes); 1085 return (nbytes); 1086 } 1087 1088 1089 container_hdl_t 1090 open_raw_data(raw_list_t *node) 1091 { 1092 char *cont_conf_file = NULL; 1093 hash_obj_t *cont_hash_obj; 1094 hash_obj_t *sec_hash_obj; 1095 container_info_t cont_info; 1096 int retval; 1097 int count; 1098 1099 cont_hash_obj = create_container_hash_object(); 1100 if (cont_hash_obj == NULL) { 1101 return (NULL); 1102 } 1103 1104 add_hashobject_to_hashtable(cont_hash_obj); 1105 1106 (void) strncpy(cont_hash_obj->u.cont_obj->device_pathname, "unknown", 1107 sizeof (cont_hash_obj->u.cont_obj->device_pathname)); 1108 1109 cont_conf_file = getenv(FRU_CONT_CONF_ENV_VAR); 1110 if (cont_conf_file == NULL) { 1111 cont_conf_file = FRU_CONT_CONF_SPARC; 1112 retval = get_container_info(cont_conf_file, node->cont_type, 1113 &cont_info); 1114 if (retval < 0) { 1115 cont_conf_file = FRU_CONT_CONF_X86; 1116 retval = get_container_info(cont_conf_file, 1117 node->cont_type, &cont_info); 1118 } 1119 } else { 1120 retval = get_container_info(cont_conf_file, node->cont_type, 1121 &cont_info); 1122 } 1123 1124 if (retval < 0) { 1125 return (NULL); 1126 } 1127 1128 cont_hash_obj->u.cont_obj->num_of_section = cont_info.num_sections; 1129 cont_hash_obj->u.cont_obj->sec_obj_list = NULL; 1130 1131 for (count = 0; count < cont_info.num_sections; count++) { 1132 sec_hash_obj = create_section_hash_object(); 1133 if (sec_hash_obj == NULL) { 1134 return (NULL); 1135 } 1136 1137 add_hashobject_to_hashtable(sec_hash_obj); 1138 1139 sec_hash_obj->u.sec_obj->section.offset = 1140 cont_info.section_info[count].address; 1141 1142 sec_hash_obj->u.sec_obj->section.protection = 1143 cont_info.section_info[count].description.field.read_only; 1144 1145 sec_hash_obj->u.sec_obj->section.length = 1146 cont_info.section_info[count].size; 1147 sec_hash_obj->u.sec_obj->section.version = 1148 cont_info.header_ver; 1149 1150 add_to_sec_object_list(cont_hash_obj, sec_hash_obj); 1151 } 1152 1153 return (cont_hash_obj->obj_hdl); 1154 } 1155 1156 1157 int 1158 fru_close_container(container_hdl_t container) 1159 { 1160 hash_obj_t *hash_obj; 1161 hash_obj_t *prev_hash; 1162 hash_obj_t *sec_hash_obj; 1163 handle_t obj_hdl; 1164 1165 /* lookup for container hash object */ 1166 hash_obj = lookup_handle_object(container, CONTAINER_TYPE); 1167 if (hash_obj == NULL) { 1168 return (0); 1169 } 1170 1171 /* points to section object list */ 1172 sec_hash_obj = hash_obj->u.cont_obj->sec_obj_list; 1173 1174 /* traverse section object list */ 1175 while (sec_hash_obj != NULL) { 1176 1177 /* traverse segment hash object in the section */ 1178 while (sec_hash_obj->u.sec_obj->seg_obj_list != NULL) { 1179 /* object handle of the segment hash object */ 1180 obj_hdl = 1181 sec_hash_obj->u.sec_obj->seg_obj_list->obj_hdl; 1182 free_segment_hash(obj_hdl, sec_hash_obj); 1183 } 1184 1185 /* going to free section hash object, relink the hash object */ 1186 if (sec_hash_obj->prev == NULL) { 1187 hash_table[(sec_hash_obj->obj_hdl % TABLE_SIZE)] = 1188 sec_hash_obj->next; 1189 if (sec_hash_obj->next != NULL) { 1190 sec_hash_obj->next->prev = NULL; 1191 } 1192 } else { 1193 sec_hash_obj->prev->next = sec_hash_obj->next; 1194 if (sec_hash_obj->next != NULL) { 1195 sec_hash_obj->next->prev = sec_hash_obj->prev; 1196 } 1197 } 1198 1199 prev_hash = sec_hash_obj; 1200 sec_hash_obj = sec_hash_obj->u.sec_obj->next; 1201 1202 free(prev_hash->u.sec_obj); /* free section hash object */ 1203 free(prev_hash); /* free section hash */ 1204 } 1205 1206 /* free container hash object */ 1207 if (hash_obj->prev == NULL) { 1208 hash_table[(hash_obj->obj_hdl % TABLE_SIZE)] = 1209 hash_obj->next; 1210 if (hash_obj->next != NULL) { 1211 hash_obj->next->prev = NULL; 1212 } 1213 } else { 1214 hash_obj->prev->next = hash_obj->next; 1215 if (hash_obj->next != NULL) { 1216 hash_obj->next->prev = hash_obj->prev; 1217 } 1218 } 1219 1220 free(hash_obj->u.cont_obj); 1221 free(hash_obj); 1222 1223 return (0); 1224 } 1225