GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * 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 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.
 *
 * Functions for tweaking parameters
 *
 */

#include "config.h"

#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "mgt/mgt.h"

#include "mgt/mgt_param.h"
#include "storage/storage.h"
#include "vav.h"
#include "vnum.h"
#include "vsl_priv.h"

const char * const JSON_FMT = (const char *)&JSON_FMT;

/*--------------------------------------------------------------------
 * Generic handling of double typed parameters
 */

typedef double parse_double_f(const char *, const char **);

static double
parse_decimal(const char *p, const char **err)
{
        double v;

        v = SF_Parse_Decimal(&p, 0, err);
        if (errno == 0 && *p != '\0') {
                errno = EINVAL;
                *err = "Invalid number";
        }
        return (v);
}

static int
tweak_generic_double(struct vsb *vsb, const char *arg, const struct parspec *pp,
    parse_double_f parse, const char *fmt)
{
        volatile double u, minv = VRT_DECIMAL_MIN, maxv = VRT_DECIMAL_MAX;
        volatile double *dest = pp->priv;
        const char *err;

        if (arg != NULL && arg != JSON_FMT) {
                if (pp->min != NULL) {
                        minv = parse(pp->min, &err);
                        if (errno) {
                                VSB_printf(vsb, "Min: %s (%s)\n", err, pp->min);
                                return (-1);
                        }
                }
                if (pp->max != NULL) {
                        maxv = parse(pp->max, &err);
                        if (errno) {
                                VSB_printf(vsb, "Max: %s (%s)\n", err, pp->max);
                                return (-1);
                        }
                }

                u = parse(arg, &err);
                if (errno) {
                        VSB_printf(vsb, "%s (%s)\n", err, arg);
                        return (-1);
                }
                if (u < minv) {
                        VSB_printf(vsb,
                            "Must be greater or equal to %s\n", pp->min);
                        return (-1);
                }
                if (u > maxv) {
                        VSB_printf(vsb,
                            "Must be less than or equal to %s\n", pp->max);
                        return (-1);
                }
                *dest = u;
        } else {
                VSB_printf(vsb, fmt, *dest);
        }
        return (0);
}

/*--------------------------------------------------------------------*/

static double
parse_duration(const char *p, const char **err)
{
        double v, r;

        v = SF_Parse_Decimal(&p, 0, err);
        if (*p == '\0')
                return (v);

        r = VNUM_duration_unit(v, p, NULL);
        if (isnan(r)) {
                errno = EINVAL;
                *err = "Invalid duration unit";
        }

        return (r);
}

int v_matchproto_(tweak_t)
tweak_timeout(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile double *dest = par->priv;

        if (arg != NULL && !vstrcmp(arg, "never")) {
                *dest = INFINITY;
                return (0);
        }

        if (*dest == INFINITY && arg == NULL) {
                VSB_cat(vsb, "never");
                return (0);
        }

        if (*dest == INFINITY && arg == JSON_FMT) {
                VSB_cat(vsb, "\"never\"");
                return (0);
        }

        return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
}

int v_matchproto_(tweak_t)
tweak_duration(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
}

/*--------------------------------------------------------------------*/

int v_matchproto_(tweak_t)
tweak_double(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        return (tweak_generic_double(vsb, arg, par, parse_decimal, "%g"));
}

/*--------------------------------------------------------------------*/

static int
parse_boolean(struct vsb *vsb, const char *arg)
{

        if (!strcasecmp(arg, "off"))
                return (0);
        if (!strcasecmp(arg, "disable"))
                return (0);
        if (!strcasecmp(arg, "no"))
                return (0);
        if (!strcasecmp(arg, "false"))
                return (0);
        if (!strcasecmp(arg, "on"))
                return (1);
        if (!strcasecmp(arg, "enable"))
                return (1);
        if (!strcasecmp(arg, "yes"))
                return (1);
        if (!strcasecmp(arg, "true"))
                return (1);

        VSB_cat(vsb, "use \"on\" or \"off\"\n");
        return (-1);
}

int v_matchproto_(tweak_t)
tweak_boolean(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile unsigned *dest;
        int val;

        dest = par->priv;
        if (arg != NULL && arg != JSON_FMT) {
                val = parse_boolean(vsb, arg);
                if (val < 0)
                        return (-1);
                *dest = val;
        } else if (arg == JSON_FMT) {
                VSB_printf(vsb, "%s", *dest ? "true" : "false");
        } else {
                VSB_printf(vsb, "%s", *dest ? "on" : "off");
        }
        return (0);
}

/*--------------------------------------------------------------------*/

