Code Coverage: vinyl-cache/lib/libvinylapi/vsc.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
7
 *
8
 * SPDX-License-Identifier: BSD-2-Clause
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
 * SUCH DAMAGE.
30
 */
31
32
#include "config.h"
33
34
#include <sys/stat.h>
35
36
#include <fnmatch.h>
37
#include <stdint.h>
38
#include <stdio.h>
39
#include <stdlib.h>
40
#include <string.h>
41
#include <unistd.h>
42
43
#include "vdef.h"
44
#include "vas.h"
45
#include "miniobj.h"
46
#include "vqueue.h"
47
#include "vjsn.h"
48
#include "vsb.h"
49
#include "vsc_priv.h"
50
#include "vtim.h"
51
52
#include "vapi/vsc.h"
53
#include "vapi/vsm.h"
54
55
struct vsc_sf_mode {
56
        const char              *name;
57
        unsigned                include;
58
        unsigned                fail;
59
        unsigned                append;
60
};
61
62
static const struct vsc_sf_mode VSC_SF_INCLUDE[1] = {{"include", 1, 1, 1}};
63
static const struct vsc_sf_mode VSC_SF_EXCLUDE[1] = {{"exclude", 0, 0, 1}};
64
static const struct vsc_sf_mode VSC_SF_REQUIRE[1] = {{"require", 1, 0, 0}};
65
66
struct vsc_sf {
67
        unsigned                        magic;
68
#define VSC_SF_MAGIC                    0x558478dd
69
        VTAILQ_ENTRY(vsc_sf)            list;
70
        char                            *pattern;
71
        const struct vsc_sf_mode        *mode;
72
};
73
74
VTAILQ_HEAD(vsc_sf_head, vsc_sf);
75
76
struct vsc_pt {
77
        struct VSC_point        point;
78
        char                    *name;
79
};
80
81
enum vsc_seg_type {
82
        VSC_SEG_COUNTERS = 1,
83
        VSC_SEG_DOCS,
84
};
85
86
struct vsc_seg {
87
        unsigned                magic;
88
#define VSC_SEG_MAGIC           0x801177d4
89
        enum vsc_seg_type       type;
90
        VTAILQ_ENTRY(vsc_seg)   list;
91
        VTAILQ_ENTRY(vsc_seg)   doc_list;
92
        struct vsm_fantom       fantom[1];
93
        const struct vsc_head   *head;
94
        const char              *body;
95
96
        struct vjsn             *vj;
97
98
        unsigned                npoints;
99
        struct vsc_pt           *points;
100
101
        int                     mapped;
102
        int                     exposed;
103
};
104
VTAILQ_HEAD(vsc_seg_head, vsc_seg);
105
106
struct vsc {
107
        unsigned                magic;
108
#define VSC_MAGIC               0x3373554a
109
110
        unsigned                raw;
111
        struct vsc_sf_head      sf_list;
112
        struct vsc_seg_head     segs;
113
        struct vsc_seg_head     docs;
114
115
        VSC_new_f               *fnew;
116
        VSC_destroy_f           *fdestroy;
117
        void                    *priv;
118
};
119
120
/*--------------------------------------------------------------------
121
 * Build the static level, type and point descriptions
122
 */
