varnish-cache/bin/varnishd/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 37968
parse_decimal(const char *p, const char **err)
60
{
61
        double v;
62
63 37968
        v = SF_Parse_Decimal(&p, 0, err);
64 37968
        if (errno == 0 && *p != '\0') {
65 2
                errno = EINVAL;
66 2
                *err = "Invalid number";
67 2
        }
68 37968
        return (v);
69
}
70
71
static int
72 391252
tweak_generic_double(struct vsb *vsb, const char *arg, const struct parspec *pp,
73
    parse_double_f parse, const char *fmt)
74
{
75 391252
        volatile double u, minv = VRT_DECIMAL_MIN, maxv = VRT_DECIMAL_MAX;
76 391252
        volatile double *dest = pp->priv;
77
        const char *err;
78
79 391252
        if (arg != NULL && arg != JSON_FMT) {
80 198274
                if (pp->min != NULL) {
81 198274
                        minv = parse(pp->min, &err);
82 198274
                        if (errno) {
83 0
                                VSB_printf(vsb, "Min: %s (%s)\n", err, pp->min);
84 0
                                return (-1);
85
                        }
86 198274
                }
87 198274
                if (pp->max != NULL) {
88 63242
                        maxv = parse(pp->max, &err);
89 63242
                        if (errno) {
90 0
                                VSB_printf(vsb, "Max: %s (%s)\n", err, pp->max);
91 0
                                return (-1);
92
                        }
93 63242
                }
94
95 198274
                u = parse(arg, &err);
96 198274
                if (errno) {
97 8
                        VSB_printf(vsb, "%s (%s)\n", err, arg);
98 8
                        return (-1);
99
                }
100 198266
                if (u < minv) {
101 4
                        VSB_printf(vsb,
102 2
                            "Must be greater or equal to %s\n", pp->min);
103 2
                        return (-1);
104
                }
105 198264
                if (u > maxv) {
106 4
                        VSB_printf(vsb,
107 2
                            "Must be less than or equal to %s\n", pp->max);
108 2
                        return (-1);
109
                }
110 198262
                *dest = u;
111 198262
        } else {
112 192978
                VSB_printf(vsb, fmt, *dest);
113
        }
114 391240
        return (0);
115 391252
}
116
117
/*--------------------------------------------------------------------*/
118
119
static double
120 421822
parse_duration(const char *p, const char **err)
121
{
122
        double v, r;
123
124 421822
        v = SF_Parse_Decimal(&p, 0, err);
125 421822
        if (*p == '\0')
126 385956
                return (v);
127
128 35866
        r = VNUM_duration_unit(v, p, NULL);
129 35866
        if (isnan(r)) {
130 4
                errno = EINVAL;
131 4
                *err = "Invalid duration unit";
132 4
        }
133
134 35866
        return (r);
135 421822
}
136
137
int v_matchproto_(tweak_t)
138 97358
tweak_timeout(struct vsb *vsb, const struct parspec *par, const char *arg)
139
{
140 97358
        volatile double *dest = par->priv;
141
142 97358
        if (arg != NULL && !strcmp(arg, "never")) {
143 2
                *dest = INFINITY;
144 2
                return (0);
145
        }
146
147 97356
        if (*dest == INFINITY && arg == NULL) {
148 0
                VSB_cat(vsb, "never");
149 0
                return (0);
150
        }
151
152 97356
        if (*dest == INFINITY && arg == JSON_FMT) {
153 0
                VSB_cat(vsb, "\"never\"");
154 0
                return (0);
155
        }
156
157 97356
        return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
158 97358
}
159
160
int v_matchproto_(tweak_t)
161 274890
tweak_duration(struct vsb *vsb, const struct parspec *par, const char *arg)
162
{
163
164 274890
        return (tweak_generic_double(vsb, arg, par, parse_duration, "%.3f"));
165
}
166
167
/*--------------------------------------------------------------------*/
168
169
int v_matchproto_(tweak_t)
170 12670
tweak_double(struct vsb *vsb, const struct parspec *par, const char *arg)
171
{
172
173 12670
        return (tweak_generic_double(vsb, arg, par, parse_decimal, "%g"));
174
}
175
176
/*--------------------------------------------------------------------*/
177
178
static int
179 24966
parse_boolean(struct vsb *vsb, const char *arg)
180
{
181
182 24966
        if (!strcasecmp(arg, "off"))
183 8068
                return (0);
184 16898
        if (!strcasecmp(arg, "disable"))
185 2
                return (0);
186 16896
        if (!strcasecmp(arg, "no"))
187 2
                return (0);
188 16894
        if (!strcasecmp(arg, "false"))
189 8
                return (0);
190 16886
        if (!strcasecmp(arg, "on"))
191 16858
                return (1);
192 28
        if (!strcasecmp(arg, "enable"))
193 2
                return (1);
194 26
        if (!strcasecmp(arg, "yes"))
195 2
                return (1);
196 24
        if (!strcasecmp(arg, "true"))
197 22
                return (1);
198
199 2
        VSB_cat(vsb, "use \"on\" or \"off\"\n");
200 2
        return (-1);
201 24966
}
202
203
int v_matchproto_(tweak_t)
204 46346
tweak_boolean(struct vsb *vsb, const struct parspec *par, const char *arg)
205
{
206
        volatile unsigned *dest;
207
        int val;
208
209 46346
        dest = par->priv;
210 46346
        if (arg != NULL && arg != JSON_FMT) {
211 24966
                val = parse_boolean(vsb, arg);
212 24966
                if (val < 0)
213 2
                        return (-1);
214 24964
                *dest = val;
215 46344
        } else if (arg == JSON_FMT) {
216 60
                VSB_printf(vsb, "%s", *dest ? "true" : "false");
217 60
        } else {
218 21320
                VSB_printf(vsb, "%s", *dest ? "on" : "off");
219
        }
220 46344
        return (0);
221 46346
}
222
223
/*--------------------------------------------------------------------*/
224
225
static int
226 317090
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 317090
        unsigned u, minv = 0, maxv = 0;
