source: rtems-libbsd/freebsd/sys/kern/subr_hints.c @ c40e45b

#include <machine/rtems-bsd-kernel-space.h>

/*-
 * Copyright (c) 2000,2001 Peter Wemm <peter@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <rtems/bsd/sys/param.h>
#include <rtems/bsd/sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
#include <sys/bus.h>

/*
 * Access functions for device resources.
 */

#ifndef __rtems__
static int checkmethod = 1;
static int use_kenv;
static char *hintp;
#else /* __rtems__ */
#define hintmode 1
#define hintp static_hints
#define use_kenv 0
static char __used default_static_hints[] = "";
__weak_reference(default_static_hints, static_hints);
#endif /* __rtems__ */

#ifndef __rtems__
/*
 * Define kern.hintmode sysctl, which only accept value 2, that cause to
 * switch from Static KENV mode to Dynamic KENV. So systems that have hints
 * compiled into kernel will be able to see/modify KENV (and hints too).
 */

static int
sysctl_hintmode(SYSCTL_HANDLER_ARGS)
{
        const char *cp;
        char *line, *eq;
        int eqidx, error, from_kenv, i, value;

        from_kenv = 0;
        cp = kern_envp;
        value = hintmode;

        /* Fetch candidate for new hintmode value */
        error = sysctl_handle_int(oidp, &value, 0, req);
        if (error || req->newptr == NULL)
                return (error);

        if (value != 2)
                /* Only accept swithing to hintmode 2 */
                return (EINVAL);

        /* Migrate from static to dynamic hints */
        switch (hintmode) {
        case 0:
                if (dynamic_kenv) {
                        /*
                         * Already here. But assign hintmode to 2, to not
                         * check it in the future.
                         */
                        hintmode = 2;
                        return (0);
                }
                from_kenv = 1;
                cp = kern_envp;
                break;
        case 1:
                cp = static_hints;
                break;
        case 2:
                /* Nothing to do, hintmode already 2 */
                return (0);
        }

        while (cp) {
                i = strlen(cp);
                if (i == 0)
                        break;
                if (from_kenv) {
                        if (strncmp(cp, "hint.", 5) != 0)
                                /* kenv can have not only hints */
                                continue;
                }
                eq = strchr(cp, '=');
                if (eq == NULL)
                        /* Bad hint value */
                        continue;
                eqidx = eq - cp;

                line = malloc(i+1, M_TEMP, M_WAITOK);
                strcpy(line, cp);
                line[eqidx] = '\0';
                kern_setenv(line, line + eqidx + 1);
                free(line, M_TEMP);
                cp += i + 1;
        }

        hintmode = value;
        use_kenv = 1;
        return (0);
}

SYSCTL_PROC(_kern, OID_AUTO, hintmode, CTLTYPE_INT|CTLFLAG_RW,
    &hintmode, 0, sysctl_hintmode, "I", "Get/set current hintmode");
#endif /* __rtems__ */

/*
 * Evil wildcarding resource string lookup.
 * This walks the supplied env string table and returns a match.
 * The start point can be remembered for incremental searches.
 */