123
124
enum vsc_levels {
125
#define VSC_LEVEL_F(v,l,e,d) v,
126
#include "tbl/vsc_levels.h"
127
};
128
129
static const struct VSC_level_desc levels[] = {
130
#define VSC_LEVEL_F(v,l,e,d) [v] = {#v, l, e, d},
131
#include "tbl/vsc_levels.h"
132
};
133
134
static const ssize_t nlevels = vcountof(levels);
135
136
/*--------------------------------------------------------------------*/
137
138
struct vsc *
139
VSC_New(void)
140 1070
{
141 1070
        struct vsc *vsc;
142
143 1070
        ALLOC_OBJ(vsc, VSC_MAGIC);
144 1070
        if (vsc == NULL)
145 0
                return (vsc);
146 1070
        VTAILQ_INIT(&vsc->sf_list);
147 1070
        VTAILQ_INIT(&vsc->segs);
148 1070
        VTAILQ_INIT(&vsc->docs);
149 1070
        return (vsc);
150 1070
}
151
152
/*--------------------------------------------------------------------*/
153
154
static int
155
vsc_sf_arg(struct vsc *vsc, const char *glob, const struct vsc_sf_mode *mode)
156 37
{
157 37
        struct vsc_sf *sf;
158
159 37
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
160 37
        AN(glob);
161 37
        AN(mode);
162
163 37
        ALLOC_OBJ(sf, VSC_SF_MAGIC);
164 37
        AN(sf);
165 37
        REPLACE(sf->pattern, glob);
166 37
        sf->mode = mode;
167 37
        AN(mode->name);
168 37
        if (mode->append)
169 29
                VTAILQ_INSERT_TAIL(&vsc->sf_list, sf, list);
170 8
        else
171 8
                VTAILQ_INSERT_HEAD(&vsc->sf_list, sf, list);
172 37
        return (1);
173 37
}
174
175
static int
176
vsc_f_arg(struct vsc *vsc, const char *opt)
177 21
{
178
179 21
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
180 21
        AN(opt);
181
182 21
        if (opt[0] == '^')
183 5
                return (vsc_sf_arg(vsc, opt + 1, VSC_SF_EXCLUDE));
184 16
        return (vsc_sf_arg(vsc, opt, VSC_SF_INCLUDE));
185 21
}
186
187
/*--------------------------------------------------------------------*/
188
189
int
190
VSC_Arg(struct vsc *vsc, char arg, const char *opt)
191 37
{
192
193 37
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
194
195 37
        switch (arg) {
196 7
        case 'I': return (vsc_sf_arg(vsc, opt, VSC_SF_INCLUDE));
197 1
        case 'X': return (vsc_sf_arg(vsc, opt, VSC_SF_EXCLUDE));
198 8
        case 'R': return (vsc_sf_arg(vsc, opt, VSC_SF_REQUIRE));
199 21
        case 'f': return (vsc_f_arg(vsc, opt));
200 0
        case 'r': vsc->raw = !vsc->raw; return (1);
201 0
        default: return (0);
202 37
        }
203 37
}
204
205
unsigned
206
VSC_IsRaw(const struct vsc *vsc)
207 7
{
208
209 7
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
210 7
        return (vsc->raw);
211 7
}
212
213
/*--------------------------------------------------------------------
214
 */
215
216
static int
217
vsc_filter(const struct vsc *vsc, const char *nm)
218 67252
{
219 67252
        struct vsc_sf *sf;
220 67252
        unsigned res = 0;
221
222 67252
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
223 67252
        VTAILQ_FOREACH(sf, &vsc->sf_list, list) {
224 12807
                if (!fnmatch(sf->pattern, nm, 0))
225 222
                        return (!sf->mode->include);
226 12585
                res |= sf->mode->fail;
227 12585
        }
228 67030
        return (res);
229 67252
}
230
231
/*--------------------------------------------------------------------
232
 */
233
234
static void
235
vsc_clean_point(struct vsc_pt *point)
236 57016
{
237 57016
        REPLACE(point->name, NULL);
238 57016
}
239
240
static void
241
vsc_fill_point(const struct vsc *vsc, const struct vsc_seg *seg,
242
    const struct vjsn_val *vv, struct vsb *vsb, struct vsc_pt *point)