231
        char *p;
232
233 317090
        if (arg != NULL && arg != JSON_FMT) {
234 164434
                if (min != NULL) {
235 145420
                        p = NULL;
236 145420
                        minv = strtoul(min, &p, 0);
237 145420
                        if (*arg == '\0' || *p != '\0') {
238 0
                                VSB_printf(vsb, "Illegal Min: %s\n", min);
239 0
                                return (-1);
240
                        }
241 145420
                }
242 164434
                if (max != NULL) {
243 61072
                        p = NULL;
244 61072
                        maxv = strtoul(max, &p, 0);
245 61072
                        if (*arg == '\0' || *p != '\0') {
246 0
                                VSB_printf(vsb, "Illegal Max: %s\n", max);
247 0
                                return (-1);
248
                        }
249 61072
                }
250 164434
                p = NULL;
251 164434
                if (!strcasecmp(arg, "unlimited"))
252 2
                        u = UINT_MAX;
253
                else {
254 164432
                        u = strtoul(arg, &p, 0);
255 164432
                        if (*arg == '\0' || *p != '\0') {
256 4
                                VSB_printf(vsb, "Not a number (%s)\n", arg);
257 4
                                return (-1);
258
                        }
259
                }
260 164430
                if (min != NULL && u < minv) {
261 8
                        VSB_printf(vsb, "Must be at least %s", min);
262 8
                        if (min_reason != NULL)
263 4
                                VSB_printf(vsb, " (%s)", min_reason);
264 8
                        VSB_putc(vsb, '\n');
265 8
                        return (-1);
266
                }
267 164422
                if (max != NULL && u > maxv) {
268 12
                        VSB_printf(vsb, "Must be no more than %s", max);
269 12
                        if (max_reason != NULL)
270 10
                                VSB_printf(vsb, " (%s)", max_reason);
271 12
                        VSB_putc(vsb, '\n');
272 12
                        return (-1);
273
                }
274 164410
                *dest = u;
275 317066
        } else if (*dest == UINT_MAX && arg != JSON_FMT) {
276 10
                VSB_cat(vsb, "unlimited");
277 10
        } else {
278 152646
                VSB_printf(vsb, "%u", *dest);
279
        }
280 317066
        return (0);