static int
tweak_generic_uint(struct vsb *vsb, volatile unsigned *dest, const char *arg,
    const char *min, const char *max,
    const char *min_reason, const char *max_reason)
{
        unsigned u, minv = 0, maxv = 0;
        char *p;

        if (arg != NULL && arg != JSON_FMT) {
                if (min != NULL) {
                        p = NULL;
                        minv = strtoul(min, &p, 0);
                        if (*arg == '\0' || *p != '\0') {
                                VSB_printf(vsb, "Illegal Min: %s\n", min);
                                return (-1);
                        }
                }
                if (max != NULL) {
                        p = NULL;
                        maxv = strtoul(max, &p, 0);
                        if (*arg == '\0' || *p != '\0') {
                                VSB_printf(vsb, "Illegal Max: %s\n", max);
                                return (-1);
                        }
                }
                p = NULL;
                if (!strcasecmp(arg, "unlimited"))
                        u = UINT_MAX;
                else {
                        u = strtoul(arg, &p, 0);
                        if (*arg == '\0' || *p != '\0') {
                                VSB_printf(vsb, "Not a number (%s)\n", arg);
                                return (-1);
                        }
                }
                if (min != NULL && u < minv) {
                        VSB_printf(vsb, "Must be at least %s", min);
                        if (min_reason != NULL)
                                VSB_printf(vsb, " (%s)", min_reason);
                        VSB_putc(vsb, '\n');
                        return (-1);
                }
                if (max != NULL && u > maxv) {
                        VSB_printf(vsb, "Must be no more than %s", max);
                        if (max_reason != NULL)
                                VSB_printf(vsb, " (%s)", max_reason);
                        VSB_putc(vsb, '\n');
                        return (-1);
                }
                *dest = u;
        } else if (*dest == UINT_MAX && arg != JSON_FMT) {
                VSB_cat(vsb, "unlimited");
        } else {
                VSB_printf(vsb, "%u", *dest);
        }
        return (0);
}

/*--------------------------------------------------------------------*/

int v_matchproto_(tweak_t)
tweak_uint(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile unsigned *dest;

        dest = par->priv;
        return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
            par->dyn_min_reason, par->dyn_max_reason));
}

int v_matchproto_(tweak_t)
tweak_uint_orzero(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile unsigned *dest;

        dest = par->priv;
        if (arg != NULL && arg != JSON_FMT && ! vstrcmp(arg, "0")) {
                VSB_cat(vsb, "0");
                *dest = 0;
                return (0);
        }
        return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
            par->dyn_min_reason, par->dyn_max_reason));
}

/*--------------------------------------------------------------------*/

static void
fmt_bytes(struct vsb *vsb, uintmax_t t)
{
        const char *p;

        if (t == 0 || t & 0xff) {
                VSB_printf(vsb, "%jub", t);
                return;
        }
        for (p = "kMGTPEZY"; *p; p++) {
                if (t & 0x300) {
                        VSB_printf(vsb, "%.2f%c", t / 1024.0, *p);
                        return;
                }
                t /= 1024;
                if (t & 0x0ff) {
                        VSB_printf(vsb, "%ju%c", t, *p);
                        return;
                }
        }
        VSB_cat(vsb, "(bogus number)");
}

static int
tweak_generic_bytes(struct vsb *vsb, volatile ssize_t *dest, const char *arg,
    const char *min, const char *max)
{
        uintmax_t r, rmin = 0, rmax = 0;
        const char *p;

        if (arg != NULL && arg != JSON_FMT) {
                if (min != NULL) {
                        p = VNUM_2bytes(min, &rmin, 0);
                        if (p != NULL) {
                                VSB_printf(vsb, "Invalid min-val: %s\n", min);
                                return (-1);
                        }
                }
                if (max != NULL) {
                        p = VNUM_2bytes(max, &rmax, 0);
                        if (p != NULL) {
                                VSB_printf(vsb, "Invalid max-val: %s\n", max);
                                return (-1);
                        }
                }
                p = VNUM_2bytes(arg, &r, 0);
                if (p != NULL) {
                        VSB_cat(vsb, "Could not convert to bytes.\n");
                        VSB_printf(vsb, "%s\n", p);
                        VSB_cat(vsb, "  Try something like '80k' or '120M'\n");
                        return (-1);
                }
                if ((uintmax_t)((ssize_t)r) != r) {
                        fmt_bytes(vsb, r);
                        VSB_cat(vsb, " is too large for this architecture.\n");
                        return (-1);
                }
                if (max != NULL && r > rmax) {
                        VSB_printf(vsb, "Must be no more than %s\n", max);
                        VSB_cat(vsb, "\n");
                        return (-1);
                }
                if (min != NULL && r < rmin) {
                        VSB_printf(vsb, "Must be at least %s\n", min);
                        return (-1);
                }
                *dest = r;
        } else if (arg == JSON_FMT) {
                VSB_printf(vsb, "%zd", *dest);
        } else {
                fmt_bytes(vsb, *dest);
        }
        return (0);
}

/*--------------------------------------------------------------------*/

int v_matchproto_(tweak_t)
tweak_bytes(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile ssize_t *dest;

        dest = par->priv;
        return (tweak_generic_bytes(vsb, dest, arg, par->min, par->max));
}

/*--------------------------------------------------------------------*/

int v_matchproto_(tweak_t)
tweak_bytes_u(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile unsigned *d1;
        volatile ssize_t dest;

        d1 = par->priv;
        dest = *d1;
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
                return (-1);
        *d1 = dest;
        return (0);
}

