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

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <libintl.h>

#include "libcpc.h"

/*
 * Takes a string and converts it to a cpc_set_t.
 *
 * While processing the string using getsubopt(), we will use an array of
 * requests to hold the data, and a proprietary representation of attributes
 * which allow us to avoid a realloc()/bcopy() dance every time we come across
 * a new attribute.
 *
 * Not until after the string has been processed in its entirety do we
 * allocate and specify a request set properly.
 */

/*
 * Leave enough room in token strings for picn, nousern, or sysn where n is
 * picnum.
 */
#define TOK_SIZE        10

typedef struct __tmp_attr {
        char                    *name;
        uint64_t                val;
        struct __tmp_attr       *next;
} tmp_attr_t;

typedef struct __tok_info {
        char                    *name;
        int                     picnum;
} tok_info_t;

typedef struct __request_t {
        char                    cr_event[CPC_MAX_EVENT_LEN];
        uint_t                  cr_flags;
        uint_t                  cr_nattrs;      /* # CPU-specific attrs */
} request_t;

static void strtoset_cleanup(void);
static void smt_special(int picnum);
static void *emalloc(size_t n);

/*
 * Clients of cpc_strtoset may set this to specify an error handler during
 * string parsing.
 */
cpc_errhndlr_t          *strtoset_errfn = NULL;

static request_t        *reqs;
static int              nreqs;
static int              ncounters;

static tmp_attr_t       **attrs;
static int              ntoks;
static char             **toks;
static tok_info_t       *tok_info;
static int              (*(*tok_funcs))(int, char *);
static char             **attrlist;     /* array of ptrs to toks in attrlistp */
static int              nattrs;
static cpc_t            *cpc;
static int              found;

static void
strtoset_err(const char *fmt, ...)
{
        va_list ap;

        if (strtoset_errfn == NULL)
                return;

        va_start(ap, fmt);
        (*strtoset_errfn)("cpc_strtoset", -1, fmt, ap);
        va_end(ap);
}

/*ARGSUSED*/
static void
event_walker(void *arg, uint_t picno, const char *event)
{
        if (strncmp(arg, event, CPC_MAX_EVENT_LEN) == 0)
                found = 1;
}

static int
event_valid(int picnum, char *event)
{
        char *end_event;
        int err;

        found = 0;

        cpc_walk_events_pic(cpc, picnum, event, event_walker);

        if (found)
                return (1);

        cpc_walk_generic_events_pic(cpc, picnum, event, event_walker);

        if (found)
                return (1);

        /*
         * Before assuming this is an invalid event, see if we have been given
         * a raw event code.
         * Check the second argument of strtol() to ensure invalid events
         * beginning with number do not go through.
         */
        err = errno;
        errno = 0;
        (void) strtol(event, &end_event, 0);
        if ((errno == 0) && (*end_event == '\0')) {
                /*
                 * Success - this is a valid raw code in hex, decimal, or octal.
                 */
                errno = err;
                return (1);
        }

        errno = err;
        return (0);
}

/*
 * An unknown token was encountered; check here if it is an implicit event
 * name. We allow users to omit the "picn=" portion of the event spec, and
 * assign such events to available pics in order they are returned from
 * getsubopt(3C). We start our search for an available pic _after_ the highest
 * picnum to be assigned. This ensures that the event spec can never be out of
 * order; i.e. if the event string is "eventa,eventb" we must ensure that the
 * picnum counting eventa is less than the picnum counting eventb.
 */
static int
find_event(char *event)
{
        int i;

        /*
         * Event names cannot have '=' in them. If present here, it means we
         * have encountered an unknown token (foo=bar, for example).
         */
        if (strchr(event, '=') != NULL)
                return (0);

        /*
         * Find the first unavailable pic, after which we must start our search.
         */
        for (i = ncounters - 1; i >= 0; i--) {
                if (reqs[i].cr_event[0] != '\0')
                        break;
        }
        /*
         * If the last counter has been assigned, we cannot place this event.
         */
        if (i == ncounters - 1)
                return (0);

        /*
         * If none of the counters have been assigned yet, i is -1 and we will
         * begin our search at 0. Else we begin our search at the counter after
         * the last one currently assigned.
         */
        i++;

        for (; i < ncounters; i++) {
                if (event_valid(i, event) == 0)
                        continue;

                nreqs++;
                (void) strncpy(reqs[i].cr_event, event, CPC_MAX_EVENT_LEN);
                return (1);
        }

        return (0);
}

