varnish-cache/lib/libvarnishapi/vsm.c
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/mman.h>
35
#include <sys/stat.h>
36
37
#include <fcntl.h>
38
#include <float.h>
39
#include <math.h>
40
#include <stdarg.h>
41
#include <stdint.h>
42
#include <stdio.h>
43
#include <stdlib.h>
44
#include <string.h>
45
#include <unistd.h>
46
47
#include "vdef.h"
48
#include "vas.h"
49
#include "miniobj.h"
50
51
#include "vav.h"
52
#include "vin.h"
53
#include "vlu.h"
54
#include "vsb.h"
55
#include "vsm_priv.h"
56
#include "vqueue.h"
57
#include "vtim.h"
58
59
#include "vapi/vsig.h"
60
#include "vapi/vsm.h"
61
62
#ifndef MAP_HASSEMAPHORE
63
#  define MAP_HASSEMAPHORE 0 /* XXX Linux */
64
#endif
65
66
#ifndef MAP_NOSYNC
67
#  define MAP_NOSYNC 0 /* XXX Linux */
68
#endif
69
70
const struct vsm_valid VSM_invalid[1] = {{"invalid"}};
71
const struct vsm_valid VSM_valid[1] = {{"valid"}};
72
73
static vlu_f vsm_vlu_func;
74
75
#define VSM_PRIV_SHIFT                                                  \
76
        (sizeof (uint64_t) * 4)
77
#define VSM_PRIV_MASK                                                   \
78
        ((1ULL << VSM_PRIV_SHIFT) - 1)
79
#define VSM_PRIV_LOW(u)                                                 \
80
        ((uint64_t)(u) & VSM_PRIV_MASK)
81
#define VSM_PRIV_HIGH(u)                                                \
82
        (((uint64_t)(u) >> VSM_PRIV_SHIFT) & VSM_PRIV_MASK)
83
#define VSM_PRIV_MERGE(low, high)                                       \
84
        (VSM_PRIV_LOW(low) | (VSM_PRIV_LOW(high) << VSM_PRIV_SHIFT))
