Code Coverage: vinyl-cache/bin/vinyld/mgt/mgt_param_tweak.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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
parse_decimal(const char *p, const char **err)
60 20208
{
61 20208
        double v;
62
63 20208
        v = SF_Parse_Decimal(&p, 0, err);
64 20208
        if (errno == 0 && *p != '\0') {
65 1
                errno = EINVAL;
66 1
                *err = "Invalid number";
67 1
        }
68 20208
        return (v);
69 20208
}
70
71
static int
72
tweak_generic_double(struct vsb *vsb, const char *arg, const struct parspec *pp,
73
    parse_double_f parse, const char *fmt)
74 208220
{
75 208220
        volatile double u, minv = VRT_DECIMAL_MIN, maxv = VRT_DECIMAL_MAX;
76 208220
        volatile double *dest = pp->priv;
77 208220
        const char *err;
78
79 208220
        if (arg != NULL && arg != JSON_FMT) {
80 105543
                if (pp->min != NULL) {
81 105543
                        minv = parse(pp->min, &err);
82 105543
                        if (errno) {
83 0
                                VSB_printf(vsb, "Min: %s (%s)\n", err, pp->min);
84 0
                                return (-1);
85 0
                        }
86 105543
                }
87 105543
                if (pp->max != NULL) {
88 33663
                        maxv = parse(pp->max, &err);
89 33663
                        if (errno) {
90 0
                                VSB_printf(vsb, "Max: %s (%s)\n", err, pp->max);
91 0
                                return (-1);
92 0
                        }
93 33663
                }
94
95 105543
                u = parse(arg, &err);
96 105543
                if (errno) {
97 4
                        VSB_printf(vsb, "%s (%s)\n", err, arg);
98 4
                        return (-1);
99 4
                }
100 105539
                if (u < minv) {
101 1
                        VSB_printf(vsb,
102 1
                            "Must be greater or equal to %s\n", pp->min);
103 1
                        return (-1);
104 1
                }
105 105538
                if (u > maxv) {
106 1
                        VSB_printf(vsb,
107 1
                            "Must be less than or equal to %s\n", pp->max);
108 1
                        return (-1);
109 1
                }
110 105537
                *dest = u;
111 105537
        } else {
112 102677
                VSB_printf(vsb, fmt, *dest);
113 102677
        }
114 208214
        return (0);
115 208220
}
116
117
/*--------------------------------------------------------------------*/
118
119
static double
120
parse_duration(const char *p, const char **err)
121 224541
{
122 224541
        double v, r;
123
124 224541
        v = SF_Parse_Decimal(&p, 0, err);
125 224541
        if (*p == '\0')
126 205452
                return (v);
127
128 19089
        r = VNUM_duration_unit(v, p, NULL);
129 19089
        if (isnan(r)) {
130 2
                errno = EINVAL;
131 2
                *err = "Invalid duration unit";
132 2
        }
133
134 19089
        return (r);
135 224541
}
136
137
int v_matchproto_(tweak_t)
138
tweak_timeout(struct vsb *vsb, const struct parspec *par, const char *arg)
139 51812
{
140 51812
        volatile double *dest = par->priv;
141
142 51812
        if (arg != NULL && !vstrcmp(arg, "never")) {
143 1
                *dest = INFINITY;
144 1
                return (0);
145 1
        }
146
147 51811
        if (*dest == INFINITY && arg == NULL) {
148 0
                VSB_cat(vsb, "never");
149 0
                return (0);
150 0
        }
151
152 51811
        if (*dest == INFINITY && arg == JSON_FMT) {
153 0
                VSB_cat(vsb, "\"never\"");
154 0
                return (0);
155 0
        }
156
157 51811
        return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
158 51811
}
159
160
int v_matchproto_(tweak_t)
161
tweak_duration(struct vsb *vsb, const struct parspec *par, const char *arg)
162 146294
{
163
164 146294
        return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
165 146294
}
166
167
/*--------------------------------------------------------------------*/
168
169
int v_matchproto_(tweak_t)
170
tweak_double(struct vsb *vsb, const struct parspec *par, const char *arg)
171 6743
{
172
173 6743
        return (tweak_generic_double(vsb, arg, par, parse_decimal, "%g"));
174 6743
}
175
176
/*--------------------------------------------------------------------*/
177
178
static int
179
parse_boolean(struct vsb *vsb, const char *arg)
180 13296
{
181
182 13296
        if (!strcasecmp(arg, "off"))
183 4302
                return (0);
184 8994
        if (!strcasecmp(arg, "disable"))
185 1
                return (0);
186 8993
        if (!strcasecmp(arg, "no"))
187 1
                return (0);
188 8992
        if (!strcasecmp(arg, "false"))
189 4
                return (0);
190 8988
        if (!strcasecmp(arg, "on"))
191 8974
                return (1);
192 14
        if (!strcasecmp(arg, "enable"))
193 1
                return (1);
194 13
        if (!strcasecmp(arg, "yes"))
195 1
                return (1);
196 12
        if (!strcasecmp(arg, "true"))
197 11
                return (1);
198
199 1
        VSB_cat(vsb, "use \"on\" or \"off\"\n");
200 1
        return (-1);
201 12
}
202
203
int v_matchproto_(tweak_t)
204
tweak_boolean(struct vsb *vsb, const struct parspec *par, const char *arg)
205 24666
{
206 24666
        volatile unsigned *dest;
207 24666
        int val;
208
209 24666
        dest = par->priv;
210 24666
        if (arg != NULL && arg != JSON_FMT) {
211 13296
                val = parse_boolean(vsb, arg);
212 13296
                if (val < 0)
213 1
                        return (-1);
214 13295
                *dest = val;
215 13295
        } else if (arg == JSON_FMT) {
216 30
                VSB_printf(vsb, "%s", *dest ? "true" : "false");
217 11340
        } else {
218 11340
                VSB_printf(vsb, "%s", *dest ? "on" : "off");
219 11340
        }
220 24665
        return (0);
221 24666
}
222
223
/*--------------------------------------------------------------------*/
224
225
static int
226
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 173233
{
230 173233
        unsigned u, minv = 0, maxv = 0;
231 173233
        char *p;
232
233 173233
        if (arg != NULL && arg != JSON_FMT) {
234 89767
                if (min != NULL) {
235 79648
                        p = NULL;
236 79648
                        minv = strtoul(min, &p, 0);
237 79648
                        if (*arg == '\0' || *p != '\0') {
238 0
                                VSB_printf(vsb, "Illegal Min: %s\n", min);
239 0
                                return (-1);
240 0
                        }
241 79648
                }
242 89767
                if (max != NULL) {
243 39251
                        p = NULL;
244 39251
                        maxv = strtoul(max, &p, 0);
245 39251
                        if (*arg == '\0' || *p != '\0') {
246 0
                                VSB_printf(vsb, "Illegal Max: %s\n", max);
247 0
                                return (-1);
248 0
                        }
249 39251
                }
250 89767
                p = NULL;
251 89767
                if (!strcasecmp(arg, "unlimited"))
252 1
                        u = UINT_MAX;
253 89766
                else {
254 89766
                        u = strtoul(arg, &p, 0);
255 89766
                        if (*arg == '\0' || *p != '\0') {
256 2
                                VSB_printf(vsb, "Not a number (%s)\n", arg);
257 2
                                return (-1);
258 2
                        }
259 89766
                }
260 89765
                if (min != NULL && u < minv) {
261 4
                        VSB_printf(vsb, "Must be at least %s", min);
262 4
                        if (min_reason != NULL)
263 2
                                VSB_printf(vsb, " (%s)", min_reason);
264 4
                        VSB_putc(vsb, '\n');
265 4
                        return (-1);
266 4
                }
267 89761
                if (max != NULL && u > maxv) {
268 6
                        VSB_printf(vsb, "Must be no more than %s", max);
269 6
                        if (max_reason != NULL)
270 5
                                VSB_printf(vsb, " (%s)", max_reason);
271 6
                        VSB_putc(vsb, '\n');
272 6
                        return (-1);
273 6
                }
274 89755
                *dest = u;
275 89755
        } else if (*dest == UINT_MAX && arg != JSON_FMT) {
276 5
                VSB_cat(vsb, "unlimited");
277 83461
        } else {
278 83461
                VSB_printf(vsb, "%u", *dest);
279 83461
        }
280 173221
        return (0);
281 173233
}
282
283
/*--------------------------------------------------------------------*/
284
285
int v_matchproto_(tweak_t)
286
tweak_uint(struct vsb *vsb, const struct parspec *par, const char *arg)
287 160863
{
288 160863
        volatile unsigned *dest;
289
290 160863
        dest = par->priv;
291 160863
        return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
292 160863
            par->dyn_min_reason, par->dyn_max_reason));
