/*
 * 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);
}