/*--------------------------------------------------------------------
 * vsl_buffer and vsl_reclen have dependencies.
 */

int v_matchproto_(tweak_t)
tweak_vsl_buffer(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile unsigned *d1;
        volatile ssize_t dest;

        d1 = par->priv;
        dest = *d1;
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
                return (-1);
        *d1 = dest;
        MCF_ParamConf(MCF_MAXIMUM, "vsl_reclen", "%u", *d1 - 12);
        return (0);
}

int v_matchproto_(tweak_t)
tweak_vsl_reclen(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile unsigned *d1;
        volatile ssize_t dest;

        d1 = par->priv;
        dest = *d1;
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
                return (-1);
        *d1 = dest;
        MCF_ParamConf(MCF_MINIMUM, "vsl_buffer", "%u", *d1 + 12);
        return (0);
}

/*--------------------------------------------------------------------*/

int v_matchproto_(tweak_t)
tweak_string(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        char **p = TRUST_ME(par->priv);

        AN(p);
        if (arg == NULL) {
                VSB_quote(vsb, *p, -1, 0);
        } else if (arg == JSON_FMT) {
                VSB_putc(vsb, '"');
                VSB_quote(vsb, *p, -1, VSB_QUOTE_JSON);
                VSB_putc(vsb, '"');
        } else {
                REPLACE(*p, arg);
        }
        return (0);
}

/*--------------------------------------------------------------------*/

int v_matchproto_(tweak_t)
tweak_poolparam(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        volatile struct poolparam *pp, px;
        struct parspec pt;
        char **av;
        int retval = 0;

        pp = par->priv;
        if (arg == JSON_FMT) {
                VSB_cat(vsb, "{\n");
                VSB_indent(vsb, 8);
                VSB_printf(vsb, "\"min_pool\": %u,\n", pp->min_pool);
                VSB_printf(vsb, "\"max_pool\": %u,\n", pp->max_pool);
                VSB_printf(vsb, "\"max_age\": %g\n", pp->max_age);
                VSB_indent(vsb, -4);
                VSB_cat(vsb, "}");
        } else if (arg == NULL) {
                VSB_printf(vsb, "%u,%u,%g",
                    pp->min_pool, pp->max_pool, pp->max_age);
        } else {
                av = VAV_Parse(arg, NULL, ARGV_COMMA);
                do {
                        if (av[0] != NULL) {
                                VSB_printf(vsb, "Parse error: %s", av[0]);
                                retval = -1;
                                break;
                        }
                        if (av[1] == NULL || av[2] == NULL || av[3] == NULL) {
                                VSB_cat(vsb,
                                    "Three fields required:"
                                    " min_pool, max_pool and max_age\n");
                                retval = -1;
                                break;
                        }
                        px = *pp;
                        retval = tweak_generic_uint(vsb, &px.min_pool, av[1],
                            par->min, par->max, par->dyn_min_reason,
                            par->dyn_max_reason);
                        if (retval)
                                break;
                        retval = tweak_generic_uint(vsb, &px.max_pool, av[2],
                            par->min, par->max, par->dyn_min_reason,
                            par->dyn_max_reason);
                        if (retval)
                                break;
                        pt.priv = &px.max_age;
                        pt.min = "0";
                        pt.max = "1000000";
                        retval = tweak_generic_double(vsb, av[3], &pt,
                            parse_decimal, "%.0f");
                        if (retval)
                                break;
                        if (px.min_pool > px.max_pool) {
                                VSB_cat(vsb,
                                    "min_pool cannot be larger"
                                    " than max_pool\n");
                                retval = -1;
                                break;
                        }
                        *pp = px;
                } while (0);
                VAV_Free(av);
        }
        return (retval);
}

/*--------------------------------------------------------------------
 * Thread pool tweaks.
 *
 * The min/max values automatically update the opposites appropriate
 * limit, so they don't end up crossing.
 */

int v_matchproto_(tweak_t)
tweak_thread_pool_min(struct vsb *vsb, const struct parspec *par,
    const char *arg)
{
        if (tweak_uint(vsb, par, arg))
                return (-1);

        MCF_ParamConf(MCF_MINIMUM, "thread_pool_max",
            "%u", mgt_param.wthread_min);
        MCF_ParamConf(MCF_MAXIMUM, "thread_pool_reserve",
            "%u", mgt_param.wthread_min * 950 / 1000);
        return (0);
}

int v_matchproto_(tweak_t)
tweak_thread_pool_max(struct vsb *vsb, const struct parspec *par,
    const char *arg)
{

        if (tweak_uint(vsb, par, arg))
                return (-1);

        MCF_ParamConf(MCF_MAXIMUM, "thread_pool_min",
            "%u", mgt_param.wthread_max);
        return (0);
}

/*--------------------------------------------------------------------
 * Tweak storage
 */