281 317090
}
282
283
/*--------------------------------------------------------------------*/
284
285
int v_matchproto_(tweak_t)
286 293846
tweak_uint(struct vsb *vsb, const struct parspec *par, const char *arg)
287
{
288
        volatile unsigned *dest;
289
290 293846
        dest = par->priv;
291 587692
        return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
292 293846
            par->dyn_min_reason, par->dyn_max_reason));
293
}
294
295
int v_matchproto_(tweak_t)
296 12672
tweak_uint_orzero(struct vsb *vsb, const struct parspec *par, const char *arg)
297
{
298
        volatile unsigned *dest;
299
300 12672
        dest = par->priv;
301 12672
        if (arg != NULL && arg != JSON_FMT && ! strcmp(arg, "0")) {
302 2106
                VSB_cat(vsb, "0");
303 2106
                *dest = 0;
304 2106
                return (0);
305
        }
306 21132
        return (tweak_generic_uint(vsb, dest, arg, par->min, par->max,
307 10566
            par->dyn_min_reason, par->dyn_max_reason));
308 12672
}
309
310
/*--------------------------------------------------------------------*/
311
312
static void
313 122772
fmt_bytes(struct vsb *vsb, uintmax_t t)
314
{
315
        const char *p;
316
317 122772
        if (t == 0 || t & 0xff) {
318 42202
                VSB_printf(vsb, "%jub", t);
319 42202
                return;
320
        }
321 110184
        for (p = "kMGTPEZY"; *p; p++) {
322 110184
                if (t & 0x300) {
323 10582
                        VSB_printf(vsb, "%.2f%c", t / 1024.0, *p);
324 10582
                        return;
325
                }
326 99602
                t /= 1024;
327 99602
                if (t & 0x0ff) {
328 69988
                        VSB_printf(vsb, "%ju%c", t, *p);
329 69988
                        return;
330
                }
331 29614
        }
332 0
        VSB_cat(vsb, "(bogus number)");
333 122772
}
334
335
static int
336 251002
tweak_generic_bytes(struct vsb *vsb, volatile ssize_t *dest, const char *arg,
337
    const char *min, const char *max)
338
{
339 251002
        uintmax_t r, rmin = 0, rmax = 0;
340
        const char *p;
341
342 251002
        if (arg != NULL && arg != JSON_FMT) {
343 128086
                if (min != NULL) {
344 128086
                        p = VNUM_2bytes(min, &rmin, 0);
345 128086
                        if (p != NULL) {
346 0
                                VSB_printf(vsb, "Invalid min-val: %s\n", min);
347 0
                                return (-1);
348
                        }
349 128086
                }
350 128086
                if (max != NULL) {
351 68998
                        p = VNUM_2bytes(max, &rmax, 0);
352 68998
                        if (p != NULL) {
353 0
                                VSB_printf(vsb, "Invalid max-val: %s\n", max);
354 0
                                return (-1);
355
                        }
356 68998
                }
357 128086
                p = VNUM_2bytes(arg, &r, 0);
358 128086
                if (p != NULL) {
359 4
                        VSB_cat(vsb, "Could not convert to bytes.\n");
360 4
                        VSB_printf(vsb, "%s\n", p);
361 4
                        VSB_cat(vsb, "  Try something like '80k' or '120M'\n");
362 4
                        return (-1);
363
                }
364 128082
                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 128082
                if (max != NULL && r > rmax) {
370 2
                        VSB_printf(vsb, "Must be no more than %s\n", max);
371 2
                        VSB_cat(vsb, "\n");
372 2
                        return (-1);
373
                }
374 128080
                if (min != NULL && r < rmin) {
375 2
                        VSB_printf(vsb, "Must be at least %s\n", min);
376 2
                        return (-1);
377
                }
378 128078
                *dest = r;
379 250994
        } else if (arg == JSON_FMT) {
380 144
                VSB_printf(vsb, "%zd", *dest);
381 144
        } else {
382 122772
                fmt_bytes(vsb, *dest);
383
        }
384 250994
        return (0);
385 251002
}
386
387
/*--------------------------------------------------------------------*/
388
389
int v_matchproto_(tweak_t)
390 48474
tweak_bytes(struct vsb *vsb, const struct parspec *par, const char *arg)
391
{
392
        volatile ssize_t *dest;
393
394 48474
        dest = par->priv;
395 48474
        return (tweak_generic_bytes(vsb, dest, arg, par->min, par->max));
396
}
397
398
/*--------------------------------------------------------------------*/
399
400
int v_matchproto_(tweak_t)
401 181394
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 181394
        d1 = par->priv;