293 160863
}
294
295
int v_matchproto_(tweak_t)
296
tweak_uint_orzero(struct vsb *vsb, const struct parspec *par, const char *arg)
297 6744
{
298 6744
        volatile unsigned *dest;
299
300 6744
        dest = par->priv;
301 6744
        if (arg != NULL && arg != JSON_FMT && ! vstrcmp(arg, "0")) {
302 1121
                VSB_cat(vsb, "0");
303 1121
                *dest = 0;
304 1121
                return (0);
305 1121
        }
306 5623
        return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
307 5623
            par->dyn_min_reason, par->dyn_max_reason));
308 6744
}
309
310
/*--------------------------------------------------------------------*/
311
312
static void
313
fmt_bytes(struct vsb *vsb, uintmax_t t)
314 67587
{
315 67587
        const char *p;
316
317 67587
        if (t == 0 || t & 0xff) {
318 22461
                VSB_printf(vsb, "%jub", t);
319 22461
                return;
320 22461
        }
321 60887
        for (p = "kMGTPEZY"; *p; p++) {
322 60887
                if (t & 0x300) {
323 5631
                        VSB_printf(vsb, "%.2f%c", t / 1024.0, *p);
324 5631
                        return;
325 5631
                }
326 55256
                t /= 1024;
327 55256
                if (t & 0x0ff) {
328 39495
                        VSB_printf(vsb, "%ju%c", t, *p);
329 39495
                        return;
330 39495
                }
331 55256
        }
332 0
        VSB_cat(vsb, "(bogus number)");
333 0
}
334
335
static int
336
tweak_generic_bytes(struct vsb *vsb, volatile ssize_t *dest, const char *arg,
337
    const char *min, const char *max)