int v_matchproto_(tweak_t)
tweak_storage(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        struct stevedore *stv;

        /* XXX: If we want to remove the MUST_RESTART flag from the
         * h2_rxbuf_storage parameter, we could have a mechanism here
         * that when the child is running calls out through CLI to change
         * the stevedore being used. */

        if (arg == NULL || arg == JSON_FMT)
                return (tweak_string(vsb, par, arg));

        if (!vstrcmp(arg, "Transient") ||
            !vstrcmp(arg, "Synth")) {
                /* Always allow setting the special names
                 *
                 * There will always be a stevedore with each of these names,
                 * but they may not have been configured at the time
                 * this is called. */
        } else {
                /* Only allow setting the value to a known configured
                 * stevedore */
                STV_Foreach(stv) {
                        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
                        if (!vstrcmp(stv->ident, arg))
                                break;
                }
                if (stv == NULL) {
                        VSB_printf(vsb, "unknown storage backend '%s'", arg);
                        return (-1);
                }
        }
        return (tweak_string(vsb, par, arg));
}

/*--------------------------------------------------------------------
 * Tweak alias
 */

int v_matchproto_(tweak_t)
tweak_alias(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        (void)vsb;
        (void)par;
        (void)arg;
        WRONG("param tweak never called directly");
}

/*--------------------------------------------------------------------
 * Tweak bits
 */

enum bit_do {BSET, BCLR, BTST};

static int
bit(uint8_t *p, unsigned no, enum bit_do act)
{
        uint8_t b;

        p += (no >> 3);
        b = (0x80 >> (no & 7));
        if (act == BSET)
                *p |= b;
        else if (act == BCLR)
                *p &= ~b;
        return (*p & b);
}

static inline void
bit_clear(uint8_t *p, unsigned l)
{

        memset(p, 0, ((size_t)l + 7) >> 3);
}

static inline void
bit_set(uint8_t *p, unsigned l)
{

        memset(p, 255, ((size_t)l + 7) >> 3);
}

/*--------------------------------------------------------------------
 */

static int
bit_tweak(struct vsb *vsb, uint8_t *p, unsigned l, const char *arg,
    const char * const *tags, const char *desc, char sign)
{
        int i, n;
        unsigned j;
        char **av;
        const char *s;

        av = VAV_Parse(arg, &n, ARGV_COMMA);
        if (av[0] != NULL) {
                VSB_printf(vsb, "Cannot parse: %s\n", av[0]);
                VAV_Free(av);
                return (-1);
        }
        for (i = 1; av[i] != NULL; i++) {
                s = av[i];
                if (sign == '+' && !vstrcmp(s, "none")) {
                        bit_clear(p, l);
                        continue;
                }
                if (sign == '+' && !vstrcmp(s, "all")) {
                        bit_set(p, l);
                        continue;
                }
                if (sign == '-' && !vstrcmp(s, "all")) {
                        bit_clear(p, l);
                        continue;
                }
                if (sign == '-' && !vstrcmp(s, "none")) {
                        bit_set(p, l);
                        continue;
                }
                if (*s != '-' && *s != '+') {
                        VSB_printf(vsb, "Missing '+' or '-' (%s)\n", s);
                        VAV_Free(av);
                        return (-1);
                }
                for (j = 0; j < l; j++) {
                        if (tags[j] != NULL && !strcasecmp(s + 1, tags[j]))
                                break;
                }
                if (tags[j] == NULL) {
                        VSB_printf(vsb, "Unknown %s (%s)\n", desc, s);
                        VAV_Free(av);
                        return (-1);
                }
                assert(j < l);
                if (s[0] == sign)
                        (void)bit(p, j, BSET);
                else
                        (void)bit(p, j, BCLR);
        }
        VAV_Free(av);
        return (0);
}


/*--------------------------------------------------------------------
 */

static int
tweak_generic_bits(struct vsb *vsb, const struct parspec *par, const char *arg,
    uint8_t *p, unsigned l, const char * const *tags, const char *desc,
    char sign)
{
        unsigned j, all;

        if (arg != NULL && !vstrcmp(arg, "default")) {
                /* XXX: deprecated in favor of param.reset */
                return (tweak_generic_bits(vsb, par, par->def, p, l, tags,
                    desc, sign));
        }

        if (arg != NULL && arg != JSON_FMT)
                return (bit_tweak(vsb, p, l, arg, tags, desc, sign));

        all = 1;
        for (j = 0; all && j < l; j++) {
                if (tags[j] == NULL)
                        continue;
                if (!bit(p, j, BTST))
                        all = 0;
        }

        if (arg == JSON_FMT)
                VSB_putc(vsb, '"');
        if (all)
                VSB_cat(vsb, sign == '+' ? "all" : "none");
        else
                VSB_cat(vsb, sign == '+' ? "none" : "all");
        for (j = 0; !all && j < l; j++) {
                if (tags[j] == NULL)
                        continue;
                if (bit(p, j, BTST))
                        VSB_printf(vsb, ",%c%s", sign, tags[j]);
        }
        if (arg == JSON_FMT)
                VSB_putc(vsb, '"');
        return (0);
}