407 181394
        dest = *d1;
408 181394
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
409 8
                return (-1);
410 181386
        *d1 = dest;
411 181386
        return (0);
412 181394
}
413
414
/*--------------------------------------------------------------------
415
 * vsl_buffer and vsl_reclen have dependencies.
416
 */
417
418
int v_matchproto_(tweak_t)
419 8466
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 8466
        d1 = par->priv;
425 8466
        dest = *d1;
426 8466
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
427 0
                return (-1);
428 8466
        *d1 = dest;
429 8466
        MCF_ParamConf(MCF_MAXIMUM, "vsl_reclen", "%u", *d1 - 12);
430 8466
        return (0);
431 8466
}
432
433
int v_matchproto_(tweak_t)
434 12668
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 12668
        d1 = par->priv;
440 12668
        dest = *d1;
441 12668
        if (tweak_generic_bytes(vsb, &dest, arg, par->min, par->max))
442 0
                return (-1);
443 12668
        *d1 = dest;
444 12668
        MCF_ParamConf(MCF_MINIMUM, "vsl_buffer", "%u", *d1 + 12);
445 12668
        return (0);
446 12668
}
447
448
/*--------------------------------------------------------------------*/
449
450
int v_matchproto_(tweak_t)
451 23174
tweak_string(struct vsb *vsb, const struct parspec *par, const char *arg)
452
{
453 23174
        char **p = TRUST_ME(par->priv);
454
455 23174
        AN(p);
456 23174
        if (arg == NULL) {
457 10662
                VSB_quote(vsb, *p, -1, 0);
458 23174
        } else if (arg == JSON_FMT) {
459 30
                VSB_putc(vsb, '"');
460 30
                VSB_quote(vsb, *p, -1, VSB_QUOTE_JSON);
461 30
                VSB_putc(vsb, '"');
462 30
        } else {
463 12482
                REPLACE(*p, arg);
464
        }
465 23174
        return (0);
466
}
467
468
/*--------------------------------------------------------------------*/
469
470
int v_matchproto_(tweak_t)
471 12766
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 12766
        int retval = 0;
477
478 12766
        pp = par->priv;
479 12766
        if (arg == JSON_FMT) {
480 22
                VSB_cat(vsb, "{\n");
481 22
                VSB_indent(vsb, 8);
482 22
                VSB_printf(vsb, "\"min_pool\": %u,\n", pp->min_pool);
483 22
                VSB_printf(vsb, "\"max_pool\": %u,\n", pp->max_pool);
484 22
                VSB_printf(vsb, "\"max_age\": %g\n", pp->max_age);
485 22
                VSB_indent(vsb, -4);
486 22
                VSB_cat(vsb, "}");
487 12766
        } else if (arg == NULL) {
488 12800
                VSB_printf(vsb, "%u,%u,%g",
489 6400
                    pp->min_pool, pp->max_pool, pp->max_age);
490 6400
        } else {
491 6344
                av = VAV_Parse(arg, NULL, ARGV_COMMA);
492 6344
                do {
493 6344
                        if (av[0] != NULL) {
494 2
                                VSB_printf(vsb, "Parse error: %s", av[0]);
495 2
                                retval = -1;
496 2
                                break;
497
                        }
498 6342
                        if (av[1] == NULL || av[2] == NULL || av[3] == NULL) {
499 2
                                VSB_cat(vsb,
500
                                    "Three fields required:"
501
                                    " min_pool, max_pool and max_age\n");
502 2
                                retval = -1;
503 2
                                break;
504
                        }
505 6340
                        px = *pp;
506 12680
                        retval = tweak_generic_uint(vsb, &px.min_pool, av[1],
507 6340
                            par->min, par->max, par->dyn_min_reason,
508 6340
                            par->dyn_max_reason);
509 6340
                        if (retval)
510 2
                                break;
511 12676
                        retval = tweak_generic_uint(vsb, &px.max_pool, av[2],
512 6338
                            par->min, par->max, par->dyn_min_reason,
513 6338
                            par->dyn_max_reason);
514 6338
                        if (retval)
515 2
                                break;
516 6336
                        pt.priv = &px.max_age;
517 6336
                        pt.min = "0";
518 6336
                        pt.max = "1000000";
519 6336
                        retval = tweak_generic_double(vsb, av[3], &pt,
520
                            parse_decimal, "%.0f");
521 6336
                        if (retval)
522 2
                                break;
523 6334
                        if (px.min_pool > px.max_pool) {
524 2
                                VSB_cat(vsb,
525
                                    "min_pool cannot be larger"
526
                                    " than max_pool\n");
527 2
                                retval = -1;
528 2
                                break;
529
                        }
530 6332
                        *pp = px;
531 6332
                } while (0);
532 6344
                VAV_Free(av);
533
        }
