mpss/common/mpss.c

	mpss.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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 2001-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/auxv.h>
#include <stdarg.h>
#include <syslog.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <procfs.h>
#include <libintl.h>
#include <locale.h>

extern int  gmatch(const char *s, const char *p);

#pragma init(__mpssmain)

static const char *mpssident = "mpss.so.1";

/* environment variables */

#define ENV_MPSSCFGFILE     "MPSSCFGFILE"
#define ENV_MPSSSTACK       "MPSSSTACK"
#define ENV_MPSSHEAP        "MPSSHEAP"
#define ENV_MPSSERRFILE     "MPSSERRFILE"

#define MPSSHEAP    0
#define MPSSSTACK   1

/* config file */

#define DEF_MPSSCFGFILE     "/etc/mpss.conf"
#define MAXLINELEN  MAXPATHLEN + 64
#define CFGDELIMITER    ':'
#define ARGDELIMITER    ' '

/*
 * avoid malloc which causes certain applications to crash
 */
static char     lbuf[MAXLINELEN];
static char     pbuf[MAXPATHLEN];

#ifdef MPSSDEBUG
#define ENV_MPSSDEBUG   "MPSSDEBUG"
#define MPSSPRINT(x, y) if (mpssdebug & x) (void) fprintf y;

static int      mpssdebug;
#else
#define MPSSPRINT(x, y)
#endif

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

/*PRINTFLIKE2*/
static void
mpsserr(FILE *fp, char *fmt, ...)
{
    va_list     ap;
    va_start(ap, fmt);
    if (fp)
        (void) vfprintf(fp, fmt, ap);
    else
        vsyslog(LOG_ERR, fmt, ap);
    va_end(ap);
}

/*
 * Return the pointer to the fully-resolved path name of the process's
 * executable file obtained from the AT_SUN_EXECNAME aux vector entry.
 */
static const char *
mygetexecname(void)
{
    const char  *execname = NULL;
    static auxv_t   auxb;

    /*
     * The first time through, read the initial aux vector that was
     * passed to the process at exec(2).  Only do this once.
     */
    int fd = open("/proc/self/auxv", O_RDONLY);

    if (fd >= 0) {
        while (read(fd, &auxb, sizeof (auxv_t)) == sizeof (auxv_t)) {
            if (auxb.a_type == AT_SUN_EXECNAME) {
                execname = auxb.a_un.a_ptr;
                break;
            }
        }
        (void) close(fd);
    }
    return (execname);
}

static size_t
atosz(char *szstr)
{
    size_t      sz;
    char        *endptr, c;

    sz = strtoll(szstr, &endptr, 0);

    while (c = *endptr++) {
        switch (c) {
        case 't':
        case 'T':
            sz *= 1024;
        /*FALLTHRU*/
        case 'g':
        case 'G':
            sz *= 1024;
        /*FALLTHRU*/
        case 'm':
        case 'M':
            sz *= 1024;
        /*FALLTHRU*/
        case 'k':
        case 'K':
            sz *= 1024;
        default:
            break;
        }
    }
    return (sz);

}

#define PGSZELEM    (8 * sizeof (void *))
static size_t       pgsz[PGSZELEM];
static int      nelem;

static int
pgszok(size_t sz)
{
    int     i;

    if (sz == 0)
        return (1);

    for (i = 0; i < nelem; i++) {
        if (sz == pgsz[i])
            break;
    }

    return (i < nelem);
}

static void
pgszinit()
{
    nelem = getpagesizes(NULL, 0);

    if (!nelem)
        return;

    if (nelem > PGSZELEM)
        nelem = PGSZELEM;

    (void) getpagesizes(pgsz, nelem);
#ifdef MPSSDEBUG
    pgsz[nelem] = 0x800000;
    nelem++;
#endif
}


static int
pgszset(size_t sz, uint_t flags)
{
    struct memcntl_mha  mpss;
    int     rc;

    mpss.mha_cmd = (flags == MPSSHEAP) ?
        MHA_MAPSIZE_BSSBRK: MHA_MAPSIZE_STACK;
    mpss.mha_pagesize = sz;
    mpss.mha_flags = 0;
    rc = memcntl(NULL, 0, MC_HAT_ADVISE, (caddr_t)&mpss, 0, 0);

    return (rc);
}

/*
 * check if exec name matches cfgname found in mpss cfg file.
 */