338 138094
{
339 138094
        uintmax_t r, rmin = 0, rmax = 0;
340 138094
        const char *p;
341
342 138094
        if (arg != NULL && arg != JSON_FMT) {
343 70432
                if (min != NULL) {
344 70432
                        p = VNUM_2bytes(min, &rmin, 0);
345 70432
                        if (p != NULL) {
346 0
                                VSB_printf(vsb, "Invalid min-val: %s\n", min);
347 0
                                return (-1);
348 0
                        }
349 70432
                }
350 70432
                if (max != NULL) {
351 36738
                        p = VNUM_2bytes(max, &rmax, 0);
352 36738
                        if (p != NULL) {
353 0
                                VSB_printf(vsb, "Invalid max-val: %s\n", max);
354 0
                                return (-1);
355 0
                        }
356 36738
                }
357 70432
                p = VNUM_2bytes(arg, &r, 0);
358 70432
                if (p != NULL) {
359 2
                        VSB_cat(vsb, "Could not convert to bytes.\n");
360 2
                        VSB_printf(vsb, "%s\n", p);
361 2
                        VSB_cat(vsb, "  Try something like '80k' or '120M'\n");
362 2
                        return (-1);
363 2
                }
364 70430
                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 0
                }
369 70430
                if (max != NULL && r > rmax) {
370 1
                        VSB_printf(vsb, "Must be no more than %s\n", max);
371 1
                        VSB_cat(vsb, "\n");
372 1
                        return (-1);
373 1
                }
374 70429
                if (min != NULL && r < rmin) {
375 1
                        VSB_printf(vsb, "Must be at least %s\n", min);
376 1
                        return (-1);
377 1
                }
378 70428
                *dest = r;
379 70428
        } else if (arg == JSON_FMT) {
380 75
                VSB_printf(vsb, "%zd", *dest);
381 67587
        } else {
382 67587
                fmt_bytes(vsb, *dest);
383 67587
        }
