/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * SCSI Enclosure Services Log Transport Module
 *
 * This transport module is responsible for accessing the ses devices seen
 * from this host, reading their logs, generating ereports for targeted
 * entries, and then writing the log contents to a well known location in
 * the filesystem.
 *
 */

#include <ctype.h>
#include <fm/fmd_api.h>
#include <fm/libtopo.h>
#include <fm/topo_hc.h>
#include <fm/topo_mod.h>
#include <limits.h>
#include <string.h>
#include <sys/fm/io/scsi.h>
#include <sys/fm/protocol.h>
#include <stdio.h>
#include <time.h>
#include <fm/libseslog.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

/*
 * This struct contains the default property values.  These may
 * be overridden by entries in a ses_log_transport.conf file.
 * The severity is set to -1 here so that the _fmd_init routine will
 * determine the default severity based on the constants in libseslog.h.
 */
static const fmd_prop_t fmd_props[] = {
        { "interval",   FMD_TYPE_TIME,      "60s"},
        { "severity",   FMD_TYPE_INT32,     "-1"},
        { "path",       FMD_TYPE_STRING,    "/var/fm/fmd/ses_logs/"},
        { "logcount",   FMD_TYPE_UINT32,    "5"},
        { "maxlogsize", FMD_TYPE_UINT32,    "1000000"},
        { NULL, 0,      NULL}
};

/* Maintains statistics on dropped ereports. */
static struct slt_stat
{
        fmd_stat_t dropped;
} slt_stats = {
        { "dropped", FMD_TYPE_UINT64, "number of dropped ereports"}
};

/*
 * This structure maintains a reference to the input values, transport, and
 * other data which is held by FMD and retrieved whenever an entry point
 * is called.
 */
typedef struct ses_log_monitor
{
        fmd_hdl_t *slt_hdl;         /* opaque handle for this transport */
        fmd_xprt_t *slt_xprt;       /* ereport transport */
        id_t slt_timer;             /* Timer for FMD polling use */
        hrtime_t slt_interval;      /* Polling interval */
        int32_t slt_severity;       /* Min severity for logging ereports */
        char *slt_path;             /* Output path for log files */
        int32_t slt_log_count;      /* Max rolled logs to keep  */
        int32_t slt_max_log_size;   /* Max log size before rolling */
        nvlist_t *slt_expanders;    /* List of expander log entries */
} ses_log_monitor_t;

/* Contains expander log data retrieved from a topology node */
typedef struct expander
{
        char slt_label[MAXNAMELEN]; /* The expander name */
        char slt_pid[MAXNAMELEN];   /* The system product id */
        char slt_key[MAXNAMELEN];   /* The expander key (sas address) */
        char slt_path[MAXPATHLEN];  /* The ses path to the expander */
        nvlist_t *fmri;             /* The fmri for this target */
} expander_t;

#define DATA_FIELD              "data"      /* Label for the expander details */
#define DEFAULT_DATA            "0"         /* Default expander details value */
#define MIN_LOG_SIZE            100000      /* The minimum log file size. */
#define MIN_LOG_COUNT           1           /* Num of rolled files to keep */
#define EXAMINE_FMRI_VALUE      0           /* Extract fmri val */
#define INVERT_FMRI_INSTANCE    1           /* Invert an FMRI instance value */
#define FATAL_ERROR             "fatal"     /* ereport val for fatal errors */
#define NON_FATAL_ERROR         "non-fatal" /* val for non fatal errors */
#define INVALID_OPERATION       0x01        /* Invalid access_fmri operation */
#define NULL_LOG_DATA           0x02        /* Lib returned NULL log ref */
#define INVALID_SEVERITY        0x03        /* Invalid severity value */
#define DATE_STRING_SIZE        16          /* Size of date string prefix. */

/* Prototype needed for use in declaring and populating tables */
static int invert_fmri(ses_log_monitor_t *, nvlist_t *);

/* Holds a code-operation pair.  Contains a log code an a function ptr */
typedef struct code_operation {
        int code;
        int (*func_ptr)(ses_log_monitor_t *, nvlist_t *);
} code_operation_t;

/* Holds a platform type and a list of code-operation structures */
typedef struct platform {
        const char *pid;
        int count;
        code_operation_t *codes;
} platform_t;

/* Holds a reference to all of the platforms */
typedef struct platforms {
        int pcount;
        platform_t *plist;
} platforms_t;

/* This is the genesis list of codes and functions. */
static code_operation_t genesis_codes[] = {
        { 684002, invert_fmri },    /* Alternate expander is down */
        { 685002, invert_fmri }     /* Alternate expander is down */
};

/* This is the list of all platforms and their associated code op pairs. */
static platform_t platform_list[] = {
        { "SUN-GENESIS",
            sizeof (genesis_codes) / sizeof (code_operation_t),
            genesis_codes }
};

