dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / libpicl / picl.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * This module implements the PICL Interface used by PICL clients
 * to access services of the PICL daemon
 *
 * Locking Strategy
 * A single reader/writer lock (icl_lock) protects the access to the interface
 * to the picl daemon, and the reference count, refcnt, variable.
 * A reader lock is obtained to send a request to the daemon.
 * A writer lock is obtained to initialize, reinitialize, or shutdown
 * the interface.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <alloca.h>
#include <fcntl.h>
#include <libintl.h>
#include <errno.h>
#include <sys/mman.h>
#include <door.h>
#include <sys/door.h>
#include <sys/time.h>
#include <assert.h>
#include <synch.h>
#include <limits.h>
#include <picl.h>
#include "picl2door.h"

/*
 * Module variables
 */
static  int             door_handle = -1;
static  uint32_t        refcnt = 0;
static  rwlock_t        picl_lock = DEFAULTRWLOCK;

static  char            *picl_errmsg[] = {
        "No error",
        "General system failure",
        "Daemon not responding",
        "Unknown PICL service",
        "Session not initialized",
        "Invalid arguments",
        "Argument too big",
        "Property not found",
        "Not a table property handle",
        "Not a node handle",
        "Not a property handle",
        "End of property list",
        "Property already exists",
        "Property not writable",
        "Insufficient permissions",
        "Invalid handle",
        "Stale handle",
        "Unsupported version",
        "Wait timed out",
        "Attempting to destroy before delete",
        "PICL Tree is busy",
        "Already has a parent",
        "Property name is reserved",
        "Invalid reference value",
        "Continue tree walk",
        "Terminate tree walk",
        "Node not found",
        "Not enough space available",
        "Property not readable",
        "Property value unavailable"
};

#define N_ERRORS                (sizeof (picl_errmsg)/sizeof (picl_errmsg[0]))
#define SEND_REQ_TRYCOUNT       1

/*
 * This function sends the client request to the daemon using a door call.
 * If door_handle is -1, it returns PICL_NOTINITIALIZED.
 * If the door_call fails, it returns PICL_NORESPONSE. Otherwise, it
 * checks the response from the daemon for error. If an error is returned
 * this function returns the error code returned and unmaps any
 * memory mapped by the door call. For successful results, the caller is
 * responsible to unmap the mapped memory after retrieving the results.
 *
 * This function does not attempt to reinitialize the interface if the
 * initial door_call fails. It is called from handshake() , shutdown()
 * and trysend_req() routines.
 */
static int
post_req(door_arg_t *dargp, void *data_ptr, size_t data_size,
    door_desc_t *desc_ptr, uint_t desc_num, void *rbuf, size_t rsize)
{
        int             err;
        picl_service_t  *ret;
        int             req_cnum;

        req_cnum = ((picl_service_t *)data_ptr)->in.cnum;
        dargp->data_ptr = data_ptr;
        dargp->data_size = data_size;
        dargp->desc_ptr = desc_ptr;
        dargp->desc_num = desc_num;
        dargp->rbuf = rbuf;
        dargp->rsize = rsize;

        if (door_call(door_handle, dargp) < 0)
                return (PICL_NORESPONSE);

        /*LINTED*/
        ret = (picl_service_t *)dargp->rbuf;
        if (ret->in.cnum == req_cnum)
                return (PICL_SUCCESS);
        else if ((ret->in.cnum == PICL_CNUM_ERROR) &&
            (ret->ret_error.in_cnum == req_cnum))
                err = ret->ret_error.errnum;
        else
            err = PICL_UNKNOWNSERVICE;
        if (dargp->rbuf != rbuf)
                (void) munmap(dargp->rbuf, dargp->rsize);
        return (err);
}

/*
 * This function posts an INIT message to the daemon to
 * verify communication channel.
 */
