/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <pri.h>
#include "priplugin.h"

#pragma init(priplugin_register)        /* place in .init section */

static md_t *mdp;

static mutex_t  rebuild_lock;
static cond_t   rebuild_cv;

static thread_t pri_worker_thread_id, pri_reader_thread_id;
static boolean_t all_thr_exit = B_FALSE;
static boolean_t event_caught = B_FALSE;

static void priplugin_init(void);
static void priplugin_fini(void);
static void
event_handler(const char *ename, const void *earg, size_t size, void *cookie);
static void *pri_worker_thread(void *arg);
static void *pri_reader_thread(void *arg);
static int remove_old_segments(picl_nodehdl_t node, void *args);


picld_plugin_reg_t priplugin_reg = {
        PICLD_PLUGIN_VERSION_1,
        PICLD_PLUGIN_CRITICAL,
        "pri_plugin",
        priplugin_init,
        priplugin_fini
};

static void
set_prop_info(ptree_propinfo_t *propinfo, int size, char *name, int type)
{
        propinfo->version = PICLD_PLUGIN_VERSION_1;
        propinfo->read = NULL;
        propinfo->write = NULL;
        propinfo->piclinfo.type = type;
        propinfo->piclinfo.accessmode = PICL_READ;
        propinfo->piclinfo.size = size;
        (void) strlcpy(propinfo->piclinfo.name, name,
            sizeof (propinfo->piclinfo.name));
}

boolean_t
prop_exists(picl_nodehdl_t node, char *name)
{
        int status;
        picl_prophdl_t proph;

        status = ptree_get_prop_by_name(node, name, &proph);
        if (status == PICL_SUCCESS)
                return (B_TRUE);
        else
                return (B_FALSE);
}

void
add_md_prop(picl_nodehdl_t node, int size, char *name, void* value, int type)
{
        ptree_propinfo_t propinfo;
        picl_prophdl_t proph;

        if (!prop_exists(node, name)) {
                set_prop_info(&propinfo, size, name, type);

                (void) ptree_create_and_add_prop(node, &propinfo,
                    value, &proph);
        }
}

/*ARGSUSED*/
static int
remove_old_segments(picl_nodehdl_t node, void *args)
{
        int status;

        if ((status = ptree_delete_node(node)) == PICL_SUCCESS)
                ptree_destroy_node(node);
        else
                pri_debug(LOG_NOTICE, "remove_old_segments: can't delete "
                    "segment node: %s\n", picl_strerror(status));

        return (PICL_WALK_CONTINUE);
}

static void
priplugin_init(void)
{
        int status;

        pri_debug(LOG_NOTICE, "priplugin: mem tree and io label thread "
            "being created; callbacks being registered\n");

        all_thr_exit = B_FALSE;
        event_caught = B_FALSE;

        (void) mutex_init(&rebuild_lock, USYNC_THREAD, NULL);
        (void) cond_init(&rebuild_cv, USYNC_THREAD, NULL);

        if ((status = thr_create(NULL, 0, pri_worker_thread, NULL, THR_BOUND,
            &pri_worker_thread_id)) < 0) {
                pri_debug(LOG_NOTICE, "priplugin: can't create worker thread: "
                    "%d\n", status);
                all_thr_exit = B_TRUE;
                (void) mutex_destroy(&rebuild_lock);
                (void) cond_destroy(&rebuild_cv);
        } else if ((status = thr_create(NULL, 0, pri_reader_thread, NULL,
            THR_BOUND, &pri_reader_thread_id)) < 0) {
                pri_debug(LOG_NOTICE, "priplugin: can't create reader thread: "
                    "%d\n", status);
                (void) mutex_lock(&rebuild_lock);
                all_thr_exit = B_TRUE;
                (void) cond_signal(&rebuild_cv);
                (void) mutex_unlock(&rebuild_lock);
                (void) thr_join(pri_worker_thread_id, NULL, NULL);
                (void) mutex_destroy(&rebuild_lock);
                (void) cond_destroy(&rebuild_cv);
        } else {
                pri_debug(LOG_NOTICE, "priplugin_init: worker and reader "
                    "threads created - registering event handlers\n");
                /*
                 * register event_handler for both "sysevent-device-added",
                 * "sysevent_device_removed", and for
                 * "sysevent-dr-app-state-change" PICL events
                 */
                (void) ptree_register_handler(PICLEVENT_SYSEVENT_DEVICE_ADDED,
                    event_handler, NULL);
                (void) ptree_register_handler(PICLEVENT_SYSEVENT_DEVICE_REMOVED,
                    event_handler, NULL);
                (void) ptree_register_handler(PICLEVENT_DR_AP_STATE_CHANGE,
                    event_handler, NULL);
        }
}