384 138090
        return (0);
385 138094
}
386
387
/*--------------------------------------------------------------------*/
388
389
int v_matchproto_(tweak_t)
390
tweak_bytes(struct vsb *vsb, const struct parspec *par, const char *arg)
391 25801
{
392 25801
        volatile ssize_t *dest;
393
394 25801
        dest = par->priv;
395 25801
        return (tweak_generic_bytes(vsb, dest, arg, par->min, par->max));
396 25801
}
397
398
/*--------------------------------------------------------------------*/
399
400
int v_matchproto_(tweak_t)
401
tweak_bytes_u(struct vsb *vsb, const struct parspec *par, const char *arg)
402 101045
{
403 101045
        volatile unsigned *d1;
404 101045
        volatile ssize_t dest;
405
406 101045
        d1 = par->priv;
407 101045
        dest = *d1;
408 101045
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
409 4
                return (-1);
410 101041
        *d1 = dest;
411 101041
        return (0);
412 101045
}
413
414
/*--------------------------------------------------------------------
415
 * vsl_buffer and vsl_reclen have dependencies.
416
 */
417
418
int v_matchproto_(tweak_t)
419
tweak_vsl_buffer(struct vsb *vsb, const struct parspec *par, const char *arg)
420 4506
{
421 4506
        volatile unsigned *d1;
422 4506
        volatile ssize_t dest;
423
424 4506
        d1 = par->priv;
425 4506
        dest = *d1;
426 4506
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
427 0
                return (-1);
428 4506
        *d1 = dest;
429 4506
        MCF_ParamConf(MCF_MAXIMUM, "vsl_reclen", "%u", *d1 - 12);
430 4506
        return (0);
431 4506
}
432
433
int v_matchproto_(tweak_t)
434
tweak_vsl_reclen(struct vsb *vsb, const struct parspec *par, const char *arg)
435 6742
{
436 6742
        volatile unsigned *d1;
437 6742
        volatile ssize_t dest;
438
439 6742
        d1 = par->priv;
440 6742
        dest = *d1;
441 6742
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
442 0
                return (-1);
443 6742
        *d1 = dest;
444 6742
        MCF_ParamConf(MCF_MINIMUM, "vsl_buffer", "%u", *d1 + 12);
445 6742
        return (0);
446 6742
}
447
448
/*--------------------------------------------------------------------*/
449
450
int v_matchproto_(tweak_t)
451
tweak_string(struct vsb *vsb, const struct parspec *par, const char *arg)
452 12334
{
453 12334
        char **p = TRUST_ME(par->priv);
454
455 12334
        AN(p);
456 12334
        if (arg == NULL) {
457 5671
                VSB_quote(vsb, *p, -1, 0);
458 6663
        } else if (arg == JSON_FMT) {
459 15
                VSB_putc(vsb, '"');
460 15
                VSB_quote(vsb, *p, -1, VSB_QUOTE_JSON);
461 15
                VSB_putc(vsb, '"');
462 6648
        } else {
463 6648
                REPLACE(*p, arg);
464 6648
        }
465 12334
        return (0);
466 12334
}
467
468
/*--------------------------------------------------------------------*/
469
470
int v_matchproto_(tweak_t)
471
tweak_poolparam(struct vsb *vsb, const struct parspec *par, const char *arg)
472 6791
{
473 6791
        volatile struct poolparam *pp, px;
474 6791
        struct parspec pt;
475 6791
        char **av;
476 6791
        int retval = 0;
477
478 6791
        pp = par->priv;
479 6791
        if (arg == JSON_FMT) {
480 11
                VSB_cat(vsb, "{\n");
481 11
                VSB_indent(vsb, 8);
482 11
                VSB_printf(vsb, "\"min_pool\": %u,\n", pp->min_pool);
483 11
                VSB_printf(vsb, "\"max_pool\": %u,\n", pp->max_pool);
484 11
                VSB_printf(vsb, "\"max_age\": %g\n", pp->max_age);
485 11
                VSB_indent(vsb, -4);
486 11
                VSB_cat(vsb, "}");
487 6780
        } else if (arg == NULL) {
488 3404
                VSB_printf(vsb, "%u,%u,%g",
489 3404
                    pp->min_pool, pp->max_pool, pp->max_age);
490 3404
        } else {
491 3376
                av = VAV_Parse(arg, NULL, ARGV_COMMA);
492 3376
                do {
493 3376
                        if (av[0] != NULL) {
494 1
                                VSB_printf(vsb, "Parse error: %s", av[0]);
495 1
                                retval = -1;
496 1
                                break;
497 1
                        }
498 3375
                        if (av[1] == NULL || av[2] == NULL || av[3] == NULL) {
499 1
                                VSB_cat(vsb,
500 1
                                    "Three fields required:"
501 1
                                    " min_pool, max_pool and max_age\n");
502 1
                                retval = -1;
503 1
                                break;
504 1
                        }
505 3374
                        px = *pp;
506 3374
                        retval = tweak_generic_uint(vsb, &px.min_pool, av[1],
507 3374
                            par->min, par->max, par->dyn_min_reason,
508 3374
                            par->dyn_max_reason);
509 3374
                        if (retval)
510 1
                                break;
511 3373
                        retval = tweak_generic_uint(vsb, &px.max_pool, av[2],
512 3373
                            par->min, par->max, par->dyn_min_reason,
513 3373
                            par->dyn_max_reason);
514 3373
                        if (retval)
515 1
                                break;
516 3372
                        pt.priv = &px.max_age;
517 3372
                        pt.min = "0";
518 3372
                        pt.max = "1000000";
519 3372
                        retval = tweak_generic_double(vsb, av[3], &pt,
520 3372
                            parse_decimal, "%.0f");
521 3372
                        if (retval)
522 1
                                break;
523 3371
                        if (px.min_pool > px.max_pool) {
524 1
                                VSB_cat(vsb,
525 1
                                    "min_pool cannot be larger"
526 1
                                    " than max_pool\n");
527 1
                                retval = -1;
528 1
                                break;
529 1
                        }
530 3370
                        *pp = px;
531 3370
                } while (0);
532 0
                VAV_Free(av);
533 3376
        }
534 0
        return (retval);
535 6791
}
536
537
/*--------------------------------------------------------------------
538
 * Thread pool tweaks.
539
 *
540
 * The min/max values automatically update the opposites appropriate
541
 * limit, so they don't end up crossing.
542
 */
