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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <picl.h> 27 #include <syslog.h> 28 #include <strings.h> 29 #include <alloca.h> 30 #include <pthread.h> 31 #include <synch.h> 32 #include <limits.h> 33 #include <ctype.h> 34 #include <unistd.h> 35 #include <picltree.h> 36 #include <signal.h> 37 #include <sys/utsname.h> 38 #include <sys/systeminfo.h> 39 #include <libnvpair.h> 40 #include "fru_tag.h" 41 #include "fru_data_impl.h" 42 #include "fru_data.h" 43 #include "picld_pluginutil.h" 44 45 #pragma init(frudata_plugin_register) /* .init section */ 46 47 static void frudata_plugin_init(void); 48 static void frudata_plugin_fini(void); 49 static container_tbl_t *container_table[TABLE_SIZE]; 50 51 /* 52 * Locking Stragtegy : 53 * calling thread should hold the cont_tbl_lock during the course 54 * of container table lookup. release the cont_tbl_lock on lookup 55 * failure or on the condition wait. 56 * 57 * thread holding the container object rwlock should release lock 58 * and signal to unblock threads blocked on the condition variable 59 * upon i/o completion. 60 * 61 */ 62 63 static pthread_mutex_t cont_tbl_lock = PTHREAD_MUTEX_INITIALIZER; 64 65 static int add_row_to_table(hash_obj_t *, picl_nodehdl_t, 66 packet_t *, container_tbl_t *); 67 68 static picld_plugin_reg_t frudata_reg_info = { 69 PICLD_PLUGIN_VERSION_1, 70 PICLD_PLUGIN_NON_CRITICAL, 71 "SUNW_piclfrudata", 72 frudata_plugin_init, /* init entry point */ 73 frudata_plugin_fini /* cleanup entry point */ 74 }; 75 76 /* initialization function */ 77 static void 78 frudata_plugin_register(void) 79 { 80 /* register plugin with daemon */ 81 if (picld_plugin_register(&frudata_reg_info) != PICL_SUCCESS) { 82 syslog(LOG_ERR, "SUNW_piclfrudata plugin registration failed"); 83 } 84 } 85 86 static int 87 map_access_err(int err) 88 { 89 switch (err) { 90 case ENFILE : 91 return (PICL_PROPEXISTS); 92 case EAGAIN : 93 return (PICL_NOSPACE); 94 case EPERM : 95 return (PICL_PERMDENIED); 96 case EEXIST : 97 return (PICL_PROPEXISTS); 98 default : 99 return (PICL_FAILURE); 100 } 101 } 102 103 /* 104 * unlock_container_lock() should be always called by the thread holding the 105 * container object lock. it will signal block thread waiting on the condition 106 * variable. 107 */ 108 109 static void 110 unlock_container_lock(container_tbl_t *cont_hash) 111 { 112 (void) pthread_rwlock_unlock(&cont_hash->rwlock); 113 (void) pthread_mutex_lock(&cont_tbl_lock); 114 (void) pthread_cond_signal(&cont_hash->cond_var); 115 (void) pthread_mutex_unlock(&cont_tbl_lock); 116 } 117 118 119 /* volatile callback read routine */ 120 /* ARGSUSED */ 121 static int 122 frudata_read_callback(ptree_rarg_t *rarg, void *buf) 123 { 124 return (PICL_SUCCESS); 125 } 126 127 /* 128 * called to get hash object for specified node and object type from 129 * hash table. 130 */ 131 static container_tbl_t * 132 lookup_container_table(picl_nodehdl_t nodehdl, int object_type) 133 { 134 int index_to_hash; 135 int retval = PICL_SUCCESS; 136 container_tbl_t *first_hash; 137 container_tbl_t *next_hash; 138 picl_nodehdl_t parenthdl = 0; 139 140 switch (object_type) { 141 case SECTION_NODE: 142 retval = ptree_get_propval_by_name(nodehdl, PICL_PROP_PARENT, 143 &parenthdl, sizeof (picl_nodehdl_t)); 144 break; 145 case SEGMENT_NODE: 146 retval = ptree_get_propval_by_name(nodehdl, PICL_PROP_PARENT, 147 &parenthdl, sizeof (picl_nodehdl_t)); 148 retval = ptree_get_propval_by_name(parenthdl, PICL_PROP_PARENT, 149 &parenthdl, sizeof (picl_nodehdl_t)); 150 break; 151 case CONTAINER_NODE : 152 parenthdl = nodehdl; 153 break; 154 default : 155 return (NULL); 156 } 157 158 if (retval != PICL_SUCCESS) { 159 return (NULL); 160 } 161 162 index_to_hash = (parenthdl % TABLE_SIZE); 163 164 first_hash = container_table[index_to_hash]; 165 166 for (next_hash = first_hash; next_hash != NULL; 167 next_hash = next_hash->next) { 168 if (parenthdl == next_hash->picl_hdl) { 169 return (next_hash); 170 } 171 } 172 return (NULL); 173 } 174 175 static int 176 lock_readwrite_lock(container_tbl_t *cont_obj, int operation) 177 { 178 /* if write operation */ 179 if (operation == PICL_WRITE) { 180 return (pthread_rwlock_trywrlock(&cont_obj->rwlock)); 181 } 182 /* read operation */ 183 return (pthread_rwlock_tryrdlock(&cont_obj->rwlock)); 184 } 185 186 /* 187 * lock the container table, do lookup for the container object 188 * in the container table. if container object found try to lock 189 * the container object, if lock on container object is busy wait 190 * on condition variable till the thread holding the container 191 * object lock signal it. 192 */ 193 194 static container_tbl_t * 195 lock_container_lock(picl_nodehdl_t nodehdl, int object_type, int operation) 196 { 197 container_tbl_t *cont_obj = NULL; 198 199 (void) pthread_mutex_lock(&cont_tbl_lock); 200 201 while (((cont_obj = lookup_container_table(nodehdl, object_type)) != 202 NULL) && (lock_readwrite_lock(cont_obj, operation) == EBUSY)) { 203 pthread_cond_wait(&cont_obj->cond_var, &cont_tbl_lock); 204 } 205 206 (void) pthread_mutex_unlock(&cont_tbl_lock); 207 208 return (cont_obj); 209 } 210 211 static hash_obj_t * 212 lookup_node_object(picl_nodehdl_t nodehdl, int object_type, 213 container_tbl_t *cont_tbl) 214 { 215 int index_to_hash; 216 hash_obj_t *first_hash; 217 hash_obj_t *next_hash; 218 219 220 index_to_hash = (nodehdl % TABLE_SIZE); 221 222 first_hash = &cont_tbl->hash_obj[index_to_hash]; 223 224 for (next_hash = first_hash->next; next_hash != NULL; 225 next_hash = next_hash->next) { 226 if ((nodehdl == next_hash->picl_hdl) && 227 (object_type == next_hash->object_type)) { 228 return (next_hash); 229 } 230 } 231 return (NULL); 232 } 233 234 /* 235 * called to add newly created container hash table into container hash table. 236 * 237 */ 238 static void 239 add_tblobject_to_container_tbl(container_tbl_t *cont_tbl) 240 { 241 int cnt; 242 int index_to_hash; 243 hash_obj_t *hash_ptr; 244 245 index_to_hash = ((cont_tbl->picl_hdl) % TABLE_SIZE); 246 247 cont_tbl->next = container_table[index_to_hash]; 248 container_table[index_to_hash] = cont_tbl; 249 hash_ptr = cont_tbl->hash_obj; 250 251 /* initialize the bucket of this container hash table. */ 252 253 for (cnt = 0; cnt < TABLE_SIZE; cnt++) { 254 hash_ptr->next = NULL; 255 hash_ptr->prev = NULL; 256 hash_ptr++; 257 } 258 if (cont_tbl->next != NULL) { 259 cont_tbl->next->prev = cont_tbl; 260 } 261 } 262 263 static void 264 add_nodeobject_to_hashtable(hash_obj_t *hash_obj, container_tbl_t *cont_tbl) 265 { 266 int index_to_hash; 267 hash_obj_t *hash_table; 268 269 index_to_hash = ((hash_obj->picl_hdl) % TABLE_SIZE); 270 hash_table = &cont_tbl->hash_obj[index_to_hash]; 271 272 hash_obj->next = hash_table->next; 273 hash_table->next = hash_obj; 274 275 if (hash_obj->next != NULL) { 276 hash_obj->next->prev = hash_obj; 277 } 278 } 279 280 static container_tbl_t * 281 alloc_container_table(picl_nodehdl_t nodehdl) 282 { 283 container_tbl_t *cont_tbl; 284 285 cont_tbl = malloc(sizeof (container_tbl_t)); 286 if (cont_tbl == NULL) { 287 return (NULL); 288 } 289 290 cont_tbl->picl_hdl = nodehdl; 291 292 cont_tbl->hash_obj = malloc(sizeof (hash_obj_t[TABLE_SIZE])); 293 cont_tbl->next = NULL; 294 cont_tbl->prev = NULL; 295 296 if (cont_tbl->hash_obj == NULL) { 297 (void) free(cont_tbl); 298 return (NULL); 299 } 300 301 (void) pthread_rwlock_init(&cont_tbl->rwlock, NULL); 302 (void) pthread_cond_init(&cont_tbl->cond_var, NULL); 303 304 return (cont_tbl); 305 } 306 307 /* 308 * called to allocate container node object for container property and a 309 * container table. 310 */ 311 312 static hash_obj_t * 313 alloc_container_node_object(picl_nodehdl_t nodehdl) 314 { 315 hash_obj_t *hash_obj; 316 fru_access_hdl_t acc_hdl; 317 container_node_t *cont_node; 318 319 /* open the container (call fruaccess) */ 320 acc_hdl = fru_open_container(nodehdl); 321 if (acc_hdl == (container_hdl_t)0) { 322 return (NULL); 323 } 324 325 /* allocate container node object */ 326 cont_node = malloc(sizeof (container_node_t)); 327 if (cont_node == NULL) { 328 return (NULL); 329 } 330 331 /* allocate container hash object */ 332 hash_obj = malloc(sizeof (hash_obj_t)); 333 if (hash_obj == NULL) { 334 (void) free(cont_node); 335 return (NULL); 336 } 337 338 cont_node->cont_hdl = acc_hdl; /* fruaccess handle */ 339 cont_node->section_list = NULL; 340 hash_obj->picl_hdl = nodehdl; /* picl node handle */ 341 hash_obj->object_type = CONTAINER_NODE; 342 hash_obj->u.cont_node = cont_node; 343 hash_obj->next = NULL; 344 hash_obj->prev = NULL; 345 346 return (hash_obj); 347 } 348 349 /* 350 * called to allocate node object for section node. 351 */ 352 353 static hash_obj_t * 354 alloc_section_node_object(picl_nodehdl_t nodehdl, section_t *section) 355 { 356 hash_obj_t *hash_obj; 357 section_node_t *sec_node; 358 359 /* allocate section node object */ 360 sec_node = malloc(sizeof (section_node_t)); 361 if (sec_node == NULL) { 362 return (NULL); 363 } 364 365 /* allocate section hash object */ 366 hash_obj = malloc(sizeof (hash_obj_t)); 367 if (hash_obj == NULL) { 368 (void) free(sec_node); 369 return (NULL); 370 } 371 372 sec_node->section_hdl = section->handle; /* fruaccess hdl. */ 373 sec_node->segment_list = NULL; 374 sec_node->next = NULL; 375 sec_node->num_of_segment = -1; 376 377 hash_obj->picl_hdl = nodehdl; /* picl node handle */ 378 hash_obj->object_type = SECTION_NODE; 379 hash_obj->u.sec_node = sec_node; 380 hash_obj->next = NULL; 381 hash_obj->prev = NULL; 382 383 return (hash_obj); 384 } 385 386 /* 387 * called to allocate segment node object. 388 */ 389 390 static hash_obj_t * 391 alloc_segment_node_object(picl_nodehdl_t nodehdl, segment_t *segment) 392 { 393 hash_obj_t *hash_obj; 394 segment_node_t *seg_node; 395 396 /* allocate segment node object */ 397 seg_node = malloc(sizeof (segment_node_t)); 398 if (seg_node == NULL) { 399 return (NULL); 400 } 401 402 /* allocate segment hash object */ 403 hash_obj = malloc(sizeof (hash_obj_t)); 404 if (hash_obj == NULL) { 405 free(seg_node); 406 return (NULL); 407 } 408 409 /* fruaccess handle */ 410 seg_node->segment_hdl = segment->handle; 411 seg_node->packet_list = NULL; 412 seg_node->next = NULL; 413 seg_node->num_of_pkt = -1; 414 415 /* picl node handle */ 416 hash_obj->picl_hdl = nodehdl; 417 hash_obj->object_type = SEGMENT_NODE; 418 hash_obj->u.seg_node = seg_node; 419 hash_obj->next = NULL; 420 hash_obj->prev = NULL; 421 422 return (hash_obj); 423 } 424 425 /* 426 * called to allocate node object for packet. 427 */ 428 429 static hash_obj_t * 430 alloc_packet_node_object(picl_nodehdl_t nodehdl, packet_t *packet) 431 { 432 hash_obj_t *hash_obj; 433 packet_node_t *pkt_node; 434 435 /* allocate packet node object */ 436 pkt_node = malloc(sizeof (packet_node_t)); 437 if (pkt_node == NULL) { 438 return (NULL); 439 } 440 441 /* allocate packet hash object */ 442 hash_obj = malloc(sizeof (hash_obj_t)); 443 if (hash_obj == NULL) { 444 free(pkt_node); 445 return (NULL); 446 } 447 448 /* fruaccess handle */ 449 pkt_node->pkt_handle = packet->handle; 450 pkt_node->next = NULL; 451 452 hash_obj->picl_hdl = nodehdl; /* picl node handle */ 453 hash_obj->object_type = PACKET_NODE; 454 hash_obj->u.pkt_node = pkt_node; 455 hash_obj->next = NULL; 456 hash_obj->prev = NULL; 457 458 return (hash_obj); 459 } 460 461 /* add new section hash object to the section list */ 462 static void 463 add_to_section_list(hash_obj_t *container_hash, hash_obj_t *sect_hash) 464 { 465 hash_obj_t *next_hash; 466 467 sect_hash->u.sec_node->container_hdl = container_hash->picl_hdl; 468 if (container_hash->u.cont_node->section_list == NULL) { 469 container_hash->u.cont_node->section_list = sect_hash; 470 return; 471 } 472 473 for (next_hash = container_hash->u.cont_node->section_list; 474 next_hash->u.sec_node->next != NULL; 475 next_hash = next_hash->u.sec_node->next) { 476 ; 477 } 478 479 next_hash->u.sec_node->next = sect_hash; 480 } 481 482 /* add new segment hash object to the existing list */ 483 484 static void 485 add_to_segment_list(hash_obj_t *parent_obj, hash_obj_t *child_obj) 486 { 487 hash_obj_t *next_hash; 488 489 child_obj->u.seg_node->sec_nodehdl = parent_obj->picl_hdl; 490 if (parent_obj->u.sec_node->segment_list == NULL) { 491 parent_obj->u.sec_node->segment_list = child_obj; 492 return; 493 } 494 495 for (next_hash = parent_obj->u.sec_node->segment_list; 496 next_hash->u.seg_node->next != NULL; 497 next_hash = next_hash->u.seg_node->next) { 498 ; 499 } 500 next_hash->u.seg_node->next = child_obj; 501 } 502 503 /* 504 * called to add packet node object to the existing packet list. 505 */ 506 static void 507 add_to_packet_list(hash_obj_t *parent_obj, hash_obj_t *child_obj) 508 { 509 hash_obj_t *next_hash; 510 511 if (parent_obj->u.seg_node->packet_list == NULL) { 512 parent_obj->u.seg_node->packet_list = child_obj; 513 return; 514 } 515 516 for (next_hash = parent_obj->u.seg_node->packet_list; 517 next_hash->u.pkt_node->next != NULL; 518 next_hash = next_hash->u.pkt_node->next) { 519 ; 520 } 521 next_hash->u.pkt_node->next = child_obj; 522 } 523 524 /* 525 * free the packet hash list. 526 */ 527 528 static void 529 free_packet_list(hash_obj_t *hash_obj, container_tbl_t *cont_tbl) 530 { 531 hash_obj_t *next_obj; 532 hash_obj_t *free_obj; 533 534 /* packet hash object list */ 535 next_obj = hash_obj->u.seg_node->packet_list; 536 while (next_obj != NULL) { 537 free_obj = next_obj; 538 next_obj = next_obj->u.pkt_node->next; 539 if (free_obj->prev == NULL) { /* first node object */ 540 cont_tbl->hash_obj[(free_obj->picl_hdl % 541 TABLE_SIZE)].next = free_obj->next; 542 if (free_obj->next != NULL) { 543 free_obj->next->prev = NULL; 544 } 545 } else { 546 free_obj->prev->next = free_obj->next; 547 if (free_obj->next != NULL) { 548 free_obj->next->prev = free_obj->prev; 549 } 550 } 551 552 free(free_obj->u.pkt_node); 553 free(free_obj); 554 } 555 hash_obj->u.seg_node->packet_list = NULL; 556 } 557 558 /* 559 * free the segment hash node object. 560 */ 561 562 static void 563 free_segment_node(hash_obj_t *hash_obj, picl_nodehdl_t nodehdl, 564 container_tbl_t *cont_tbl) 565 { 566 hash_obj_t *prev_hash_obj; 567 hash_obj_t *next_obj; 568 569 /* segment hash object list */ 570 next_obj = hash_obj->u.sec_node->segment_list; 571 if (next_obj == NULL) { 572 return; 573 } 574 575 /* find the segment hash from the segment list to be deleted. */ 576 if (next_obj->picl_hdl == nodehdl) { 577 hash_obj->u.sec_node->segment_list = 578 next_obj->u.seg_node->next; 579 } else { 580 while (next_obj != NULL) { 581 if (next_obj->picl_hdl != nodehdl) { 582 prev_hash_obj = next_obj; 583 next_obj = next_obj->u.seg_node->next; 584 } else { 585 prev_hash_obj->u.seg_node->next = 586 next_obj->u.seg_node->next; 587 break; 588 } 589 } 590 591 if (next_obj == NULL) { 592 return; 593 } 594 595 } 596 597 if (next_obj->prev == NULL) { 598 cont_tbl->hash_obj[(next_obj->picl_hdl % TABLE_SIZE)].next = 599 next_obj->next; 600 if (next_obj->next != NULL) 601 next_obj->next->prev = NULL; 602 } else { 603 next_obj->prev->next = next_obj->next; 604 if (next_obj->next != NULL) { 605 next_obj->next->prev = next_obj->prev; 606 } 607 } 608 609 free_packet_list(next_obj, cont_tbl); 610 free(next_obj->u.seg_node); 611 free(next_obj); 612 } 613 614 615 /* 616 * Description : frudata_delete_segment is called when volatile property 617 * delete_segment under class segment is accessed. 618 * 619 * Arguments : ptree_warg_t is holds node handle of segment node and property 620 * handle of delete_segment property. 621 */ 622 623 /* ARGSUSED */ 624 static int 625 frudata_delete_segment(ptree_warg_t *warg, const void *buf) 626 { 627 int retval; 628 int num_of_segment; 629 int num_of_pkt; 630 int pkt_cnt; 631 int count; 632 packet_t *pkt_buf; 633 segment_t *seg_buffer; 634 hash_obj_t *seg_hash; 635 hash_obj_t *pkt_hash; 636 hash_obj_t *hash_obj; 637 fru_segdesc_t *desc; 638 picl_nodehdl_t sec_nodehdl; 639 container_tbl_t *cont_tbl; 640 fru_access_hdl_t seg_acc_hdl; 641 fru_access_hdl_t new_sec_acc_hdl; 642 643 cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE); 644 if (!cont_tbl) { 645 return (PICL_FAILURE); 646 } 647 648 /* segment hash */ 649 hash_obj = lookup_node_object(warg->nodeh, SEGMENT_NODE, cont_tbl); 650 if (hash_obj == NULL) { 651 unlock_container_lock(cont_tbl); 652 return (PICL_FAILURE); 653 } 654 655 /* fruaccess segment handle */ 656 seg_acc_hdl = hash_obj->u.seg_node->segment_hdl; 657 658 /* call fruaccess to get new section handle */ 659 if (fru_delete_segment(seg_acc_hdl, &new_sec_acc_hdl, &warg->cred) 660 == -1) { 661 unlock_container_lock(cont_tbl); 662 return (map_access_err(errno)); 663 } 664 665 if (ptree_delete_node(warg->nodeh) != PICL_SUCCESS) { 666 unlock_container_lock(cont_tbl); 667 return (PICL_FAILURE); 668 } 669 670 if (ptree_destroy_node(warg->nodeh) != PICL_SUCCESS) { 671 unlock_container_lock(cont_tbl); 672 return (PICL_FAILURE); 673 } 674 675 676 /* get section node handle */ 677 sec_nodehdl = hash_obj->u.seg_node->sec_nodehdl; 678 /* get section hash */ 679 hash_obj = lookup_node_object(sec_nodehdl, SECTION_NODE, cont_tbl); 680 if (hash_obj == NULL) { 681 unlock_container_lock(cont_tbl); 682 return (PICL_FAILURE); 683 } 684 685 free_segment_node(hash_obj, warg->nodeh, cont_tbl); 686 687 hash_obj->u.sec_node->num_of_segment = 0; 688 689 /* call fruaccess with new section handle */ 690 num_of_segment = fru_get_num_segments(new_sec_acc_hdl, &warg->cred); 691 if (num_of_segment <= 0) { 692 unlock_container_lock(cont_tbl); 693 return (PICL_SUCCESS); 694 } 695 696 seg_buffer = alloca(sizeof (segment_t) * num_of_segment); 697 if (seg_buffer == NULL) { 698 unlock_container_lock(cont_tbl); 699 return (PICL_FAILURE); 700 } 701 702 /* get all the segments */ 703 retval = fru_get_segments(new_sec_acc_hdl, seg_buffer, 704 num_of_segment, &warg->cred); 705 if (retval == -1) { 706 unlock_container_lock(cont_tbl); 707 return (PICL_FAILURE); 708 } 709 710 seg_hash = hash_obj->u.sec_node->segment_list; 711 if (seg_hash == NULL) { 712 unlock_container_lock(cont_tbl); 713 return (PICL_SUCCESS); 714 } 715 716 /* rebuild the segment list */ 717 for (count = 0; count < num_of_segment; count++) { 718 desc = (fru_segdesc_t *)&seg_buffer[count].descriptor; 719 if (!(desc->field.field_perm & SEGMENT_READ)) { 720 seg_hash = seg_hash->u.seg_node->next; 721 continue; 722 } 723 724 if (desc->field.opaque) { 725 seg_hash = seg_hash->u.seg_node->next; 726 continue; 727 } 728 729 hash_obj->u.sec_node->num_of_segment++; 730 731 seg_hash->u.seg_node->segment_hdl = seg_buffer[count].handle; 732 733 num_of_pkt = fru_get_num_packets(seg_buffer[count].handle, 734 &warg->cred); 735 if (num_of_pkt <= 0) { 736 seg_hash = seg_hash->u.seg_node->next; 737 continue; 738 } 739 740 pkt_buf = alloca(sizeof (packet_t) * num_of_pkt); 741 if (pkt_buf == NULL) { 742 unlock_container_lock(cont_tbl); 743 return (PICL_FAILURE); 744 } 745 746 retval = fru_get_packets(seg_buffer[count].handle, pkt_buf, 747 num_of_pkt, &warg->cred); 748 if (retval == -1) { 749 seg_hash = seg_hash->u.seg_node->next; 750 continue; 751 } 752 753 pkt_hash = seg_hash->u.seg_node->packet_list; 754 if (pkt_hash == NULL) { 755 seg_hash = seg_hash->u.seg_node->next; 756 continue; 757 } 758 759 /* rebuild the packet list */ 760 for (pkt_cnt = 0; pkt_cnt < num_of_pkt; pkt_cnt++) { 761 pkt_hash->u.pkt_node->pkt_handle = 762 pkt_buf[pkt_cnt].handle; 763 pkt_hash = pkt_hash->u.pkt_node->next; 764 } 765 766 seg_hash = seg_hash->u.seg_node->next; 767 if (seg_hash == NULL) { 768 break; 769 } 770 } 771 772 /* updated with new section handle */ 773 hash_obj->u.sec_node->section_hdl = new_sec_acc_hdl; 774 775 unlock_container_lock(cont_tbl); 776 777 return (PICL_SUCCESS); 778 } 779 780 /* 781 * Description : frudata_read_payload is called when volatile property 782 * payload is read. 783 * 784 * Arguments : ptree_rarg_t holds node handle of the table property. 785 * and property handle of the payload cell. 786 * p_buf contains payload data when function returns. 787 * 788 * Returns : PICL_SUCCESS on success. 789 * PICL_FAILURE on failure. 790 */ 791 792 static int 793 frudata_read_payload(ptree_rarg_t *rarg, void *buf) 794 { 795 int num_bytes; 796 hash_obj_t *hash_obj; 797 fru_access_hdl_t pkt_acc_hdl; 798 container_tbl_t *cont_tbl; 799 800 801 cont_tbl = lock_container_lock(rarg->nodeh, SEGMENT_NODE, PICL_READ); 802 if (!cont_tbl) { 803 return (PICL_FAILURE); 804 } 805 806 hash_obj = lookup_node_object(rarg->proph, PACKET_NODE, cont_tbl); 807 if (hash_obj == NULL) { 808 unlock_container_lock(cont_tbl); 809 return (PICL_FAILURE); 810 } 811 812 pkt_acc_hdl = hash_obj->u.pkt_node->pkt_handle; 813 814 num_bytes = fru_get_payload(pkt_acc_hdl, buf, 815 hash_obj->u.pkt_node->paylen, &rarg->cred); 816 if (num_bytes != hash_obj->u.pkt_node->paylen) { 817 unlock_container_lock(cont_tbl); 818 return (PICL_FAILURE); 819 } 820 821 unlock_container_lock(cont_tbl); 822 823 return (PICL_SUCCESS); 824 } 825 826 /* 827 * Description : frudata_write_payload is called when payload property cell 828 * is accessed. 829 * 830 * Arguments : ptree_warg_t holds node handle of the packet-table. 831 * and property handle of the payload cell. 832 * p_buf contains payload data. 833 * 834 * Returns : PICL_SUCCESS on success. 835 * 836 */ 837 838 static int 839 frudata_write_payload(ptree_warg_t *warg, const void *buf) 840 { 841 int retval; 842 hash_obj_t *hash_obj; 843 fru_access_hdl_t pkt_acc_hdl; 844 container_tbl_t *cont_tbl; 845 846 cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE); 847 if (!cont_tbl) { 848 return (PICL_FAILURE); 849 } 850 851 hash_obj = lookup_node_object(warg->proph, PACKET_NODE, cont_tbl); 852 if (hash_obj == NULL) { 853 unlock_container_lock(cont_tbl); 854 return (PICL_FAILURE); 855 } 856 857 pkt_acc_hdl = hash_obj->u.pkt_node->pkt_handle; 858 859 retval = fru_update_payload(pkt_acc_hdl, buf, 860 hash_obj->u.pkt_node->paylen, 861 &pkt_acc_hdl, &warg->cred); 862 if (retval == -1) { 863 unlock_container_lock(cont_tbl); 864 return (map_access_err(errno)); 865 } 866 867 hash_obj->u.pkt_node->pkt_handle = pkt_acc_hdl; 868 869 unlock_container_lock(cont_tbl); 870 871 return (PICL_SUCCESS); 872 } 873 874 /* 875 * callback volatile function is called when tag volatile property 876 * is accessed. this routine holds a read lock over the hash table 877 * and do a lookup over the property handle i.e property handle of 878 * the tag property passed in rarg parameter. 879 * tag value is copied into the buffer (void *buf). 880 */ 881 882 static int 883 frudata_read_tag(ptree_rarg_t *rarg, void *buf) 884 { 885 int retval; 886 hash_obj_t *hash_obj; 887 picl_prophdl_t rowproph; 888 container_tbl_t *cont_tbl; 889 890 cont_tbl = lock_container_lock(rarg->nodeh, SEGMENT_NODE, PICL_READ); 891 if (!cont_tbl) { 892 return (PICL_FAILURE); 893 } 894 895 retval = ptree_get_next_by_row(rarg->proph, &rowproph); 896 if (retval != PICL_SUCCESS) { 897 unlock_container_lock(cont_tbl); 898 return (retval); 899 } 900 901 hash_obj = lookup_node_object(rowproph, PACKET_NODE, cont_tbl); 902 if (hash_obj == NULL) { 903 unlock_container_lock(cont_tbl); 904 return (PICL_FAILURE); 905 } 906 907 (void) memcpy(buf, &hash_obj->u.pkt_node->tag, sizeof (tag_t)); 908 909 unlock_container_lock(cont_tbl); 910 return (PICL_SUCCESS); 911 } 912 913 914 /* 915 * Description : create_packet_table() is called by fru_delete_packet_row(), 916 * to create a packet-table volatile property. it's called after 917 * deleting the packet-table. fru_delete_packet_row() calls 918 * frudata_read_packet_table() to add rows into the table. 919 */ 920 921 static int 922 create_packet_table(picl_nodehdl_t seghdl, picl_prophdl_t *thdl) 923 { 924 int retval; 925 picl_prophdl_t tblhdl; 926 picl_nodehdl_t prophdl; 927 ptree_propinfo_t prop; 928 929 retval = ptree_create_table(&tblhdl); 930 if (retval != PICL_SUCCESS) { 931 return (retval); 932 } 933 934 prop.version = PTREE_PROPINFO_VERSION; 935 prop.piclinfo.type = PICL_PTYPE_TABLE; 936 prop.piclinfo.accessmode = PICL_READ|PICL_WRITE; 937 prop.piclinfo.size = sizeof (picl_prophdl_t); 938 prop.read = NULL; 939 prop.write = NULL; 940 (void) strcpy(prop.piclinfo.name, PICL_PROP_PACKET_TABLE); 941 942 retval = ptree_create_and_add_prop(seghdl, &prop, &tblhdl, 943 &prophdl); 944 if (retval != PICL_SUCCESS) { 945 return (retval); 946 } 947 948 /* hold the table handle */ 949 *thdl = tblhdl; 950 951 return (PICL_SUCCESS); 952 } 953 954 /* 955 * Description : frudata_delete_packet is called when write operation is 956 * performed on tag volatile property. 957 * 958 * 959 * Arguments : ptree_warg_t holds node handle to the segment node. 960 * and property handle of the tag cell in the packet table to be 961 * deleted. 962 * buf contains the tag data + plus DELETE_KEY_TAG 963 * 964 * Returns : PICL_SUCCESS on success 965 * 966 */ 967 968 static int 969 frudata_delete_packet(ptree_warg_t *warg, const void *buf) 970 { 971 int count = 0; 972 int retval; 973 int num_of_pkt; 974 uint64_t tag; 975 packet_t *packet; 976 hash_obj_t *seg_hash_obj; 977 hash_obj_t *pkt_hash_obj; 978 container_tbl_t *cont_tbl; 979 picl_prophdl_t tblhdl; 980 picl_prophdl_t rowproph; 981 fru_access_hdl_t new_seg_acc_hdl; 982 983 cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE); 984 if (!cont_tbl) { 985 return (PICL_FAILURE); 986 } 987 988 /* get the payload property handle */ 989 retval = ptree_get_next_by_row(warg->proph, &rowproph); 990 if (retval != PICL_SUCCESS) { 991 unlock_container_lock(cont_tbl); 992 return (retval); 993 } 994 995 /* do lookup on payload property handle */ 996 pkt_hash_obj = lookup_node_object(rowproph, PACKET_NODE, cont_tbl); 997 if (pkt_hash_obj == NULL) { 998 unlock_container_lock(cont_tbl); 999 return (PICL_FAILURE); 1000 } 1001 1002 /* verify the tag */ 1003 tag = pkt_hash_obj->u.pkt_node->tag.raw_data; 1004 tag &= FRUDATA_DELETE_TAG_MASK; 1005 tag |= FRUDATA_DELETE_TAG_KEY; 1006 if (*(uint64_t *)buf != tag) { 1007 unlock_container_lock(cont_tbl); 1008 return (PICL_FAILURE); 1009 } 1010 1011 /* call fruaccess module */ 1012 retval = fru_delete_packet(pkt_hash_obj->u.pkt_node->pkt_handle, 1013 &new_seg_acc_hdl, &warg->cred); 1014 if (retval == -1) { 1015 unlock_container_lock(cont_tbl); 1016 return (map_access_err(errno)); 1017 } 1018 1019 /* delete the packet table */ 1020 retval = ptree_get_prop_by_name(warg->nodeh, PICL_PROP_PACKET_TABLE, 1021 &tblhdl); 1022 if (retval != PICL_SUCCESS) { 1023 unlock_container_lock(cont_tbl); 1024 return (retval); 1025 } 1026 1027 retval = ptree_delete_prop(tblhdl); 1028 if (retval != PICL_SUCCESS) { 1029 unlock_container_lock(cont_tbl); 1030 return (retval); 1031 } 1032 1033 retval = ptree_destroy_prop(tblhdl); 1034 if (retval != PICL_SUCCESS) { 1035 unlock_container_lock(cont_tbl); 1036 return (retval); 1037 } 1038 1039 1040 seg_hash_obj = lookup_node_object(warg->nodeh, SEGMENT_NODE, 1041 cont_tbl); 1042 if (seg_hash_obj == NULL) { 1043 unlock_container_lock(cont_tbl); 1044 return (PICL_FAILURE); 1045 } 1046 1047 /* free all packet hash object */ 1048 free_packet_list(seg_hash_obj, cont_tbl); 1049 1050 /* recreate the packet table */ 1051 retval = create_packet_table(warg->nodeh, &tblhdl); 1052 if (retval != PICL_SUCCESS) { 1053 unlock_container_lock(cont_tbl); 1054 return (retval); 1055 } 1056 1057 seg_hash_obj->u.seg_node->segment_hdl = new_seg_acc_hdl; 1058 1059 seg_hash_obj->u.seg_node->num_of_pkt = 0; 1060 1061 num_of_pkt = fru_get_num_packets(new_seg_acc_hdl, &warg->cred); 1062 if (num_of_pkt == -1) { 1063 unlock_container_lock(cont_tbl); 1064 return (PICL_FAILURE); 1065 } 1066 1067 if (num_of_pkt == 0) { 1068 unlock_container_lock(cont_tbl); 1069 return (PICL_SUCCESS); 1070 } 1071 1072 packet = alloca(sizeof (packet_t) * num_of_pkt); 1073 if (packet == NULL) { 1074 unlock_container_lock(cont_tbl); 1075 return (PICL_FAILURE); 1076 } 1077 1078 retval = fru_get_packets(new_seg_acc_hdl, packet, 1079 num_of_pkt, &warg->cred); 1080 if (retval == -1) { 1081 unlock_container_lock(cont_tbl); 1082 return (PICL_FAILURE); 1083 } 1084 1085 /* rebuild the packet hash object */ 1086 for (count = 0; count < num_of_pkt; count++) { 1087 (void) add_row_to_table(seg_hash_obj, tblhdl, packet+count, 1088 cont_tbl); 1089 } 1090 1091 seg_hash_obj->u.seg_node->num_of_pkt = num_of_pkt; 1092 1093 (void) ptree_update_propval_by_name(warg->nodeh, PICL_PROP_NUM_TAGS, 1094 &num_of_pkt, sizeof (uint32_t)); 1095 1096 unlock_container_lock(cont_tbl); 1097 1098 return (PICL_SUCCESS); 1099 } 1100 1101 /* 1102 * called from frudata_delete_packet(), frudata_add_packet(), 1103 * frudata_read_packet() callback routine to add packet into 1104 * the packet table. it also create hash node object for each 1105 * individual packet and add the object to the packet list. 1106 */ 1107 1108 static int 1109 add_row_to_table(hash_obj_t *seg_obj, picl_nodehdl_t tblhdl, packet_t *pkt, 1110 container_tbl_t *cont_tbl) 1111 { 1112 int retval; 1113 int paylen; 1114 size_t tag_size; 1115 hash_obj_t *hash_obj; 1116 fru_tagtype_t tagtype; 1117 picl_prophdl_t prophdl[NUM_OF_COL_IN_PKT_TABLE]; 1118 ptree_propinfo_t prop; 1119 1120 prop.version = PTREE_PROPINFO_VERSION; 1121 1122 prop.piclinfo.type = PICL_PTYPE_BYTEARRAY; 1123 prop.piclinfo.accessmode = PICL_READ|PICL_WRITE|PICL_VOLATILE; 1124 prop.piclinfo.size = sizeof (fru_tag_t); 1125 prop.read = frudata_read_tag; 1126 prop.write = frudata_delete_packet; 1127 1128 /* tag property node */ 1129 (void) strcpy(prop.piclinfo.name, PICL_PROP_TAG); 1130 1131 paylen = get_payload_length((void *)&pkt->tag); 1132 if (paylen < 0) { 1133 return (PICL_FAILURE); 1134 } 1135 1136 retval = ptree_create_prop(&prop, NULL, &prophdl[0]); 1137 if (retval != PICL_SUCCESS) { 1138 return (retval); 1139 } 1140 1141 1142 /* payload property node */ 1143 prop.piclinfo.type = PICL_PTYPE_BYTEARRAY; 1144 prop.piclinfo.size = paylen; 1145 (void) strcpy(prop.piclinfo.name, PICL_PROP_PAYLOAD); 1146 prop.piclinfo.accessmode = PICL_READ|PICL_WRITE|PICL_VOLATILE; 1147 prop.read = frudata_read_payload; 1148 prop.write = frudata_write_payload; 1149 1150 retval = ptree_create_prop(&prop, NULL, &prophdl[1]); 1151 if (retval != PICL_SUCCESS) { 1152 return (retval); 1153 } 1154 1155 hash_obj = alloc_packet_node_object(prophdl[1], pkt); 1156 if (hash_obj == NULL) { 1157 return (PICL_FAILURE); 1158 } 1159 1160 retval = ptree_add_row_to_table(tblhdl, NUM_OF_COL_IN_PKT_TABLE, 1161 prophdl); 1162 if (retval != PICL_SUCCESS) { 1163 free(hash_obj); 1164 return (retval); 1165 } 1166 1167 tagtype = get_tag_type((fru_tag_t *)&pkt->tag); 1168 if (tagtype == -1) { 1169 return (PICL_FAILURE); 1170 } 1171 1172 tag_size = get_tag_size(tagtype); 1173 if (tag_size == (size_t)-1) { 1174 return (PICL_FAILURE); 1175 } 1176 1177 hash_obj->u.pkt_node->paylen = paylen; 1178 hash_obj->u.pkt_node->tag.raw_data = 0; 1179 (void) memcpy(&hash_obj->u.pkt_node->tag, &pkt->tag, tag_size); 1180 1181 add_nodeobject_to_hashtable(hash_obj, cont_tbl); 1182 1183 add_to_packet_list(seg_obj, hash_obj); 1184 1185 return (PICL_SUCCESS); 1186 } 1187 1188 /* 1189 * called from frudata_read_segment() callback routine. it's called after 1190 * creating the packet table under class segment. this routine reads the 1191 * segment data to get total number of packets in the segments and add 1192 * the tag and payload data into the table. it calls add_row_to_table 1193 * routine to add individual row into the packet table. 1194 */ 1195 1196 static int 1197 frudata_read_packet(picl_nodehdl_t nodeh, picl_prophdl_t *tblhdl, 1198 container_tbl_t *cont_tbl, door_cred_t *cred) 1199 { 1200 int cnt; 1201 int retval; 1202 int num_of_pkt; 1203 packet_t *packet; 1204 hash_obj_t *hash_obj; 1205 fru_access_hdl_t seg_acc_hdl; 1206 1207 hash_obj = lookup_node_object(nodeh, SEGMENT_NODE, cont_tbl); 1208 if (hash_obj == NULL) { 1209 return (PICL_FAILURE); 1210 } 1211 1212 if (hash_obj->u.seg_node->num_of_pkt == -1) { 1213 /* get the access handle */ 1214 seg_acc_hdl = hash_obj->u.seg_node->segment_hdl; 1215 /* get total number of packets */ 1216 num_of_pkt = fru_get_num_packets(seg_acc_hdl, cred); 1217 if (num_of_pkt < 0) { 1218 hash_obj->u.seg_node->num_of_pkt = 0; 1219 return (map_access_err(errno)); 1220 } 1221 1222 if (num_of_pkt == 0) { 1223 hash_obj->u.seg_node->num_of_pkt = 0; 1224 return (0); 1225 } 1226 1227 /* allocate buffer */ 1228 packet = alloca(sizeof (packet_t) * num_of_pkt); 1229 if (packet == NULL) { 1230 hash_obj->u.seg_node->num_of_pkt = 0; 1231 return (0); 1232 } 1233 1234 /* get all the packet into the packet buffer */ 1235 retval = fru_get_packets(seg_acc_hdl, packet, num_of_pkt, cred); 1236 if (retval == -1) { 1237 return (0); 1238 } 1239 1240 /* add payload and tag into the table. */ 1241 for (cnt = 0; cnt < num_of_pkt; cnt++) { 1242 (void) add_row_to_table(hash_obj, *tblhdl, packet+cnt, 1243 cont_tbl); 1244 } 1245 1246 hash_obj->u.seg_node->num_of_pkt = num_of_pkt; 1247 } 1248 return (0); 1249 } 1250 1251 1252 /* 1253 * Description : frudata_add_packet is called when add-packet volatile 1254 * property is accessed. 1255 * 1256 * Arguments : ptree_warg_t holds node handle of the segment node and 1257 * property handle of add-packet property. 1258 * p_buf- contains packet data to be added. 1259 * 1260 * Return : PICL_SUCCESS on success. 1261 * 1262 */ 1263 1264 /* ARGSUSED */ 1265 static int 1266 frudata_add_packet(ptree_warg_t *warg, const void *buf) 1267 { 1268 size_t tag_size; 1269 int paylen; 1270 int retval; 1271 int num_of_pkt; 1272 int cnt; 1273 packet_t packet; 1274 packet_t *pkt_buf; 1275 hash_obj_t *hash_obj; 1276 hash_obj_t *pkt_hash; 1277 container_tbl_t *cont_tbl; 1278 fru_tagtype_t tagtype; 1279 picl_prophdl_t tblhdl; 1280 fru_access_hdl_t seg_acc_hdl; 1281 fru_access_hdl_t new_seg_acc_hdl; 1282 1283 cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE); 1284 if (!cont_tbl) { 1285 return (PICL_FAILURE); 1286 } 1287 1288 hash_obj = lookup_node_object(warg->nodeh, SEGMENT_NODE, cont_tbl); 1289 if (hash_obj == NULL) { 1290 unlock_container_lock(cont_tbl); 1291 return (PICL_FAILURE); 1292 } 1293 1294 seg_acc_hdl = hash_obj->u.seg_node->segment_hdl; 1295 1296 tagtype = get_tag_type((void *)buf); 1297 if (tagtype == -1) { 1298 unlock_container_lock(cont_tbl); 1299 return (PICL_FAILURE); 1300 } 1301 1302 tag_size = get_tag_size(tagtype); 1303 if (tag_size == (size_t)-1) { 1304 unlock_container_lock(cont_tbl); 1305 return (PICL_FAILURE); 1306 } 1307 1308 paylen = get_payload_length((void *)buf); 1309 if (paylen == -1) { 1310 unlock_container_lock(cont_tbl); 1311 return (PICL_FAILURE); 1312 } 1313 1314 packet.tag = 0; 1315 (void) memcpy(&packet.tag, buf, tag_size); 1316 1317 retval = fru_append_packet(seg_acc_hdl, &packet, (char *)buf + tag_size, 1318 paylen, &new_seg_acc_hdl, &warg->cred); 1319 if (retval == -1) { 1320 unlock_container_lock(cont_tbl); 1321 return (map_access_err(errno)); 1322 } 1323 1324 retval = ptree_get_propval_by_name(warg->nodeh, 1325 PICL_PROP_PACKET_TABLE, &tblhdl, sizeof (picl_prophdl_t)); 1326 if (retval != PICL_SUCCESS) { 1327 unlock_container_lock(cont_tbl); 1328 return (retval); 1329 } 1330 retval = add_row_to_table(hash_obj, tblhdl, &packet, cont_tbl); 1331 if (retval != PICL_SUCCESS) { 1332 unlock_container_lock(cont_tbl); 1333 return (retval); 1334 } 1335 1336 num_of_pkt = fru_get_num_packets(new_seg_acc_hdl, &warg->cred); 1337 if (num_of_pkt == -1) { 1338 unlock_container_lock(cont_tbl); 1339 return (PICL_FAILURE); 1340 } 1341 1342 pkt_buf = alloca(sizeof (packet_t) * num_of_pkt); 1343 if (pkt_buf == NULL) { 1344 unlock_container_lock(cont_tbl); 1345 return (PICL_FAILURE); 1346 } 1347 1348 retval = fru_get_packets(new_seg_acc_hdl, pkt_buf, 1349 num_of_pkt, &warg->cred); 1350 if (retval == -1) { 1351 unlock_container_lock(cont_tbl); 1352 return (PICL_FAILURE); 1353 } 1354 1355 pkt_hash = hash_obj->u.seg_node->packet_list; 1356 if (pkt_hash == NULL) { 1357 unlock_container_lock(cont_tbl); 1358 return (PICL_FAILURE); 1359 } 1360 1361 for (cnt = 0; cnt < num_of_pkt; cnt++) { 1362 pkt_hash->u.pkt_node->pkt_handle = pkt_buf[cnt].handle; 1363 pkt_hash = pkt_hash->u.pkt_node->next; 1364 } 1365 1366 hash_obj->u.seg_node->num_of_pkt = num_of_pkt; 1367 1368 (void) ptree_update_propval_by_name(warg->nodeh, PICL_PROP_NUM_TAGS, 1369 &num_of_pkt, sizeof (uint32_t)); 1370 1371 unlock_container_lock(cont_tbl); 1372 1373 return (PICL_SUCCESS); 1374 } 1375 1376 static void 1377 freeup(picl_nodehdl_t nodeh) 1378 { 1379 (void) ptree_delete_node(nodeh); 1380 (void) ptree_destroy_node(nodeh); 1381 } 1382 1383 /* 1384 * called by frudata_read_segment() and fru_data_add_segment() callback routine. 1385 * it's called to create a segment node and all it's property beneith the 1386 * segment node in the picl tree. 1387 */ 1388 1389 static int 1390 create_segment_node(hash_obj_t *sec_obj, picl_nodehdl_t sec_node, 1391 segment_t *segment, container_tbl_t *cont_tbl, door_cred_t *cred) 1392 { 1393 1394 int retval; 1395 char segname[SEG_NAME_LEN + 1]; 1396 uint32_t numoftags = 0; 1397 uint32_t protection; 1398 hash_obj_t *hash_obj; 1399 picl_nodehdl_t nodehdl; 1400 picl_prophdl_t prophdl; 1401 picl_nodehdl_t tblhdl; 1402 ptree_propinfo_t prop; 1403 1404 (void) strlcpy(segname, segment->name, SEG_NAME_LEN + 1); 1405 segname[SEG_NAME_LEN] = '\0'; 1406 1407 if (!(isprint(segname[0]) || isprint(segname[1]))) { 1408 return (PICL_FAILURE); 1409 } 1410 1411 if (ptree_create_node(segname, PICL_CLASS_SEGMENT, &nodehdl) 1412 != PICL_SUCCESS) { 1413 return (PICL_FAILURE); 1414 } 1415 1416 1417 /* create property node */ 1418 prop.version = PTREE_PROPINFO_VERSION; 1419 prop.piclinfo.accessmode = PICL_READ; 1420 prop.read = NULL; 1421 prop.write = NULL; 1422 1423 prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT; 1424 prop.piclinfo.size = sizeof (uint32_t); 1425 1426 /* descriptor property */ 1427 (void) strcpy(prop.piclinfo.name, PICL_PROP_DESCRIPTOR); 1428 if (ptree_create_and_add_prop(nodehdl, &prop, &segment->descriptor, 1429 &prophdl) != PICL_SUCCESS) { 1430 freeup(nodehdl); 1431 return (PICL_FAILURE); 1432 } 1433 1434 1435 /* offset property */ 1436 (void) strcpy(prop.piclinfo.name, PICL_PROP_OFFSET); 1437 if (ptree_create_and_add_prop(nodehdl, &prop, &segment->offset, 1438 &prophdl) != PICL_SUCCESS) { 1439 freeup(nodehdl); 1440 return (PICL_FAILURE); 1441 } 1442 1443 1444 /* length property */ 1445 (void) strcpy(prop.piclinfo.name, PICL_PROP_LENGTH); 1446 if (ptree_create_and_add_prop(nodehdl, &prop, &segment->length, 1447 &prophdl) != PICL_SUCCESS) { 1448 freeup(nodehdl); 1449 return (PICL_FAILURE); 1450 } 1451 1452 /* Number of Tags */ 1453 (void) strcpy(prop.piclinfo.name, PICL_PROP_NUM_TAGS); 1454 if (ptree_create_and_add_prop(nodehdl, &prop, &numoftags, &prophdl) 1455 != PICL_SUCCESS) { 1456 freeup(nodehdl); 1457 return (PICL_FAILURE); 1458 } 1459 1460 if (create_packet_table(nodehdl, &tblhdl) != PICL_SUCCESS) { 1461 freeup(nodehdl); 1462 return (PICL_FAILURE); 1463 } 1464 1465 retval = ptree_get_propval_by_name(sec_node, 1466 PICL_PROP_PROTECTED, &protection, sizeof (uint32_t)); 1467 if (retval != PICL_SUCCESS) { 1468 freeup(nodehdl); 1469 return (PICL_FAILURE); 1470 } 1471 1472 if (protection == 0) { /* to be added only read/write section */ 1473 /* delete segment volatile property */ 1474 prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT; 1475 prop.piclinfo.size = sizeof (uint32_t); 1476 prop.piclinfo.accessmode = PICL_WRITE|PICL_VOLATILE; 1477 prop.write = frudata_delete_segment; 1478 prop.read = frudata_read_callback; 1479 1480 (void) strcpy(prop.piclinfo.name, PICL_PROP_DELETE_SEGMENT); 1481 if (ptree_create_and_add_prop(nodehdl, &prop, NULL, &prophdl) 1482 != PICL_SUCCESS) { 1483 freeup(nodehdl); 1484 return (PICL_FAILURE); 1485 } 1486 1487 1488 /* add packet volatile property */ 1489 prop.piclinfo.type = PICL_PTYPE_BYTEARRAY; 1490 prop.piclinfo.size = segment->length; /* segment length */ 1491 prop.piclinfo.accessmode = PICL_READ|PICL_WRITE|PICL_VOLATILE; 1492 prop.read = frudata_read_callback; 1493 prop.write = frudata_add_packet; 1494 1495 (void) strcpy(prop.piclinfo.name, PICL_PROP_ADD_PACKET); 1496 if (ptree_create_and_add_prop(nodehdl, &prop, NULL, &prophdl) 1497 != PICL_SUCCESS) { 1498 freeup(nodehdl); 1499 return (PICL_FAILURE); 1500 } 1501 } 1502 1503 if (ptree_add_node(sec_node, nodehdl) != PICL_SUCCESS) { 1504 freeup(nodehdl); 1505 return (PICL_FAILURE); 1506 } 1507 1508 hash_obj = alloc_segment_node_object(nodehdl, segment); 1509 if (hash_obj == NULL) { 1510 freeup(nodehdl); 1511 return (PICL_FAILURE); 1512 } 1513 1514 add_nodeobject_to_hashtable(hash_obj, cont_tbl); 1515 1516 add_to_segment_list(sec_obj, hash_obj); 1517 1518 retval = frudata_read_packet(nodehdl, &tblhdl, cont_tbl, cred); 1519 if (retval != 0) { 1520 return (PICL_SUCCESS); 1521 } 1522 1523 (void) ptree_update_propval_by_name(nodehdl, PICL_PROP_NUM_TAGS, 1524 &hash_obj->u.seg_node->num_of_pkt, sizeof (uint32_t)); 1525 1526 return (PICL_SUCCESS); 1527 } 1528 1529 /* 1530 * Description :frudata_read_segment is called when num_segment volatile 1531 * property is accessed. 1532 * 1533 * Arguments : ptree_rarg_t contains node handle of the section node. 1534 * and property node of num_segments. 1535 * void * will hold number of segment. 1536 * 1537 * Returns : PICL_SUCCESS on success. 1538 * PICL_FAILURE on failure. 1539 */ 1540 1541 static int 1542 frudata_read_segment(ptree_rarg_t *rarg, void *buf) 1543 { 1544 int num_of_segment; 1545 int cnt; 1546 int retval; 1547 segment_t *segment; 1548 hash_obj_t *hash_obj; 1549 fru_segdesc_t *desc; 1550 fru_access_hdl_t sec_acc_hdl; 1551 container_tbl_t *cont_tbl; 1552 1553 cont_tbl = lock_container_lock(rarg->nodeh, SECTION_NODE, PICL_READ); 1554 if (!cont_tbl) { 1555 return (PICL_FAILURE); 1556 } 1557 1558 hash_obj = lookup_node_object(rarg->nodeh, SECTION_NODE, cont_tbl); 1559 if (hash_obj == NULL) { 1560 unlock_container_lock(cont_tbl); 1561 return (PICL_FAILURE); 1562 } 1563 1564 if (hash_obj->u.sec_node->num_of_segment == -1) { 1565 sec_acc_hdl = hash_obj->u.sec_node->section_hdl; 1566 1567 hash_obj->u.sec_node->num_of_segment = 0; 1568 1569 num_of_segment = fru_get_num_segments(sec_acc_hdl, 1570 &rarg->cred); 1571 if (num_of_segment < 0) { 1572 *(int *)buf = 0; 1573 unlock_container_lock(cont_tbl); 1574 return (PICL_FAILURE); 1575 } 1576 1577 if (num_of_segment == 0) { 1578 *(int *)buf = 0; 1579 unlock_container_lock(cont_tbl); 1580 return (PICL_SUCCESS); 1581 } 1582 1583 segment = alloca(sizeof (segment_t) * num_of_segment); 1584 if (segment == NULL) { 1585 *(int *)buf = 0; 1586 unlock_container_lock(cont_tbl); 1587 return (PICL_SUCCESS); 1588 } 1589 1590 retval = fru_get_segments(sec_acc_hdl, segment, 1591 num_of_segment, &rarg->cred); 1592 if (retval == -1) { 1593 *(int *)buf = 0; 1594 unlock_container_lock(cont_tbl); 1595 return (PICL_SUCCESS); 1596 } 1597 1598 for (cnt = 0; cnt < num_of_segment; cnt++) { 1599 1600 desc = (fru_segdesc_t *)&segment[cnt].descriptor; 1601 if (!(desc->field.field_perm & SEGMENT_READ)) { 1602 continue; 1603 } 1604 1605 /* if opaque segment don't create segment node */ 1606 if (desc->field.opaque) { 1607 continue; 1608 } 1609 (void) create_segment_node(hash_obj, rarg->nodeh, 1610 &segment[cnt], cont_tbl, &rarg->cred); 1611 hash_obj->u.sec_node->num_of_segment++; 1612 } 1613 } 1614 1615 /* return number of segment in the section */ 1616 *(int *)buf = hash_obj->u.sec_node->num_of_segment; 1617 1618 unlock_container_lock(cont_tbl); 1619 1620 return (PICL_SUCCESS); 1621 } 1622 1623 1624 /* 1625 * Description : frudata_add_segment is called when volatile property 1626 * add_segment under class node section is accessed. 1627 * 1628 * Arguments : ptree_warg_t holds node handle for the section node. 1629 * property handle for the add_segment property. 1630 * 1631 * Returns : PICL_SUCCESS on success. 1632 * PICL_FAILURE on failure. 1633 */ 1634 1635 static int 1636 frudata_add_segment(ptree_warg_t *warg, const void *buf) 1637 { 1638 int retval; 1639 int cnt; 1640 int num_of_segment; 1641 segment_t *seg_buf; 1642 segment_t segment; 1643 hash_obj_t *seg_hash; 1644 hash_obj_t *hash_obj; 1645 container_tbl_t *cont_tbl; 1646 fru_segdef_t *seg_def; 1647 fru_segdesc_t *desc; 1648 fru_access_hdl_t new_sec_acc_hdl; 1649 1650 seg_def = (fru_segdef_t *)buf; 1651 1652 /* initialize segment_t */ 1653 segment.handle = 0; 1654 (void) memcpy(segment.name, seg_def->name, SEG_NAME_LEN); 1655 segment.descriptor = seg_def->desc.raw_data; 1656 segment.length = seg_def->size; /* segment length */ 1657 segment.offset = seg_def->address; /* segment offset */ 1658 1659 desc = (fru_segdesc_t *)&segment.descriptor; 1660 if (!(desc->field.field_perm & SEGMENT_READ)) { 1661 return (PICL_PERMDENIED); 1662 } 1663 1664 cont_tbl = lock_container_lock(warg->nodeh, SECTION_NODE, PICL_WRITE); 1665 if (!cont_tbl) { 1666 return (PICL_FAILURE); 1667 } 1668 1669 hash_obj = lookup_node_object(warg->nodeh, SECTION_NODE, cont_tbl); 1670 if (hash_obj == NULL) { 1671 unlock_container_lock(cont_tbl); 1672 return (PICL_FAILURE); 1673 } 1674 1675 /* call fruaccess module, get the new section handle. */ 1676 retval = fru_add_segment(hash_obj->u.sec_node->section_hdl, 1677 &segment, &new_sec_acc_hdl, &warg->cred); 1678 if (retval == -1) { 1679 unlock_container_lock(cont_tbl); 1680 return (map_access_err(errno)); 1681 } 1682 1683 /* call access module with new section handle */ 1684 num_of_segment = fru_get_num_segments(new_sec_acc_hdl, &warg->cred); 1685 1686 seg_buf = alloca(sizeof (segment_t) * num_of_segment); 1687 if (seg_buf == NULL) { 1688 unlock_container_lock(cont_tbl); 1689 return (PICL_FAILURE); 1690 } 1691 1692 retval = fru_get_segments(new_sec_acc_hdl, seg_buf, 1693 num_of_segment, &warg->cred); 1694 if (retval == -1) { 1695 unlock_container_lock(cont_tbl); 1696 return (PICL_FAILURE); 1697 } 1698 1699 segment.offset = seg_buf[(num_of_segment -1)].offset; 1700 segment.handle = seg_buf[(num_of_segment-1)].handle; 1701 1702 (void) create_segment_node(hash_obj, warg->nodeh, &segment, 1703 cont_tbl, &warg->cred); 1704 1705 /* rebuild segment list */ 1706 seg_hash = hash_obj->u.sec_node->segment_list; 1707 if (seg_hash == NULL) { 1708 unlock_container_lock(cont_tbl); 1709 return (PICL_FAILURE); 1710 } 1711 1712 hash_obj->u.sec_node->num_of_segment = 0; 1713 1714 for (cnt = 0; cnt < num_of_segment; cnt++) { 1715 desc = (fru_segdesc_t *)&seg_buf[cnt].descriptor; 1716 if (!(desc->field.field_perm & SEGMENT_READ)) { 1717 continue; 1718 } 1719 1720 /* if opaque segment don't create segment node */ 1721 if (desc->field.opaque) { 1722 continue; 1723 } 1724 1725 seg_hash->u.seg_node->segment_hdl = 1726 seg_buf[cnt].handle; 1727 seg_hash = seg_hash->u.seg_node->next; 1728 hash_obj->u.sec_node->num_of_segment++; 1729 } 1730 1731 /* update with new section handle */ 1732 hash_obj->u.sec_node->section_hdl = new_sec_acc_hdl; 1733 1734 unlock_container_lock(cont_tbl); 1735 1736 return (PICL_SUCCESS); 1737 } 1738 1739 /* 1740 * called from frudata_write_section() callback routine to create 1741 * section node and all the property under class section. it also 1742 * allocate hash node object for each section in the container and 1743 * add the section node object in the section list. 1744 */ 1745 1746 static int 1747 create_section_node(picl_nodehdl_t nodehdl, int section_count, 1748 section_t *section, container_tbl_t *cont_tbl) 1749 { 1750 char sec_name[SECNAMESIZE]; 1751 hash_obj_t *hash_obj; 1752 hash_obj_t *cont_hash; 1753 picl_nodehdl_t chld_node; 1754 picl_prophdl_t prophdl; 1755 ptree_propinfo_t prop; 1756 1757 (void) snprintf(sec_name, SECNAMESIZE, "section%d", section_count); 1758 1759 if (ptree_create_node(sec_name, PICL_CLASS_SECTION, &chld_node) 1760 != PICL_SUCCESS) { 1761 return (PICL_FAILURE); 1762 } 1763 prop.version = PTREE_PROPINFO_VERSION; 1764 prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT; 1765 prop.piclinfo.accessmode = PICL_READ; 1766 prop.piclinfo.size = sizeof (uint32_t); 1767 prop.read = NULL; 1768 prop.write = NULL; 1769 1770 /* offset */ 1771 (void) strcpy(prop.piclinfo.name, PICL_PROP_OFFSET); 1772 if (ptree_create_and_add_prop(chld_node, &prop, §ion->offset, 1773 &prophdl) != PICL_SUCCESS) { 1774 freeup(chld_node); 1775 return (PICL_FAILURE); 1776 } 1777 1778 /* length */ 1779 (void) strcpy(prop.piclinfo.name, PICL_PROP_LENGTH); 1780 if (ptree_create_and_add_prop(chld_node, &prop, §ion->length, 1781 &prophdl) != PICL_SUCCESS) { 1782 freeup(chld_node); 1783 return (PICL_FAILURE); 1784 } 1785 1786 1787 /* protected */ 1788 (void) strcpy(prop.piclinfo.name, PICL_PROP_PROTECTED); 1789 if (ptree_create_and_add_prop(chld_node, &prop, §ion->protection, 1790 &prophdl) != PICL_SUCCESS) { 1791 freeup(chld_node); 1792 return (PICL_FAILURE); 1793 } 1794 1795 prop.piclinfo.accessmode = PICL_READ|PICL_VOLATILE; 1796 prop.read = frudata_read_segment; 1797 1798 (void) strcpy(prop.piclinfo.name, PICL_PROP_NUM_SEGMENTS); 1799 1800 if (ptree_create_and_add_prop(chld_node, &prop, NULL, &prophdl) 1801 != PICL_SUCCESS) { 1802 freeup(chld_node); 1803 return (PICL_FAILURE); 1804 } 1805 1806 1807 prop.piclinfo.type = PICL_PTYPE_BYTEARRAY; 1808 prop.piclinfo.size = sizeof (fru_segdef_t); 1809 1810 prop.piclinfo.accessmode = PICL_WRITE|PICL_READ|PICL_VOLATILE; 1811 prop.write = frudata_add_segment; /* callback routine */ 1812 prop.read = frudata_read_callback; 1813 1814 (void) strcpy(prop.piclinfo.name, PICL_PROP_ADD_SEGMENT); 1815 /* add-segment prop if read/write section */ 1816 if (section->protection == 0) { 1817 if (ptree_create_and_add_prop(chld_node, &prop, NULL, &prophdl) 1818 != PICL_SUCCESS) { 1819 freeup(chld_node); 1820 return (PICL_FAILURE); 1821 } 1822 } 1823 1824 if (ptree_add_node(nodehdl, chld_node) != PICL_SUCCESS) { 1825 freeup(chld_node); 1826 return (PICL_FAILURE); 1827 } 1828 1829 /* lookup for container handle */ 1830 cont_hash = lookup_node_object(nodehdl, CONTAINER_NODE, cont_tbl); 1831 if (cont_hash == NULL) { 1832 freeup(chld_node); 1833 return (PICL_FAILURE); 1834 } 1835 1836 hash_obj = alloc_section_node_object(chld_node, section); 1837 if (hash_obj == NULL) { 1838 freeup(chld_node); 1839 return (PICL_FAILURE); 1840 } 1841 1842 add_nodeobject_to_hashtable(hash_obj, cont_tbl); 1843 1844 add_to_section_list(cont_hash, hash_obj); 1845 return (PICL_SUCCESS); 1846 } 1847 1848 1849 /* 1850 * Description :frudata_write_section is called when volatile container 1851 * property is accessed. it reads the section table associated 1852 * with the specified node handle(container) in ptree_rarg_t. 1853 * it calls search_root_node to search the node handle to open the 1854 * device associated with the node handle. it creates section 1855 * node and it's associated property. it also creates 1856 * volatile property num_segments. 1857 * 1858 * Argument : ptree_rarg_t : contains node handle of fru container the 1859 * container. 1860 * property handle of the container. 1861 * 1862 * Return : PICL_SUCCESS on success. 1863 * 1864 */ 1865 1866 /* ARGSUSED */ 1867 1868 static int 1869 frudata_write_section(ptree_warg_t *warg, const void *buf) 1870 { 1871 int retval; 1872 int num_of_section; 1873 int count; 1874 section_t *section; 1875 hash_obj_t *hash_obj; 1876 container_tbl_t *cont_tbl = NULL; 1877 fru_access_hdl_t cont_acc_hdl; 1878 1879 (void) pthread_mutex_lock(&cont_tbl_lock); 1880 1881 /* 1882 * if lookup succeed return from this function with PICL_SUCCESS 1883 * because first write operation has already occurred on this container, 1884 * it also means that the container has been already initialzed. 1885 */ 1886 1887 cont_tbl = lookup_container_table(warg->nodeh, CONTAINER_NODE); 1888 if (cont_tbl != NULL) { /* found the hash obj in the hash table */ 1889 (void) pthread_mutex_unlock(&cont_tbl_lock); 1890 return (PICL_SUCCESS); 1891 } 1892 1893 /* 1894 * lookup failed that means this is first write on the 1895 * container property. allocate a new container hash table for this 1896 * new container and add to the cont_tbl hash table. 1897 */ 1898 1899 cont_tbl = alloc_container_table(warg->nodeh); 1900 if (cont_tbl == NULL) { 1901 (void) pthread_mutex_unlock(&cont_tbl_lock); 1902 return (map_access_err(errno)); 1903 } 1904 1905 hash_obj = alloc_container_node_object(warg->nodeh); 1906 if (hash_obj == NULL) { 1907 (void) pthread_mutex_unlock(&cont_tbl_lock); 1908 free(cont_tbl->hash_obj); 1909 free(cont_tbl); 1910 return (map_access_err(errno)); 1911 } 1912 1913 /* add container table object to container table */ 1914 add_tblobject_to_container_tbl(cont_tbl); 1915 1916 /* add the hash object to container hash table. */ 1917 add_nodeobject_to_hashtable(hash_obj, cont_tbl); 1918 1919 while (pthread_rwlock_trywrlock(&cont_tbl->rwlock) == EBUSY) { 1920 pthread_cond_wait(&cont_tbl->cond_var, &cont_tbl_lock); 1921 } 1922 1923 (void) pthread_mutex_unlock(&cont_tbl_lock); 1924 1925 /* fruaccess handle */ 1926 cont_acc_hdl = hash_obj->u.cont_node->cont_hdl; 1927 1928 num_of_section = fru_get_num_sections(cont_acc_hdl, &warg->cred); 1929 1930 if (num_of_section == -1) { 1931 free(hash_obj); 1932 unlock_container_lock(cont_tbl); 1933 return (PICL_FAILURE); 1934 } 1935 1936 section = alloca(num_of_section * sizeof (section_t)); 1937 1938 retval = fru_get_sections(cont_acc_hdl, section, 1939 num_of_section, &warg->cred); 1940 if (retval == -1) { 1941 free(hash_obj); 1942 unlock_container_lock(cont_tbl); 1943 return (PICL_FAILURE); 1944 } 1945 1946 hash_obj->u.cont_node->num_of_section = num_of_section; 1947 1948 for (count = 0; count < num_of_section; count++) { 1949 (void) create_section_node(warg->nodeh, count, 1950 section + count, cont_tbl); 1951 } 1952 1953 unlock_container_lock(cont_tbl); 1954 1955 return (PICL_SUCCESS); 1956 } 1957 1958 /* create container and add-segment property */ 1959 1960 static int 1961 create_container_prop(picl_nodehdl_t fruhdl) 1962 { 1963 int retval; 1964 picl_prophdl_t prophdl; 1965 ptree_propinfo_t prop; 1966 1967 prop.version = PTREE_PROPINFO_VERSION; 1968 prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT; 1969 prop.piclinfo.size = sizeof (uint32_t); 1970 prop.piclinfo.accessmode = PICL_WRITE|PICL_VOLATILE; 1971 (void) strcpy(prop.piclinfo.name, PICL_PROP_CONTAINER); 1972 prop.read = frudata_read_callback; 1973 prop.write = frudata_write_section; /* callback routine */ 1974 1975 /* create a property */ 1976 retval = ptree_create_and_add_prop(fruhdl, &prop, NULL, &prophdl); 1977 1978 return (retval); 1979 } 1980 1981 /* search for FRUDataAvailable and create container and add segment property */ 1982 1983 static void 1984 create_frudata_props(picl_prophdl_t fruhdl) 1985 { 1986 int retval; 1987 picl_nodehdl_t chldhdl; 1988 picl_nodehdl_t tmphdl; 1989 1990 for (retval = ptree_get_propval_by_name(fruhdl, PICL_PROP_CHILD, 1991 &chldhdl, sizeof (picl_nodehdl_t)); retval != PICL_PROPNOTFOUND; 1992 retval = ptree_get_propval_by_name(chldhdl, PICL_PROP_PEER, 1993 &chldhdl, sizeof (picl_nodehdl_t))) { 1994 if (retval != PICL_SUCCESS) 1995 return; 1996 1997 /* Does it have a FRUDataAvailable property */ 1998 retval = ptree_get_prop_by_name(chldhdl, 1999 PICL_PROP_FRUDATA_AVAIL, &tmphdl); 2000 if (retval == PICL_SUCCESS) { 2001 (void) create_container_prop(chldhdl); 2002 } 2003 2004 /* Traverse tree recursively */ 2005 (void) create_frudata_props(chldhdl); 2006 } 2007 } 2008 2009 /* 2010 * Search for the frutree config file from the platform specific 2011 * directory to the common directory. 2012 * 2013 * The size of outfilename must be PATH_MAX 2014 */ 2015 static int 2016 get_config_file(char *outfilename) 2017 { 2018 char nmbuf[SYS_NMLN]; 2019 char pname[PATH_MAX]; 2020 2021 if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) { 2022 (void) snprintf(pname, PATH_MAX, FRUDATA_CONFFILE_NAME, nmbuf); 2023 if (access(pname, R_OK) == 0) { 2024 (void) strlcpy(outfilename, pname, PATH_MAX); 2025 return (0); 2026 } 2027 } 2028 2029 if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) { 2030 (void) snprintf(pname, PATH_MAX, FRUDATA_CONFFILE_NAME, nmbuf); 2031 if (access(pname, R_OK) == 0) { 2032 (void) strlcpy(outfilename, pname, PATH_MAX); 2033 return (0); 2034 } 2035 } 2036 2037 (void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR, 2038 FRUDATA_CONFFILE_NAME); 2039 if (access(pname, R_OK) == 0) { 2040 (void) strlcpy(outfilename, pname, PATH_MAX); 2041 return (0); 2042 } 2043 return (-1); 2044 } 2045 2046 /* 2047 * called from delete_frudata_props(), this routine delete the section node 2048 * and free's the section hash object. it calls free_segment_node() to 2049 * delete segment node beneath it. 2050 */ 2051 2052 static void 2053 free_section_node(hash_obj_t *sec_hash, container_tbl_t *cont_tbl) 2054 { 2055 hash_obj_t *seg_hash; 2056 2057 for (seg_hash = sec_hash->u.sec_node->segment_list; seg_hash != NULL; 2058 seg_hash = seg_hash->u.seg_node->next) { 2059 free_segment_node(seg_hash, seg_hash->picl_hdl, cont_tbl); 2060 } 2061 2062 if (sec_hash->prev == NULL) { 2063 cont_tbl->hash_obj[(sec_hash->picl_hdl % TABLE_SIZE)].next = 2064 sec_hash->next; 2065 if (sec_hash->next != NULL) { 2066 sec_hash->next->prev = NULL; 2067 } 2068 } else { 2069 sec_hash->prev->next = sec_hash->next; 2070 if (sec_hash->next != NULL) { 2071 sec_hash->next->prev = sec_hash->prev; 2072 } 2073 } 2074 2075 /* delete & destroy section node */ 2076 (void) ptree_delete_node(sec_hash->picl_hdl); 2077 (void) ptree_destroy_node(sec_hash->picl_hdl); 2078 2079 free(sec_hash->u.sec_node); 2080 free(sec_hash); 2081 } 2082 2083 /* 2084 * called from delete_frudata_props(), this routine free's the container 2085 * hash object. 2086 */ 2087 2088 static void 2089 unlink_container_node(container_tbl_t *cont_hash) 2090 { 2091 if (cont_hash->prev == NULL) { 2092 container_table[(cont_hash->picl_hdl % TABLE_SIZE)] = 2093 cont_hash->next; 2094 if (cont_hash->next != NULL) { 2095 cont_hash->next->prev = NULL; 2096 } 2097 } else { 2098 cont_hash->prev->next = cont_hash->next; 2099 if (cont_hash->next != NULL) { 2100 cont_hash->next->prev = cont_hash->prev; 2101 } 2102 } 2103 } 2104 2105 /* 2106 * called from frudata_event_handler() to free the corresponding hash object 2107 * of the removed fru. 2108 */ 2109 2110 static void 2111 delete_frudata_props(picl_nodehdl_t fru_hdl) 2112 { 2113 hash_obj_t *cont_hash; 2114 hash_obj_t *free_obj; 2115 hash_obj_t *sec_hash; 2116 container_tbl_t *cont_tbl; 2117 2118 (void) pthread_mutex_lock(&cont_tbl_lock); 2119 2120 cont_tbl = lookup_container_table(fru_hdl, CONTAINER_NODE); 2121 if (cont_tbl == NULL) { 2122 (void) pthread_mutex_unlock(&cont_tbl_lock); 2123 return; 2124 } 2125 2126 /* remove the container object from the container table */ 2127 unlink_container_node(cont_tbl); 2128 2129 (void) pthread_cond_broadcast(&cont_tbl->cond_var); 2130 2131 (void) pthread_mutex_unlock(&cont_tbl_lock); 2132 2133 /* 2134 * waiting/blocking calling thread for all I/O in 2135 * progress to complete. don't free the container 2136 * hash before all I/O is complete. 2137 */ 2138 (void) pthread_rwlock_wrlock(&cont_tbl->rwlock); 2139 2140 (void) pthread_rwlock_unlock(&cont_tbl->rwlock); 2141 2142 2143 cont_hash = lookup_node_object(fru_hdl, CONTAINER_NODE, cont_tbl); 2144 if (cont_hash == NULL) { 2145 return; 2146 } 2147 2148 free_obj = cont_hash->u.cont_node->section_list; 2149 /* walk through the section list */ 2150 for (sec_hash = free_obj; sec_hash != NULL; free_obj = sec_hash) { 2151 sec_hash = sec_hash->u.sec_node->next; 2152 free_section_node(free_obj, cont_tbl); 2153 } 2154 (void) fru_close_container(cont_hash->u.cont_node->cont_hdl); 2155 2156 free(cont_hash->u.cont_node); 2157 free(cont_hash); 2158 2159 free(cont_tbl->hash_obj); 2160 free(cont_tbl); 2161 } 2162 2163 /* 2164 * called when there is any state-change in location, fru, port nodes. 2165 * this event handler handles only location state-changes. 2166 */ 2167 /* ARGSUSED */ 2168 static void 2169 frudata_state_change_evhandler(const char *event_name, const void *event_arg, 2170 size_t size, void *cookie) 2171 { 2172 int rc; 2173 nvlist_t *nvlp; 2174 ptree_propinfo_t prop; 2175 picl_nodehdl_t loch, fruh; 2176 picl_prophdl_t proph, prophdl; 2177 char *present_state, *last_state; 2178 char name[PICL_PROPNAMELEN_MAX]; 2179 2180 if (strcmp(event_name, PICLEVENT_STATE_CHANGE) != 0) 2181 return; 2182 2183 if (nvlist_unpack((char *)event_arg, size, &nvlp, NULL)) { 2184 return; 2185 } 2186 2187 if (nvlist_lookup_uint64(nvlp, PICLEVENTARG_NODEHANDLE, 2188 &loch) == -1) { 2189 nvlist_free(nvlp); 2190 return; 2191 } 2192 2193 if (ptree_get_propval_by_name(loch, PICL_PROP_CLASSNAME, name, 2194 sizeof (name)) != PICL_SUCCESS) { 2195 nvlist_free(nvlp); 2196 return; 2197 } 2198 2199 /* handle only location events */ 2200 if (strcmp(name, PICL_CLASS_LOCATION) != 0) { 2201 nvlist_free(nvlp); 2202 return; 2203 } 2204 2205 if (nvlist_lookup_string(nvlp, PICLEVENTARG_STATE, 2206 &present_state)) { 2207 nvlist_free(nvlp); 2208 return; 2209 } 2210 2211 rc = ptree_get_propval_by_name(loch, PICL_PROP_CHILD, 2212 &fruh, sizeof (picl_nodehdl_t)); 2213 if (rc != PICL_SUCCESS) { 2214 nvlist_free(nvlp); 2215 return; 2216 } 2217 2218 /* fru removed */ 2219 if (strcmp(present_state, PICLEVENTARGVAL_EMPTY) == 0) { 2220 delete_frudata_props(fruh); 2221 nvlist_free(nvlp); 2222 return; 2223 } 2224 2225 if (nvlist_lookup_string(nvlp, PICLEVENTARG_LAST_STATE, 2226 &last_state)) { 2227 nvlist_free(nvlp); 2228 return; 2229 } 2230 2231 /* fru added */ 2232 if ((strcmp(last_state, PICLEVENTARGVAL_EMPTY) == 0) || 2233 (strcmp(last_state, PICLEVENTARGVAL_UNKNOWN) == 0)) { 2234 rc = ptree_get_prop_by_name(fruh, PICL_PROP_FRUDATA_AVAIL, 2235 &proph); 2236 if (rc != PICL_SUCCESS) { 2237 if (fru_is_data_available(fruh) == 0) { 2238 nvlist_free(nvlp); 2239 return; 2240 } 2241 /* create the property */ 2242 prop.version = PTREE_PROPINFO_VERSION; 2243 prop.piclinfo.type = PICL_PTYPE_VOID; 2244 prop.piclinfo.accessmode = PICL_READ; 2245 prop.piclinfo.size = 0; 2246 (void) strncpy(prop.piclinfo.name, 2247 PICL_PROP_FRUDATA_AVAIL, 2248 sizeof (prop.piclinfo.name)); 2249 2250 rc = ptree_create_prop(&prop, NULL, &prophdl); 2251 if (rc != PICL_SUCCESS) { 2252 nvlist_free(nvlp); 2253 return; 2254 } 2255 rc = ptree_add_prop(fruh, prophdl); 2256 if (rc != PICL_SUCCESS) { 2257 nvlist_free(nvlp); 2258 return; 2259 } 2260 } 2261 (void) create_container_prop(fruh); 2262 } 2263 nvlist_free(nvlp); 2264 } 2265 2266 /* 2267 * called when event is posted when is fru is either added or removed from 2268 * the picltree. 2269 */ 2270 2271 /* ARGSUSED */ 2272 static void 2273 frudata_event_handler(const char *event_name, const void *event_arg, 2274 size_t size, void *cookie) 2275 { 2276 int retval; 2277 char fullfilename[PATH_MAX]; 2278 picl_nodehdl_t fru_picl_hdl; 2279 picl_nodehdl_t roothdl; 2280 2281 if (strcmp(event_name, PICL_FRU_REMOVED) == 0) { 2282 2283 retval = nvlist_lookup_uint64((nvlist_t *)event_arg, 2284 PICLEVENTARG_FRUHANDLE, &fru_picl_hdl); 2285 if (retval != PICL_SUCCESS) { 2286 return; 2287 } 2288 2289 /* free the hash object */ 2290 delete_frudata_props(fru_picl_hdl); 2291 2292 } else if (strcmp(event_name, PICL_FRU_ADDED) == 0) { 2293 /* 2294 * reparse the configuration file to create 2295 * FRUDevicePath Prop. 2296 */ 2297 (void) get_config_file(fullfilename); 2298 retval = ptree_get_root(&roothdl); 2299 if (retval != PICL_SUCCESS) { 2300 return; 2301 } 2302 2303 (void) picld_pluginutil_parse_config_file(roothdl, 2304 fullfilename); 2305 2306 retval = nvlist_lookup_uint64((nvlist_t *)event_arg, 2307 PICLEVENTARG_PARENTHANDLE, &fru_picl_hdl); 2308 if (retval != PICL_SUCCESS) { 2309 return; 2310 } 2311 2312 /* create container property */ 2313 create_frudata_props(fru_picl_hdl); 2314 } 2315 } 2316 2317 /* 2318 * Function : plugin_init() is called by daemon. this routine is specified 2319 * while registering with daemon. it performs the initialization 2320 * of plugin module. 2321 */ 2322 2323 static void 2324 frudata_plugin_init(void) 2325 { 2326 int retval; 2327 int count; 2328 char fullfilename[PATH_MAX]; 2329 picl_nodehdl_t fru_nodehdl; 2330 picl_nodehdl_t roothdl; 2331 2332 retval = ptree_get_root(&roothdl); 2333 if (retval != PICL_SUCCESS) { 2334 return; 2335 } 2336 2337 (void) ptree_register_handler(PICL_FRU_ADDED, 2338 frudata_event_handler, NULL); 2339 2340 (void) ptree_register_handler(PICL_FRU_REMOVED, 2341 frudata_event_handler, NULL); 2342 2343 (void) ptree_register_handler(PICLEVENT_STATE_CHANGE, 2344 frudata_state_change_evhandler, NULL); 2345 2346 (void) pthread_mutex_lock(&cont_tbl_lock); 2347 for (count = 0; count < TABLE_SIZE; count++) { 2348 container_table[count] = NULL; 2349 } 2350 (void) pthread_mutex_unlock(&cont_tbl_lock); 2351 2352 (void) get_config_file(fullfilename); 2353 2354 (void) picld_pluginutil_parse_config_file(roothdl, fullfilename); 2355 2356 retval = ptree_get_node_by_path(FRUTREE_PATH, &fru_nodehdl); 2357 2358 if (retval != PICL_SUCCESS) { 2359 return; 2360 } 2361 2362 create_frudata_props(fru_nodehdl); 2363 2364 } 2365 2366 static void 2367 free_packet_hash_object(hash_obj_t *pkt_obj) 2368 { 2369 hash_obj_t *tmp_obj; 2370 2371 while (pkt_obj != NULL) { 2372 tmp_obj = pkt_obj->u.pkt_node->next; 2373 free(pkt_obj->u.pkt_node); 2374 free(pkt_obj); 2375 pkt_obj = tmp_obj; 2376 } 2377 } 2378 2379 static void 2380 free_segment_hash_object(hash_obj_t *seg_obj) 2381 { 2382 hash_obj_t *tmp_obj; 2383 2384 while (seg_obj != NULL) { 2385 free_packet_hash_object(seg_obj->u.seg_node->packet_list); 2386 tmp_obj = seg_obj->u.seg_node->next; 2387 free(seg_obj->u.seg_node); 2388 free(seg_obj); 2389 seg_obj = tmp_obj; 2390 } 2391 } 2392 2393 static void 2394 free_hash_objects(hash_obj_t *sec_obj) 2395 { 2396 hash_obj_t *tmp_obj; 2397 2398 while (sec_obj != NULL) { 2399 free_segment_hash_object(sec_obj->u.sec_node->segment_list); 2400 tmp_obj = sec_obj->u.sec_node->next; 2401 free(sec_obj->u.sec_node); 2402 free(sec_obj); 2403 sec_obj = tmp_obj; 2404 } 2405 } 2406 2407 /* 2408 * called from frudata_plugin_fini() this routine walks through 2409 * the hash table to free each and very hash object in the hash table. 2410 */ 2411 2412 static void 2413 free_hash_table(void) 2414 { 2415 int cnt; 2416 picl_nodehdl_t nodehdl; 2417 hash_obj_t *next_obj; 2418 hash_obj_t *sec_obj; 2419 container_tbl_t *cont_tbl; 2420 2421 for (cnt = 0; cnt < TABLE_SIZE; cnt++) { 2422 2423 while (container_table[cnt]) { 2424 2425 (void) pthread_mutex_lock(&cont_tbl_lock); 2426 2427 cont_tbl = container_table[cnt]; 2428 nodehdl = cont_tbl->picl_hdl; 2429 2430 cont_tbl = lookup_container_table(nodehdl, 2431 CONTAINER_NODE); 2432 if (cont_tbl == NULL) { 2433 (void) pthread_mutex_unlock(&cont_tbl_lock); 2434 break; 2435 } 2436 2437 unlink_container_node(cont_tbl); 2438 2439 pthread_cond_broadcast(&cont_tbl->cond_var); 2440 2441 (void) pthread_mutex_unlock(&cont_tbl_lock); 2442 2443 /* 2444 * waiting/blocking calling thread for all I/O in 2445 * progress to complete. don't free the container 2446 * hash until all I/O is complete. 2447 */ 2448 (void) pthread_rwlock_wrlock(&cont_tbl->rwlock); 2449 2450 (void) pthread_rwlock_unlock(&cont_tbl->rwlock); 2451 2452 next_obj = cont_tbl->hash_obj->next; 2453 if (next_obj == NULL) { 2454 break; 2455 } 2456 2457 if (next_obj->object_type == CONTAINER_NODE) { 2458 sec_obj = next_obj->u.cont_node->section_list; 2459 free_hash_objects(sec_obj); 2460 } 2461 2462 free(next_obj->u.cont_node); 2463 free(next_obj); 2464 container_table[cnt] = cont_tbl->next; 2465 2466 free(cont_tbl); 2467 } 2468 } 2469 } 2470 2471 /* 2472 * called by the daemon and perform frudata cleanup. hold the write lock 2473 * over the entire hash table to free each and every hash object. 2474 */ 2475 2476 static void 2477 frudata_plugin_fini(void) 2478 { 2479 2480 free_hash_table(); 2481 2482 (void) ptree_unregister_handler(PICL_FRU_ADDED, 2483 frudata_event_handler, NULL); 2484 2485 (void) ptree_unregister_handler(PICL_FRU_REMOVED, 2486 frudata_event_handler, NULL); 2487 2488 (void) ptree_unregister_handler(PICLEVENT_STATE_CHANGE, 2489 frudata_state_change_evhandler, NULL); 2490 } 2491