Code Coverage: vinyl-cache/bin/vinyld/cache/cache_vdpio_mock.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright 2026 UPLEX - Nils Goroll Systemtoptimierung
2
 * All rights reserved.
3
 *
4
 * Author: Nils Goroll <nils.goroll@uplex.de>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 * Mocking for minimal VDPIO testing/fuzzing
30
 */
31
32
#include "config.h"
33
34
//lint -e766
35
//lint -e801 goto
36
37
#include <stdlib.h>
38
#include <stdio.h>
39
40
#include "cache_int.h"
41
#include "cache_filter.h"
42
#include "cache_objhead.h"
43
#include "cache_vgz.h"
44
45
#include "vfil.h"
46
#include "vrnd.h"
47
#include "vtim.h"
48
49
#include "storage/storage.h"
50
#include "storage/storage_vai.h"
51
52
#include "vdpio_test.h"
53
54
#ifdef VDPIO_TEST_DRIVER
55
56
enum mock_flags {
57
        MF_LATE_END =   1,      // send VSCARAB_F_END after all data
58
        MF_EMPTY_VIOV = 1U<<1,  // lease must be returned
59
        MF_OK_LIM,
60
        // can not be combined with other flags
61
        MF_ERROR =      1U<<16
62
};
63
64
65
struct VSC_main *VSC_C_main = &(struct VSC_main){};
66
//lint -esym(843, cache_param)
67
//lint -esym(844, cache_param)
68
volatile struct params *cache_param = &(struct params){};
69
void
70 145450
VSLb(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, ...) {
71 145450
        va_list ap;
72
73 145450
        (void)vsl;
74 145450
        (void)tag;
75 145450
        va_start(ap, fmt);
76 145450
        (void)vprintf(fmt, ap);
77 145450
        printf("\n");
78 145450
        va_end(ap);
79 145450
}
80
void
81 0
WRK_Log(enum VSL_tag_e tag, const char *fmt, ...) {
82 0
        (void)tag;
83 0
        (void)fmt;
84 0
}
85
int
86
PAN__DumpStruct(struct vsb *vsb, int block, int track, const void *ptr,
87 0
    const char *smagic, unsigned magic, const char *fmt, ...) {
88 0
        (void)vsb;
89 0
        (void)block;
90 0
        (void)track;
91 0
        (void)ptr;
92 0
        (void)smagic;
93 0
        (void)magic;
94 0
        (void)fmt;
95 0
        return (0);
96 0
}
97
void
98 800
http_Unset(struct http *hp, hdr_t hdr) {
99 800
        (void)hp;
100 800
        (void)hdr;
101 800
}
102
struct boc *
103 0
HSH_RefBoc(const struct objcore *oc) {
104 0
        (void)oc;
105 0
        return (NULL);
106 0
}
107
void
108
HSH_DerefBoc(struct worker *wrk, struct objcore *oc)
109 0
{
110 0
        (void)wrk;
111 0
        (void)oc;
112 0
}
113
void
114
HSH_Cancel(struct worker *wrk, struct objcore *oc, struct boc *boc)
115 0
{
116 0
        (void)wrk;
117 0
        (void)oc;
118 0
        (void)boc;
119 0
}
120
int
121
ObjIterate(struct worker *wrk, struct objcore *oc,
122
    void *priv, objiterate_f *func, int final)
123 0
{
124 0
        (void)wrk;
125 0
        (void)oc;
126 0
        (void)priv;
127 0
        (void)func;
128 0
        (void)final;
129 0
        return (1);
130 0
}
131
132
// cache_http.c
133
#define HTTPH(a, b, c) hdr_t b = HDR(a);
134
#include "tbl/http_headers.h"
135
136
const void *
137
ObjGetAttr(struct worker *wrk, struct objcore *oc, enum obj_attr attr,
138
   ssize_t *len)