543
544
int v_matchproto_(tweak_t)
545
tweak_thread_pool_min(struct vsb *vsb, const struct parspec *par,
546
    const char *arg)
547 7792
{
548 7792
        if (tweak_uint(vsb, par, arg))
549 2
                return (-1);
550
551 7790
        MCF_ParamConf(MCF_MINIMUM, "thread_pool_max",
552 7790
            "%u", mgt_param.wthread_min);
553 7790
        MCF_ParamConf(MCF_MAXIMUM, "thread_pool_reserve",
554 7790
            "%u", mgt_param.wthread_min * 950 / 1000);
555 7790
        return (0);
556 7792
}
557
558
int v_matchproto_(tweak_t)
559
tweak_thread_pool_max(struct vsb *vsb, const struct parspec *par,
560
    const char *arg)
561 2275
{
562
563 2275
        if (tweak_uint(vsb, par, arg))
564 2
                return (-1);
565
566 2273
        MCF_ParamConf(MCF_MAXIMUM, "thread_pool_min",
567 2273
            "%u", mgt_param.wthread_max);
568 2273
        return (0);
569 2275
}
570
571
/*--------------------------------------------------------------------
572
 * Tweak storage
573
 */
574
575
int v_matchproto_(tweak_t)
576
tweak_storage(struct vsb *vsb, const struct parspec *par, const char *arg)
577 2259
{
578 2259
        struct stevedore *stv;
579
580
        /* XXX: If we want to remove the MUST_RESTART flag from the
581
         * h2_rxbuf_storage parameter, we could have a mechanism here
582
         * that when the child is running calls out through CLI to change
583
         * the stevedore being used. */
584
585 2259
        if (arg == NULL || arg == JSON_FMT)
586 1137
                return (tweak_string(vsb, par, arg));
587
588 1122
        if (!vstrcmp(arg, "Transient") ||
589 1122
            !vstrcmp(arg, "Synth")) {
590
                /* Always allow setting the special names
591
                 *
592
                 * There will always be a stevedore with each of these names,
593
                 * but they may not have been configured at the time
594
                 * this is called. */
595 1121
        } else {
596
                /* Only allow setting the value to a known configured
597
                 * stevedore */
598 1
                STV_Foreach(stv) {
599 1
                        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
600 1
                        if (!vstrcmp(stv->ident, arg))
601 1
                                break;
602 1
                }
603 1
                if (stv == NULL) {
604 0
                        VSB_printf(vsb, "unknown storage backend '%s'", arg);
605 0
                        return (-1);
606 0
                }
607 1
        }
608 1122
        return (tweak_string(vsb, par, arg));
609 1122
}
610
611
/*--------------------------------------------------------------------
612
 * Tweak alias
613
 */