static int
res_find(int *line, int *startln,
    const char *name, int *unit, const char *resname, const char *value,
    const char **ret_name, int *ret_namelen, int *ret_unit,
    const char **ret_resname, int *ret_resnamelen, const char **ret_value)
{
        int n = 0, hit, i = 0;
        char r_name[32];
        int r_unit;
        char r_resname[32];
        char r_value[128];
        const char *s, *cp;
        char *p;

#ifndef __rtems__
        if (checkmethod) {
                hintp = NULL;

                switch (hintmode) {
                case 0:         /* loader hints in environment only */
                        break;
                case 1:         /* static hints only */
                        hintp = static_hints;
                        checkmethod = 0;
                        break;
                case 2:         /* fallback mode */
                        if (dynamic_kenv) {
                                mtx_lock(&kenv_lock);
                                cp = kenvp[0];
                                for (i = 0; cp != NULL; cp = kenvp[++i]) {
                                        if (!strncmp(cp, "hint.", 5)) {
                                                use_kenv = 1;
                                                checkmethod = 0;
                                                break;
                                        }
                                }
                                mtx_unlock(&kenv_lock);
                        } else {
                                cp = kern_envp;
                                while (cp) {
                                        if (strncmp(cp, "hint.", 5) == 0) {
                                                cp = NULL;
                                                hintp = kern_envp;
                                                break;
                                        }
                                        while (*cp != '\0')
                                                cp++;
                                        cp++;
                                        if (*cp == '\0') {
                                                cp = NULL;
                                                hintp = static_hints;
                                                break;
                                        }
                                }
                        }
                        break;
                default:
                        break;
                }
                if (hintp == NULL) {
                        if (dynamic_kenv) {
                                use_kenv = 1;
                                checkmethod = 0;
                        } else
                                hintp = kern_envp;
                }
        }

        if (use_kenv) {
                mtx_lock(&kenv_lock);
                i = 0;
                cp = kenvp[0];
                if (cp == NULL) {
                        mtx_unlock(&kenv_lock);
                        return (ENOENT);
                }
        } else
#endif /* __rtems__ */
                cp = hintp;
        while (cp) {
                hit = 1;
                (*line)++;
                if (strncmp(cp, "hint.", 5) != 0)
                        hit = 0;
                else
                        n = sscanf(cp, "hint.%32[^.].%d.%32[^=]=%127s",
                            r_name, &r_unit, r_resname, r_value);
                if (hit && n != 4) {
                        printf("CONFIG: invalid hint '%s'\n", cp);
                        p = strchr(cp, 'h');
                        *p = 'H';
                        hit = 0;
                }
                if (hit && startln && *startln >= 0 && *line < *startln)
                        hit = 0;
                if (hit && name && strcmp(name, r_name) != 0)
                        hit = 0;
                if (hit && unit && *unit != r_unit)
                        hit = 0;
                if (hit && resname && strcmp(resname, r_resname) != 0)
                        hit = 0;
                if (hit && value && strcmp(value, r_value) != 0)
                        hit = 0;
                if (hit)
                        break;
                if (use_kenv) {
#ifndef __rtems__
                        cp = kenvp[++i];
                        if (cp == NULL)
                                break;
#else /* __rtems__ */
                        (void) i;
#endif /* __rtems__ */
                } else {
                        while (*cp != '\0')
                                cp++;
                        cp++;
                        if (*cp == '\0') {
                                cp = NULL;
                                break;
                        }
                }
        }
#ifndef __rtems__
        if (use_kenv)
                mtx_unlock(&kenv_lock);
#endif /* __rtems__ */
        if (cp == NULL)
                return ENOENT;

        s = cp;
        /* This is a bit of a hack, but at least is reentrant */
        /* Note that it returns some !unterminated! strings. */
        s = strchr(s, '.') + 1;         /* start of device */
        if (ret_name)
                *ret_name = s;
        s = strchr(s, '.') + 1;         /* start of unit */
        if (ret_namelen && ret_name)
                *ret_namelen = s - *ret_name - 1; /* device length */
        if (ret_unit)
                *ret_unit = r_unit;
        s = strchr(s, '.') + 1;         /* start of resname */
        if (ret_resname)
                *ret_resname = s;
        s = strchr(s, '=') + 1;         /* start of value */
        if (ret_resnamelen && ret_resname)
                *ret_resnamelen = s - *ret_resname - 1; /* value len */
        if (ret_value)
                *ret_value = s;
        if (startln)                    /* line number for anchor */
                *startln = *line + 1;
        return 0;
}

/*
 * Search all the data sources for matches to our query.  We look for
 * dynamic hints first as overrides for static or fallback hints.
 */
static int
resource_find(int *line, int *startln,
    const char *name, int *unit, const char *resname, const char *value,
    const char **ret_name, int *ret_namelen, int *ret_unit,
    const char **ret_resname, int *ret_resnamelen, const char **ret_value)
{
        int i;
        int un;

        *line = 0;

        /* Search for exact unit matches first */
        i = res_find(line, startln, name, unit, resname, value,
            ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
            ret_value);
        if (i == 0)
                return 0;
        if (unit == NULL)
                return ENOENT;
        /* If we are still here, search for wildcard matches */
        un = -1;
        i = res_find(line, startln, name, &un, resname, value,
            ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
            ret_value);
        if (i == 0)
                return 0;
        return ENOENT;
}

int
resource_int_value(const char *name, int unit, const char *resname, int *result)
{
        int error;
        const char *str;
        char *op;
        unsigned long val;
        int line;

        line = 0;
        error = resource_find(&line, NULL, name, &unit, resname, NULL,
            NULL, NULL, NULL, NULL, NULL, &str);
        if (error)
                return error;
        if (*str == '\0') 
                return EFTYPE;
        val = strtoul(str, &op, 0);
        if (*op != '\0') 
                return EFTYPE;
        *result = val;
        return 0;
}

