lib/libzpool/kernel.c

   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  */
  24
  25 #include <assert.h>
  26 #include <fcntl.h>
  27 #include <poll.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <zlib.h>
  32 #include <sys/signal.h>
  33 #include <sys/spa.h>
  34 #include <sys/stat.h>
  35 #include <sys/processor.h>
  36 #include <sys/zfs_context.h>
  37 #include <sys/utsname.h>
  38 #include <sys/time.h>
  39 #include <sys/systeminfo.h>
  40
  41 /*
  42  * Emulation of kernel services in userland.
  43  */
  44
  45 int aok;
  46 uint64_t physmem;
  47 vnode_t *rootdir = (vnode_t *)0xabcd1234;
  48 char hw_serial[HW_HOSTID_LEN];
  49
  50 struct utsname utsname = {
  51         "userland", "libzpool", "1", "1", "na"
  52 };
  53
  54 /* this only exists to have its address taken */
  55 struct proc p0;
  56
  57 /*
  58  * =========================================================================
  59  * threads
  60  * =========================================================================
  61  */
  62
  63 pthread_cond_t kthread_cond = PTHREAD_COND_INITIALIZER;
  64 pthread_mutex_t kthread_lock = PTHREAD_MUTEX_INITIALIZER;
  65 pthread_key_t kthread_key;
  66 int kthread_nr = 0;
  67
  68 static void
  69 thread_init(void)
  70 {
  71         kthread_t *kt;
  72
  73         VERIFY3S(pthread_key_create(&kthread_key, NULL), ==, 0);
  74
  75         /* Create entry for primary kthread */
  76         kt = umem_zalloc(sizeof(kthread_t), UMEM_NOFAIL);
  77         kt->t_tid = pthread_self();
  78         kt->t_func = NULL;
  79
  80         VERIFY3S(pthread_setspecific(kthread_key, kt), ==, 0);
  81
  82         /* Only the main thread should be running at the moment */
  83         ASSERT3S(kthread_nr, ==, 0);
  84         kthread_nr = 1;
  85 }
  86
  87 static void
  88 thread_fini(void)
  89 {
  90         kthread_t *kt = curthread;
  91
  92         ASSERT(pthread_equal(kt->t_tid, pthread_self()));
  93         ASSERT3P(kt->t_func, ==, NULL);
  94
  95         umem_free(kt, sizeof(kthread_t));
  96
  97         /* Wait for all threads to exit via thread_exit() */
  98         VERIFY3S(pthread_mutex_lock(&kthread_lock), ==, 0);
  99
 100         kthread_nr--; /* Main thread is exiting */
 101
 102         while (kthread_nr > 0)
 103                 VERIFY3S(pthread_cond_wait(&kthread_cond, &kthread_lock), ==,
 104                     0);
 105
 106         ASSERT3S(kthread_nr, ==, 0);
 107         VERIFY3S(pthread_mutex_unlock(&kthread_lock), ==, 0);
 108
 109         VERIFY3S(pthread_key_delete(kthread_key), ==, 0);
 110 }
 111
 112 kthread_t *
 113 zk_thread_current(void)
 114 {
 115         kthread_t *kt = pthread_getspecific(kthread_key);
 116
 117         ASSERT3P(kt, !=, NULL);
 118
 119         return kt;
 120 }
 121
 122 void *
 123 zk_thread_helper(void *arg)
 124 {
 125         kthread_t *kt = (kthread_t *) arg;
 126
 127         VERIFY3S(pthread_setspecific(kthread_key, kt), ==, 0);
 128
 129         VERIFY3S(pthread_mutex_lock(&kthread_lock), ==, 0);
 130         kthread_nr++;
 131         VERIFY3S(pthread_mutex_unlock(&kthread_lock), ==, 0);
 132
 133         kt->t_tid = pthread_self();
 134         ((thread_func_arg_t) kt->t_func)(kt->t_arg);
 135
 136         /* Unreachable, thread must exit with thread_exit() */
 137         abort();
 138
 139         return NULL;
 140 }
 141
 142 kthread_t *
 143 zk_thread_create(caddr_t stk, size_t stksize, thread_func_t func, void *arg,
 144               size_t len, proc_t *pp, int state, pri_t pri, int detachstate)
 145 {
 146         kthread_t *kt;
 147         pthread_attr_t attr;
 148         size_t stack;
 149
 150         ASSERT3S(state & ~TS_RUN, ==, 0);
 151
 152         kt = umem_zalloc(sizeof(kthread_t), UMEM_NOFAIL);
 153         kt->t_func = func;
 154         kt->t_arg = arg;
 155
 156         /*
 157          * The Solaris kernel stack size is 24k for x86/x86_64.
 158          * The Linux kernel stack size is 8k for x86/x86_64.
 159          *
 160          * We reduce the default stack size in userspace, to ensure
 161          * we observe stack overruns in user space as well as in
 162          * kernel space. In practice we can't set the userspace stack
 163          * size to 8k because differences in stack usage between kernel
 164          * space and userspace could lead to spurious stack overflows
 165          * (especially when debugging is enabled). Nevertheless, we try
 166          * to set it to the lowest value that works (currently 8k*4).
 167          * PTHREAD_STACK_MIN is the minimum stack required for a NULL
 168          * procedure in user space and is added in to the stack
 169          * requirements.
 170          *
 171          * Some buggy NPTL threading implementations include the
 172          * guard area within the stack size allocations.  In
 173          * this case we allocate an extra page to account for the
 174          * guard area since we only have two pages of usable stack
 175          * on Linux.
 176          */
 177
 178         stack = PTHREAD_STACK_MIN + MAX(stksize, STACK_SIZE) * 4;
 179
 180         VERIFY3S(pthread_attr_init(&attr), ==, 0);
 181         VERIFY3S(pthread_attr_setstacksize(&attr, stack), ==, 0);
 182         VERIFY3S(pthread_attr_setguardsize(&attr, PAGESIZE), ==, 0);
 183         VERIFY3S(pthread_attr_setdetachstate(&attr, detachstate), ==, 0);
 184
 185         VERIFY3S(pthread_create(&kt->t_tid, &attr, &zk_thread_helper, kt),
 186             ==, 0);
 187
 188         VERIFY3S(pthread_attr_destroy(&attr), ==, 0);
 189
 190         return kt;
 191 }
 192
 193 void
 194 zk_thread_exit(void)
 195 {
 196         kthread_t *kt = curthread;
 197
 198         ASSERT(pthread_equal(kt->t_tid, pthread_self()));
 199
 200         umem_free(kt, sizeof(kthread_t));
 201
 202         pthread_mutex_lock(&kthread_lock);
 203         kthread_nr--;
 204         pthread_mutex_unlock(&kthread_lock);
 205
 206         pthread_cond_broadcast(&kthread_cond);
 207         pthread_exit((void *)TS_MAGIC);
 208 }
 209
 210 void
 211 zk_thread_join(kt_did_t tid)
 212 {
 213         void *ret;
 214
 215         pthread_join((pthread_t)tid, &ret);
 216         VERIFY3P(ret, ==, (void *)TS_MAGIC);
 217 }
 218
 219 /*
 220  * =========================================================================
 221  * kstats
 222  * =========================================================================
 223  */
 224 /*ARGSUSED*/
 225 kstat_t *
 226 kstat_create(char *module, int instance, char *name, char *class,
 227     uchar_t type, ulong_t ndata, uchar_t ks_flag)
 228 {
 229         return (NULL);
 230 }
 231
 232 /*ARGSUSED*/
 233 void
 234 kstat_install(kstat_t *ksp)
 235 {}
 236
 237 /*ARGSUSED*/
 238 void
 239 kstat_delete(kstat_t *ksp)
 240 {}
 241
 242 /*
 243  * =========================================================================
 244  * mutexes
 245  * =========================================================================
 246  */
 247
 248 void
 249 mutex_init(kmutex_t *mp, char *name, int type, void *cookie)
 250 {
 251         ASSERT3S(type, ==, MUTEX_DEFAULT);
 252         ASSERT3P(cookie, ==, NULL);
 253         mp->m_owner = MTX_INIT;
 254         mp->m_magic = MTX_MAGIC;
 255         VERIFY3S(pthread_mutex_init(&mp->m_lock, NULL), ==, 0);
 256 }
 257
 258 void
 259 mutex_destroy(kmutex_t *mp)
 260 {
 261         ASSERT3U(mp->m_magic, ==, MTX_MAGIC);
 262         ASSERT3P(mp->m_owner, ==, MTX_INIT);
 263         VERIFY3S(pthread_mutex_destroy(&(mp)->m_lock), ==, 0);
 264         mp->m_owner = MTX_DEST;
 265         mp->m_magic = 0;
 266 }
 267
 268 void
 269 mutex_enter(kmutex_t *mp)
 270 {
 271         ASSERT3U(mp->m_magic, ==, MTX_MAGIC);
 272         ASSERT3P(mp->m_owner, !=, MTX_DEST);
 273         ASSERT3P(mp->m_owner, !=, curthread);
 274         VERIFY3S(pthread_mutex_lock(&mp->m_lock), ==, 0);
 275         ASSERT3P(mp->m_owner, ==, MTX_INIT);
 276         mp->m_owner = curthread;
 277 }
 278
 279 int
 280 mutex_tryenter(kmutex_t *mp)
 281 {
 282         ASSERT3U(mp->m_magic, ==, MTX_MAGIC);
 283         ASSERT3P(mp->m_owner, !=, MTX_DEST);
 284         if (0 == pthread_mutex_trylock(&mp->m_lock)) {
 285                 ASSERT3P(mp->m_owner, ==, MTX_INIT);
 286                 mp->m_owner = curthread;
 287                 return (1);
 288         } else {
 289                 return (0);
 290         }
 291 }
 292
 293 void
 294 mutex_exit(kmutex_t *mp)
 295 {
 296         ASSERT3U(mp->m_magic, ==, MTX_MAGIC);
 297         ASSERT3P(mutex_owner(mp), ==, curthread);
 298         mp->m_owner = MTX_INIT;
 299         VERIFY3S(pthread_mutex_unlock(&mp->m_lock), ==, 0);
 300 }
 301
 302 void *
 303 mutex_owner(kmutex_t *mp)
 304 {
 305         ASSERT3U(mp->m_magic, ==, MTX_MAGIC);
 306         return (mp->m_owner);
 307 }
 308
 309 int
 310 mutex_held(kmutex_t *mp)
 311 {
 312         return (mp->m_owner == curthread);
 313 }
 314
 315 /*
 316  * =========================================================================
 317  * rwlocks
 318  * =========================================================================
 319  */
 320
 321 void
 322 rw_init(krwlock_t *rwlp, char *name, int type, void *arg)
 323 {
 324         ASSERT3S(type, ==, RW_DEFAULT);
 325         ASSERT3P(arg, ==, NULL);
 326         VERIFY3S(pthread_rwlock_init(&rwlp->rw_lock, NULL), ==, 0);
 327         rwlp->rw_owner = RW_INIT;
 328         rwlp->rw_wr_owner = RW_INIT;
 329         rwlp->rw_readers = 0;
 330         rwlp->rw_magic = RW_MAGIC;
 331 }
 332
 333 void
 334 rw_destroy(krwlock_t *rwlp)
 335 {
 336         ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC);
 337
 338         VERIFY3S(pthread_rwlock_destroy(&rwlp->rw_lock), ==, 0);
 339         rwlp->rw_magic = 0;
 340 }
 341
 342 void
 343 rw_enter(krwlock_t *rwlp, krw_t rw)
 344 {
 345         ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC);
 346         ASSERT3P(rwlp->rw_owner, !=, curthread);
 347         ASSERT3P(rwlp->rw_wr_owner, !=, curthread);
 348
 349         if (rw == RW_READER) {
 350                 VERIFY3S(pthread_rwlock_rdlock(&rwlp->rw_lock), ==, 0);
 351                 ASSERT3P(rwlp->rw_wr_owner, ==, RW_INIT);
 352
 353                 atomic_inc_uint(&rwlp->rw_readers);
 354         } else {
 355                 VERIFY3S(pthread_rwlock_wrlock(&rwlp->rw_lock), ==, 0);
 356                 ASSERT3P(rwlp->rw_wr_owner, ==, RW_INIT);
 357                 ASSERT3U(rwlp->rw_readers, ==, 0);
 358
 359                 rwlp->rw_wr_owner = curthread;
 360         }
 361
 362         rwlp->rw_owner = curthread;
 363 }
 364
 365 void
 366 rw_exit(krwlock_t *rwlp)
 367 {
 368         ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC);
 369         ASSERT(RW_LOCK_HELD(rwlp));
 370
 371         if (RW_READ_HELD(rwlp))
 372                 atomic_dec_uint(&rwlp->rw_readers);
 373         else
 374                 rwlp->rw_wr_owner = RW_INIT;
 375
 376         rwlp->rw_owner = RW_INIT;
 377         VERIFY3S(pthread_rwlock_unlock(&rwlp->rw_lock), ==, 0);
 378 }
 379
 380 int
 381 rw_tryenter(krwlock_t *rwlp, krw_t rw)
 382 {
 383         int rv;
 384
 385         ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC);
 386
 387         if (rw == RW_READER)
 388                 rv = pthread_rwlock_tryrdlock(&rwlp->rw_lock);
 389         else
 390                 rv = pthread_rwlock_trywrlock(&rwlp->rw_lock);
 391
 392         if (rv == 0) {
 393                 ASSERT3P(rwlp->rw_wr_owner, ==, RW_INIT);
 394
 395                 if (rw == RW_READER)
 396                         atomic_inc_uint(&rwlp->rw_readers);
 397                 else {
 398                         ASSERT3U(rwlp->rw_readers, ==, 0);
 399                         rwlp->rw_wr_owner = curthread;
 400                 }
 401
 402                 rwlp->rw_owner = curthread;
 403                 return (1);
 404         }
 405
 406         VERIFY3S(rv, ==, EBUSY);
 407
 408         return (0);
 409 }
 410
 411 int
 412 rw_tryupgrade(krwlock_t *rwlp)
 413 {
 414         ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC);
 415
 416         return (0);
 417 }
 418
 419 /*
 420  * =========================================================================
 421  * condition variables
 422  * =========================================================================
 423  */
 424
 425 void
 426 cv_init(kcondvar_t *cv, char *name, int type, void *arg)
 427 {
 428         ASSERT3S(type, ==, CV_DEFAULT);
 429         cv->cv_magic = CV_MAGIC;
 430         VERIFY3S(pthread_cond_init(&cv->cv, NULL), ==, 0);
 431 }
 432
 433 void
 434 cv_destroy(kcondvar_t *cv)
 435 {
 436         ASSERT3U(cv->cv_magic, ==, CV_MAGIC);
 437         VERIFY3S(pthread_cond_destroy(&cv->cv), ==, 0);
 438         cv->cv_magic = 0;
 439 }
 440
 441 void
 442 cv_wait(kcondvar_t *cv, kmutex_t *mp)
 443 {
 444         ASSERT3U(cv->cv_magic, ==, CV_MAGIC);
 445         ASSERT3P(mutex_owner(mp), ==, curthread);
 446         mp->m_owner = MTX_INIT;
 447         int ret = pthread_cond_wait(&cv->cv, &mp->m_lock);
 448         if (ret != 0)
 449                 VERIFY3S(ret, ==, EINTR);
 450         mp->m_owner = curthread;
 451 }
 452
 453 clock_t
 454 cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime)
 455 {
 456         int error;
 457         struct timeval tv;
 458         timestruc_t ts;
 459         clock_t delta;
 460
 461         ASSERT3U(cv->cv_magic, ==, CV_MAGIC);
 462
 463 top:
 464         delta = abstime - ddi_get_lbolt();
 465         if (delta <= 0)
 466                 return (-1);
 467
 468         VERIFY(gettimeofday(&tv, NULL) == 0);
 469
 470         ts.tv_sec = tv.tv_sec + delta / hz;
 471         ts.tv_nsec = tv.tv_usec * 1000 + (delta % hz) * (NANOSEC / hz);
 472         if (ts.tv_nsec >= NANOSEC) {
 473                 ts.tv_sec++;
 474                 ts.tv_nsec -= NANOSEC;
 475         }
 476
 477         ASSERT3P(mutex_owner(mp), ==, curthread);
 478         mp->m_owner = MTX_INIT;
 479         error = pthread_cond_timedwait(&cv->cv, &mp->m_lock, &ts);
 480         mp->m_owner = curthread;
 481
 482         if (error == ETIMEDOUT)
 483                 return (-1);
 484
 485         if (error == EINTR)
 486                 goto top;
 487
 488         VERIFY3S(error, ==, 0);
 489
 490         return (1);
 491 }
 492
 493 void
 494 cv_signal(kcondvar_t *cv)
 495 {
 496         ASSERT3U(cv->cv_magic, ==, CV_MAGIC);
 497         VERIFY3S(pthread_cond_signal(&cv->cv), ==, 0);
 498 }
 499
 500 void
 501 cv_broadcast(kcondvar_t *cv)
 502 {
 503         ASSERT3U(cv->cv_magic, ==, CV_MAGIC);
 504         VERIFY3S(pthread_cond_broadcast(&cv->cv), ==, 0);
 505 }
 506
 507 /*
 508  * =========================================================================
 509  * vnode operations
 510  * =========================================================================
 511  */
 512 /*
 513  * Note: for the xxxat() versions of these functions, we assume that the
 514  * starting vp is always rootdir (which is true for spa_directory.c, the only
 515  * ZFS consumer of these interfaces).  We assert this is true, and then emulate
 516  * them by adding '/' in front of the path.
 517  */
 518
 519 /*ARGSUSED*/
 520 int
 521 vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3)
 522 {
 523         int fd;
 524         vnode_t *vp;
 525         int old_umask;
 526         char *realpath;
 527         struct stat64 st;
 528         int err;
 529
 530         realpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
 531
 532         /*
 533          * If we're accessing a real disk from userland, we need to use
 534          * the character interface to avoid caching.  This is particularly
 535          * important if we're trying to look at a real in-kernel storage
 536          * pool from userland, e.g. via zdb, because otherwise we won't
 537          * see the changes occurring under the segmap cache.
 538          * On the other hand, the stupid character device returns zero
 539          * for its size.  So -- gag -- we open the block device to get
 540          * its size, and remember it for subsequent VOP_GETATTR().
 541          */
 542 #if defined(__sun__) || defined(__sun)
 543         if (strncmp(path, "/dev/", 5) == 0) {
 544 #else
 545         if (0) {
 546 #endif
 547                 char *dsk;
 548                 fd = open64(path, O_RDONLY);
 549                 if (fd == -1) {
 550                         err = errno;
 551                         free(realpath);
 552                         return (err);
 553                 }
 554                 if (fstat64(fd, &st) == -1) {
 555                         err = errno;
 556                         close(fd);
 557                         free(realpath);
 558                         return (err);
 559                 }
 560                 close(fd);
 561                 (void) sprintf(realpath, "%s", path);
 562                 dsk = strstr(path, "/dsk/");
 563                 if (dsk != NULL)
 564                         (void) sprintf(realpath + (dsk - path) + 1, "r%s",
 565                             dsk + 1);
 566         } else {
 567                 (void) sprintf(realpath, "%s", path);
 568                 if (!(flags & FCREAT) && stat64(realpath, &st) == -1) {
 569                         err = errno;
 570                         free(realpath);
 571                         return (err);
 572                 }
 573         }
 574
 575         if (!(flags & FCREAT) && S_ISBLK(st.st_mode)) {
 576 #ifdef __linux__
 577                 flags |= O_DIRECT;
 578 #endif
 579                 /* We shouldn't be writing to block devices in userspace */
 580                 VERIFY(!(flags & FWRITE));
 581         }
 582
 583         if (flags & FCREAT)
 584                 old_umask = umask(0);
 585
 586         /*
 587          * The construct 'flags - FREAD' conveniently maps combinations of
 588          * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR.
 589          */
 590         fd = open64(realpath, flags - FREAD, mode);
 591         free(realpath);
 592
 593         if (flags & FCREAT)
 594                 (void) umask(old_umask);
 595
 596         if (fd == -1)
 597                 return (errno);
 598
 599         if (fstat64_blk(fd, &st) == -1) {
 600                 err = errno;
 601                 close(fd);
 602                 return (err);
 603         }
 604
 605         (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
 606
 607         *vpp = vp = umem_zalloc(sizeof (vnode_t), UMEM_NOFAIL);
 608
 609         vp->v_fd = fd;
 610         vp->v_size = st.st_size;
 611         vp->v_path = spa_strdup(path);
 612
 613         return (0);
 614 }
 615
 616 /*ARGSUSED*/
 617 int
 618 vn_openat(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2,
 619     int x3, vnode_t *startvp, int fd)
 620 {
 621         char *realpath = umem_alloc(strlen(path) + 2, UMEM_NOFAIL);
 622         int ret;
 623
 624         ASSERT(startvp == rootdir);
 625         (void) sprintf(realpath, "/%s", path);
 626
 627         /* fd ignored for now, need if want to simulate nbmand support */
 628         ret = vn_open(realpath, x1, flags, mode, vpp, x2, x3);
 629
 630         umem_free(realpath, strlen(path) + 2);
 631
 632         return (ret);
 633 }
 634
 635 /*ARGSUSED*/
 636 int
 637 vn_rdwr(int uio, vnode_t *vp, void *addr, ssize_t len, offset_t offset,
 638         int x1, int x2, rlim64_t x3, void *x4, ssize_t *residp)
 639 {
 640         ssize_t rc, done = 0, split;
 641
 642         if (uio == UIO_READ) {
 643                 rc = pread64(vp->v_fd, addr, len, offset);
 644         } else {
 645                 /*
 646                  * To simulate partial disk writes, we split writes into two
 647                  * system calls so that the process can be killed in between.
 648                  */
 649                 int sectors = len >> SPA_MINBLOCKSHIFT;
 650                 split = (sectors > 0 ? rand() % sectors : 0) <<
 651                     SPA_MINBLOCKSHIFT;
 652                 rc = pwrite64(vp->v_fd, addr, split, offset);
 653                 if (rc != -1) {
 654                         done = rc;
 655                         rc = pwrite64(vp->v_fd, (char *)addr + split,
 656                             len - split, offset + split);
 657                 }
 658         }
 659
 660 #ifdef __linux__
 661         if (rc == -1 && errno == EINVAL) {
 662                 /*
 663                  * Under Linux, this most likely means an alignment issue
 664                  * (memory or disk) due to O_DIRECT, so we abort() in order to
 665                  * catch the offender.
 666                  */
 667                  abort();
 668         }
 669 #endif
 670         if (rc == -1)
 671                 return (errno);
 672
 673         done += rc;
 674
 675         if (residp)
 676                 *residp = len - done;
 677         else if (done != len)
 678                 return (EIO);
 679         return (0);
 680 }
 681
 682 void
 683 vn_close(vnode_t *vp)
 684 {
 685         close(vp->v_fd);
 686         spa_strfree(vp->v_path);
 687         umem_free(vp, sizeof (vnode_t));
 688 }
 689
 690 /*
 691  * At a minimum we need to update the size since vdev_reopen()
 692  * will no longer call vn_openat().
 693  */
 694 int
 695 fop_getattr(vnode_t *vp, vattr_t *vap)
 696 {
 697         struct stat64 st;
 698         int err;
 699
 700         if (fstat64_blk(vp->v_fd, &st) == -1) {
 701                 err = errno;
 702                 close(vp->v_fd);
 703                 return (err);
 704         }
 705
 706         vap->va_size = st.st_size;
 707         return (0);
 708 }
 709
 710 /*
 711  * =========================================================================
 712  * Figure out which debugging statements to print
 713  * =========================================================================
 714  */
 715
 716 static char *dprintf_string;
 717 static int dprintf_print_all;
 718
 719 int
 720 dprintf_find_string(const char *string)
 721 {
 722         char *tmp_str = dprintf_string;
 723         int len = strlen(string);
 724
 725         /*
 726          * Find out if this is a string we want to print.
 727          * String format: file1.c,function_name1,file2.c,file3.c
 728          */
 729
 730         while (tmp_str != NULL) {
 731                 if (strncmp(tmp_str, string, len) == 0 &&
 732                     (tmp_str[len] == ',' || tmp_str[len] == '\0'))
 733                         return (1);
 734                 tmp_str = strchr(tmp_str, ',');
 735                 if (tmp_str != NULL)
 736                         tmp_str++; /* Get rid of , */
 737         }
 738         return (0);
 739 }
 740
 741 void
 742 dprintf_setup(int *argc, char **argv)
 743 {
 744         int i, j;
 745
 746         /*
 747          * Debugging can be specified two ways: by setting the
 748          * environment variable ZFS_DEBUG, or by including a
 749          * "debug=..."  argument on the command line.  The command
 750          * line setting overrides the environment variable.
 751          */
 752
 753         for (i = 1; i < *argc; i++) {
 754                 int len = strlen("debug=");
 755                 /* First look for a command line argument */
 756                 if (strncmp("debug=", argv[i], len) == 0) {
 757                         dprintf_string = argv[i] + len;
 758                         /* Remove from args */
 759                         for (j = i; j < *argc; j++)
 760                                 argv[j] = argv[j+1];
 761                         argv[j] = NULL;
 762                         (*argc)--;
 763                 }
 764         }
 765
 766         if (dprintf_string == NULL) {
 767                 /* Look for ZFS_DEBUG environment variable */
 768                 dprintf_string = getenv("ZFS_DEBUG");
 769         }
 770
 771         /*
 772          * Are we just turning on all debugging?
 773          */
 774         if (dprintf_find_string("on"))
 775                 dprintf_print_all = 1;
 776 }
 777
 778 /*
 779  * =========================================================================
 780  * debug printfs
 781  * =========================================================================
 782  */
 783 void
 784 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
 785 {
 786         const char *newfile;
 787         va_list adx;
 788
 789         /*
 790          * Get rid of annoying "../common/" prefix to filename.
 791          */
 792         newfile = strrchr(file, '/');
 793         if (newfile != NULL) {
 794                 newfile = newfile + 1; /* Get rid of leading / */
 795         } else {
 796                 newfile = file;
 797         }
 798
 799         if (dprintf_print_all ||
 800             dprintf_find_string(newfile) ||
 801             dprintf_find_string(func)) {
 802                 /* Print out just the function name if requested */
 803                 flockfile(stdout);
 804                 if (dprintf_find_string("pid"))
 805                         (void) printf("%d ", getpid());
 806                 if (dprintf_find_string("tid"))
 807                         (void) printf("%u ", (uint_t) pthread_self());
 808                 if (dprintf_find_string("cpu"))
 809                         (void) printf("%u ", getcpuid());
 810                 if (dprintf_find_string("time"))
 811                         (void) printf("%llu ", gethrtime());
 812                 if (dprintf_find_string("long"))
 813                         (void) printf("%s, line %d: ", newfile, line);
 814                 (void) printf("%s: ", func);
 815                 va_start(adx, fmt);
 816                 (void) vprintf(fmt, adx);
 817                 va_end(adx);
 818                 funlockfile(stdout);
 819         }
 820 }
 821
 822 /*
 823  * =========================================================================
 824  * cmn_err() and panic()
 825  * =========================================================================
 826  */
 827 static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" };
 828 static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" };
 829
 830 void
 831 vpanic(const char *fmt, va_list adx)
 832 {
 833         (void) fprintf(stderr, "error: ");
 834         (void) vfprintf(stderr, fmt, adx);
 835         (void) fprintf(stderr, "\n");
 836
 837         abort();        /* think of it as a "user-level crash dump" */
 838 }
 839
 840 void
 841 panic(const char *fmt, ...)
 842 {
 843         va_list adx;
 844
 845         va_start(adx, fmt);
 846         vpanic(fmt, adx);
 847         va_end(adx);
 848 }
 849
 850 void
 851 vcmn_err(int ce, const char *fmt, va_list adx)
 852 {
 853         if (ce == CE_PANIC)
 854                 vpanic(fmt, adx);
 855         if (ce != CE_NOTE) {    /* suppress noise in userland stress testing */
 856                 (void) fprintf(stderr, "%s", ce_prefix[ce]);
 857                 (void) vfprintf(stderr, fmt, adx);
 858                 (void) fprintf(stderr, "%s", ce_suffix[ce]);
 859         }
 860 }
 861
 862 /*PRINTFLIKE2*/
 863 void
 864 cmn_err(int ce, const char *fmt, ...)
 865 {
 866         va_list adx;
 867
 868         va_start(adx, fmt);
 869         vcmn_err(ce, fmt, adx);
 870         va_end(adx);
 871 }
 872
 873 /*
 874  * =========================================================================
 875  * kobj interfaces
 876  * =========================================================================
 877  */
 878 struct _buf *
 879 kobj_open_file(char *name)
 880 {
 881         struct _buf *file;
 882         vnode_t *vp;
 883
 884         /* set vp as the _fd field of the file */
 885         if (vn_openat(name, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0, rootdir,
 886             -1) != 0)
 887                 return ((void *)-1UL);
 888
 889         file = umem_zalloc(sizeof (struct _buf), UMEM_NOFAIL);
 890         file->_fd = (intptr_t)vp;
 891         return (file);
 892 }
 893
 894 int
 895 kobj_read_file(struct _buf *file, char *buf, unsigned size, unsigned off)
 896 {
 897         ssize_t resid;
 898
 899         vn_rdwr(UIO_READ, (vnode_t *)file->_fd, buf, size, (offset_t)off,
 900             UIO_SYSSPACE, 0, 0, 0, &resid);
 901
 902         return (size - resid);
 903 }
 904
 905 void
 906 kobj_close_file(struct _buf *file)
 907 {
 908         vn_close((vnode_t *)file->_fd);
 909         umem_free(file, sizeof (struct _buf));
 910 }
 911
 912 int
 913 kobj_get_filesize(struct _buf *file, uint64_t *size)
 914 {
 915         struct stat64 st;
 916         vnode_t *vp = (vnode_t *)file->_fd;
 917
 918         if (fstat64(vp->v_fd, &st) == -1) {
 919                 vn_close(vp);
 920                 return (errno);
 921         }
 922         *size = st.st_size;
 923         return (0);
 924 }
 925
 926 /*
 927  * =========================================================================
 928  * misc routines
 929  * =========================================================================
 930  */
 931
 932 void
 933 delay(clock_t ticks)
 934 {
 935         poll(0, 0, ticks * (1000 / hz));
 936 }
 937
 938 /*
 939  * Find highest one bit set.
 940  *      Returns bit number + 1 of highest bit that is set, otherwise returns 0.
 941  * High order bit is 31 (or 63 in _LP64 kernel).
 942  */
 943 int
 944 highbit(ulong_t i)
 945 {
 946         register int h = 1;
 947
 948         if (i == 0)
 949                 return (0);
 950 #ifdef _LP64
 951         if (i & 0xffffffff00000000ul) {
 952                 h += 32; i >>= 32;
 953         }
 954 #endif
 955         if (i & 0xffff0000) {
 956                 h += 16; i >>= 16;
 957         }
 958         if (i & 0xff00) {
 959                 h += 8; i >>= 8;
 960         }
 961         if (i & 0xf0) {
 962                 h += 4; i >>= 4;
 963         }
 964         if (i & 0xc) {
 965                 h += 2; i >>= 2;
 966         }
 967         if (i & 0x2) {
 968                 h += 1;
 969         }
 970         return (h);
 971 }
 972
 973 static int random_fd = -1, urandom_fd = -1;
 974
 975 static int
 976 random_get_bytes_common(uint8_t *ptr, size_t len, int fd)
 977 {
 978         size_t resid = len;
 979         ssize_t bytes;
 980
 981         ASSERT(fd != -1);
 982
 983         while (resid != 0) {
 984                 bytes = read(fd, ptr, resid);
 985                 ASSERT3S(bytes, >=, 0);
 986                 ptr += bytes;
 987                 resid -= bytes;
 988         }
 989
 990         return (0);
 991 }
 992
 993 int
 994 random_get_bytes(uint8_t *ptr, size_t len)
 995 {
 996         return (random_get_bytes_common(ptr, len, random_fd));
 997 }
 998
 999 int
1000 random_get_pseudo_bytes(uint8_t *ptr, size_t len)
1001 {
1002         return (random_get_bytes_common(ptr, len, urandom_fd));
1003 }
1004
1005 int
1006 ddi_strtoul(const char *hw_serial, char **nptr, int base, unsigned long *result)
1007 {
1008         char *end;
1009
1010         *result = strtoul(hw_serial, &end, base);
1011         if (*result == 0)
1012                 return (errno);
1013         return (0);
1014 }
1015
1016 int
1017 ddi_strtoull(const char *str, char **nptr, int base, u_longlong_t *result)
1018 {
1019         char *end;
1020
1021         *result = strtoull(str, &end, base);
1022         if (*result == 0)
1023                 return (errno);
1024         return (0);
1025 }
1026
1027 /*
1028  * =========================================================================
1029  * kernel emulation setup & teardown
1030  * =========================================================================
1031  */
1032 static int
1033 umem_out_of_memory(void)
1034 {
1035         char errmsg[] = "out of memory -- generating core dump\n";
1036
1037         (void) fprintf(stderr, "%s", errmsg);
1038         abort();
1039         return (0);
1040 }
1041
1042 void
1043 kernel_init(int mode)
1044 {
1045         umem_nofail_callback(umem_out_of_memory);
1046
1047         physmem = sysconf(_SC_PHYS_PAGES);
1048
1049         dprintf("physmem = %llu pages (%.2f GB)\n", physmem,
1050             (double)physmem * sysconf(_SC_PAGE_SIZE) / (1ULL << 30));
1051
1052         (void) snprintf(hw_serial, sizeof (hw_serial), "%ld",
1053             (mode & FWRITE) ? gethostid() : 0);
1054
1055         VERIFY((random_fd = open("/dev/random", O_RDONLY)) != -1);
1056         VERIFY((urandom_fd = open("/dev/urandom", O_RDONLY)) != -1);
1057
1058         thread_init();
1059         system_taskq_init();
1060
1061         spa_init(mode);
1062 }
1063
1064 void
1065 kernel_fini(void)
1066 {
1067         spa_fini();
1068
1069         system_taskq_fini();
1070         thread_fini();
1071
1072         close(random_fd);
1073         close(urandom_fd);
1074
1075         random_fd = -1;
1076         urandom_fd = -1;
1077 }
1078
1079 uid_t
1080 crgetuid(cred_t *cr)
1081 {
1082         return (0);
1083 }
1084
1085 gid_t
1086 crgetgid(cred_t *cr)
1087 {
1088         return (0);
1089 }
1090
1091 int
1092 crgetngroups(cred_t *cr)
1093 {
1094         return (0);
1095 }
1096
1097 gid_t *
1098 crgetgroups(cred_t *cr)
1099 {
1100         return (NULL);
1101 }
1102
1103 int
1104 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
1105 {
1106         return (0);
1107 }
1108
1109 int
1110 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
1111 {
1112         return (0);
1113 }
1114
1115 int
1116 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
1117 {
1118         return (0);
1119 }
1120
1121 ksiddomain_t *
1122 ksid_lookupdomain(const char *dom)
1123 {
1124         ksiddomain_t *kd;
1125
1126         kd = umem_zalloc(sizeof (ksiddomain_t), UMEM_NOFAIL);
1127         kd->kd_name = spa_strdup(dom);
1128         return (kd);
1129 }
1130
1131 void
1132 ksiddomain_rele(ksiddomain_t *ksid)
1133 {
1134         spa_strfree(ksid->kd_name);
1135         umem_free(ksid, sizeof (ksiddomain_t));
1136 }
1137
1138 char *
1139 kmem_vasprintf(const char *fmt, va_list adx)
1140 {
1141         char *buf = NULL;
1142         va_list adx_copy;
1143
1144         va_copy(adx_copy, adx);
1145         VERIFY(vasprintf(&buf, fmt, adx_copy) != -1);
1146         va_end(adx_copy);
1147
1148         return (buf);
1149 }
1150
1151 char *
1152 kmem_asprintf(const char *fmt, ...)
1153 {
1154         char *buf = NULL;
1155         va_list adx;
1156
1157         va_start(adx, fmt);
1158         VERIFY(vasprintf(&buf, fmt, adx) != -1);
1159         va_end(adx);
1160
1161         return (buf);
1162 }
1163
1164 /* ARGSUSED */
1165 int
1166 zfs_onexit_fd_hold(int fd, minor_t *minorp)
1167 {
1168         *minorp = 0;
1169         return (0);
1170 }
1171
1172 /* ARGSUSED */
1173 void
1174 zfs_onexit_fd_rele(int fd)
1175 {
1176 }
1177
1178 /* ARGSUSED */
1179 int
1180 zfs_onexit_add_cb(minor_t minor, void (*func)(void *), void *data,
1181     uint64_t *action_handle)
1182 {
1183         return (0);
1184 }
1185
1186 /* ARGSUSED */
1187 int
1188 zfs_onexit_del_cb(minor_t minor, uint64_t action_handle, boolean_t fire)
1189 {
1190         return (0);
1191 }
1192
1193 /* ARGSUSED */
1194 int
1195 zfs_onexit_cb_data(minor_t minor, uint64_t action_handle, void **data)
1196 {
1197         return (0);
1198 }