/* This structure holds a reference to the platform list. */
static const platforms_t platforms = {
        sizeof (platform_list) / sizeof (platform_t),
        platform_list
};

/*
 * Post ereports using this method.
 */
static void
slt_post_ereport(fmd_hdl_t *hdl, fmd_xprt_t *xprt, const char *ereport_class,
    uint64_t ena, nvlist_t *detector, nvlist_t *payload)
{
        nvlist_t *nvl;
        int e = 0;
        char fullclass[PATH_MAX];

        (void) snprintf(fullclass, sizeof (fullclass), "%s.io.sas.log.%s",
            FM_EREPORT_CLASS, ereport_class);

        if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) == 0) {

                e |= nvlist_add_string(nvl, FM_CLASS, fullclass);
                e |= nvlist_add_uint8(nvl, FM_VERSION, FM_EREPORT_VERSION);
                e |= nvlist_add_uint64(nvl, FM_EREPORT_ENA, ena);
                e |= nvlist_add_nvlist(nvl, FM_EREPORT_DETECTOR, detector);
                e |= nvlist_merge(nvl, payload, 0);

                if (e == 0) {
                        fmd_xprt_post(hdl, xprt, nvl, 0);
                } else {
                        nvlist_free(nvl);
                        fmd_hdl_debug(hdl, "Error adding fields to ereport");
                        slt_stats.dropped.fmds_value.ui64++;
                }
        } else {
                fmd_hdl_debug(hdl, "Could not allocate space for ereport");
                slt_stats.dropped.fmds_value.ui64++;
        }
}

/*
 * Create a directory if it doesn't exist.
 * Parameters:
 * path: The directory path to create.
 * mode: The mode used when creating the directory.
 */
static int
do_mkdir(const char *path, mode_t mode)
{
        struct stat st;
        int status = 0;

        if (stat(path, &st) != 0) {
                /* Directory does not exist */
                if (mkdir(path, mode) != 0)
                        status = -1;
        } else if (!S_ISDIR(st.st_mode)) {
                errno = ENOTDIR;
                status = -1;
        }

        return (status);
}

/*
 * Validates that all directories in path exist
 * path: The directory path to create.
 * mode: The mode used when creating the directory.
 */
static int
mkpath(char *path, mode_t mode)
{
        char *pp;
        char *sp;
        int status = 0;

        pp = path;
        while (status == 0 && (sp = strchr(pp, '/')) != 0) {
                if (sp != pp) {
                        /* Neither root nor double slash in path */
                        *sp = '\0';
                        status = do_mkdir(path, mode);
                        *sp = '/';
                }
                pp = sp + 1;
        }

        return (status);
}

/*
 * Rotate the file from base.max-1->base.max, ... base.1->base.2, base->base.1
 * Parameter:
 * file: The name of the current log file.
 */
void
check_file_size(ses_log_monitor_t *slmp, char *file, int byte_count)
{
        int i;
        char newFile[MAXPATHLEN];
        char oldName[MAXPATHLEN];
        struct stat st;
        int size;

        stat(file, &st);
        size = st.st_size;
        /*
         * If current file size plus what will be added is larger
         * than max file size, rotate the logs
         * For check to see if larger than configured max size.
         */
        if (size + byte_count < slmp->slt_max_log_size) {
                /* next log entries can fit */
                return;
        }
        /* next log entries could make log entries too large */
        for (i = slmp->slt_log_count; i > 1; i--) {
                (void) snprintf(newFile, MAXPATHLEN, "%s.%x", file, i);
                (void) snprintf(oldName, MAXPATHLEN, "%s.%x", file, i - 1);
                (void) rename(oldName, newFile);
        }
        /* Finally move base to base.1 */
        (void) rename(file, oldName);

}

/*
 * This method exists to give access into the fmri.  One purpose is to flip the
 * instance number on the FMRI for a given hc-list entry. It is also
 * used to pull the value of an hc-list entry.  In all cases, the function
 * returns the value of the hc-list entry found, NULL if no value was found.
 */