534 12766
        return (retval);
535
}
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 14630
tweak_thread_pool_min(struct vsb *vsb, const struct parspec *par,
546
    const char *arg)
547
{
548 14630
        if (tweak_uint(vsb, par, arg))
549 4
                return (-1);
550
551 14626
        MCF_ParamConf(MCF_MINIMUM, "thread_pool_max",
552 14626
            "%u", mgt_param.wthread_min);
553 14626
        MCF_ParamConf(MCF_MAXIMUM, "thread_pool_reserve",
554 14626
            "%u", mgt_param.wthread_min * 950 / 1000);
555 14626
        return (0);
556 14630
}
557
558
int v_matchproto_(tweak_t)
559 4278
tweak_thread_pool_max(struct vsb *vsb, const struct parspec *par,
560
    const char *arg)
561
{
562
563 4278
        if (tweak_uint(vsb, par, arg))
564 4
                return (-1);
565
566 4274
        MCF_ParamConf(MCF_MAXIMUM, "thread_pool_min",
567 4274
            "%u", mgt_param.wthread_max);
568 4274
        return (0);
569 4278
}
570
571
/*--------------------------------------------------------------------
572
 * Tweak storage
573
 */
574
575
int v_matchproto_(tweak_t)
576 4246
tweak_storage(struct vsb *vsb, const struct parspec *par, const char *arg)
577
{
578
        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 4246
        if (arg == NULL || arg == JSON_FMT)
586 2138
                return (tweak_string(vsb, par, arg));
587
588 2108
        if (!strcmp(arg, "Transient")) {
589
                /* Always allow setting to the special name
590
                 * "Transient". There will always be a stevedore with this
591
                 * name, but it may not have been configured at the time
592
                 * this is called. */
593 2106
        } else {
594
                /* Only allow setting the value to a known configured
595
                 * stevedore */
596 2
                STV_Foreach(stv) {
597 2
                        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
598 2
                        if (!strcmp(stv->ident, arg))
599 2
                                break;
600
                }
601 2
                if (stv == NULL) {
602 0
                        VSB_printf(vsb, "unknown storage backend '%s'", arg);
603 0
                        return (-1);
604
                }
605
        }
606 2108
        return (tweak_string(vsb, par, arg));
607 4246
}
608
609
/*--------------------------------------------------------------------
610
 * Tweak alias
611
 */
612
613
int v_matchproto_(tweak_t)
614 0
tweak_alias(struct vsb *vsb, const struct parspec *par, const char *arg)
615
{
616
617 0
        (void)vsb;
618 0
        (void)par;
619 0
        (void)arg;
620 0
        WRONG("param tweak never called directly");
621 0
}
622
623
/*--------------------------------------------------------------------
624
 * Tweak bits
625
 */
626
627
enum bit_do {BSET, BCLR, BTST};
628
629
static int
630 343574
bit(uint8_t *p, unsigned no, enum bit_do act)
631
{
632
        uint8_t b;
633
634 343574
        p += (no >> 3);
635 343574
        b = (0x80 >> (no & 7));
636 343574
        if (act == BSET)
637 40424
                *p |= b;
638 303150
        else if (act == BCLR)
639 5844
                *p &= ~b;
640 343574
        return (*p & b);
641
}
642
643
static inline void
644 10536
bit_clear(uint8_t *p, unsigned l)
645
{
646
647 10536
        memset(p, 0, ((size_t)l + 7) >> 3);
648 10536
}
649
650
static inline void
651 4
bit_set(uint8_t *p, unsigned l)
652
{
653
654 4
        memset(p, 255, ((size_t)l + 7) >> 3);
655 4
}
656
657
/*--------------------------------------------------------------------
658
 */
