fru_data.c revision 161c3e5a3e36266bace5970ff96ffec158570b08
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <picl.h>
#include <syslog.h>
#include <strings.h>
#include <alloca.h>
#include <pthread.h>
#include <synch.h>
#include <limits.h>
#include <ctype.h>
#include <unistd.h>
#include <picltree.h>
#include <signal.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <libnvpair.h>
#include "fru_tag.h"
#include "fru_data_impl.h"
#include "fru_data.h"
#include "picld_pluginutil.h"
#pragma init(frudata_plugin_register) /* .init section */
static void frudata_plugin_init(void);
static void frudata_plugin_fini(void);
static container_tbl_t *container_table[TABLE_SIZE];
/*
* Locking Stragtegy :
* calling thread should hold the cont_tbl_lock during the course
* of container table lookup. release the cont_tbl_lock on lookup
* failure or on the condition wait.
*
* thread holding the container object rwlock should release lock
* and signal to unblock threads blocked on the condition variable
* upon i/o completion.
*
*/
static pthread_mutex_t cont_tbl_lock = PTHREAD_MUTEX_INITIALIZER;
static int add_row_to_table(hash_obj_t *, picl_nodehdl_t,
packet_t *, container_tbl_t *);
static picld_plugin_reg_t frudata_reg_info = {
PICLD_PLUGIN_VERSION_1,
PICLD_PLUGIN_NON_CRITICAL,
"SUNW_piclfrudata",
frudata_plugin_init, /* init entry point */
frudata_plugin_fini /* cleanup entry point */
};
/* initialization function */
static void
frudata_plugin_register(void)
{
/* register plugin with daemon */
if (picld_plugin_register(&frudata_reg_info) != PICL_SUCCESS) {
syslog(LOG_ERR, "SUNW_piclfrudata plugin registration failed");
}
}
static int
map_access_err(int err)
{
switch (err) {
case ENFILE :
return (PICL_PROPEXISTS);
case EAGAIN :
return (PICL_NOSPACE);
case EPERM :
return (PICL_PERMDENIED);
case EEXIST :
return (PICL_PROPEXISTS);
default :
return (PICL_FAILURE);
}
}
/*
* unlock_container_lock() should be always called by the thread holding the
* container object lock. it will signal block thread waiting on the condition
* variable.
*/
static void
unlock_container_lock(container_tbl_t *cont_hash)
{
(void) pthread_rwlock_unlock(&cont_hash->rwlock);
(void) pthread_mutex_lock(&cont_tbl_lock);
(void) pthread_cond_signal(&cont_hash->cond_var);
(void) pthread_mutex_unlock(&cont_tbl_lock);
}
/* volatile callback read routine */
/* ARGSUSED */
static int
frudata_read_callback(ptree_rarg_t *rarg, void *buf)
{
return (PICL_SUCCESS);
}
/*
* called to get hash object for specified node and object type from
* hash table.
*/
static container_tbl_t *
lookup_container_table(picl_nodehdl_t nodehdl, int object_type)
{
int index_to_hash;
int retval = PICL_SUCCESS;
container_tbl_t *first_hash;
container_tbl_t *next_hash;
picl_nodehdl_t parenthdl = 0;
switch (object_type) {
case SECTION_NODE:
retval = ptree_get_propval_by_name(nodehdl, PICL_PROP_PARENT,
&parenthdl, sizeof (picl_nodehdl_t));
break;
case SEGMENT_NODE:
retval = ptree_get_propval_by_name(nodehdl, PICL_PROP_PARENT,
&parenthdl, sizeof (picl_nodehdl_t));
retval = ptree_get_propval_by_name(parenthdl, PICL_PROP_PARENT,
&parenthdl, sizeof (picl_nodehdl_t));
break;
case CONTAINER_NODE :
parenthdl = nodehdl;
break;
default :
return (NULL);
}
if (retval != PICL_SUCCESS) {
return (NULL);
}
index_to_hash = (parenthdl % TABLE_SIZE);
first_hash = container_table[index_to_hash];
for (next_hash = first_hash; next_hash != NULL;
next_hash = next_hash->next) {
if (parenthdl == next_hash->picl_hdl) {
return (next_hash);
}
}
return (NULL);
}
static int
lock_readwrite_lock(container_tbl_t *cont_obj, int operation)
{
/* if write operation */
if (operation == PICL_WRITE) {
return (pthread_rwlock_trywrlock(&cont_obj->rwlock));
}
/* read operation */
return (pthread_rwlock_tryrdlock(&cont_obj->rwlock));
}
/*
* lock the container table, do lookup for the container object
* in the container table. if container object found try to lock
* the container object, if lock on container object is busy wait
* on condition variable till the thread holding the container
* object lock signal it.
*/
static container_tbl_t *
lock_container_lock(picl_nodehdl_t nodehdl, int object_type, int operation)
{
container_tbl_t *cont_obj = NULL;
(void) pthread_mutex_lock(&cont_tbl_lock);
while (((cont_obj = lookup_container_table(nodehdl, object_type)) !=
NULL) && (lock_readwrite_lock(cont_obj, operation) == EBUSY)) {
pthread_cond_wait(&cont_obj->cond_var, &cont_tbl_lock);
}
(void) pthread_mutex_unlock(&cont_tbl_lock);
return (cont_obj);
}
static hash_obj_t *
lookup_node_object(picl_nodehdl_t nodehdl, int object_type,
container_tbl_t *cont_tbl)
{
int index_to_hash;
hash_obj_t *first_hash;
hash_obj_t *next_hash;
index_to_hash = (nodehdl % TABLE_SIZE);
first_hash = &cont_tbl->hash_obj[index_to_hash];
for (next_hash = first_hash->next; next_hash != NULL;
next_hash = next_hash->next) {
if ((nodehdl == next_hash->picl_hdl) &&
(object_type == next_hash->object_type)) {
return (next_hash);
}
}
return (NULL);
}
/*
* called to add newly created container hash table into container hash table.
*
*/
static void
add_tblobject_to_container_tbl(container_tbl_t *cont_tbl)
{
int cnt;
int index_to_hash;
hash_obj_t *hash_ptr;
index_to_hash = ((cont_tbl->picl_hdl) % TABLE_SIZE);
cont_tbl->next = container_table[index_to_hash];
container_table[index_to_hash] = cont_tbl;
hash_ptr = cont_tbl->hash_obj;
/* initialize the bucket of this container hash table. */
for (cnt = 0; cnt < TABLE_SIZE; cnt++) {
hash_ptr->next = NULL;
hash_ptr->prev = NULL;
hash_ptr++;
}
if (cont_tbl->next != NULL) {
cont_tbl->next->prev = cont_tbl;
}
}
static void
add_nodeobject_to_hashtable(hash_obj_t *hash_obj, container_tbl_t *cont_tbl)
{
int index_to_hash;
hash_obj_t *hash_table;
index_to_hash = ((hash_obj->picl_hdl) % TABLE_SIZE);
hash_table = &cont_tbl->hash_obj[index_to_hash];
hash_obj->next = hash_table->next;
hash_table->next = hash_obj;
if (hash_obj->next != NULL) {
hash_obj->next->prev = hash_obj;
}
}
static container_tbl_t *
alloc_container_table(picl_nodehdl_t nodehdl)
{
container_tbl_t *cont_tbl;
cont_tbl = malloc(sizeof (container_tbl_t));
if (cont_tbl == NULL) {
return (NULL);
}
cont_tbl->picl_hdl = nodehdl;
cont_tbl->hash_obj = malloc(sizeof (hash_obj_t[TABLE_SIZE]));
cont_tbl->next = NULL;
cont_tbl->prev = NULL;
if (cont_tbl->hash_obj == NULL) {
(void) free(cont_tbl);
return (NULL);
}
(void) pthread_rwlock_init(&cont_tbl->rwlock, NULL);
(void) pthread_cond_init(&cont_tbl->cond_var, NULL);
return (cont_tbl);
}
/*
* called to allocate container node object for container property and a
* container table.
*/
static hash_obj_t *
alloc_container_node_object(picl_nodehdl_t nodehdl)
{
hash_obj_t *hash_obj;
fru_access_hdl_t acc_hdl;
container_node_t *cont_node;
/* open the container (call fruaccess) */
acc_hdl = fru_open_container(nodehdl);
if (acc_hdl == (container_hdl_t)0) {
return (NULL);
}
/* allocate container node object */
cont_node = malloc(sizeof (container_node_t));
if (cont_node == NULL) {
return (NULL);
}
/* allocate container hash object */
hash_obj = malloc(sizeof (hash_obj_t));
if (hash_obj == NULL) {
(void) free(cont_node);
return (NULL);
}
cont_node->cont_hdl = acc_hdl; /* fruaccess handle */
cont_node->section_list = NULL;
hash_obj->picl_hdl = nodehdl; /* picl node handle */
hash_obj->object_type = CONTAINER_NODE;
hash_obj->u.cont_node = cont_node;
hash_obj->next = NULL;
hash_obj->prev = NULL;
return (hash_obj);
}
/*
* called to allocate node object for section node.
*/
static hash_obj_t *
alloc_section_node_object(picl_nodehdl_t nodehdl, section_t *section)
{
hash_obj_t *hash_obj;
section_node_t *sec_node;
/* allocate section node object */
sec_node = malloc(sizeof (section_node_t));
if (sec_node == NULL) {
return (NULL);
}
/* allocate section hash object */
hash_obj = malloc(sizeof (hash_obj_t));
if (hash_obj == NULL) {
(void) free(sec_node);
return (NULL);
}
sec_node->section_hdl = section->handle; /* fruaccess hdl. */
sec_node->segment_list = NULL;
sec_node->next = NULL;
sec_node->num_of_segment = -1;
hash_obj->picl_hdl = nodehdl; /* picl node handle */
hash_obj->object_type = SECTION_NODE;
hash_obj->u.sec_node = sec_node;
hash_obj->next = NULL;
hash_obj->prev = NULL;
return (hash_obj);
}
/*
* called to allocate segment node object.
*/
static hash_obj_t *
alloc_segment_node_object(picl_nodehdl_t nodehdl, segment_t *segment)
{
hash_obj_t *hash_obj;
segment_node_t *seg_node;
/* allocate segment node object */
seg_node = malloc(sizeof (segment_node_t));
if (seg_node == NULL) {
return (NULL);
}
/* allocate segment hash object */
hash_obj = malloc(sizeof (hash_obj_t));
if (hash_obj == NULL) {
free(seg_node);
return (NULL);
}
/* fruaccess handle */
seg_node->segment_hdl = segment->handle;
seg_node->packet_list = NULL;
seg_node->next = NULL;
seg_node->num_of_pkt = -1;
/* picl node handle */
hash_obj->picl_hdl = nodehdl;
hash_obj->object_type = SEGMENT_NODE;
hash_obj->u.seg_node = seg_node;
hash_obj->next = NULL;
hash_obj->prev = NULL;
return (hash_obj);
}
/*
* called to allocate node object for packet.
*/
static hash_obj_t *
alloc_packet_node_object(picl_nodehdl_t nodehdl, packet_t *packet)
{
hash_obj_t *hash_obj;
packet_node_t *pkt_node;
/* allocate packet node object */
pkt_node = malloc(sizeof (packet_node_t));
if (pkt_node == NULL) {
return (NULL);
}
/* allocate packet hash object */
hash_obj = malloc(sizeof (hash_obj_t));
if (hash_obj == NULL) {
free(pkt_node);
return (NULL);
}
/* fruaccess handle */
pkt_node->pkt_handle = packet->handle;
pkt_node->next = NULL;
hash_obj->picl_hdl = nodehdl; /* picl node handle */
hash_obj->object_type = PACKET_NODE;
hash_obj->u.pkt_node = pkt_node;
hash_obj->next = NULL;
hash_obj->prev = NULL;
return (hash_obj);
}
/* add new section hash object to the section list */
static void
add_to_section_list(hash_obj_t *container_hash, hash_obj_t *sect_hash)
{
hash_obj_t *next_hash;
sect_hash->u.sec_node->container_hdl = container_hash->picl_hdl;
if (container_hash->u.cont_node->section_list == NULL) {
container_hash->u.cont_node->section_list = sect_hash;
return;
}
for (next_hash = container_hash->u.cont_node->section_list;
next_hash->u.sec_node->next != NULL;
next_hash = next_hash->u.sec_node->next) {
;
}
next_hash->u.sec_node->next = sect_hash;
}
/* add new segment hash object to the existing list */
static void
add_to_segment_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
{
hash_obj_t *next_hash;
child_obj->u.seg_node->sec_nodehdl = parent_obj->picl_hdl;
if (parent_obj->u.sec_node->segment_list == NULL) {
parent_obj->u.sec_node->segment_list = child_obj;
return;
}
for (next_hash = parent_obj->u.sec_node->segment_list;
next_hash->u.seg_node->next != NULL;
next_hash = next_hash->u.seg_node->next) {
;
}
next_hash->u.seg_node->next = child_obj;
}
/*
* called to add packet node object to the existing packet list.
*/
static void
add_to_packet_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
{
hash_obj_t *next_hash;
if (parent_obj->u.seg_node->packet_list == NULL) {
parent_obj->u.seg_node->packet_list = child_obj;
return;
}
for (next_hash = parent_obj->u.seg_node->packet_list;
next_hash->u.pkt_node->next != NULL;
next_hash = next_hash->u.pkt_node->next) {
;
}
next_hash->u.pkt_node->next = child_obj;
}
/*
* free the packet hash list.
*/
static void
free_packet_list(hash_obj_t *hash_obj, container_tbl_t *cont_tbl)
{
hash_obj_t *next_obj;
hash_obj_t *free_obj;
/* packet hash object list */
next_obj = hash_obj->u.seg_node->packet_list;
while (next_obj != NULL) {
free_obj = next_obj;
next_obj = next_obj->u.pkt_node->next;
if (free_obj->prev == NULL) { /* first node object */
cont_tbl->hash_obj[(free_obj->picl_hdl %
TABLE_SIZE)].next = free_obj->next;
if (free_obj->next != NULL) {
free_obj->next->prev = NULL;
}
} else {
free_obj->prev->next = free_obj->next;
if (free_obj->next != NULL) {
free_obj->next->prev = free_obj->prev;
}
}
free(free_obj->u.pkt_node);
free(free_obj);
}
hash_obj->u.seg_node->packet_list = NULL;
}
/*
* free the segment hash node object.
*/
static void
free_segment_node(hash_obj_t *hash_obj, picl_nodehdl_t nodehdl,
container_tbl_t *cont_tbl)
{
hash_obj_t *prev_hash_obj;
hash_obj_t *next_obj;
/* segment hash object list */
next_obj = hash_obj->u.sec_node->segment_list;
if (next_obj == NULL) {
return;
}
/* find the segment hash from the segment list to be deleted. */
if (next_obj->picl_hdl == nodehdl) {
hash_obj->u.sec_node->segment_list =
next_obj->u.seg_node->next;
} else {
while (next_obj != NULL) {
if (next_obj->picl_hdl != nodehdl) {
prev_hash_obj = next_obj;
next_obj = next_obj->u.seg_node->next;
} else {
prev_hash_obj->u.seg_node->next =
next_obj->u.seg_node->next;
break;
}
}
if (next_obj == NULL) {
return;
}
}
if (next_obj->prev == NULL) {
cont_tbl->hash_obj[(next_obj->picl_hdl % TABLE_SIZE)].next =
next_obj->next;
if (next_obj->next != NULL)
next_obj->next->prev = NULL;
} else {
next_obj->prev->next = next_obj->next;
if (next_obj->next != NULL) {
next_obj->next->prev = next_obj->prev;
}
}
free_packet_list(next_obj, cont_tbl);
free(next_obj->u.seg_node);
free(next_obj);
}
/*
* Description : frudata_delete_segment is called when volatile property
* delete_segment under class segment is accessed.
*
* Arguments : ptree_warg_t is holds node handle of segment node and property
* handle of delete_segment property.
*/
/* ARGSUSED */
static int
frudata_delete_segment(ptree_warg_t *warg, const void *buf)
{
int retval;
int num_of_segment;
int num_of_pkt;
int pkt_cnt;
int count;
packet_t *pkt_buf;
segment_t *seg_buffer;
hash_obj_t *seg_hash;
hash_obj_t *pkt_hash;
hash_obj_t *hash_obj;
fru_segdesc_t *desc;
picl_nodehdl_t sec_nodehdl;
container_tbl_t *cont_tbl;
fru_access_hdl_t seg_acc_hdl;
fru_access_hdl_t new_sec_acc_hdl;
cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE);
if (!cont_tbl) {
return (PICL_FAILURE);
}
/* segment hash */
hash_obj = lookup_node_object(warg->nodeh, SEGMENT_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* fruaccess segment handle */
seg_acc_hdl = hash_obj->u.seg_node->segment_hdl;
/* call fruaccess to get new section handle */
if (fru_delete_segment(seg_acc_hdl, &new_sec_acc_hdl, &warg->cred)
== -1) {
unlock_container_lock(cont_tbl);
return (map_access_err(errno));
}
if (ptree_delete_node(warg->nodeh) != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
if (ptree_destroy_node(warg->nodeh) != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* get section node handle */
sec_nodehdl = hash_obj->u.seg_node->sec_nodehdl;
/* get section hash */
hash_obj = lookup_node_object(sec_nodehdl, SECTION_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
free_segment_node(hash_obj, warg->nodeh, cont_tbl);
hash_obj->u.sec_node->num_of_segment = 0;
/* call fruaccess with new section handle */
num_of_segment = fru_get_num_segments(new_sec_acc_hdl, &warg->cred);
if (num_of_segment <= 0) {
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
seg_buffer = alloca(sizeof (segment_t) * num_of_segment);
if (seg_buffer == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* get all the segments */
retval = fru_get_segments(new_sec_acc_hdl, seg_buffer,
num_of_segment, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
seg_hash = hash_obj->u.sec_node->segment_list;
if (seg_hash == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/* rebuild the segment list */
for (count = 0; count < num_of_segment; count++) {
desc = (fru_segdesc_t *)&seg_buffer[count].descriptor;
if (!(desc->field.field_perm & SEGMENT_READ)) {
seg_hash = seg_hash->u.seg_node->next;
continue;
}
if (desc->field.opaque) {
seg_hash = seg_hash->u.seg_node->next;
continue;
}
hash_obj->u.sec_node->num_of_segment++;
seg_hash->u.seg_node->segment_hdl = seg_buffer[count].handle;
num_of_pkt =
fru_get_num_packets(seg_buffer[count].handle,
&warg->cred);
if (num_of_pkt <= 0) {
seg_hash = seg_hash->u.seg_node->next;
continue;
}
pkt_buf = alloca(sizeof (packet_t) * num_of_pkt);
if (pkt_buf == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
retval = fru_get_packets(seg_buffer[count].handle, pkt_buf,
num_of_pkt, &warg->cred);
if (retval == -1) {
seg_hash = seg_hash->u.seg_node->next;
continue;
}
pkt_hash = seg_hash->u.seg_node->packet_list;
if (pkt_hash == NULL) {
seg_hash = seg_hash->u.seg_node->next;
continue;
}
/* rebuild the packet list */
for (pkt_cnt = 0; pkt_cnt < num_of_pkt; pkt_cnt++) {
pkt_hash->u.pkt_node->pkt_handle =
pkt_buf[pkt_cnt].handle;
pkt_hash = pkt_hash->u.pkt_node->next;
}
seg_hash = seg_hash->u.seg_node->next;
if (seg_hash == NULL) {
break;
}
}
/* updated with new section handle */
hash_obj->u.sec_node->section_hdl = new_sec_acc_hdl;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* Description : frudata_read_payload is called when volatile property
* payload is read.
*
* Arguments : ptree_rarg_t holds node handle of the table property.
* and property handle of the payload cell.
* p_buf contains payload data when function returns.
*
* Returns : PICL_SUCCESS on success.
* PICL_FAILURE on failure.
*/
static int
frudata_read_payload(ptree_rarg_t *rarg, void *buf)
{
int num_bytes;
hash_obj_t *hash_obj;
fru_access_hdl_t pkt_acc_hdl;
container_tbl_t *cont_tbl;
cont_tbl = lock_container_lock(rarg->nodeh, SEGMENT_NODE, PICL_READ);
if (!cont_tbl) {
return (PICL_FAILURE);
}
hash_obj = lookup_node_object(rarg->proph, PACKET_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
pkt_acc_hdl = hash_obj->u.pkt_node->pkt_handle;
num_bytes = fru_get_payload(pkt_acc_hdl, buf,
hash_obj->u.pkt_node->paylen, &rarg->cred);
if (num_bytes != hash_obj->u.pkt_node->paylen) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* Description : frudata_write_payload is called when payload property cell
* is accessed.
*
* Arguments : ptree_warg_t holds node handle of the packet-table.
* and property handle of the payload cell.
* p_buf contains payload data.
*
* Returns : PICL_SUCCESS on success.
*
*/
static int
frudata_write_payload(ptree_warg_t *warg, const void *buf)
{
int retval;
hash_obj_t *hash_obj;
fru_access_hdl_t pkt_acc_hdl;
container_tbl_t *cont_tbl;
cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE);
if (!cont_tbl) {
return (PICL_FAILURE);
}
hash_obj = lookup_node_object(warg->proph, PACKET_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
pkt_acc_hdl = hash_obj->u.pkt_node->pkt_handle;
retval = fru_update_payload(pkt_acc_hdl, buf,
hash_obj->u.pkt_node->paylen,
&pkt_acc_hdl, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (map_access_err(errno));
}
hash_obj->u.pkt_node->pkt_handle = pkt_acc_hdl;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* callback volatile function is called when tag volatile property
* is accessed. this routine holds a read lock over the hash table
* and do a lookup over the property handle i.e property handle of
* the tag property passed in rarg parameter.
* tag value is copied into the buffer (void *buf).
*/
static int
frudata_read_tag(ptree_rarg_t *rarg, void *buf)
{
int retval;
hash_obj_t *hash_obj;
picl_prophdl_t rowproph;
container_tbl_t *cont_tbl;
cont_tbl = lock_container_lock(rarg->nodeh, SEGMENT_NODE, PICL_READ);
if (!cont_tbl) {
return (PICL_FAILURE);
}
retval = ptree_get_next_by_row(rarg->proph, &rowproph);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
hash_obj = lookup_node_object(rowproph, PACKET_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
(void) memcpy(buf, &hash_obj->u.pkt_node->tag, sizeof (tag_t));
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* Description : create_packet_table() is called by fru_delete_packet_row(),
* to create a packet-table volatile property. it's called after
* deleting the packet-table. fru_delete_packet_row() calls
* frudata_read_packet_table() to add rows into the table.
*/
static int
create_packet_table(picl_nodehdl_t seghdl, picl_prophdl_t *thdl)
{
int retval;
picl_prophdl_t tblhdl;
picl_nodehdl_t prophdl;
ptree_propinfo_t prop;
retval = ptree_create_table(&tblhdl);
if (retval != PICL_SUCCESS) {
return (retval);
}
prop.version = PTREE_PROPINFO_VERSION;
prop.piclinfo.type = PICL_PTYPE_TABLE;
prop.piclinfo.accessmode = PICL_READ|PICL_WRITE;
prop.piclinfo.size = sizeof (picl_prophdl_t);
prop.read = NULL;
prop.write = NULL;
(void) strcpy(prop.piclinfo.name, PICL_PROP_PACKET_TABLE);
retval = ptree_create_and_add_prop(seghdl, &prop, &tblhdl,
&prophdl);
if (retval != PICL_SUCCESS) {
return (retval);
}
/* hold the table handle */
*thdl = tblhdl;
return (PICL_SUCCESS);
}
/*
* Description : frudata_delete_packet is called when write operation is
* performed on tag volatile property.
*
*
* Arguments : ptree_warg_t holds node handle to the segment node.
* and property handle of the tag cell in the packet table to be
* deleted.
* buf contains the tag data + plus DELETE_KEY_TAG
*
* Returns : PICL_SUCCESS on success
*
*/
static int
frudata_delete_packet(ptree_warg_t *warg, const void *buf)
{
int count = 0;
int retval;
int num_of_pkt;
uint64_t tag;
packet_t *packet;
hash_obj_t *seg_hash_obj;
hash_obj_t *pkt_hash_obj;
container_tbl_t *cont_tbl;
picl_prophdl_t tblhdl;
picl_prophdl_t rowproph;
fru_access_hdl_t new_seg_acc_hdl;
cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE);
if (!cont_tbl) {
return (PICL_FAILURE);
}
/* get the payload property handle */
retval = ptree_get_next_by_row(warg->proph, &rowproph);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
/* do lookup on payload property handle */
pkt_hash_obj = lookup_node_object(rowproph, PACKET_NODE, cont_tbl);
if (pkt_hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* verify the tag */
tag = pkt_hash_obj->u.pkt_node->tag.raw_data;
tag &= FRUDATA_DELETE_TAG_MASK;
tag |= FRUDATA_DELETE_TAG_KEY;
if (*(uint64_t *)buf != tag) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* call fruaccess module */
retval = fru_delete_packet(pkt_hash_obj->u.pkt_node->pkt_handle,
&new_seg_acc_hdl, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (map_access_err(errno));
}
/* delete the packet table */
retval = ptree_get_prop_by_name(warg->nodeh, PICL_PROP_PACKET_TABLE,
&tblhdl);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
retval = ptree_delete_prop(tblhdl);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
retval = ptree_destroy_prop(tblhdl);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
seg_hash_obj = lookup_node_object(warg->nodeh, SEGMENT_NODE,
cont_tbl);
if (seg_hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* free all packet hash object */
free_packet_list(seg_hash_obj, cont_tbl);
/* recreate the packet table */
retval = create_packet_table(warg->nodeh, &tblhdl);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
seg_hash_obj->u.seg_node->segment_hdl = new_seg_acc_hdl;
seg_hash_obj->u.seg_node->num_of_pkt = 0;
num_of_pkt = fru_get_num_packets(new_seg_acc_hdl, &warg->cred);
if (num_of_pkt == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
if (num_of_pkt == 0) {
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
packet = alloca(sizeof (packet_t) * num_of_pkt);
if (packet == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
retval = fru_get_packets(new_seg_acc_hdl, packet,
num_of_pkt, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* rebuild the packet hash object */
for (count = 0; count < num_of_pkt; count++) {
(void) add_row_to_table(seg_hash_obj, tblhdl, packet+count,
cont_tbl);
}
seg_hash_obj->u.seg_node->num_of_pkt = num_of_pkt;
(void) ptree_update_propval_by_name(warg->nodeh, PICL_PROP_NUM_TAGS,
&num_of_pkt, sizeof (uint32_t));
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* called from frudata_delete_packet(), frudata_add_packet(),
* frudata_read_packet() callback routine to add packet into
* the packet table. it also create hash node object for each
* individual packet and add the object to the packet list.
*/
static int
add_row_to_table(hash_obj_t *seg_obj, picl_nodehdl_t tblhdl, packet_t *pkt,
container_tbl_t *cont_tbl)
{
int retval;
int paylen;
size_t tag_size;
hash_obj_t *hash_obj;
fru_tagtype_t tagtype;
picl_prophdl_t prophdl[NUM_OF_COL_IN_PKT_TABLE];
ptree_propinfo_t prop;
prop.version = PTREE_PROPINFO_VERSION;
prop.piclinfo.type = PICL_PTYPE_BYTEARRAY;
prop.piclinfo.accessmode = PICL_READ|PICL_WRITE|PICL_VOLATILE;
prop.piclinfo.size = sizeof (fru_tag_t);
prop.read = frudata_read_tag;
prop.write = frudata_delete_packet;
/* tag property node */
(void) strcpy(prop.piclinfo.name, PICL_PROP_TAG);
paylen = get_payload_length((void *)&pkt->tag);
if (paylen < 0) {
return (PICL_FAILURE);
}
retval = ptree_create_prop(&prop, NULL, &prophdl[0]);
if (retval != PICL_SUCCESS) {
return (retval);
}
/* payload property node */
prop.piclinfo.type = PICL_PTYPE_BYTEARRAY;
prop.piclinfo.size = paylen;
(void) strcpy(prop.piclinfo.name, PICL_PROP_PAYLOAD);
prop.piclinfo.accessmode = PICL_READ|PICL_WRITE|PICL_VOLATILE;
prop.read = frudata_read_payload;
prop.write = frudata_write_payload;
retval = ptree_create_prop(&prop, NULL, &prophdl[1]);
if (retval != PICL_SUCCESS) {
return (retval);
}
hash_obj = alloc_packet_node_object(prophdl[1], pkt);
if (hash_obj == NULL) {
return (PICL_FAILURE);
}
retval = ptree_add_row_to_table(tblhdl, NUM_OF_COL_IN_PKT_TABLE,
prophdl);
if (retval != PICL_SUCCESS) {
free(hash_obj);
return (retval);
}
tagtype = get_tag_type((fru_tag_t *)&pkt->tag);
if (tagtype == -1) {
return (PICL_FAILURE);
}
tag_size = get_tag_size(tagtype);
if (tag_size == (size_t)-1) {
return (PICL_FAILURE);
}
hash_obj->u.pkt_node->paylen = paylen;
hash_obj->u.pkt_node->tag.raw_data = 0;
(void) memcpy(&hash_obj->u.pkt_node->tag, &pkt->tag, tag_size);
add_nodeobject_to_hashtable(hash_obj, cont_tbl);
add_to_packet_list(seg_obj, hash_obj);
return (PICL_SUCCESS);
}
/*
* called from frudata_read_segment() callback routine. it's called after
* creating the packet table under class segment. this routine reads the
* segment data to get total number of packets in the segments and add
* the tag and payload data into the table. it calls add_row_to_table
* routine to add individual row into the packet table.
*/
static int
frudata_read_packet(picl_nodehdl_t nodeh, picl_prophdl_t *tblhdl,
container_tbl_t *cont_tbl, door_cred_t *cred)
{
int cnt;
int retval;
int num_of_pkt;
packet_t *packet;
hash_obj_t *hash_obj;
fru_access_hdl_t seg_acc_hdl;
hash_obj = lookup_node_object(nodeh, SEGMENT_NODE, cont_tbl);
if (hash_obj == NULL) {
return (PICL_FAILURE);
}
if (hash_obj->u.seg_node->num_of_pkt == -1) {
/* get the access handle */
seg_acc_hdl = hash_obj->u.seg_node->segment_hdl;
/* get total number of packets */
num_of_pkt = fru_get_num_packets(seg_acc_hdl, cred);
if (num_of_pkt < 0) {
hash_obj->u.seg_node->num_of_pkt = 0;
return (map_access_err(errno));
}
if (num_of_pkt == 0) {
hash_obj->u.seg_node->num_of_pkt = 0;
return (0);
}
/* allocate buffer */
packet = alloca(sizeof (packet_t) * num_of_pkt);
if (packet == NULL) {
hash_obj->u.seg_node->num_of_pkt = 0;
return (0);
}
/* get all the packet into the packet buffer */
retval = fru_get_packets(seg_acc_hdl, packet, num_of_pkt, cred);
if (retval == -1) {
return (0);
}
/* add payload and tag into the table. */
for (cnt = 0; cnt < num_of_pkt; cnt++) {
(void) add_row_to_table(hash_obj, *tblhdl, packet+cnt,
cont_tbl);
}
hash_obj->u.seg_node->num_of_pkt = num_of_pkt;
}
return (0);
}
/*
* Description : frudata_add_packet is called when add-packet volatile
* property is accessed.
*
* Arguments : ptree_warg_t holds node handle of the segment node and
* property handle of add-packet property.
* p_buf- contains packet data to be added.
*
* Return : PICL_SUCCESS on success.
*
*/
/* ARGSUSED */
static int
frudata_add_packet(ptree_warg_t *warg, const void *buf)
{
size_t tag_size;
int paylen;
int retval;
int num_of_pkt;
int cnt;
packet_t packet;
packet_t *pkt_buf;
hash_obj_t *hash_obj;
hash_obj_t *pkt_hash;
container_tbl_t *cont_tbl;
fru_tagtype_t tagtype;
picl_prophdl_t tblhdl;
fru_access_hdl_t seg_acc_hdl;
fru_access_hdl_t new_seg_acc_hdl;
cont_tbl = lock_container_lock(warg->nodeh, SEGMENT_NODE, PICL_WRITE);
if (!cont_tbl) {
return (PICL_FAILURE);
}
hash_obj = lookup_node_object(warg->nodeh, SEGMENT_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
seg_acc_hdl = hash_obj->u.seg_node->segment_hdl;
tagtype = get_tag_type((void *)buf);
if (tagtype == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
tag_size = get_tag_size(tagtype);
if (tag_size == (size_t)-1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
paylen = get_payload_length((void *)buf);
if (paylen == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
packet.tag = 0;
(void) memcpy(&packet.tag, buf, tag_size);
retval = fru_append_packet(seg_acc_hdl, &packet, (char *)buf + tag_size,
paylen, &new_seg_acc_hdl, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (map_access_err(errno));
}
retval = ptree_get_propval_by_name(warg->nodeh,
PICL_PROP_PACKET_TABLE, &tblhdl, sizeof (picl_prophdl_t));
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
retval = add_row_to_table(hash_obj, tblhdl, &packet, cont_tbl);
if (retval != PICL_SUCCESS) {
unlock_container_lock(cont_tbl);
return (retval);
}
num_of_pkt = fru_get_num_packets(new_seg_acc_hdl, &warg->cred);
if (num_of_pkt == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
pkt_buf = alloca(sizeof (packet_t) * num_of_pkt);
if (pkt_buf == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
retval = fru_get_packets(new_seg_acc_hdl, pkt_buf,
num_of_pkt, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
pkt_hash = hash_obj->u.seg_node->packet_list;
if (pkt_hash == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
for (cnt = 0; cnt < num_of_pkt; cnt++) {
pkt_hash->u.pkt_node->pkt_handle = pkt_buf[cnt].handle;
pkt_hash = pkt_hash->u.pkt_node->next;
}
hash_obj->u.seg_node->num_of_pkt = num_of_pkt;
(void) ptree_update_propval_by_name(warg->nodeh, PICL_PROP_NUM_TAGS,
&num_of_pkt, sizeof (uint32_t));
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
static void
freeup(picl_nodehdl_t nodeh)
{
(void) ptree_delete_node(nodeh);
(void) ptree_destroy_node(nodeh);
}
/*
* called by frudata_read_segment() and fru_data_add_segment() callback routine.
* it's called to create a segment node and all it's property beneith the
* segment node in the picl tree.
*/
static int
create_segment_node(hash_obj_t *sec_obj, picl_nodehdl_t sec_node,
segment_t *segment, container_tbl_t *cont_tbl, door_cred_t *cred)
{
int retval;
char segname[SEG_NAME_LEN + 1];
uint32_t numoftags = 0;
uint32_t protection;
hash_obj_t *hash_obj;
picl_nodehdl_t nodehdl;
picl_prophdl_t prophdl;
picl_nodehdl_t tblhdl;
ptree_propinfo_t prop;
(void) strlcpy(segname, segment->name, SEG_NAME_LEN + 1);
segname[SEG_NAME_LEN] = '\0';
if (!(isprint(segname[0]) || isprint(segname[1]))) {
return (PICL_FAILURE);
}
if (ptree_create_node(segname, PICL_CLASS_SEGMENT, &nodehdl)
!= PICL_SUCCESS) {
return (PICL_FAILURE);
}
/* create property node */
prop.version = PTREE_PROPINFO_VERSION;
prop.piclinfo.accessmode = PICL_READ;
prop.read = NULL;
prop.write = NULL;
prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT;
prop.piclinfo.size = sizeof (uint32_t);
/* descriptor property */
(void) strcpy(prop.piclinfo.name, PICL_PROP_DESCRIPTOR);
if (ptree_create_and_add_prop(nodehdl, &prop, &segment->descriptor,
&prophdl) != PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
/* offset property */
(void) strcpy(prop.piclinfo.name, PICL_PROP_OFFSET);
if (ptree_create_and_add_prop(nodehdl, &prop, &segment->offset,
&prophdl) != PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
/* length property */
(void) strcpy(prop.piclinfo.name, PICL_PROP_LENGTH);
if (ptree_create_and_add_prop(nodehdl, &prop, &segment->length,
&prophdl) != PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
/* Number of Tags */
(void) strcpy(prop.piclinfo.name, PICL_PROP_NUM_TAGS);
if (ptree_create_and_add_prop(nodehdl, &prop, &numoftags, &prophdl)
!= PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
if (create_packet_table(nodehdl, &tblhdl) != PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
retval = ptree_get_propval_by_name(sec_node,
PICL_PROP_PROTECTED, &protection, sizeof (uint32_t));
if (retval != PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
if (protection == 0) { /* to be added only read/write section */
/* delete segment volatile property */
prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT;
prop.piclinfo.size = sizeof (uint32_t);
prop.piclinfo.accessmode = PICL_WRITE|PICL_VOLATILE;
prop.write = frudata_delete_segment;
prop.read = frudata_read_callback;
(void) strcpy(prop.piclinfo.name, PICL_PROP_DELETE_SEGMENT);
if (ptree_create_and_add_prop(nodehdl, &prop, NULL, &prophdl)
!= PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
/* add packet volatile property */
prop.piclinfo.type = PICL_PTYPE_BYTEARRAY;
prop.piclinfo.size = segment->length; /* segment length */
prop.piclinfo.accessmode = PICL_READ|PICL_WRITE|PICL_VOLATILE;
prop.read = frudata_read_callback;
prop.write = frudata_add_packet;
(void) strcpy(prop.piclinfo.name, PICL_PROP_ADD_PACKET);
if (ptree_create_and_add_prop(nodehdl, &prop, NULL, &prophdl)
!= PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
}
if (ptree_add_node(sec_node, nodehdl) != PICL_SUCCESS) {
freeup(nodehdl);
return (PICL_FAILURE);
}
hash_obj = alloc_segment_node_object(nodehdl, segment);
if (hash_obj == NULL) {
freeup(nodehdl);
return (PICL_FAILURE);
}
add_nodeobject_to_hashtable(hash_obj, cont_tbl);
add_to_segment_list(sec_obj, hash_obj);
retval = frudata_read_packet(nodehdl, &tblhdl, cont_tbl, cred);
if (retval != 0) {
return (PICL_SUCCESS);
}
(void) ptree_update_propval_by_name(nodehdl, PICL_PROP_NUM_TAGS,
&hash_obj->u.seg_node->num_of_pkt, sizeof (uint32_t));
return (PICL_SUCCESS);
}
/*
* Description :frudata_read_segment is called when num_segment volatile
* property is accessed.
*
* Arguments : ptree_rarg_t contains node handle of the section node.
* and property node of num_segments.
* void * will hold number of segment.
*
* Returns : PICL_SUCCESS on success.
* PICL_FAILURE on failure.
*/
static int
frudata_read_segment(ptree_rarg_t *rarg, void *buf)
{
int num_of_segment;
int cnt;
int retval;
segment_t *segment;
hash_obj_t *hash_obj;
fru_segdesc_t *desc;
fru_access_hdl_t sec_acc_hdl;
container_tbl_t *cont_tbl;
cont_tbl = lock_container_lock(rarg->nodeh, SECTION_NODE, PICL_READ);
if (!cont_tbl) {
return (PICL_FAILURE);
}
hash_obj = lookup_node_object(rarg->nodeh, SECTION_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
if (hash_obj->u.sec_node->num_of_segment == -1) {
sec_acc_hdl = hash_obj->u.sec_node->section_hdl;
hash_obj->u.sec_node->num_of_segment = 0;
num_of_segment = fru_get_num_segments(sec_acc_hdl,
&rarg->cred);
if (num_of_segment < 0) {
*(int *)buf = 0;
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
if (num_of_segment == 0) {
*(int *)buf = 0;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
segment = alloca(sizeof (segment_t) * num_of_segment);
if (segment == NULL) {
*(int *)buf = 0;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
retval = fru_get_segments(sec_acc_hdl, segment,
num_of_segment, &rarg->cred);
if (retval == -1) {
*(int *)buf = 0;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
for (cnt = 0; cnt < num_of_segment; cnt++) {
desc = (fru_segdesc_t *)&segment[cnt].descriptor;
if (!(desc->field.field_perm & SEGMENT_READ)) {
continue;
}
/* if opaque segment don't create segment node */
if (desc->field.opaque) {
continue;
}
(void) create_segment_node(hash_obj, rarg->nodeh,
&segment[cnt], cont_tbl, &rarg->cred);
hash_obj->u.sec_node->num_of_segment++;
}
}
/* return number of segment in the section */
*(int *)buf = hash_obj->u.sec_node->num_of_segment;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* Description : frudata_add_segment is called when volatile property
* add_segment under class node section is accessed.
*
* Arguments : ptree_warg_t holds node handle for the section node.
* property handle for the add_segment property.
*
* Returns : PICL_SUCCESS on success.
* PICL_FAILURE on failure.
*/
static int
frudata_add_segment(ptree_warg_t *warg, const void *buf)
{
int retval;
int cnt;
int num_of_segment;
segment_t *seg_buf;
segment_t segment;
hash_obj_t *seg_hash;
hash_obj_t *hash_obj;
container_tbl_t *cont_tbl;
fru_segdef_t *seg_def;
fru_segdesc_t *desc;
fru_access_hdl_t new_sec_acc_hdl;
seg_def = (fru_segdef_t *)buf;
/* initialize segment_t */
segment.handle = 0;
(void) memcpy(segment.name, seg_def->name, SEG_NAME_LEN);
segment.descriptor = seg_def->desc.raw_data;
segment.length = seg_def->size; /* segment length */
segment.offset = seg_def->address; /* segment offset */
desc = (fru_segdesc_t *)&segment.descriptor;
if (!(desc->field.field_perm & SEGMENT_READ)) {
return (PICL_PERMDENIED);
}
cont_tbl = lock_container_lock(warg->nodeh, SECTION_NODE, PICL_WRITE);
if (!cont_tbl) {
return (PICL_FAILURE);
}
hash_obj = lookup_node_object(warg->nodeh, SECTION_NODE, cont_tbl);
if (hash_obj == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
/* call fruaccess module, get the new section handle. */
retval = fru_add_segment(hash_obj->u.sec_node->section_hdl,
&segment, &new_sec_acc_hdl, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (map_access_err(errno));
}
/* call access module with new section handle */
num_of_segment = fru_get_num_segments(new_sec_acc_hdl, &warg->cred);
seg_buf = alloca(sizeof (segment_t) * num_of_segment);
if (seg_buf == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
retval = fru_get_segments(new_sec_acc_hdl, seg_buf,
num_of_segment, &warg->cred);
if (retval == -1) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
segment.offset = seg_buf[(num_of_segment -1)].offset;
segment.handle = seg_buf[(num_of_segment-1)].handle;
(void) create_segment_node(hash_obj, warg->nodeh, &segment,
cont_tbl, &warg->cred);
/* rebuild segment list */
seg_hash = hash_obj->u.sec_node->segment_list;
if (seg_hash == NULL) {
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
hash_obj->u.sec_node->num_of_segment = 0;
for (cnt = 0; cnt < num_of_segment; cnt++) {
desc = (fru_segdesc_t *)&seg_buf[cnt].descriptor;
if (!(desc->field.field_perm & SEGMENT_READ)) {
continue;
}
/* if opaque segment don't create segment node */
if (desc->field.opaque) {
continue;
}
seg_hash->u.seg_node->segment_hdl =
seg_buf[cnt].handle;
seg_hash = seg_hash->u.seg_node->next;
hash_obj->u.sec_node->num_of_segment++;
}
/* update with new section handle */
hash_obj->u.sec_node->section_hdl = new_sec_acc_hdl;
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/*
* called from frudata_write_section() callback routine to create
* section node and all the property under class section. it also
* allocate hash node object for each section in the container and
* add the section node object in the section list.
*/
static int
create_section_node(picl_nodehdl_t nodehdl, int section_count,
section_t *section, container_tbl_t *cont_tbl)
{
char sec_name[SECNAMESIZE];
hash_obj_t *hash_obj;
hash_obj_t *cont_hash;
picl_nodehdl_t chld_node;
picl_prophdl_t prophdl;
ptree_propinfo_t prop;
(void) snprintf(sec_name, SECNAMESIZE, "section%d", section_count);
if (ptree_create_node(sec_name, PICL_CLASS_SECTION, &chld_node)
!= PICL_SUCCESS) {
return (PICL_FAILURE);
}
prop.version = PTREE_PROPINFO_VERSION;
prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT;
prop.piclinfo.accessmode = PICL_READ;
prop.piclinfo.size = sizeof (uint32_t);
prop.read = NULL;
prop.write = NULL;
/* offset */
(void) strcpy(prop.piclinfo.name, PICL_PROP_OFFSET);
if (ptree_create_and_add_prop(chld_node, &prop, &section->offset,
&prophdl) != PICL_SUCCESS) {
freeup(chld_node);
return (PICL_FAILURE);
}
/* length */
(void) strcpy(prop.piclinfo.name, PICL_PROP_LENGTH);
if (ptree_create_and_add_prop(chld_node, &prop, &section->length,
&prophdl) != PICL_SUCCESS) {
freeup(chld_node);
return (PICL_FAILURE);
}
/* protected */
(void) strcpy(prop.piclinfo.name, PICL_PROP_PROTECTED);
if (ptree_create_and_add_prop(chld_node, &prop, &section->protection,
&prophdl) != PICL_SUCCESS) {
freeup(chld_node);
return (PICL_FAILURE);
}
prop.piclinfo.accessmode = PICL_READ|PICL_VOLATILE;
prop.read = frudata_read_segment;
(void) strcpy(prop.piclinfo.name, PICL_PROP_NUM_SEGMENTS);
if (ptree_create_and_add_prop(chld_node, &prop, NULL, &prophdl)
!= PICL_SUCCESS) {
freeup(chld_node);
return (PICL_FAILURE);
}
prop.piclinfo.type = PICL_PTYPE_BYTEARRAY;
prop.piclinfo.size = sizeof (fru_segdef_t);
prop.piclinfo.accessmode = PICL_WRITE|PICL_READ|PICL_VOLATILE;
prop.write = frudata_add_segment; /* callback routine */
prop.read = frudata_read_callback;
(void) strcpy(prop.piclinfo.name, PICL_PROP_ADD_SEGMENT);
/* add-segment prop if read/write section */
if (section->protection == 0) {
if (ptree_create_and_add_prop(chld_node, &prop, NULL, &prophdl)
!= PICL_SUCCESS) {
freeup(chld_node);
return (PICL_FAILURE);
}
}
if (ptree_add_node(nodehdl, chld_node) != PICL_SUCCESS) {
freeup(chld_node);
return (PICL_FAILURE);
}
/* lookup for container handle */
cont_hash = lookup_node_object(nodehdl, CONTAINER_NODE, cont_tbl);
if (cont_hash == NULL) {
freeup(chld_node);
return (PICL_FAILURE);
}
hash_obj = alloc_section_node_object(chld_node, section);
if (hash_obj == NULL) {
freeup(chld_node);
return (PICL_FAILURE);
}
add_nodeobject_to_hashtable(hash_obj, cont_tbl);
add_to_section_list(cont_hash, hash_obj);
return (PICL_SUCCESS);
}
/*
* Description :frudata_write_section is called when volatile container
* property is accessed. it reads the section table associated
* with the specified node handle(container) in ptree_rarg_t.
* it calls search_root_node to search the node handle to open the
* device associated with the node handle. it creates section
* node and it's associated property. it also creates
* volatile property num_segments.
*
* Argument : ptree_rarg_t : contains node handle of fru container the
* container.
* property handle of the container.
*
* Return : PICL_SUCCESS on success.
*
*/
/* ARGSUSED */
static int
frudata_write_section(ptree_warg_t *warg, const void *buf)
{
int retval;
int num_of_section;
int count;
section_t *section;
hash_obj_t *hash_obj;
container_tbl_t *cont_tbl = NULL;
fru_access_hdl_t cont_acc_hdl;
(void) pthread_mutex_lock(&cont_tbl_lock);
/*
* if lookup succeed return from this function with PICL_SUCCESS
* because first write operation has already occurred on this container,
* it also means that the container has been already initialzed.
*/
cont_tbl = lookup_container_table(warg->nodeh, CONTAINER_NODE);
if (cont_tbl != NULL) { /* found the hash obj in the hash table */
(void) pthread_mutex_unlock(&cont_tbl_lock);
return (PICL_SUCCESS);
}
/*
* lookup failed that means this is first write on the
* container property. allocate a new container hash table for this
* new container and add to the cont_tbl hash table.
*/
cont_tbl = alloc_container_table(warg->nodeh);
if (cont_tbl == NULL) {
(void) pthread_mutex_unlock(&cont_tbl_lock);
return (map_access_err(errno));
}
hash_obj = alloc_container_node_object(warg->nodeh);
if (hash_obj == NULL) {
(void) pthread_mutex_unlock(&cont_tbl_lock);
return (map_access_err(errno));
}
/* add container table object to container table */
add_tblobject_to_container_tbl(cont_tbl);
/* add the hash object to container hash table. */
add_nodeobject_to_hashtable(hash_obj, cont_tbl);
while (pthread_rwlock_trywrlock(&cont_tbl->rwlock) == EBUSY) {
pthread_cond_wait(&cont_tbl->cond_var, &cont_tbl_lock);
}
(void) pthread_mutex_unlock(&cont_tbl_lock);
/* fruaccess handle */
cont_acc_hdl = hash_obj->u.cont_node->cont_hdl;
num_of_section = fru_get_num_sections(cont_acc_hdl, &warg->cred);
if (num_of_section == -1) {
free(hash_obj);
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
section = alloca(num_of_section * sizeof (section_t));
retval = fru_get_sections(cont_acc_hdl, section,
num_of_section, &warg->cred);
if (retval == -1) {
free(hash_obj);
unlock_container_lock(cont_tbl);
return (PICL_FAILURE);
}
hash_obj->u.cont_node->num_of_section = num_of_section;
for (count = 0; count < num_of_section; count++) {
(void) create_section_node(warg->nodeh, count,
section + count, cont_tbl);
}
unlock_container_lock(cont_tbl);
return (PICL_SUCCESS);
}
/* create container and add-segment property */
static int
create_container_prop(picl_nodehdl_t fruhdl)
{
int retval;
picl_prophdl_t prophdl;
ptree_propinfo_t prop;
prop.version = PTREE_PROPINFO_VERSION;
prop.piclinfo.type = PICL_PTYPE_UNSIGNED_INT;
prop.piclinfo.size = sizeof (uint32_t);
prop.piclinfo.accessmode = PICL_WRITE|PICL_VOLATILE;
(void) strcpy(prop.piclinfo.name, PICL_PROP_CONTAINER);
prop.read = frudata_read_callback;
prop.write = frudata_write_section; /* callback routine */
/* create a property */
retval = ptree_create_and_add_prop(fruhdl, &prop, NULL, &prophdl);
return (retval);
}
/* search for FRUDataAvailable and create container and add segment property */
static void
create_frudata_props(picl_prophdl_t fruhdl)
{
int retval;
picl_nodehdl_t chldhdl;
picl_nodehdl_t tmphdl;
for (retval = ptree_get_propval_by_name(fruhdl, PICL_PROP_CHILD,
&chldhdl, sizeof (picl_nodehdl_t)); retval != PICL_PROPNOTFOUND;
retval = ptree_get_propval_by_name(chldhdl, PICL_PROP_PEER,
&chldhdl, sizeof (picl_nodehdl_t))) {
if (retval != PICL_SUCCESS)
return;
/* Does it have a FRUDataAvailable property */
retval = ptree_get_prop_by_name(chldhdl,
PICL_PROP_FRUDATA_AVAIL, &tmphdl);
if (retval == PICL_SUCCESS) {
(void) create_container_prop(chldhdl);
}
/* Traverse tree recursively */
(void) create_frudata_props(chldhdl);
}
}
/*
* Search for the frutree config file from the platform specific
* directory to the common directory.
*
* The size of outfilename must be PATH_MAX
*/
static int
get_config_file(char *outfilename)
{
char nmbuf[SYS_NMLN];
char pname[PATH_MAX];
if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
(void) snprintf(pname, PATH_MAX, FRUDATA_CONFFILE_NAME, nmbuf);
if (access(pname, R_OK) == 0) {
(void) strlcpy(outfilename, pname, PATH_MAX);
return (0);
}
}
if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
(void) snprintf(pname, PATH_MAX, FRUDATA_CONFFILE_NAME, nmbuf);
if (access(pname, R_OK) == 0) {
(void) strlcpy(outfilename, pname, PATH_MAX);
return (0);
}
}
(void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
FRUDATA_CONFFILE_NAME);
if (access(pname, R_OK) == 0) {
(void) strlcpy(outfilename, pname, PATH_MAX);
return (0);
}
return (-1);
}
/*
* called from delete_frudata_props(), this routine delete the section node
* and free's the section hash object. it calls free_segment_node() to
* delete segment node beneath it.
*/
static void
free_section_node(hash_obj_t *sec_hash, container_tbl_t *cont_tbl)
{
hash_obj_t *seg_hash;
for (seg_hash = sec_hash->u.sec_node->segment_list; seg_hash != NULL;
seg_hash = seg_hash->u.seg_node->next) {
free_segment_node(seg_hash, seg_hash->picl_hdl, cont_tbl);
}
if (sec_hash->prev == NULL) {
cont_tbl->hash_obj[(sec_hash->picl_hdl % TABLE_SIZE)].next =
sec_hash->next;
if (sec_hash->next != NULL) {
sec_hash->next->prev = NULL;
}
} else {
sec_hash->prev->next = sec_hash->next;
if (sec_hash->next != NULL) {
sec_hash->next->prev = sec_hash->prev;
}
}
/* delete & destroy section node */
(void) ptree_delete_node(sec_hash->picl_hdl);
(void) ptree_destroy_node(sec_hash->picl_hdl);
free(sec_hash->u.sec_node);
free(sec_hash);
}
/*
* called from delete_frudata_props(), this routine free's the container
* hash object.
*/
static void
unlink_container_node(container_tbl_t *cont_hash)
{
if (cont_hash->prev == NULL) {
container_table[(cont_hash->picl_hdl % TABLE_SIZE)] =
cont_hash->next;
if (cont_hash->next != NULL) {
cont_hash->next->prev = NULL;
}
} else {
cont_hash->prev->next = cont_hash->next;
if (cont_hash->next != NULL) {
cont_hash->next->prev = cont_hash->prev;
}
}
}
/*
* called from frudata_event_handler() to free the corresponding hash object
* of the removed fru.
*/
static void
delete_frudata_props(picl_nodehdl_t fru_hdl)
{
hash_obj_t *cont_hash;
hash_obj_t *free_obj;
hash_obj_t *sec_hash;
container_tbl_t *cont_tbl;
(void) pthread_mutex_lock(&cont_tbl_lock);
cont_tbl = lookup_container_table(fru_hdl, CONTAINER_NODE);
if (cont_tbl == NULL) {
(void) pthread_mutex_unlock(&cont_tbl_lock);
return;
}
/* remove the container object from the container table */
unlink_container_node(cont_tbl);
(void) pthread_cond_broadcast(&cont_tbl->cond_var);
(void) pthread_mutex_unlock(&cont_tbl_lock);
/*
* waiting/blocking calling thread for all I/O in
* progress to complete. don't free the container
* hash before all I/O is complete.
*/
(void) pthread_rwlock_wrlock(&cont_tbl->rwlock);
(void) pthread_rwlock_unlock(&cont_tbl->rwlock);
cont_hash = lookup_node_object(fru_hdl, CONTAINER_NODE, cont_tbl);
if (cont_hash == NULL) {
return;
}
free_obj = cont_hash->u.cont_node->section_list;
/* walk through the section list */
for (sec_hash = free_obj; sec_hash != NULL; free_obj = sec_hash) {
sec_hash = sec_hash->u.sec_node->next;
free_section_node(free_obj, cont_tbl);
}
(void) fru_close_container(cont_hash->u.cont_node->cont_hdl);
free(cont_hash->u.cont_node);
free(cont_hash);
free(cont_tbl->hash_obj);
free(cont_tbl);
}
/*
* called when there is any state-change in location, fru, port nodes.
* this event handler handles only location state-changes.
*/
/* ARGSUSED */
static void
frudata_state_change_evhandler(const char *event_name, const void *event_arg,
size_t size, void *cookie)
{
int rc;
nvlist_t *nvlp;
ptree_propinfo_t prop;
picl_nodehdl_t loch, fruh;
picl_prophdl_t proph, prophdl;
char *present_state, *last_state;
char name[PICL_PROPNAMELEN_MAX];
if (strcmp(event_name, PICLEVENT_STATE_CHANGE) != 0)
return;
if (nvlist_unpack((char *)event_arg, size, &nvlp, NULL)) {
return;
}
if (nvlist_lookup_uint64(nvlp, PICLEVENTARG_NODEHANDLE,
&loch) == -1) {
nvlist_free(nvlp);
return;
}
if (ptree_get_propval_by_name(loch, PICL_PROP_CLASSNAME, name,
sizeof (name)) != PICL_SUCCESS) {
nvlist_free(nvlp);
return;
}
/* handle only location events */
if (strcmp(name, PICL_CLASS_LOCATION) != 0) {
nvlist_free(nvlp);
return;
}
if (nvlist_lookup_string(nvlp, PICLEVENTARG_STATE,
&present_state)) {
nvlist_free(nvlp);
return;
}
rc = ptree_get_propval_by_name(loch, PICL_PROP_CHILD,
&fruh, sizeof (picl_nodehdl_t));
if (rc != PICL_SUCCESS) {
nvlist_free(nvlp);
return;
}
/* fru removed */
if (strcmp(present_state, PICLEVENTARGVAL_EMPTY) == 0) {
delete_frudata_props(fruh);
nvlist_free(nvlp);
return;
}
if (nvlist_lookup_string(nvlp, PICLEVENTARG_LAST_STATE,
&last_state)) {
nvlist_free(nvlp);
return;
}
/* fru added */
if ((strcmp(last_state, PICLEVENTARGVAL_EMPTY) == 0) ||
(strcmp(last_state, PICLEVENTARGVAL_UNKNOWN) == 0)) {
rc = ptree_get_prop_by_name(fruh, PICL_PROP_FRUDATA_AVAIL,
&proph);
if (rc != PICL_SUCCESS) {
if (fru_is_data_available(fruh) == 0) {
nvlist_free(nvlp);
return;
}
/* create the property */
prop.version = PTREE_PROPINFO_VERSION;
prop.piclinfo.type = PICL_PTYPE_VOID;
prop.piclinfo.accessmode = PICL_READ;
prop.piclinfo.size = 0;
(void) strncpy(prop.piclinfo.name,
PICL_PROP_FRUDATA_AVAIL,
sizeof (prop.piclinfo.name));
rc = ptree_create_prop(&prop, NULL, &prophdl);
if (rc != PICL_SUCCESS) {
nvlist_free(nvlp);
return;
}
rc = ptree_add_prop(fruh, prophdl);
if (rc != PICL_SUCCESS) {
nvlist_free(nvlp);
return;
}
}
(void) create_container_prop(fruh);
}
nvlist_free(nvlp);
}
/*
* called when event is posted when is fru is either added or removed from
* the picltree.
*/
/* ARGSUSED */
static void
frudata_event_handler(const char *event_name, const void *event_arg,
size_t size, void *cookie)
{
int retval;
char fullfilename[PATH_MAX];
picl_nodehdl_t fru_picl_hdl;
picl_nodehdl_t roothdl;
if (strcmp(event_name, PICL_FRU_REMOVED) == 0) {
retval = nvlist_lookup_uint64((nvlist_t *)event_arg,
PICLEVENTARG_FRUHANDLE, &fru_picl_hdl);
if (retval != PICL_SUCCESS) {
return;
}
/* free the hash object */
delete_frudata_props(fru_picl_hdl);
} else if (strcmp(event_name, PICL_FRU_ADDED) == 0) {
/*
* reparse the configuration file to create
* FRUDevicePath Prop.
*/
(void) get_config_file(fullfilename);
retval = ptree_get_root(&roothdl);
if (retval != PICL_SUCCESS) {
return;
}
(void) picld_pluginutil_parse_config_file(roothdl,
fullfilename);
retval = nvlist_lookup_uint64((nvlist_t *)event_arg,
PICLEVENTARG_PARENTHANDLE, &fru_picl_hdl);
if (retval != PICL_SUCCESS) {
return;
}
/* create container property */
create_frudata_props(fru_picl_hdl);
}
}
/*
* Function : plugin_init() is called by daemon. this routine is specified
* while registering with daemon. it performs the initialization
* of plugin module.
*/
static void
frudata_plugin_init(void)
{
int retval;
int count;
char fullfilename[PATH_MAX];
picl_nodehdl_t fru_nodehdl;
picl_nodehdl_t roothdl;
retval = ptree_get_root(&roothdl);
if (retval != PICL_SUCCESS) {
return;
}
(void) ptree_register_handler(PICL_FRU_ADDED,
frudata_event_handler, NULL);
(void) ptree_register_handler(PICL_FRU_REMOVED,
frudata_event_handler, NULL);
(void) ptree_register_handler(PICLEVENT_STATE_CHANGE,
frudata_state_change_evhandler, NULL);
(void) pthread_mutex_lock(&cont_tbl_lock);
for (count = 0; count < TABLE_SIZE; count++) {
container_table[count] = NULL;
}
(void) pthread_mutex_unlock(&cont_tbl_lock);
(void) get_config_file(fullfilename);
(void) picld_pluginutil_parse_config_file(roothdl, fullfilename);
retval = ptree_get_node_by_path(FRUTREE_PATH, &fru_nodehdl);
if (retval != PICL_SUCCESS) {
return;
}
create_frudata_props(fru_nodehdl);
}
static void
free_packet_hash_object(hash_obj_t *pkt_obj)
{
hash_obj_t *tmp_obj;
while (pkt_obj != NULL) {
tmp_obj = pkt_obj->u.pkt_node->next;
free(pkt_obj->u.pkt_node);
free(pkt_obj);
pkt_obj = tmp_obj;
}
}
static void
free_segment_hash_object(hash_obj_t *seg_obj)
{
hash_obj_t *tmp_obj;
while (seg_obj != NULL) {
free_packet_hash_object(seg_obj->u.seg_node->packet_list);
tmp_obj = seg_obj->u.seg_node->next;
free(seg_obj->u.seg_node);
free(seg_obj);
seg_obj = tmp_obj;
}
}
static void
free_hash_objects(hash_obj_t *sec_obj)
{
hash_obj_t *tmp_obj;
while (sec_obj != NULL) {
free_segment_hash_object(sec_obj->u.sec_node->segment_list);
tmp_obj = sec_obj->u.sec_node->next;
free(sec_obj->u.sec_node);
free(sec_obj);
sec_obj = tmp_obj;
}
}
/*
* called from frudata_plugin_fini() this routine walks through
* the hash table to free each and very hash object in the hash table.
*/
static void
free_hash_table(void)
{
int cnt;
picl_nodehdl_t nodehdl;
hash_obj_t *next_obj;
hash_obj_t *sec_obj;
container_tbl_t *cont_tbl;
for (cnt = 0; cnt < TABLE_SIZE; cnt++) {
while (container_table[cnt]) {
(void) pthread_mutex_lock(&cont_tbl_lock);
cont_tbl = container_table[cnt];
nodehdl = cont_tbl->picl_hdl;
cont_tbl = lookup_container_table(nodehdl,
CONTAINER_NODE);
if (cont_tbl == NULL) {
(void) pthread_mutex_unlock(&cont_tbl_lock);
break;
}
unlink_container_node(cont_tbl);
pthread_cond_broadcast(&cont_tbl->cond_var);
(void) pthread_mutex_unlock(&cont_tbl_lock);
/*
* waiting/blocking calling thread for all I/O in
* progress to complete. don't free the container
* hash until all I/O is complete.
*/
(void) pthread_rwlock_wrlock(&cont_tbl->rwlock);
(void) pthread_rwlock_unlock(&cont_tbl->rwlock);
next_obj = cont_tbl->hash_obj->next;
if (next_obj == NULL) {
break;
}
if (next_obj->object_type == CONTAINER_NODE) {
sec_obj = next_obj->u.cont_node->section_list;
free_hash_objects(sec_obj);
}
free(next_obj->u.cont_node);
free(next_obj);
container_table[cnt] = cont_tbl->next;
free(cont_tbl);
}
}
}
/*
* called by the daemon and perform frudata cleanup. hold the write lock
* over the entire hash table to free each and every hash object.
*/
static void
frudata_plugin_fini(void)
{
free_hash_table();
(void) ptree_unregister_handler(PICL_FRU_ADDED,
frudata_event_handler, NULL);
(void) ptree_unregister_handler(PICL_FRU_REMOVED,
frudata_event_handler, NULL);
(void) ptree_unregister_handler(PICLEVENT_STATE_CHANGE,
frudata_state_change_evhandler, NULL);
}