/*--------------------------------------------------------------------
 * The vsl_mask parameter
 */

static const char * const VSL_tags[256] = {
#  define SLTM(foo,flags,sdesc,ldesc) [SLT_##foo] = #foo,
#  include "tbl/vsl_tags.h"
};

int v_matchproto_(tweak_t)
tweak_vsl_mask(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        return (tweak_generic_bits(vsb, par, arg, mgt_param.vsl_mask,
            SLT__Reserved, VSL_tags, "VSL tag", '-'));
}

/*--------------------------------------------------------------------
 * The debug parameter
 */

static const char * const debug_tags[] = {
#  define DEBUG_BIT(U, l, d) [DBG_##U] = #l,
#  include "tbl/debug_bits.h"
       NULL
};

int v_matchproto_(tweak_t)
tweak_debug(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        return (tweak_generic_bits(vsb, par, arg, mgt_param.debug_bits,
            DBG_Reserved, debug_tags, "debug bit", '+'));
}

/*--------------------------------------------------------------------
 * The experimental parameter
 */

//lint --e{766} not used - remove this linter suppression when adding back exp bits

static const char * const experimental_tags[] = {
#  define EXPERIMENTAL_BIT(U, l, d) [EXPERIMENT_##U] = #l,
#  include "tbl/experimental_bits.h"
       NULL
};

int v_matchproto_(tweak_t)
tweak_experimental(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        return (tweak_generic_bits(vsb, par, arg, mgt_param.experimental_bits,
            EXPERIMENT_Reserved, experimental_tags, "experimental bit", '+'));
}

/*--------------------------------------------------------------------
 * The feature parameter
 */

static const char * const feature_tags[] = {
#  define FEATURE_BIT(U, l, d) [FEATURE_##U] = #l,
#  include "tbl/feature_bits.h"
       NULL
};

int v_matchproto_(tweak_t)
tweak_feature(struct vsb *vsb, const struct parspec *par, const char *arg)
{

        return (tweak_generic_bits(vsb, par, arg, mgt_param.feature_bits,
            FEATURE_Reserved, feature_tags, "feature bit", '+'));
}

/*--------------------------------------------------------------------
 * The vcc_feature parameter
 */

static const char * const vcc_feature_tags[] = {
#  define VCC_FEATURE_BIT(U, l, d) [VCC_FEATURE_##U] = #l,
#  include "tbl/vcc_feature_bits.h"
       NULL
};

int v_matchproto_(tweak_t)
tweak_vcc_feature(struct vsb *vsb, const struct parspec *par, const char *arg)
{
        const struct parspec *orig;
        char buf[32];
        int val;

        if (arg != NULL && arg != JSON_FMT &&
            vstrcmp(par->name, "vcc_feature")) {
                orig = TRUST_ME(par->priv);
                val = parse_boolean(vsb, arg);
                if (val < 0)
                        return (-1);
                bprintf(buf, "%c%s", val ? '+' : '-',
                    par->name + vstrlen("vcc_"));
                return (tweak_vcc_feature(vsb, orig, buf));
        }
        return (tweak_generic_bits(vsb, par, arg, mgt_param.vcc_feature_bits,
            VCC_FEATURE_Reserved, vcc_feature_tags, "vcc_feature bit", '+'));
}

		vinyl-cache/bin/vinyld/mgt/mgt_param_tweak.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		* Functions for tweaking parameters