static int
pic(int tok, char *val)
{
        int picnum = tok_info[tok].picnum;
        /*
         * Make sure the each pic only appears in the spec once.
         */
        if (reqs[picnum].cr_event[0] != '\0') {
                strtoset_err(gettext("repeated 'pic%d' token\n"), picnum);
                return (-1);
        }

        if (val == NULL || val[0] == '\0') {
                strtoset_err(gettext("missing 'pic%d' value\n"), picnum);
                return (-1);
        }

        if (event_valid(picnum, val) == 0) {
                strtoset_err(gettext("pic%d cannot measure event '%s' on this "
                    "cpu\n"), picnum, val);
                return (-1);
        }

        nreqs++;
        (void) strncpy(reqs[picnum].cr_event, val, CPC_MAX_EVENT_LEN);
        return (0);
}

/*
 * We explicitly ignore any value provided for these tokens, as their
 * mere presence signals us to turn on or off the relevant flags.
 */
/*ARGSUSED*/
static int
flag(int tok, char *val)
{
        int i;
        int picnum = tok_info[tok].picnum;

        /*
         * If picnum is -1, this flag should be applied to all reqs.
         */
        for (i = (picnum == -1) ? 0 : picnum; i < ncounters; i++) {
                if (strcmp(tok_info[tok].name, "nouser") == 0)
                        reqs[i].cr_flags &= ~CPC_COUNT_USER;
                else if (strcmp(tok_info[tok].name, "sys") == 0)
                        reqs[i].cr_flags |= CPC_COUNT_SYSTEM;
                else
                        return (-1);

                if (picnum != -1)
                        break;
        }

        return (0);
}

static int
doattr(int tok, char *val)
{
        int             i;
        int             picnum = tok_info[tok].picnum;
        tmp_attr_t      *tmp;
        char            *endptr;

        /*
         * If picnum is -1, this attribute should be applied to all reqs.
         */
        for (i = (picnum == -1) ? 0 : picnum; i < ncounters; i++) {
                tmp = (tmp_attr_t *)emalloc(sizeof (tmp_attr_t));
                tmp->name = tok_info[tok].name;
                if (val != NULL) {
                        tmp->val = strtoll(val, &endptr, 0);
                        if (endptr == val) {
                                strtoset_err(gettext("invalid value '%s' for "
                                    "attribute '%s'\n"), val, tmp->name);
                                free(tmp);
                                return (-1);
                        }
                } else
                        /*
                         * No value was provided for this attribute,
                         * so specify a default value of 1.
                         */
                        tmp->val = 1;

                tmp->next = attrs[i];
                attrs[i] = tmp;
                reqs[i].cr_nattrs++;

                if (picnum != -1)
                        break;
        }

        return (0);
}

/*ARGSUSED*/
static void
attr_count_walker(void *arg, const char *attr)
{
        /*
         * We don't allow picnum to be specified by the user.
         */
        if (strncmp(attr, "picnum", 7) == 0)
                return;
        (*(int *)arg)++;
}

static int
cpc_count_attrs(cpc_t *cpc)
{
        int nattrs = 0;

        cpc_walk_attrs(cpc, &nattrs, attr_count_walker);

        return (nattrs);
}

static void
attr_walker(void *arg, const char *attr)
{
        int *i = arg;

        if (strncmp(attr, "picnum", 7) == 0)
                return;

        if ((attrlist[(*i)++] = strdup(attr)) == NULL) {
                strtoset_err(gettext("no memory available\n"));
                exit(0);
        }
}