static int
fnmatch(const char *execname, char *cfgname, char *cwd)
{
    const char  *ename;
    int     rc;

    /* cfgname should not have a '/' unless it begins with one */
    if (cfgname[0] == '/') {
        /*
         * if execname does not begin with a '/', prepend the
         * current directory.
         */
        if (execname[0] != '/') {
            ename = (const char *)strcat(cwd, execname);
        } else
            ename = execname;
    } else {    /* simple cfg name */
        if (ename = strrchr(execname, '/'))
            /* execname is a path name - get the base name */
            ename++;
        else
            ename = execname;
    }
    rc = gmatch(ename, cfgname);
    MPSSPRINT(2, (stderr, "gmatch: %s %s %s %d\n",
        cfgname, ename, execname, rc));

    return (rc);
}

/*
 * Check if string matches any of exec arguments.
 */
static int
argmatch(char *str, FILE *errfp)
{
    int fd;
    psinfo_t pi;
    int rc = 0;
    int arg;
    char **argv;

    fd = open("/proc/self/psinfo", O_RDONLY);

    if (fd >= 0) {
        if (read(fd, &pi, sizeof (pi)) == sizeof (pi)) {
            argv = (char **)pi.pr_argv;
            argv++;
            MPSSPRINT(2, (stderr, "argmatch: %s ", str));
            for (arg = 1; arg < pi.pr_argc; arg++, argv++) {
                if (rc = gmatch(*argv, str)) {
                    MPSSPRINT(2, (stderr, "%s ", *argv));
                    break;
                }
            }
            MPSSPRINT(2, (stderr, "%d\n", rc));
        } else {
            mpsserr(errfp, dgettext(TEXT_DOMAIN,
                "%s: /proc/self/psinfo read failed [%s]\n"),
                mpssident, strerror(errno));
        }
        (void) close(fd);
    } else {
        mpsserr(errfp, dgettext(TEXT_DOMAIN,
            "%s: /proc/self/psinfo open failed [%s]\n"),
            mpssident, strerror(errno));
    }
    return (rc);
}

static int
empty(char *str)
{
    char    c;

    while ((c = *str) == '\n' || c == ' ' || c == '\t')
        str++;
    return (*str == '\0');
}