31		*
32		*/
33
34		#include "config.h"
35
36		#include <limits.h>
37		#include <math.h>
38		#include <stdio.h>
39		#include <stdlib.h>
40		#include <string.h>
41
42		#include "mgt/mgt.h"
43
44		#include "mgt/mgt_param.h"
45		#include "storage/storage.h"
46		#include "vav.h"
47		#include "vnum.h"
48		#include "vsl_priv.h"
49
50		const char * const JSON_FMT = (const char *)&JSON_FMT;
51
52		/*--------------------------------------------------------------------
53		* Generic handling of double typed parameters
54		*/
55
56		typedef double parse_double_f(const char , const char *);
57
58		static double
59	79176	parse_decimal(const char p, const char *err)
60		{
61		double v;
62
63	79176	v = SF_Parse_Decimal(&p, 0, err);
64	79176	if (errno == 0 && *p != '\0') {
65	4	errno = EINVAL;
66	4	*err = "Invalid number";
67	4	}
68	79176	return (v);
69		}
70
71		static int
72	815832	tweak_generic_double(struct vsb vsb, const char arg, const struct parspec *pp,
73		parse_double_f parse, const char *fmt)
74		{
75	815832	volatile double u, minv = VRT_DECIMAL_MIN, maxv = VRT_DECIMAL_MAX;
76	815832	volatile double *dest = pp->priv;
77		const char *err;
78
79	815832	if (arg != NULL && arg != JSON_FMT) {
80	413496	if (pp->min != NULL) {
81	413496	minv = parse(pp->min, &err);
82	413496	if (errno) {
83	0	VSB_printf(vsb, "Min: %s (%s)\n", err, pp->min);
84	0	return (-1);
85		}
86	413496	}
87	413496	if (pp->max != NULL) {
88	131888	maxv = parse(pp->max, &err);
89	131888	if (errno) {
90	0	VSB_printf(vsb, "Max: %s (%s)\n", err, pp->max);
91	0	return (-1);
92		}
93	131888	}
94
95	413496	u = parse(arg, &err);
96	413496	if (errno) {
97	16	VSB_printf(vsb, "%s (%s)\n", err, arg);
98	16	return (-1);
99		}
100	413480	if (u < minv) {
101	8	VSB_printf(vsb,
102	4	"Must be greater or equal to %s\n", pp->min);
103	4	return (-1);
104		}
105	413476	if (u > maxv) {
106	8	VSB_printf(vsb,
107	4	"Must be less than or equal to %s\n", pp->max);
108	4	return (-1);
109		}
110	413472	*dest = u;
111	413472	} else {
112	402336	VSB_printf(vsb, fmt, *dest);
113		}
114	815808	return (0);
115	815832	}
116
117		/--------------------------------------------------------------------/
118
119		static double
120	879704	parse_duration(const char p, const char *err)
121		{
122		double v, r;
123
124	879704	v = SF_Parse_Decimal(&p, 0, err);
125	879704	if (*p == '\0')
126	804912	return (v);
127
128	74792	r = VNUM_duration_unit(v, p, NULL);
129	74792	if (isnan(r)) {
130	8	errno = EINVAL;
131	8	*err = "Invalid duration unit";
132	8	}
133
134	74792	return (r);
135	879704	}
136
137		int v_matchproto_(tweak_t)
138	202996	tweak_timeout(struct vsb vsb, const struct parspec par, const char *arg)
139		{
140	202996	volatile double *dest = par->priv;
141
142	202996	if (arg != NULL && !vstrcmp(arg, "never")) {
143	4	*dest = INFINITY;
144	4	return (0);
145		}
146
147	202992	if (*dest == INFINITY && arg == NULL) {
148	0	VSB_cat(vsb, "never");
149	0	return (0);
150		}
151
152	202992	if (*dest == INFINITY && arg == JSON_FMT) {
153	0	VSB_cat(vsb, "\"never\"");
154	0	return (0);
155		}
156
157	202992	return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
158	202996	}
159
160		int v_matchproto_(tweak_t)
161	573208	tweak_duration(struct vsb vsb, const struct parspec par, const char *arg)
162		{
163
164	573208	return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
165		}
166
167		/--------------------------------------------------------------------/
168
169		int v_matchproto_(tweak_t)
170	26420	tweak_double(struct vsb vsb, const struct parspec par, const char *arg)
171		{
172
173	26420	return (tweak_generic_double(vsb, arg, par, parse_decimal, "%g"));
174		}
175
176		/--------------------------------------------------------------------/
177
178		static int
179	52044	parse_boolean(struct vsb vsb, const char arg)
180		{
181
182	52044	if (!strcasecmp(arg, "off"))
183	16808	return (0);
184	35236	if (!strcasecmp(arg, "disable"))
185	4	return (0);
186	35232	if (!strcasecmp(arg, "no"))
187	4	return (0);
188	35228	if (!strcasecmp(arg, "false"))
189	16	return (0);
190	35212	if (!strcasecmp(arg, "on"))
191	35156	return (1);
192	56	if (!strcasecmp(arg, "enable"))
193	4	return (1);
194	52	if (!strcasecmp(arg, "yes"))
195	4	return (1);
196	48	if (!strcasecmp(arg, "true"))
197	44	return (1);
198
199	4	VSB_cat(vsb, "use \"on\" or \"off\"\n");
200	4	return (-1);
201	52044	}
202
203		int v_matchproto_(tweak_t)
204	96604	tweak_boolean(struct vsb vsb, const struct parspec par, const char *arg)
205		{
206		volatile unsigned *dest;
207		int val;
208
209	96604	dest = par->priv;
210	96604	if (arg != NULL && arg != JSON_FMT) {
211	52044	val = parse_boolean(vsb, arg);
212	52044	if (val < 0)
213	4	return (-1);
214	52040	*dest = val;
215	96600	} else if (arg == JSON_FMT) {
216	120	VSB_printf(vsb, "%s", *dest ? "true" : "false");
217	120	} else {
218	44440	VSB_printf(vsb, "%s", *dest ? "on" : "off");
219		}
220	96600	return (0);
221	96604	}
222
223		/--------------------------------------------------------------------/
224
225		static int
226	678728	tweak_generic_uint(struct vsb vsb, volatile unsigned dest, const char *arg,
227		const char min, const char max,
228		const char min_reason, const char max_reason)
229		{
230	678728	unsigned u, minv = 0, maxv = 0;
231		char *p;
232
233	678728	if (arg != NULL && arg != JSON_FMT) {
234	351672	if (min != NULL) {
235	312024	p = NULL;
236	312024	minv = strtoul(min, &p, 0);
237	312024	if (arg == '\0' \|\| p != '\0') {
238	0	VSB_printf(vsb, "Illegal Min: %s\n", min);
239	0	return (-1);
240		}
241	312024	}
242	351672	if (max != NULL) {
243	153748	p = NULL;
244	153748	maxv = strtoul(max, &p, 0);
245	153748	if (arg == '\0' \|\| p != '\0') {
246	0	VSB_printf(vsb, "Illegal Max: %s\n", max);
247	0	return (-1);
248		}
249	153748	}
250	351672	p = NULL;
251	351672	if (!strcasecmp(arg, "unlimited"))
252	4	u = UINT_MAX;
253		else {
254	351668	u = strtoul(arg, &p, 0);
255	351668	if (arg == '\0' \|\| p != '\0') {
256	8	VSB_printf(vsb, "Not a number (%s)\n", arg);
257	8	return (-1);
258		}
259		}
260	351664	if (min != NULL && u < minv) {
261	16	VSB_printf(vsb, "Must be at least %s", min);
262	16	if (min_reason != NULL)
263	8	VSB_printf(vsb, " (%s)", min_reason);
264	16	VSB_putc(vsb, '\n');
265	16	return (-1);
266		}
267	351648	if (max != NULL && u > maxv) {
268	24	VSB_printf(vsb, "Must be no more than %s", max);
269	24	if (max_reason != NULL)
270	20	VSB_printf(vsb, " (%s)", max_reason);
271	24	VSB_putc(vsb, '\n');
272	24	return (-1);
273		}
274	351624	*dest = u;
275	678680	} else if (*dest == UINT_MAX && arg != JSON_FMT) {
276	20	VSB_cat(vsb, "unlimited");
277	20	} else {
278	327036	VSB_printf(vsb, "%u", *dest);
279		}
280	678680	return (0);
281	678728	}
282
283		/--------------------------------------------------------------------/
284
285		int v_matchproto_(tweak_t)
286	630260	tweak_uint(struct vsb vsb, const struct parspec par, const char *arg)
287		{
288		volatile unsigned *dest;
289
290	630260	dest = par->priv;
291	1260520	return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
292	630260	par->dyn_min_reason, par->dyn_max_reason));
293		}
294
295		int v_matchproto_(tweak_t)
296	26424	tweak_uint_orzero(struct vsb vsb, const struct parspec par, const char *arg)
297		{
298		volatile unsigned *dest;
299
300	26424	dest = par->priv;
301	26424	if (arg != NULL && arg != JSON_FMT && ! vstrcmp(arg, "0")) {
302	4392	VSB_cat(vsb, "0");
303	4392	*dest = 0;
304	4392	return (0);
305		}
306	44064	return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
307	22032	par->dyn_min_reason, par->dyn_max_reason));
308	26424	}
309
310		/--------------------------------------------------------------------/
311
312		static void
313	255984	fmt_bytes(struct vsb *vsb, uintmax_t t)
314		{
315		const char *p;
316
317	255984	if (t == 0 \|\| t & 0xff) {
318	88004	VSB_printf(vsb, "%jub", t);
319	88004	return;
320		}
321	229728	for (p = "kMGTPEZY"; *p; p++) {
322	229728	if (t & 0x300) {
323	22064	VSB_printf(vsb, "%.2f%c", t / 1024.0, *p);
324	22064	return;
325		}
326	207664	t /= 1024;
327	207664	if (t & 0x0ff) {
328	145916	VSB_printf(vsb, "%ju%c", t, *p);
329	145916	return;
330		}
331	61748	}
332	0	VSB_cat(vsb, "(bogus number)");
333	255984	}
334
335		static int
336	523356	tweak_generic_bytes(struct vsb vsb, volatile ssize_t dest, const char *arg,
337		const char min, const char max)
338		{
339	523356	uintmax_t r, rmin = 0, rmax = 0;
340		const char *p;
341
342	523356	if (arg != NULL && arg != JSON_FMT) {
343	267084	if (min != NULL) {
344	267084	p = VNUM_2bytes(min, &rmin, 0);
345	267084	if (p != NULL) {
346	0	VSB_printf(vsb, "Invalid min-val: %s\n", min);
347	0	return (-1);
348		}
349	267084	}
350	267084	if (max != NULL) {
351	143868	p = VNUM_2bytes(max, &rmax, 0);
352	143868	if (p != NULL) {
353	0	VSB_printf(vsb, "Invalid max-val: %s\n", max);
354	0	return (-1);
355		}
356	143868	}
357	267084	p = VNUM_2bytes(arg, &r, 0);
358	267084	if (p != NULL) {
359	8	VSB_cat(vsb, "Could not convert to bytes.\n");
360	8	VSB_printf(vsb, "%s\n", p);
361	8	VSB_cat(vsb, " Try something like '80k' or '120M'\n");
362	8	return (-1);
363		}
364	267076	if ((uintmax_t)((ssize_t)r) != r) {
365	0	fmt_bytes(vsb, r);
366	0	VSB_cat(vsb, " is too large for this architecture.\n");
367	0	return (-1);
368		}
369	267076	if (max != NULL && r > rmax) {
370	4	VSB_printf(vsb, "Must be no more than %s\n", max);
371	4	VSB_cat(vsb, "\n");
372	4	return (-1);
373		}
374	267072	if (min != NULL && r < rmin) {
375	4	VSB_printf(vsb, "Must be at least %s\n", min);
376	4	return (-1);
377		}
378	267068	*dest = r;
379	523340	} else if (arg == JSON_FMT) {
380	288	VSB_printf(vsb, "%zd", *dest);
381	288	} else {
382	255984	fmt_bytes(vsb, *dest);
383		}
384	523340	return (0);
385	523356	}
386
387		/--------------------------------------------------------------------/
388
389		int v_matchproto_(tweak_t)
390	101060	tweak_bytes(struct vsb vsb, const struct parspec par, const char *arg)
391		{
392		volatile ssize_t *dest;
393
394	101060	dest = par->priv;
395	101060	return (tweak_generic_bytes(vsb, dest, arg, par->min, par->max));
396		}
397
398		/--------------------------------------------------------------------/
399
400		int v_matchproto_(tweak_t)
401	378224	tweak_bytes_u(struct vsb vsb, const struct parspec par, const char *arg)
402		{
403		volatile unsigned *d1;
404		volatile ssize_t dest;
405
406	378224	d1 = par->priv;
407	378224	dest = *d1;
408	378224	if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
409	16	return (-1);
410	378208	*d1 = dest;
411	378208	return (0);
412	378224	}
413
414		/*--------------------------------------------------------------------
415		* vsl_buffer and vsl_reclen have dependencies.
416		*/
417
418		int v_matchproto_(tweak_t)
419	17656	tweak_vsl_buffer(struct vsb vsb, const struct parspec par, const char *arg)
420		{
421		volatile unsigned *d1;
422		volatile ssize_t dest;
423
424	17656	d1 = par->priv;
425	17656	dest = *d1;
426	17656	if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
427	0	return (-1);
428	17656	*d1 = dest;
429	17656	MCF_ParamConf(MCF_MAXIMUM, "vsl_reclen", "%u", *d1 - 12);
430	17656	return (0);
431	17656	}
432
433		int v_matchproto_(tweak_t)
434	26416	tweak_vsl_reclen(struct vsb vsb, const struct parspec par, const char *arg)
435		{
436		volatile unsigned *d1;
437		volatile ssize_t dest;
438
439	26416	d1 = par->priv;
440	26416	dest = *d1;
441	26416	if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
442	0	return (-1);
443	26416	*d1 = dest;
444	26416	MCF_ParamConf(MCF_MINIMUM, "vsl_buffer", "%u", *d1 + 12);
445	26416	return (0);
446	26416	}
447
448		/--------------------------------------------------------------------/
449
450		int v_matchproto_(tweak_t)
451	48308	tweak_string(struct vsb vsb, const struct parspec par, const char *arg)
452		{
453	48308	char **p = TRUST_ME(par->priv);
454
455	48308	AN(p);
456	48308	if (arg == NULL) {
457	22224	VSB_quote(vsb, *p, -1, 0);
458	48308	} else if (arg == JSON_FMT) {
459	60	VSB_putc(vsb, '"');
460	60	VSB_quote(vsb, *p, -1, VSB_QUOTE_JSON);
461	60	VSB_putc(vsb, '"');
462	60	} else {
463	26024	REPLACE(*p, arg);
464		}
465	48308	return (0);
466		}
467
468		/--------------------------------------------------------------------/
469
470		int v_matchproto_(tweak_t)
471	26612	tweak_poolparam(struct vsb vsb, const struct parspec par, const char *arg)
472		{
473		volatile struct poolparam *pp, px;
474		struct parspec pt;
475		char **av;
476	26612	int retval = 0;
477
478	26612	pp = par->priv;
479	26612	if (arg == JSON_FMT) {
480	44	VSB_cat(vsb, "{\n");
481	44	VSB_indent(vsb, 8);
482	44	VSB_printf(vsb, "\"min_pool\": %u,\n", pp->min_pool);
483	44	VSB_printf(vsb, "\"max_pool\": %u,\n", pp->max_pool);
484	44	VSB_printf(vsb, "\"max_age\": %g\n", pp->max_age);
485	44	VSB_indent(vsb, -4);
486	44	VSB_cat(vsb, "}");
487	26612	} else if (arg == NULL) {
488	26680	VSB_printf(vsb, "%u,%u,%g",
489	13340	pp->min_pool, pp->max_pool, pp->max_age);
490	13340	} else {
491	13228	av = VAV_Parse(arg, NULL, ARGV_COMMA);
492	13228	do {
493	13228	if (av[0] != NULL) {
494	4	VSB_printf(vsb, "Parse error: %s", av[0]);
495	4	retval = -1;
496	4	break;
497		}
498	13224	if (av[1] == NULL \|\| av[2] == NULL \|\| av[3] == NULL) {
499	4	VSB_cat(vsb,