static char *
access_fmri(ses_log_monitor_t *slmp, nvlist_t *fmri, char *target,
    int operation, int *err)
{
        int i;
        nvpair_t *nvp;
        nvpair_t *nvp2;
        uint_t nelem;
        nvlist_t **nvl_array;
        char *name;
        int ival;
        char ivs[25];
        char *target_val = NULL;

        if ((*err = nvlist_lookup_nvpair(fmri, "hc-list", &nvp)) != 0) {
                fmd_hdl_debug(slmp->slt_hdl, "No hc-list in the fmri");
                return (NULL);
        }

        /* hc-list is an array of nvlists */
        (void) nvpair_value_nvlist_array(nvp, &nvl_array, &nelem);

        /*
         * Loop until you find the list that has hc-name that equals the
         * passed in "target" value (such as controller) in it.
         */
        for (i = 0; i < nelem; i++) {

                /* Skip this pair if it is not labeled hc-name */
                if ((nvlist_lookup_nvpair(nvl_array[i], "hc-name", &nvp2))
                    != 0) {
                        continue;
                }

                /*
                 * Extract the value of the name. Continue on an error because
                 * we want to check all of the hc-name entries.
                 */
                if (nvpair_value_string(nvp2, &name) != 0) {
                        continue;
                }

                /* If this isn't the target, go to the next pair. */
                if (strcmp(name, target) != 0) {
                        continue;
                }

                if ((*err = nvlist_lookup_nvpair(nvl_array[i], "hc-id", &nvp2))
                    != 0) {

                        fmd_hdl_debug(slmp->slt_hdl,
                            "Could not find hc-id in the fmri for %s", target);
                        return (NULL);
                }

                /*
                 * This is the target pair.  If we can't get the value then
                 * exit out and log an error.
                 */
                if ((*err = nvpair_value_string(nvp2, &target_val)) != 0) {
                        fmd_hdl_debug(slmp->slt_hdl,
                            "Target value not returned.");
                        return (NULL);
                }

                switch (operation) {

                case INVERT_FMRI_INSTANCE:

                        ival = atoi(target_val);
                        ival = (ival + 1) % 2;

                        (void) snprintf(ivs, sizeof (ivs), "%d", ival);

                        if ((*err = nvlist_remove_nvpair(nvl_array[i], nvp2))
                            == 0) {

                                if ((*err = nvlist_add_string(nvl_array[i],
                                    "hc-id", ivs)) != 0) {

                                        fmd_hdl_debug(slmp->slt_hdl,
                                            "Error setting ivalue.");
                                }
                        } else {
                                fmd_hdl_debug(slmp->slt_hdl,
                                    "Error removing original ivalue.");
                        }

                        break;

                case EXAMINE_FMRI_VALUE:
                        /*
                         * target_val is already set. Return without modifying
                         * its value.
                         */
                        break;

                /* Can return target_val as is (NULL) */
                default:
                        *err = INVALID_OPERATION;
                        break;

                } /* End switch on operation */


                /* Exit the loop.  You have found the target */
                break;
        }

        return (target_val);
}

/*
 * Generate a filename based on the target path
 * Parameters:
 * filename: The space for the generated output log file name.
 * expander: An expander_t struct containing path, pid etc info from the node.
 * slmp: A pointer to the transport data structure which contains the
 * configurable file parameters.
 * byte_count: The number of bytes that will be added to the target file for
 * this expander.
 */
static int
create_filename(char *fileName, expander_t *expander, ses_log_monitor_t *slmp,
    int byte_count)
{
        char *ses_node;
        int i;
        int label_length;
        int status = 0;
        char *subchassis_val = NULL;

        /*
         * Add the file name with the path root
         * and append a forward slash if one is not there.
         */
        (void) snprintf(fileName, MAXPATHLEN, "%s", slmp->slt_path);

        ses_node = strrchr(fileName, '/');

        if ((ses_node != NULL) && (ses_node[0] != '\0')) {
                (void) strlcat(fileName, "/", MAXPATHLEN);
        }

        ses_node = strrchr(expander->slt_path, '/');

        (void) strlcat(fileName, ses_node + 1, MAXPATHLEN);

        /*
         * If a subchassis is defined, include it in the file name.
         * Errors are logged in the function.  There may legitimately be no
         * subchassis, so simply continue if none is found.
         */
        subchassis_val =  access_fmri(slmp, expander->fmri, SUBCHASSIS,
            EXAMINE_FMRI_VALUE, &status);

        if (subchassis_val != NULL) {
                (void) strlcat(fileName, "_", MAXPATHLEN);
                (void) strlcat(fileName, SUBCHASSIS, MAXPATHLEN);
                (void) strlcat(fileName, subchassis_val, MAXPATHLEN);
        }

        (void) strlcat(fileName, "_", MAXPATHLEN);
        /* remove spaces and forward slashes from name */
        label_length = strlen(expander->slt_label);
        for (i = 0; i < label_length; i++) {
                if ((!isspace(expander->slt_label[i])) &&
                    ('/' != expander->slt_label[i])) {
                        (void) strncat(fileName, &expander->slt_label[i], 1);
                }
        }
        (void) strlcat(fileName, "/log", MAXPATHLEN);

        /*
         * Ensure directory structure exists for log file.
         */
        status = mkpath(fileName, 0744);

        /*
         * Check size of file and rotate if necessary.
         */
        check_file_size(slmp, fileName, byte_count);

        return (status);

}