614
615
int v_matchproto_(tweak_t)
616
tweak_alias(struct vsb *vsb, const struct parspec *par, const char *arg)
617 0
{
618
619 0
        (void)vsb;
620 0
        (void)par;
621 0
        (void)arg;
622 0
        WRONG("param tweak never called directly");
623 0
}
624
625
/*--------------------------------------------------------------------
626
 * Tweak bits
627
 */
628
629
enum bit_do {BSET, BCLR, BTST};
630
631
static int
632
bit(uint8_t *p, unsigned no, enum bit_do act)
633 186116
{
634 186116
        uint8_t b;
635
636 186116
        p += (no >> 3);
637 186116
        b = (0x80 >> (no & 7));
638 186116
        if (act == BSET)
639 23808
                *p |= b;
640 162308
        else if (act == BCLR)
641 3124
                *p &= ~b;
642 186116
        return (*p & b);
643 186116
}
644
645
static inline void
646
bit_clear(uint8_t *p, unsigned l)
647 5608
{
648
649 5608
        memset(p, 0, ((size_t)l + 7) >> 3);
650 5608
}
651
652
static inline void
653
bit_set(uint8_t *p, unsigned l)
654 2
{
655
656 2
        memset(p, 255, ((size_t)l + 7) >> 3);
657 2
}
658
659
/*--------------------------------------------------------------------
660
 */
661
662
static int
663
bit_tweak(struct vsb *vsb, uint8_t *p, unsigned l, const char *arg,
664
    const char * const *tags, const char *desc, char sign)
