xref: /illumos-gate/usr/src/cmd/picl/plugins/sun4u/frudata/fru_data.c (revision ada2da53)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#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);
		free(cont_tbl->hash_obj);
		free(cont_tbl);
		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, 0)) {
		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);
}