/*
 * Determines the error class type based on the severity of the entry.
 * Parameter
 * severity: A severity level from a log entry.
 */
static char *
error_type(int severity)
{
        char *rval;

        switch (severity) {
        case SES_LOG_LEVEL_FATAL:
                rval = FATAL_ERROR;
                break;

        case SES_LOG_LEVEL_ERROR:
                rval = NON_FATAL_ERROR;
                break;

        default:
                rval = NULL;
                break;
        }

        return (rval);
}

/*
 * Allocates and adds an entry for a given expander to the expander list.
 * Parameters
 * slmp: A pointer to the ses_log_monitor_t struct for this transport.
 * key: A unique identifier for this expander.
 */
static int
add_expander_record(ses_log_monitor_t *slmp, char *key)
{
        nvlist_t *expanderDetails;
        int status = 0;


        if ((status = nvlist_alloc(&expanderDetails, NV_UNIQUE_NAME, 0)) != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Error allocating expander detail space (%d)", status);
                return (status);
        }

        if ((status = nvlist_add_string(expanderDetails, DATA_FIELD,
            DEFAULT_DATA)) != 0) {

                fmd_hdl_debug(slmp->slt_hdl,
                    "Error adding default data to expander details (%d)",
                    status);
        } else {

                if ((status = nvlist_add_nvlist(slmp->slt_expanders, key,
                    expanderDetails)) != 0) {

                        fmd_hdl_debug(slmp->slt_hdl,
                            "Error storing the default expander details (%d)",
                            status);
                }
        }

        nvlist_free(expanderDetails);

        return (status);

}

/*
 * Retrieves the expander record nvlist that is associated with the
 * expander identified by the given key.  If no match is found, an
 * entry is created with default values.
 * Parameters
 * slmp: A pointer to the ses_log_monitor_t struct for this transport.
 * key: A pointer to the key for an expander.
 * expdata: A pointer to a pointer for the last log entry data for this
 * expander.
 */
static int
get_last_entry(ses_log_monitor_t *slmp, char *key, char **expdata)
{
        nvlist_t *expanderRecord;
        int err = 0;

        /*
         * Retrieve the expander record that matches this expander.  A default
         * entry will be returned if no matching entry is found.
         */
        if ((err = nvlist_lookup_nvlist(slmp->slt_expanders, key,
            &expanderRecord)) != 0) {

                if ((err = add_expander_record(slmp, key)) != 0) {
                        fmd_hdl_debug(slmp->slt_hdl,
                            "Expander add failed for %s", key);
                        return (err);
                }

                if ((err = nvlist_lookup_nvlist(slmp->slt_expanders, key,
                    &expanderRecord)) != 0) {

                        fmd_hdl_debug(slmp->slt_hdl,
                            "Could not retrieve the data after adding it", key);
                        return (err);
                }
        }


        if ((err = nvlist_lookup_string(expanderRecord, DATA_FIELD, expdata))
            != 0) {

                fmd_hdl_debug(slmp->slt_hdl,
                    "Could not retrieve the expander data field (%d)", err);
                return (err);
        }

        return (err);
}

/*
 * Searches the platform lists for target codes.  If a match is found then
 * it calls then indicated function.
 */
static int
check_code(ses_log_monitor_t *slmp, nvlist_t *fmri, char *pid, int code)
{
        int status = 0;
        int i, x;

        for (i = 0; i < platforms.pcount; i++) {
                if (strcmp(platforms.plist[i].pid, pid) == 0) {

                        for (x = 0; x < platforms.plist[i].count; x++) {
                                if (code == platforms.plist[i].codes[x].code) {
                                        status = platforms.plist[i].codes[x].
                                            func_ptr(slmp, fmri);

                                        break;
                                }
                        }
                        break;
                }
        }

        if (status != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Error checking for a code action (%d)", status);
        }

        return (status);
}

/*
 * Searches the platform lists for for a match on the supplied product id.
 * Returns non zero if supported, zero otherwise.
 */
static int
platform_supported(char *pid)
{
        int supported = 0;
        int i;

        for (i = 0; i < platforms.pcount; i++) {
                if (strcmp(platforms.plist[i].pid, pid) == 0) {
                        supported = 1;
                        break;
                }
        }

        return (supported);
}

/*
 * Inverts the controller instance and the expander instance in the
 * specified FMRI.
 */
static int
invert_fmri(ses_log_monitor_t *slmp, nvlist_t *fmri)
{
        int err = 0;

        (void) access_fmri(slmp, fmri, CONTROLLER, INVERT_FMRI_INSTANCE, &err);
        if (err != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "error inverting the controller instance: %d", err);
                return (err);
        }

        (void) access_fmri(slmp, fmri, SASEXPANDER, INVERT_FMRI_INSTANCE, &err);
        if (err != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "error inverting sas-expander instance: %d", err);
        }

        return (err);
}