/*
 * This thread handles the main processing of PRI data.  It is woken
 * up by either the event handler, to process a PICL event, or it is
 * woken up by the PRI reader thread which has just fetched a new
 * copy of the PRI.
 */
/*ARGSUSED*/
static void *
pri_worker_thread(void *arg)
{
        int status;
        picl_nodehdl_t picl_root_node;

        pri_debug(LOG_NOTICE, "pri_worker_thread: start\n");

        (void) mutex_lock(&rebuild_lock);
        /*LINTED E_FUNC_RET_MAYBE_IGNORED2*/
        while (1) {
                (void) cond_wait(&rebuild_cv, &rebuild_lock);

                if (all_thr_exit == B_TRUE) {
                        (void) mutex_unlock(&rebuild_lock);
                        pri_debug(LOG_NOTICE, "pri_worker_thread: time to "
                            "exit\n");
                        break;
                }

                /*
                 * We don't get events for changes to system memory,
                 * and we do not want to interfere with other plug-ins
                 * by making changes to the picl tree.  So if we were
                 * woken up by a thread then do not destroy and rebuild
                 * the memory info.  Just go fix the labels.
                 */
                if (event_caught == B_FALSE) {
                        status = ptree_get_root(&picl_root_node);
                        if (status != PICL_SUCCESS) {
                                pri_debug(LOG_NOTICE, "pri_worker_thread: "
                                    "can't get picl tree root node: %s\n",
                                    picl_strerror(status));
                                continue;
                        }

                        pri_debug(LOG_NOTICE, "pri_worker_thread: have root "
                            "picl and PRI nodes\n");

                        status = ptree_walk_tree_by_class(picl_root_node,
                            "memory-segment", NULL, remove_old_segments);
                        if (status != PICL_SUCCESS) {
                                pri_debug(LOG_NOTICE, "pri_worker_thread: "
                                    "can't remove old memory segments: \n",
                                    picl_strerror(status));
                        } else
                                pri_debug(LOG_NOTICE, "pri_worker_thread: "
                                    "old memory segments removed\n");

                        status = ptree_walk_tree_by_class(picl_root_node,
                            "memory", (void *) mdp, add_mem_prop);
                        if (status != PICL_SUCCESS) {
                                pri_debug(LOG_NOTICE, "pri_worker_thread: "
                                    "memory segments walk failed: \n",
                                    picl_strerror(status));
                        } else
                                pri_debug(LOG_NOTICE, "pri_worker_thread: "
                                    "success walking memory node\n");
                } else
                        event_caught = B_FALSE;

                io_dev_addlabel(mdp);
        }
        pri_debug(LOG_NOTICE, "pri_worker_thread: exiting\n");
        return (NULL);
}

/*
 * This thread camps out in the PRI driver, waiting for it to return
 * the contents of a new PRI.  When the PRI is changed this thread
 * reads that data and prepares it for processing by the worker thread.
 * It then signals the worker thread to process the new PRI data.
 */
/*ARGSUSED*/
static void *
pri_reader_thread(void *arg)
{
        uint64_t tok;
        int status, count;

        pri_debug(LOG_NOTICE, "pri_reader_thread: thread start\n");

        if (pri_init() != 0) {
                pri_debug(LOG_NOTICE, "pri_reader_thread: pri_init failed\n");
                return (NULL);
        }

        /*
         * It's entirely possible that a new PRI may get pushed while
         * the worker thread is processing the previous PRI.  We will
         * wait until the worker is finished, then flush the old contents
         * and wake up the worker again to process the new data.
         */
        mdp = NULL;
        tok = 0;
        count = 0;
        /*LINTED E_FUNC_RET_MAYBE_IGNORED2*/
        while (1) {
                /*
                 * The _fini() function will close the PRI's fd, which will
                 * cause this function to break out of waiting in the PRI
                 * driver and return an error.
                 */
                status = pri_devinit(&tok);

                (void) mutex_lock(&rebuild_lock);
                if (all_thr_exit == B_TRUE) {
                        (void) mutex_unlock(&rebuild_lock);
                        pri_debug(LOG_NOTICE, "pri_reader_thread: time to "
                            "exit\n");
                        break;
                }

                /*
                 * Wait until the worker is idle before swapping in the
                 * new PRI contents, then signal the worker to process
                 * that new data.
                 */
                if (status == 0) {
                        pri_debug(LOG_NOTICE, "pri_reader_thread: got PRI\n");

                        /* old buffer will be freed by pri_bufinit() */
                        mdp = pri_bufinit(mdp);
                        if (mdp != NULL) {
                                (void) cond_signal(&rebuild_cv);
                                count = 0;
                        } else {
                                pri_debug(LOG_NOTICE, "pri_reader_thread: "
                                    "NULL mdp!\n");
                                status = -1;
                        }
                }

                /*
                 * Try to handle SP resets or other unexplained errors
                 * from ds by closing down and re-opening the PRI driver.
                 */
                if (status == -1) {
                        if (errno != 0) {
                                pri_debug(LOG_NOTICE, "pri_reader_thread: "
                                    "can't get PRI contents: %s\n",
                                    strerror(errno));
                        }
                        if (++count > 6) {
                                pri_debug(LOG_NOTICE, "pci_reader_thread: "
                                    "can't process PRI data\n");
                                (void) mutex_unlock(&rebuild_lock);
                                break;
                        }
                        /* old buffer will be freed by pri_fini() */
                        pri_fini();
                        tok = 0;
                        sleep(10);
                        if (pri_init() != 0) {
                                pri_debug(LOG_NOTICE, "pci_reader_thread: "
                                    "can't reinitialize PRI driver\n");
                                (void) mutex_unlock(&rebuild_lock);
                                break;
                        }
                }
                (void) mutex_unlock(&rebuild_lock);
        }

        pri_debug(LOG_NOTICE, "pri_reader_thread: thread exiting\n");
        return (NULL);
}

