X-Git-Url: https://git.camperquake.de/gitweb.cgi?a=blobdiff_plain;f=lib%2Flibzpool%2Fkernel.c;h=f7aeeb440c0696d27f46f3ebf1fc48c0cafe6509;hb=a4914d38a794915c774670307d6f61480eba2046;hp=f323bf60b099051abaa378a974a68e9bd4bd7d53;hpb=572e285762521df27fe5b026f409ba1a21abb7ac;p=zfs.git diff --git a/lib/libzpool/kernel.c b/lib/libzpool/kernel.c index f323bf6..f7aeeb4 100644 --- a/lib/libzpool/kernel.c +++ b/lib/libzpool/kernel.c @@ -29,12 +29,13 @@ #include #include #include +#include #include #include #include #include -#include #include +#include #include /* @@ -58,16 +59,161 @@ struct proc p0; * threads * ========================================================================= */ -/*ARGSUSED*/ + +pthread_cond_t kthread_cond = PTHREAD_COND_INITIALIZER; +pthread_mutex_t kthread_lock = PTHREAD_MUTEX_INITIALIZER; +pthread_key_t kthread_key; +int kthread_nr = 0; + +static void +thread_init(void) +{ + kthread_t *kt; + + VERIFY3S(pthread_key_create(&kthread_key, NULL), ==, 0); + + /* Create entry for primary kthread */ + kt = umem_zalloc(sizeof(kthread_t), UMEM_NOFAIL); + kt->t_tid = pthread_self(); + kt->t_func = NULL; + + VERIFY3S(pthread_setspecific(kthread_key, kt), ==, 0); + + /* Only the main thread should be running at the moment */ + ASSERT3S(kthread_nr, ==, 0); + kthread_nr = 1; +} + +static void +thread_fini(void) +{ + kthread_t *kt = curthread; + + ASSERT(pthread_equal(kt->t_tid, pthread_self())); + ASSERT3P(kt->t_func, ==, NULL); + + umem_free(kt, sizeof(kthread_t)); + + /* Wait for all threads to exit via thread_exit() */ + VERIFY3S(pthread_mutex_lock(&kthread_lock), ==, 0); + + kthread_nr--; /* Main thread is exiting */ + + while (kthread_nr > 0) + VERIFY3S(pthread_cond_wait(&kthread_cond, &kthread_lock), ==, + 0); + + ASSERT3S(kthread_nr, ==, 0); + VERIFY3S(pthread_mutex_unlock(&kthread_lock), ==, 0); + + VERIFY3S(pthread_key_delete(kthread_key), ==, 0); +} + +kthread_t * +zk_thread_current(void) +{ + kthread_t *kt = pthread_getspecific(kthread_key); + + ASSERT3P(kt, !=, NULL); + + return kt; +} + +void * +zk_thread_helper(void *arg) +{ + kthread_t *kt = (kthread_t *) arg; + + VERIFY3S(pthread_setspecific(kthread_key, kt), ==, 0); + + VERIFY3S(pthread_mutex_lock(&kthread_lock), ==, 0); + kthread_nr++; + VERIFY3S(pthread_mutex_unlock(&kthread_lock), ==, 0); + + kt->t_tid = pthread_self(); + ((thread_func_arg_t) kt->t_func)(kt->t_arg); + + /* Unreachable, thread must exit with thread_exit() */ + abort(); + + return NULL; +} + kthread_t * -zk_thread_create(void (*func)(), void *arg) +zk_thread_create(caddr_t stk, size_t stksize, thread_func_t func, void *arg, + size_t len, proc_t *pp, int state, pri_t pri, int detachstate) { - thread_t tid; + kthread_t *kt; + pthread_attr_t attr; + size_t stack; + + ASSERT3S(state & ~TS_RUN, ==, 0); + + kt = umem_zalloc(sizeof(kthread_t), UMEM_NOFAIL); + kt->t_func = func; + kt->t_arg = arg; + + /* + * The Solaris kernel stack size is 24k for x86/x86_64. + * The Linux kernel stack size is 8k for x86/x86_64. + * + * We reduce the default stack size in userspace, to ensure + * we observe stack overruns in user space as well as in + * kernel space. In practice we can't set the userspace stack + * size to 8k because differences in stack usage between kernel + * space and userspace could lead to spurious stack overflows + * (especially when debugging is enabled). Nevertheless, we try + * to set it to the lowest value that works (currently 8k*4). + * PTHREAD_STACK_MIN is the minimum stack required for a NULL + * procedure in user space and is added in to the stack + * requirements. + * + * Some buggy NPTL threading implementations include the + * guard area within the stack size allocations. In + * this case we allocate an extra page to account for the + * guard area since we only have two pages of usable stack + * on Linux. + */ + + stack = PTHREAD_STACK_MIN + MAX(stksize, STACK_SIZE) * 4; - VERIFY(thr_create(0, 0, (void *(*)(void *))func, arg, THR_DETACHED, - &tid) == 0); + VERIFY3S(pthread_attr_init(&attr), ==, 0); + VERIFY3S(pthread_attr_setstacksize(&attr, stack), ==, 0); + VERIFY3S(pthread_attr_setguardsize(&attr, PAGESIZE), ==, 0); + VERIFY3S(pthread_attr_setdetachstate(&attr, detachstate), ==, 0); - return ((void *)(uintptr_t)tid); + VERIFY3S(pthread_create(&kt->t_tid, &attr, &zk_thread_helper, kt), + ==, 0); + + VERIFY3S(pthread_attr_destroy(&attr), ==, 0); + + return kt; +} + +void +zk_thread_exit(void) +{ + kthread_t *kt = curthread; + + ASSERT(pthread_equal(kt->t_tid, pthread_self())); + + umem_free(kt, sizeof(kthread_t)); + + pthread_mutex_lock(&kthread_lock); + kthread_nr--; + pthread_mutex_unlock(&kthread_lock); + + pthread_cond_broadcast(&kthread_cond); + pthread_exit((void *)TS_MAGIC); +} + +void +zk_thread_join(kt_did_t tid) +{ + void *ret; + + pthread_join((pthread_t)tid, &ret); + VERIFY3P(ret, ==, (void *)TS_MAGIC); } /* @@ -98,42 +244,45 @@ kstat_delete(kstat_t *ksp) * mutexes * ========================================================================= */ + void -zmutex_init(kmutex_t *mp) +mutex_init(kmutex_t *mp, char *name, int type, void *cookie) { - mp->m_owner = NULL; - mp->initialized = B_TRUE; - (void) _mutex_init(&mp->m_lock, USYNC_THREAD, NULL); + ASSERT3S(type, ==, MUTEX_DEFAULT); + ASSERT3P(cookie, ==, NULL); + mp->m_owner = MTX_INIT; + mp->m_magic = MTX_MAGIC; + VERIFY3S(pthread_mutex_init(&mp->m_lock, NULL), ==, 0); } void -zmutex_destroy(kmutex_t *mp) +mutex_destroy(kmutex_t *mp) { - ASSERT(mp->initialized == B_TRUE); - ASSERT(mp->m_owner == NULL); - (void) _mutex_destroy(&(mp)->m_lock); - mp->m_owner = (void *)-1UL; - mp->initialized = B_FALSE; + ASSERT3U(mp->m_magic, ==, MTX_MAGIC); + ASSERT3P(mp->m_owner, ==, MTX_INIT); + VERIFY3S(pthread_mutex_destroy(&(mp)->m_lock), ==, 0); + mp->m_owner = MTX_DEST; + mp->m_magic = 0; } void mutex_enter(kmutex_t *mp) { - ASSERT(mp->initialized == B_TRUE); - ASSERT(mp->m_owner != (void *)-1UL); - ASSERT(mp->m_owner != curthread); - VERIFY(mutex_lock(&mp->m_lock) == 0); - ASSERT(mp->m_owner == NULL); + ASSERT3U(mp->m_magic, ==, MTX_MAGIC); + ASSERT3P(mp->m_owner, !=, MTX_DEST); + ASSERT3P(mp->m_owner, !=, curthread); + VERIFY3S(pthread_mutex_lock(&mp->m_lock), ==, 0); + ASSERT3P(mp->m_owner, ==, MTX_INIT); mp->m_owner = curthread; } int mutex_tryenter(kmutex_t *mp) { - ASSERT(mp->initialized == B_TRUE); - ASSERT(mp->m_owner != (void *)-1UL); - if (0 == mutex_trylock(&mp->m_lock)) { - ASSERT(mp->m_owner == NULL); + ASSERT3U(mp->m_magic, ==, MTX_MAGIC); + ASSERT3P(mp->m_owner, !=, MTX_DEST); + if (0 == pthread_mutex_trylock(&mp->m_lock)) { + ASSERT3P(mp->m_owner, ==, MTX_INIT); mp->m_owner = curthread; return (1); } else { @@ -144,53 +293,71 @@ mutex_tryenter(kmutex_t *mp) void mutex_exit(kmutex_t *mp) { - ASSERT(mp->initialized == B_TRUE); - ASSERT(mutex_owner(mp) == curthread); - mp->m_owner = NULL; - VERIFY(mutex_unlock(&mp->m_lock) == 0); + ASSERT3U(mp->m_magic, ==, MTX_MAGIC); + ASSERT3P(mutex_owner(mp), ==, curthread); + mp->m_owner = MTX_INIT; + VERIFY3S(pthread_mutex_unlock(&mp->m_lock), ==, 0); } void * mutex_owner(kmutex_t *mp) { - ASSERT(mp->initialized == B_TRUE); + ASSERT3U(mp->m_magic, ==, MTX_MAGIC); return (mp->m_owner); } +int +mutex_held(kmutex_t *mp) +{ + return (mp->m_owner == curthread); +} + /* * ========================================================================= * rwlocks * ========================================================================= */ -/*ARGSUSED*/ + void rw_init(krwlock_t *rwlp, char *name, int type, void *arg) { - rwlock_init(&rwlp->rw_lock, USYNC_THREAD, NULL); - rwlp->rw_owner = NULL; - rwlp->initialized = B_TRUE; + ASSERT3S(type, ==, RW_DEFAULT); + ASSERT3P(arg, ==, NULL); + VERIFY3S(pthread_rwlock_init(&rwlp->rw_lock, NULL), ==, 0); + rwlp->rw_owner = RW_INIT; + rwlp->rw_wr_owner = RW_INIT; + rwlp->rw_readers = 0; + rwlp->rw_magic = RW_MAGIC; } void rw_destroy(krwlock_t *rwlp) { - rwlock_destroy(&rwlp->rw_lock); - rwlp->rw_owner = (void *)-1UL; - rwlp->initialized = B_FALSE; + ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC); + + VERIFY3S(pthread_rwlock_destroy(&rwlp->rw_lock), ==, 0); + rwlp->rw_magic = 0; } void rw_enter(krwlock_t *rwlp, krw_t rw) { - ASSERT(!RW_LOCK_HELD(rwlp)); - ASSERT(rwlp->initialized == B_TRUE); - ASSERT(rwlp->rw_owner != (void *)-1UL); - ASSERT(rwlp->rw_owner != curthread); + ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC); + ASSERT3P(rwlp->rw_owner, !=, curthread); + ASSERT3P(rwlp->rw_wr_owner, !=, curthread); - if (rw == RW_READER) - VERIFY(rw_rdlock(&rwlp->rw_lock) == 0); - else - VERIFY(rw_wrlock(&rwlp->rw_lock) == 0); + if (rw == RW_READER) { + VERIFY3S(pthread_rwlock_rdlock(&rwlp->rw_lock), ==, 0); + ASSERT3P(rwlp->rw_wr_owner, ==, RW_INIT); + + atomic_inc_uint(&rwlp->rw_readers); + } else { + VERIFY3S(pthread_rwlock_wrlock(&rwlp->rw_lock), ==, 0); + ASSERT3P(rwlp->rw_wr_owner, ==, RW_INIT); + ASSERT3U(rwlp->rw_readers, ==, 0); + + rwlp->rw_wr_owner = curthread; + } rwlp->rw_owner = curthread; } @@ -198,11 +365,16 @@ rw_enter(krwlock_t *rwlp, krw_t rw) void rw_exit(krwlock_t *rwlp) { - ASSERT(rwlp->initialized == B_TRUE); - ASSERT(rwlp->rw_owner != (void *)-1UL); + ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC); + ASSERT(RW_LOCK_HELD(rwlp)); - rwlp->rw_owner = NULL; - VERIFY(rw_unlock(&rwlp->rw_lock) == 0); + if (RW_READ_HELD(rwlp)) + atomic_dec_uint(&rwlp->rw_readers); + else + rwlp->rw_wr_owner = RW_INIT; + + rwlp->rw_owner = RW_INIT; + VERIFY3S(pthread_rwlock_unlock(&rwlp->rw_lock), ==, 0); } int @@ -210,28 +382,36 @@ rw_tryenter(krwlock_t *rwlp, krw_t rw) { int rv; - ASSERT(rwlp->initialized == B_TRUE); - ASSERT(rwlp->rw_owner != (void *)-1UL); + ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC); if (rw == RW_READER) - rv = rw_tryrdlock(&rwlp->rw_lock); + rv = pthread_rwlock_tryrdlock(&rwlp->rw_lock); else - rv = rw_trywrlock(&rwlp->rw_lock); + rv = pthread_rwlock_trywrlock(&rwlp->rw_lock); if (rv == 0) { + ASSERT3P(rwlp->rw_wr_owner, ==, RW_INIT); + + if (rw == RW_READER) + atomic_inc_uint(&rwlp->rw_readers); + else { + ASSERT3U(rwlp->rw_readers, ==, 0); + rwlp->rw_wr_owner = curthread; + } + rwlp->rw_owner = curthread; return (1); } + VERIFY3S(rv, ==, EBUSY); + return (0); } -/*ARGSUSED*/ int rw_tryupgrade(krwlock_t *rwlp) { - ASSERT(rwlp->initialized == B_TRUE); - ASSERT(rwlp->rw_owner != (void *)-1UL); + ASSERT3U(rwlp->rw_magic, ==, RW_MAGIC); return (0); } @@ -241,26 +421,32 @@ rw_tryupgrade(krwlock_t *rwlp) * condition variables * ========================================================================= */ -/*ARGSUSED*/ + void cv_init(kcondvar_t *cv, char *name, int type, void *arg) { - VERIFY(cond_init(cv, type, NULL) == 0); + ASSERT3S(type, ==, CV_DEFAULT); + cv->cv_magic = CV_MAGIC; + VERIFY3S(pthread_cond_init(&cv->cv, NULL), ==, 0); } void cv_destroy(kcondvar_t *cv) { - VERIFY(cond_destroy(cv) == 0); + ASSERT3U(cv->cv_magic, ==, CV_MAGIC); + VERIFY3S(pthread_cond_destroy(&cv->cv), ==, 0); + cv->cv_magic = 0; } void cv_wait(kcondvar_t *cv, kmutex_t *mp) { - ASSERT(mutex_owner(mp) == curthread); - mp->m_owner = NULL; - int ret = cond_wait(cv, &mp->m_lock); - VERIFY(ret == 0 || ret == EINTR); + ASSERT3U(cv->cv_magic, ==, CV_MAGIC); + ASSERT3P(mutex_owner(mp), ==, curthread); + mp->m_owner = MTX_INIT; + int ret = pthread_cond_wait(&cv->cv, &mp->m_lock); + if (ret != 0) + VERIFY3S(ret, ==, EINTR); mp->m_owner = curthread; } @@ -268,29 +454,38 @@ clock_t cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime) { int error; + struct timeval tv; timestruc_t ts; clock_t delta; + ASSERT3U(cv->cv_magic, ==, CV_MAGIC); + top: delta = abstime - ddi_get_lbolt(); if (delta <= 0) return (-1); - ts.tv_sec = delta / hz; - ts.tv_nsec = (delta % hz) * (NANOSEC / hz); + VERIFY(gettimeofday(&tv, NULL) == 0); + + ts.tv_sec = tv.tv_sec + delta / hz; + ts.tv_nsec = tv.tv_usec * 1000 + (delta % hz) * (NANOSEC / hz); + if (ts.tv_nsec >= NANOSEC) { + ts.tv_sec++; + ts.tv_nsec -= NANOSEC; + } - ASSERT(mutex_owner(mp) == curthread); - mp->m_owner = NULL; - error = cond_reltimedwait(cv, &mp->m_lock, &ts); + ASSERT3P(mutex_owner(mp), ==, curthread); + mp->m_owner = MTX_INIT; + error = pthread_cond_timedwait(&cv->cv, &mp->m_lock, &ts); mp->m_owner = curthread; - if (error == ETIME) + if (error == ETIMEDOUT) return (-1); if (error == EINTR) goto top; - ASSERT(error == 0); + VERIFY3S(error, ==, 0); return (1); } @@ -298,13 +493,15 @@ top: void cv_signal(kcondvar_t *cv) { - VERIFY(cond_signal(cv) == 0); + ASSERT3U(cv->cv_magic, ==, CV_MAGIC); + VERIFY3S(pthread_cond_signal(&cv->cv), ==, 0); } void cv_broadcast(kcondvar_t *cv) { - VERIFY(cond_broadcast(cv) == 0); + ASSERT3U(cv->cv_magic, ==, CV_MAGIC); + VERIFY3S(pthread_cond_broadcast(&cv->cv), ==, 0); } /* @@ -325,9 +522,12 @@ vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3) { int fd; vnode_t *vp; - int old_umask; - char realpath[MAXPATHLEN]; + int old_umask = 0; + char *realpath; struct stat64 st; + int err; + + realpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL); /* * If we're accessing a real disk from userland, we need to use @@ -339,14 +539,23 @@ vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3) * for its size. So -- gag -- we open the block device to get * its size, and remember it for subsequent VOP_GETATTR(). */ +#if defined(__sun__) || defined(__sun) if (strncmp(path, "/dev/", 5) == 0) { +#else + if (0) { +#endif char *dsk; fd = open64(path, O_RDONLY); - if (fd == -1) - return (errno); + if (fd == -1) { + err = errno; + free(realpath); + return (err); + } if (fstat64(fd, &st) == -1) { + err = errno; close(fd); - return (errno); + free(realpath); + return (err); } close(fd); (void) sprintf(realpath, "%s", path); @@ -356,8 +565,19 @@ vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3) dsk + 1); } else { (void) sprintf(realpath, "%s", path); - if (!(flags & FCREAT) && stat64(realpath, &st) == -1) - return (errno); + if (!(flags & FCREAT) && stat64(realpath, &st) == -1) { + err = errno; + free(realpath); + return (err); + } + } + + if (!(flags & FCREAT) && S_ISBLK(st.st_mode)) { +#ifdef __linux__ + flags |= O_DIRECT; +#endif + /* We shouldn't be writing to block devices in userspace */ + VERIFY(!(flags & FWRITE)); } if (flags & FCREAT) @@ -368,6 +588,7 @@ vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3) * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR. */ fd = open64(realpath, flags - FREAD, mode); + free(realpath); if (flags & FCREAT) (void) umask(old_umask); @@ -375,9 +596,10 @@ vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3) if (fd == -1) return (errno); - if (fstat64(fd, &st) == -1) { + if (fstat64_blk(fd, &st) == -1) { + err = errno; close(fd); - return (errno); + return (err); } (void) fcntl(fd, F_SETFD, FD_CLOEXEC); @@ -415,26 +637,44 @@ 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) { - ssize_t iolen, split; + ssize_t rc, done = 0, split; if (uio == UIO_READ) { - iolen = pread64(vp->v_fd, addr, len, offset); + rc = pread64(vp->v_fd, addr, len, offset); } else { /* * To simulate partial disk writes, we split writes into two * system calls so that the process can be killed in between. */ - split = (len > 0 ? rand() % len : 0); - iolen = pwrite64(vp->v_fd, addr, split, offset); - iolen += pwrite64(vp->v_fd, (char *)addr + split, - len - split, offset + split); + int sectors = len >> SPA_MINBLOCKSHIFT; + split = (sectors > 0 ? rand() % sectors : 0) << + SPA_MINBLOCKSHIFT; + rc = pwrite64(vp->v_fd, addr, split, offset); + if (rc != -1) { + done = rc; + rc = pwrite64(vp->v_fd, (char *)addr + split, + len - split, offset + split); + } } - if (iolen == -1) +#ifdef __linux__ + if (rc == -1 && errno == EINVAL) { + /* + * Under Linux, this most likely means an alignment issue + * (memory or disk) due to O_DIRECT, so we abort() in order to + * catch the offender. + */ + abort(); + } +#endif + if (rc == -1) return (errno); + + done += rc; + if (residp) - *residp = len - iolen; - else if (iolen != len) + *residp = len - done; + else if (done != len) return (EIO); return (0); } @@ -455,18 +695,18 @@ int fop_getattr(vnode_t *vp, vattr_t *vap) { struct stat64 st; + int err; - if (fstat64(vp->v_fd, &st) == -1) { + if (fstat64_blk(vp->v_fd, &st) == -1) { + err = errno; close(vp->v_fd); - return (errno); + return (err); } vap->va_size = st.st_size; return (0); } -#ifdef ZFS_DEBUG - /* * ========================================================================= * Figure out which debugging statements to print @@ -564,7 +804,7 @@ __dprintf(const char *file, const char *func, int line, const char *fmt, ...) if (dprintf_find_string("pid")) (void) printf("%d ", getpid()); if (dprintf_find_string("tid")) - (void) printf("%u ", thr_self()); + (void) printf("%u ", (uint_t) pthread_self()); if (dprintf_find_string("cpu")) (void) printf("%u ", getcpuid()); if (dprintf_find_string("time")) @@ -579,8 +819,6 @@ __dprintf(const char *file, const char *func, int line, const char *fmt, ...) } } -#endif /* ZFS_DEBUG */ - /* * ========================================================================= * cmn_err() and panic() @@ -796,7 +1034,7 @@ umem_out_of_memory(void) { char errmsg[] = "out of memory -- generating core dump\n"; - write(fileno(stderr), errmsg, sizeof (errmsg)); + (void) fprintf(stderr, "%s", errmsg); abort(); return (0); } @@ -817,6 +1055,7 @@ kernel_init(int mode) VERIFY((random_fd = open("/dev/random", O_RDONLY)) != -1); VERIFY((urandom_fd = open("/dev/urandom", O_RDONLY)) != -1); + thread_init(); system_taskq_init(); spa_init(mode); @@ -828,6 +1067,7 @@ kernel_fini(void) spa_fini(); system_taskq_fini(); + thread_fini(); close(random_fd); close(urandom_fd); @@ -836,31 +1076,6 @@ kernel_fini(void) urandom_fd = -1; } -int -z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen) -{ - int ret; - uLongf len = *dstlen; - - if ((ret = uncompress(dst, &len, src, srclen)) == Z_OK) - *dstlen = (size_t)len; - - return (ret); -} - -int -z_compress_level(void *dst, size_t *dstlen, const void *src, size_t srclen, - int level) -{ - int ret; - uLongf len = *dstlen; - - if ((ret = compress2(dst, &len, src, srclen, level)) == Z_OK) - *dstlen = (size_t)len; - - return (ret); -} - uid_t crgetuid(cred_t *cr) { @@ -920,25 +1135,27 @@ ksiddomain_rele(ksiddomain_t *ksid) umem_free(ksid, sizeof (ksiddomain_t)); } -/* - * Do not change the length of the returned string; it must be freed - * with strfree(). - */ char * -kmem_asprintf(const char *fmt, ...) +kmem_vasprintf(const char *fmt, va_list adx) { - int size; - va_list adx; - char *buf; + char *buf = NULL; + va_list adx_copy; - va_start(adx, fmt); - size = vsnprintf(NULL, 0, fmt, adx) + 1; - va_end(adx); + va_copy(adx_copy, adx); + VERIFY(vasprintf(&buf, fmt, adx_copy) != -1); + va_end(adx_copy); + + return (buf); +} - buf = kmem_alloc(size, KM_SLEEP); +char * +kmem_asprintf(const char *fmt, ...) +{ + char *buf = NULL; + va_list adx; va_start(adx, fmt); - size = vsnprintf(buf, size, fmt, adx); + VERIFY(vasprintf(&buf, fmt, adx) != -1); va_end(adx); return (buf);