659
660
static int
661 15006
bit_tweak(struct vsb *vsb, uint8_t *p, unsigned l, const char *arg,
662
    const char * const *tags, const char *desc, char sign)
663
{
664
        int i, n;
665
        unsigned j;
666
        char **av;
667
        const char *s;
668
669 15006
        av = VAV_Parse(arg, &n, ARGV_COMMA);
670 15006
        if (av[0] != NULL) {
671 2
                VSB_printf(vsb, "Cannot parse: %s\n", av[0]);
672 2
                VAV_Free(av);
673 2
                return (-1);
674
        }
675 71812
        for (i = 1; av[i] != NULL; i++) {
676 56812
                s = av[i];
677 56812
                if (sign == '+' && !strcmp(s, "none")) {
678 8426
                        bit_clear(p, l);
679 8426
                        continue;
680
                }
681 48386
                if (sign == '+' && !strcmp(s, "all")) {
682 2
                        bit_set(p, l);
683 2
                        continue;
684
                }
685 48384
                if (sign == '-' && !strcmp(s, "all")) {
686 2110
                        bit_clear(p, l);
687 2110
                        continue;
688
                }
689 46274
                if (sign == '-' && !strcmp(s, "none")) {
690 2
                        bit_set(p, l);
691 2
                        continue;
692
                }
693 46272
                if (*s != '-' && *s != '+') {
694 2
                        VSB_printf(vsb, "Missing '+' or '-' (%s)\n", s);
695 2
                        VAV_Free(av);
696 2
                        return (-1);
697
                }
698 2374508
                for (j = 0; j < l; j++) {
699 2374506
                        if (tags[j] != NULL && !strcasecmp(s + 1, tags[j]))
700 46268
                                break;
701 2328238
                }
702 46270
                if (tags[j] == NULL) {
703 2
                        VSB_printf(vsb, "Unknown %s (%s)\n", desc, s);
704 2
                        VAV_Free(av);
705 2
                        return (-1);
706
                }
707 46268
                assert(j < l);
708 46268
                if (s[0] == sign)
709 40424
                        (void)bit(p, j, BSET);
710
                else
711 5844
                        (void)bit(p, j, BCLR);
712 46268
        }
713 15000
        VAV_Free(av);
714 15000
        return (0);
715 15006
}
716
717
718
/*--------------------------------------------------------------------
719
 */
720
721
static int
722 25744
tweak_generic_bits(struct vsb *vsb, const struct parspec *par, const char *arg,
723
    uint8_t *p, unsigned l, const char * const *tags, const char *desc,
724
    char sign)
725
{
726
        unsigned j, all;
727
728 25744
        if (arg != NULL && !strcmp(arg, "default")) {
729
                /* XXX: deprecated in favor of param.reset */
730 0
                return (tweak_generic_bits(vsb, par, par->def, p, l, tags,
731 0
                    desc, sign));
732
        }
733
734 25744
        if (arg != NULL && arg != JSON_FMT)
735 15006
                return (bit_tweak(vsb, p, l, arg, tags, desc, sign));
736
737 10738
        all = 1;
738 29008
        for (j = 0; all && j < l; j++) {
739 18270
                if (tags[j] == NULL)
740 2798
                        continue;
741 15472
                if (!bit(p, j, BTST))
742 10726
                        all = 0;
743 15472
        }
744
745 10738
        if (arg == JSON_FMT)
746 42
                VSB_putc(vsb, '"');
747 10738
        if (all)
748 12
                VSB_cat(vsb, sign == '+' ? "all" : "none");
749
        else
750 10726
                VSB_cat(vsb, sign == '+' ? "none" : "all");
751 639366
        for (j = 0; !all && j < l; j++) {
752 628628
                if (tags[j] == NULL)
753 346794
                        continue;
754 281834
                if (bit(p, j, BTST))
755 38610
                        VSB_printf(vsb, ",%c%s", sign, tags[j]);
756 281834
        }
757 10738
        if (arg == JSON_FMT)
758 42
                VSB_putc(vsb, '"');
759 10738
        return (0);
760 25744
}
761
762
/*--------------------------------------------------------------------
763
 * The vsl_mask parameter
764
 */