665 8006
{
666 8006
        int i, n;
667 8006
        unsigned j;
668 8006
        char **av;
669 8006
        const char *s;
670
671 8006
        av = VAV_Parse(arg, &n, ARGV_COMMA);
672 8006
        if (av[0] != NULL) {
673 1
                VSB_printf(vsb, "Cannot parse: %s\n", av[0]);
674 1
                VAV_Free(av);
675 1
                return (-1);
676 1
        }
677 40547
        for (i = 1; av[i] != NULL; i++) {
678 32544
                s = av[i];
679 32544
                if (sign == '+' && !vstrcmp(s, "none")) {
680 4485
                        bit_clear(p, l);
681 4485
                        continue;
682 4485
                }
683 28059
                if (sign == '+' && !vstrcmp(s, "all")) {
684 1
                        bit_set(p, l);
685 1
                        continue;
686 1
                }
687 28058
                if (sign == '-' && !vstrcmp(s, "all")) {
688 1123
                        bit_clear(p, l);
689 1123
                        continue;
690 1123
                }
691 26935
                if (sign == '-' && !vstrcmp(s, "none")) {
692 1
                        bit_set(p, l);
693 1
                        continue;
694 1
                }
695 26934
                if (*s != '-' && *s != '+') {
696 1
                        VSB_printf(vsb, "Missing '+' or '-' (%s)\n", s);
697 1
                        VAV_Free(av);
698 1
                        return (-1);
699 1
                }
700 1376979
                for (j = 0; j < l; j++) {
701 1376978
                        if (tags[j] != NULL && !strcasecmp(s + 1, tags[j]))
702 26932
                                break;
703 1376978
                }
704 26933
                if (tags[j] == NULL) {
705 1
                        VSB_printf(vsb, "Unknown %s (%s)\n", desc, s);
706 1
                        VAV_Free(av);
707 1
                        return (-1);
708 1
                }
709 26932
                assert(j < l);
710 26932
                if (s[0] == sign)
711 23808
                        (void)bit(p, j, BSET);
712 3124
                else
713 3124
                        (void)bit(p, j, BCLR);
714 26932
        }
715 8003
        VAV_Free(av);
716 8003
        return (0);
717 8005
}
718
719
720
/*--------------------------------------------------------------------
721
 */
722
723
static int
724
tweak_generic_bits(struct vsb *vsb, const struct parspec *par, const char *arg,
725
    uint8_t *p, unsigned l, const char * const *tags, const char *desc,
726
    char sign)
727 13715
{
728 13715
        unsigned j, all;
729
730 13715
        if (arg != NULL && !vstrcmp(arg, "default")) {
731
                /* XXX: deprecated in favor of param.reset */
732 0
                return (tweak_generic_bits(vsb, par, par->def, p, l, tags,
733 0
                    desc, sign));
734 0
        }
735
736 13715
        if (arg != NULL && arg != JSON_FMT)
737 8006
                return (bit_tweak(vsb, p, l, arg, tags, desc, sign));
738
739 5709
        all = 1;
740 15388
        for (j = 0; all && j < l; j++) {
741 9679
                if (tags[j] == NULL)
742 1465
                        continue;
743 8214
                if (!bit(p, j, BTST))
744 5703
                        all = 0;
745 8214
        }
746
747 5709
        if (arg == JSON_FMT)
748 21
                VSB_putc(vsb, '"');
749 5709
        if (all)
750 6
                VSB_cat(vsb, sign == '+' ? "all" : "none");
751 5703
        else
752 5703
                VSB_cat(vsb, sign == '+' ? "none" : "all");
753 339879
        for (j = 0; !all && j < l; j++) {
754 334170
                if (tags[j] == NULL)
755 183200
                        continue;
756 150970
                if (bit(p, j, BTST))
757 22809
                        VSB_printf(vsb, ",%c%s", sign, tags[j]);
758 150970
        }
759 5709
        if (arg == JSON_FMT)
760 21
                VSB_putc(vsb, '"');
761 5709
        return (0);
762 13715
}
763
764
/*--------------------------------------------------------------------
765
 * The vsl_mask parameter
766
 */