void
__mpssmain()
{
    static size_t   heapsz = (size_t)-1, stacksz = (size_t)-1, sz;
    char        *cfgfile, *errfile;
    const char  *execname;
    char        *cwd;
    int     cwdlen;
    FILE        *fp = NULL, *errfp = NULL;
    char        *tok, *tokheap = NULL, *tokstack = NULL, *tokarg;
    char        *str, *envheap, *envstack;
    int     lineno = 0;
    char        *locale;

    /*
     * If a private error file is indicated then set the locale
     * for error messages for the duration of this routine.
     * Error messages destined for syslog should not be translated
     * and thus come from the default C locale.
     */
    if ((errfile = getenv(ENV_MPSSERRFILE)) != NULL) {
        errfp = fopen(errfile, "a");
        if (errfp) {
            locale = setlocale(LC_MESSAGES, "");
        } else {
            mpsserr(NULL, dgettext(TEXT_DOMAIN,
                "%s: cannot open error file: %s [%s]\n"),
                mpssident, errfile, strerror(errno));
        }
    }

#ifdef MPSSDEBUG
    if (str = getenv(ENV_MPSSDEBUG))
        mpssdebug = atosz(str);
#endif

    pgszinit();

    if (envstack = getenv(ENV_MPSSSTACK)) {
        sz = atosz(envstack);
        if (pgszok(sz))
            stacksz = sz;
        else
            mpsserr(errfp, dgettext(TEXT_DOMAIN,
                "%s: invalid stack page size specified:"
                " MPSSSTACK=%s\n"),
                mpssident, envstack);
    }

    if (envheap = getenv(ENV_MPSSHEAP)) {
        sz = atosz(envheap);
        if (pgszok(sz))
            heapsz = sz;
        else
            mpsserr(errfp, dgettext(TEXT_DOMAIN,
                "%s: invalid heap page size specified:"
                " MPSSHEAP=%s\n"),
                mpssident, envheap);
    }

    /*
     * Open specified cfg file or default one.
     */
    if (cfgfile = getenv(ENV_MPSSCFGFILE)) {
        fp = fopen(cfgfile, "r");
        if (!fp) {
            mpsserr(errfp, dgettext(TEXT_DOMAIN,
                "%s: cannot open configuration file: %s [%s]\n"),
                mpssident, cfgfile, strerror(errno));
        }
    } else {
        cfgfile = DEF_MPSSCFGFILE;
        fp = fopen(cfgfile, "r");
    }

    execname = mygetexecname();

    if (fp) {

        cwd = getcwd(pbuf, MAXPATHLEN);
        if (!cwd)
            return;

        cwd = strcat(cwd, "/");
        cwdlen = strlen(cwd);

        while (fgets(lbuf, MAXLINELEN, fp)) {
            lineno++;
            if (empty(lbuf))
                continue;
            /*
             * Make sure line wasn't truncated.
             */
            if (strlen(lbuf) >= MAXLINELEN - 1) {
                mpsserr(errfp, dgettext(TEXT_DOMAIN,
                    "%s: invalid entry, "
                    "line too long - cfgfile:"
                    " %s, line: %d\n"),
                    mpssident, cfgfile, lineno);
                continue;
            }
            /*
             * parse right to left in case delimiter is
             * in name.
             */
            if (!(tokstack = strrchr(lbuf, CFGDELIMITER))) {
                mpsserr(errfp, dgettext(TEXT_DOMAIN,
                    "%s: no delimiters specified - cfgfile:"
                    " %s, line: %d\n"),
                    mpssident, cfgfile, lineno);
                continue;
            }
            /* found delimiter in lbuf */
            *tokstack++ = '\0';
            /* remove for error message */
            if (str = strrchr(tokstack, '\n'))
                *str = '\0';
            if (!(tokheap = strrchr(lbuf, CFGDELIMITER))) {
                mpsserr(errfp, dgettext(TEXT_DOMAIN,
                    "%s: invalid entry, "
                    "missing delimiter - cfgfile: %s,"
                    " line: %d\n"),
                    mpssident, cfgfile, lineno);
                continue;
            }
            *tokheap++ = '\0';

            /* exec-args is optional */
            if (tokarg = strrchr(lbuf, ARGDELIMITER)) {
                *tokarg++ = '\0';
            }

            tok = lbuf;

            if (!fnmatch(execname, tok, cwd)) {
                tokheap = tokstack = tokarg = NULL;
                cwd[cwdlen] = '\0';
                continue;
            }

            if (tokarg &&
                !empty(tokarg) &&
                !argmatch(tokarg, errfp)) {
                tokheap = tokstack = tokarg = NULL;
                cwd[cwdlen] = '\0';
                continue;
            }

            /* heap token */
            if (empty(tokheap)) {
                /* empty cfg entry */
                heapsz = (size_t)-1;
            } else {
                sz = atosz(tokheap);
                if (pgszok(sz))
                    heapsz = sz;
                else {
                    mpsserr(errfp, dgettext(TEXT_DOMAIN,
                        "%s: invalid heap page size"
                        " specified (%s) for %s - "
                        "cfgfile: %s, line: %d\n"),
                        mpssident, tokheap,
                        execname, cfgfile,
                        lineno);
                    heapsz = (size_t)-1;
                }
            }

            /* stack token */
            if (empty(tokstack)) {
                stacksz = (size_t)-1;
                break;
            } else {
                sz = atosz(tokstack);
                if (pgszok(sz))
                    stacksz = sz;
                else {
                    mpsserr(errfp, dgettext(TEXT_DOMAIN,
                        "%s: invalid stack page size"
                        " specified (%s) for %s - "
                        "cfgfile: %s, line: %d\n"),
                        mpssident, tokstack,
                        execname, cfgfile, lineno);
                    stacksz = (size_t)-1;
                }
            }
            break;
        }
        (void) fclose(fp);
    }

    if ((heapsz != (size_t)-1) && (pgszset(heapsz, MPSSHEAP) < 0))
        mpsserr(errfp, dgettext(TEXT_DOMAIN,
            "%s: memcntl() failed [%s]: heap page size (%s)"
            " for %s not set\n"),
            mpssident, strerror(errno), (tokheap) ? tokheap : envheap,
            execname);
    if ((stacksz != (size_t)-1) && (pgszset(stacksz, MPSSSTACK) < 0))
        mpsserr(errfp, dgettext(TEXT_DOMAIN,
            "%s: memcntl() failed [%s]: stack page size (%s)"
            " for %s not set\n"),
            mpssident, strerror(errno), (tokstack) ? tokstack: envstack,
            execname);

    if (errfp) {
        (void) fclose(errfp);
        (void) setlocale(LC_MESSAGES, locale);
    } else {
        /* close log file: no-op if nothing logged to syslog */
        closelog();
    }
}