243 67252
{
244 67252
        struct vjsn_val *vt;
245
246 67252
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
247 67252
        memset(point, 0, sizeof *point);
248
249 67252
        vt = vjsn_child(vv, "name");
250 67252
        AN(vt);
251 67252
        assert(vjsn_is_string(vt));
252
253 67252
        VSB_clear(vsb);
254 67252
        VSB_printf(vsb, "%s.%s", seg->fantom->ident, vt->value);
255 67252
        AZ(VSB_finish(vsb));
256
257 67252
        if (vsc_filter(vsc, VSB_data(vsb)))
258 4373
                return;
259
260 62879
        point->name = strdup(VSB_data(vsb));
261 62879
        AN(point->name);
262 62879
        point->point.name = point->name;
263
264 62879
#define DOF(n, k)                               \
265 188637
        vt = vjsn_child(vv, k);                 \
266 188637
        AN(vt);                                 \
267 188637
        assert(vjsn_is_string(vt));             \
268 188637
        point->point.n = vt->value;
269
270 125758
        DOF(ctype, "ctype");
271 125758
        DOF(sdesc, "oneliner");
272 125758
        DOF(ldesc, "docs");
273 125758
#undef DOF
274 125758
        vt = vjsn_child(vv, "type");
275 125758
        AN(vt);
276 62879
        assert(vjsn_is_string(vt));
277
278 62879
        if (!vstrcmp(vt->value, "counter")) {
279 56212
                point->point.semantics = 'c';
280 56212
        } else if (!vstrcmp(vt->value, "gauge")) {
281 6532
                point->point.semantics = 'g';
282 6532
        } else if (!vstrcmp(vt->value, "bitmap")) {
283 135
                point->point.semantics = 'b';
284 135
        } else {
285 0
                point->point.semantics = '?';
286 0
        }
287
288 62879
        vt = vjsn_child(vv, "format");
289 62879
        AN(vt);
290 62879
        assert(vjsn_is_string(vt));
291
292 62879
        if (!vstrcmp(vt->value, "integer")) {
293 57202
                point->point.format = 'i';
294 57202
        } else if (!vstrcmp(vt->value, "bytes")) {
295 5031
                point->point.format = 'B';
296 5031
        } else if (!vstrcmp(vt->value, "bitmap")) {
297 135
                point->point.format = 'b';
298 511
        } else if (!vstrcmp(vt->value, "duration")) {
299 511
                point->point.format = 'd';
300 511
        } else {
301 0
                point->point.format = '?';
302 0
        }
303
304 62879
        vt = vjsn_child(vv, "level");
305 62879
        AN(vt);
306 62879
        assert(vjsn_is_string(vt));
307
308 62879
        if (!vstrcmp(vt->value, "info"))  {
309 30680
                point->point.level = &levels[info];
310 32199
        } else if (!vstrcmp(vt->value, "diag")) {
311 19495
                point->point.level = &levels[diag];
312 19495
        } else if (!vstrcmp(vt->value, "debug")) {
313 12704
                point->point.level = &levels[debug];
314 12704
        } else {
315 0
                WRONG("Illegal level");
316 0
        }
317
318 62879
        vt = vjsn_child(vv, "index");
319 62879
        AN(vt);
320
321 62879
        point->point.ptr = (volatile const void*)(seg->body + atoi(vt->value));
322 62879
        point->point.raw = vsc->raw;
323 62879
}
324
325
static struct vsc_seg *
326
vsc_new_seg(const struct vsm_fantom *fp, enum vsc_seg_type type)
327 13170
{
328 13170
        struct vsc_seg *sp;
329
330 13170
        ALLOC_OBJ(sp, VSC_SEG_MAGIC);
331 13170
        AN(sp);
332 13170
        *sp->fantom = *fp;
333 13170
        sp->type = type;
334
335 13170
        return (sp);
336 13170
}
337
338
static void
339
vsc_unmap_seg(const struct vsc *vsc, struct vsm *vsm, struct vsc_seg *sp)
340 12319
{
341 12319
        unsigned u;
342 12319
        struct vsc_pt *pp;
343
344 12319
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
345 12319
        AN(vsm);
346 12319
        CHECK_OBJ_NOTNULL(sp, VSC_SEG_MAGIC);
347
348 12319
        AZ(sp->exposed);
349 12319
        if (!sp->mapped)
350 9088
                return;
351
352 3231
        if (sp->type == VSC_SEG_COUNTERS) {
353 2398
                pp = sp->points;
354 59414
                for (u = 0; u < sp->npoints; u++, pp++)
355 57016
                        vsc_clean_point(pp);
356 2398
                free(sp->points);
357 2398
                sp->points = NULL;
358 2398
                sp->npoints = 0;
359 2398
                AZ(sp->vj);
360 2398
        } else if (sp->type == VSC_SEG_DOCS) {
361 833
                if (sp->vj != NULL)
362 833
                        vjsn_delete(&sp->vj);
363 833
                AZ(sp->vj);
364 833
                AZ(sp->points);
365 833
        } else {
366 0
                WRONG("Invalid segment type");
367 0
        }
368
369 3231
        AZ(VSM_Unmap(vsm, sp->fantom));
370 3231
        sp->head = NULL;
371 3231
        sp->body = NULL;
372 3231
        sp->mapped = 0;
373 3231
}
374
375
static int
376
vsc_map_seg(const struct vsc *vsc, struct vsm *vsm, struct vsc_seg *sp)
377 27102
{
378 27102
        const struct vsc_head *head;
379 27102
        struct vsc_seg *spd;
380 27102
        const char *e;
381 27102
        struct vjsn_val *vv, *vve;
382 27102
        struct vsb *vsb;
383 27102
        struct vsc_pt *pp;
384 27102
        int retry;
385
386 27102
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
387 27102
        AN(vsm);
388 27102
        CHECK_OBJ_NOTNULL(sp, VSC_SEG_MAGIC);
389
390 27102
        if (sp->mapped)
391 23020
                return (0);
392
393 4082
        AZ(sp->exposed);
394
395 4082
        if (VSM_Map(vsm, sp->fantom))
396 0
                return (-1);
397 4082
        head = sp->fantom->b;
398
399
        /* It isn't ready yet. Sleep and try again. If it still
400
         * isn't ready, fail the mapping. The transitions inside
401
         * vinyld that we are waiting for are just some memcpy()
402
         * operations, so there is no reason to allow a long retry
403
         * time. */
404 4082
        for (retry = 10; retry > 0 && head->ready == 0; retry--)
405 0
                VTIM_sleep(0.01);
406
407 4082
        if (head->ready == 0) {
408 0
                AZ(VSM_Unmap(vsm, sp->fantom));
409 0
                return (-1);
410 0
        }
411
412 4082
        sp->head = head;
413 4082
        sp->body = (char*)sp->fantom->b + sp->head->body_offset;
414 4082
        sp->mapped = 1;
415
416 4082
        if (sp->type == VSC_SEG_DOCS) {
417
                /* Parse the DOCS json */
418 977
                sp->vj = vjsn_parse(sp->body, &e);
419 977
                XXXAZ(e);
420 977
                AN(sp->vj);
421 977
                return (0);
422 977
        }
423
424 3105
        assert(sp->type == VSC_SEG_COUNTERS);
425
426
        /* Find the corresponding DOCS seg. We are not able to
427
         * read and match on the doc_id until the DOCS section is
428
         * mapped. Iterate over all the DOCS sections, attempt to
429
         * map if needed, and then check the doc_id. */
430 10892
        VTAILQ_FOREACH(spd, &vsc->docs, doc_list) {
431 10892
                CHECK_OBJ_NOTNULL(spd, VSC_SEG_MAGIC);
432 10892
                assert(spd->type == VSC_SEG_DOCS);
433 10892
                if (!spd->mapped && vsc_map_seg(vsc, vsm, spd))
434 0
                        continue; /* Failed to map it */
435 10892
                AN(spd->mapped);
436 10892
                if (spd->head->doc_id == sp->head->doc_id)
437 3105
                        break; /* We have a match */
438 10892
        }
439 3105
        if (spd == NULL) {
440
                /* Could not find the right DOCS seg. Leave this
441
                 * seg as unmapped. */
442 0
                vsc_unmap_seg(vsc, vsm, sp);
443 0
                return (-1);
444 0
        }
445
446
        /* Create the VSC points list */
447 3105
        vve = vjsn_child(spd->vj->value, "elements");
448 3105
        AN(vve);
449 3105
        sp->npoints = strtoul(vve->value, NULL, 0);
450 3105
        sp->points = calloc(sp->npoints, sizeof *sp->points);
451 3105
        AN(sp->points);
452 3105
        vsb = VSB_new_auto();
453 3105
        AN(vsb);
454 3105
        vve = vjsn_child(spd->vj->value, "elem");
455 3105
        AN(vve);
456 3105
        pp = sp->points;
457 67252
        VTAILQ_FOREACH(vv, &vve->children, list) {
458 67252
                vsc_fill_point(vsc, sp, vv, vsb, pp);
459 67252
                pp++;
460 67252
        }
461 3105
        VSB_destroy(&vsb);
462 3105
        return (0);
463 3105
}
464
465
/*--------------------------------------------------------------------
466
 */