#ifndef __rtems__
int
resource_long_value(const char *name, int unit, const char *resname,
    long *result)
{
        int error;
        const char *str;
        char *op;
        unsigned long val;
        int line;

        line = 0;
        error = resource_find(&line, NULL, name, &unit, resname, NULL,
            NULL, NULL, NULL, NULL, NULL, &str);
        if (error)
                return error;
        if (*str == '\0') 
                return EFTYPE;
        val = strtoul(str, &op, 0);
        if (*op != '\0') 
                return EFTYPE;
        *result = val;
        return 0;
}
#endif /* __rtems__ */

int
resource_string_value(const char *name, int unit, const char *resname,
    const char **result)
{
        int error;
        const char *str;
        int line;

        line = 0;
        error = resource_find(&line, NULL, name, &unit, resname, NULL,
            NULL, NULL, NULL, NULL, NULL, &str);
        if (error)
                return error;
        *result = str;
        return 0;
}

/*
 * This is a bit nasty, but allows us to not modify the env strings.
 */
static const char *
resource_string_copy(const char *s, int len)
{
        static char stringbuf[256];
        static int offset = 0;
        const char *ret;

        if (len == 0)
                len = strlen(s);
        if (len > 255)
                return NULL;
        if ((offset + len + 1) > 255)
                offset = 0;
        bcopy(s, &stringbuf[offset], len);
        stringbuf[offset + len] = '\0';
        ret = &stringbuf[offset];
        offset += len + 1;
        return ret;
}

/*
 * err = resource_find_match(&anchor, &name, &unit, resname, value)
 * Iteratively fetch a list of devices wired "at" something
 * res and value are restrictions.  eg: "at", "scbus0".
 * For practical purposes, res = required, value = optional.
 * *name and *unit are set.
 * set *anchor to zero before starting.
 */
int
resource_find_match(int *anchor, const char **name, int *unit,
    const char *resname, const char *value)
{
        const char *found_name;
        int found_namelen;
        int found_unit;
        int ret;
        int newln;

        newln = *anchor;
        ret = resource_find(anchor, &newln, NULL, NULL, resname, value,
            &found_name, &found_namelen, &found_unit, NULL, NULL, NULL);
        if (ret == 0) {
                *name = resource_string_copy(found_name, found_namelen);
                *unit = found_unit;
        }
        *anchor = newln;
        return ret;
}

#ifndef __rtems__

/*
 * err = resource_find_dev(&anchor, name, &unit, res, value);
 * Iterate through a list of devices, returning their unit numbers.
 * res and value are optional restrictions.  eg: "at", "scbus0".
 * *unit is set to the value.
 * set *anchor to zero before starting.
 */
int
resource_find_dev(int *anchor, const char *name, int *unit,
    const char *resname, const char *value)
{
        int found_unit;
        int newln;
        int ret;

        newln = *anchor;
        ret = resource_find(anchor, &newln, name, NULL, resname, value,
            NULL, NULL, &found_unit, NULL, NULL, NULL);
        if (ret == 0) {
                *unit = found_unit;
        }
        *anchor = newln;
        return ret;
}
#endif /* __rtems__ */

/*
 * Check to see if a device is disabled via a disabled hint.
 */
int
resource_disabled(const char *name, int unit)
{
        int error, value;

        error = resource_int_value(name, unit, "disabled", &value);
        if (error)
               return (0);
        return (value);
}

/*
 * Clear a value associated with a device by removing it from
 * the kernel environment.  This only removes a hint for an
 * exact unit.
 */
int
resource_unset_value(const char *name, int unit, const char *resname)
{
        char varname[128];
        const char *retname, *retvalue;
        int error, line;
        size_t len;

        line = 0;
        error = resource_find(&line, NULL, name, &unit, resname, NULL,
            &retname, NULL, NULL, NULL, NULL, &retvalue);
        if (error)
                return (error);

        retname -= strlen("hint.");
        len = retvalue - retname - 1;
        if (len > sizeof(varname) - 1)
                return (ENAMETOOLONG);
        memcpy(varname, retname, len);
        varname[len] = '\0';
        return (kern_unsetenv(varname));
}