/*
 * Checks the severity of the log entry against the configured boundary,
 * generates and ereport, and writes the data out to the log file.
 * Parameters
 * slmp: A pointer to the ses_log_monitor_t struct for this transport.
 * entry: The log entry
 * ena: the ena for this transport.
 * expander: Contains derived information for this expander.
 * format_time: The formatted time to append to this entry.
 * fp: A file pointer for the data to be written out to.
 */
static int
handle_log_entry(ses_log_monitor_t *slmp, nvpair_t *entry,
    expander_t *expander, char *format_time, FILE *fp)
{
        nvlist_t *entry_data;
        char *log_entry;
        char *severity;
        int severityValue = 0;
        char *code;
        char *class_sev = NULL;
        uint64_t ena;
        int rval = 0;

        if ((rval = nvpair_value_nvlist(entry, &entry_data)) != 0) {
                fmd_hdl_debug(slmp->slt_hdl, "Unable to retrieve entry");
                return (rval);
        }

        if ((rval = nvlist_lookup_string(entry_data, ENTRY_SEVERITY, &severity))
            == 0) {

                severityValue = atoi(severity);

                if (severityValue >= slmp->slt_severity) {
                        /*
                         * Pull the code and check to see if there are any
                         * special operations to perform for it on the given
                         * platform.
                         */
                        if ((rval = nvlist_lookup_string(entry_data, ENTRY_CODE,
                            &code)) != 0) {

                                fmd_hdl_debug(slmp->slt_hdl,
                                    "Error retrieving code: %d", rval);
                                return (rval);
                        }

                        /*
                         * Check this code for any actions specific
                         * to this platform.
                         */
                        (void) check_code(slmp, expander->fmri,
                            expander->slt_pid, atoi(code));

                        class_sev = error_type(severityValue);
                        if (class_sev == NULL) {
                                fmd_hdl_debug(slmp->slt_hdl,
                                    "log severity %d mapped to NULL", severity);
                                return (INVALID_SEVERITY);
                        }

                        /* Create the ENA for this ereport */
                        ena = fmd_event_ena_create(slmp->slt_hdl);

                        slt_post_ereport(slmp->slt_hdl, slmp->slt_xprt,
                            class_sev, ena, expander->fmri, entry_data);

                }
        } else {

                fmd_hdl_debug(slmp->slt_hdl,
                    "Unable to pull severity from the entry.");
                return (rval);
        }

        /*
         * Append the log entry to the log file.
         */
        if (fp) {

                if ((rval = nvlist_lookup_string(entry_data, ENTRY_LOG,
                    &log_entry)) == 0) {

                        (void) fprintf(fp, "%s %s\n", format_time,
                            log_entry);
                } else {

                        fmd_hdl_debug(slmp->slt_hdl,
                            "Unable to pull log from the entry.");
                }
        }

        return (rval);

}

/*
 * The function performs the work of deallocating the space used for an
 * expander_t structure.
 * Parameters:
 * slmp: A pointer to t ses_log_monitor_t struct for this transport.
 * exp: A pointer to an expander_t structure that identifies an expander.
 */
static void
free_expander(ses_log_monitor_t *slmp, expander_t *exp)
{
        if (exp != NULL) {
                if (exp->fmri != NULL) {
                        nvlist_free(exp->fmri);
                }
                fmd_hdl_free(slmp->slt_hdl, exp, sizeof (expander_t));
        }
}

/*
 * This function performs the log read on a target
 *
 * Parameters:
 * slmp: A pointer to the ses log monitor structure.
 * expander: A pointer to an expander object that contains info required
 * for a call to the libseslog library.
 * lib_param: The structure used to pass data to and from the library.  This
 * contains the target's information as well as a ponter to returned data.
 */
static int
get_log(ses_log_monitor_t *slmp, expander_t *expander,
    struct ses_log_call_struct *lib_param)
{
        char *expdata;
        int err;
        nvlist_t *expanderRecord;

        /* Retrieve the last entry for this expander for the lib call */
        if ((err = get_last_entry(slmp, expander->slt_key, &expdata)) != 0) {

                fmd_hdl_debug(slmp->slt_hdl, "Error collecting expander entry");
                return (err);
        }
        (void) strncpy(lib_param->target_path, expander->slt_path, MAXPATHLEN);
        (void) strncpy(lib_param->product_id, expander->slt_pid, MAXNAMELEN);
        (void) strncpy(lib_param->last_log_entry, expdata, MAXNAMELEN);
        lib_param->poll_time = slmp->slt_interval;

