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, 2018 by Delphix. All rights reserved. 24 * Copyright (c) 2016 Actifio, Inc. All rights reserved. 25 */ 26 27 #include <assert.h> 28 #include <fcntl.h> 29 #include <libgen.h> 30 #include <poll.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <string.h> 34 #include <sys/crypto/icp.h> 35 #include <sys/processor.h> 36 #include <sys/rrwlock.h> 37 #include <sys/spa.h> 38 #include <sys/stat.h> 39 #include <sys/systeminfo.h> 40 #include <sys/time.h> 41 #include <sys/utsname.h> 42 #include <sys/zfs_context.h> 43 #include <sys/zfs_onexit.h> 44 #include <sys/zfs_vfsops.h> 45 #include <sys/zstd/zstd.h> 46 #include <sys/zvol.h> 47 #include <zfs_fletcher.h> 48 #include <zlib.h> 49 50 /* 51 * Emulation of kernel services in userland. 52 */ 53 54 uint64_t physmem; 55 char hw_serial[HW_HOSTID_LEN]; 56 struct utsname hw_utsname; 57 58 /* If set, all blocks read will be copied to the specified directory. */ 59 char *vn_dumpdir = NULL; 60 61 /* this only exists to have its address taken */ 62 struct proc p0; 63 64 /* 65 * ========================================================================= 66 * threads 67 * ========================================================================= 68 * 69 * TS_STACK_MIN is dictated by the minimum allowed pthread stack size. While 70 * TS_STACK_MAX is somewhat arbitrary, it was selected to be large enough for 71 * the expected stack depth while small enough to avoid exhausting address 72 * space with high thread counts. 73 */ 74 #define TS_STACK_MIN MAX(PTHREAD_STACK_MIN, 32768) 75 #define TS_STACK_MAX (256 * 1024) 76 77 /*ARGSUSED*/ 78 kthread_t * 79 zk_thread_create(void (*func)(void *), void *arg, size_t stksize, int state) 80 { 81 pthread_attr_t attr; 82 pthread_t tid; 83 char *stkstr; 84 int detachstate = PTHREAD_CREATE_DETACHED; 85 86 VERIFY0(pthread_attr_init(&attr)); 87 88 if (state & TS_JOINABLE) 89 detachstate = PTHREAD_CREATE_JOINABLE; 90 91 VERIFY0(pthread_attr_setdetachstate(&attr, detachstate)); 92 93 /* 94 * We allow the default stack size in user space to be specified by 95 * setting the ZFS_STACK_SIZE environment variable. This allows us 96 * the convenience of observing and debugging stack overruns in 97 * user space. Explicitly specified stack sizes will be honored. 98 * The usage of ZFS_STACK_SIZE is discussed further in the 99 * ENVIRONMENT VARIABLES sections of the ztest(1) man page. 100 */ 101 if (stksize == 0) { 102 stkstr = getenv("ZFS_STACK_SIZE"); 103 104 if (stkstr == NULL) 105 stksize = TS_STACK_MAX; 106 else 107 stksize = MAX(atoi(stkstr), TS_STACK_MIN); 108 } 109 110 VERIFY3S(stksize, >, 0); 111 stksize = P2ROUNDUP(MAX(stksize, TS_STACK_MIN), PAGESIZE); 112 113 /* 114 * If this ever fails, it may be because the stack size is not a 115 * multiple of system page size. 116 */ 117 VERIFY0(pthread_attr_setstacksize(&attr, stksize)); 118 VERIFY0(pthread_attr_setguardsize(&attr, PAGESIZE)); 119 120 VERIFY0(pthread_create(&tid, &attr, (void *(*)(void *))func, arg)); 121 VERIFY0(pthread_attr_destroy(&attr)); 122 123 return ((void *)(uintptr_t)tid); 124 } 125 126 /* 127 * ========================================================================= 128 * kstats 129 * ========================================================================= 130 */ 131 /*ARGSUSED*/ 132 kstat_t * 133 kstat_create(const char *module, int instance, const char *name, 134 const char *class, uchar_t type, ulong_t ndata, uchar_t ks_flag) 135 { 136 return (NULL); 137 } 138 139 /*ARGSUSED*/ 140 void 141 kstat_install(kstat_t *ksp) 142 {} 143 144 /*ARGSUSED*/ 145 void 146 kstat_delete(kstat_t *ksp) 147 {} 148 149 /*ARGSUSED*/ 150 void 151 kstat_waitq_enter(kstat_io_t *kiop) 152 {} 153 154 /*ARGSUSED*/ 155 void 156 kstat_waitq_exit(kstat_io_t *kiop) 157 {} 158 159 /*ARGSUSED*/ 160 void 161 kstat_runq_enter(kstat_io_t *kiop) 162 {} 163 164 /*ARGSUSED*/ 165 void 166 kstat_runq_exit(kstat_io_t *kiop) 167 {} 168 169 /*ARGSUSED*/ 170 void 171 kstat_waitq_to_runq(kstat_io_t *kiop) 172 {} 173 174 /*ARGSUSED*/ 175 void 176 kstat_runq_back_to_waitq(kstat_io_t *kiop) 177 {} 178 179 void 180 kstat_set_raw_ops(kstat_t *ksp, 181 int (*headers)(char *buf, size_t size), 182 int (*data)(char *buf, size_t size, void *data), 183 void *(*addr)(kstat_t *ksp, loff_t index)) 184 {} 185 186 /* 187 * ========================================================================= 188 * mutexes 189 * ========================================================================= 190 */ 191 192 void 193 mutex_init(kmutex_t *mp, char *name, int type, void *cookie) 194 { 195 VERIFY0(pthread_mutex_init(&mp->m_lock, NULL)); 196 memset(&mp->m_owner, 0, sizeof (pthread_t)); 197 } 198 199 void 200 mutex_destroy(kmutex_t *mp) 201 { 202 VERIFY0(pthread_mutex_destroy(&mp->m_lock)); 203 } 204 205 void 206 mutex_enter(kmutex_t *mp) 207 { 208 VERIFY0(pthread_mutex_lock(&mp->m_lock)); 209 mp->m_owner = pthread_self(); 210 } 211 212 int 213 mutex_tryenter(kmutex_t *mp) 214 { 215 int error; 216 217 error = pthread_mutex_trylock(&mp->m_lock); 218 if (error == 0) { 219 mp->m_owner = pthread_self(); 220 return (1); 221 } else { 222 VERIFY3S(error, ==, EBUSY); 223 return (0); 224 } 225 } 226 227 void 228 mutex_exit(kmutex_t *mp) 229 { 230 memset(&mp->m_owner, 0, sizeof (pthread_t)); 231 VERIFY0(pthread_mutex_unlock(&mp->m_lock)); 232 } 233 234 /* 235 * ========================================================================= 236 * rwlocks 237 * ========================================================================= 238 */ 239 240 void 241 rw_init(krwlock_t *rwlp, char *name, int type, void *arg) 242 { 243 VERIFY0(pthread_rwlock_init(&rwlp->rw_lock, NULL)); 244 rwlp->rw_readers = 0; 245 rwlp->rw_owner = 0; 246 } 247 248 void 249 rw_destroy(krwlock_t *rwlp) 250 { 251 VERIFY0(pthread_rwlock_destroy(&rwlp->rw_lock)); 252 } 253 254 void 255 rw_enter(krwlock_t *rwlp, krw_t rw) 256 { 257 if (rw == RW_READER) { 258 VERIFY0(pthread_rwlock_rdlock(&rwlp->rw_lock)); 259 atomic_inc_uint(&rwlp->rw_readers); 260 } else { 261 VERIFY0(pthread_rwlock_wrlock(&rwlp->rw_lock)); 262 rwlp->rw_owner = pthread_self(); 263 } 264 } 265 266 void 267 rw_exit(krwlock_t *rwlp) 268 { 269 if (RW_READ_HELD(rwlp)) 270 atomic_dec_uint(&rwlp->rw_readers); 271 else 272 rwlp->rw_owner = 0; 273 274 VERIFY0(pthread_rwlock_unlock(&rwlp->rw_lock)); 275 } 276 277 int 278 rw_tryenter(krwlock_t *rwlp, krw_t rw) 279 { 280 int error; 281 282 if (rw == RW_READER) 283 error = pthread_rwlock_tryrdlock(&rwlp->rw_lock); 284 else 285 error = pthread_rwlock_trywrlock(&rwlp->rw_lock); 286 287 if (error == 0) { 288 if (rw == RW_READER) 289 atomic_inc_uint(&rwlp->rw_readers); 290 else 291 rwlp->rw_owner = pthread_self(); 292 293 return (1); 294 } 295 296 VERIFY3S(error, ==, EBUSY); 297 298 return (0); 299 } 300 301 /* ARGSUSED */ 302 uint32_t 303 zone_get_hostid(void *zonep) 304 { 305 /* 306 * We're emulating the system's hostid in userland. 307 */ 308 return (strtoul(hw_serial, NULL, 10)); 309 } 310 311 int 312 rw_tryupgrade(krwlock_t *rwlp) 313 { 314 return (0); 315 } 316 317 /* 318 * ========================================================================= 319 * condition variables 320 * ========================================================================= 321 */ 322 323 void 324 cv_init(kcondvar_t *cv, char *name, int type, void *arg) 325 { 326 VERIFY0(pthread_cond_init(cv, NULL)); 327 } 328 329 void 330 cv_destroy(kcondvar_t *cv) 331 { 332 VERIFY0(pthread_cond_destroy(cv)); 333 } 334 335 void 336 cv_wait(kcondvar_t *cv, kmutex_t *mp) 337 { 338 memset(&mp->m_owner, 0, sizeof (pthread_t)); 339 VERIFY0(pthread_cond_wait(cv, &mp->m_lock)); 340 mp->m_owner = pthread_self(); 341 } 342 343 int 344 cv_wait_sig(kcondvar_t *cv, kmutex_t *mp) 345 { 346 cv_wait(cv, mp); 347 return (1); 348 } 349 350 int 351 cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime) 352 { 353 int error; 354 struct timeval tv; 355 struct timespec ts; 356 clock_t delta; 357 358 delta = abstime - ddi_get_lbolt(); 359 if (delta <= 0) 360 return (-1); 361 362 VERIFY(gettimeofday(&tv, NULL) == 0); 363 364 ts.tv_sec = tv.tv_sec + delta / hz; 365 ts.tv_nsec = tv.tv_usec * NSEC_PER_USEC + (delta % hz) * (NANOSEC / hz); 366 if (ts.tv_nsec >= NANOSEC) { 367 ts.tv_sec++; 368 ts.tv_nsec -= NANOSEC; 369 } 370 371 memset(&mp->m_owner, 0, sizeof (pthread_t)); 372 error = pthread_cond_timedwait(cv, &mp->m_lock, &ts); 373 mp->m_owner = pthread_self(); 374 375 if (error == ETIMEDOUT) 376 return (-1); 377 378 VERIFY0(error); 379 380 return (1); 381 } 382 383 /*ARGSUSED*/ 384 int 385 cv_timedwait_hires(kcondvar_t *cv, kmutex_t *mp, hrtime_t tim, hrtime_t res, 386 int flag) 387 { 388 int error; 389 struct timeval tv; 390 struct timespec ts; 391 hrtime_t delta; 392 393 ASSERT(flag == 0 || flag == CALLOUT_FLAG_ABSOLUTE); 394 395 delta = tim; 396 if (flag & CALLOUT_FLAG_ABSOLUTE) 397 delta -= gethrtime(); 398 399 if (delta <= 0) 400 return (-1); 401 402 VERIFY0(gettimeofday(&tv, NULL)); 403 404 ts.tv_sec = tv.tv_sec + delta / NANOSEC; 405 ts.tv_nsec = tv.tv_usec * NSEC_PER_USEC + (delta % NANOSEC); 406 if (ts.tv_nsec >= NANOSEC) { 407 ts.tv_sec++; 408 ts.tv_nsec -= NANOSEC; 409 } 410 411 memset(&mp->m_owner, 0, sizeof (pthread_t)); 412 error = pthread_cond_timedwait(cv, &mp->m_lock, &ts); 413 mp->m_owner = pthread_self(); 414 415 if (error == ETIMEDOUT) 416 return (-1); 417 418 VERIFY0(error); 419 420 return (1); 421 } 422 423 void 424 cv_signal(kcondvar_t *cv) 425 { 426 VERIFY0(pthread_cond_signal(cv)); 427 } 428 429 void 430 cv_broadcast(kcondvar_t *cv) 431 { 432 VERIFY0(pthread_cond_broadcast(cv)); 433 } 434 435 /* 436 * ========================================================================= 437 * procfs list 438 * ========================================================================= 439 */ 440 441 void 442 seq_printf(struct seq_file *m, const char *fmt, ...) 443 {} 444 445 void 446 procfs_list_install(const char *module, 447 const char *submodule, 448 const char *name, 449 mode_t mode, 450 procfs_list_t *procfs_list, 451 int (*show)(struct seq_file *f, void *p), 452 int (*show_header)(struct seq_file *f), 453 int (*clear)(procfs_list_t *procfs_list), 454 size_t procfs_list_node_off) 455 { 456 mutex_init(&procfs_list->pl_lock, NULL, MUTEX_DEFAULT, NULL); 457 list_create(&procfs_list->pl_list, 458 procfs_list_node_off + sizeof (procfs_list_node_t), 459 procfs_list_node_off + offsetof(procfs_list_node_t, pln_link)); 460 procfs_list->pl_next_id = 1; 461 procfs_list->pl_node_offset = procfs_list_node_off; 462 } 463 464 void 465 procfs_list_uninstall(procfs_list_t *procfs_list) 466 {} 467 468 void 469 procfs_list_destroy(procfs_list_t *procfs_list) 470 { 471 ASSERT(list_is_empty(&procfs_list->pl_list)); 472 list_destroy(&procfs_list->pl_list); 473 mutex_destroy(&procfs_list->pl_lock); 474 } 475 476 #define NODE_ID(procfs_list, obj) \ 477 (((procfs_list_node_t *)(((char *)obj) + \ 478 (procfs_list)->pl_node_offset))->pln_id) 479 480 void 481 procfs_list_add(procfs_list_t *procfs_list, void *p) 482 { 483 ASSERT(MUTEX_HELD(&procfs_list->pl_lock)); 484 NODE_ID(procfs_list, p) = procfs_list->pl_next_id++; 485 list_insert_tail(&procfs_list->pl_list, p); 486 } 487 488 /* 489 * ========================================================================= 490 * vnode operations 491 * ========================================================================= 492 */ 493 494 /* 495 * ========================================================================= 496 * Figure out which debugging statements to print 497 * ========================================================================= 498 */ 499 500 static char *dprintf_string; 501 static int dprintf_print_all; 502 503 int 504 dprintf_find_string(const char *string) 505 { 506 char *tmp_str = dprintf_string; 507 int len = strlen(string); 508 509 /* 510 * Find out if this is a string we want to print. 511 * String format: file1.c,function_name1,file2.c,file3.c 512 */ 513 514 while (tmp_str != NULL) { 515 if (strncmp(tmp_str, string, len) == 0 && 516 (tmp_str[len] == ',' || tmp_str[len] == '\0')) 517 return (1); 518 tmp_str = strchr(tmp_str, ','); 519 if (tmp_str != NULL) 520 tmp_str++; /* Get rid of , */ 521 } 522 return (0); 523 } 524 525 void 526 dprintf_setup(int *argc, char **argv) 527 { 528 int i, j; 529 530 /* 531 * Debugging can be specified two ways: by setting the 532 * environment variable ZFS_DEBUG, or by including a 533 * "debug=..." argument on the command line. The command 534 * line setting overrides the environment variable. 535 */ 536 537 for (i = 1; i < *argc; i++) { 538 int len = strlen("debug="); 539 /* First look for a command line argument */ 540 if (strncmp("debug=", argv[i], len) == 0) { 541 dprintf_string = argv[i] + len; 542 /* Remove from args */ 543 for (j = i; j < *argc; j++) 544 argv[j] = argv[j+1]; 545 argv[j] = NULL; 546 (*argc)--; 547 } 548 } 549 550 if (dprintf_string == NULL) { 551 /* Look for ZFS_DEBUG environment variable */ 552 dprintf_string = getenv("ZFS_DEBUG"); 553 } 554 555 /* 556 * Are we just turning on all debugging? 557 */ 558 if (dprintf_find_string("on")) 559 dprintf_print_all = 1; 560 561 if (dprintf_string != NULL) 562 zfs_flags |= ZFS_DEBUG_DPRINTF; 563 } 564 565 /* 566 * ========================================================================= 567 * debug printfs 568 * ========================================================================= 569 */ 570 void 571 __dprintf(boolean_t dprint, const char *file, const char *func, 572 int line, const char *fmt, ...) 573 { 574 const char *newfile; 575 va_list adx; 576 577 /* 578 * Get rid of annoying "../common/" prefix to filename. 579 */ 580 newfile = strrchr(file, '/'); 581 if (newfile != NULL) { 582 newfile = newfile + 1; /* Get rid of leading / */ 583 } else { 584 newfile = file; 585 } 586 587 if (dprint) { 588 /* dprintf messages are printed immediately */ 589 590 if (!dprintf_print_all && 591 !dprintf_find_string(newfile) && 592 !dprintf_find_string(func)) 593 return; 594 595 /* Print out just the function name if requested */ 596 flockfile(stdout); 597 if (dprintf_find_string("pid")) 598 (void) printf("%d ", getpid()); 599 if (dprintf_find_string("tid")) 600 (void) printf("%ju ", 601 (uintmax_t)(uintptr_t)pthread_self()); 602 if (dprintf_find_string("cpu")) 603 (void) printf("%u ", getcpuid()); 604 if (dprintf_find_string("time")) 605 (void) printf("%llu ", gethrtime()); 606 if (dprintf_find_string("long")) 607 (void) printf("%s, line %d: ", newfile, line); 608 (void) printf("dprintf: %s: ", func); 609 va_start(adx, fmt); 610 (void) vprintf(fmt, adx); 611 va_end(adx); 612 funlockfile(stdout); 613 } else { 614 /* zfs_dbgmsg is logged for dumping later */ 615 size_t size; 616 char *buf; 617 int i; 618 619 size = 1024; 620 buf = umem_alloc(size, UMEM_NOFAIL); 621 i = snprintf(buf, size, "%s:%d:%s(): ", newfile, line, func); 622 623 if (i < size) { 624 va_start(adx, fmt); 625 (void) vsnprintf(buf + i, size - i, fmt, adx); 626 va_end(adx); 627 } 628 629 __zfs_dbgmsg(buf); 630 631 umem_free(buf, size); 632 } 633 } 634 635 /* 636 * ========================================================================= 637 * cmn_err() and panic() 638 * ========================================================================= 639 */ 640 static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" }; 641 static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" }; 642 643 void 644 vpanic(const char *fmt, va_list adx) 645 { 646 (void) fprintf(stderr, "error: "); 647 (void) vfprintf(stderr, fmt, adx); 648 (void) fprintf(stderr, "\n"); 649 650 abort(); /* think of it as a "user-level crash dump" */ 651 } 652 653 void 654 panic(const char *fmt, ...) 655 { 656 va_list adx; 657 658 va_start(adx, fmt); 659 vpanic(fmt, adx); 660 va_end(adx); 661 } 662 663 void 664 vcmn_err(int ce, const char *fmt, va_list adx) 665 { 666 if (ce == CE_PANIC) 667 vpanic(fmt, adx); 668 if (ce != CE_NOTE) { /* suppress noise in userland stress testing */ 669 (void) fprintf(stderr, "%s", ce_prefix[ce]); 670 (void) vfprintf(stderr, fmt, adx); 671 (void) fprintf(stderr, "%s", ce_suffix[ce]); 672 } 673 } 674 675 /*PRINTFLIKE2*/ 676 void 677 cmn_err(int ce, const char *fmt, ...) 678 { 679 va_list adx; 680 681 va_start(adx, fmt); 682 vcmn_err(ce, fmt, adx); 683 va_end(adx); 684 } 685 686 /* 687 * ========================================================================= 688 * misc routines 689 * ========================================================================= 690 */ 691 692 void 693 delay(clock_t ticks) 694 { 695 (void) poll(0, 0, ticks * (1000 / hz)); 696 } 697 698 /* 699 * Find highest one bit set. 700 * Returns bit number + 1 of highest bit that is set, otherwise returns 0. 701 * The __builtin_clzll() function is supported by both GCC and Clang. 702 */ 703 int 704 highbit64(uint64_t i) 705 { 706 if (i == 0) 707 return (0); 708 709 return (NBBY * sizeof (uint64_t) - __builtin_clzll(i)); 710 } 711 712 /* 713 * Find lowest one bit set. 714 * Returns bit number + 1 of lowest bit that is set, otherwise returns 0. 715 * The __builtin_ffsll() function is supported by both GCC and Clang. 716 */ 717 int 718 lowbit64(uint64_t i) 719 { 720 if (i == 0) 721 return (0); 722 723 return (__builtin_ffsll(i)); 724 } 725 726 const char *random_path = "/dev/random"; 727 const char *urandom_path = "/dev/urandom"; 728 static int random_fd = -1, urandom_fd = -1; 729 730 void 731 random_init(void) 732 { 733 VERIFY((random_fd = open(random_path, O_RDONLY | O_CLOEXEC)) != -1); 734 VERIFY((urandom_fd = open(urandom_path, O_RDONLY | O_CLOEXEC)) != -1); 735 } 736 737 void 738 random_fini(void) 739 { 740 close(random_fd); 741 close(urandom_fd); 742 743 random_fd = -1; 744 urandom_fd = -1; 745 } 746 747 static int 748 random_get_bytes_common(uint8_t *ptr, size_t len, int fd) 749 { 750 size_t resid = len; 751 ssize_t bytes; 752 753 ASSERT(fd != -1); 754 755 while (resid != 0) { 756 bytes = read(fd, ptr, resid); 757 ASSERT3S(bytes, >=, 0); 758 ptr += bytes; 759 resid -= bytes; 760 } 761 762 return (0); 763 } 764 765 int 766 random_get_bytes(uint8_t *ptr, size_t len) 767 { 768 return (random_get_bytes_common(ptr, len, random_fd)); 769 } 770 771 int 772 random_get_pseudo_bytes(uint8_t *ptr, size_t len) 773 { 774 return (random_get_bytes_common(ptr, len, urandom_fd)); 775 } 776 777 int 778 ddi_strtoul(const char *hw_serial, char **nptr, int base, unsigned long *result) 779 { 780 char *end; 781 782 *result = strtoul(hw_serial, &end, base); 783 if (*result == 0) 784 return (errno); 785 return (0); 786 } 787 788 int 789 ddi_strtoull(const char *str, char **nptr, int base, u_longlong_t *result) 790 { 791 char *end; 792 793 *result = strtoull(str, &end, base); 794 if (*result == 0) 795 return (errno); 796 return (0); 797 } 798 799 utsname_t * 800 utsname(void) 801 { 802 return (&hw_utsname); 803 } 804 805 /* 806 * ========================================================================= 807 * kernel emulation setup & teardown 808 * ========================================================================= 809 */ 810 static int 811 umem_out_of_memory(void) 812 { 813 char errmsg[] = "out of memory -- generating core dump\n"; 814 815 (void) fprintf(stderr, "%s", errmsg); 816 abort(); 817 return (0); 818 } 819 820 void 821 kernel_init(int mode) 822 { 823 extern uint_t rrw_tsd_key; 824 825 umem_nofail_callback(umem_out_of_memory); 826 827 physmem = sysconf(_SC_PHYS_PAGES); 828 829 dprintf("physmem = %llu pages (%.2f GB)\n", physmem, 830 (double)physmem * sysconf(_SC_PAGE_SIZE) / (1ULL << 30)); 831 832 (void) snprintf(hw_serial, sizeof (hw_serial), "%ld", 833 (mode & SPA_MODE_WRITE) ? get_system_hostid() : 0); 834 835 random_init(); 836 837 VERIFY0(uname(&hw_utsname)); 838 839 system_taskq_init(); 840 icp_init(); 841 842 zstd_init(); 843 844 spa_init((spa_mode_t)mode); 845 846 fletcher_4_init(); 847 848 tsd_create(&rrw_tsd_key, rrw_tsd_destroy); 849 } 850 851 void 852 kernel_fini(void) 853 { 854 fletcher_4_fini(); 855 spa_fini(); 856 857 zstd_fini(); 858 859 icp_fini(); 860 system_taskq_fini(); 861 862 random_fini(); 863 } 864 865 uid_t 866 crgetuid(cred_t *cr) 867 { 868 return (0); 869 } 870 871 uid_t 872 crgetruid(cred_t *cr) 873 { 874 return (0); 875 } 876 877 gid_t 878 crgetgid(cred_t *cr) 879 { 880 return (0); 881 } 882 883 int 884 crgetngroups(cred_t *cr) 885 { 886 return (0); 887 } 888 889 gid_t * 890 crgetgroups(cred_t *cr) 891 { 892 return (NULL); 893 } 894 895 int 896 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr) 897 { 898 return (0); 899 } 900 901 int 902 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr) 903 { 904 return (0); 905 } 906 907 int 908 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr) 909 { 910 return (0); 911 } 912 913 int 914 secpolicy_zfs(const cred_t *cr) 915 { 916 return (0); 917 } 918 919 int 920 secpolicy_zfs_proc(const cred_t *cr, proc_t *proc) 921 { 922 return (0); 923 } 924 925 ksiddomain_t * 926 ksid_lookupdomain(const char *dom) 927 { 928 ksiddomain_t *kd; 929 930 kd = umem_zalloc(sizeof (ksiddomain_t), UMEM_NOFAIL); 931 kd->kd_name = spa_strdup(dom); 932 return (kd); 933 } 934 935 void 936 ksiddomain_rele(ksiddomain_t *ksid) 937 { 938 spa_strfree(ksid->kd_name); 939 umem_free(ksid, sizeof (ksiddomain_t)); 940 } 941 942 char * 943 kmem_vasprintf(const char *fmt, va_list adx) 944 { 945 char *buf = NULL; 946 va_list adx_copy; 947 948 va_copy(adx_copy, adx); 949 VERIFY(vasprintf(&buf, fmt, adx_copy) != -1); 950 va_end(adx_copy); 951 952 return (buf); 953 } 954 955 char * 956 kmem_asprintf(const char *fmt, ...) 957 { 958 char *buf = NULL; 959 va_list adx; 960 961 va_start(adx, fmt); 962 VERIFY(vasprintf(&buf, fmt, adx) != -1); 963 va_end(adx); 964 965 return (buf); 966 } 967 968 /* ARGSUSED */ 969 int 970 zfs_onexit_fd_hold(int fd, minor_t *minorp) 971 { 972 *minorp = 0; 973 return (0); 974 } 975 976 /* ARGSUSED */ 977 void 978 zfs_onexit_fd_rele(int fd) 979 { 980 } 981 982 /* ARGSUSED */ 983 int 984 zfs_onexit_add_cb(minor_t minor, void (*func)(void *), void *data, 985 uint64_t *action_handle) 986 { 987 return (0); 988 } 989 990 fstrans_cookie_t 991 spl_fstrans_mark(void) 992 { 993 return ((fstrans_cookie_t)0); 994 } 995 996 void 997 spl_fstrans_unmark(fstrans_cookie_t cookie) 998 { 999 } 1000 1001 int 1002 __spl_pf_fstrans_check(void) 1003 { 1004 return (0); 1005 } 1006 1007 int 1008 kmem_cache_reap_active(void) 1009 { 1010 return (0); 1011 } 1012 1013 void *zvol_tag = "zvol_tag"; 1014 1015 void 1016 zvol_create_minor(const char *name) 1017 { 1018 } 1019 1020 void 1021 zvol_create_minors_recursive(const char *name) 1022 { 1023 } 1024 1025 void 1026 zvol_remove_minors(spa_t *spa, const char *name, boolean_t async) 1027 { 1028 } 1029 1030 void 1031 zvol_rename_minors(spa_t *spa, const char *oldname, const char *newname, 1032 boolean_t async) 1033 { 1034 } 1035 1036 /* 1037 * Open file 1038 * 1039 * path - fully qualified path to file 1040 * flags - file attributes O_READ / O_WRITE / O_EXCL 1041 * fpp - pointer to return file pointer 1042 * 1043 * Returns 0 on success underlying error on failure. 1044 */ 1045 int 1046 zfs_file_open(const char *path, int flags, int mode, zfs_file_t **fpp) 1047 { 1048 int fd = -1; 1049 int dump_fd = -1; 1050 int err; 1051 int old_umask = 0; 1052 zfs_file_t *fp; 1053 struct stat64 st; 1054 1055 if (!(flags & O_CREAT) && stat64(path, &st) == -1) 1056 return (errno); 1057 1058 if (!(flags & O_CREAT) && S_ISBLK(st.st_mode)) 1059 flags |= O_DIRECT; 1060 1061 if (flags & O_CREAT) 1062 old_umask = umask(0); 1063 1064 fd = open64(path, flags, mode); 1065 if (fd == -1) 1066 return (errno); 1067 1068 if (flags & O_CREAT) 1069 (void) umask(old_umask); 1070 1071 if (vn_dumpdir != NULL) { 1072 char *dumppath = umem_zalloc(MAXPATHLEN, UMEM_NOFAIL); 1073 char *inpath = basename((char *)(uintptr_t)path); 1074 1075 (void) snprintf(dumppath, MAXPATHLEN, 1076 "%s/%s", vn_dumpdir, inpath); 1077 dump_fd = open64(dumppath, O_CREAT | O_WRONLY, 0666); 1078 umem_free(dumppath, MAXPATHLEN); 1079 if (dump_fd == -1) { 1080 err = errno; 1081 close(fd); 1082 return (err); 1083 } 1084 } else { 1085 dump_fd = -1; 1086 } 1087 1088 (void) fcntl(fd, F_SETFD, FD_CLOEXEC); 1089 1090 fp = umem_zalloc(sizeof (zfs_file_t), UMEM_NOFAIL); 1091 fp->f_fd = fd; 1092 fp->f_dump_fd = dump_fd; 1093 *fpp = fp; 1094 1095 return (0); 1096 } 1097 1098 void 1099 zfs_file_close(zfs_file_t *fp) 1100 { 1101 close(fp->f_fd); 1102 if (fp->f_dump_fd != -1) 1103 close(fp->f_dump_fd); 1104 1105 umem_free(fp, sizeof (zfs_file_t)); 1106 } 1107 1108 /* 1109 * Stateful write - use os internal file pointer to determine where to 1110 * write and update on successful completion. 1111 * 1112 * fp - pointer to file (pipe, socket, etc) to write to 1113 * buf - buffer to write 1114 * count - # of bytes to write 1115 * resid - pointer to count of unwritten bytes (if short write) 1116 * 1117 * Returns 0 on success errno on failure. 1118 */ 1119 int 1120 zfs_file_write(zfs_file_t *fp, const void *buf, size_t count, ssize_t *resid) 1121 { 1122 ssize_t rc; 1123 1124 rc = write(fp->f_fd, buf, count); 1125 if (rc < 0) 1126 return (errno); 1127 1128 if (resid) { 1129 *resid = count - rc; 1130 } else if (rc != count) { 1131 return (EIO); 1132 } 1133 1134 return (0); 1135 } 1136 1137 /* 1138 * Stateless write - os internal file pointer is not updated. 1139 * 1140 * fp - pointer to file (pipe, socket, etc) to write to 1141 * buf - buffer to write 1142 * count - # of bytes to write 1143 * off - file offset to write to (only valid for seekable types) 1144 * resid - pointer to count of unwritten bytes 1145 * 1146 * Returns 0 on success errno on failure. 1147 */ 1148 int 1149 zfs_file_pwrite(zfs_file_t *fp, const void *buf, 1150 size_t count, loff_t pos, ssize_t *resid) 1151 { 1152 ssize_t rc, split, done; 1153 int sectors; 1154 1155 /* 1156 * To simulate partial disk writes, we split writes into two 1157 * system calls so that the process can be killed in between. 1158 * This is used by ztest to simulate realistic failure modes. 1159 */ 1160 sectors = count >> SPA_MINBLOCKSHIFT; 1161 split = (sectors > 0 ? rand() % sectors : 0) << SPA_MINBLOCKSHIFT; 1162 rc = pwrite64(fp->f_fd, buf, split, pos); 1163 if (rc != -1) { 1164 done = rc; 1165 rc = pwrite64(fp->f_fd, (char *)buf + split, 1166 count - split, pos + split); 1167 } 1168 #ifdef __linux__ 1169 if (rc == -1 && errno == EINVAL) { 1170 /* 1171 * Under Linux, this most likely means an alignment issue 1172 * (memory or disk) due to O_DIRECT, so we abort() in order 1173 * to catch the offender. 1174 */ 1175 abort(); 1176 } 1177 #endif 1178 1179 if (rc < 0) 1180 return (errno); 1181 1182 done += rc; 1183 1184 if (resid) { 1185 *resid = count - done; 1186 } else if (done != count) { 1187 return (EIO); 1188 } 1189 1190 return (0); 1191 } 1192 1193 /* 1194 * Stateful read - use os internal file pointer to determine where to 1195 * read and update on successful completion. 1196 * 1197 * fp - pointer to file (pipe, socket, etc) to read from 1198 * buf - buffer to write 1199 * count - # of bytes to read 1200 * resid - pointer to count of unread bytes (if short read) 1201 * 1202 * Returns 0 on success errno on failure. 1203 */ 1204 int 1205 zfs_file_read(zfs_file_t *fp, void *buf, size_t count, ssize_t *resid) 1206 { 1207 int rc; 1208 1209 rc = read(fp->f_fd, buf, count); 1210 if (rc < 0) 1211 return (errno); 1212 1213 if (resid) { 1214 *resid = count - rc; 1215 } else if (rc != count) { 1216 return (EIO); 1217 } 1218 1219 return (0); 1220 } 1221 1222 /* 1223 * Stateless read - os internal file pointer is not updated. 1224 * 1225 * fp - pointer to file (pipe, socket, etc) to read from 1226 * buf - buffer to write 1227 * count - # of bytes to write 1228 * off - file offset to read from (only valid for seekable types) 1229 * resid - pointer to count of unwritten bytes (if short write) 1230 * 1231 * Returns 0 on success errno on failure. 1232 */ 1233 int 1234 zfs_file_pread(zfs_file_t *fp, void *buf, size_t count, loff_t off, 1235 ssize_t *resid) 1236 { 1237 ssize_t rc; 1238 1239 rc = pread64(fp->f_fd, buf, count, off); 1240 if (rc < 0) { 1241 #ifdef __linux__ 1242 /* 1243 * Under Linux, this most likely means an alignment issue 1244 * (memory or disk) due to O_DIRECT, so we abort() in order to 1245 * catch the offender. 1246 */ 1247 if (errno == EINVAL) 1248 abort(); 1249 #endif 1250 return (errno); 1251 } 1252 1253 if (fp->f_dump_fd != -1) { 1254 int status; 1255 1256 status = pwrite64(fp->f_dump_fd, buf, rc, off); 1257 ASSERT(status != -1); 1258 } 1259 1260 if (resid) { 1261 *resid = count - rc; 1262 } else if (rc != count) { 1263 return (EIO); 1264 } 1265 1266 return (0); 1267 } 1268 1269 /* 1270 * lseek - set / get file pointer 1271 * 1272 * fp - pointer to file (pipe, socket, etc) to read from 1273 * offp - value to seek to, returns current value plus passed offset 1274 * whence - see man pages for standard lseek whence values 1275 * 1276 * Returns 0 on success errno on failure (ESPIPE for non seekable types) 1277 */ 1278 int 1279 zfs_file_seek(zfs_file_t *fp, loff_t *offp, int whence) 1280 { 1281 loff_t rc; 1282 1283 rc = lseek(fp->f_fd, *offp, whence); 1284 if (rc < 0) 1285 return (errno); 1286 1287 *offp = rc; 1288 1289 return (0); 1290 } 1291 1292 /* 1293 * Get file attributes 1294 * 1295 * filp - file pointer 1296 * zfattr - pointer to file attr structure 1297 * 1298 * Currently only used for fetching size and file mode 1299 * 1300 * Returns 0 on success or error code of underlying getattr call on failure. 1301 */ 1302 int 1303 zfs_file_getattr(zfs_file_t *fp, zfs_file_attr_t *zfattr) 1304 { 1305 struct stat64 st; 1306 1307 if (fstat64_blk(fp->f_fd, &st) == -1) 1308 return (errno); 1309 1310 zfattr->zfa_size = st.st_size; 1311 zfattr->zfa_mode = st.st_mode; 1312 1313 return (0); 1314 } 1315 1316 /* 1317 * Sync file to disk 1318 * 1319 * filp - file pointer 1320 * flags - O_SYNC and or O_DSYNC 1321 * 1322 * Returns 0 on success or error code of underlying sync call on failure. 1323 */ 1324 int 1325 zfs_file_fsync(zfs_file_t *fp, int flags) 1326 { 1327 int rc; 1328 1329 rc = fsync(fp->f_fd); 1330 if (rc < 0) 1331 return (errno); 1332 1333 return (0); 1334 } 1335 1336 /* 1337 * fallocate - allocate or free space on disk 1338 * 1339 * fp - file pointer 1340 * mode (non-standard options for hole punching etc) 1341 * offset - offset to start allocating or freeing from 1342 * len - length to free / allocate 1343 * 1344 * OPTIONAL 1345 */ 1346 int 1347 zfs_file_fallocate(zfs_file_t *fp, int mode, loff_t offset, loff_t len) 1348 { 1349 #ifdef __linux__ 1350 return (fallocate(fp->f_fd, mode, offset, len)); 1351 #else 1352 return (EOPNOTSUPP); 1353 #endif 1354 } 1355 1356 /* 1357 * Request current file pointer offset 1358 * 1359 * fp - pointer to file 1360 * 1361 * Returns current file offset. 1362 */ 1363 loff_t 1364 zfs_file_off(zfs_file_t *fp) 1365 { 1366 return (lseek(fp->f_fd, SEEK_CUR, 0)); 1367 } 1368 1369 /* 1370 * unlink file 1371 * 1372 * path - fully qualified file path 1373 * 1374 * Returns 0 on success. 1375 * 1376 * OPTIONAL 1377 */ 1378 int 1379 zfs_file_unlink(const char *path) 1380 { 1381 return (remove(path)); 1382 } 1383 1384 /* 1385 * Get reference to file pointer 1386 * 1387 * fd - input file descriptor 1388 * fpp - pointer to file pointer 1389 * 1390 * Returns 0 on success EBADF on failure. 1391 * Unsupported in user space. 1392 */ 1393 int 1394 zfs_file_get(int fd, zfs_file_t **fpp) 1395 { 1396 abort(); 1397 1398 return (EOPNOTSUPP); 1399 } 1400 1401 /* 1402 * Drop reference to file pointer 1403 * 1404 * fd - input file descriptor 1405 * 1406 * Unsupported in user space. 1407 */ 1408 void 1409 zfs_file_put(int fd) 1410 { 1411 abort(); 1412 } 1413 1414 void 1415 zfsvfs_update_fromname(const char *oldname, const char *newname) 1416 { 1417 } 1418