467
468
static void
469
vsc_expose(const struct vsc *vsc, struct vsc_seg *sp, int del)
470 38444
{
471 38444
        struct vsc_pt *pp;
472 38444
        unsigned u;
473 38444
        int expose;
474
475 38444
        if (!sp->mapped) {
476 9088
                AZ(sp->exposed);
477 9088
                return;
478 9088
        }
479
480 29356
        if (vsc->fnew != NULL && !sp->exposed &&
481 29356
            !del && sp->head->ready == 1)
482 264
                expose = 1;
483 29092
        else if (vsc->fdestroy != NULL && sp->exposed &&
484 29092
            (del || sp->head->ready == 2))
485 264
                expose = 0;
486 28828
        else
487 28828
                return;
488
489 528
        pp = sp->points;
490 6222
        for (u = 0; u < sp->npoints; u++, pp++) {
491 5694
                if (pp->name == NULL)
492 752
                        continue;
493 4942
                if (expose)
494 2471
                        pp->point.priv = vsc->fnew(vsc->priv, &pp->point);
495 2471
                else
496 2471
                        vsc->fdestroy(vsc->priv, &pp->point);
497 4942
        }
498 528
        sp->exposed = expose;
499 528
}
500
501
/*--------------------------------------------------------------------
502
 */