765
766
static const char * const VSL_tags[256] = {
767
#  define SLTM(foo,flags,sdesc,ldesc) [SLT_##foo] = #foo,
768
#  include "tbl/vsl_tags.h"
769
};
770
771
int v_matchproto_(tweak_t)
772 6252
tweak_vsl_mask(struct vsb *vsb, const struct parspec *par, const char *arg)
773
{
774
775 6252
        return (tweak_generic_bits(vsb, par, arg, mgt_param.vsl_mask,
776
            SLT__Reserved, VSL_tags, "VSL tag", '-'));
777
}
778
779
/*--------------------------------------------------------------------
780
 * The debug parameter
781
 */
782
783
static const char * const debug_tags[] = {
784
#  define DEBUG_BIT(U, l, d) [DBG_##U] = #l,
785
#  include "tbl/debug_bits.h"
786
       NULL
787
};
788
789
int v_matchproto_(tweak_t)
790 6444
tweak_debug(struct vsb *vsb, const struct parspec *par, const char *arg)
791
{
792
793 6444
        return (tweak_generic_bits(vsb, par, arg, mgt_param.debug_bits,
794
            DBG_Reserved, debug_tags, "debug bit", '+'));
795
}
796
797
/*--------------------------------------------------------------------
798
 * The experimental parameter
799
 */
800
801
static const char * const experimental_tags[] = {
802
#  define EXPERIMENTAL_BIT(U, l, d) [EXPERIMENT_##U] = #l,
803
#  include "tbl/experimental_bits.h"
804
       NULL
805
};
806
807
int v_matchproto_(tweak_t)
808 4248
tweak_experimental(struct vsb *vsb, const struct parspec *par, const char *arg)
809
{
810
811 4248
        return (tweak_generic_bits(vsb, par, arg, mgt_param.experimental_bits,
812
            EXPERIMENT_Reserved, experimental_tags, "experimental bit", '+'));
813
}
814
815
/*--------------------------------------------------------------------
816
 * The feature parameter
817
 */
818
819
static const char * const feature_tags[] = {
820
#  define FEATURE_BIT(U, l, d) [FEATURE_##U] = #l,
821
#  include "tbl/feature_bits.h"
822
       NULL
823
};
824
825
int v_matchproto_(tweak_t)
826 4496
tweak_feature(struct vsb *vsb, const struct parspec *par, const char *arg)
827
{
828
829 4496
        return (tweak_generic_bits(vsb, par, arg, mgt_param.feature_bits,
830
            FEATURE_Reserved, feature_tags, "feature bit", '+'));
831
}
832
833
/*--------------------------------------------------------------------
834
 * The vcc_feature parameter
835
 */
836
837
static const char * const vcc_feature_tags[] = {
838
#  define VCC_FEATURE_BIT(U, l, d) [VCC_FEATURE_##U] = #l,
839
#  include "tbl/vcc_feature_bits.h"
840
       NULL
841
};
842
843
int v_matchproto_(tweak_t)
844 4304
tweak_vcc_feature(struct vsb *vsb, const struct parspec *par, const char *arg)
845
{
846
        const struct parspec *orig;
847
        char buf[32];
848
        int val;
849
850 4304
        if (arg != NULL && arg != JSON_FMT &&
851 2160
            strcmp(par->name, "vcc_feature")) {
852 0
                orig = TRUST_ME(par->priv);
853 0
                val = parse_boolean(vsb, arg);
854 0
                if (val < 0)
855 0
                        return (-1);
856 0
                bprintf(buf, "%c%s", val ? '+' : '-',
857
                    par->name + strlen("vcc_"));
858 0
                return (tweak_vcc_feature(vsb, orig, buf));
859
        }
860 4304
        return (tweak_generic_bits(vsb, par, arg, mgt_param.vcc_feature_bits,
861
            VCC_FEATURE_Reserved, vcc_feature_tags, "vcc_feature bit", '+'));
862 4304
}