1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
24 * Copyright 2020 Joyent, Inc.
25 * Copyright 2017 RackTop Systems.
26 */
27
28 #include <assert.h>
29 #include <fcntl.h>
30 #include <poll.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <zlib.h>
35 #include <libgen.h>
36 #include <sys/spa.h>
37 #include <sys/stat.h>
38 #include <sys/processor.h>
39 #include <sys/zfs_context.h>
40 #include <sys/rrwlock.h>
41 #include <sys/zmod.h>
42 #include <sys/utsname.h>
43 #include <sys/systeminfo.h>
44 #include <libzutil.h>
45 #include <sys/crypto/common.h>
46 #include <sys/crypto/impl.h>
47 #include <sys/crypto/api.h>
48 #include <sys/sha2.h>
49 #include <crypto/aes/aes_impl.h>
50
51 extern void system_taskq_init(void);
52 extern void system_taskq_fini(void);
53
54 /*
55 * Emulation of kernel services in userland.
56 */
57
58 pgcnt_t physmem;
59 vnode_t *rootdir = (vnode_t *)0xabcd1234;
60 char hw_serial[HW_HOSTID_LEN];
61 kmutex_t cpu_lock;
62 vmem_t *zio_arena = NULL;
63
64 /* If set, all blocks read will be copied to the specified directory. */
65 char *vn_dumpdir = NULL;
66
67 struct utsname utsname = {
68 "userland", "libzpool", "1", "1", "na"
69 };
70
71 /*
72 * =========================================================================
73 * vnode operations
74 * =========================================================================
75 */
76 /*
77 * Note: for the xxxat() versions of these functions, we assume that the
78 * starting vp is always rootdir (which is true for spa_directory.c, the only
79 * ZFS consumer of these interfaces). We assert this is true, and then emulate
80 * them by adding '/' in front of the path.
81 */
82
83 /*ARGSUSED*/
84 int
vn_open(char * path,int x1,int flags,int mode,vnode_t ** vpp,int x2,int x3)85 vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3)
86 {
87 int fd;
88 int dump_fd;
89 vnode_t *vp;
90 int old_umask;
91 char realpath[MAXPATHLEN];
92 struct stat64 st;
93
94 /*
95 * If we're accessing a real disk from userland, we need to use
96 * the character interface to avoid caching. This is particularly
97 * important if we're trying to look at a real in-kernel storage
98 * pool from userland, e.g. via zdb, because otherwise we won't
99 * see the changes occurring under the segmap cache.
100 * On the other hand, the stupid character device returns zero
101 * for its size. So -- gag -- we open the block device to get
102 * its size, and remember it for subsequent VOP_GETATTR().
103 */
104 if (strncmp(path, "/dev/", 5) == 0) {
105 char *dsk;
106 fd = open64(path, O_RDONLY);
107 if (fd == -1)
108 return (errno);
109 if (fstat64(fd, &st) == -1) {
110 close(fd);
111 return (errno);
112 }
113 close(fd);
114 (void) sprintf(realpath, "%s", path);
115 dsk = strstr(path, "/dsk/");
116 if (dsk != NULL)
117 (void) sprintf(realpath + (dsk - path) + 1, "r%s",
118 dsk + 1);
119 } else {
120 (void) sprintf(realpath, "%s", path);
121 if (!(flags & FCREAT) && stat64(realpath, &st) == -1)
122 return (errno);
123 }
124
125 if (flags & FCREAT)
126 old_umask = umask(0);
127
128 /*
129 * The construct 'flags - FREAD' conveniently maps combinations of
130 * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR.
131 */
132 fd = open64(realpath, flags - FREAD, mode);
133
134 if (flags & FCREAT)
135 (void) umask(old_umask);
136
137 if (vn_dumpdir != NULL) {
138 char dumppath[MAXPATHLEN];
139 (void) snprintf(dumppath, sizeof (dumppath),
140 "%s/%s", vn_dumpdir, basename(realpath));
141 dump_fd = open64(dumppath, O_CREAT | O_WRONLY, 0666);
142 if (dump_fd == -1)
143 return (errno);
144 } else {
145 dump_fd = -1;
146 }
147
148 if (fd == -1)
149 return (errno);
150
151 if (fstat64(fd, &st) == -1) {
152 close(fd);
153 return (errno);
154 }
155
156 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
157
158 *vpp = vp = umem_zalloc(sizeof (vnode_t), UMEM_NOFAIL);
159
160 vp->v_fd = fd;
161 vp->v_size = st.st_size;
162 vp->v_path = spa_strdup(path);
163 vp->v_dump_fd = dump_fd;
164
165 return (0);
166 }
167
168 /*ARGSUSED*/
169 int
vn_openat(char * path,int x1,int flags,int mode,vnode_t ** vpp,int x2,int x3,vnode_t * startvp,int fd)170 vn_openat(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2,
171 int x3, vnode_t *startvp, int fd)
172 {
173 char *realpath = umem_alloc(strlen(path) + 2, UMEM_NOFAIL);
174 int ret;
175
176 ASSERT(startvp == rootdir);
177 (void) sprintf(realpath, "/%s", path);
178
179 /* fd ignored for now, need if want to simulate nbmand support */
180 ret = vn_open(realpath, x1, flags, mode, vpp, x2, x3);
181
182 umem_free(realpath, strlen(path) + 2);
183
184 return (ret);
185 }
186
187 /*ARGSUSED*/
188 int
vn_rdwr(int uio,vnode_t * vp,void * addr,ssize_t len,offset_t offset,int x1,int x2,rlim64_t x3,void * x4,ssize_t * residp)189 vn_rdwr(int uio, vnode_t *vp, void *addr, ssize_t len, offset_t offset,
190 int x1, int x2, rlim64_t x3, void *x4, ssize_t *residp)
191 {
192 ssize_t iolen, split;
193
194 if (uio == UIO_READ) {
195 iolen = pread64(vp->v_fd, addr, len, offset);
196 if (vp->v_dump_fd != -1) {
197 int status =
198 pwrite64(vp->v_dump_fd, addr, iolen, offset);
199 ASSERT(status != -1);
200 }
201 } else {
202 /*
203 * To simulate partial disk writes, we split writes into two
204 * system calls so that the process can be killed in between.
205 */
206 int sectors = len >> SPA_MINBLOCKSHIFT;
207 split = (sectors > 0 ? rand() % sectors : 0) <<
208 SPA_MINBLOCKSHIFT;
209 iolen = pwrite64(vp->v_fd, addr, split, offset);
210 iolen += pwrite64(vp->v_fd, (char *)addr + split,
211 len - split, offset + split);
212 }
213
214 if (iolen == -1)
215 return (errno);
216 if (residp)
217 *residp = len - iolen;
218 else if (iolen != len)
219 return (EIO);
220 return (0);
221 }
222
223 void
vn_close(vnode_t * vp)224 vn_close(vnode_t *vp)
225 {
226 close(vp->v_fd);
227 if (vp->v_dump_fd != -1)
228 close(vp->v_dump_fd);
229 spa_strfree(vp->v_path);
230 umem_free(vp, sizeof (vnode_t));
231 }
232
233 /*
234 * At a minimum we need to update the size since vdev_reopen()
235 * will no longer call vn_openat().
236 */
237 int
fop_getattr(vnode_t * vp,vattr_t * vap)238 fop_getattr(vnode_t *vp, vattr_t *vap)
239 {
240 struct stat64 st;
241
242 if (fstat64(vp->v_fd, &st) == -1) {
243 close(vp->v_fd);
244 return (errno);
245 }
246
247 vap->va_size = st.st_size;
248 return (0);
249 }
250
251 #ifdef ZFS_DEBUG
252
253 /*
254 * =========================================================================
255 * Figure out which debugging statements to print
256 * =========================================================================
257 */
258
259 static char *dprintf_string;
260 static int dprintf_print_all;
261
262 int
dprintf_find_string(const char * string)263 dprintf_find_string(const char *string)
264 {
265 char *tmp_str = dprintf_string;
266 int len = strlen(string);
267
268 /*
269 * Find out if this is a string we want to print.
270 * String format: file1.c,function_name1,file2.c,file3.c
271 */
272
273 while (tmp_str != NULL) {
274 if (strncmp(tmp_str, string, len) == 0 &&
275 (tmp_str[len] == ',' || tmp_str[len] == '\0'))
276 return (1);
277 tmp_str = strchr(tmp_str, ',');
278 if (tmp_str != NULL)
279 tmp_str++; /* Get rid of , */
280 }
281 return (0);
282 }
283
284 void
dprintf_setup(int * argc,char ** argv)285 dprintf_setup(int *argc, char **argv)
286 {
287 int i, j;
288
289 /*
290 * Debugging can be specified two ways: by setting the
291 * environment variable ZFS_DEBUG, or by including a
292 * "debug=..." argument on the command line. The command
293 * line setting overrides the environment variable.
294 */
295
296 for (i = 1; i < *argc; i++) {
297 int len = strlen("debug=");
298 /* First look for a command line argument */
299 if (strncmp("debug=", argv[i], len) == 0) {
300 dprintf_string = argv[i] + len;
301 /* Remove from args */
302 for (j = i; j < *argc; j++)
303 argv[j] = argv[j+1];
304 argv[j] = NULL;
305 (*argc)--;
306 }
307 }
308
309 if (dprintf_string == NULL) {
310 /* Look for ZFS_DEBUG environment variable */
311 dprintf_string = getenv("ZFS_DEBUG");
312 }
313
314 /*
315 * Are we just turning on all debugging?
316 */
317 if (dprintf_find_string("on"))
318 dprintf_print_all = 1;
319
320 if (dprintf_string != NULL)
321 zfs_flags |= ZFS_DEBUG_DPRINTF;
322 }
323
324 /*
325 * =========================================================================
326 * debug printfs
327 * =========================================================================
328 */
329 void
__dprintf(const char * file,const char * func,int line,const char * fmt,...)330 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
331 {
332 const char *newfile;
333 va_list adx;
334
335 /*
336 * Get rid of annoying "../common/" prefix to filename.
337 */
338 newfile = strrchr(file, '/');
339 if (newfile != NULL) {
340 newfile = newfile + 1; /* Get rid of leading / */
341 } else {
342 newfile = file;
343 }
344
345 if (dprintf_print_all ||
346 dprintf_find_string(newfile) ||
347 dprintf_find_string(func)) {
348 /* Print out just the function name if requested */
349 flockfile(stdout);
350 if (dprintf_find_string("pid"))
351 (void) printf("%d ", getpid());
352 if (dprintf_find_string("tid"))
353 (void) printf("%u ", thr_self());
354 if (dprintf_find_string("cpu"))
355 (void) printf("%u ", getcpuid());
356 if (dprintf_find_string("time"))
357 (void) printf("%llu ", gethrtime());
358 if (dprintf_find_string("long"))
359 (void) printf("%s, line %d: ", newfile, line);
360 (void) printf("%s: ", func);
361 va_start(adx, fmt);
362 (void) vprintf(fmt, adx);
363 va_end(adx);
364 funlockfile(stdout);
365 }
366 }
367
368 #endif /* ZFS_DEBUG */
369
370 /*
371 * =========================================================================
372 * kobj interfaces
373 * =========================================================================
374 */
375 struct _buf *
kobj_open_file(char * name)376 kobj_open_file(char *name)
377 {
378 struct _buf *file;
379 vnode_t *vp;
380
381 /* set vp as the _fd field of the file */
382 if (vn_openat(name, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0, rootdir,
383 -1) != 0)
384 return ((void *)-1UL);
385
386 file = umem_zalloc(sizeof (struct _buf), UMEM_NOFAIL);
387 file->_fd = (intptr_t)vp;
388 return (file);
389 }
390
391 int
kobj_read_file(struct _buf * file,char * buf,unsigned size,unsigned off)392 kobj_read_file(struct _buf *file, char *buf, unsigned size, unsigned off)
393 {
394 ssize_t resid;
395
396 vn_rdwr(UIO_READ, (vnode_t *)file->_fd, buf, size, (offset_t)off,
397 UIO_SYSSPACE, 0, 0, 0, &resid);
398
399 return (size - resid);
400 }
401
402 void
kobj_close_file(struct _buf * file)403 kobj_close_file(struct _buf *file)
404 {
405 vn_close((vnode_t *)file->_fd);
406 umem_free(file, sizeof (struct _buf));
407 }
408
409 int
kobj_get_filesize(struct _buf * file,uint64_t * size)410 kobj_get_filesize(struct _buf *file, uint64_t *size)
411 {
412 struct stat64 st;
413 vnode_t *vp = (vnode_t *)file->_fd;
414
415 if (fstat64(vp->v_fd, &st) == -1) {
416 vn_close(vp);
417 return (errno);
418 }
419 *size = st.st_size;
420 return (0);
421 }
422
423 /*
424 * =========================================================================
425 * misc routines
426 * =========================================================================
427 */
428
429 /*
430 * Find lowest one bit set.
431 * Returns bit number + 1 of lowest bit that is set, otherwise returns 0.
432 * This is basically a reimplementation of ffsll(), which is GNU specific.
433 */
434 int
lowbit64(uint64_t i)435 lowbit64(uint64_t i)
436 {
437 register int h = 64;
438 if (i == 0)
439 return (0);
440
441 if (i & 0x00000000ffffffffULL)
442 h -= 32;
443 else
444 i >>= 32;
445
446 if (i & 0x0000ffff)
447 h -= 16;
448 else
449 i >>= 16;
450
451 if (i & 0x00ff)
452 h -= 8;
453 else
454 i >>= 8;
455
456 if (i & 0x0f)
457 h -= 4;
458 else
459 i >>= 4;
460
461 if (i & 0x3)
462 h -= 2;
463 else
464 i >>= 2;
465
466 if (i & 0x1)
467 h -= 1;
468
469 return (h);
470 }
471
472 int
highbit64(uint64_t i)473 highbit64(uint64_t i)
474 {
475 int h = 1;
476
477 if (i == 0)
478 return (0);
479 if (i & 0xffffffff00000000ULL) {
480 h += 32; i >>= 32;
481 }
482 if (i & 0xffff0000) {
483 h += 16; i >>= 16;
484 }
485 if (i & 0xff00) {
486 h += 8; i >>= 8;
487 }
488 if (i & 0xf0) {
489 h += 4; i >>= 4;
490 }
491 if (i & 0xc) {
492 h += 2; i >>= 2;
493 }
494 if (i & 0x2) {
495 h += 1;
496 }
497 return (h);
498 }
499
500 /*
501 * =========================================================================
502 * kernel emulation setup & teardown
503 * =========================================================================
504 */
505 static int
umem_out_of_memory(void)506 umem_out_of_memory(void)
507 {
508 char errmsg[] = "out of memory -- generating core dump\n";
509
510 write(fileno(stderr), errmsg, sizeof (errmsg));
511 abort();
512 return (0);
513 }
514
515 void
kernel_init(int mode)516 kernel_init(int mode)
517 {
518 extern uint_t rrw_tsd_key;
519
520 umem_nofail_callback(umem_out_of_memory);
521
522 physmem = sysconf(_SC_PHYS_PAGES);
523
524 dprintf("physmem = %llu pages (%.2f GB)\n", physmem,
525 (double)physmem * sysconf(_SC_PAGE_SIZE) / (1ULL << 30));
526
527 (void) snprintf(hw_serial, sizeof (hw_serial), "%ld",
528 (mode & FWRITE) ? get_system_hostid() : 0);
529
530 system_taskq_init();
531
532 mutex_init(&cpu_lock, NULL, MUTEX_DEFAULT, NULL);
533
534 spa_init(mode);
535
536 tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
537 }
538
539 void
kernel_fini(void)540 kernel_fini(void)
541 {
542 spa_fini();
543
544 system_taskq_fini();
545 }
546
547 /* ARGSUSED */
548 uint32_t
zone_get_hostid(void * zonep)549 zone_get_hostid(void *zonep)
550 {
551 /*
552 * We're emulating the system's hostid in userland.
553 */
554 return (strtoul(hw_serial, NULL, 10));
555 }
556
557 int
z_uncompress(void * dst,size_t * dstlen,const void * src,size_t srclen)558 z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen)
559 {
560 int ret;
561 uLongf len = *dstlen;
562
563 if ((ret = uncompress(dst, &len, src, srclen)) == Z_OK)
564 *dstlen = (size_t)len;
565
566 return (ret);
567 }
568
569 int
z_compress_level(void * dst,size_t * dstlen,const void * src,size_t srclen,int level)570 z_compress_level(void *dst, size_t *dstlen, const void *src, size_t srclen,
571 int level)
572 {
573 int ret;
574 uLongf len = *dstlen;
575
576 if ((ret = compress2(dst, &len, src, srclen, level)) == Z_OK)
577 *dstlen = (size_t)len;
578
579 return (ret);
580 }
581
582 int
zfs_secpolicy_snapshot_perms(const char * name,cred_t * cr)583 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
584 {
585 return (0);
586 }
587
588 int
zfs_secpolicy_rename_perms(const char * from,const char * to,cred_t * cr)589 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
590 {
591 return (0);
592 }
593
594 int
zfs_secpolicy_destroy_perms(const char * name,cred_t * cr)595 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
596 {
597 return (0);
598 }
599
600 /* ARGSUSED */
601 int
zfs_onexit_fd_hold(int fd,minor_t * minorp)602 zfs_onexit_fd_hold(int fd, minor_t *minorp)
603 {
604 *minorp = 0;
605 return (0);
606 }
607
608 /* ARGSUSED */
609 void
zfs_onexit_fd_rele(int fd)610 zfs_onexit_fd_rele(int fd)
611 {
612 }
613
614 /* ARGSUSED */
615 int
zfs_onexit_add_cb(minor_t minor,void (* func)(void *),void * data,uint64_t * action_handle)616 zfs_onexit_add_cb(minor_t minor, void (*func)(void *), void *data,
617 uint64_t *action_handle)
618 {
619 return (0);
620 }
621
622 /* ARGSUSED */
623 int
zfs_onexit_del_cb(minor_t minor,uint64_t action_handle,boolean_t fire)624 zfs_onexit_del_cb(minor_t minor, uint64_t action_handle, boolean_t fire)
625 {
626 return (0);
627 }
628
629 /* ARGSUSED */
630 int
zfs_onexit_cb_data(minor_t minor,uint64_t action_handle,void ** data)631 zfs_onexit_cb_data(minor_t minor, uint64_t action_handle, void **data)
632 {
633 return (0);
634 }
635
636 void
bioinit(buf_t * bp)637 bioinit(buf_t *bp)
638 {
639 bzero(bp, sizeof (buf_t));
640 }
641
642 void
biodone(buf_t * bp)643 biodone(buf_t *bp)
644 {
645 if (bp->b_iodone != NULL) {
646 (*(bp->b_iodone))(bp);
647 return;
648 }
649 ASSERT((bp->b_flags & B_DONE) == 0);
650 bp->b_flags |= B_DONE;
651 }
652
653 void
bioerror(buf_t * bp,int error)654 bioerror(buf_t *bp, int error)
655 {
656 ASSERT(bp != NULL);
657 ASSERT(error >= 0);
658
659 if (error != 0) {
660 bp->b_flags |= B_ERROR;
661 } else {
662 bp->b_flags &= ~B_ERROR;
663 }
664 bp->b_error = error;
665 }
666
667
668 int
geterror(struct buf * bp)669 geterror(struct buf *bp)
670 {
671 int error = 0;
672
673 if (bp->b_flags & B_ERROR) {
674 error = bp->b_error;
675 if (!error)
676 error = EIO;
677 }
678 return (error);
679 }
680
681 int
crypto_create_ctx_template(crypto_mechanism_t * mech,crypto_key_t * key,crypto_ctx_template_t * tmpl,int kmflag)682 crypto_create_ctx_template(crypto_mechanism_t *mech,
683 crypto_key_t *key, crypto_ctx_template_t *tmpl, int kmflag)
684 {
685 return (0);
686 }
687
688 crypto_mech_type_t
crypto_mech2id(const char * name)689 crypto_mech2id(const char *name)
690 {
691 return (CRYPTO_MECH_INVALID);
692 }
693
694 int
crypto_mac(crypto_mechanism_t * mech,crypto_data_t * data,crypto_key_t * key,crypto_ctx_template_t impl,crypto_data_t * mac,crypto_call_req_t * cr)695 crypto_mac(crypto_mechanism_t *mech, crypto_data_t *data,
696 crypto_key_t *key, crypto_ctx_template_t impl,
697 crypto_data_t *mac, crypto_call_req_t *cr)
698 {
699 return (0);
700 }
701
702 int
crypto_encrypt(crypto_mechanism_t * mech,crypto_data_t * plaintext,crypto_key_t * key,crypto_ctx_template_t tmpl,crypto_data_t * ciphertext,crypto_call_req_t * cr)703 crypto_encrypt(crypto_mechanism_t *mech, crypto_data_t *plaintext,
704 crypto_key_t *key, crypto_ctx_template_t tmpl,
705 crypto_data_t *ciphertext, crypto_call_req_t *cr)
706 {
707 return (0);
708 }
709
710 /* This could probably be a weak reference */
711 int
crypto_decrypt(crypto_mechanism_t * mech,crypto_data_t * plaintext,crypto_key_t * key,crypto_ctx_template_t tmpl,crypto_data_t * ciphertext,crypto_call_req_t * cr)712 crypto_decrypt(crypto_mechanism_t *mech, crypto_data_t *plaintext,
713 crypto_key_t *key, crypto_ctx_template_t tmpl,
714 crypto_data_t *ciphertext, crypto_call_req_t *cr)
715 {
716 return (0);
717 }
718
719
720 int
crypto_digest_final(crypto_context_t context,crypto_data_t * digest,crypto_call_req_t * cr)721 crypto_digest_final(crypto_context_t context, crypto_data_t *digest,
722 crypto_call_req_t *cr)
723 {
724 return (0);
725 }
726
727 int
crypto_digest_update(crypto_context_t context,crypto_data_t * data,crypto_call_req_t * cr)728 crypto_digest_update(crypto_context_t context, crypto_data_t *data,
729 crypto_call_req_t *cr)
730 {
731 return (0);
732 }
733
734 int
crypto_digest_init(crypto_mechanism_t * mech,crypto_context_t * ctxp,crypto_call_req_t * crq)735 crypto_digest_init(crypto_mechanism_t *mech, crypto_context_t *ctxp,
736 crypto_call_req_t *crq)
737 {
738 return (0);
739 }
740
741 void
crypto_destroy_ctx_template(crypto_ctx_template_t tmpl)742 crypto_destroy_ctx_template(crypto_ctx_template_t tmpl)
743 {
744 }
745
crypto_mac_init(crypto_mechanism_t * mech,crypto_key_t * key,crypto_ctx_template_t tmpl,crypto_context_t * ctxp,crypto_call_req_t * cr)746 extern int crypto_mac_init(crypto_mechanism_t *mech, crypto_key_t *key,
747 crypto_ctx_template_t tmpl, crypto_context_t *ctxp,
748 crypto_call_req_t *cr)
749 {
750 return (0);
751 }
752
crypto_mac_update(crypto_context_t ctx,crypto_data_t * data,crypto_call_req_t * cr)753 extern int crypto_mac_update(crypto_context_t ctx, crypto_data_t *data,
754 crypto_call_req_t *cr)
755 {
756 return (0);
757 }
758
crypto_mac_final(crypto_context_t ctx,crypto_data_t * data,crypto_call_req_t * cr)759 extern int crypto_mac_final(crypto_context_t ctx, crypto_data_t *data,
760 crypto_call_req_t *cr)
761 {
762 return (0);
763 }
764