503
504
static void
505
vsc_del_segs(struct vsc *vsc, struct vsm *vsm, struct vsc_seg_head *head)
506 2525
{
507 2525
        struct vsc_seg *sp, *sp2;
508
509 12319
        VTAILQ_FOREACH_SAFE(sp, head, list, sp2) {
510 12319
                CHECK_OBJ(sp, VSC_SEG_MAGIC);
511 12319
                VTAILQ_REMOVE(head, sp, list);
512 12319
                if (sp->type == VSC_SEG_DOCS)
513 2311
                        VTAILQ_REMOVE(&vsc->docs, sp, doc_list);
514 12319
                vsc_expose(vsc, sp, 1);
515 12319
                vsc_unmap_seg(vsc, vsm, sp);
516 12319
                FREE_OBJ(sp);
517 12319
        }
518 2525
}
519
520
/*--------------------------------------------------------------------
521
 */
522
523
static int
524
vsc_iter_seg(const struct vsc *vsc, const struct vsc_seg *sp,
525
    VSC_iter_f *fiter, void *priv)
526 23266
{
527 23266
        unsigned u;
528 23266
        int i = 0;
529 23266
        struct vsc_pt *pp;
530
531 23266
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
532 23266
        CHECK_OBJ_NOTNULL(sp, VSC_SEG_MAGIC);
533 23266
        AN(fiter);
534 23266
        pp = sp->points;
535 339703
        for (u = 0; u < sp->npoints && i == 0; u++, pp++) {
536 316437
                if (pp->name != NULL)
537 314130
                        i = fiter(priv, &pp->point);
538 316437
        }
539 23266
        return (i);
540 23266
}
541
542
int
543
VSC_Iter(struct vsc *vsc, struct vsm *vsm, VSC_iter_f *fiter, void *priv)
544 1483
{
545 1483
        enum vsc_seg_type type;
546 1483
        struct vsm_fantom ifantom;
547 1483
        struct vsc_seg *sp, *sp2;
548 1483
        struct vsc_seg_head removed;
549 1483
        int i = 0;
550
551 1483
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
552 1483
        AN(vsm);
553
554
        /* First walk the VSM segment list and consolidate with the shadow
555
         * VSC seg list. We avoid calling any of the callback functions
556
         * while iterating the VSMs. This removes any headaches wrt to
557
         * callbacks calling VSM_Status(). */
558 1483
        VTAILQ_INIT(&removed);
559 1483
        sp = VTAILQ_FIRST(&vsc->segs);
560 78943
        VSM_FOREACH(&ifantom, vsm) {
561 78943
                AN(ifantom.category);
562 78943
                if (!vstrcmp(ifantom.category, VSC_CLASS))
563 56815
                        type = VSC_SEG_COUNTERS;
564 22128
                else if (!vstrcmp(ifantom.category, VSC_DOC_CLASS))
565 13270
                        type = VSC_SEG_DOCS;
566 8858
                else {
567
                        /* Not one of the categories we care about */
568 8858
                        continue;
569 8858
                }
570
571 70847
                while (sp != NULL) {
572 57677
                        CHECK_OBJ_NOTNULL(sp, VSC_SEG_MAGIC);
573 57677
                        if (VSM_StillValid(vsm, sp->fantom) == VSM_valid &&
574 57677
                            !vstrcmp(ifantom.ident, sp->fantom->ident)) {
575
                                /* sp matches the expected value */
576 56915
                                break;
577 56915
                        }
578
579
                        /* sp is no longer in the VSM list. Remove it from
580
                         * our list. */
581 762
                        sp2 = sp;
582 762
                        sp = VTAILQ_NEXT(sp, list);
583 762
                        VTAILQ_REMOVE(&vsc->segs, sp2, list);
584 762
                        VTAILQ_INSERT_TAIL(&removed, sp2, list);
585 762
                }
586
587 70085
                if (sp == NULL) {
588
                        /* New entries are always appended last in the VSM
589
                         * list. Since we have iterated past all the
590
                         * entries in our shadow list, the VSM entry is a
591
                         * new entry we have not seen before. */
592 13170
                        sp = vsc_new_seg(&ifantom, type);
593 13170
                        AN(sp);
594 13170
                        VTAILQ_INSERT_TAIL(&vsc->segs, sp, list);
595 13170
                        if (type == VSC_SEG_DOCS)
596 2455
                                VTAILQ_INSERT_TAIL(&vsc->docs, sp, doc_list);
597 13170
                }
598
599 70085
                assert(sp->type == type);
600 70085
                sp = VTAILQ_NEXT(sp, list);
601 70085
        }
602 1483
        while (sp != NULL) {
603
                /* Clean up the tail end of the shadow list. */
604 0
                CHECK_OBJ_NOTNULL(sp, VSC_SEG_MAGIC);
605 0
                sp2 = sp;
606 0
                sp = VTAILQ_NEXT(sp, list);
607
608 0
                VTAILQ_REMOVE(&vsc->segs, sp2, list);
609 0
                VTAILQ_INSERT_TAIL(&removed, sp2, list);
610 0
        }
611
612 1483
        vsc_del_segs(vsc, vsm, &removed);
613
614
        /* Iterate our shadow list, reporting on each pointer value */
615 33100
        VTAILQ_FOREACH(sp, &vsc->segs, list) {
616 33100
                CHECK_OBJ_NOTNULL(sp, VSC_SEG_MAGIC);
617
618 33100
                if (sp->type != VSC_SEG_COUNTERS)
619 6975
                        continue;
620
621
                /* Attempt to map the VSM. This is a noop if it was
622
                 * already mapped. If we fail we skip this seg on this
623
                 * call to VSC_Iter(), but will attempt again the next
624
                 * time VSC_Iter() is called. */
625 26125
                if (vsc_map_seg(vsc, vsm, sp))
626 0
                        continue;
627
628
                /* Expose the counters if necessary */
629 26125
                vsc_expose(vsc, sp, 0);
630
631 26125
                if (fiter != NULL && sp->head->ready == 1)
632 23266
                        i = vsc_iter_seg(vsc, sp, fiter, priv);
633 26125
                if (i)
634 1139
                        break;
635 26125
        }
636
637 1483
        return (i);
638 1483
}
639
640
/*--------------------------------------------------------------------
641
 */