767
768
static const char * const VSL_tags[256] = {
769
#  define SLTM(foo,flags,sdesc,ldesc) [SLT_##foo] = #foo,
770
#  include "tbl/vsl_tags.h"
771
};
772
773
int v_matchproto_(tweak_t)
774
tweak_vsl_mask(struct vsb *vsb, const struct parspec *par, const char *arg)
775 3355
{
776
777 3355
        return (tweak_generic_bits(vsb, par, arg, mgt_param.vsl_mask,
778 3355
            SLT__Reserved, VSL_tags, "VSL tag", '-'));
779 3355
}
780
781
/*--------------------------------------------------------------------
782
 * The debug parameter
783
 */
784
785
static const char * const debug_tags[] = {
786
#  define DEBUG_BIT(U, l, d) [DBG_##U] = #l,
787
#  include "tbl/debug_bits.h"
788
       NULL
789
};
790
791
int v_matchproto_(tweak_t)
792
tweak_debug(struct vsb *vsb, const struct parspec *par, const char *arg)
793 3426
{
794
795 3426
        return (tweak_generic_bits(vsb, par, arg, mgt_param.debug_bits,
796 3426
            DBG_Reserved, debug_tags, "debug bit", '+'));
797 3426
}
798
799
/*--------------------------------------------------------------------
800
 * The experimental parameter
801
 */
802
803
//lint --e{766} not used - remove this linter suppression when adding back exp bits
804
805
static const char * const experimental_tags[] = {
806
#  define EXPERIMENTAL_BIT(U, l, d) [EXPERIMENT_##U] = #l,
807
#  include "tbl/experimental_bits.h"
808
       NULL
809
};
810
811
int v_matchproto_(tweak_t)
812
tweak_experimental(struct vsb *vsb, const struct parspec *par, const char *arg)
813 2258
{
814
815 2258
        return (tweak_generic_bits(vsb, par, arg, mgt_param.experimental_bits,
816 2258
            EXPERIMENT_Reserved, experimental_tags, "experimental bit", '+'));
817 2258
}
818
819
/*--------------------------------------------------------------------
820
 * The feature parameter
821
 */
822
823
static const char * const feature_tags[] = {
824
#  define FEATURE_BIT(U, l, d) [FEATURE_##U] = #l,
825
#  include "tbl/feature_bits.h"
826
       NULL
827
};
828
829
int v_matchproto_(tweak_t)
830
tweak_feature(struct vsb *vsb, const struct parspec *par, const char *arg)
831 2388
{
832
833 2388
        return (tweak_generic_bits(vsb, par, arg, mgt_param.feature_bits,
834 2388
            FEATURE_Reserved, feature_tags, "feature bit", '+'));
835 2388
}
836
837
/*--------------------------------------------------------------------
838
 * The vcc_feature parameter
839
 */
840
841
static const char * const vcc_feature_tags[] = {
842
#  define VCC_FEATURE_BIT(U, l, d) [VCC_FEATURE_##U] = #l,
843
#  include "tbl/vcc_feature_bits.h"
844
       NULL
845
};
846
847
int v_matchproto_(tweak_t)
848
tweak_vcc_feature(struct vsb *vsb, const struct parspec *par, const char *arg)
849 2288
{
850 2288
        const struct parspec *orig;
851 2288
        char buf[32];
852 2288
        int val;
853
854 2288
        if (arg != NULL && arg != JSON_FMT &&
855 2288
            vstrcmp(par->name, "vcc_feature")) {
856 0
                orig = TRUST_ME(par->priv);
857 0
                val = parse_boolean(vsb, arg);
858 0
                if (val < 0)
859 0
                        return (-1);
860 0
                bprintf(buf, "%c%s", val ? '+' : '-',
861 0
                    par->name + vstrlen("vcc_"));
862 0
                return (tweak_vcc_feature(vsb, orig, buf));
863 0
        }
864 2288
        return (tweak_generic_bits(vsb, par, arg, mgt_param.vcc_feature_bits,
865 2288
            VCC_FEATURE_Reserved, vcc_feature_tags, "vcc_feature bit", '+'));
866 2288
}