static void
priplugin_fini(void)
{
        pri_debug(LOG_NOTICE, "priplugin_fini: called\n");

        if (all_thr_exit == B_TRUE)
                return;

        /* unregister the event handlers */
        (void) ptree_unregister_handler(PICLEVENT_SYSEVENT_DEVICE_ADDED,
            event_handler, NULL);
        (void) ptree_unregister_handler(PICLEVENT_SYSEVENT_DEVICE_REMOVED,
            event_handler, NULL);
        (void) ptree_unregister_handler(PICLEVENT_DR_AP_STATE_CHANGE,
            event_handler, NULL);

        /*
         * Set the exit flag to tell the worker thread to quit and wake
         * up that thread.  Once that thread is reaped then pull the rug
         * out from the PRI reader thread by calling pri_fini(), which
         * closes the PRI fd.  That wakes the PRI reader thread and it
         * will then exit as well.
         */
        (void) mutex_lock(&rebuild_lock);
        all_thr_exit = B_TRUE;
        (void) cond_signal(&rebuild_cv);
        (void) mutex_unlock(&rebuild_lock);

        (void) thr_join(pri_worker_thread_id, NULL, NULL);

        pri_devfini(mdp);
        mdp = NULL;
        pri_fini();
        (void) thr_join(pri_reader_thread_id, NULL, NULL);

        (void) mutex_destroy(&rebuild_lock);
        (void) cond_destroy(&rebuild_cv);
}

void
priplugin_register(void)
{
        picld_plugin_register(&priplugin_reg);
}

/*
 * Discovery event handler
 * respond to the picl events:
 *      PICLEVENT_SYSEVENT_DEVICE_ADDED
 *      PICLEVENT_SYSEVENT_DEVICE_REMOVED
 *      PICLEVENT_DR_AP_STATE_CHANGE
 *
 * We can't do much of anything fancy since the event data doesn't contain
 * a nac for the device.  Nothing to do for remove - the devtree plug-in
 * will have removed the node for us.  For add we have to go back and
 * add labels again.
 */
static void
event_handler(const char *ename, const void *earg, size_t size, void *cookie)
{

        pri_debug(LOG_NOTICE, "pri: event_handler: caught event "
            "%s\n", ename);
        if ((strcmp(ename, PICLEVENT_SYSEVENT_DEVICE_ADDED) == 0) ||
            (strcmp(ename, PICLEVENT_SYSEVENT_DEVICE_REMOVED) == 0) ||
            (strcmp(ename, PICLEVENT_DR_AP_STATE_CHANGE) == 0)) {
                pri_debug(LOG_NOTICE, "pri: event_handler: handle event "
                    "%s; waking worker thread\n", ename);

                (void) mutex_lock(&rebuild_lock);

                if (all_thr_exit == B_FALSE) {
                        /*
                         * Tell the worker thread to only re-examine the
                         * IO device labels.
                         */
                        event_caught = B_TRUE;
                        (void) cond_signal(&rebuild_cv);
                }

                (void) mutex_unlock(&rebuild_lock);
        }
}

/*VARARGS2*/
void
pri_debug(int level, char *fmt, ...)
{
#if (PRI_DEBUG != 0)
        va_list ap;

        va_start(ap, fmt);
        vsyslog(level, fmt, ap);
        va_end(ap);
#endif
}