139 0
{
140 0
        (void)wrk;
141 0
        (void)oc;
142 0
        (void)attr;
143 0
        (void)len;
144 0
        return (NULL);
145 0
}
146
147
struct mockbuf {
148
        unsigned                magic;
149
#define MOCKBUF_MAGIC           0x78d40433
150
        size_t                  sz;
151
        VTAILQ_ENTRY(mockbuf)   list;
152
        char                    bytes[];
153
};
154
155
struct mockstats {
156
        unsigned                again;
157
        unsigned                nobufs;
158
};
159
160
struct mockhdl {
161
        unsigned                magic;
162
#define MOCKHDL_MAGIC           0xbbf5bb65
163
164
        char                    *body;
165
        size_t                  body_len;
166
167
        size_t                  leased;
168
169
        unsigned                nleased;        // outstanding non-buffers
170
        VTAILQ_HEAD(,mockbuf)   bufhead;
171
172
        unsigned                mf;
173
174
        // injection
175
        int                     error_lease;
176
        int                     error_buffer;
177
        size_t                  inject_at;
178
179
        struct mockstats        s_lease, s_buffer;
180
181
        // notification
182
        pthread_mutex_t         mtx;
183
        pthread_cond_t          cond;
184
        unsigned                posted;
185
        unsigned                running;
186
};
187
188
static void *
189
notify_thread(void *priv)
190 3597
{
191 3597
        struct mockhdl *hdl;
192
193 3597
        CAST_OBJ_NOTNULL(hdl, priv, MOCKHDL_MAGIC);
194
195 3597
        usleep(100);
196 3597
        ObjVAInotify(NULL, priv);
197 3597
        PTOK(pthread_mutex_lock(&hdl->mtx));
198 3597
        AN(hdl->running--);
199 3597
        PTOK(pthread_mutex_unlock(&hdl->mtx));
200 3597
        return (NULL);
201 3597
}
202
203
static void
204
notify(vai_hdl vhdl)
205 3597
{
206 3597
        struct mockhdl *hdl;
207 3597
        pthread_attr_t attr;
208 3597
        pthread_t thr;
209
210 3597
        CAST_OBJ_NOTNULL(hdl, vhdl, MOCKHDL_MAGIC);
211 3597
        PTOK(pthread_mutex_lock(&hdl->mtx));
212 3597
        hdl->running++;
213 3597
        PTOK(pthread_mutex_unlock(&hdl->mtx));
214 3597
        PTOK(pthread_attr_init(&attr));
215 3597
        PTOK(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
216 3597
        AZ(pthread_create(&thr, &attr, notify_thread, vhdl));
217 3597
}
218
219
static const viov_lease_t mocklease = (viov_lease_t)&mocklease;
220
221
222
//lint -esym(818, cb_priv)
223
vai_hdl
224
ObjVAIinit(struct worker *wrk, struct objcore *oc, struct ws *ws,
225
    vai_notify_cb *cb, void *cb_priv)
226 976
{
227 976
        struct mockhdl *hdl;
228
229 976
        (void)wrk;
230 976
        (void)oc;
231 976
        (void)ws;
232 976
        AZ(cb);
233 976
        AZ(cb_priv);
234
235 976
        ALLOC_OBJ(hdl, MOCKHDL_MAGIC);
236 976
        AN(hdl);
237
238 976
        VTAILQ_INIT(&hdl->bufhead);
239 976
        PTOK(pthread_mutex_init(&hdl->mtx, NULL));
240 976
        PTOK(pthread_cond_init(&hdl->cond, NULL));
241 976
        return (hdl);
242 976
}
243
244
int
245
ObjVAIlease(struct worker *wrk, vai_hdl vhdl, struct vscarab *scarab)
246 15123
{
247 15123
        struct mockhdl *hdl;
248 15123
        struct viov *vio;
249 15123
        size_t sz;
250 15123
        int n, r;
251
252 15123
        if (scarab->capacity == scarab->used)
253 0
                return (0);
254 15123
        (void) wrk;
255 15123
        CAST_OBJ_NOTNULL(hdl, vhdl, MOCKHDL_MAGIC);
256 15123
        assert(scarab->capacity > scarab->used);
257
258 15123
        if (hdl->error_lease == -EAGAIN) {
259 1182
                notify(vhdl);
260 1182
                hdl->error_lease = 0;
261 1182
                hdl->s_lease.again++;
262 1182
                return (-EAGAIN);
263 1182
        }
264 13941
        if (hdl->error_lease == -ENOBUFS) {
265 1037
                hdl->error_lease = 0;
266 1037
                hdl->s_lease.nobufs++;
267 1037
                return (-ENOBUFS);
268 1037
        }
269 12904
        if (hdl->error_lease) {
270 0
                int error_lease = hdl->error_lease;
271 0
                hdl->error_lease = 0;
272 0
                return (error_lease);
273 0
        }
274
275 12904
        n = 1 + VRND_RandomTestable() % (scarab->capacity - scarab->used);
276 12904
        r = 0;
277 14480
        while (hdl->leased < hdl->body_len && n--) {
278 12273
                sz = hdl->body_len - hdl->leased;
279 12273
                if (sz > 1024)
280 12192
                        sz = (size_t)VRND_RandomTestable() % sz;
281
282 12273
                if (hdl->leased == hdl->inject_at) {
283 10697
                        r = -EPIPE;
284 10697
                        break;
285 10697
                }
286 1576
                assert(hdl->leased < hdl->inject_at);
287 1576
                if (hdl->leased + sz > hdl->inject_at)
288 640
                        sz = hdl->inject_at - hdl->leased;
289
290 1576
                vio = VSCARAB_GET(scarab);
291 1576
                AN(vio);
292 1576
                vio->lease = mocklease;
293 1576
                vio->iov.iov_base = hdl->body + hdl->leased;
294 1576
                vio->iov.iov_len = sz;
295
296 1576
                hdl->leased += sz;
297 1576
                hdl->nleased++;
298 1576
                r++;
299 1576
        }
300 12904
        if ((hdl->mf & MF_EMPTY_VIOV) && ((vio = VSCARAB_GET(scarab)) != NULL)) {
301 516
                vio->iov = IOV_NIL;
302 516
                vio->lease = mocklease;
303 516
                hdl->nleased++;
304 516
        }
305
306 12904
        if (hdl->mf & MF_LATE_END) {
307 687
                if (r == 0 && hdl->leased == hdl->body_len)
308 546
                        scarab->flags |= VSCARAB_F_END;
309 687
        }
310 12217
        else if (hdl->leased == hdl->body_len)
311 1022
                scarab->flags |= VSCARAB_F_END;
312
313 12904
        return (r);
314 12904
}
315
316
int
317
ObjVAIbuffer(struct worker *wrk, vai_hdl vhdl, struct vscarab *scarab)
318 14076
{
319 14076
        struct mockhdl *hdl;
320 14076
        struct viov *vio;
321 14076
        struct mockbuf *b;
322 14076
        size_t sz;
323 14076
        const unsigned long addsz = 2752;
324 14076
        int n, r;
325
326 14076
        (void)wrk;
327 14076
        CAST_OBJ_NOTNULL(hdl, vhdl, MOCKHDL_MAGIC);
328 14076
        assert(scarab->capacity >= scarab->used);
329
330 14076
        if (hdl->error_buffer == -EAGAIN) {
331 2415
                notify(vhdl);
332 2415
                hdl->error_buffer = 0;
333 2415
                hdl->s_buffer.again++;
334 2415
                return (-EAGAIN);
335 2415
        }
336 11661
        if (hdl->error_buffer == -ENOBUFS) {
337 2303
                hdl->error_buffer = 0;
338 2303
                hdl->s_buffer.nobufs++;
339 2303
                return (-ENOBUFS);
340 2303
        }
341 9358
        if (hdl->error_buffer) {
342 0
                int error_buffer = hdl->error_buffer;
343 0
                hdl->error_buffer = 0;
344 0
                return (error_buffer);
345 0
        }
346
347 9358
        n = 1 + VRND_RandomTestable() % scarab->used;
348 9358
        r = 0;
349 9358
        VSCARAB_FOREACH(vio, scarab)
350 9358
                assert(vio->iov.iov_len < UINT_MAX);
351 9358
        VSCARAB_FOREACH(vio, scarab) {
352 9358
                if (n-- == 0)
353 0
                        break;
354 9358
                sz = vio->iov.iov_len + (unsigned long)VRND_RandomTestable() % addsz;
355 9358
                if (sz > UINT_MAX)
356 0
                        sz = UINT_MAX;
357 9358
                ALLOC_OBJ_EXTRA(b, sz, MOCKBUF_MAGIC);
358 9358
                AN(b);
359 9358
                b->sz = sz;
360 9358
                VTAILQ_INSERT_TAIL(&hdl->bufhead, b, list);
361
362 9358
                vio->lease = ptr2lease(b);
363 9358
                vio->iov.iov_base = b->bytes;
364 9358
                vio->iov.iov_len = sz;
365 9358
                r++;
366 9358
        }
367
368 9358
        AN(r);
369 9358
        return (r);
370 9358
}
371
372
void
373
ObjVAIreturn(struct worker *wrk, vai_hdl vhdl, struct vscaret *scaret)
374 5036
{
375 5036
        struct mockhdl *hdl;
376 5036
        struct mockbuf *b, *safe;
377 5036
        viov_lease_t *p;
378
379 5036
        (void) wrk;
380 5036
        CAST_OBJ_NOTNULL(hdl, vhdl, MOCKHDL_MAGIC);
381 11450
        VSCARET_FOREACH(p, scaret) {
382 11450
                if (*p == VAI_LEASE_NORET)
383 0
                        continue;
384 11450
                if (*p == mocklease) {
385 2092
                        AN(hdl->nleased);
386 2092
                        hdl->nleased--;
387 2092
                        continue;
388 2092
                }
389 9362
                VTAILQ_FOREACH_SAFE(b, &hdl->bufhead, list, safe) {
390 9362
                        CHECK_OBJ(b, MOCKBUF_MAGIC);
391 9362
                        if (*p != ptr2lease(b))
392 4
                                continue;
393 9358
                        VTAILQ_REMOVE(&hdl->bufhead, b, list);
394 9358
                        break;
395 9362
                }
396 9358
                if (b == NULL)
397 0
                        WRONG("returned lease not found");
398 9358
                free(b);        // NOT FREE_OBJ, sets b = NULL
399 9358
        }
400 5036
        VSCARET_INIT(scaret, scaret->capacity);
401 5036
}
402
403
void
404
ObjVAInotify(struct worker *wrk, vai_hdl vhdl)
405 3597
{
406 3597
        struct mockhdl *hdl;
407
408 3597
        (void) wrk;
409 3597
        CAST_OBJ_NOTNULL(hdl, vhdl, MOCKHDL_MAGIC);
410 3597
        PTOK(pthread_mutex_lock(&hdl->mtx));
411 3597
        hdl->posted++;
412 3597
        PTOK(pthread_cond_broadcast(&hdl->cond));
413 3597
        PTOK(pthread_mutex_unlock(&hdl->mtx));
414 3597
}
415
416
void
417
ObjVAIfini(struct worker *wrk, vai_hdl *vhdlp)
418 976
{
419 976
        struct mockhdl *hdl;
420 976
        int err;
421
422 976
        (void) wrk;
423 976
        TAKE_OBJ_NOTNULL(hdl, vhdlp, MOCKHDL_MAGIC);
424
425 976
        AZ(hdl->nleased);
426 976
        assert(VTAILQ_EMPTY(&hdl->bufhead));
427 976
        VTAILQ_INIT(&hdl->bufhead);
428 976
        while ((err = pthread_mutex_destroy(&hdl->mtx)) != 0)
429 0
                assert(err == EBUSY);
430 976
        PTOK(pthread_cond_destroy(&hdl->cond));
431 976
}
432
433
static pthread_mutex_t rndlck = PTHREAD_MUTEX_INITIALIZER;
434
static void
435
rndlock(void)
436 44452
{
437 44452
        PTOK(pthread_mutex_lock(&rndlck));
438 44452
}
439
static void
440
rndunlock(void)
441 44452
{
442 44452
        PTOK(pthread_mutex_unlock(&rndlck));
443 44452
}
444
445
static void
446
mock_wait(vai_hdl vhdl)
447 2557
{
448 2557
        struct mockhdl *hdl;
449
450 2557
        CAST_OBJ_NOTNULL(hdl, vhdl, MOCKHDL_MAGIC);
451 2557
        PTOK(pthread_mutex_lock(&hdl->mtx));
452 3754
        while (hdl->posted == 0)
453 2557
                PTOK(pthread_cond_wait(&hdl->cond, &hdl->mtx));
454 2557
        AN(hdl->posted);
455 2557
        hdl->posted--;
456 2557
        PTOK(pthread_mutex_unlock(&hdl->mtx));
457 2557
}
458
459
// return if error
460
static int
461
vdpio_mock_cap(const struct vdp *vdp, void *priv, const char *data, size_t datasz, const char *expect, size_t expectsz, unsigned cap, unsigned mf)
462 976
{
463 976
        VRND_Lock = rndlock;
464 976
        VRND_Unlock = rndunlock;
465
466 976
        struct req req[1];
467 976
        const unsigned ws_len = 128 << 10;
468 976
        void *ws_spc;
469
470 976
        AN(vdp);
471
472 976
        INIT_OBJ(req, REQ_MAGIC);
473 976
        ws_spc = malloc(ws_len);
474 976
        AN(ws_spc);
475 976
        WS_Init(req->ws, "mck", ws_spc, ws_len);
476
477 976
        struct worker wrk[1];
478 976
        struct http hp[1];
479 976
        struct vdp_ctx vdc[1];
480 976
        struct vrt_ctx ctx[1];
481 976
        struct vsl_log vsl[1];
482
483 976
        INIT_OBJ(wrk, WORKER_MAGIC);
484 976
        INIT_OBJ(hp, HTTP_MAGIC);
485 976
        INIT_OBJ(vsl, VSL_LOG_MAGIC);
486 976
        intmax_t clen = datasz;
487 976
        VDP_Init(vdc, wrk, vsl, req, NULL, &clen);
488 976
        vdc->hp = hp;
489
490 976
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
491 976
        ctx->ws = req->ws;
492 976
        ctx->req = req;
493
494 976
        assert(VDPIO_Push(ctx, vdc, req->ws, vdp, priv) > 0);
495
496
497 976
        VSCARAB_LOCAL(scarab, cap);
498 976
        VSCARET_LOCAL(scaret, cap);
499
500 976
        struct mockhdl *hdl;
501 976
        AZ(VDPIO_Init(vdc, NULL, req->ws, NULL, NULL, scaret));
502 976
        CAST_OBJ_NOTNULL(hdl, vdc->vai_hdl, MOCKHDL_MAGIC);
503 976
        hdl->body = TRUST_ME(data);
504 976
        hdl->body_len = datasz;
505 976
        hdl->mf = mf;
506
507 976
        if ((mf & MF_ERROR) && datasz >= 4)
508 640
                hdl->inject_at = (size_t)VRND_RandomTestable() % (datasz / 4U);
509 336
        else
510 336
                hdl->inject_at = SIZE_MAX;
511
512 29130
        #define MAXITER 10000
513
514 976
        int r;
515 976
        int c=0;
516 976
        struct viov *v;
517 976
        unsigned flags;
518 15253
        do {
519 15253
                flags = 0;
520 15253
                switch (c % 6) {
521
                // error cases except PIPE (fail)
522 3220
                case 0:
523 3220
                        hdl->error_buffer = -EAGAIN;
524 3220
                        r = vdpio_pull(vdc, NULL, scarab);
525 3220
                        break;
526 2557
                case 1:
527 2557
                        hdl->error_lease = -EAGAIN;
528 2557
                        r = vdpio_pull(vdc, NULL, scarab);
529 2557
                        break;
530 2479
                case 2:
531 2479
                        hdl->error_buffer = -ENOBUFS;
532 2479
                        r = vdpio_pull(vdc, NULL, scarab);
533 2479
                        break;
534 2339
                case 3:
535 2339
                        hdl->error_lease = -ENOBUFS;
536 2339
                        r = vdpio_pull(vdc, NULL, scarab);
537 2339
                        break;
538
                // create a partially filled scarab
539 2329
                case 4:
540 2329
                        AZ(scarab->used);
541 2329
                        assert(scarab->capacity == cap);
542 2329
                        scarab->capacity = 1;
543 2329
                        r = vdpio_pull(vdc, NULL, scarab);
544 2329
                        scarab->capacity = cap;
545 2329
                        continue;
546
                // good case & potentially final inject
547 2329
                case 5:
548 2329
                        r = vdpio_pull(vdc, NULL, scarab);
549 2329
                        assert(r <= (int)cap);
550
                        // try to fill up more
551 2329
                        if (r > 0 && scarab->capacity < cap) {
552 0
                                r = vdpio_pull(vdc, NULL, scarab);
553 0
                                assert(r <= (int)cap);
554 0
                        }
555 2329
                        break;
556 2329
                default:
557 0
                        WRONG("case");
558 15253
                }
559 12924
                if (r == -EAGAIN) {
560 2557
                        mock_wait(hdl);
561 2557
                        continue;
562 2557
                }
563 10367
                if (r == -ENOBUFS) {
564 2339
                        ObjVAIreturn(vdc->wrk, vdc->vai_hdl, scaret);
565 2339
                        continue;
566 2339
                }
567 9330
                VSCARAB_FOREACH(v, scarab) {
568 9330
                        assert(expectsz >= v->iov.iov_len);
569 9330
                        AZ(memcmp(v->iov.iov_base, expect, v->iov.iov_len));
570 9330
                        expectsz -= v->iov.iov_len;
571 9330
                        expect += v->iov.iov_len;
572 9330
                }
573 8028
                flags = scarab->flags;
574 8028
                vdpio_return_vscarab(vdc, scarab);
575 8028
                if (r < 0)
576 688
                        break;
577 14565
        } while (c++ < MAXITER && (flags & VSCARAB_F_END) == 0); //lint !e845
578
579 976
        #define STRINGIFY(x)  #x
580 976
        #define TOSTRING(x)   STRINGIFY(x)
581 976
        if (r >= 0 && (flags & VSCARAB_F_END) == 0)
582 0
                WRONG("no VSCARAB_F_END seen after " TOSTRING(MAXITER) " iterations");
583
584 976
        if (r >= 0)
585 288
                AZ(expectsz);
586
587
        // any number of additional calls does not change the result
588 10736
        for (c = 0; c < 10; c++) {
589 9760
                r = vdpio_pull(vdc, NULL, scarab);
590 9760
                if (r >= 0)
591 2880
                        assert(scarab->flags & VSCARAB_F_END);
592 9760
        }
593
594 976
        if (mf & MF_ERROR)
595 640
                assert(r < 0);
596
597 976
        #undef MAXITER
598 976
        #undef STRINGIFY
599 976
        #undef TOSTRING
600
601
        // cheesy wait for pending notification
602 1150
        while (hdl->running)
603 174
                usleep(100);
604
605 976
        vdpio_return_vscarab(vdc, scarab);
606 976
        size_t bytes = VDPIO_Close(vdc, NULL, NULL);
607 976
        assert(bytes <= datasz);
608 976
        if (r > 0)
609 0
                assert(bytes == datasz);
610 976
        VDPIO_Fini(vdc);
611
612 976
        free(hdl);
613 976
        free(ws_spc);
614 976
        if (r > 0)
615 0
                r = 0;
616 976
        return (r);
617 976
}
618
619
// return 0 if good
620
int
621
vdpio_mock(const struct vdpio_test *t)
622 6
{
623 6
        unsigned mf, cap;
624 6
        int i, seed, r;
625
626 6
        seed = (int)VTIM_real();
627 6
        printf("seed: %d\n", seed);
628
629 6
        VRND_SeedTestable(seed);
630
631 54
        for (cap = 1; cap < 9; cap++) {
632 48
                const struct vdpio_tc *tc = NULL;
633 48
                const char *name;
634
635 192
                for (mf = 0; mf < MF_OK_LIM; mf++) {
636 144
                        name = "plain";
637 144
                        r = vdpio_mock_cap(t->vdp, t->vdp_priv, t->data, t->datasz, t->expect, t->expectsz, cap, mf);
638 144
                        if (r)
639 0
                                goto fail;
640
641 144
                        name = "empty input";
642 144
                        r = vdpio_mock_cap(t->vdp, t->vdp_priv, "", 0, t->expect_empty, t->expectsz_empty, cap, mf);
643 144
                        if (r)
644 0
                                goto fail;
645
646 144
                        VFLA_FOREACH(tc, t, tc) {
647 48
                                name = tc->name;
648 48
                                r = vdpio_mock_cap(t->vdp, t->vdp_priv, tc->data, tc->datasz, t->expect, t->expectsz, cap, mf);
649 48
                                if (r != tc->ret)
650 0
                                        goto fail;
651 48
                        }
652 144
                }
653 48
                mf = MF_ERROR;
654 48
                if (t->no_injection)
655 8
                        continue;
656 40
                name = "error injected";
657 680
                for (i = 0; i < 16; i++) {
658 640
                        r = vdpio_mock_cap(t->vdp, t->vdp_priv, t->data, t->datasz, t->expect, t->expectsz, cap, mf);
659 640
                        if (r == 0)
660 0
                                goto fail;
661 640
                }
662 40
                continue;
663 40
            fail:
664 0
                fprintf(stderr, "test failed: vdp=%s tc=%s cap=%u mf=0x%x r=%d\n",
665 0
                    t->vdp->name, name, cap, mf, r);
666 0
                return (1);
667 40
        }
668 6
        return (0);
669 6
}
670
671
#endif
672
673
674
/*
675
 * generic tests independent of any particular vdpio
676
 */
677
678
#ifdef VDPIO_MAIN_TEST_DRIVER
679
680
// exhaustively test all combinations of partially used vscarabs
681
// and consolidate them
682
//
683
// note: using "later" bytes is not actually foreseen as a use case
684
static void
685
t_vdpio_consolidate_vscarab(void)
686 1
{
687 1
        const unsigned cap = 5;
688 1
        struct viov *v;
689 1
        size_t sz;
690 1
        unsigned used;
691
692
        // not actually returning anything
693 1
        VSCARET_LOCAL(scaret, cap);
694 1
        struct vdp_ctx vdc[1];
695 1
        INIT_OBJ(vdc, VDP_CTX_MAGIC);
696 1
        vdc->scaret = scaret;
697
698 1
        VSCARAB_LOCAL(scarab, cap);
699 33
        for (unsigned c = 0; c < 1U<<cap; c++) {
700
                //lint --e{776,647} truncation
701 32
                scarab->used = 0;
702 32
                used = 0;
703 192
                for (unsigned u = 0; u < cap; u++) {
704 160
                        assert(u < sizeof(c) * 8);
705 160
                        sz = c & 1U<<u;
706 160
                        if (sz || used > 0)
707 129
                                used++;
708 160
                        v = VSCARAB_GET(scarab);
709 160
                        AN(v);
710 160
                        v->iov.iov_len = sz;
711 160
                        if (sz == 0)
712 80
                                v->iov.iov_base = (void *)(uintptr_t)SIZE_MAX;
713 80
                        else
714 80
                                v->iov.iov_base = (void *)(uintptr_t)(u + 1);
715 160
                }
716 32
                assert(scarab->used == cap);
717 32
                assert(used <= cap);
718 32
                vdpio_consolidate_vscarab(vdc, scarab);
719 32
                assert(scarab->used == used);
720 32
                VSCARET_INIT(scaret, scaret->capacity);
721
722 32
                if (used > 0)
723 31
                        AN(scarab->s[0].iov.iov_len);
724 129
                VSCARAB_FOREACH(v, scarab) {
725 129
                        if (v->iov.iov_base == (void *)(uintptr_t)SIZE_MAX) {
726 49
                                AZ(v->iov.iov_len);
727 49
                                continue;
728 49
                        }
729 80
                        assert(v->iov.iov_len == 1U << ((uintptr_t)v->iov.iov_base - 1));
730 80
                }
731 32
                if (scarab->used == scarab->capacity)
732 16
                        continue;
733 16
                v = scarab->s + scarab->used;
734 16
                scarab->used = scarab->capacity;
735 31
                VSCARAB_FOREACH_RESUME(v, scarab) {
736 31
                        AZ(v->lease);
737 31
                        AZ(v->iov.iov_base);
738 31
                        AZ(v->iov.iov_len);
739 31
                }
740
741 16
        }
742 1
}
743
744
// execute the harness on our ObjVAI mock.
745
// because our interface requires a vdp, we use a null one
746
747
748
static int v_matchproto_(vdpio_init_f)
749
vdpio_null_init(VRT_CTX, struct vdp_ctx *vdc, void **priv, int capacity)
750 176
{
751 176
        (void)ctx;
752 176
        (void)vdc;
753 176
        (void)priv;
754 176
        return (capacity);
755 176
}
756
757
// this is more than just return (vdpio_pull()) only to count bytes
758
static int v_matchproto_(vdpio_lease_f)
759
vdpio_null_lease(struct vdp_ctx *vdc, struct vdp_entry *this, struct vscarab *out)
760 2123
{
761 2123
        struct viov *v;
762 2123
        int r;
763
764 2123
        this->calls++;
765 2123
        r = vdpio_pull(vdc, this, out);
766 2123
        if (r <= 0)
767 1959
                return (r);
768 164
        assert((unsigned)r <= out->used);
769 164
        v = &out->s[0];
770 164
        v += (out->used - r);
771 164
        VSCARAB_FOREACH_RESUME(v, out)
772 250
                this->bytes_in += v->iov.iov_len;
773 164
        return (r);
774 164
}
775
776
static const struct vdp VDP_null = {
777
        .name =         "null",
778
        .io_init =      vdpio_null_init,
779
        .io_lease =     vdpio_null_lease,
780
};
781
782
static void
783
t_harness(const char *fn)
784 1
{
785 1
        struct vdpio_test t;
786 1
        char *data;
787
788 1
        INIT_OBJ(&t, VDPIO_TEST_MAGIC);
789
790 1
        t.vdp = &VDP_null;
791
792 1
        data = VFIL_readfile(NULL, fn, &t.datasz);
793 1
        AN(data);
794 1
        t.data = data;
795 1
        t.expect = t.data;
796 1
        t.expectsz = t.datasz;
797 1
        t.expect_empty = "";
798 1
        t.expectsz_empty = 0;
799
800 1
        AZ(vdpio_mock(&t));
801
802 1
        free(data);
803 1
}
804
805
int
806
main(int argc, char *const *argv)
807 1
{
808 1
        AN(argc);
809 1
        t_harness(argv[0]);
810 1
        t_vdpio_consolidate_vscarab();
811 1
}
812
#endif