/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2012 by Delphix. All rights reserved.

 */

#include <assert.h>

#include <fcntl.h>

#include <poll.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <zlib.h>

#include <sys/spa.h>

#include <sys/stat.h>

#include <sys/processor.h>

#include <sys/zfs_context.h>

#include <sys/zmod.h>

#include <sys/utsname.h>

#include <sys/systeminfo.h>

/*

 * Emulation of kernel services in userland.

 */

int aok;

uint64_t physmem;

vnode_t *rootdir = (vnode_t *)0xabcd1234;

char hw_serial[HW_HOSTID_LEN];

vmem_t *zio_arena = NULL;

struct utsname utsname = {

	"userland", "libzpool", "1", "1", "na"

};

/* this only exists to have its address taken */

struct proc p0;

/*

 * =========================================================================

 * threads

 * =========================================================================

 */

/*ARGSUSED*/

kthread_t *

zk_thread_create(void (*func)(), void *arg)

{

	thread_t tid;

	VERIFY(thr_create(0, 0, (void *(*)(void *))func, arg, THR_DETACHED,

	    &tid) == 0);

	return ((void *)(uintptr_t)tid);

}

/*

 * =========================================================================

 * kstats

 * =========================================================================

 */

/*ARGSUSED*/

kstat_t *

kstat_create(char *module, int instance, char *name, char *class,

    uchar_t type, ulong_t ndata, uchar_t ks_flag)

{

	return (NULL);

}

/*ARGSUSED*/

void

kstat_install(kstat_t *ksp)

{}

/*ARGSUSED*/

void

kstat_delete(kstat_t *ksp)

{}

/*

 * =========================================================================

 * mutexes

 * =========================================================================

 */

void

zmutex_init(kmutex_t *mp)

{

	mp->m_owner = NULL;

	mp->initialized = B_TRUE;

	(void) _mutex_init(&mp->m_lock, USYNC_THREAD, NULL);

}

void

zmutex_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;

}

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);

	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);

		mp->m_owner = curthread;

		return (1);

	} else {

		return (0);

	}

}

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);

}

void *

mutex_owner(kmutex_t *mp)

{

	ASSERT(mp->initialized == B_TRUE);

	return (mp->m_owner);

}

/*

 * =========================================================================

 * 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;

}

void

rw_destroy(krwlock_t *rwlp)

{

	rwlock_destroy(&rwlp->rw_lock);

	rwlp->rw_owner = (void *)-1UL;

	rwlp->initialized = B_FALSE;

}

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);

	if (rw == RW_READER)

		VERIFY(rw_rdlock(&rwlp->rw_lock) == 0);

	else

		VERIFY(rw_wrlock(&rwlp->rw_lock) == 0);

	rwlp->rw_owner = curthread;

}

void

rw_exit(krwlock_t *rwlp)

{

	ASSERT(rwlp->initialized == B_TRUE);

	ASSERT(rwlp->rw_owner != (void *)-1UL);

	rwlp->rw_owner = NULL;

	VERIFY(rw_unlock(&rwlp->rw_lock) == 0);

}

int

rw_tryenter(krwlock_t *rwlp, krw_t rw)

{

	int rv;

	ASSERT(rwlp->initialized == B_TRUE);

	ASSERT(rwlp->rw_owner != (void *)-1UL);

	if (rw == RW_READER)

		rv = rw_tryrdlock(&rwlp->rw_lock);

	else

		rv = rw_trywrlock(&rwlp->rw_lock);

	if (rv == 0) {

		rwlp->rw_owner = curthread;

		return (1);

	}

	return (0);

}

/*ARGSUSED*/

int

rw_tryupgrade(krwlock_t *rwlp)

{

	ASSERT(rwlp->initialized == B_TRUE);

	ASSERT(rwlp->rw_owner != (void *)-1UL);

	return (0);

}

/*

 * =========================================================================

 * condition variables

 * =========================================================================

 */

/*ARGSUSED*/

void

cv_init(kcondvar_t *cv, char *name, int type, void *arg)

{

	VERIFY(cond_init(cv, type, NULL) == 0);

}

void

cv_destroy(kcondvar_t *cv)

{

	VERIFY(cond_destroy(cv) == 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);

	mp->m_owner = curthread;

}

clock_t

cv_timedwait(kcondvar_t *cv, kmutex_t *mp, clock_t abstime)

{

	int error;

	timestruc_t ts;

	clock_t delta;

top:

	delta = abstime - ddi_get_lbolt();

	if (delta <= 0)

		return (-1);

	ts.tv_sec = delta / hz;

	ts.tv_nsec = (delta % hz) * (NANOSEC / hz);

	ASSERT(mutex_owner(mp) == curthread);

	mp->m_owner = NULL;

	error = cond_reltimedwait(cv, &mp->m_lock, &ts);

	mp->m_owner = curthread;

	if (error == ETIME)

		return (-1);

	if (error == EINTR)

		goto top;

	ASSERT(error == 0);

	return (1);

}

void

cv_signal(kcondvar_t *cv)

{

	VERIFY(cond_signal(cv) == 0);

}

void

cv_broadcast(kcondvar_t *cv)