        /*
         * If the library call returned non zero, log it, however, the call
         * may still have returned valid log data.  Check the log data.  If it
         * is NULL, return an error.  Otherwise continue processing.
         */
        if ((err = access_ses_log(lib_param)) != 0) {
                fmd_hdl_debug(slmp->slt_hdl, "Library access error: %d", err);
        }

        /* Double check that log data actually exists. */
        if (lib_param->log_data == NULL) {
                if (err != 0) {
                        return (err);
                }
                return (NULL_LOG_DATA);
        }

        /*
         * If we can retrieve the expander details for this expander then store
         * the last log entry returned from the library.  Otherwise log it
         * and continue processing.
         */
        if ((err = nvlist_lookup_nvlist(slmp->slt_expanders, expander->slt_key,
            &expanderRecord)) == 0) {

                if (nvlist_add_string(expanderRecord, DATA_FIELD,
                    lib_param->last_log_entry) != 0) {

                        fmd_hdl_debug(slmp->slt_hdl,
                            "Error saving buffer data in expander details");
                }
        } else {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Could not retrieve expander to store last entry: %d", err);
        }

        return (err);

}

/*
 * This function processes the log data from a target.  This includes
 * writing the data to the filesystem and initiating generation of ereports
 * as needed by calling slt_post_ereport.
 *
 *
 * Parameters:
 * slmp: A pointer to the ses log monitor structure.
 * expander: A pointer to an expander object that contains info about the
 * expander.
 * lib_param: The structure used to pass data to and from the library.  This
 * contains the target's information as well as a ponter to returned data.
 */
static int
process_log(ses_log_monitor_t *slmp, expander_t *expander,
    struct ses_log_call_struct *lib_param)
{
        nvlist_t *result;
        int err;

        char *pairName;
        nvpair_t *entry = NULL;
        FILE *fp = NULL;
        char fileName[MAXPATHLEN];
        time_t now;
        char format_time[30];
        struct tm tim;
        int output_count;

        /*
         * Determine how many bytes will be written out with this response,
         * pass this count to a function that will determine whether or not
         * to roll the logs, and will return the name of the file path to use.
         */
        output_count = lib_param->number_log_entries * DATE_STRING_SIZE +
            lib_param->size_of_log_entries;

        err = create_filename(fileName, expander, slmp, output_count);

        if (err == 0) {
                fp = fopen(fileName, "a");
                if (fp == NULL) {
                        fmd_hdl_debug(slmp->slt_hdl, "File open failed");
                }
        }

        /* Format the time to prepend to the log entry */
        now = time(NULL);
        tim = *(localtime(&now));
        (void) strftime(format_time, 30, "%b %d %H:%M:%S ", &tim);

        /*
         * For each entry returned, generate an ereport if the severity
         * is at or above the target level, then append all entries to
         * the appropriate log file.
         */
        result = lib_param->log_data;
        while ((entry = nvlist_next_nvpair(result, entry)) != NULL) {

                pairName = nvpair_name(entry);
                /*
                 * Process each entry in the result data returned from
                 * the library call.  These are log entries and may
                 * warrant an ereport.
                 */
                if (strncmp(ENTRY_PREFIX, pairName, 5) == 0) {

                        err = handle_log_entry(slmp, entry, expander,
                            format_time, fp);
                }
        }

        /* Close the log file */
        if (fp) {
                (void) fclose(fp);
                fp = NULL;
        }

        /* Free the space used for the result and the fmri. */
        nvlist_free(result);

        return (0);

}

/*
 * This function performs the log read and processing of the logs for a target
 * as well as writing the data to the filesystem.  Ereports are generated
 * as needed by calling slt_post_ereport.
 *
 * Access the log data for a specific ses.
 * If a log entry should generate an ereport, call slt_post_ereport
 * Format and store the data at the appropriate location.
 */