cpc_set_t *
cpc_strtoset(cpc_t *cpcin, const char *spec, int smt)
{
        cpc_set_t               *set;
        cpc_attr_t              *req_attrs;
        tmp_attr_t              *tmp;
        size_t                  toklen;
        int                     i;
        int                     j;
        int                     x;
        char                    *opts;
        char                    *val;

        cpc = cpcin;
        nattrs = 0;

        ncounters = cpc_npic(cpc);

        reqs = (request_t *)emalloc(ncounters * sizeof (request_t));

        attrs = (tmp_attr_t **)emalloc(ncounters * sizeof (tmp_attr_t *));

        for (i = 0; i < ncounters; i++) {
                reqs[i].cr_event[0] = '\0';
                reqs[i].cr_flags = CPC_COUNT_USER;
                /*
                 * Each pic will have at least one attribute: the physical pic
                 * assignment via the "picnum" attribute. Set that up here for
                 * each request.
                 */
                reqs[i].cr_nattrs = 1;
                attrs[i] = emalloc(sizeof (tmp_attr_t));
                attrs[i]->name = "picnum";
                attrs[i]->val = i;
                attrs[i]->next = NULL;
        }

        /*
         * Build up a list of acceptable tokens.
         *
         * Permitted tokens are
         * picn=event
         * nousern
         * sysn
         * attrn=val
         * nouser
         * sys
         * attr=val
         *
         * Where n is a counter number, and attr is any attribute supported by
         * the current processor.
         *
         * If a token appears without a counter number, it applies to all
         * counters in the request set.
         *
         * The number of tokens is:
         *
         * picn: ncounters
         * generic flags: 2 * ncounters (nouser, sys)
         * attrs: nattrs * ncounters
         * attrs with no picnum: nattrs
         * generic flags with no picnum: 2 (nouser, sys)
         * NULL token to signify end of list to getsubopt(3C).
         *
         * Matching each token's index in the token table is a function which
         * process that token; these are in tok_funcs.
         */

        /*
         * Count the number of valid attributes.
         * Set up the attrlist array to point to the attributes in attrlistp.
         */
        nattrs = cpc_count_attrs(cpc);
        attrlist = (char **)emalloc(nattrs * sizeof (char *));

        i = 0;
        cpc_walk_attrs(cpc, &i, attr_walker);

        ntoks = ncounters + (2 * ncounters) + (nattrs * ncounters) + nattrs + 3;
        toks = (char **)emalloc(ntoks * sizeof (char *));
        tok_info = (tok_info_t *)emalloc(ntoks * sizeof (tok_info_t));

        tok_funcs = (int (**)(int, char *))emalloc(ntoks *
            sizeof (int (*)(char *)));

        for (i = 0; i < ntoks; i++) {
                toks[i] = NULL;
                tok_funcs[i] = NULL;
        }

        x = 0;
        for (i = 0; i < ncounters; i++) {
                toks[x] = (char *)emalloc(TOK_SIZE);
                (void) snprintf(toks[x], TOK_SIZE, "pic%d", i);
                tok_info[x].name = "pic";
                tok_info[i].picnum = i;
                tok_funcs[x] = pic;
                x++;
        }

        for (i = 0; i < ncounters; i++) {
                toks[x] = (char *)emalloc(TOK_SIZE);
                (void) snprintf(toks[x], TOK_SIZE, "nouser%d", i);
                tok_info[x].name = "nouser";
                tok_info[x].picnum = i;
                tok_funcs[x] = flag;
                x++;
        }

        for (i = 0; i < ncounters; i++) {
                toks[x] = (char *)emalloc(TOK_SIZE);
                (void) snprintf(toks[x], TOK_SIZE, "sys%d", i);
                tok_info[x].name = "sys";
                tok_info[x].picnum = i;
                tok_funcs[x] = flag;
                x++;
        }
        for (j = 0; j < nattrs; j++) {
                toklen = strlen(attrlist[j]) + 3;
                for (i = 0; i < ncounters; i++) {
                        toks[x] = (char *)emalloc(toklen);
                        (void) snprintf(toks[x], toklen, "%s%d", attrlist[j],
                            i);
                        tok_info[x].name = attrlist[j];
                        tok_info[x].picnum = i;
                        tok_funcs[x] = doattr;
                        x++;
                }

                /*
                 * Now create a token for this attribute with no picnum; if used
                 * it will be applied to all reqs.
                 */
                toks[x] = (char *)emalloc(toklen);
                (void) snprintf(toks[x], toklen, "%s", attrlist[j]);
                tok_info[x].name = attrlist[j];
                tok_info[x].picnum = -1;
                tok_funcs[x] = doattr;
                x++;
        }

        toks[x] = "nouser";
        tok_info[x].name = "nouser";
        tok_info[x].picnum = -1;
        tok_funcs[x] = flag;
        x++;

        toks[x] = "sys";
        tok_info[x].name = "sys";
        tok_info[x].picnum = -1;
        tok_funcs[x] = flag;
        x++;

        toks[x] = NULL;

        opts = strdupa(spec);
        while (*opts != '\0') {
                int idx = getsubopt(&opts, toks, &val);

                if (idx == -1) {
                        if (find_event(val) == 0) {
                                strtoset_err(gettext("bad token '%s'\n"), val);
                                goto inval;
                        } else
                                continue;
                }

                if (tok_funcs[idx](idx, val) == -1)
                        goto inval;
        }

        /*
         * The string has been processed. Now count how many PICs were used,
         * create a request set, and specify each request properly.
         */

        if ((set = cpc_set_create(cpc)) == NULL) {
                strtoset_err(gettext("no memory available\n"));
                exit(0);
        }

        for (i = 0; i < ncounters; i++) {
                if (reqs[i].cr_event[0] == '\0')
                        continue;

                /*
                 * If the caller wishes to measure events on the physical CPU,
                 * we need to add SMT attributes to each request.
                 */
                if (smt)
                        smt_special(i);

                req_attrs = (cpc_attr_t *)emalloc(reqs[i].cr_nattrs *
                    sizeof (cpc_attr_t));

                j = 0;
                for (tmp = attrs[i]; tmp != NULL; tmp = tmp->next) {
                        req_attrs[j].ca_name = tmp->name;
                        req_attrs[j].ca_val = tmp->val;
                        j++;
                }

                if (cpc_set_add_request(cpc, set, reqs[i].cr_event, 0,
                    reqs[i].cr_flags, reqs[i].cr_nattrs, req_attrs) == -1) {
                        free(req_attrs);
                        (void) cpc_set_destroy(cpc, set);
                        strtoset_err(
                            gettext("cpc_set_add_request() failed: %s\n"),
                            strerror(errno));
                        goto inval;
                }

                free(req_attrs);
        }

        strtoset_cleanup();

        return (set);

inval:
        strtoset_cleanup();
        errno = EINVAL;
        return (NULL);
}