{

	VERIFY(cond_broadcast(cv) == 0);

}

/*

 * =========================================================================

 * vnode operations

 * =========================================================================

 */

/*

 * Note: for the xxxat() versions of these functions, we assume that the

 * starting vp is always rootdir (which is true for spa_directory.c, the only

 * ZFS consumer of these interfaces).  We assert this is true, and then emulate

 * them by adding '/' in front of the path.

 */

/*ARGSUSED*/

int

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];

	struct stat64 st;

	/*

	 * If we're accessing a real disk from userland, we need to use

	 * the character interface to avoid caching.  This is particularly

	 * important if we're trying to look at a real in-kernel storage

	 * pool from userland, e.g. via zdb, because otherwise we won't

	 * see the changes occurring under the segmap cache.

	 * On the other hand, the stupid character device returns zero

	 * for its size.  So -- gag -- we open the block device to get

	 * its size, and remember it for subsequent VOP_GETATTR().

	 */

	if (strncmp(path, "/dev/", 5) == 0) {

		char *dsk;

		fd = open64(path, O_RDONLY);

		if (fd == -1)

			return (errno);

		if (fstat64(fd, &st) == -1) {

			close(fd);

			return (errno);

		}

		close(fd);

		(void) sprintf(realpath, "%s", path);

		dsk = strstr(path, "/dsk/");

		if (dsk != NULL)

			(void) sprintf(realpath + (dsk - path) + 1, "r%s",

			    dsk + 1);

	} else {

		(void) sprintf(realpath, "%s", path);

		if (!(flags & FCREAT) && stat64(realpath, &st) == -1)

			return (errno);

	}

	if (flags & FCREAT)

		old_umask = umask(0);

	/*

	 * The construct 'flags - FREAD' conveniently maps combinations of

	 * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR.

	 */

	fd = open64(realpath, flags - FREAD, mode);

	if (flags & FCREAT)

		(void) umask(old_umask);

	if (fd == -1)

		return (errno);

	if (fstat64(fd, &st) == -1) {

		close(fd);

		return (errno);

	}

	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);

	*vpp = vp = umem_zalloc(sizeof (vnode_t), UMEM_NOFAIL);

	vp->v_fd = fd;

	vp->v_size = st.st_size;

	vp->v_path = spa_strdup(path);

	return (0);

}

/*ARGSUSED*/

int

vn_openat(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2,

    int x3, vnode_t *startvp, int fd)

{

	char *realpath = umem_alloc(strlen(path) + 2, UMEM_NOFAIL);

	int ret;

	ASSERT(startvp == rootdir);

	(void) sprintf(realpath, "/%s", path);

	/* fd ignored for now, need if want to simulate nbmand support */

	ret = vn_open(realpath, x1, flags, mode, vpp, x2, x3);

	umem_free(realpath, strlen(path) + 2);

	return (ret);

}

/*ARGSUSED*/

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;

	if (uio == UIO_READ) {

		iolen = 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.

		 */

		int sectors = len >> SPA_MINBLOCKSHIFT;

		split = (sectors > 0 ? rand() % sectors : 0) <<

		    SPA_MINBLOCKSHIFT;

		iolen = pwrite64(vp->v_fd, addr, split, offset);

		iolen += pwrite64(vp->v_fd, (char *)addr + split,

		    len - split, offset + split);

	}

	if (iolen == -1)

		return (errno);

	if (residp)

		*residp = len - iolen;

	else if (iolen != len)

		return (EIO);

	return (0);

}

void

vn_close(vnode_t *vp)

{

	close(vp->v_fd);

	spa_strfree(vp->v_path);

	umem_free(vp, sizeof (vnode_t));

}

/*

 * At a minimum we need to update the size since vdev_reopen()

 * will no longer call vn_openat().

 */

int

fop_getattr(vnode_t *vp, vattr_t *vap)

{

	struct stat64 st;

	if (fstat64(vp->v_fd, &st) == -1) {

		close(vp->v_fd);

		return (errno);

	}

	vap->va_size = st.st_size;

	return (0);

}

#ifdef ZFS_DEBUG

/*

 * =========================================================================

 * Figure out which debugging statements to print

 * =========================================================================

 */

static char *dprintf_string;

static int dprintf_print_all;

int

dprintf_find_string(const char *string)

{

	char *tmp_str = dprintf_string;

	int len = strlen(string);

	/*

	 * Find out if this is a string we want to print.

	 * String format: file1.c,function_name1,file2.c,file3.c

	 */

	while (tmp_str != NULL) {

		if (strncmp(tmp_str, string, len) == 0 &&

		    (tmp_str[len] == ',' || tmp_str[len] == '\0'))

			return (1);

		tmp_str = strchr(tmp_str, ',');

		if (tmp_str != NULL)

			tmp_str++; /* Get rid of , */

	}

	return (0);

}

void

dprintf_setup(int *argc, char **argv)

{

	int i, j;

	/*

	 * Debugging can be specified two ways: by setting the

	 * environment variable ZFS_DEBUG, or by including a

	 * "debug=..."  argument on the command line.  The command

	 * line setting overrides the environment variable.

	 */