static int
slt_process_ses_log(topo_hdl_t *thp, tnode_t *node, void *arg)
{
        ses_log_monitor_t *slmp = arg;
        nvlist_t *fmri;
        expander_t *expander;
        struct ses_log_call_struct lib_param;

        int err = 0;
        char *label = NULL;
        char *target_path = NULL;
        char *product_id = NULL;
        char *sas_address = NULL;

        if (strcmp(SASEXPANDER, topo_node_name(node)) != 0) {
                /* Not the type of node we are looking for */
                return (TOPO_WALK_NEXT);
        }

        if (topo_prop_get_string(node, "authority", "product-id",
            &product_id, &err) != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Error collecting product_id %d", err);
                return (TOPO_WALK_NEXT);
        }

        /* If the current system type is unsupported stop processing the node */
        if (platform_supported(product_id) == 0) {
                fmd_hdl_debug(slmp->slt_hdl, "Unsupported platform %d",
                    product_id);
                topo_hdl_strfree(thp, product_id);
                return (TOPO_WALK_NEXT);
        }

        /* Allocate space for the holder structure */
        expander = (expander_t *)fmd_hdl_zalloc(slmp->slt_hdl,
            sizeof (expander_t), FMD_SLEEP);

        (void) snprintf(expander->slt_pid, MAXNAMELEN, "%s", product_id);
        topo_hdl_strfree(thp, product_id);

        if (topo_prop_get_string(node, "protocol", "label", &label, &err)
            != 0) {
                fmd_hdl_debug(slmp->slt_hdl, "Error collecting label %d", err);
                free_expander(slmp, expander);
                return (TOPO_WALK_NEXT);
        }
        (void) snprintf(expander->slt_label, MAXNAMELEN, "%s", label);
        topo_hdl_strfree(thp, label);

        if (topo_prop_get_string(node, TOPO_PGROUP_SES,
            TOPO_PROP_SES_DEV_PATH, &target_path, &err) != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Error collecting ses-devfs-path for %s: %d",
                    expander->slt_label, err);
                free_expander(slmp, expander);
                return (TOPO_WALK_NEXT);
        }
        (void) snprintf(expander->slt_path, MAXPATHLEN, "%s", target_path);
        topo_hdl_strfree(thp, target_path);

        if (topo_prop_get_string(node, TOPO_PGROUP_STORAGE,
            TOPO_PROP_SAS_ADDR, &sas_address, &err) != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Error collecting sas_address for %s: %d",
                    expander->slt_label, err);
                free_expander(slmp, expander);
                return (TOPO_WALK_NEXT);
        }
        if (strlen(sas_address) != 16) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "sas-address length is not 16: (%s)", sas_address);
                free_expander(slmp, expander);
                topo_hdl_strfree(thp, sas_address);
                return (TOPO_WALK_NEXT);
        }
        (void) snprintf(expander->slt_key, MAXNAMELEN, "%s", sas_address);
        topo_hdl_strfree(thp, sas_address);

        /* Obtain the fmri for this node and save a reference to it. */
        if (topo_node_resource(node, &fmri, &err) != 0) {
                fmd_hdl_debug(slmp->slt_hdl, "failed to get fmri for %s: %s",
                    expander->slt_label, topo_strerror(err));

                free_expander(slmp, expander);
                return (TOPO_WALK_NEXT);
        } else {
                expander->fmri = fmri;
        }

        if ((err = get_log(slmp, expander, &lib_param)) != 0) {
                /*
                 * NULL_LOG_DATA means that no data was returned from the
                 * library.  (i.e. There were no log entries.) Just free memory
                 * and return.
                 */
                if (err != NULL_LOG_DATA) {
                        fmd_hdl_debug(slmp->slt_hdl,
                            "Error retrieving logs from %s: %d",
                            expander->slt_label, err);
                }
                free_expander(slmp, expander);
                return (TOPO_WALK_NEXT);
        }

        if ((err = process_log(slmp, expander, &lib_param)) != 0) {
                fmd_hdl_debug(slmp->slt_hdl,
                    "Error processing logs from %s: %d",
                    expander->slt_label, err);
        }

        /* Free the expander structure before exiting. */
        free_expander(slmp, expander);

        return (TOPO_WALK_NEXT);
}

/*
 * Called by the FMD after the specified timeout has expired.
 * This initiates the processing of the SES device logs.
 * slt_process_ses_log() performs the actual log retrieval and analysis.
 *
 * The last action is to reset the timer so that this method is called again.
 */
/*ARGSUSED*/
static void
slt_timeout(fmd_hdl_t *hdl, id_t id, void *data)
{
        topo_hdl_t *thp;
        topo_walk_t *twp;
        int err;

        /* Retrieve the SES log monitor structure. */
        ses_log_monitor_t *slmp = fmd_hdl_getspecific(hdl);

        if (slmp == NULL) {
                fmd_hdl_abort(hdl, "Unable to retrieve log monitor structure.");
                return;
        }
        slmp->slt_hdl = hdl;

        thp = fmd_hdl_topo_hold(hdl, TOPO_VERSION);

        /*
         * This initializes a topology walk structure for stepping through
         * the snapshot associated with thp.  Note that a callback function
         * is supplied (slt_process_ses_log in this case).
         */
        if ((twp = topo_walk_init(thp, FM_FMRI_SCHEME_HC, slt_process_ses_log,
            slmp, &err)) == NULL) {

                fmd_hdl_topo_rele(hdl, thp);
                fmd_hdl_abort(hdl, "failed to get topology: %s\n",
                    topo_strerror(err));
                return;
        }

        /*
         * This function walks through the snapshot and invokes the callback
         * function supplied when it was set up above.
         */
        if (topo_walk_step(twp, TOPO_WALK_CHILD) == TOPO_WALK_ERR) {
                topo_walk_fini(twp);
                fmd_hdl_topo_rele(hdl, thp);
                fmd_hdl_abort(hdl, "failed to walk topology\n");
                return;
        }

        /* This releases the walk structure. */
        topo_walk_fini(twp);
        fmd_hdl_topo_rele(hdl, thp);

        /* Reset the timer for the next iteration. */
        slmp->slt_timer = fmd_timer_install(hdl, NULL, NULL,
            slmp->slt_interval);

}