642
643
void
644
VSC_State(struct vsc *vsc, VSC_new_f *fn, VSC_destroy_f *fd, void *priv)
645 7
{
646 7
        struct vsc_seg *sp;
647
648 7
        CHECK_OBJ_NOTNULL(vsc, VSC_MAGIC);
649 7
        assert((fn == NULL && fd == NULL) || (fn != NULL && fd != NULL));
650 7
        if (fd == NULL) {
651 0
                VTAILQ_FOREACH(sp, &vsc->segs, list)
652 0
                        vsc_expose(vsc, sp, 1);
653 0
        }
654 7
        vsc->fnew = fn;
655 7
        vsc->fdestroy = fd;
656 7
        vsc->priv = priv;
657 7
}
658
659
/*--------------------------------------------------------------------
660
 */
661
662
const struct VSC_level_desc *
663
VSC_ChangeLevel(const struct VSC_level_desc *old, int chg)
664 12
{
665 12
        int i;
666
667 12
        if (old == NULL)
668 7
                old = &levels[0];
669 13
        for (i = 0; i < nlevels; i++)
670 13
                if (old == &levels[i])
671 12
                        break;
672 12
        if (i == nlevels)
673 0
                i = 0;
674
675 12
        i += chg;
676 12
        if (i >= nlevels)
677 0
                i = nlevels - 1;
678 12
        if (i < 0)
679 0
                i = 0;
680 12
        return (&levels[i]);
681 12
}
682
683
/*--------------------------------------------------------------------*/
684
685
void
686
VSC_Destroy(struct vsc **vscp, struct vsm *vsm)
687 1042
{
688 1042
        struct vsc *vsc;
689 1042
        struct vsc_sf *sf, *sf2;
690
691 1042
        TAKE_OBJ_NOTNULL(vsc, vscp, VSC_MAGIC);
692
693 1042
        VTAILQ_FOREACH_SAFE(sf, &vsc->sf_list, list, sf2) {
694 20
                CHECK_OBJ_NOTNULL(sf, VSC_SF_MAGIC);
695 20
                VTAILQ_REMOVE(&vsc->sf_list, sf, list);
696 20
                free(sf->pattern);
697 20
                FREE_OBJ(sf);
698 20
        }
699
700 1042
        vsc_del_segs(vsc, vsm, &vsc->segs);
701 1042
        assert(VTAILQ_EMPTY(&vsc->docs));
702 1042
        FREE_OBJ(vsc);
703 1042
}