85
86
/*--------------------------------------------------------------------*/
87
88
struct vsm_set;
89
90
struct vsm_seg {
91
        unsigned                magic;
92
#define VSM_SEG_MAGIC           0xeb6c6dfd
93
        unsigned                flags;
94
#define VSM_FLAG_MARKSCAN       (1U<<1)
95
#define VSM_FLAG_STALE          (1U<<2)
96
#define VSM_FLAG_CLUSTER        (1U<<3)
97
        VTAILQ_ENTRY(vsm_seg)   list;
98
        VTAILQ_ENTRY(vsm_seg)   clist;
99
        struct vsm_set          *set;
100
        struct vsm_seg          *cluster;
101
        char                    **av;
102
        int                     refs;
103
        void                    *s;
104
        size_t                  sz;
105
        void                    *b;
106
        void                    *e;
107
        uint64_t                serial;
108
};
109
110
struct vsm_set {
111
        unsigned                magic;
112
#define VSM_SET_MAGIC           0xdee401b8
113
        const char              *dname;
114
        struct vsm              *vsm;
115
        VTAILQ_HEAD(,vsm_seg)   segs;
116
        VTAILQ_HEAD(,vsm_seg)   stale;
117
        VTAILQ_HEAD(,vsm_seg)   clusters;
118
119
        int                     dfd;
120
        struct stat             dst;
121
122
        int                     fd;
123
        struct stat             fst;
124
125
        uintmax_t               id1, id2;
126
127
        // _.index reading state
128
        struct vlu              *vlu;
129
        unsigned                retval;
130
        struct vsm_seg          *vg;
131
132
        unsigned                flag_running;
133
        unsigned                flag_changed;
134
        unsigned                flag_restarted;
135
136
        int                     couldkill;
137
};
138
139
struct vsm {
140
        unsigned                magic;
141
#define VSM_MAGIC               0x6e3bd69b
142
143
        struct vsb              *diag;
144
        uint64_t                serial;
145
146
        int                     wdfd;
147
        struct stat             wdst;
148
        char                    *wdname;
149
150
        struct vsm_set          *mgt;
151
        struct vsm_set          *child;
152
153
        int                     attached;
154
        double                  patience;
155
};
156
157
/*--------------------------------------------------------------------*/
158
159
static int
160 1831
vsm_diag(struct vsm *vd, const char *fmt, ...)
161
{
162
        va_list ap;
163
164 1831
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
165 1831
        AN(fmt);
166
167 1831
        if (vd->diag == NULL)
168 1831
                vd->diag = VSB_new_auto();
169 1831
        AN(vd->diag);
170 1831
        VSB_clear(vd->diag);
171 1831
        va_start(ap, fmt);
172 1831
        VSB_vprintf(vd->diag, fmt, ap);
173 1831
        va_end(ap);
174 1831
        AZ(VSB_finish(vd->diag));
175 1831
        return (-1);
176
}
177
178
/*--------------------------------------------------------------------*/
179
180
static int
181 264547
vsm_mapseg(struct vsm *vd, struct vsm_seg *vg)
182
{
183
        size_t of, off, sz, ps, len;
184
        struct vsb *vsb;
185
        void *s;
186
        int fd;
187
188 264547
        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
189
190 264547
        if (vg->s != NULL)
191 4040
                return (0);
192
193 260507
        ps = getpagesize();
194
195 260507
        of = strtoul(vg->av[2], NULL, 10);
196 260507
        off = RDN2(of, ps);
197
198 260507
        if (vg->flags & VSM_FLAG_CLUSTER)
199 1723
                assert(of == 0);
200 260507
        assert(vg->cluster == NULL);
201
202 260507
        sz = strtoul(vg->av[3], NULL, 10);
203 260507
        assert(sz > 0);
204 260507
        assert(of >= off);
205 260507
        len = RUP2((of - off) + sz, ps);
206
207 260507
        vsb = VSB_new_auto();
208 260507
        AN(vsb);
209 260507
        VSB_printf(vsb, "%s/%s/%s", vd->wdname, vg->set->dname, vg->av[1]);
210 260507
        AZ(VSB_finish(vsb));
211
212 260507
        fd = open(VSB_data(vsb), O_RDONLY);     // XXX: openat
213 260507
        if (fd < 0) {
214 18
                VSB_destroy(&vsb);
215 18
                return (vsm_diag(vd, "Could not open segment"));
216
        }
217
218 520978
        s = (void*)mmap(NULL, len,
219
            PROT_READ,
220
            MAP_HASSEMAPHORE | MAP_NOSYNC | MAP_SHARED,
221 260489
            fd, (off_t)off);
222
223 260489
        VSB_destroy(&vsb);
224
225 260489
        closefd(&fd);
226 260489
        if (s == MAP_FAILED)
227 0
                return (vsm_diag(vd, "Could not mmap segment"));
228
229 260489
        vg->s = s;
230 260489
        vg->b = (char*)(vg->s) + of - off;
231 260489
        vg->e = (char *)vg->b + sz;
232 260489
        vg->sz = len;
233
234 260489
        return (0);
235 264547
}
236
237
static void
238 232329
vsm_unmapseg(struct vsm_seg *vg)
239
{
240
241 232329
        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
242
243 232329
        AN(vg->b);
244 232329
        AN(vg->e);
245 232329
        AZ(munmap(vg->s, vg->sz));
246 232329
        vg->s = vg->b = vg->e = NULL;
247 232329
        vg->sz = 0;
248 232329
}
249
250
/*--------------------------------------------------------------------*/
251
252
static void
253 3251602
vsm_delseg(struct vsm_seg *vg, int refsok)
254
{
255
256 3251602
        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
257
258 3251602
        if (vg->set->vg == vg) {
259 195180
                AZ(vg->flags & VSM_FLAG_STALE);
260 195180
                vg->set->vg = VTAILQ_NEXT(vg, list);
261 195180
        }
262
263 3251602
        if (refsok && vg->refs) {
264 5618
                AZ(vg->flags & VSM_FLAG_STALE);
265 5618
                vg->flags |= VSM_FLAG_STALE;
266 5618
                VTAILQ_REMOVE(&vg->set->segs, vg, list);
267 5618
                VTAILQ_INSERT_TAIL(&vg->set->stale, vg, list);
268 5618
                return;
269
        }
270
271 3245984
        if (vg->s != NULL)
272 0
                vsm_unmapseg(vg);
273
274 3245984
        if (vg->flags & VSM_FLAG_CLUSTER) {
275 77040
                vg->flags &= ~VSM_FLAG_CLUSTER;
276 77040
                VTAILQ_REMOVE(&vg->set->clusters, vg, clist);
277 77040
        }
278
279 3245984
        if (vg->flags & VSM_FLAG_STALE)
280 5618
                VTAILQ_REMOVE(&vg->set->stale, vg, list);
281
        else
282 3240366
                VTAILQ_REMOVE(&vg->set->segs, vg, list);
283 3245984
        VAV_Free(vg->av);
284 3245984
        FREE_OBJ(vg);
285 3251602
}
286
287
/*--------------------------------------------------------------------*/
288
289
static struct vsm_set *
290 181200
vsm_newset(const char *dirname)
291
{
292
        struct vsm_set *vs;
293
294 181200
        ALLOC_OBJ(vs, VSM_SET_MAGIC);
295 181200
        AN(vs);
296 181200
        VTAILQ_INIT(&vs->segs);
297 181200
        VTAILQ_INIT(&vs->stale);
298 181200
        VTAILQ_INIT(&vs->clusters);
299 181200
        vs->dname = dirname;
300 181200
        vs->dfd = vs->fd = -1;
301 181200
        vs->vlu = VLU_New(vsm_vlu_func, vs, 0);
302 181200
        AN(vs->vlu);
303 181200
        if (getenv("VSM_NOPID") != NULL)
304 0
                vs->couldkill = -1;
305 181200
        return (vs);
306
}
307
308
static void
309 178960
vsm_delset(struct vsm_set **p)
310
{
311
        struct vsm_set *vs;
312
        struct vsm_seg *vg;
313
314 178960
        TAKE_OBJ_NOTNULL(vs, p, VSM_SET_MAGIC);
315
316 178960
        if (vs->fd >= 0)
317 109805
                closefd(&vs->fd);
318 178960
        if (vs->dfd >= 0)
319 147320
                closefd(&vs->dfd);
320 178960
        while ((vg = VTAILQ_FIRST(&vs->stale)) != NULL) {
321 0
                AN(vg->flags & VSM_FLAG_STALE);
322 0
                vsm_delseg(vg, 0);
323
        }
324 3237902
        while ((vg = VTAILQ_FIRST(&vs->segs)) != NULL) {
325 3058942
                AZ(vg->flags & VSM_FLAG_STALE);
326 3058942
                vsm_delseg(vg, 0);
327
        }
328 178960
        assert(VTAILQ_EMPTY(&vs->clusters));
329 178960
        VLU_Destroy(&vs->vlu);
330 178960
        FREE_OBJ(vs);
331 178960
}
332
333
static void
334 402549
vsm_wash_set(const struct vsm_set *vs, int all)
335
{
336
        struct vsm_seg *vg, *vg2;
337
338 3587881
        VTAILQ_FOREACH_SAFE(vg, &vs->segs, list, vg2) {
339 3185332
                if (all || (vg->flags & VSM_FLAG_MARKSCAN) == 0)
340 108597
                        vsm_delseg(vg, 1);
341 3185332
        }
342 402549
}
343
344
/*--------------------------------------------------------------------*/
345
346
struct vsm *
347 90600
VSM_New(void)
348
{
349
        struct vsm *vd;
350
351 90600
        ALLOC_OBJ(vd, VSM_MAGIC);
352 90600
        AN(vd);
353
354 90600
        vd->mgt = vsm_newset(VSM_MGT_DIRNAME);
355 90600
        vd->mgt->flag_running = VSM_MGT_RUNNING;
356 90600
        vd->mgt->flag_changed = VSM_MGT_CHANGED;
357 90600
        vd->mgt->flag_restarted = VSM_MGT_RESTARTED;
358
359 90600
        vd->child = vsm_newset(VSM_CHILD_DIRNAME);
360 90600
        vd->child->flag_running = VSM_WRK_RUNNING;
361 90600
        vd->child->flag_changed = VSM_WRK_CHANGED;
362 90600
        vd->child->flag_restarted = VSM_WRK_RESTARTED;
363
364 90600
        vd->mgt->vsm = vd;
365 90600
        vd->child->vsm = vd;
366 90600
        vd->wdfd = -1;
367 90600
        vd->patience = 5;
368 90600
        return (vd);
369
}
370
371
/*--------------------------------------------------------------------*/
372
373
int
374 92360
VSM_Arg(struct vsm *vd, char flag, const char *arg)
375
{
376 92360
        char *p = NULL;
377
378 92360
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
379
380 92360
        if (arg == NULL)
381 1640
                return (1);
382 90720
        switch (flag) {
383
        case 't':
384 520
                if (!strcasecmp(arg, "off")) {
385 0
                        vd->patience = -1;
386 0
                } else {
387 520
                        vd->patience = strtod(arg, &p);
388 840
                        if ((p != NULL && *p != '\0') ||
389 320
                            !isfinite(vd->patience) || vd->patience < 0)
390 560
                                return (vsm_diag(vd,
391 280
                                    "-t: Invalid argument: %s", arg));
392
                }
393 240
                break;
394
        case 'n':
395 90200
                if (vd->wdname != NULL)
396 0
                        free(vd->wdname);
397 90200
                vd->wdname = VIN_n_Arg(arg);
398 90200
                if (vd->wdname == NULL)
399 0
                        return (vsm_diag(vd, "Invalid instance name: %s",
400 0
                            strerror(errno)));
401 90200
                break;
402
        default:
403 0
                return (vsm_diag(vd, "Unknown VSM_Arg('%c')", flag));
404
        }
405 90440
        return (1);
406 92360
}
407
408
/*--------------------------------------------------------------------*/
409
410
void
411 89480
VSM_Destroy(struct vsm **vdp)
412
{
413
        struct vsm *vd;
414
415 89480
        TAKE_OBJ_NOTNULL(vd, vdp, VSM_MAGIC);
416
417 89480
        VSM_ResetError(vd);
418 89480
        REPLACE(vd->wdname, NULL);
419 89480
        if (vd->diag != NULL)
420 0
                VSB_destroy(&vd->diag);
421 89480
        if (vd->wdfd >= 0)
422 89400
                closefd(&vd->wdfd);
423 89480
        vsm_delset(&vd->mgt);
424 89480
        vsm_delset(&vd->child);
425 89480
        FREE_OBJ(vd);
426 89480
}
427
428
/*--------------------------------------------------------------------*/
429
430
const char *
431 458
VSM_Error(const struct vsm *vd)
432
{
433
434 458
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
435
436 458
        if (vd->diag == NULL)
437 0
                return ("No VSM error");
438
        else
439 458
                return (VSB_data(vd->diag));
440 458
}
441
442
/*--------------------------------------------------------------------*/
443
444
void
445 180973
VSM_ResetError(struct vsm *vd)
446
{
447
448 180973
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
449
450 180973
        if (vd->diag == NULL)
451 179502
                return;
452 1471
        VSB_destroy(&vd->diag);
453 180973
}
454
455
/*--------------------------------------------------------------------
456
 */