/*
 * Entry points for the FMD to access this transport.
 */
static const fmd_hdl_ops_t fmd_ops = {
        NULL, /* fmdo_recv */
        slt_timeout, /* fmdo_timeout */
        NULL, /* fmdo_close */
        NULL, /* fmdo_stats */
        NULL, /* fmdo_gc */
        NULL, /* fmdo_send */
        NULL, /* fmdo_topo_change */
};

static const fmd_hdl_info_t fmd_info = {
        "SES Log Transport Agent", "1.0", &fmd_ops, fmd_props
};

/*
 * Initialize the transport.
 */
void
_fmd_init(fmd_hdl_t *hdl)
{
        ses_log_monitor_t *slmp;
        int error;
        nvlist_t *expanderList;

        if (fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info) != 0)
                return;

        (void) fmd_stat_create(hdl, FMD_STAT_NOALLOC,
            sizeof (slt_stats) / sizeof (fmd_stat_t),
            (fmd_stat_t *)&slt_stats);

        slmp = fmd_hdl_zalloc(hdl, sizeof (ses_log_monitor_t), FMD_SLEEP);
        fmd_hdl_setspecific(hdl, slmp);

        slmp->slt_xprt = fmd_xprt_open(hdl, FMD_XPRT_RDONLY, NULL, NULL);
        if (slmp->slt_xprt == NULL) {
                fmd_hdl_error(hdl,
                    "Unable to obtain a reference to the transport");
                fmd_hdl_free(hdl, slmp, sizeof (*slmp));
                fmd_hdl_unregister(hdl);
                return;
        }

        /*
         * interval is validity checked by the framework since it is of type
         * FMD_TYPE_TIME.
         */
        slmp->slt_interval = fmd_prop_get_int64(hdl, "interval");

        /*
         * Use default the severity if it is out of range.
         * Setting the severity too high is allowed as this has the effect
         * of preventing any ereports from being generated.
         */
        slmp->slt_severity = fmd_prop_get_int32(hdl, "severity");
        if (slmp->slt_severity < SES_LOG_LEVEL_NOTICE) {

                slmp->slt_severity = SES_LOG_LEVEL_ERROR;
        }

        slmp->slt_log_count = fmd_prop_get_int32(hdl, "logcount");
        if (slmp->slt_log_count < MIN_LOG_COUNT) {
                slmp->slt_log_count = MIN_LOG_COUNT;
        }

        slmp->slt_max_log_size = fmd_prop_get_int32(hdl, "maxlogsize");
                if (slmp->slt_max_log_size < MIN_LOG_SIZE) {
                slmp->slt_max_log_size = MIN_LOG_SIZE;
        }

        /* Invalid paths will be handled by logging and skipping log creation */
        slmp->slt_path = fmd_prop_get_string(hdl, "path");

        /* Allocate space for the expander id holder */
        if ((error = nvlist_alloc(&expanderList, NV_UNIQUE_NAME, 0)) != 0) {
                fmd_xprt_close(hdl, slmp->slt_xprt);
                fmd_hdl_strfree(hdl, slmp->slt_path);
                fmd_hdl_free(hdl, slmp, sizeof (*slmp));

                fmd_hdl_error(hdl,
                    "Error allocating space for the expander list: %d", error);
                fmd_hdl_unregister(hdl);
                return;
        }

        slmp->slt_expanders = expanderList;

        /*
         * Call our initial timer routine, starting the periodic timeout.
         */
        slmp->slt_timer = fmd_timer_install(hdl, NULL, NULL, 0);
}

/*
 * Shut down the transport.  The primary responsibility is to release any
 * allocated memory.
 */
void
_fmd_fini(fmd_hdl_t *hdl)
{
        ses_log_monitor_t *slmp;

        slmp = fmd_hdl_getspecific(hdl);
        if (slmp) {
                fmd_timer_remove(hdl, slmp->slt_timer);
                fmd_xprt_close(hdl, slmp->slt_xprt);
                fmd_prop_free_string(hdl, slmp->slt_path);
                nvlist_free(slmp->slt_expanders);
                fmd_hdl_free(hdl, slmp, sizeof (*slmp));
        }
}