static int
handshake(void)
{
        int             err;
        door_arg_t      darg;
        picl_reqinit_t  req;
        picl_retinit_t  outargs;

        req.cnum = PICL_CNUM_INIT;
        req.clrev = PICL_VERSION_1;

        if ((err = post_req(&darg, &req, sizeof (picl_reqinit_t), NULL,
            0, &outargs, sizeof (picl_retinit_t))) != PICL_SUCCESS)
                return (err);

        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function calls post_req() to make door_call and reinitializes
 * the interface is post_req() fails.
 */
static int
trysend_req(door_arg_t *dargp, void *data_ptr, size_t data_size,
    door_desc_t *desc_ptr, uint_t desc_num, void *rbuf, size_t rsize,
        unsigned int trycount)
{
        int     err;
        int     write_locked;

        write_locked = 0;
        (void) rw_rdlock(&picl_lock);
        if (refcnt == 0) {
                (void) rw_unlock(&picl_lock);   /* read unlock */
                return (PICL_NOTINITIALIZED);
        }

        while ((err = post_req(dargp, data_ptr, data_size, desc_ptr, desc_num,
            rbuf, rsize)) == PICL_NORESPONSE) {
                if (trycount == 0)      /* no more retry */
                        break;

                if (write_locked == 1) {        /* close and open door */
                        (void) close(door_handle);
                        if ((door_handle = open(PICLD_DOOR, O_RDONLY)) < 0) {
                                err = PICL_NORESPONSE;
                                break;
                        }
                        --trycount;
                        continue;
                }
                /*
                 * Upgrade read to a write lock
                 */
                (void) rw_unlock(&picl_lock);
                (void) rw_wrlock(&picl_lock);

                /*
                 * if picl_shutdown happens during lock upgrade
                 */
                if (refcnt == 0) {
                        err =  PICL_NOTINITIALIZED;
                        break;
                }
                write_locked = 1;
                continue;
        }
        (void) rw_unlock(&picl_lock);   /* read or write unlock */
        return (err);
}

/*
 * Initialize the PICL interface
 * Increment the reference count.
 */
int
picl_initialize(void)
{
        int     err;

        (void) rw_wrlock(&picl_lock);
        if (refcnt > 0) {               /* previously initialized */
                err = handshake();
                if (err == PICL_SUCCESS) {
                        ++refcnt;
                        (void) rw_unlock(&picl_lock);   /* write unlock */
                        return (err);
                }
                if (err != PICL_NORESPONSE) {
                        (void) rw_unlock(&picl_lock);   /* write unlock */
                        return (err);
                }
                (void) close(door_handle);      /* close bad door */
        }

        /*
         * Open picld door and initialize door_handle
         */
        if ((door_handle = open(PICLD_DOOR, O_RDONLY)) < 0) {
                (void) rw_unlock(&picl_lock); /* write unlock */
                return (PICL_NORESPONSE);
        }

        err = handshake();
        if (err != PICL_SUCCESS)
                (void) close(door_handle);
        else
                ++refcnt;
        (void) rw_unlock(&picl_lock);   /* write unlock */
        return (err);
}

/*
 * Shutdown the PICL interface
 * Decrement the reference count and close the door_handle if refcnt is zero
 */
int
picl_shutdown(void)
{
        int             err;
        door_arg_t      darg;
        picl_reqfini_t  req_fini;
        picl_retfini_t  outargs;

        (void) rw_wrlock(&picl_lock);   /* write lock */
        if (refcnt == 0) {
                (void) rw_unlock(&picl_lock);   /* write unlock */
                return (PICL_NOTINITIALIZED);
        }
        req_fini.cnum = PICL_CNUM_FINI;
        err = post_req(&darg, &req_fini, sizeof (picl_reqfini_t),
            NULL, 0, &outargs, sizeof (picl_retfini_t));
        --refcnt;
        if (refcnt == 0)
                (void) close(door_handle);
        (void) rw_unlock(&picl_lock);   /* write unlock */
        if (err != PICL_SUCCESS)
                return (err);
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function waits for the specified number of seconds for a PICL
 * tree refresh.
 */
int
picl_wait(unsigned int secs)
{
        door_arg_t      darg;
        picl_reqwait_t  req_wait;
        picl_retwait_t  outargs;
        picl_service_t  *ret;
        int             err;

        req_wait.cnum = PICL_CNUM_WAIT;
        req_wait.secs = secs;
        err = trysend_req(&darg, &req_wait, sizeof (picl_reqwait_t),
            NULL, 0, &outargs, sizeof (picl_retwait_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        err = ret->ret_wait.retcode;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (err);
}

/*
 * This function copies the handle of the root node of the PICL tree into
 * the buffer <rooth>
 */
int
picl_get_root(picl_nodehdl_t *rooth)
{
        door_arg_t      darg;
        picl_reqroot_t  req_root;
        picl_retroot_t  outargs;
        picl_service_t  *ret;
        int     err;

        req_root.cnum = PICL_CNUM_GETROOT;
        err = trysend_req(&darg, &req_root, sizeof (picl_reqroot_t), NULL,
            0, &outargs, sizeof (picl_retroot_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);
        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *rooth = ret->ret_root.rnode;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the value of the property specified by its handle
 * into the buffer <valbuf>.
 */
int
picl_get_propval(picl_prophdl_t proph, void *valbuf, size_t nbytes)
{
        door_arg_t              darg;
        picl_reqattrval_t       req_attrval;
        picl_service_t          *ret;
        picl_retattrval_t       *outargs;
        int                     err;

        req_attrval.cnum = PICL_CNUM_GETATTRVAL;
        req_attrval.attr = proph;
        req_attrval.bufsize = (uint32_t)nbytes;
        if ((size_t)req_attrval.bufsize != nbytes)
                return (PICL_VALUETOOBIG);
        outargs = alloca(sizeof (picl_retattrval_t) + nbytes);

        err = trysend_req(&darg, &req_attrval, sizeof (picl_reqattrval_t),
            NULL, 0, outargs, sizeof (picl_retattrval_t) + nbytes,
            SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        if (ret->ret_attrval.nbytes > (uint32_t)nbytes)
                err = PICL_VALUETOOBIG;
        else
                (void) memcpy(valbuf, ret->ret_attrval.ret_buf,
                    (size_t)ret->ret_attrval.nbytes);
        if (darg.rbuf != (char *)outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (err);
}

/*
 * This function copies the value of the property specified by its
 * name into the buffer <valbuf>
 */
int
picl_get_propval_by_name(picl_nodehdl_t nodeh, const char *propname,
    void *valbuf, size_t nbytes)
{
        door_arg_t              darg;
        picl_reqattrvalbyname_t req_attrvalbyname;
        picl_service_t          *ret;
        picl_retattrvalbyname_t *outargs;
        int                     err;

        req_attrvalbyname.cnum = PICL_CNUM_GETATTRVALBYNAME;
        req_attrvalbyname.nodeh = nodeh;
        (void) strcpy(req_attrvalbyname.propname, propname);
        req_attrvalbyname.bufsize = (uint32_t)nbytes;
        if ((size_t)req_attrvalbyname.bufsize != nbytes)
                return (PICL_VALUETOOBIG);
        outargs = alloca(sizeof (picl_retattrvalbyname_t) + nbytes);

        err = trysend_req(&darg, &req_attrvalbyname,
            sizeof (picl_reqattrvalbyname_t), NULL, 0, outargs,
            sizeof (picl_retattrvalbyname_t) + nbytes, SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        if (ret->ret_attrvalbyname.nbytes > (uint32_t)nbytes)
                err = PICL_VALUETOOBIG;
        else
                (void) memcpy(valbuf, ret->ret_attrvalbyname.ret_buf,
                    (size_t)ret->ret_attrvalbyname.nbytes);
        if (darg.rbuf != (char *)outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (err);
}

/*
 * This function sets the value of the property specified by its
 * handle with the value specified in <valbuf>.
 */
int
picl_set_propval(picl_prophdl_t proph, void *valbuf, size_t nbytes)
{
        door_arg_t              darg;
        picl_reqsetattrval_t    ret_setattrval;
        picl_reqsetattrval_t    *inargs;
        int                     err;

        if (nbytes >= (size_t)PICL_PROPSIZE_MAX)
                return (PICL_VALUETOOBIG);

        inargs = alloca(sizeof (picl_reqsetattrval_t) + nbytes);
        inargs->cnum = PICL_CNUM_SETATTRVAL;
        inargs->attr = proph;
        inargs->bufsize = (uint32_t)nbytes;
        if ((size_t)inargs->bufsize != nbytes)
                return (PICL_VALUETOOBIG);
        (void) memcpy(inargs->valbuf, valbuf, nbytes);

        err = trysend_req(&darg, inargs, sizeof (picl_reqsetattrval_t) +
            nbytes, NULL, 0, &ret_setattrval,
            sizeof (picl_retsetattrval_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        if (darg.rbuf != (char *)&ret_setattrval)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function sets the value of the property specified by its
 * name with the value given in <valbuf>
 */
int
picl_set_propval_by_name(picl_nodehdl_t nodeh, const char *propname,
    void *valbuf, size_t nbytes)
{
        door_arg_t                      darg;
        picl_retsetattrvalbyname_t      ret_setattrvalbyname;
        picl_reqsetattrvalbyname_t      *inargs;
        int                             err;

        if (nbytes >= (size_t)PICL_PROPSIZE_MAX)
                return (PICL_VALUETOOBIG);

        inargs = alloca(sizeof (picl_reqsetattrvalbyname_t) + nbytes);
        inargs->cnum = PICL_CNUM_SETATTRVALBYNAME;
        inargs->nodeh = nodeh;
        (void) strcpy(inargs->propname, propname);
        inargs->bufsize = (uint32_t)nbytes;
        if ((size_t)inargs->bufsize != nbytes)
                return (PICL_VALUETOOBIG);
        (void) memcpy(inargs->valbuf, valbuf, nbytes);

        err = trysend_req(&darg, inargs,
            sizeof (picl_reqsetattrvalbyname_t) + nbytes, NULL, 0,
            &ret_setattrvalbyname, sizeof (picl_retsetattrvalbyname_t),
            SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        if (darg.rbuf != (char *)&ret_setattrvalbyname)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the information of the specified property
 * into <pinfo>
 */
int
picl_get_propinfo(picl_prophdl_t proph, picl_propinfo_t *pinfo)
{
        door_arg_t              darg;
        picl_reqattrinfo_t      req_attrinfo;
        picl_service_t          *ret;
        picl_retattrinfo_t      outargs;
        int                     err;

        req_attrinfo.cnum = PICL_CNUM_GETATTRINFO;
        req_attrinfo.attr = proph;

        err = trysend_req(&darg, &req_attrinfo,
            sizeof (picl_reqattrinfo_t), NULL, 0, &outargs,
            sizeof (picl_retattrinfo_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        pinfo->type = ret->ret_attrinfo.type;
        pinfo->accessmode = ret->ret_attrinfo.accessmode;
        pinfo->size = (size_t)ret->ret_attrinfo.size;
        (void) strcpy(pinfo->name, ret->ret_attrinfo.name);
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the first property of a node into
 * <proph>
 */
int
picl_get_first_prop(picl_nodehdl_t nodeh, picl_prophdl_t *proph)
{
        door_arg_t              darg;
        picl_reqfirstattr_t     req_firstattr;
        picl_service_t          *ret;
        picl_retfirstattr_t     outargs;
        int                     err;

        req_firstattr.cnum = PICL_CNUM_GETFIRSTATTR;
        req_firstattr.nodeh = nodeh;

        err = trysend_req(&darg, &req_firstattr,
            sizeof (picl_reqfirstattr_t), NULL, 0, &outargs,
            sizeof (picl_retfirstattr_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *proph = ret->ret_firstattr.attr;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the next property in list
 * into <nextprop>.
 */
int
picl_get_next_prop(picl_prophdl_t proph, picl_prophdl_t *nextprop)
{
        door_arg_t              darg;
        picl_reqnextattr_t      req_nextattr;
        picl_service_t          *ret;
        picl_retnextattr_t      outargs;
        int                     err;


        req_nextattr.cnum = PICL_CNUM_GETNEXTATTR;
        req_nextattr.attr = proph;

        err = trysend_req(&darg, &req_nextattr,
            sizeof (picl_reqnextattr_t), NULL, 0,  &outargs,
            sizeof (picl_retnextattr_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *nextprop = ret->ret_nextattr.nextattr;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the property specified by its
 * name into <proph>.
 */
int
picl_get_prop_by_name(picl_nodehdl_t nodeh, const char *name,
    picl_prophdl_t *proph)
{
        door_arg_t              darg;
        picl_reqattrbyname_t    req_attrbyname;
        picl_service_t          *ret;
        picl_retattrbyname_t    outargs;
        int                     err;

        req_attrbyname.cnum = PICL_CNUM_GETATTRBYNAME;
        req_attrbyname.nodeh = nodeh;
        (void) strcpy(req_attrbyname.propname, name);

        err = trysend_req(&darg, &req_attrbyname,
            sizeof (picl_reqattrbyname_t), NULL, 0, &outargs,
            sizeof (picl_retattrbyname_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *proph = ret->ret_attrbyname.attr;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the next property on the same
 * row of the table into <rowproph>.
 * When proph is the table handle, the handle of the property that is
 * in first row and first column is copied.
 */
int
picl_get_next_by_row(picl_prophdl_t proph, picl_prophdl_t *rowproph)
{
        door_arg_t              darg;
        picl_reqattrbyrow_t     req_attrbyrow;
        picl_service_t          *ret;
        picl_retattrbyrow_t     outargs;
        int                     err;

        req_attrbyrow.cnum = PICL_CNUM_GETATTRBYROW;
        req_attrbyrow.attr = proph;

        err = trysend_req(&darg, &req_attrbyrow,
            sizeof (picl_reqattrbyrow_t), NULL, 0, &outargs,
            sizeof (picl_retattrbyrow_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *rowproph = ret->ret_attrbyrow.rowattr;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the next property on the same
 * column of the table into <colproph>.
 * When proph is the table handle, the handle of the property that is
 * in the first row and first column is copied.
 */
int
picl_get_next_by_col(picl_prophdl_t proph, picl_prophdl_t *colproph)
{
        door_arg_t              darg;
        picl_reqattrbycol_t     req_attrbycol;
        picl_service_t          *ret;
        picl_retattrbycol_t     outargs;
        int                     err;

        req_attrbycol.cnum = PICL_CNUM_GETATTRBYCOL;
        req_attrbycol.attr = proph;

        err = trysend_req(&darg, (char *)&req_attrbycol,
            sizeof (picl_reqattrbycol_t), NULL, 0, (char *)&outargs,
            sizeof (picl_retattrbycol_t), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *colproph = ret->ret_attrbycol.colattr;
        if (darg.rbuf != (char *)&outargs)
                (void) munmap(darg.rbuf, darg.rsize);
        return (PICL_SUCCESS);
}

/*
 * This function returns the picl error messages corresponding to the
 * error number.
 */
char *
picl_strerror(int err)
{
        if ((err < N_ERRORS) && (err >= 0)) {
                return (gettext(picl_errmsg[err]));
        }
        return (NULL);
}

/*
 * recursively visit all nodes
 */
static int
do_walk(picl_nodehdl_t rooth, const char *classname,
    void *c_args, int (*callback_fn)(picl_nodehdl_t hdl, void *args))
{
        int             err;
        picl_nodehdl_t  chdh;
        char            classval[PICL_CLASSNAMELEN_MAX];

        err = picl_get_propval_by_name(rooth, PICL_PROP_CHILD, &chdh,
            sizeof (chdh));
        while (err == PICL_SUCCESS) {
                err = picl_get_propval_by_name(chdh, PICL_PROP_CLASSNAME,
                    classval, sizeof (classval));
                if (err != PICL_SUCCESS)
                        return (err);

                if ((classname == NULL) || (strcmp(classname, classval) == 0)) {
                        err = callback_fn(chdh, c_args);
                        if (err != PICL_WALK_CONTINUE)
                                return (err);
                }

                if ((err = do_walk(chdh, classname, c_args, callback_fn)) !=
                    PICL_WALK_CONTINUE)
                        return (err);

                err = picl_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
                    sizeof (chdh));
        }
        if (err == PICL_PROPNOTFOUND)   /* end of a branch */
                return (PICL_WALK_CONTINUE);
        return (err);

}

/*
 * This function walks the tree by class and invokes the callback
 * function on class name matches.
 */
int
picl_walk_tree_by_class(picl_nodehdl_t rooth, const char *classname,
    void *c_args, int (*callback_fn)(picl_nodehdl_t hdl, void *args))
{
        int             err;

        if (callback_fn == NULL)
                return (PICL_INVALIDARG);
        err = do_walk(rooth, classname, c_args, callback_fn);
        if ((err == PICL_WALK_CONTINUE) || (err == PICL_WALK_TERMINATE))
                return (PICL_SUCCESS);
        return (err);
}

/*
 * This function gets propinfo and prop handle of the named property
 */
int
picl_get_propinfo_by_name(picl_nodehdl_t nodeh, const char *prop_name,
    picl_propinfo_t *pinfo, picl_prophdl_t *proph)
{
        int             err;
        picl_prophdl_t  tmpproph;
        picl_propinfo_t tmppinfo;

        err = picl_get_prop_by_name(nodeh, prop_name, &tmpproph);
        if (err != PICL_SUCCESS)
                return (err);

        err = picl_get_propinfo(tmpproph, &tmppinfo);
        if (err != PICL_SUCCESS)
                return (err);

        *proph = tmpproph;
        *pinfo = tmppinfo;
        return (PICL_SUCCESS);
}

int
picl_get_node_by_path(const char *piclpath, picl_nodehdl_t *nodeh)
{
        door_arg_t              darg;
        picl_reqnodebypath_t    req;
        picl_retnodebypath_t    out;
        picl_service_t          *ret;
        int     err;

        req.cnum = PICL_CNUM_NODEBYPATH;
        req.psize = PATH_MAX;
        if (strlen(piclpath) >= PATH_MAX)
                return (PICL_VALUETOOBIG);
        (void) strncpy(req.pathbuf, piclpath, PATH_MAX);

        err = trysend_req(&darg, &req, sizeof (req), NULL, 0, &out,
            sizeof (out), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *nodeh = ret->ret_nodebypath.nodeh;
        if (darg.rbuf != (char *)&out)
                (void) munmap(darg.rbuf, darg.rsize);
        return (err);
}

int
picl_find_node(picl_nodehdl_t rooth, char *pname, picl_prop_type_t ptype,
    void *pval, size_t valsize, picl_nodehdl_t *retnodeh)
{
        door_arg_t              darg;
        picl_reqfindnode_t      *req;
        picl_service_t          *ret;
        picl_retfindnode_t      out;
        int                     err;

        req = alloca(sizeof (picl_reqfindnode_t) + valsize);
        req->cnum = PICL_CNUM_FINDNODE;
        req->nodeh = rooth;
        if (strlen(pname) >= PICL_PROPNAMELEN_MAX)
                return (PICL_VALUETOOBIG);
        (void) strncpy(req->propname, pname, PICL_PROPNAMELEN_MAX);
        req->ptype = ptype;
        req->valsize = (uint32_t)valsize;
        if ((size_t)req->valsize != valsize)
                return (PICL_VALUETOOBIG);
        (void) memcpy(req->valbuf, pval, valsize);

        err = trysend_req(&darg, req, sizeof (picl_reqfindnode_t) + valsize,
            NULL, 0, &out, sizeof (out), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *retnodeh = ret->ret_findnode.rnodeh;
        if (darg.rbuf != (char *)&out)
                (void) munmap(darg.rbuf, darg.rsize);
        return (err);
}

int
picl_get_frutree_parent(picl_nodehdl_t devh, picl_nodehdl_t *fruh)
{
        door_arg_t              darg;
        picl_reqfruparent_t     req;
        picl_retfruparent_t     out;
        picl_service_t          *ret;
        int                     err;

        req.cnum = PICL_CNUM_FRUTREEPARENT;
        req.devh = devh;

        err = trysend_req(&darg, &req, sizeof (req), NULL, 0, &out,
            sizeof (out), SEND_REQ_TRYCOUNT);
        if (err != PICL_SUCCESS)
                return (err);

        /*LINTED*/
        ret = (picl_service_t *)darg.rbuf;
        *fruh = ret->ret_fruparent.fruh;
        if (darg.rbuf != (char *)&out)
                (void) munmap(darg.rbuf, darg.rsize);
        return (err);
}