457
458
static int
459 696697
vsm_cmp_av(char * const *a1, char * const *a2)
460
{
461
462 1023726
        while (1) {
463 1023726
                if (*a1 == NULL && *a2 == NULL)
464 80507
                        return (0);
465 943219
                if (*a1 == NULL || *a2 == NULL)
466 0
                        return (1);
467 943219
                if (strcmp(*a1, *a2))
468 616190
                        return (1);
469 327029
                a1++;
470 327029
                a2++;
471
        }
472 696697
}
473
474
static struct vsm_seg *
475 83193
vsm_findcluster(const struct vsm_set *vs, const char *cnam)
476
{
477
        struct vsm_seg *vg;
478 83193
        AN(vs);
479 83193
        AN(cnam);
480 117682
        VTAILQ_FOREACH(vg, &vs->clusters, clist) {
481 117682
                AN(vg->av[1]);
482 117682
                if (!strcmp(cnam, vg->av[1]))
483 83193
                        return (vg);
484 34489
        }
485 0
        return (NULL);
486 83193
}
487
488
static unsigned
489 2473227
vsm_running(struct vsm_set *vs, pid_t pid)
490
{
491
492 2473227
        AN(vs);
493
494 2473227
        if (pid == 0)
495 0
                return (0);
496
497 2473227
        if (kill(pid, 0) == 0) {
498 2382576
                vs->couldkill = 1;
499 2382576
                return (1);
500
        }
501 90651
        if (errno == EPERM)     /* a process exists, assume running */
502 0
                return (1);
503 90651
        assert(errno != EINVAL);
504 90651
        return (0);
505 2473227
}
506
507
static int
508 151077
vsm_vlu_hash(struct vsm_set *vs, const char *line)
509
{
510
        int i;
511
        uintmax_t id1, id2;
512
513 151077
        i = sscanf(line, "# %ju %ju", &id1, &id2);
514 151077
        if (i != 2) {
515 0
                vs->retval |= vs->flag_restarted;
516 0
                return (0);
517
        }
518 151077
        if (vs->couldkill >= 0 && vsm_running(vs, id1)) {
519
                /* nothing to do */
520 151077
        } else if (vs->couldkill > 0 && errno == ESRCH) {
521 0
                vs->retval |= vs->flag_restarted | VSM_MGT_CHANGED;
522 0
                return (0);
523
        }
524 151077
        vs->retval |= VSM_MGT_RUNNING;
525 151077
        if (id1 != vs->id1 || id2 != vs->id2) {
526 151000
                vs->retval |= vs->flag_restarted;
527 151000
                vs->id1 = id1;
528 151000
                vs->id2 = id2;
529 151000
        }
530 151077
        return (0);
531 151077
}
532
533
static int
534 3284646
vsm_vlu_plus(struct vsm *vd, struct vsm_set *vs, const char *line)
535
{
536
        char **av;
537
        int ac;
538
        struct vsm_seg *vg;
539
540 3284646
        av = VAV_Parse(line + 1, &ac, 0);
541
542 3284646
        if (av[0] != NULL || ac < 4 || ac > 6) {
543 0
                (void)(vsm_diag(vd, "vsm_vlu_plus: bad index (%d/%s)",
544 0
                    ac, av[0]));
545 0
                VAV_Free(av);
546 0
                return (-1);
547
        }
548
549 3284646
        vg = vs->vg;
550 3284646
        CHECK_OBJ_ORNULL(vg, VSM_SEG_MAGIC);
551 3284646
        if (vg != NULL)
552 2062
                AZ(vg->flags & VSM_FLAG_STALE);
553 3285406
        while (vg != NULL && vsm_cmp_av(&vg->av[1], &av[1]))
554 760
                vg = VTAILQ_NEXT(vg, list);
555 3284646
        if (vg != NULL) {
556
                /* entry compared equal, so it survives */
557 2062
                CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
558 2062
                VAV_Free(av);
559 2062
                vg->flags |= VSM_FLAG_MARKSCAN;
560 2062
                vs->vg = VTAILQ_NEXT(vg, list);
561 2062
        } else {
562 3282584
                ALLOC_OBJ(vg, VSM_SEG_MAGIC);
563 3282584
                AN(vg);
564 3282584
                vg->av = av;
565 3282584
                vg->set = vs;
566 3282584
                vg->flags = VSM_FLAG_MARKSCAN;
567 3282584
                vg->serial = vd->serial;
568
569 3282584
                VTAILQ_INSERT_TAIL(&vs->segs, vg, list);
570 3282584
                if (ac == 4) {
571 77680
                        vg->flags |= VSM_FLAG_CLUSTER;
572 77680
                        VTAILQ_INSERT_TAIL(&vs->clusters, vg, clist);
573 3282584
                } else if (*vg->av[2] != '0') {
574 81080
                        vg->cluster = vsm_findcluster(vs, vg->av[1]);
575 81080
                        CHECK_OBJ_NOTNULL(vg->cluster, VSM_SEG_MAGIC);
576 81080
                }
577 3282584
                vs->retval |= vs->flag_changed;
578
        }
579 3284646
        return (0);
580 3284646
}
581
582
static int
583 78445
vsm_vlu_minus(struct vsm *vd, struct vsm_set *vs, const char *line)
584
{
585
        char **av;
586
        int ac;
587
        struct vsm_seg *vg;
588
589 78445
        av = VAV_Parse(line + 1, &ac, 0);
590
591 78445
        if (av[0] != NULL || ac < 4 || ac > 6) {
592 0
                (void)(vsm_diag(vd, "vsm_vlu_minus: bad index (%d/%s)",
593 0
                    ac, av[0]));
594 0
                VAV_Free(av);
595 0
                return (-1);
596
        }
597
598
        /* Clustered segments cannot come before their cluster */
599 78445
        if (*av[2] != '0')
600 2113
                vg = vsm_findcluster(vs, av[1]);
601
        else
602 76332
                vg = VTAILQ_FIRST(&vs->segs);
603
604 693875
        for (;vg != NULL; vg = VTAILQ_NEXT(vg, list)) {
605 693875
                if (!vsm_cmp_av(&vg->av[1], &av[1])) {
606 78445
                        vs->retval |= vs->flag_changed;
607 78445
                        vsm_delseg(vg, 1);
608 78445
                        break;
609
                }
610 615430
        }
611 78445
        AN(vg);
612 78445
        VAV_Free(av);
613 78445
        return (0);
614 78445
}
615
616
static int v_matchproto_(vlu_f)
617 3514168
vsm_vlu_func(void *priv, const char *line)
618
{
619
        struct vsm *vd;
620
        struct vsm_set *vs;
621 3514168
        int i = 0;
622
623 3514168
        CAST_OBJ_NOTNULL(vs, priv, VSM_SET_MAGIC);
624 3514168
        vd = vs->vsm;
625 3514168
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
626 3514168
        AN(line);
627
628
        /* Up the serial counter. This wraps at UINTPTR_MAX/2
629
         * because thats the highest value we can store in struct
630
         * vsm_fantom. */
631 3514168
        vd->serial = VSM_PRIV_LOW(vd->serial + 1);
632
633 3514168
        switch (line[0]) {
634
        case '#':
635 151077
                i = vsm_vlu_hash(vs, line);
636 261688
                VTAILQ_FOREACH(vs->vg, &vs->segs, list)
637 110611
                        vs->vg->flags &= ~VSM_FLAG_MARKSCAN;
638 151077
                if (!(vs->retval & vs->flag_restarted))
639 77
                        vs->vg = VTAILQ_FIRST(&vs->segs);
640 151077
                break;
641
        case '+':
642 3284646
                i = vsm_vlu_plus(vd, vs, line);
643 3284646
                break;
644
        case '-':
645 78445
                i = vsm_vlu_minus(vd, vs, line);
646 78445
                break;
647
        default:
648 0
                break;
649
        }
650 3514168
        return (i);
651
}
652
653
static void
654 2322148
vsm_readlines(struct vsm_set *vs)
655
{
656
        int i;
657
658 2322148
        do {
659 2684156
                assert(vs->fd >= 0);
660 2684156
                i = VLU_Fd(vs->vlu, vs->fd);
661 2684156
        } while (!i);
662 2322148
        assert(i == -2);
663 2322148
}
664
665
static unsigned
666 2646554
vsm_refresh_set(struct vsm *vd, struct vsm_set *vs)
667
{
668 2646554
        unsigned restarted = 0;
669
        struct stat st;
670
671 2646554
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
672 2646554
        CHECK_OBJ_NOTNULL(vs, VSM_SET_MAGIC);
673 2646554
        vs->retval = 0;
674 4890641
        if (vs->dfd >= 0 && (
675 2246462
            fstatat(vd->wdfd, vs->dname, &st, AT_SYMLINK_NOFOLLOW) ||
676 2246483
            st.st_ino != vs->dst.st_ino ||
677 2244085
            st.st_dev != vs->dst.st_dev ||
678 2244086
            st.st_mode != vs->dst.st_mode ||
679 2244087
            st.st_nlink == 0)) {
680 2444
                closefd(&vs->dfd);
681 2400
                restarted = vs->flag_restarted;
682 2400
        }
683
684 2646556
        if (vs->dfd < 0) {
685 402472
                if (vs->fd >= 0)
686 2395
                        closefd(&vs->fd);
687 402472
                vs->dfd = openat(vd->wdfd, vs->dname, O_RDONLY);
688 402472
        }
689
690 2646556
        if (vs->dfd < 0) {
691 251472
                vs->id1 = vs->id2 = 0;
692 251472
                vsm_wash_set(vs, 1);
693 251472
                return (vs->retval | restarted);
694
        }
695
696 2395084
        AZ(fstat(vs->dfd, &vs->dst));
697
698 4566172
        if (vs->fd >= 0 && (
699 2208661
            fstatat(vs->dfd, "_.index", &st, AT_SYMLINK_NOFOLLOW) ||
700 2171165
            st.st_ino != vs->fst.st_ino ||
701 2171088
            st.st_dev != vs->fst.st_dev ||
702 2171086
            st.st_mode != vs->fst.st_mode ||
703 2171087
            st.st_size < vs->fst.st_size ||
704 2171088
            st.st_nlink < 1)) {
705 37601
                closefd(&vs->fd);
706 37597
                vs->retval |= vs->flag_changed;
707 37597
        }
708
709 2395084
        if (vs->fd >= 0) {
710 2171084
                vs->vg = NULL;
711 2171084
                vsm_readlines(vs);
712 2171084
        } else {
713 694743
                VTAILQ_FOREACH(vs->vg, &vs->segs, list)
714 470743
                        vs->vg->flags &= ~VSM_FLAG_MARKSCAN;
715 224000
                vs->vg = VTAILQ_FIRST(&vs->segs);
716 224000
                vs->fd = openat(vs->dfd, "_.index", O_RDONLY);
717 224000
                if (vs->fd < 0)
718 72923
                        return (vs->retval | restarted);
719 151077
                VLU_Reset(vs->vlu);
720 151077
                AZ(fstat(vs->fd, &vs->fst));
721 151077
                vsm_readlines(vs);
722 151077
                vsm_wash_set(vs, 0);
723
        }
724
725 2322161
        vs->fst.st_size = lseek(vs->fd, 0L, SEEK_CUR);
726
727 2322161
        if (vs->couldkill < 0 || vsm_running(vs, vs->id1))
728 2231629
                vs->retval |= vs->flag_running;
729 2322169
        return (vs->retval);
730 2646564
}
731
732
/*--------------------------------------------------------------------*/
733
734
unsigned
735 1359767
VSM_Status(struct vsm *vd)
736
{
737 1359767
        unsigned retval = 0;
738
        struct stat st;
739
740 1359767
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
741
742
        /* See if the -n workdir changed */
743 1359767
        if (vd->wdfd >= 0) {
744 1268372
                AZ(fstat(vd->wdfd, &st));
745 2536737
                if (st.st_ino != vd->wdst.st_ino ||
746 1268364
                    st.st_dev != vd->wdst.st_dev ||
747 1268365
                    st.st_mode != vd->wdst.st_mode ||
748 1268365
                    st.st_nlink == 0) {
749 16
                        closefd(&vd->wdfd);
750 0
                        vsm_wash_set(vd->mgt, 1);
751 0
                        vsm_wash_set(vd->child, 1);
752 0
                }
753 1268360
        }
754
755
        /* Open workdir */
756 1359755
        if (vd->wdfd < 0) {
757 91413
                retval |= VSM_MGT_RESTARTED | VSM_MGT_CHANGED;
758 91413
                retval |= VSM_WRK_RESTARTED | VSM_WRK_CHANGED;
759 91413
                vd->wdfd = open(vd->wdname, O_RDONLY);
760 91413
                if (vd->wdfd < 0)
761 1373
                        (void)vsm_diag(vd,
762
                            "VSM_Status: Cannot open workdir");
763
                else
764 90040
                        AZ(fstat(vd->wdfd, &vd->wdst));
765 91413
        }
766
767 1359755
        if (vd->wdfd >= 0) {
768 1358401
                retval |= vsm_refresh_set(vd, vd->mgt);
769 1358401
                if (vd->mgt->couldkill > 0 && (retval & VSM_MGT_RESTARTED))
770 90040
                        vd->mgt->couldkill = 0;
771 1358401
                if (retval & VSM_MGT_RUNNING)
772 1288150
                        retval |= vsm_refresh_set(vd, vd->child);
773 1358401
                if (vd->child->couldkill > 0 && (retval & VSM_WRK_RESTARTED))
774 60844
                        vd->child->couldkill = 0;
775 1358401
        }
776 1359755
        return (retval);
777
}
778
779
/*--------------------------------------------------------------------*/
780
781
int
782 90200
VSM_Attach(struct vsm *vd, int progress)
783
{
784
        const char *def;
785
        double t0;
786
        unsigned u;
787 90200
        int i, n = 0;
788
789 90200
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
790
791 90200
        if (vd->patience < 0)
792 0
                t0 = DBL_MAX;
793
        else
794 90200
                t0 = VTIM_mono() + vd->patience;
795
796 90200
        if (vd->wdname == NULL) {
797 280
                def = getenv("VARNISH_DEFAULT_N");
798 280
                if (def == NULL)
799 0
                        def = ""; /* Use default (hostname) */
800 280
                i = VSM_Arg(vd, 'n', def);
801 280
                if (i < 0)
802 0
                        return (i);
803 280
                AN(vd->wdname);
804 280
        }
805
806 90200
        AZ(vd->attached);
807 91533
        while (!VSIG_int && !VSIG_term) {
808 91493
                u = VSM_Status(vd);
809 91493
                VSM_ResetError(vd);
810 91493
                if (u & VSM_MGT_RUNNING) {
811 90040
                        if (progress >= 0 && n > 4)
812 0
                                (void)write(progress, "\n", 1);
813 90040
                        vd->attached = 1;
814 90040
                        return (0);
815
                }
816 1453
                if (t0 < VTIM_mono()) {
817 120
                        if (progress >= 0 && n > 4)
818 40
                                (void)write(progress, "\n", 1);
819 120
                        return (vsm_diag(vd,
820
                            "Could not get hold of varnishd, is it running?"));
821
                }
822 1333
                if (progress >= 0 && !(++n % 4))
823 286
                        (void)write(progress, ".", 1);
824 1333
                VTIM_sleep(.25);
825
        }
826 40
        return (vsm_diag(vd, "Attach interrupted"));
827 90200
}
828
829
/*--------------------------------------------------------------------*/
830
831
static struct vsm_seg *
832 246668
vsm_set_findseg(const struct vsm_set *vs, uintptr_t serial)
833
{
834
        struct vsm_seg *vg;
835
836 3322055
        VTAILQ_FOREACH(vg, &vs->segs, list) {
837 3172651
                if (vg->serial == serial)
838 97264
                        return (vg);
839 3075387
        }
840 290804
        VTAILQ_FOREACH(vg, &vs->stale, list) {
841 146938
                if (vg->serial == serial)
842 5538
                        return (vg);
843 141400
        }
844 143866
        return (NULL);
845 246668
}
846
847
static struct vsm_seg *
848 8162077
vsm_findseg(const struct vsm *vd, const struct vsm_fantom *vf)
849
{
850
        struct vsm_seg *vg;
851
        uint64_t x;
852
853 8162077
        x = VSM_PRIV_HIGH(vf->priv);
854 8162077
        if (x == vd->serial) {
855 8037086
                vg = (struct vsm_seg *)vf->priv2;
856 8037086
                if (!VALID_OBJ(vg, VSM_SEG_MAGIC) ||
857 8037086
                    vg->serial != VSM_PRIV_LOW(vf->priv))
858 0
                        WRONG("Corrupt fantom");
859 8037086
                return (vg);
860
        }
861
862 124991
        x = VSM_PRIV_LOW(vf->priv);
863 124991
        vg = vsm_set_findseg(vd->mgt, x);
864 124991
        if (vg == NULL)
865 121677
                vg = vsm_set_findseg(vd->child, x);
866 124991
        if (vg == NULL)
867 22189
                return (NULL);
868
869
        /* Update the fantom with the new priv so that lookups will be
870
         * fast on the next call. Note that this casts away the const. */
871 102802
        ((struct vsm_fantom *)TRUST_ME(vf))->priv =
872 102802
            VSM_PRIV_MERGE(vg->serial, vd->serial);
873 102802
        return (vg);
874 8162077
}
875
876
/*--------------------------------------------------------------------*/
877
878
void
879 348039
VSM__iter0(const struct vsm *vd, struct vsm_fantom *vf)
880
{
881
882 348039
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
883 348039
        AN(vf);
884
885 348039
        AN(vd->attached);
886 348039
        memset(vf, 0, sizeof *vf);
887 348039
}
888
889
int
890 4780922
VSM__itern(struct vsm *vd, struct vsm_fantom *vf)
891
{
892
        struct vsm_seg *vg;
893
894 4780922
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
895 4780922
        AN(vd->attached);
896 4780922
        AN(vf);
897
898 4780922
        if (vf->priv == 0) {
899 348039
                vg = VTAILQ_FIRST(&vd->mgt->segs);
900 348039
                if (vg == NULL)
901 7
                        return (0);
902 348032
        } else {
903 4432883
                vg = vsm_findseg(vd, vf);
904 4432883
                if (vg == NULL)
905 0
                        return (vsm_diag(vd, "VSM_FOREACH: inconsistency"));
906 4499408
                while (1) {
907 4499408
                        if (vg->set == vd->mgt && VTAILQ_NEXT(vg, list) == NULL)
908 344230
                                vg = VTAILQ_FIRST(&vd->child->segs);
909
                        else
910 4155178
                                vg = VTAILQ_NEXT(vg, list);
911 4499408
                        if (vg == NULL)
912 231869
                                return (0);
913 4267539
                        if (!(vg->flags & VSM_FLAG_CLUSTER))
914 4201014
                                break;
915
                }
916
        }
917 4549046
        memset(vf, 0, sizeof *vf);
918 4549046
        vf->priv = VSM_PRIV_MERGE(vg->serial, vd->serial);
919 4549046
        vf->priv2 = (uintptr_t)vg;
920 4549046
        vf->category = vg->av[4];
921 4549046
        vf->ident = vg->av[5];
922 4549046
        AN(vf->category);
923 4549046
        return (1);
924 4780922
}
925
926
/*--------------------------------------------------------------------*/
927
928
int
929 264547
VSM_Map(struct vsm *vd, struct vsm_fantom *vf)
930
{
931
        struct vsm_seg *vg, *vgc;
932
        size_t of, sz;
933
        int r;
934
935 264547
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
936 264547
        AN(vd->attached);
937 264547
        AN(vf);
938 264547
        vg = vsm_findseg(vd, vf);
939 264547
        if (vg == NULL)
940 0
                return (vsm_diag(vd, "VSM_Map: bad fantom"));
941
942 264547
        assert(vg->serial == VSM_PRIV_LOW(vf->priv));
943 264547
        assert(vg->av[4] == vf->category);
944 264547
        assert(vg->av[5] == vf->ident);
945
946 264547
        if (vg->b != NULL) {
947 0
                assert(vg->refs > 0);
948 0
                AN(vg->e);
949 0
                vf->b = vg->b;
950 0
                vf->e = vg->e;
951 0
                vg->refs++;
952 0
                return (0);
953
        }
954
955 264547
        assert(vg->refs == 0);
956
957 264547
        vgc = vg->cluster;
958
959 264547
        if (vgc == NULL) {
960 258784
                r = vsm_mapseg(vd, vg);
961 258784
                if (r)
962 18
                        return (r);
963 258766
                vf->b = vg->b;
964 258766
                vf->e = vg->e;
965
966 258766
                vg->refs++;
967
968 258766
                return (0);
969
        }
970
971 5763
        CHECK_OBJ_NOTNULL(vgc, VSM_SEG_MAGIC);
972 5763
        assert(vgc->flags & VSM_FLAG_CLUSTER);
973 5763
        assert(vg->s == NULL);
974 5763
        assert(vg->sz == 0);
975
976 5763
        r = vsm_mapseg(vd, vgc);
977 5763
        if (r)
978 0
                return (r);
979 5763
        vgc->refs++;
980
981 5763
        of = strtoul(vg->av[2], NULL, 10);
982 5763
        sz = strtoul(vg->av[3], NULL, 10);
983 5763
        assert(sz > 0);
984
985 5763
        assert(vgc->sz >= of + sz);
986 5763
        assert(vgc->s == vgc->b);
987 5763
        vg->b = (char *)vgc->b + of;
988 5763
        vg->e = (char *)vg->b + sz;
989
990 5763
        vf->b = vg->b;
991 5763
        vf->e = vg->e;
992
993 5763
        vg->refs++;
994
995 5763
        return (0);
996 264547
}
997
998
/*--------------------------------------------------------------------*/
999
1000
int
1001 232409
VSM_Unmap(struct vsm *vd, struct vsm_fantom *vf)
1002
{
1003
        struct vsm_seg *vg;
1004
1005 232409
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
1006 232409
        AN(vd->attached);
1007 232409
        AN(vf);
1008 232409
        AN(vf->b);
1009 232409
        vg = vsm_findseg(vd, vf);
1010 232409
        if (vg == NULL)
1011 0
                return (vsm_diag(vd, "VSM_Unmap: bad fantom"));
1012 232409
        CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
1013 232409
        assert(vg->refs > 0);
1014 232409
        vg->refs--;
1015 232409
        vf->b = NULL;
1016 232409
        vf->e = NULL;
1017 232409
        if (vg->refs > 0)
1018 0
                return (0);
1019
1020 232409
        if (vg->cluster) {
1021 1163
                CHECK_OBJ_NOTNULL(vg->cluster, VSM_SEG_MAGIC);
1022 1163
                assert(vg->s == NULL);
1023 1163
                assert(vg->sz == 0);
1024 1163
                assert(vg->cluster->refs > 0);
1025 1163
                if (--vg->cluster->refs == 0) {
1026 1083
                        vsm_unmapseg(vg->cluster);
1027 1083
                        if (vg->cluster->flags & VSM_FLAG_STALE) {
1028 80
                                AN(vg->flags & VSM_FLAG_STALE);
1029 80
                                vsm_delseg(vg->cluster, 0);
1030 80
                        }
1031 1083
                }
1032 1163
                vg->b = vg->e = NULL;
1033 1163
        } else {
1034 231246
                vsm_unmapseg(vg);
1035
        }
1036 232409
        if (vg->flags & VSM_FLAG_STALE)
1037 5538
                vsm_delseg(vg, 0);
1038 232409
        return (0);
1039 232409
}
1040
1041
/*--------------------------------------------------------------------*/
1042
1043
const struct vsm_valid *
1044 3232412
VSM_StillValid(const struct vsm *vd, const struct vsm_fantom *vf)
1045
{
1046
        struct vsm_seg *vg;
1047
1048 3232412
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
1049 3232412
        AN(vf);
1050 3232412
        vg = vsm_findseg(vd, vf);
1051 3232412
        if (vg == NULL || vg->flags & VSM_FLAG_STALE)
1052 28264
                return (VSM_invalid);
1053 3204148
        return (VSM_valid);
1054 3232412
}
1055
1056
/*--------------------------------------------------------------------*/
1057
1058
int
1059 292081
VSM_Get(struct vsm *vd, struct vsm_fantom *vf,
1060
    const char *category, const char *ident)