static void
strtoset_cleanup(void)
{
        int             i;
        tmp_attr_t      *tmp, *p;

        for (i = 0; i < nattrs; i++)
                free(attrlist[i]);
        free(attrlist);

        for (i = 0; i < ncounters; i++) {
                for (tmp = attrs[i]; tmp != NULL; tmp = p) {
                        p = tmp->next;
                        free(tmp);
                }
        }
        free(attrs);

        for (i = 0; i < ntoks - 3; i++)
                /*
                 * We free all but the last three tokens: "nouser", "sys", NULL
                 */
                free(toks[i]);
        free(toks);
        free(reqs);
        free(tok_info);
        free(tok_funcs);
}

/*
 * The following is called to modify requests so that they count events on
 * behalf of a physical processor, instead of a logical processor. It duplicates
 * the request flags for the sibling processor (i.e. if the request counts user
 * events, add an attribute to count user events on the sibling processor also).
 */
static void
smt_special(int picnum)
{
        tmp_attr_t *attr;

        if (reqs[picnum].cr_flags & CPC_COUNT_USER) {
                attr = (tmp_attr_t *)emalloc(sizeof (tmp_attr_t));
                attr->name = "count_sibling_usr";
                attr->val = 1;
                attr->next = attrs[picnum];
                attrs[picnum] = attr;
                reqs[picnum].cr_nattrs++;
        }

        if (reqs[picnum].cr_flags & CPC_COUNT_SYSTEM) {
                attr = (tmp_attr_t *)emalloc(sizeof (tmp_attr_t));
                attr->name = "count_sibling_sys";
                attr->val = 1;
                attr->next = attrs[picnum];
                attrs[picnum] = attr;
                reqs[picnum].cr_nattrs++;
        }
}

/*
 * If we ever fail to get memory, we print an error message and exit.
 */
static void *
emalloc(size_t n)
{
        void *p = malloc(n);

        if (p == NULL) {
                strtoset_err(gettext("no memory available\n"));
                exit(0);
        }

        return (p);
}