1061
{
1062
1063 292081
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
1064 292081
        AN(vd->attached);
1065 2088038
        VSM_FOREACH(vf, vd) {
1066 1908321
                if (strcmp(vf->category, category))
1067 1795957
                        continue;
1068 112364
                if (ident != NULL && strcmp(vf->ident, ident))
1069 0
                        continue;
1070 112364
                return (1);
1071
        }
1072 179717
        memset(vf, 0, sizeof *vf);
1073 179717
        return (0);
1074 292081
}
1075
1076
/*--------------------------------------------------------------------*/
1077
1078
char *
1079 3800
VSM_Dup(struct vsm *vd, const char *category, const char *ident)
1080
{
1081
        struct vsm_fantom vf;
1082 3800
        char *p = NULL;
1083
1084 3800
        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
1085 3800
        AN(vd->attached);
1086 15280
        VSM_FOREACH(&vf, vd) {
1087 15280
                if (strcmp(vf.category, category))
1088 6560
                        continue;
1089 8720
                if (ident != NULL && strcmp(vf.ident, ident))
1090 4920
                        continue;
1091 3800
                AZ(VSM_Map(vd, &vf));
1092 3800
                AN(vf.b);
1093 3800
                AN(vf.e);
1094 3800
                p = malloc((char*)vf.e - (char*)vf.b);
1095 3800
                AN(p);
1096 3800
                memcpy(p, vf.b, (char*)vf.e - (char*)vf.b);
1097 3800
                AZ(VSM_Unmap(vd, &vf));
1098 3800
                break;
1099
        }
1100 3800
        return (p);
1101
}