Add linux libspl support

All changes needed for the libspl layer.  This includes modifications
to files directly copied from OpenSolaris and the addition of new
files needed to fill in the gaps.

Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>

configure.ac

@@ -60,6 +60,11 @@ AC_CONFIG_FILES([
 	man/Makefile
 	man/man8/Makefile
 	lib/Makefile
+	lib/libspl/Makefile
+	lib/libspl/asm-generic/Makefile
+	lib/libspl/asm-i386/Makefile
+	lib/libspl/asm-x86_64/Makefile
+	lib/libspl/include/Makefile
 	lib/libavl/Makefile
 	lib/libefi/Makefile
 	lib/libnvpair/Makefile

lib/Makefile.am

@@ -1 +1 @@
-SUBDIRS = libavl libefi libnvpair libunicode libuutil libzfs libzpool
+SUBDIRS = libspl libavl libefi libnvpair libunicode libuutil libzfs libzpool

lib/libspl/Makefile.am

@@ -0,0 +1,33 @@
+include $(top_srcdir)/config/Rules.am
+
+AM_CFLAGS += $(DEBUG_STACKFLAGS) $(FRAME_LARGER_THAN)
+
+SUBDIRS = include $(TARGET_ASM_DIR)
+DIST_SUBDIRS = include asm-generic asm-i386 asm-x86_64
+
+DEFAULT_INCLUDES += \
+	-I${top_srcdir}/lib/libspl/include
+
+AM_CCASFLAGS = \
+	-I${top_srcdir}/lib/libspl/include
+
+lib_LTLIBRARIES = libspl.la
+
+libspl_la_LDFLAGS = -lrt
+
+libspl_la_SOURCES = \
+	${top_srcdir}/lib/libspl/getexecname.c \
+	${top_srcdir}/lib/libspl/gethrtime.c \
+	${top_srcdir}/lib/libspl/gethrestime.c \
+	${top_srcdir}/lib/libspl/getmntany.c \
+	${top_srcdir}/lib/libspl/list.c \
+	${top_srcdir}/lib/libspl/mkdirp.c \
+	${top_srcdir}/lib/libspl/strlcat.c \
+	${top_srcdir}/lib/libspl/strlcpy.c \
+	${top_srcdir}/lib/libspl/strnlen.c \
+	${top_srcdir}/lib/libspl/timestamp.c \
+	${top_srcdir}/lib/libspl/zone.c \
+	${top_srcdir}/lib/libspl/xdr.c \
+	${top_srcdir}/lib/libspl/${TARGET_ASM_DIR}/atomic.S \
+	${top_srcdir}/lib/libspl/include/sys/list.h \
+	${top_srcdir}/lib/libspl/include/sys/list_impl.h

lib/libspl/asm-generic/Makefile.am

@@ -0,0 +1,18 @@
+include $(top_srcdir)/config/Rules.am
+
+DEFAULT_INCLUDES += \
+        -I${top_srcdir}/lib/libspl/include
+
+atomic_SOURCE = atomic.c
+atomic_ASM = atomic.S
+
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	  $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -fPIC
+EXTRA_DIST = ${atomic_SOURCE}
+
+# Generates assembly to simplify inclusion in ../Makefile.am
+all-am:
+	$(COMPILE) -c -S ${atomic_SOURCE} -o ${atomic_ASM}
+
+clean-generic:
+	$(RM) ${atomic_ASM}

lib/libspl/asm-generic/atomic.S

@@ -0,0 +1,6 @@
+Stub file for 'make dist' distdir rule.
+
+This file is directly referenced by ../Makefile.am as a source
+file and thus will be expected by 'make dist'.  To avoid this
+being a problem this stub file was added.  It will be overwritten
+at build time based on assmebly generated from atomic.c.

lib/libspl/asm-generic/atomic.c

@@ -0,0 +1,424 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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) 2009 by Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <atomic.h>
+#include <assert.h>
+#include <pthread.h>
+
+/*
+ * All operations are implemented by serializing them through a global
+ * pthread mutex.  This provides a correct generic implementation.
+ * However all supported architectures are encouraged to provide a
+ * native implementation is assembly for performance reasons.
+ */
+pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * Theses are the void returning variants
+ */
+
+#define ATOMIC_INC(name, type) \
+	void atomic_inc_##name(volatile type *target)			\
+	{								\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		(*target)++;						\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+	}
+
+ATOMIC_INC(long, unsigned long)
+ATOMIC_INC(8, uint8_t)
+ATOMIC_INC(uchar, uchar_t)
+ATOMIC_INC(16, uint16_t)
+ATOMIC_INC(ushort, ushort_t)
+ATOMIC_INC(32, uint32_t)
+ATOMIC_INC(uint, uint_t)
+ATOMIC_INC(ulong, ulong_t)
+ATOMIC_INC(64, uint64_t)
+
+
+#define ATOMIC_DEC(name, type) \
+	void atomic_dec_##name(volatile type *target)			\
+	{								\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		(*target)--;						\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+	}
+
+ATOMIC_DEC(long, unsigned long)
+ATOMIC_DEC(8, uint8_t)
+ATOMIC_DEC(uchar, uchar_t)
+ATOMIC_DEC(16, uint16_t)
+ATOMIC_DEC(ushort, ushort_t)
+ATOMIC_DEC(32, uint32_t)
+ATOMIC_DEC(uint, uint_t)
+ATOMIC_DEC(ulong, ulong_t)
+ATOMIC_DEC(64, uint64_t)
+
+
+#define ATOMIC_ADD(name, type1, type2) \
+	void atomic_add_##name(volatile type1 *target, type2 bits)	\
+	{								\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		*target += bits;					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+	}
+
+ATOMIC_ADD(8, uint8_t, int8_t)
+ATOMIC_ADD(char, uchar_t, signed char)
+ATOMIC_ADD(16, uint16_t, int16_t)
+ATOMIC_ADD(short, ushort_t, short)
+ATOMIC_ADD(32, uint32_t, int32_t)
+ATOMIC_ADD(int, uint_t, int)
+ATOMIC_ADD(long, ulong_t, long)
+ATOMIC_ADD(64, uint64_t, int64_t)
+
+void atomic_add_ptr(volatile void *target, ssize_t bits)
+{
+	VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
+	*(caddr_t *)target += bits;
+	VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+}
+
+
+#define ATOMIC_OR(name, type) \
+	void atomic_or_##name(volatile type *target, type bits)		\
+	{								\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		*target |= bits;					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+	}
+
+ATOMIC_OR(8, uint8_t)
+ATOMIC_OR(uchar, uchar_t)
+ATOMIC_OR(16, uint16_t)
+ATOMIC_OR(ushort, ushort_t)
+ATOMIC_OR(32, uint32_t)
+ATOMIC_OR(uint, uint_t)
+ATOMIC_OR(ulong, ulong_t)
+ATOMIC_OR(64, uint64_t)
+
+
+#define ATOMIC_AND(name, type) \
+	void atomic_and_##name(volatile type *target, type bits)	\
+	{								\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		*target &= bits;					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+	}
+
+ATOMIC_AND(8, uint8_t)
+ATOMIC_AND(uchar, uchar_t)
+ATOMIC_AND(16, uint16_t)
+ATOMIC_AND(ushort, ushort_t)
+ATOMIC_AND(32, uint32_t)
+ATOMIC_AND(uint, uint_t)
+ATOMIC_AND(ulong, ulong_t)
+ATOMIC_AND(64, uint64_t)
+
+
+/*
+ * New value returning variants
+ */
+
+#define ATOMIC_INC_NV(name, type) \
+	type atomic_inc_##name##_nv(volatile type *target)		\
+	{								\
+		type rc;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		rc = (++(*target));					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return rc;						\
+	}
+
+ATOMIC_INC_NV(long, unsigned long)
+ATOMIC_INC_NV(8, uint8_t)
+ATOMIC_INC_NV(uchar, uchar_t)
+ATOMIC_INC_NV(16, uint16_t)
+ATOMIC_INC_NV(ushort, ushort_t)
+ATOMIC_INC_NV(32, uint32_t)
+ATOMIC_INC_NV(uint, uint_t)
+ATOMIC_INC_NV(ulong, ulong_t)
+ATOMIC_INC_NV(64, uint64_t)
+
+
+#define ATOMIC_DEC_NV(name, type) \
+	type atomic_dec_##name##_nv(volatile type *target)		\
+	{								\
+		type rc;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		rc = (--(*target));					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return rc;						\
+	}
+
+ATOMIC_DEC_NV(long, unsigned long)
+ATOMIC_DEC_NV(8, uint8_t)
+ATOMIC_DEC_NV(uchar, uchar_t)
+ATOMIC_DEC_NV(16, uint16_t)
+ATOMIC_DEC_NV(ushort, ushort_t)
+ATOMIC_DEC_NV(32, uint32_t)
+ATOMIC_DEC_NV(uint, uint_t)
+ATOMIC_DEC_NV(ulong, ulong_t)
+ATOMIC_DEC_NV(64, uint64_t)
+
+
+#define ATOMIC_ADD_NV(name, type1, type2) \
+	type1 atomic_add_##name##_nv(volatile type1 *target, type2 bits)\
+	{								\
+		type1 rc;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		rc = (*target += bits);					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return rc;						\
+	}
+
+ATOMIC_ADD_NV(8, uint8_t, int8_t)
+ATOMIC_ADD_NV(char, uchar_t, signed char)
+ATOMIC_ADD_NV(16, uint16_t, int16_t)
+ATOMIC_ADD_NV(short, ushort_t, short)
+ATOMIC_ADD_NV(32, uint32_t, int32_t)
+ATOMIC_ADD_NV(int, uint_t, int)
+ATOMIC_ADD_NV(long, ulong_t, long)
+ATOMIC_ADD_NV(64, uint64_t, int64_t)
+
+void *atomic_add_ptr_nv(volatile void *target, ssize_t bits)
+{
+	void *ptr;
+
+	VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
+	ptr = (*(caddr_t *)target += bits);
+	VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+
+	return ptr;
+}
+
+
+#define ATOMIC_OR_NV(name, type) \
+	type atomic_or_##name##_nv(volatile type *target, type bits)	\
+	{								\
+		type rc;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		rc = (*target |= bits);					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return rc;						\
+	}
+
+ATOMIC_OR_NV(long, unsigned long)
+ATOMIC_OR_NV(8, uint8_t)
+ATOMIC_OR_NV(uchar, uchar_t)
+ATOMIC_OR_NV(16, uint16_t)
+ATOMIC_OR_NV(ushort, ushort_t)
+ATOMIC_OR_NV(32, uint32_t)
+ATOMIC_OR_NV(uint, uint_t)
+ATOMIC_OR_NV(ulong, ulong_t)
+ATOMIC_OR_NV(64, uint64_t)
+
+
+#define ATOMIC_AND_NV(name, type) \
+	type atomic_and_##name##_nv(volatile type *target, type bits)	\
+	{								\
+		type rc;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		rc = (*target &= bits);					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return rc;						\
+	}
+
+ATOMIC_AND_NV(long, unsigned long)
+ATOMIC_AND_NV(8, uint8_t)
+ATOMIC_AND_NV(uchar, uchar_t)
+ATOMIC_AND_NV(16, uint16_t)
+ATOMIC_AND_NV(ushort, ushort_t)
+ATOMIC_AND_NV(32, uint32_t)
+ATOMIC_AND_NV(uint, uint_t)
+ATOMIC_AND_NV(ulong, ulong_t)
+ATOMIC_AND_NV(64, uint64_t)
+
+
+/*
+ *  If *arg1 == arg2, set *arg1 = arg3; return old value
+ */
+
+#define ATOMIC_CAS(name, type) \
+	type atomic_cas_##name(volatile type *target, type arg1, type arg2) \
+	{								\
+		type old;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		old = *target;						\
+		if (old == arg1)					\
+			*target = arg2;					\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return old;						\
+	}
+
+ATOMIC_CAS(8, uint8_t)
+ATOMIC_CAS(uchar, uchar_t)
+ATOMIC_CAS(16, uint16_t)
+ATOMIC_CAS(ushort, ushort_t)
+ATOMIC_CAS(32, uint32_t)
+ATOMIC_CAS(uint, uint_t)
+ATOMIC_CAS(ulong, ulong_t)
+ATOMIC_CAS(64, uint64_t)
+
+void *atomic_cas_ptr(volatile void *target, void *arg1, void *arg2)
+{
+	void *old;
+
+	VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
+	old = *(void **)target;
+        if (old == arg1)
+                *(void **)target = arg2;
+	VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+
+        return old;
+}
+
+
+/*
+ * Swap target and return old value
+ */
+
+#define ATOMIC_SWAP(name, type) \
+	type atomic_swap_##name(volatile type *target, type bits)	\
+	{								\
+		type old;						\
+		VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);	\
+		old = *target;						\
+		*target = bits;						\
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);	\
+		return old;						\
+	}
+
+ATOMIC_SWAP(8, uint8_t)
+ATOMIC_SWAP(uchar, uchar_t)
+ATOMIC_SWAP(16, uint16_t)
+ATOMIC_SWAP(ushort, ushort_t)
+ATOMIC_SWAP(32, uint32_t)
+ATOMIC_SWAP(uint, uint_t)
+ATOMIC_SWAP(ulong, ulong_t)
+ATOMIC_SWAP(64, uint64_t)
+
+void *atomic_swap_ptr(volatile void *target, void *bits)
+{
+	void *old;
+
+	VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
+	old = *(void **)target;
+	*(void **)target = bits;
+	VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+
+	return old;
+}
+
+
+int atomic_set_long_excl(volatile ulong_t *target, uint_t value)
+{
+	ulong_t bit;
+
+	VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
+	bit = (1UL << value);
+	if ((*target & bit) != 0) {
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+		return -1;
+	}
+	*target |= bit;
+	VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+
+	return 0;
+}
+
+int atomic_clear_long_excl(volatile ulong_t *target, uint_t value)
+{
+	ulong_t bit;
+
+	VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
+	bit = (1UL << value);
+	if ((*target & bit) != 0) {
+		VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+		return -1;
+	}
+	*target &= ~bit;
+	VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
+
+	return 0;
+}
+
+void membar_enter(void)
+{
+	/* XXX - Implement me */
+}
+
+void membar_exit(void)
+{
+	/* XXX - Implement me */
+}
+
+void membar_producer(void)
+{
+	/* XXX - Implement me */
+}
+
+void membar_consumer(void)
+{
+	/* XXX - Implement me */
+}
+
+/* Legacy kernel interfaces; they will go away (eventually). */
+
+uint8_t cas8(uint8_t *target, uint8_t arg1, uint8_t arg2)
+{
+	return atomic_cas_8(target, arg1, arg2);
+}
+
+uint32_t cas32(uint32_t *target, uint32_t arg1, uint32_t arg2)
+{
+	return atomic_cas_32(target, arg1, arg2);
+}
+
+uint64_t cas64(uint64_t *target, uint64_t arg1, uint64_t arg2)
+{
+	return atomic_cas_64(target, arg1, arg2);
+}
+
+ulong_t caslong(ulong_t *target, ulong_t arg1, ulong_t arg2)
+{
+	return atomic_cas_ulong(target, arg1, arg2);
+}
+
+void *casptr(void *target, void *arg1, void *arg2)
+{
+	return atomic_cas_ptr(target, arg1, arg2);
+}
+
+void atomic_and_long(ulong_t *target, ulong_t bits)
+{
+	return atomic_and_ulong(target, bits);
+}
+
+void atomic_or_long(ulong_t *target, ulong_t bits)
+{
+	return atomic_or_ulong(target, bits);
+}

lib/libspl/asm-i386/Makefile.am

@@ -0,0 +1 @@
+noinst_HEADERS = *.S

lib/libspl/asm-i386/atomic.S

@@ -0,0 +1,730 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+	.ident	"%Z%%M%	%I%	%E% SMI"
+
+	.file	"%M%"
+
+#define _ASM
+#include <ia32/sys/asm_linkage.h>
+
+	ENTRY(atomic_inc_8)
+	ALTENTRY(atomic_inc_uchar)
+	movl	4(%esp), %eax
+	lock
+	incb	(%eax)
+	ret
+	SET_SIZE(atomic_inc_uchar)
+	SET_SIZE(atomic_inc_8)
+
+	ENTRY(atomic_inc_16)
+	ALTENTRY(atomic_inc_ushort)
+	movl	4(%esp), %eax
+	lock
+	incw	(%eax)
+	ret
+	SET_SIZE(atomic_inc_ushort)
+	SET_SIZE(atomic_inc_16)
+
+	ENTRY(atomic_inc_32)
+	ALTENTRY(atomic_inc_uint)
+	ALTENTRY(atomic_inc_ulong)
+	movl	4(%esp), %eax
+	lock
+	incl	(%eax)
+	ret
+	SET_SIZE(atomic_inc_ulong)
+	SET_SIZE(atomic_inc_uint)
+	SET_SIZE(atomic_inc_32)
+
+	ENTRY(atomic_inc_8_nv)
+	ALTENTRY(atomic_inc_uchar_nv)
+	movl	4(%esp), %edx
+	movb	(%edx), %al
+1:
+	leal	1(%eax), %ecx
+	lock
+	cmpxchgb %cl, (%edx)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_inc_uchar_nv)
+	SET_SIZE(atomic_inc_8_nv)
+
+	ENTRY(atomic_inc_16_nv)
+	ALTENTRY(atomic_inc_ushort_nv)
+	movl	4(%esp), %edx
+	movw	(%edx), %ax
+1:
+	leal	1(%eax), %ecx
+	lock
+	cmpxchgw %cx, (%edx)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_inc_ushort_nv)
+	SET_SIZE(atomic_inc_16_nv)
+
+	ENTRY(atomic_inc_32_nv)
+	ALTENTRY(atomic_inc_uint_nv)
+	ALTENTRY(atomic_inc_ulong_nv)
+	movl	4(%esp), %edx
+	movl	(%edx), %eax
+1:
+	leal	1(%eax), %ecx
+	lock
+	cmpxchgl %ecx, (%edx)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_inc_ulong_nv)
+	SET_SIZE(atomic_inc_uint_nv)
+	SET_SIZE(atomic_inc_32_nv)
+
+	/*
+	 * NOTE: If atomic_inc_64 and atomic_inc_64_nv are ever
+	 * separated, you need to also edit the libc i386 platform
+	 * specific mapfile and remove the NODYNSORT attribute
+	 * from atomic_inc_64_nv.
+	 */
+	ENTRY(atomic_inc_64)
+	ALTENTRY(atomic_inc_64_nv)
+	pushl	%edi
+	pushl	%ebx
+	movl	12(%esp), %edi
+	movl	(%edi), %eax
+	movl	4(%edi), %edx
+1:
+	xorl	%ebx, %ebx
+	xorl	%ecx, %ecx
+	incl	%ebx
+	addl	%eax, %ebx
+	adcl	%edx, %ecx
+	lock
+	cmpxchg8b (%edi)
+	jne	1b
+	movl	%ebx, %eax
+	movl	%ecx, %edx
+	popl	%ebx
+	popl	%edi
+	ret
+	SET_SIZE(atomic_inc_64_nv)
+	SET_SIZE(atomic_inc_64)
+
+	ENTRY(atomic_dec_8)
+	ALTENTRY(atomic_dec_uchar)
+	movl	4(%esp), %eax
+	lock
+	decb	(%eax)
+	ret
+	SET_SIZE(atomic_dec_uchar)
+	SET_SIZE(atomic_dec_8)
+
+	ENTRY(atomic_dec_16)
+	ALTENTRY(atomic_dec_ushort)
+	movl	4(%esp), %eax
+	lock
+	decw	(%eax)
+	ret
+	SET_SIZE(atomic_dec_ushort)
+	SET_SIZE(atomic_dec_16)
+
+	ENTRY(atomic_dec_32)
+	ALTENTRY(atomic_dec_uint)
+	ALTENTRY(atomic_dec_ulong)
+	movl	4(%esp), %eax
+	lock
+	decl	(%eax)
+	ret
+	SET_SIZE(atomic_dec_ulong)
+	SET_SIZE(atomic_dec_uint)
+	SET_SIZE(atomic_dec_32)
+
+	ENTRY(atomic_dec_8_nv)
+	ALTENTRY(atomic_dec_uchar_nv)
+	movl	4(%esp), %edx
+	movb	(%edx), %al
+1:
+	leal	-1(%eax), %ecx
+	lock
+	cmpxchgb %cl, (%edx)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_dec_uchar_nv)
+	SET_SIZE(atomic_dec_8_nv)
+
+	ENTRY(atomic_dec_16_nv)
+	ALTENTRY(atomic_dec_ushort_nv)
+	movl	4(%esp), %edx
+	movw	(%edx), %ax
+1:
+	leal	-1(%eax), %ecx
+	lock
+	cmpxchgw %cx, (%edx)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_dec_ushort_nv)
+	SET_SIZE(atomic_dec_16_nv)
+
+	ENTRY(atomic_dec_32_nv)
+	ALTENTRY(atomic_dec_uint_nv)
+	ALTENTRY(atomic_dec_ulong_nv)
+	movl	4(%esp), %edx
+	movl	(%edx), %eax
+1:
+	leal	-1(%eax), %ecx
+	lock
+	cmpxchgl %ecx, (%edx)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_dec_ulong_nv)
+	SET_SIZE(atomic_dec_uint_nv)
+	SET_SIZE(atomic_dec_32_nv)
+
+	/*
+	 * NOTE: If atomic_dec_64 and atomic_dec_64_nv are ever
+	 * separated, it is important to edit the libc i386 platform
+	 * specific mapfile and remove the NODYNSORT attribute
+	 * from atomic_dec_64_nv.
+	 */
+	ENTRY(atomic_dec_64)
+	ALTENTRY(atomic_dec_64_nv)
+	pushl	%edi
+	pushl	%ebx
+	movl	12(%esp), %edi
+	movl	(%edi), %eax
+	movl	4(%edi), %edx
+1:
+	xorl	%ebx, %ebx
+	xorl	%ecx, %ecx
+	not	%ecx
+	not	%ebx
+	addl	%eax, %ebx
+	adcl	%edx, %ecx
+	lock
+	cmpxchg8b (%edi)
+	jne	1b
+	movl	%ebx, %eax
+	movl	%ecx, %edx
+	popl	%ebx
+	popl	%edi
+	ret
+	SET_SIZE(atomic_dec_64_nv)
+	SET_SIZE(atomic_dec_64)
+
+	ENTRY(atomic_add_8)
+	ALTENTRY(atomic_add_char)
+	movl	4(%esp), %eax
+	movl	8(%esp), %ecx
+	lock
+	addb	%cl, (%eax)
+	ret
+	SET_SIZE(atomic_add_char)
+	SET_SIZE(atomic_add_8)
+
+	ENTRY(atomic_add_16)
+	ALTENTRY(atomic_add_short)
+	movl	4(%esp), %eax
+	movl	8(%esp), %ecx
+	lock
+	addw	%cx, (%eax)
+	ret
+	SET_SIZE(atomic_add_short)
+	SET_SIZE(atomic_add_16)
+
+	ENTRY(atomic_add_32)
+	ALTENTRY(atomic_add_int)
+	ALTENTRY(atomic_add_ptr)
+	ALTENTRY(atomic_add_long)
+	movl	4(%esp), %eax
+	movl	8(%esp), %ecx
+	lock
+	addl	%ecx, (%eax)
+	ret
+	SET_SIZE(atomic_add_long)
+	SET_SIZE(atomic_add_ptr)
+	SET_SIZE(atomic_add_int)
+	SET_SIZE(atomic_add_32)
+
+	ENTRY(atomic_or_8)
+	ALTENTRY(atomic_or_uchar)
+	movl	4(%esp), %eax
+	movb	8(%esp), %cl
+	lock
+	orb	%cl, (%eax)
+	ret
+	SET_SIZE(atomic_or_uchar)
+	SET_SIZE(atomic_or_8)
+
+	ENTRY(atomic_or_16)
+	ALTENTRY(atomic_or_ushort)
+	movl	4(%esp), %eax
+	movw	8(%esp), %cx
+	lock
+	orw	%cx, (%eax)
+	ret
+	SET_SIZE(atomic_or_ushort)
+	SET_SIZE(atomic_or_16)
+
+	ENTRY(atomic_or_32)
+	ALTENTRY(atomic_or_uint)
+	ALTENTRY(atomic_or_ulong)
+	movl	4(%esp), %eax
+	movl	8(%esp), %ecx
+	lock
+	orl	%ecx, (%eax)
+	ret
+	SET_SIZE(atomic_or_ulong)
+	SET_SIZE(atomic_or_uint)
+	SET_SIZE(atomic_or_32)
+
+	ENTRY(atomic_and_8)
+	ALTENTRY(atomic_and_uchar)
+	movl	4(%esp), %eax
+	movb	8(%esp), %cl
+	lock
+	andb	%cl, (%eax)
+	ret
+	SET_SIZE(atomic_and_uchar)
+	SET_SIZE(atomic_and_8)
+
+	ENTRY(atomic_and_16)
+	ALTENTRY(atomic_and_ushort)
+	movl	4(%esp), %eax
+	movw	8(%esp), %cx
+	lock
+	andw	%cx, (%eax)
+	ret
+	SET_SIZE(atomic_and_ushort)
+	SET_SIZE(atomic_and_16)
+
+	ENTRY(atomic_and_32)
+	ALTENTRY(atomic_and_uint)
+	ALTENTRY(atomic_and_ulong)
+	movl	4(%esp), %eax
+	movl	8(%esp), %ecx
+	lock
+	andl	%ecx, (%eax)
+	ret
+	SET_SIZE(atomic_and_ulong)
+	SET_SIZE(atomic_and_uint)
+	SET_SIZE(atomic_and_32)
+
+	ENTRY(atomic_add_8_nv)
+	ALTENTRY(atomic_add_char_nv)
+	movl	4(%esp), %edx
+	movb	(%edx), %al
+1:
+	movl	8(%esp), %ecx
+	addb	%al, %cl
+	lock
+	cmpxchgb %cl, (%edx)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_add_char_nv)
+	SET_SIZE(atomic_add_8_nv)
+
+	ENTRY(atomic_add_16_nv)
+	ALTENTRY(atomic_add_short_nv)
+	movl	4(%esp), %edx
+	movw	(%edx), %ax
+1:
+	movl	8(%esp), %ecx
+	addw	%ax, %cx
+	lock
+	cmpxchgw %cx, (%edx)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_add_short_nv)
+	SET_SIZE(atomic_add_16_nv)
+
+	ENTRY(atomic_add_32_nv)
+	ALTENTRY(atomic_add_int_nv)
+	ALTENTRY(atomic_add_ptr_nv)
+	ALTENTRY(atomic_add_long_nv)
+	movl	4(%esp), %edx
+	movl	(%edx), %eax
+1:
+	movl	8(%esp), %ecx
+	addl	%eax, %ecx
+	lock
+	cmpxchgl %ecx, (%edx)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_add_long_nv)
+	SET_SIZE(atomic_add_ptr_nv)
+	SET_SIZE(atomic_add_int_nv)
+	SET_SIZE(atomic_add_32_nv)
+
+	/*
+	 * NOTE: If atomic_add_64 and atomic_add_64_nv are ever
+	 * separated, it is important to edit the libc i386 platform
+	 * specific mapfile and remove the NODYNSORT attribute
+	 * from atomic_add_64_nv.
+	 */
+	ENTRY(atomic_add_64)
+	ALTENTRY(atomic_add_64_nv)
+	pushl	%edi
+	pushl	%ebx
+	movl	12(%esp), %edi
+	movl	(%edi), %eax
+	movl	4(%edi), %edx
+1:
+	movl	16(%esp), %ebx
+	movl	20(%esp), %ecx
+	addl	%eax, %ebx
+	adcl	%edx, %ecx
+	lock
+	cmpxchg8b (%edi)
+	jne	1b
+	movl	%ebx, %eax
+	movl	%ecx, %edx
+	popl	%ebx
+	popl	%edi
+	ret
+	SET_SIZE(atomic_add_64_nv)
+	SET_SIZE(atomic_add_64)
+
+	ENTRY(atomic_or_8_nv)
+	ALTENTRY(atomic_or_uchar_nv)
+	movl	4(%esp), %edx
+	movb	(%edx), %al
+1:
+	movl	8(%esp), %ecx
+	orb	%al, %cl
+	lock
+	cmpxchgb %cl, (%edx)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_or_uchar_nv)
+	SET_SIZE(atomic_or_8_nv)
+
+	ENTRY(atomic_or_16_nv)
+	ALTENTRY(atomic_or_ushort_nv)
+	movl	4(%esp), %edx
+	movw	(%edx), %ax
+1:
+	movl	8(%esp), %ecx
+	orw	%ax, %cx
+	lock
+	cmpxchgw %cx, (%edx)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_or_ushort_nv)
+	SET_SIZE(atomic_or_16_nv)
+
+	ENTRY(atomic_or_32_nv)
+	ALTENTRY(atomic_or_uint_nv)
+	ALTENTRY(atomic_or_ulong_nv)
+	movl	4(%esp), %edx
+	movl	(%edx), %eax
+1:
+	movl	8(%esp), %ecx
+	orl	%eax, %ecx
+	lock
+	cmpxchgl %ecx, (%edx)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_or_ulong_nv)
+	SET_SIZE(atomic_or_uint_nv)
+	SET_SIZE(atomic_or_32_nv)
+
+	/*
+	 * NOTE: If atomic_or_64 and atomic_or_64_nv are ever
+	 * separated, it is important to edit the libc i386 platform
+	 * specific mapfile and remove the NODYNSORT attribute
+	 * from atomic_or_64_nv.
+	 */
+	ENTRY(atomic_or_64)
+	ALTENTRY(atomic_or_64_nv)
+	pushl	%edi
+	pushl	%ebx
+	movl	12(%esp), %edi
+	movl	(%edi), %eax
+	movl	4(%edi), %edx
+1:
+	movl	16(%esp), %ebx
+	movl	20(%esp), %ecx
+	orl	%eax, %ebx
+	orl	%edx, %ecx
+	lock
+	cmpxchg8b (%edi)
+	jne	1b
+	movl	%ebx, %eax
+	movl	%ecx, %edx
+	popl	%ebx
+	popl	%edi
+	ret
+	SET_SIZE(atomic_or_64_nv)
+	SET_SIZE(atomic_or_64)
+
+	ENTRY(atomic_and_8_nv)
+	ALTENTRY(atomic_and_uchar_nv)
+	movl	4(%esp), %edx
+	movb	(%edx), %al
+1:
+	movl	8(%esp), %ecx
+	andb	%al, %cl
+	lock
+	cmpxchgb %cl, (%edx)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_and_uchar_nv)
+	SET_SIZE(atomic_and_8_nv)
+
+	ENTRY(atomic_and_16_nv)
+	ALTENTRY(atomic_and_ushort_nv)
+	movl	4(%esp), %edx
+	movw	(%edx), %ax
+1:
+	movl	8(%esp), %ecx
+	andw	%ax, %cx
+	lock
+	cmpxchgw %cx, (%edx)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_and_ushort_nv)
+	SET_SIZE(atomic_and_16_nv)
+
+	ENTRY(atomic_and_32_nv)
+	ALTENTRY(atomic_and_uint_nv)
+	ALTENTRY(atomic_and_ulong_nv)
+	movl	4(%esp), %edx
+	movl	(%edx), %eax
+1:
+	movl	8(%esp), %ecx
+	andl	%eax, %ecx
+	lock
+	cmpxchgl %ecx, (%edx)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_and_ulong_nv)
+	SET_SIZE(atomic_and_uint_nv)
+	SET_SIZE(atomic_and_32_nv)
+
+	/*
+	 * NOTE: If atomic_and_64 and atomic_and_64_nv are ever
+	 * separated, it is important to edit the libc i386 platform
+	 * specific mapfile and remove the NODYNSORT attribute
+	 * from atomic_and_64_nv.
+	 */
+	ENTRY(atomic_and_64)
+	ALTENTRY(atomic_and_64_nv)
+	pushl	%edi
+	pushl	%ebx
+	movl	12(%esp), %edi
+	movl	(%edi), %eax
+	movl	4(%edi), %edx
+1:
+	movl	16(%esp), %ebx
+	movl	20(%esp), %ecx
+	andl	%eax, %ebx
+	andl	%edx, %ecx
+	lock
+	cmpxchg8b (%edi)
+	jne	1b
+	movl	%ebx, %eax
+	movl	%ecx, %edx
+	popl	%ebx
+	popl	%edi
+	ret
+	SET_SIZE(atomic_and_64_nv)
+	SET_SIZE(atomic_and_64)
+
+	ENTRY(atomic_cas_8)
+	ALTENTRY(atomic_cas_uchar)
+	movl	4(%esp), %edx
+	movzbl	8(%esp), %eax
+	movb	12(%esp), %cl
+	lock
+	cmpxchgb %cl, (%edx)
+	ret
+	SET_SIZE(atomic_cas_uchar)
+	SET_SIZE(atomic_cas_8)
+
+	ENTRY(atomic_cas_16)
+	ALTENTRY(atomic_cas_ushort)
+	movl	4(%esp), %edx
+	movzwl	8(%esp), %eax
+	movw	12(%esp), %cx
+	lock
+	cmpxchgw %cx, (%edx)
+	ret
+	SET_SIZE(atomic_cas_ushort)
+	SET_SIZE(atomic_cas_16)
+
+	ENTRY(atomic_cas_32)
+	ALTENTRY(atomic_cas_uint)
+	ALTENTRY(atomic_cas_ulong)
+	ALTENTRY(atomic_cas_ptr)
+	movl	4(%esp), %edx
+	movl	8(%esp), %eax
+	movl	12(%esp), %ecx
+	lock
+	cmpxchgl %ecx, (%edx)
+	ret
+	SET_SIZE(atomic_cas_ptr)
+	SET_SIZE(atomic_cas_ulong)
+	SET_SIZE(atomic_cas_uint)
+	SET_SIZE(atomic_cas_32)
+
+	ENTRY(atomic_cas_64)
+	pushl	%ebx
+	pushl	%esi
+	movl	12(%esp), %esi
+	movl	16(%esp), %eax
+	movl	20(%esp), %edx
+	movl	24(%esp), %ebx
+	movl	28(%esp), %ecx
+	lock
+	cmpxchg8b (%esi)
+	popl	%esi
+	popl	%ebx
+	ret
+	SET_SIZE(atomic_cas_64)
+
+	ENTRY(atomic_swap_8)
+	ALTENTRY(atomic_swap_uchar)
+	movl	4(%esp), %edx
+	movzbl	8(%esp), %eax
+	lock
+	xchgb	%al, (%edx)
+	ret
+	SET_SIZE(atomic_swap_uchar)
+	SET_SIZE(atomic_swap_8)
+
+	ENTRY(atomic_swap_16)
+	ALTENTRY(atomic_swap_ushort)
+	movl	4(%esp), %edx
+	movzwl	8(%esp), %eax
+	lock
+	xchgw	%ax, (%edx)
+	ret
+	SET_SIZE(atomic_swap_ushort)
+	SET_SIZE(atomic_swap_16)
+
+	ENTRY(atomic_swap_32)
+	ALTENTRY(atomic_swap_uint)
+	ALTENTRY(atomic_swap_ptr)
+	ALTENTRY(atomic_swap_ulong)
+	movl	4(%esp), %edx
+	movl	8(%esp), %eax
+	lock
+	xchgl	%eax, (%edx)
+	ret
+	SET_SIZE(atomic_swap_ulong)
+	SET_SIZE(atomic_swap_ptr)
+	SET_SIZE(atomic_swap_uint)
+	SET_SIZE(atomic_swap_32)
+
+	ENTRY(atomic_swap_64)
+	pushl	%esi
+	pushl	%ebx
+	movl	12(%esp), %esi
+	movl	16(%esp), %ebx
+	movl	20(%esp), %ecx
+	movl	(%esi), %eax
+	movl	4(%esi), %edx
+1:
+	lock
+	cmpxchg8b (%esi)
+	jne	1b
+	popl	%ebx
+	popl	%esi
+	ret
+	SET_SIZE(atomic_swap_64)
+
+	ENTRY(atomic_set_long_excl)
+	movl	4(%esp), %edx
+	movl	8(%esp), %ecx
+	xorl	%eax, %eax
+	lock
+	btsl	%ecx, (%edx)
+	jnc	1f
+	decl	%eax
+1:
+	ret
+	SET_SIZE(atomic_set_long_excl)
+
+	ENTRY(atomic_clear_long_excl)
+	movl	4(%esp), %edx
+	movl	8(%esp), %ecx
+	xorl	%eax, %eax
+	lock
+	btrl	%ecx, (%edx)
+	jc	1f
+	decl	%eax
+1:
+	ret
+	SET_SIZE(atomic_clear_long_excl)
+
+	/*
+	 * NOTE: membar_enter, membar_exit, membar_producer, and 
+	 * membar_consumer are all identical routines. We define them
+	 * separately, instead of using ALTENTRY definitions to alias them
+	 * together, so that DTrace and debuggers will see a unique address
+	 * for them, allowing more accurate tracing.
+	*/
+
+
+	ENTRY(membar_enter)
+	lock
+	xorl	$0, (%esp)
+	ret
+	SET_SIZE(membar_enter)
+
+	ENTRY(membar_exit)
+	lock
+	xorl	$0, (%esp)
+	ret
+	SET_SIZE(membar_exit)
+
+	ENTRY(membar_producer)
+	lock
+	xorl	$0, (%esp)
+	ret
+	SET_SIZE(membar_producer)
+
+	ENTRY(membar_consumer)
+	lock
+	xorl	$0, (%esp)
+	ret
+	SET_SIZE(membar_consumer)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",%progbits
+#endif

lib/libspl/asm-x86_64/Makefile.am

@@ -0,0 +1 @@
+noinst_HEADERS = *.S

lib/libspl/asm-x86_64/atomic.S

@@ -0,0 +1,595 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+	.ident	"%Z%%M%	%I%	%E% SMI"
+
+	.file	"%M%"
+
+#define _ASM
+#include <ia32/sys/asm_linkage.h>
+
+	ENTRY(atomic_inc_8)
+	ALTENTRY(atomic_inc_uchar)
+	lock
+	incb	(%rdi)
+	ret
+	SET_SIZE(atomic_inc_uchar)
+	SET_SIZE(atomic_inc_8)
+
+	ENTRY(atomic_inc_16)
+	ALTENTRY(atomic_inc_ushort)
+	lock
+	incw	(%rdi)
+	ret
+	SET_SIZE(atomic_inc_ushort)
+	SET_SIZE(atomic_inc_16)
+
+	ENTRY(atomic_inc_32)
+	ALTENTRY(atomic_inc_uint)
+	lock
+	incl	(%rdi)
+	ret
+	SET_SIZE(atomic_inc_uint)
+	SET_SIZE(atomic_inc_32)
+
+	ENTRY(atomic_inc_64)
+	ALTENTRY(atomic_inc_ulong)
+	lock
+	incq	(%rdi)
+	ret
+	SET_SIZE(atomic_inc_ulong)
+	SET_SIZE(atomic_inc_64)
+
+	ENTRY(atomic_inc_8_nv)
+	ALTENTRY(atomic_inc_uchar_nv)
+	movb	(%rdi), %al
+1:
+	leaq	1(%rax), %rcx
+	lock
+	cmpxchgb %cl, (%rdi)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_inc_uchar_nv)
+	SET_SIZE(atomic_inc_8_nv)
+
+	ENTRY(atomic_inc_16_nv)
+	ALTENTRY(atomic_inc_ushort_nv)
+	movw	(%rdi), %ax
+1:
+	leaq	1(%rax), %rcx
+	lock
+	cmpxchgw %cx, (%rdi)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_inc_ushort_nv)
+	SET_SIZE(atomic_inc_16_nv)
+
+	ENTRY(atomic_inc_32_nv)
+	ALTENTRY(atomic_inc_uint_nv)
+	movl	(%rdi), %eax
+1:
+	leaq	1(%rax), %rcx
+	lock
+	cmpxchgl %ecx, (%rdi)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_inc_uint_nv)
+	SET_SIZE(atomic_inc_32_nv)
+
+	ENTRY(atomic_inc_64_nv)
+	ALTENTRY(atomic_inc_ulong_nv)
+	movq	(%rdi), %rax
+1:
+	leaq	1(%rax), %rcx
+	lock
+	cmpxchgq %rcx, (%rdi)
+	jne	1b
+	movq	%rcx, %rax
+	ret
+	SET_SIZE(atomic_inc_ulong_nv)
+	SET_SIZE(atomic_inc_64_nv)
+
+	ENTRY(atomic_dec_8)
+	ALTENTRY(atomic_dec_uchar)
+	lock
+	decb	(%rdi)
+	ret
+	SET_SIZE(atomic_dec_uchar)
+	SET_SIZE(atomic_dec_8)
+
+	ENTRY(atomic_dec_16)
+	ALTENTRY(atomic_dec_ushort)
+	lock
+	decw	(%rdi)
+	ret
+	SET_SIZE(atomic_dec_ushort)
+	SET_SIZE(atomic_dec_16)
+
+	ENTRY(atomic_dec_32)
+	ALTENTRY(atomic_dec_uint)
+	lock
+	decl	(%rdi)
+	ret
+	SET_SIZE(atomic_dec_uint)
+	SET_SIZE(atomic_dec_32)
+
+	ENTRY(atomic_dec_64)
+	ALTENTRY(atomic_dec_ulong)
+	lock
+	decq	(%rdi)
+	ret
+	SET_SIZE(atomic_dec_ulong)
+	SET_SIZE(atomic_dec_64)
+
+	ENTRY(atomic_dec_8_nv)
+	ALTENTRY(atomic_dec_uchar_nv)
+	movb	(%rdi), %al
+1:
+	leaq	-1(%rax), %rcx
+	lock
+	cmpxchgb %cl, (%rdi)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_dec_uchar_nv)
+	SET_SIZE(atomic_dec_8_nv)
+
+	ENTRY(atomic_dec_16_nv)
+	ALTENTRY(atomic_dec_ushort_nv)
+	movw	(%rdi), %ax
+1:
+	leaq	-1(%rax), %rcx
+	lock
+	cmpxchgw %cx, (%rdi)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_dec_ushort_nv)
+	SET_SIZE(atomic_dec_16_nv)
+
+	ENTRY(atomic_dec_32_nv)
+	ALTENTRY(atomic_dec_uint_nv)
+	movl	(%rdi), %eax
+1:
+	leaq	-1(%rax), %rcx
+	lock
+	cmpxchgl %ecx, (%rdi)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_dec_uint_nv)
+	SET_SIZE(atomic_dec_32_nv)
+
+	ENTRY(atomic_dec_64_nv)
+	ALTENTRY(atomic_dec_ulong_nv)
+	movq	(%rdi), %rax
+1:
+	leaq	-1(%rax), %rcx
+	lock
+	cmpxchgq %rcx, (%rdi)
+	jne	1b
+	movq	%rcx, %rax
+	ret
+	SET_SIZE(atomic_dec_ulong_nv)
+	SET_SIZE(atomic_dec_64_nv)
+
+	ENTRY(atomic_add_8)
+	ALTENTRY(atomic_add_char)
+	lock
+	addb	%sil, (%rdi)
+	ret
+	SET_SIZE(atomic_add_char)
+	SET_SIZE(atomic_add_8)
+
+	ENTRY(atomic_add_16)
+	ALTENTRY(atomic_add_short)
+	lock
+	addw	%si, (%rdi)
+	ret
+	SET_SIZE(atomic_add_short)
+	SET_SIZE(atomic_add_16)
+
+	ENTRY(atomic_add_32)
+	ALTENTRY(atomic_add_int)
+	lock
+	addl	%esi, (%rdi)
+	ret
+	SET_SIZE(atomic_add_int)
+	SET_SIZE(atomic_add_32)
+
+	ENTRY(atomic_add_64)
+	ALTENTRY(atomic_add_ptr)
+	ALTENTRY(atomic_add_long)
+	lock
+	addq	%rsi, (%rdi)
+	ret
+	SET_SIZE(atomic_add_long)
+	SET_SIZE(atomic_add_ptr)
+	SET_SIZE(atomic_add_64)
+
+	ENTRY(atomic_or_8)
+	ALTENTRY(atomic_or_uchar)
+	lock
+	orb	%sil, (%rdi)
+	ret
+	SET_SIZE(atomic_or_uchar)
+	SET_SIZE(atomic_or_8)
+
+	ENTRY(atomic_or_16)
+	ALTENTRY(atomic_or_ushort)
+	lock
+	orw	%si, (%rdi)
+	ret
+	SET_SIZE(atomic_or_ushort)
+	SET_SIZE(atomic_or_16)
+
+	ENTRY(atomic_or_32)
+	ALTENTRY(atomic_or_uint)
+	lock
+	orl	%esi, (%rdi)
+	ret
+	SET_SIZE(atomic_or_uint)
+	SET_SIZE(atomic_or_32)
+
+	ENTRY(atomic_or_64)
+	ALTENTRY(atomic_or_ulong)
+	lock
+	orq	%rsi, (%rdi)
+	ret
+	SET_SIZE(atomic_or_ulong)
+	SET_SIZE(atomic_or_64)
+
+	ENTRY(atomic_and_8)
+	ALTENTRY(atomic_and_uchar)
+	lock
+	andb	%sil, (%rdi)
+	ret
+	SET_SIZE(atomic_and_uchar)
+	SET_SIZE(atomic_and_8)
+
+	ENTRY(atomic_and_16)
+	ALTENTRY(atomic_and_ushort)
+	lock
+	andw	%si, (%rdi)
+	ret
+	SET_SIZE(atomic_and_ushort)
+	SET_SIZE(atomic_and_16)
+
+	ENTRY(atomic_and_32)
+	ALTENTRY(atomic_and_uint)
+	lock
+	andl	%esi, (%rdi)
+	ret
+	SET_SIZE(atomic_and_uint)
+	SET_SIZE(atomic_and_32)
+
+	ENTRY(atomic_and_64)
+	ALTENTRY(atomic_and_ulong)
+	lock
+	andq	%rsi, (%rdi)
+	ret
+	SET_SIZE(atomic_and_ulong)
+	SET_SIZE(atomic_and_64)
+
+	ENTRY(atomic_add_8_nv)
+	ALTENTRY(atomic_add_char_nv)
+	movb	(%rdi), %al
+1:
+	movb	%sil, %cl
+	addb	%al, %cl
+	lock
+	cmpxchgb %cl, (%rdi)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_add_char_nv)
+	SET_SIZE(atomic_add_8_nv)
+
+	ENTRY(atomic_add_16_nv)
+	ALTENTRY(atomic_add_short_nv)
+	movw	(%rdi), %ax
+1:
+	movw	%si, %cx
+	addw	%ax, %cx
+	lock
+	cmpxchgw %cx, (%rdi)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_add_short_nv)
+	SET_SIZE(atomic_add_16_nv)
+
+	ENTRY(atomic_add_32_nv)
+	ALTENTRY(atomic_add_int_nv)
+	movl	(%rdi), %eax
+1:
+	movl	%esi, %ecx
+	addl	%eax, %ecx
+	lock
+	cmpxchgl %ecx, (%rdi)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_add_int_nv)
+	SET_SIZE(atomic_add_32_nv)
+
+	ENTRY(atomic_add_64_nv)
+	ALTENTRY(atomic_add_ptr_nv)
+	ALTENTRY(atomic_add_long_nv)
+	movq	(%rdi), %rax
+1:
+	movq	%rsi, %rcx
+	addq	%rax, %rcx
+	lock
+	cmpxchgq %rcx, (%rdi)
+	jne	1b
+	movq	%rcx, %rax
+	ret
+	SET_SIZE(atomic_add_long_nv)
+	SET_SIZE(atomic_add_ptr_nv)
+	SET_SIZE(atomic_add_64_nv)
+
+	ENTRY(atomic_and_8_nv)
+	ALTENTRY(atomic_and_uchar_nv)
+	movb	(%rdi), %al
+1:
+	movb	%sil, %cl
+	andb	%al, %cl
+	lock
+	cmpxchgb %cl, (%rdi)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_and_uchar_nv)
+	SET_SIZE(atomic_and_8_nv)
+
+	ENTRY(atomic_and_16_nv)
+	ALTENTRY(atomic_and_ushort_nv)
+	movw	(%rdi), %ax
+1:
+	movw	%si, %cx
+	andw	%ax, %cx
+	lock
+	cmpxchgw %cx, (%rdi)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_and_ushort_nv)
+	SET_SIZE(atomic_and_16_nv)
+
+	ENTRY(atomic_and_32_nv)
+	ALTENTRY(atomic_and_uint_nv)
+	movl	(%rdi), %eax
+1:
+	movl	%esi, %ecx
+	andl	%eax, %ecx
+	lock
+	cmpxchgl %ecx, (%rdi)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_and_uint_nv)
+	SET_SIZE(atomic_and_32_nv)
+
+	ENTRY(atomic_and_64_nv)
+	ALTENTRY(atomic_and_ulong_nv)
+	movq	(%rdi), %rax
+1:
+	movq	%rsi, %rcx
+	andq	%rax, %rcx
+	lock
+	cmpxchgq %rcx, (%rdi)
+	jne	1b
+	movq	%rcx, %rax
+	ret
+	SET_SIZE(atomic_and_ulong_nv)
+	SET_SIZE(atomic_and_64_nv)
+
+	ENTRY(atomic_or_8_nv)
+	ALTENTRY(atomic_or_uchar_nv)
+	movb	(%rdi), %al
+1:
+	movb	%sil, %cl
+	orb	%al, %cl
+	lock
+	cmpxchgb %cl, (%rdi)
+	jne	1b
+	movzbl	%cl, %eax
+	ret
+	SET_SIZE(atomic_and_uchar_nv)
+	SET_SIZE(atomic_and_8_nv)
+
+	ENTRY(atomic_or_16_nv)
+	ALTENTRY(atomic_or_ushort_nv)
+	movw	(%rdi), %ax
+1:
+	movw	%si, %cx
+	orw	%ax, %cx
+	lock
+	cmpxchgw %cx, (%rdi)
+	jne	1b
+	movzwl	%cx, %eax
+	ret
+	SET_SIZE(atomic_or_ushort_nv)
+	SET_SIZE(atomic_or_16_nv)
+
+	ENTRY(atomic_or_32_nv)
+	ALTENTRY(atomic_or_uint_nv)
+	movl	(%rdi), %eax
+1:
+	movl	%esi, %ecx
+	orl	%eax, %ecx
+	lock
+	cmpxchgl %ecx, (%rdi)
+	jne	1b
+	movl	%ecx, %eax
+	ret
+	SET_SIZE(atomic_or_uint_nv)
+	SET_SIZE(atomic_or_32_nv)
+
+	ENTRY(atomic_or_64_nv)
+	ALTENTRY(atomic_or_ulong_nv)
+	movq	(%rdi), %rax
+1:
+	movq	%rsi, %rcx
+	orq	%rax, %rcx
+	lock
+	cmpxchgq %rcx, (%rdi)
+	jne	1b
+	movq	%rcx, %rax
+	ret
+	SET_SIZE(atomic_or_ulong_nv)
+	SET_SIZE(atomic_or_64_nv)
+
+	ENTRY(atomic_cas_8)
+	ALTENTRY(atomic_cas_uchar)
+	movzbl	%sil, %eax
+	lock
+	cmpxchgb %dl, (%rdi)
+	ret
+	SET_SIZE(atomic_cas_uchar)
+	SET_SIZE(atomic_cas_8)
+
+	ENTRY(atomic_cas_16)
+	ALTENTRY(atomic_cas_ushort)
+	movzwl	%si, %eax
+	lock
+	cmpxchgw %dx, (%rdi)
+	ret
+	SET_SIZE(atomic_cas_ushort)
+	SET_SIZE(atomic_cas_16)
+
+	ENTRY(atomic_cas_32)
+	ALTENTRY(atomic_cas_uint)
+	movl	%esi, %eax
+	lock
+	cmpxchgl %edx, (%rdi)
+	ret
+	SET_SIZE(atomic_cas_uint)
+	SET_SIZE(atomic_cas_32)
+
+	ENTRY(atomic_cas_64)
+	ALTENTRY(atomic_cas_ulong)
+	ALTENTRY(atomic_cas_ptr)
+	movq	%rsi, %rax
+	lock
+	cmpxchgq %rdx, (%rdi)
+	ret
+	SET_SIZE(atomic_cas_ptr)
+	SET_SIZE(atomic_cas_ulong)
+	SET_SIZE(atomic_cas_64)
+
+	ENTRY(atomic_swap_8)
+	ALTENTRY(atomic_swap_uchar)
+	movzbl	%sil, %eax
+	lock
+	xchgb %al, (%rdi)
+	ret
+	SET_SIZE(atomic_swap_uchar)
+	SET_SIZE(atomic_swap_8)
+
+	ENTRY(atomic_swap_16)
+	ALTENTRY(atomic_swap_ushort)
+	movzwl	%si, %eax
+	lock
+	xchgw %ax, (%rdi)
+	ret
+	SET_SIZE(atomic_swap_ushort)
+	SET_SIZE(atomic_swap_16)
+
+	ENTRY(atomic_swap_32)
+	ALTENTRY(atomic_swap_uint)
+	movl	%esi, %eax
+	lock
+	xchgl %eax, (%rdi)
+	ret
+	SET_SIZE(atomic_swap_uint)
+	SET_SIZE(atomic_swap_32)
+
+	ENTRY(atomic_swap_64)
+	ALTENTRY(atomic_swap_ulong)
+	ALTENTRY(atomic_swap_ptr)
+	movq	%rsi, %rax
+	lock
+	xchgq %rax, (%rdi)
+	ret
+	SET_SIZE(atomic_swap_ptr)
+	SET_SIZE(atomic_swap_ulong)
+	SET_SIZE(atomic_swap_64)
+
+	ENTRY(atomic_set_long_excl)
+	xorl	%eax, %eax
+	lock
+	btsq	%rsi, (%rdi)
+	jnc	1f
+	decl	%eax
+1:
+	ret
+	SET_SIZE(atomic_set_long_excl)
+
+	ENTRY(atomic_clear_long_excl)
+	xorl	%eax, %eax
+	lock
+	btrq	%rsi, (%rdi)
+	jc	1f
+	decl	%eax
+1:
+	ret
+	SET_SIZE(atomic_clear_long_excl)
+
+	/*
+	 * NOTE: membar_enter, and membar_exit are identical routines. 
+	 * We define them separately, instead of using an ALTENTRY
+	 * definitions to alias them together, so that DTrace and
+	 * debuggers will see a unique address for them, allowing 
+	 * more accurate tracing.
+	*/
+
+	ENTRY(membar_enter)
+	mfence
+	ret
+	SET_SIZE(membar_enter)
+
+	ENTRY(membar_exit)
+	mfence
+	ret
+	SET_SIZE(membar_exit)
+
+	ENTRY(membar_producer)
+	sfence
+	ret
+	SET_SIZE(membar_producer)
+
+	ENTRY(membar_consumer)
+	lfence
+	ret
+	SET_SIZE(membar_consumer)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",%progbits
+#endif

lib/libspl/getexecname.c

@@ -0,0 +1,57 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <limits.h>
+
+const char *
+getexecname(void)
+{
+	static char execname[PATH_MAX + 1] = "";
+	static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
+	char *ptr = NULL;
+	ssize_t rc;
+
+	pthread_mutex_lock(&mtx);
+
+	if (strlen(execname) == 0) {
+		rc = readlink("/proc/self/exe", execname, sizeof(execname) - 1);
+		if (rc == -1) {
+			execname[0] = '\0';
+		} else {
+			execname[rc] = '\0';
+			ptr = execname;
+		}
+	} else {
+		ptr = execname;
+	}
+
+	pthread_mutex_unlock(&mtx);
+	return ptr;
+}

lib/libspl/gethrestime.c

@@ -0,0 +1,38 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <time.h>
+#include <sys/time.h>
+
+void
+gethrestime(timestruc_t *ts)
+{
+        struct timeval tv;
+
+        gettimeofday(&tv, NULL);
+        ts->tv_sec = tv.tv_sec;
+        ts->tv_nsec = tv.tv_usec * NSEC_PER_USEC;
+}

lib/libspl/gethrtime.c

@@ -0,0 +1,45 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <time.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+hrtime_t
+gethrtime(void)
+{
+	struct timespec ts;
+	int rc;
+
+	rc = clock_gettime(CLOCK_MONOTONIC, &ts);
+	if (rc) {
+		fprintf(stderr, "Error: clock_gettime() = %d\n", rc);
+	        abort();
+	}
+
+	return (((u_int64_t)ts.tv_sec) * NANOSEC) + ts.tv_nsec;
+}

lib/libspl/getmntany.c

@@ -0,0 +1,99 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2006 Ricardo Correia.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*	Copyright (c) 1988 AT&T	*/
+/*	  All Rights Reserved	*/
+
+#include <stdio.h>
+#include <string.h>
+#include <mntent.h>
+#include <sys/mnttab.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define BUFSIZE (MNT_LINE_MAX + 2)
+
+__thread char buf[BUFSIZE];
+
+#define DIFF(xx) ((mrefp->xx != NULL) && \
+		  (mgetp->xx == NULL || strcmp(mrefp->xx, mgetp->xx) != 0))
+
+int
+getmntany(FILE *fp, struct mnttab *mgetp, struct mnttab *mrefp)
+{
+	int ret;
+
+	while (((ret = _sol_getmntent(fp, mgetp)) == 0) &&
+	       (DIFF(mnt_special) || DIFF(mnt_mountp) ||
+		DIFF(mnt_fstype) || DIFF(mnt_mntopts)));
+
+	return ret;
+}
+
+int
+_sol_getmntent(FILE *fp, struct mnttab *mgetp)
+{
+	struct mntent mntbuf;
+	struct mntent *ret;
+
+	ret = getmntent_r(fp, &mntbuf, buf, BUFSIZE);
+
+	if (ret != NULL) {
+		mgetp->mnt_special = mntbuf.mnt_fsname;
+		mgetp->mnt_mountp = mntbuf.mnt_dir;
+		mgetp->mnt_fstype = mntbuf.mnt_type;
+		mgetp->mnt_mntopts = mntbuf.mnt_opts;
+		return 0;
+	}
+
+	if (feof(fp))
+		return -1;
+
+	return MNT_TOOLONG;
+}
+
+int
+getextmntent(FILE *fp, struct extmnttab *mp, int len)
+{
+	int ret;
+	struct stat64 st;
+
+	ret = _sol_getmntent(fp, (struct mnttab *) mp);
+	if (ret == 0) {
+		if (stat64(mp->mnt_mountp, &st) != 0) {
+			mp->mnt_major = 0;
+			mp->mnt_minor = 0;
+			return ret;
+		}
+		mp->mnt_major = major(st.st_dev);
+		mp->mnt_minor = minor(st.st_dev);
+	}
+
+	return ret;
+}

lib/libspl/include/Makefile.am

@@ -0,0 +1,7 @@
+nobase_pkginclude_HEADERS  = *.h
+nobase_pkginclude_HEADERS += ia32/sys/*.h
+nobase_pkginclude_HEADERS += rpc/*.h
+nobase_pkginclude_HEADERS += sys/*.h
+nobase_pkginclude_HEADERS += sys/dktp/*.h
+nobase_pkginclude_HEADERS += sys/sysevent/*.h
+nobase_pkginclude_HEADERS += util/*.h

lib/libspl/include/assert.h

@@ -0,0 +1,96 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <assert.h>
+
+#ifndef _LIBSPL_ASSERT_H
+#define _LIBSPL_ASSERT_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __assert_c99
+static inline void
+__assert_c99(const char *expr, const char *file, int line, const char *func)
+{
+	fprintf(stderr, "%s:%i: %s: Assertion `%s` failed.\n",
+		file, line, func, expr);
+	abort();
+}
+#endif  /* __assert_c99 */
+
+#ifndef verify
+#if defined(__STDC__)
+#if __STDC_VERSION__ - 0 >= 199901L
+#define	verify(EX) (void)((EX) || \
+	(__assert_c99(#EX, __FILE__, __LINE__, __func__), 0))
+#else
+#define	verify(EX) (void)((EX) || (__assert(#EX, __FILE__, __LINE__), 0))
+#endif  /* __STDC_VERSION__ - 0 >= 199901L */
+#else
+#define	verify(EX) (void)((EX) || (_assert("EX", __FILE__, __LINE__), 0))
+#endif	/* __STDC__ */
+#endif  /* verify */
+
+#undef VERIFY
+#undef ASSERT
+
+#define	VERIFY	verify
+#define	ASSERT	assert
+
+extern void __assert(const char *, const char *, int);
+
+/* BEGIN CSTYLED */
+#define	VERIFY3_IMPL(LEFT, OP, RIGHT, TYPE) do { \
+	const TYPE __left = (TYPE)(LEFT); \
+	const TYPE __right = (TYPE)(RIGHT); \
+	if (!(__left OP __right)) { \
+		char *__buf = alloca(256); \
+		(void) snprintf(__buf, 256, "%s %s %s (0x%llx %s 0x%llx)", \
+			#LEFT, #OP, #RIGHT, \
+			(u_longlong_t)__left, #OP, (u_longlong_t)__right); \
+		__assert(__buf, __FILE__, __LINE__); \
+	} \
+} while (0)
+/* END CSTYLED */
+
+#define	VERIFY3S(x, y, z)	VERIFY3_IMPL(x, y, z, int64_t)
+#define	VERIFY3U(x, y, z)	VERIFY3_IMPL(x, y, z, uint64_t)
+#define	VERIFY3P(x, y, z)	VERIFY3_IMPL(x, y, z, uintptr_t)
+
+#ifdef NDEBUG
+#define	ASSERT3S(x, y, z)	((void)0)
+#define	ASSERT3U(x, y, z)	((void)0)
+#define	ASSERT3P(x, y, z)	((void)0)
+#define	ASSERTV(x)
+#else
+#define	ASSERT3S(x, y, z)	VERIFY3S(x, y, z)
+#define	ASSERT3U(x, y, z)	VERIFY3U(x, y, z)
+#define	ASSERT3P(x, y, z)	VERIFY3P(x, y, z)
+#define	ASSERTV(x)		x
+#endif  /* NDEBUG */
+
+#endif  /* _LIBSPL_ASSERT_H */

lib/libspl/include/atomic.h

@@ -0,0 +1,266 @@
+/*
+ * 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 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_ATOMIC_H
+#define	_SYS_ATOMIC_H
+
+#include <sys/types.h>
+#include <sys/inttypes.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#if defined(__STDC__)
+/*
+ * Increment target.
+ */
+extern void atomic_inc_8(volatile uint8_t *);
+extern void atomic_inc_uchar(volatile uchar_t *);
+extern void atomic_inc_16(volatile uint16_t *);
+extern void atomic_inc_ushort(volatile ushort_t *);
+extern void atomic_inc_32(volatile uint32_t *);
+extern void atomic_inc_uint(volatile uint_t *);
+extern void atomic_inc_ulong(volatile ulong_t *);
+#if defined(_INT64_TYPE)
+extern void atomic_inc_64(volatile uint64_t *);
+#endif
+
+/*
+ * Decrement target
+ */
+extern void atomic_dec_8(volatile uint8_t *);
+extern void atomic_dec_uchar(volatile uchar_t *);
+extern void atomic_dec_16(volatile uint16_t *);
+extern void atomic_dec_ushort(volatile ushort_t *);
+extern void atomic_dec_32(volatile uint32_t *);
+extern void atomic_dec_uint(volatile uint_t *);
+extern void atomic_dec_ulong(volatile ulong_t *);
+#if defined(_INT64_TYPE)
+extern void atomic_dec_64(volatile uint64_t *);
+#endif
+
+/*
+ * Add delta to target
+ */
+extern void atomic_add_8(volatile uint8_t *, int8_t);
+extern void atomic_add_char(volatile uchar_t *, signed char);
+extern void atomic_add_16(volatile uint16_t *, int16_t);
+extern void atomic_add_short(volatile ushort_t *, short);
+extern void atomic_add_32(volatile uint32_t *, int32_t);
+extern void atomic_add_int(volatile uint_t *, int);
+extern void atomic_add_ptr(volatile void *, ssize_t);
+extern void atomic_add_long(volatile ulong_t *, long);
+#if defined(_INT64_TYPE)
+extern void atomic_add_64(volatile uint64_t *, int64_t);
+#endif
+
+/*
+ * logical OR bits with target
+ */
+extern void atomic_or_8(volatile uint8_t *, uint8_t);
+extern void atomic_or_uchar(volatile uchar_t *, uchar_t);
+extern void atomic_or_16(volatile uint16_t *, uint16_t);
+extern void atomic_or_ushort(volatile ushort_t *, ushort_t);
+extern void atomic_or_32(volatile uint32_t *, uint32_t);
+extern void atomic_or_uint(volatile uint_t *, uint_t);
+extern void atomic_or_ulong(volatile ulong_t *, ulong_t);
+#if defined(_INT64_TYPE)
+extern void atomic_or_64(volatile uint64_t *, uint64_t);
+#endif
+
+/*
+ * logical AND bits with target
+ */
+extern void atomic_and_8(volatile uint8_t *, uint8_t);
+extern void atomic_and_uchar(volatile uchar_t *, uchar_t);
+extern void atomic_and_16(volatile uint16_t *, uint16_t);
+extern void atomic_and_ushort(volatile ushort_t *, ushort_t);
+extern void atomic_and_32(volatile uint32_t *, uint32_t);
+extern void atomic_and_uint(volatile uint_t *, uint_t);
+extern void atomic_and_ulong(volatile ulong_t *, ulong_t);
+#if defined(_INT64_TYPE)
+extern void atomic_and_64(volatile uint64_t *, uint64_t);
+#endif
+
+/*
+ * As above, but return the new value.  Note that these _nv() variants are
+ * substantially more expensive on some platforms than the no-return-value
+ * versions above, so don't use them unless you really need to know the
+ * new value *atomically* (e.g. when decrementing a reference count and
+ * checking whether it went to zero).
+ */
+
+/*
+ * Increment target and return new value.
+ */
+extern uint8_t atomic_inc_8_nv(volatile uint8_t *);
+extern uchar_t atomic_inc_uchar_nv(volatile uchar_t *);
+extern uint16_t atomic_inc_16_nv(volatile uint16_t *);
+extern ushort_t atomic_inc_ushort_nv(volatile ushort_t *);
+extern uint32_t atomic_inc_32_nv(volatile uint32_t *);
+extern uint_t atomic_inc_uint_nv(volatile uint_t *);
+extern ulong_t atomic_inc_ulong_nv(volatile ulong_t *);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_inc_64_nv(volatile uint64_t *);
+#endif
+
+/*
+ * Decrement target and return new value.
+ */
+extern uint8_t atomic_dec_8_nv(volatile uint8_t *);
+extern uchar_t atomic_dec_uchar_nv(volatile uchar_t *);
+extern uint16_t atomic_dec_16_nv(volatile uint16_t *);
+extern ushort_t atomic_dec_ushort_nv(volatile ushort_t *);
+extern uint32_t atomic_dec_32_nv(volatile uint32_t *);
+extern uint_t atomic_dec_uint_nv(volatile uint_t *);
+extern ulong_t atomic_dec_ulong_nv(volatile ulong_t *);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_dec_64_nv(volatile uint64_t *);
+#endif
+
+/*
+ * Add delta to target
+ */
+extern uint8_t atomic_add_8_nv(volatile uint8_t *, int8_t);
+extern uchar_t atomic_add_char_nv(volatile uchar_t *, signed char);
+extern uint16_t atomic_add_16_nv(volatile uint16_t *, int16_t);
+extern ushort_t atomic_add_short_nv(volatile ushort_t *, short);
+extern uint32_t atomic_add_32_nv(volatile uint32_t *, int32_t);
+extern uint_t atomic_add_int_nv(volatile uint_t *, int);
+extern void *atomic_add_ptr_nv(volatile void *, ssize_t);
+extern ulong_t atomic_add_long_nv(volatile ulong_t *, long);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_add_64_nv(volatile uint64_t *, int64_t);
+#endif
+
+/*
+ * logical OR bits with target and return new value.
+ */
+extern uint8_t atomic_or_8_nv(volatile uint8_t *, uint8_t);
+extern uchar_t atomic_or_uchar_nv(volatile uchar_t *, uchar_t);
+extern uint16_t atomic_or_16_nv(volatile uint16_t *, uint16_t);
+extern ushort_t atomic_or_ushort_nv(volatile ushort_t *, ushort_t);
+extern uint32_t atomic_or_32_nv(volatile uint32_t *, uint32_t);
+extern uint_t atomic_or_uint_nv(volatile uint_t *, uint_t);
+extern ulong_t atomic_or_ulong_nv(volatile ulong_t *, ulong_t);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_or_64_nv(volatile uint64_t *, uint64_t);
+#endif
+
+/*
+ * logical AND bits with target and return new value.
+ */
+extern uint8_t atomic_and_8_nv(volatile uint8_t *, uint8_t);
+extern uchar_t atomic_and_uchar_nv(volatile uchar_t *, uchar_t);
+extern uint16_t atomic_and_16_nv(volatile uint16_t *, uint16_t);
+extern ushort_t atomic_and_ushort_nv(volatile ushort_t *, ushort_t);
+extern uint32_t atomic_and_32_nv(volatile uint32_t *, uint32_t);
+extern uint_t atomic_and_uint_nv(volatile uint_t *, uint_t);
+extern ulong_t atomic_and_ulong_nv(volatile ulong_t *, ulong_t);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_and_64_nv(volatile uint64_t *, uint64_t);
+#endif
+
+/*
+ * If *arg1 == arg2, set *arg1 = arg3; return old value
+ */
+extern uint8_t atomic_cas_8(volatile uint8_t *, uint8_t, uint8_t);
+extern uchar_t atomic_cas_uchar(volatile uchar_t *, uchar_t, uchar_t);
+extern uint16_t atomic_cas_16(volatile uint16_t *, uint16_t, uint16_t);
+extern ushort_t atomic_cas_ushort(volatile ushort_t *, ushort_t, ushort_t);
+extern uint32_t atomic_cas_32(volatile uint32_t *, uint32_t, uint32_t);
+extern uint_t atomic_cas_uint(volatile uint_t *, uint_t, uint_t);
+extern void *atomic_cas_ptr(volatile void *, void *, void *);
+extern ulong_t atomic_cas_ulong(volatile ulong_t *, ulong_t, ulong_t);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_cas_64(volatile uint64_t *, uint64_t, uint64_t);
+#endif
+
+/*
+ * Swap target and return old value
+ */
+extern uint8_t atomic_swap_8(volatile uint8_t *, uint8_t);
+extern uchar_t atomic_swap_uchar(volatile uchar_t *, uchar_t);
+extern uint16_t atomic_swap_16(volatile uint16_t *, uint16_t);
+extern ushort_t atomic_swap_ushort(volatile ushort_t *, ushort_t);
+extern uint32_t atomic_swap_32(volatile uint32_t *, uint32_t);
+extern uint_t atomic_swap_uint(volatile uint_t *, uint_t);
+extern void *atomic_swap_ptr(volatile void *, void *);
+extern ulong_t atomic_swap_ulong(volatile ulong_t *, ulong_t);
+#if defined(_INT64_TYPE)
+extern uint64_t atomic_swap_64(volatile uint64_t *, uint64_t);
+#endif
+
+/*
+ * Perform an exclusive atomic bit set/clear on a target.
+ * Returns 0 if bit was sucessfully set/cleared, or -1
+ * if the bit was already set/cleared.
+ */
+extern int atomic_set_long_excl(volatile ulong_t *, uint_t);
+extern int atomic_clear_long_excl(volatile ulong_t *, uint_t);
+
+/*
+ * Generic memory barrier used during lock entry, placed after the
+ * memory operation that acquires the lock to guarantee that the lock
+ * protects its data.  No stores from after the memory barrier will
+ * reach visibility, and no loads from after the barrier will be
+ * resolved, before the lock acquisition reaches global visibility.
+ */
+extern void membar_enter(void);
+
+/*
+ * Generic memory barrier used during lock exit, placed before the
+ * memory operation that releases the lock to guarantee that the lock
+ * protects its data.  All loads and stores issued before the barrier
+ * will be resolved before the subsequent lock update reaches visibility.
+ */
+extern void membar_exit(void);
+
+/*
+ * Arrange that all stores issued before this point in the code reach
+ * global visibility before any stores that follow; useful in producer
+ * modules that update a data item, then set a flag that it is available.
+ * The memory barrier guarantees that the available flag is not visible
+ * earlier than the updated data, i.e. it imposes store ordering.
+ */
+extern void membar_producer(void);
+
+/*
+ * Arrange that all loads issued before this point in the code are
+ * completed before any subsequent loads; useful in consumer modules
+ * that check to see if data is available and read the data.
+ * The memory barrier guarantees that the data is not sampled until
+ * after the available flag has been seen, i.e. it imposes load ordering.
+ */
+extern void membar_consumer(void);
+#endif  /* __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_ATOMIC_H */

lib/libspl/include/attr.h

@@ -0,0 +1,25 @@
+/*
+ * 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
+ */
+
+#ifndef _LIBSPL_ATTR_H
+#define	_LIBSPL_ATTR_H
+
+#endif /* _LIBSPL_ATTR_H */

lib/libspl/include/devid.h

@@ -0,0 +1,48 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_DEVID_H
+#define _LIBSPL_DEVID_H
+
+#include <stdlib.h>
+
+typedef int ddi_devid_t;
+
+typedef struct devid_nmlist {
+	char *devname;
+	dev_t dev;
+} devid_nmlist_t;
+
+static inline int devid_str_decode(char *devidstr, ddi_devid_t *retdevid, char **retminor_name) { abort(); }
+static inline int devid_deviceid_to_nmlist(char *search_path, ddi_devid_t devid, char *minor_name, devid_nmlist_t **retlist) { abort(); }
+static inline void devid_str_free(char *str) { abort(); }
+static inline void devid_free(ddi_devid_t devid) { abort(); }
+static inline void devid_free_nmlist(devid_nmlist_t *list) { abort(); }
+static inline int devid_get(int fd, ddi_devid_t *retdevid) { return -1; }
+static inline int devid_get_minor_name(int fd, char **retminor_name) { abort(); }
+static inline char *devid_str_encode(ddi_devid_t devid, char *minor_name) { abort(); }
+
+#endif

lib/libspl/include/ia32/sys/asm_linkage.h

@@ -0,0 +1,302 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _IA32_SYS_ASM_LINKAGE_H
+#define	_IA32_SYS_ASM_LINKAGE_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef _ASM	/* The remainder of this file is only for assembly files */
+
+/*
+ * make annoying differences in assembler syntax go away
+ */
+
+/*
+ * D16 and A16 are used to insert instructions prefixes; the
+ * macros help the assembler code be slightly more portable.
+ */
+#if !defined(__GNUC_AS__)
+/*
+ * /usr/ccs/bin/as prefixes are parsed as separate instructions
+ */
+#define	D16	data16;
+#define	A16	addr16;
+
+/*
+ * (There are some weird constructs in constant expressions)
+ */
+#define	_CONST(const)		[const]
+#define	_BITNOT(const)		-1!_CONST(const)
+#define	_MUL(a, b)		_CONST(a \* b)
+
+#else
+/*
+ * Why not use the 'data16' and 'addr16' prefixes .. well, the
+ * assembler doesn't quite believe in real mode, and thus argues with
+ * us about what we're trying to do.
+ */
+#define	D16	.byte	0x66;
+#define	A16	.byte	0x67;
+
+#define	_CONST(const)		(const)
+#define	_BITNOT(const)		~_CONST(const)
+#define	_MUL(a, b)		_CONST(a * b)
+
+#endif
+
+/*
+ * C pointers are different sizes between i386 and amd64.
+ * These constants can be used to compute offsets into pointer arrays.
+ */
+#if defined(__amd64)
+#define	CLONGSHIFT	3
+#define	CLONGSIZE	8
+#define	CLONGMASK	7
+#elif defined(__i386)
+#define	CLONGSHIFT	2
+#define	CLONGSIZE	4
+#define	CLONGMASK	3
+#endif
+
+/*
+ * Since we know we're either ILP32 or LP64 ..
+ */
+#define	CPTRSHIFT	CLONGSHIFT
+#define	CPTRSIZE	CLONGSIZE
+#define	CPTRMASK	CLONGMASK
+
+#if CPTRSIZE != (1 << CPTRSHIFT) || CLONGSIZE != (1 << CLONGSHIFT)
+#error	"inconsistent shift constants"
+#endif
+
+#if CPTRMASK != (CPTRSIZE - 1) || CLONGMASK != (CLONGSIZE - 1)
+#error	"inconsistent mask constants"
+#endif
+
+#define	ASM_ENTRY_ALIGN	16
+
+/*
+ * SSE register alignment and save areas
+ */
+
+#define	XMM_SIZE	16
+#define	XMM_ALIGN	16
+
+#if defined(__amd64)
+
+#define	SAVE_XMM_PROLOG(sreg, nreg)				\
+	subq	$_CONST(_MUL(XMM_SIZE, nreg)), %rsp;		\
+	movq	%rsp, sreg
+
+#define	RSTOR_XMM_EPILOG(sreg, nreg)				\
+	addq	$_CONST(_MUL(XMM_SIZE, nreg)), %rsp
+
+#elif defined(__i386)
+
+#define	SAVE_XMM_PROLOG(sreg, nreg)				\
+	subl	$_CONST(_MUL(XMM_SIZE, nreg) + XMM_ALIGN), %esp; \
+	movl	%esp, sreg;					\
+	addl	$XMM_ALIGN, sreg;				\
+	andl	$_BITNOT(XMM_ALIGN-1), sreg
+
+#define	RSTOR_XMM_EPILOG(sreg, nreg)				\
+	addl	$_CONST(_MUL(XMM_SIZE, nreg) + XMM_ALIGN), %esp;
+
+#endif	/* __i386 */
+
+/*
+ * profiling causes definitions of the MCOUNT and RTMCOUNT
+ * particular to the type
+ */
+#ifdef GPROF
+
+#define	MCOUNT(x) \
+	pushl	%ebp; \
+	movl	%esp, %ebp; \
+	call	_mcount; \
+	popl	%ebp
+
+#endif /* GPROF */
+
+#ifdef PROF
+
+#define	MCOUNT(x) \
+/* CSTYLED */ \
+	.lcomm .L_/**/x/**/1, 4, 4; \
+	pushl	%ebp; \
+	movl	%esp, %ebp; \
+/* CSTYLED */ \
+	movl	$.L_/**/x/**/1, %edx; \
+	call	_mcount; \
+	popl	%ebp
+
+#endif /* PROF */
+
+/*
+ * if we are not profiling, MCOUNT should be defined to nothing
+ */
+#if !defined(PROF) && !defined(GPROF)
+#define	MCOUNT(x)
+#endif /* !defined(PROF) && !defined(GPROF) */
+
+#define	RTMCOUNT(x)	MCOUNT(x)
+
+/*
+ * Macro to define weak symbol aliases. These are similar to the ANSI-C
+ *	#pragma weak name = _name
+ * except a compiler can determine type. The assembler must be told. Hence,
+ * the second parameter must be the type of the symbol (i.e.: function,...)
+ */
+#define	ANSI_PRAGMA_WEAK(sym, stype)	\
+	.weak	sym; \
+	.type sym, @stype; \
+/* CSTYLED */ \
+sym	= _/**/sym
+
+/*
+ * Like ANSI_PRAGMA_WEAK(), but for unrelated names, as in:
+ *	#pragma weak sym1 = sym2
+ */
+#define	ANSI_PRAGMA_WEAK2(sym1, sym2, stype)	\
+	.weak	sym1; \
+	.type sym1, @stype; \
+sym1	= sym2
+
+/*
+ * ENTRY provides the standard procedure entry code and an easy way to
+ * insert the calls to mcount for profiling. ENTRY_NP is identical, but
+ * never calls mcount.
+ */
+#define	ENTRY(x) \
+	.text; \
+	.align	ASM_ENTRY_ALIGN; \
+	.globl	x; \
+	.type	x, @function; \
+x:	MCOUNT(x)
+
+#define	ENTRY_NP(x) \
+	.text; \
+	.align	ASM_ENTRY_ALIGN; \
+	.globl	x; \
+	.type	x, @function; \
+x:
+
+#define	RTENTRY(x) \
+	.text; \
+	.align	ASM_ENTRY_ALIGN; \
+	.globl	x; \
+	.type	x, @function; \
+x:	RTMCOUNT(x)
+
+/*
+ * ENTRY2 is identical to ENTRY but provides two labels for the entry point.
+ */
+#define	ENTRY2(x, y) \
+	.text; \
+	.align	ASM_ENTRY_ALIGN; \
+	.globl	x, y; \
+	.type	x, @function; \
+	.type	y, @function; \
+/* CSTYLED */ \
+x:	; \
+y:	MCOUNT(x)
+
+#define	ENTRY_NP2(x, y) \
+	.text; \
+	.align	ASM_ENTRY_ALIGN; \
+	.globl	x, y; \
+	.type	x, @function; \
+	.type	y, @function; \
+/* CSTYLED */ \
+x:	; \
+y:
+
+
+/*
+ * ALTENTRY provides for additional entry points.
+ */
+#define	ALTENTRY(x) \
+	.globl x; \
+	.type	x, @function; \
+x:
+
+/*
+ * DGDEF and DGDEF2 provide global data declarations.
+ *
+ * DGDEF provides a word aligned word of storage.
+ *
+ * DGDEF2 allocates "sz" bytes of storage with **NO** alignment.  This
+ * implies this macro is best used for byte arrays.
+ *
+ * DGDEF3 allocates "sz" bytes of storage with "algn" alignment.
+ */
+#define	DGDEF2(name, sz) \
+	.data; \
+	.globl	name; \
+	.type	name, @object; \
+	.size	name, sz; \
+name:
+
+#define	DGDEF3(name, sz, algn) \
+	.data; \
+	.align	algn; \
+	.globl	name; \
+	.type	name, @object; \
+	.size	name, sz; \
+name:
+
+#define	DGDEF(name)	DGDEF3(name, 4, 4)
+
+/*
+ * SET_SIZE trails a function and set the size for the ELF symbol table.
+ */
+#define	SET_SIZE(x) \
+	.size	x, [.-x]
+
+/*
+ * NWORD provides native word value.
+ */
+#if defined(__amd64)
+
+/*CSTYLED*/
+#define	NWORD	quad
+
+#elif defined(__i386)
+
+#define	NWORD	long
+
+#endif  /* __i386 */
+
+#endif /* _ASM */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _IA32_SYS_ASM_LINKAGE_H */

lib/libspl/include/libdevinfo.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_LIBDEVINFO_H
+#define _LIBSPL_LIBDEVINFO_H
+
+#endif /* _LIBSPL_LIBDEVINFO_H */

lib/libspl/include/libshare.h

@@ -0,0 +1,34 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * basic API declarations for share management
+ */
+
+#ifndef _LIBSPL_LIBSHARE_H
+#define _LIBSPL_LIBSHARE_H
+
+#endif /* _LIBSPL_LIBSHARE_H */

lib/libspl/include/limits.h

@@ -0,0 +1,40 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <limits.h>
+
+#ifndef _LIBSPL_LIMITS_H
+#define _LIBSPL_LIMITS_H
+
+#define DBL_DIG		15
+#define DBL_MAX		1.7976931348623157081452E+308
+#define DBL_MIN		2.2250738585072013830903E-308
+
+#define FLT_DIG		6
+#define FLT_MAX		3.4028234663852885981170E+38F
+#define FLT_MIN		1.1754943508222875079688E-38F
+
+#endif /* _LIBSPL_LIMITS_H */

lib/libspl/include/locale.h

@@ -0,0 +1,35 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <locale.h>
+
+#ifndef _LIBSPL_LOCALE_H
+#define _LIBSPL_LOCALE_H
+
+#include <time.h>
+#include <sys/time.h>
+
+#endif

lib/libspl/include/note.h

@@ -0,0 +1,53 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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) 1994 by Sun Microsystems, Inc.
+ */
+
+/*
+ * note.h:      interface for annotating source with info for tools
+ *
+ * NOTE is the default interface, but if the identifier NOTE is in use for
+ * some other purpose, you may prepare a similar header file using your own
+ * identifier, mapping that identifier to _NOTE.  Also, exported header
+ * files should *not* use NOTE, since the name may already be in use in
+ * a program's namespace.  Rather, exported header files should include
+ * sys/note.h directly and use _NOTE.  For consistency, all kernel source
+ * should use _NOTE.
+ */
+
+#ifndef _NOTE_H
+#define _NOTE_H
+
+#include <sys/note.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define NOTE _NOTE
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif  /* _NOTE_H */

lib/libspl/include/priv.h

@@ -0,0 +1,46 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_PRIV_H
+#define _LIBSPL_PRIV_H
+
+#include <sys/types.h>
+
+/* Couldn't find this definition in OpenGrok */
+#define PRIV_SYS_CONFIG "sys_config"
+
+/*
+ * priv_op_t indicates a privilege operation type
+ */
+typedef enum priv_op {
+	PRIV_ON,
+	PRIV_OFF,
+	PRIV_SET
+} priv_op_t;
+
+static inline boolean_t priv_ineffect(const char *priv) { return B_TRUE; }
+
+#endif

lib/libspl/include/rpc/types.h

@@ -0,0 +1,32 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef LIBSPL_RPC_TYPES_H
+#define LIBSPL_RPC_TYPES_H
+
+#include_next <rpc/types.h>
+#include <sys/kmem.h>
+
+#endif /* LIBSPL_RPC_TYPES_H */

lib/libspl/include/rpc/xdr.h

@@ -0,0 +1,65 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ *
+ *	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T
+ *	  All Rights Reserved
+ *
+ * Portions of this source code were derived from Berkeley 4.3 BSD
+ * under license from the Regents of the University of California.
+ */
+
+#ifndef LIBSPL_RPC_XDR_H
+#define LIBSPL_RPC_XDR_H
+
+#include_next <rpc/xdr.h>
+
+/*
+ * These are XDR control operators
+ */
+
+#define	XDR_GET_BYTES_AVAIL 1
+
+typedef struct xdr_bytesrec {
+	bool_t xc_is_last_record;
+	size_t xc_num_avail;
+} xdr_bytesrec_t;
+
+/*
+ * These are the request arguments to XDR_CONTROL.
+ *
+ * XDR_PEEK - returns the contents of the next XDR unit on the XDR stream.
+ * XDR_SKIPBYTES - skips the next N bytes in the XDR stream.
+ * XDR_RDMAGET - for xdr implementation over RDMA, gets private flags from
+ *		 the XDR stream being moved over RDMA
+ * XDR_RDMANOCHUNK - for xdr implementaion over RDMA, sets private flags in
+ *                   the XDR stream moving over RDMA.
+ */
+#define XDR_PEEK      2
+#define XDR_SKIPBYTES 3
+#define XDR_RDMAGET   4
+#define XDR_RDMASET   5
+
+extern bool_t xdr_control(XDR *xdrs, int request, void *info);
+
+#endif

lib/libspl/include/statcommon.h

@@ -0,0 +1,41 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ *
+ * Common routines for acquiring snapshots of kstats for
+ * iostat, mpstat, and vmstat.
+ */
+
+#ifndef	_STATCOMMON_H
+#define	_STATCOMMON_H
+
+#include <sys/types.h>
+
+#define	NODATE	0	/* Default:  No time stamp */
+#define	DDATE	1	/* Standard date format */
+#define	UDATE	2	/* Internal representation of Unix time */
+
+/* Print a timestamp in either Unix or standard format. */
+void print_timestamp(uint_t);
+
+#endif /* _STATCOMMON_H */

lib/libspl/include/stdio.h

@@ -0,0 +1,34 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <stdio.h>
+
+#ifndef _LIBSPL_STDIO_H
+#define _LIBSPL_STDIO_H
+
+#define enable_extended_FILE_stdio(fd, sig)	((void) 0)
+
+#endif

lib/libspl/include/stdlib.h

@@ -0,0 +1,34 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <stdlib.h>
+
+#ifndef _LIBSPL_STDLIB_H
+#define _LIBSPL_STDLIB_H
+
+extern const char *getexecname(void);
+
+#endif

lib/libspl/include/string.h

@@ -0,0 +1,36 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_STRING_H
+#define _LIBSPL_STRING_H
+
+#include_next <string.h>
+
+extern size_t strlcat(char *dst, const char *src, size_t dstsize);
+extern size_t strlcpy(char *dst, const char *src, size_t len);
+extern size_t strnlen(const char *str, size_t maxlen);
+
+#endif

lib/libspl/include/strings.h

@@ -0,0 +1,33 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_STRINGS_H
+#define _LIBSPL_STRINGS_H
+
+#include <string.h>
+#include_next <strings.h>
+
+#endif

lib/libspl/include/stropts.h

@@ -0,0 +1,25 @@
+/*
+ * 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
+ */
+
+#ifndef _LIBSPL_STROPTS_H
+#define	_LIBSPL_STROPTS_H
+
+#endif /* _LIBSPL_STROPTS_H */

lib/libspl/include/synch.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYNCH_H
+#define _LIBSPL_SYNCH_H
+
+#endif

lib/libspl/include/sys/acl.h

@@ -0,0 +1,287 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_ACL_H
+#define	_SYS_ACL_H
+
+#include <sys/types.h>
+#include <sys/acl_impl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	MAX_ACL_ENTRIES		(1024)	/* max entries of each type */
+typedef struct acl {
+	int		a_type;		/* the type of ACL entry */
+	uid_t		a_id;		/* the entry in -uid or gid */
+	o_mode_t	a_perm;		/* the permission field */
+} aclent_t;
+
+typedef struct ace {
+	uid_t		a_who;		/* uid or gid */
+	uint32_t	a_access_mask;	/* read,write,... */
+	uint16_t	a_flags;	/* see below */
+	uint16_t	a_type;		/* allow or deny */
+} ace_t;
+
+typedef struct acl_info acl_t;
+
+/*
+ * The following are Defined types for an aclent_t.
+ */
+#define	USER_OBJ	(0x01)		/* object owner */
+#define	USER		(0x02)		/* additional users */
+#define	GROUP_OBJ	(0x04)		/* owning group of the object */
+#define	GROUP		(0x08)		/* additional groups */
+#define	CLASS_OBJ	(0x10)		/* file group class and mask entry */
+#define	OTHER_OBJ	(0x20)		/* other entry for the object */
+#define	ACL_DEFAULT	(0x1000)	/* default flag */
+/* default object owner */
+#define	DEF_USER_OBJ	(ACL_DEFAULT | USER_OBJ)
+/* default additional users */
+#define	DEF_USER	(ACL_DEFAULT | USER)
+/* default owning group */
+#define	DEF_GROUP_OBJ	(ACL_DEFAULT | GROUP_OBJ)
+/* default additional groups */
+#define	DEF_GROUP	(ACL_DEFAULT | GROUP)
+/* default mask entry */
+#define	DEF_CLASS_OBJ	(ACL_DEFAULT | CLASS_OBJ)
+/* default other entry */
+#define	DEF_OTHER_OBJ	(ACL_DEFAULT | OTHER_OBJ)
+
+/*
+ * The following are defined for ace_t.
+ */
+#define	ACE_READ_DATA		0x00000001
+#define	ACE_LIST_DIRECTORY	0x00000001
+#define	ACE_WRITE_DATA		0x00000002
+#define	ACE_ADD_FILE		0x00000002
+#define	ACE_APPEND_DATA		0x00000004
+#define	ACE_ADD_SUBDIRECTORY	0x00000004
+#define	ACE_READ_NAMED_ATTRS	0x00000008
+#define	ACE_WRITE_NAMED_ATTRS	0x00000010
+#define	ACE_EXECUTE		0x00000020
+#define	ACE_DELETE_CHILD	0x00000040
+#define	ACE_READ_ATTRIBUTES	0x00000080
+#define	ACE_WRITE_ATTRIBUTES	0x00000100
+#define	ACE_DELETE		0x00010000
+#define	ACE_READ_ACL		0x00020000
+#define	ACE_WRITE_ACL		0x00040000
+#define	ACE_WRITE_OWNER		0x00080000
+#define	ACE_SYNCHRONIZE		0x00100000
+
+#define	ACE_FILE_INHERIT_ACE		0x0001
+#define	ACE_DIRECTORY_INHERIT_ACE	0x0002
+#define	ACE_NO_PROPAGATE_INHERIT_ACE	0x0004
+#define	ACE_INHERIT_ONLY_ACE		0x0008
+#define	ACE_SUCCESSFUL_ACCESS_ACE_FLAG	0x0010
+#define	ACE_FAILED_ACCESS_ACE_FLAG	0x0020
+#define	ACE_IDENTIFIER_GROUP		0x0040
+#define	ACE_INHERITED_ACE		0x0080
+#define	ACE_OWNER			0x1000
+#define	ACE_GROUP			0x2000
+#define	ACE_EVERYONE			0x4000
+
+#define	ACE_ACCESS_ALLOWED_ACE_TYPE	0x0000
+#define	ACE_ACCESS_DENIED_ACE_TYPE	0x0001
+#define	ACE_SYSTEM_AUDIT_ACE_TYPE	0x0002
+#define	ACE_SYSTEM_ALARM_ACE_TYPE	0x0003
+
+#define	ACL_AUTO_INHERIT		0x0001
+#define	ACL_PROTECTED			0x0002
+#define	ACL_DEFAULTED			0x0004
+#define	ACL_FLAGS_ALL			(ACL_AUTO_INHERIT|ACL_PROTECTED| \
+    ACL_DEFAULTED)
+
+#ifdef _KERNEL
+
+/*
+ * These are only applicable in a CIFS context.
+ */
+#define	ACE_ACCESS_ALLOWED_COMPOUND_ACE_TYPE		0x04
+#define	ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE		0x05
+#define	ACE_ACCESS_DENIED_OBJECT_ACE_TYPE		0x06
+#define	ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE		0x07
+#define	ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE		0x08
+#define	ACE_ACCESS_ALLOWED_CALLBACK_ACE_TYPE		0x09
+#define	ACE_ACCESS_DENIED_CALLBACK_ACE_TYPE		0x0A
+#define	ACE_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE	0x0B
+#define	ACE_ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE	0x0C
+#define	ACE_SYSTEM_AUDIT_CALLBACK_ACE_TYPE		0x0D
+#define	ACE_SYSTEM_ALARM_CALLBACK_ACE_TYPE		0x0E
+#define	ACE_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE	0x0F
+#define	ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE	0x10
+
+#define	ACE_ALL_TYPES	0x001F
+
+typedef struct ace_object {
+	uid_t		a_who;		/* uid or gid */
+	uint32_t	a_access_mask;	/* read,write,... */
+	uint16_t	a_flags;	/* see below */
+	uint16_t	a_type;		/* allow or deny */
+	uint8_t		a_obj_type[16];	/* obj type */
+	uint8_t		a_inherit_obj_type[16];  /* inherit obj */
+} ace_object_t;
+
+#endif
+
+#define	ACE_ALL_PERMS	(ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \
+    ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_READ_NAMED_ATTRS| \
+    ACE_WRITE_NAMED_ATTRS|ACE_EXECUTE|ACE_DELETE_CHILD|ACE_READ_ATTRIBUTES| \
+    ACE_WRITE_ATTRIBUTES|ACE_DELETE|ACE_READ_ACL|ACE_WRITE_ACL| \
+    ACE_WRITE_OWNER|ACE_SYNCHRONIZE)
+
+/*
+ * The following flags are supported by both NFSv4 ACLs and ace_t.
+ */
+#define	ACE_NFSV4_SUP_FLAGS (ACE_FILE_INHERIT_ACE | \
+    ACE_DIRECTORY_INHERIT_ACE | \
+    ACE_NO_PROPAGATE_INHERIT_ACE | \
+    ACE_INHERIT_ONLY_ACE | \
+    ACE_IDENTIFIER_GROUP)
+
+#define	ACE_TYPE_FLAGS		(ACE_OWNER|ACE_GROUP|ACE_EVERYONE| \
+    ACE_IDENTIFIER_GROUP)
+#define	ACE_INHERIT_FLAGS	(ACE_FILE_INHERIT_ACE| \
+    ACE_DIRECTORY_INHERIT_ACE|ACE_NO_PROPAGATE_INHERIT_ACE|ACE_INHERIT_ONLY_ACE)
+
+/* cmd args to acl(2) for aclent_t  */
+#define	GETACL			1
+#define	SETACL			2
+#define	GETACLCNT		3
+
+/* cmd's to manipulate ace acls. */
+#define	ACE_GETACL		4
+#define	ACE_SETACL		5
+#define	ACE_GETACLCNT		6
+
+/* minimal acl entries from GETACLCNT */
+#define	MIN_ACL_ENTRIES		4
+
+#if !defined(_KERNEL)
+
+/* acl check errors */
+#define	GRP_ERROR		1
+#define	USER_ERROR		2
+#define	OTHER_ERROR		3
+#define	CLASS_ERROR		4
+#define	DUPLICATE_ERROR		5
+#define	MISS_ERROR		6
+#define	MEM_ERROR		7
+#define	ENTRY_ERROR		8
+
+
+/*
+ * similar to ufs_acl.h: changed to char type for user commands (tar, cpio)
+ * Attribute types
+ */
+#define	UFSD_FREE	('0')	/* Free entry */
+#define	UFSD_ACL	('1')	/* Access Control Lists */
+#define	UFSD_DFACL	('2')	/* reserved for future use */
+#define	ACE_ACL		('3')	/* ace_t style acls */
+
+/*
+ * flag to [f]acl_get()
+ * controls whether a trivial acl should be returned.
+ */
+#define	ACL_NO_TRIVIAL	0x2
+
+
+/*
+ * Flags to control acl_totext()
+ */
+
+#define	ACL_APPEND_ID	0x1 	/* append uid/gid to user/group entries */
+#define	ACL_COMPACT_FMT	0x2 	/* build ACL in ls -V format */
+#define	ACL_NORESOLVE	0x4	/* don't do name service lookups */
+
+/*
+ * Legacy aclcheck errors for aclent_t ACLs
+ */
+#define	EACL_GRP_ERROR		GRP_ERROR
+#define	EACL_USER_ERROR		USER_ERROR
+#define	EACL_OTHER_ERROR	OTHER_ERROR
+#define	EACL_CLASS_ERROR	CLASS_ERROR
+#define	EACL_DUPLICATE_ERROR	DUPLICATE_ERROR
+#define	EACL_MISS_ERROR		MISS_ERROR
+#define	EACL_MEM_ERROR		MEM_ERROR
+#define	EACL_ENTRY_ERROR	ENTRY_ERROR
+
+#define	EACL_INHERIT_ERROR	9		/* invalid inherit flags */
+#define	EACL_FLAGS_ERROR	10		/* unknown flag value */
+#define	EACL_PERM_MASK_ERROR	11		/* unknown permission */
+#define	EACL_COUNT_ERROR	12		/* invalid acl count */
+
+#define	EACL_INVALID_SLOT	13		/* invalid acl slot */
+#define	EACL_NO_ACL_ENTRY	14		/* Entry doesn't exist */
+#define	EACL_DIFF_TYPE		15		/* acls aren't same type */
+
+#define	EACL_INVALID_USER_GROUP	16		/* need user/group name */
+#define	EACL_INVALID_STR	17		/* invalid acl string */
+#define	EACL_FIELD_NOT_BLANK	18		/* can't have blank field */
+#define	EACL_INVALID_ACCESS_TYPE 19		/* invalid access type */
+#define	EACL_UNKNOWN_DATA	20		/* Unrecognized data in ACL */
+#define	EACL_MISSING_FIELDS	21		/* missing fields in acl */
+
+#define	EACL_INHERIT_NOTDIR	22		/* Need dir for inheritance */
+
+extern int aclcheck(aclent_t *, int, int *);
+extern int acltomode(aclent_t *, int, mode_t *);
+extern int aclfrommode(aclent_t *, int, mode_t *);
+extern int aclsort(int, int, aclent_t *);
+extern char *acltotext(aclent_t *, int);
+extern aclent_t *aclfromtext(char *, int *);
+extern void acl_free(acl_t *);
+extern int acl_get(const char *, int, acl_t **);
+extern int facl_get(int, int, acl_t **);
+extern int acl_set(const char *, acl_t *acl);
+extern int facl_set(int, acl_t *acl);
+extern int acl_strip(const char *, uid_t, gid_t, mode_t);
+extern int acl_trivial(const char *);
+extern char *acl_totext(acl_t *, int);
+extern int acl_fromtext(const char *, acl_t **);
+extern int acl_check(acl_t *, int);
+
+#else	/* !defined(_KERNEL) */
+
+extern void ksort(caddr_t, int, int, int (*)(void *, void *));
+extern int cmp2acls(void *, void *);
+
+#endif	/* !defined(_KERNEL) */
+
+#if defined(__STDC__)
+extern int acl(const char *path, int cmd, int cnt, void *buf);
+extern int facl(int fd, int cmd, int cnt, void *buf);
+#else	/* !__STDC__ */
+extern int acl();
+extern int facl();
+#endif	/* defined(__STDC__) */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ACL_H */

lib/libspl/include/sys/acl_impl.h

@@ -0,0 +1,59 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_ACL_IMPL_H
+#define	_SYS_ACL_IMPL_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * acl flags
+ *
+ * ACL_AUTO_INHERIT, ACL_PROTECTED and ACL_DEFAULTED
+ * flags can also be stored in this field.
+ */
+#define	ACL_IS_TRIVIAL	0x10000
+#define	ACL_IS_DIR	0x20000
+
+typedef enum acl_type {
+	ACLENT_T = 0,
+	ACE_T = 1
+} acl_type_t;
+
+struct acl_info {
+	acl_type_t acl_type;		/* style of acl */
+	int acl_cnt;			/* number of acl entries */
+	int acl_entry_size;		/* sizeof acl entry */
+	int acl_flags;			/* special flags about acl */
+	void *acl_aclp;			/* the acl */
+};
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_ACL_IMPL_H */

lib/libspl/include/sys/bitmap.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_BITMAP_H
+#define _LIBSPL_SYS_BITMAP_H
+
+#endif

lib/libspl/include/sys/byteorder.h

@@ -0,0 +1,199 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+/*
+ * University Copyright- Copyright (c) 1982, 1986, 1988
+ * The Regents of the University of California
+ * All Rights Reserved
+ *
+ * University Acknowledgment- Portions of this document are derived from
+ * software developed by the University of California, Berkeley, and its
+ * contributors.
+ */
+
+#ifndef _SYS_BYTEORDER_H
+#define	_SYS_BYTEORDER_H
+
+
+
+#include <sys/isa_defs.h>
+#include <sys/int_types.h>
+
+#if defined(__GNUC__) && defined(_ASM_INLINES) && \
+	(defined(__i386) || defined(__amd64))
+#include <asm/byteorder.h>
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * macros for conversion between host and (internet) network byte order
+ */
+
+#if defined(_BIG_ENDIAN) && !defined(ntohl) && !defined(__lint)
+/* big-endian */
+#define	ntohl(x)	(x)
+#define	ntohs(x)	(x)
+#define	htonl(x)	(x)
+#define	htons(x)	(x)
+
+#elif !defined(ntohl) /* little-endian */
+
+#ifndef	_IN_PORT_T
+#define	_IN_PORT_T
+typedef uint16_t in_port_t;
+#endif
+
+#ifndef	_IN_ADDR_T
+#define	_IN_ADDR_T
+typedef uint32_t in_addr_t;
+#endif
+
+#if !defined(_XPG4_2) || defined(__EXTENSIONS__) || defined(_XPG5)
+extern	uint32_t htonl(uint32_t);
+extern	uint16_t htons(uint16_t);
+extern 	uint32_t ntohl(uint32_t);
+extern	uint16_t ntohs(uint16_t);
+#else
+extern	in_addr_t htonl(in_addr_t);
+extern	in_port_t htons(in_port_t);
+extern 	in_addr_t ntohl(in_addr_t);
+extern	in_port_t ntohs(in_port_t);
+#endif	/* !defined(_XPG4_2) || defined(__EXTENSIONS__) || defined(_XPG5) */
+#endif
+
+#if !defined(_XPG4_2) || defined(__EXTENSIONS__)
+
+/*
+ * Macros to reverse byte order
+ */
+#define	BSWAP_8(x)	((x) & 0xff)
+#define	BSWAP_16(x)	((BSWAP_8(x) << 8) | BSWAP_8((x) >> 8))
+#define	BSWAP_32(x)	((BSWAP_16(x) << 16) | BSWAP_16((x) >> 16))
+#define	BSWAP_64(x)	((BSWAP_32(x) << 32) | BSWAP_32((x) >> 32))
+
+#define	BMASK_8(x)	((x) & 0xff)
+#define	BMASK_16(x)	((x) & 0xffff)
+#define	BMASK_32(x)	((x) & 0xffffffff)
+#define	BMASK_64(x)	(x)
+
+/*
+ * Macros to convert from a specific byte order to/from native byte order
+ */
+#ifdef _BIG_ENDIAN
+#define	BE_8(x)		BMASK_8(x)
+#define	BE_16(x)	BMASK_16(x)
+#define	BE_32(x)	BMASK_32(x)
+#define	BE_64(x)	BMASK_64(x)
+#define	LE_8(x)		BSWAP_8(x)
+#define	LE_16(x)	BSWAP_16(x)
+#define	LE_32(x)	BSWAP_32(x)
+#define	LE_64(x)	BSWAP_64(x)
+#else
+#define	LE_8(x)		BMASK_8(x)
+#define	LE_16(x)	BMASK_16(x)
+#define	LE_32(x)	BMASK_32(x)
+#define	LE_64(x)	BMASK_64(x)
+#define	BE_8(x)		BSWAP_8(x)
+#define	BE_16(x)	BSWAP_16(x)
+#define	BE_32(x)	BSWAP_32(x)
+#define	BE_64(x)	BSWAP_64(x)
+#endif
+
+/*
+ * Macros to read unaligned values from a specific byte order to
+ * native byte order
+ */
+
+#define	BE_IN8(xa) \
+	*((uint8_t *)(xa))
+
+#define	BE_IN16(xa) \
+	(((uint16_t)BE_IN8(xa) << 8) | BE_IN8((uint8_t *)(xa)+1))
+
+#define	BE_IN32(xa) \
+	(((uint32_t)BE_IN16(xa) << 16) | BE_IN16((uint8_t *)(xa)+2))
+
+#define	BE_IN64(xa) \
+	(((uint64_t)BE_IN32(xa) << 32) | BE_IN32((uint8_t *)(xa)+4))
+
+#define	LE_IN8(xa) \
+	*((uint8_t *)(xa))
+
+#define	LE_IN16(xa) \
+	(((uint16_t)LE_IN8((uint8_t *)(xa) + 1) << 8) | LE_IN8(xa))
+
+#define	LE_IN32(xa) \
+	(((uint32_t)LE_IN16((uint8_t *)(xa) + 2) << 16) | LE_IN16(xa))
+
+#define	LE_IN64(xa) \
+	(((uint64_t)LE_IN32((uint8_t *)(xa) + 4) << 32) | LE_IN32(xa))
+
+/*
+ * Macros to write unaligned values from native byte order to a specific byte
+ * order.
+ */
+
+#define	BE_OUT8(xa, yv) *((uint8_t *)(xa)) = (uint8_t)(yv);
+
+#define	BE_OUT16(xa, yv) \
+	BE_OUT8((uint8_t *)(xa) + 1, yv); \
+	BE_OUT8((uint8_t *)(xa), (yv) >> 8);
+
+#define	BE_OUT32(xa, yv) \
+	BE_OUT16((uint8_t *)(xa) + 2, yv); \
+	BE_OUT16((uint8_t *)(xa), (yv) >> 16);
+
+#define	BE_OUT64(xa, yv) \
+	BE_OUT32((uint8_t *)(xa) + 4, yv); \
+	BE_OUT32((uint8_t *)(xa), (yv) >> 32);
+
+#define	LE_OUT8(xa, yv) *((uint8_t *)(xa)) = (uint8_t)(yv);
+
+#define	LE_OUT16(xa, yv) \
+	LE_OUT8((uint8_t *)(xa), yv); \
+	LE_OUT8((uint8_t *)(xa) + 1, (yv) >> 8);
+
+#define	LE_OUT32(xa, yv) \
+	LE_OUT16((uint8_t *)(xa), yv); \
+	LE_OUT16((uint8_t *)(xa) + 2, (yv) >> 16);
+
+#define	LE_OUT64(xa, yv) \
+	LE_OUT32((uint8_t *)(xa), yv); \
+	LE_OUT32((uint8_t *)(xa) + 4, (yv) >> 32);
+
+#endif	/* !defined(_XPG4_2) || defined(__EXTENSIONS__) */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_BYTEORDER_H */

lib/libspl/include/sys/callb.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_CALLB_H
+#define _SYS_CALLB_H
+
+#endif

lib/libspl/include/sys/cmn_err.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_CMN_ERR_H
+#define _LIBSPL_SYS_CMN_ERR_H
+
+#endif

lib/libspl/include/sys/compress.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_COMPRESS_H
+#define _LIBSPL_SYS_COMPRESS_H
+
+#endif /* _LIBSPL_SYS_COMPRESS_H */

lib/libspl/include/sys/cred.h

@@ -0,0 +1,32 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_CRED_H
+#define _LIBSPL_SYS_CRED_H
+
+typedef struct cred cred_t;
+
+#endif

lib/libspl/include/sys/debug.h

@@ -0,0 +1,32 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_DEBUG_H
+#define _LIBSPL_SYS_DEBUG_H
+
+#include <assert.h>
+
+#endif

lib/libspl/include/sys/dkio.h

@@ -0,0 +1,484 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_DKIO_H
+#define	_SYS_DKIO_H
+
+
+
+#include <sys/dklabel.h>	/* Needed for NDKMAP define */
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Structures and definitions for disk io control commands
+ */
+
+/*
+ * Structures used as data by ioctl calls.
+ */
+
+#define	DK_DEVLEN	16		/* device name max length, including */
+					/* unit # & NULL (ie - "xyc1") */
+
+/*
+ * Used for controller info
+ */
+struct dk_cinfo {
+	char	dki_cname[DK_DEVLEN];	/* controller name (no unit #) */
+	ushort_t dki_ctype;		/* controller type */
+	ushort_t dki_flags;		/* flags */
+	ushort_t dki_cnum;		/* controller number */
+	uint_t	dki_addr;		/* controller address */
+	uint_t	dki_space;		/* controller bus type */
+	uint_t	dki_prio;		/* interrupt priority */
+	uint_t	dki_vec;		/* interrupt vector */
+	char	dki_dname[DK_DEVLEN];	/* drive name (no unit #) */
+	uint_t	dki_unit;		/* unit number */
+	uint_t	dki_slave;		/* slave number */
+	ushort_t dki_partition;		/* partition number */
+	ushort_t dki_maxtransfer;	/* max. transfer size in DEV_BSIZE */
+};
+
+/*
+ * Controller types
+ */
+#define	DKC_UNKNOWN	0
+#define	DKC_CDROM	1	/* CD-ROM, SCSI or otherwise */
+#define	DKC_WDC2880	2
+#define	DKC_XXX_0	3	/* unassigned */
+#define	DKC_XXX_1	4	/* unassigned */
+#define	DKC_DSD5215	5
+#define	DKC_ACB4000	7
+#define	DKC_MD21	8
+#define	DKC_XXX_2	9	/* unassigned */
+#define	DKC_NCRFLOPPY	10
+#define	DKC_SMSFLOPPY	12
+#define	DKC_SCSI_CCS	13	/* SCSI CCS compatible */
+#define	DKC_INTEL82072	14	/* native floppy chip */
+#define	DKC_MD		16	/* meta-disk (virtual-disk) driver */
+#define	DKC_INTEL82077	19	/* 82077 floppy disk controller */
+#define	DKC_DIRECT	20	/* Intel direct attached device i.e. IDE */
+#define	DKC_PCMCIA_MEM	21	/* PCMCIA memory disk-like type */
+#define	DKC_PCMCIA_ATA	22	/* PCMCIA AT Attached type */
+#define	DKC_VBD		23	/* virtual block device */
+
+/*
+ * Sun reserves up through 1023
+ */
+
+#define	DKC_CUSTOMER_BASE	1024
+
+/*
+ * Flags
+ */
+#define	DKI_BAD144	0x01	/* use DEC std 144 bad sector fwding */
+#define	DKI_MAPTRK	0x02	/* controller does track mapping */
+#define	DKI_FMTTRK	0x04	/* formats only full track at a time */
+#define	DKI_FMTVOL	0x08	/* formats only full volume at a time */
+#define	DKI_FMTCYL	0x10	/* formats only full cylinders at a time */
+#define	DKI_HEXUNIT	0x20	/* unit number is printed as 3 hex digits */
+#define	DKI_PCMCIA_PFD	0x40	/* PCMCIA pseudo-floppy memory card */
+
+/*
+ * Used for all partitions
+ */
+struct dk_allmap {
+	struct dk_map	dka_map[NDKMAP];
+};
+
+#if defined(_SYSCALL32)
+struct dk_allmap32 {
+	struct dk_map32	dka_map[NDKMAP];
+};
+#endif /* _SYSCALL32 */
+
+/*
+ * Definition of a disk's geometry
+ */
+struct dk_geom {
+	unsigned short	dkg_ncyl;	/* # of data cylinders */
+	unsigned short	dkg_acyl;	/* # of alternate cylinders */
+	unsigned short	dkg_bcyl;	/* cyl offset (for fixed head area) */
+	unsigned short	dkg_nhead;	/* # of heads */
+	unsigned short	dkg_obs1;	/* obsolete */
+	unsigned short	dkg_nsect;	/* # of data sectors per track */
+	unsigned short	dkg_intrlv;	/* interleave factor */
+	unsigned short	dkg_obs2;	/* obsolete */
+	unsigned short	dkg_obs3;	/* obsolete */
+	unsigned short	dkg_apc;	/* alternates per cyl (SCSI only) */
+	unsigned short	dkg_rpm;	/* revolutions per minute */
+	unsigned short	dkg_pcyl;	/* # of physical cylinders */
+	unsigned short	dkg_write_reinstruct;	/* # sectors to skip, writes */
+	unsigned short	dkg_read_reinstruct;	/* # sectors to skip, reads */
+	unsigned short	dkg_extra[7];	/* for compatible expansion */
+};
+
+/*
+ * These defines are for historic compatibility with old drivers.
+ */
+#define	dkg_bhead	dkg_obs1	/* used to be head offset */
+#define	dkg_gap1	dkg_obs2	/* used to be gap1 */
+#define	dkg_gap2	dkg_obs3	/* used to be gap2 */
+
+/*
+ * Disk io control commands
+ * Warning: some other ioctls with the DIOC prefix exist elsewhere.
+ * The Generic DKIOC numbers are from	0   -  50.
+ *	The Floppy Driver uses		51  - 100.
+ *	The Hard Disk (except SCSI)	101 - 106.	(these are obsolete)
+ *	The CDROM Driver		151 - 200.
+ *	The USCSI ioctl			201 - 250.
+ */
+#define	DKIOC		(0x04 << 8)
+
+/*
+ * The following ioctls are generic in nature and need to be
+ * suported as appropriate by all disk drivers
+ */
+#define	DKIOCGGEOM	(DKIOC|1)		/* Get geometry */
+#define	DKIOCINFO	(DKIOC|3)		/* Get info */
+#define	DKIOCEJECT	(DKIOC|6)		/* Generic 'eject' */
+#define	DKIOCGVTOC	(DKIOC|11)		/* Get VTOC */
+#define	DKIOCSVTOC	(DKIOC|12)		/* Set VTOC & Write to Disk */
+
+/*
+ * Disk Cache Controls.  These ioctls should be supported by
+ * all disk drivers.
+ *
+ * DKIOCFLUSHWRITECACHE when used from user-mode ignores the ioctl
+ * argument, but it should be passed as NULL to allow for future
+ * reinterpretation.  From user-mode, this ioctl request is synchronous.
+ *
+ * When invoked from within the kernel, the arg can be NULL to indicate
+ * a synchronous request or can be the address of a struct dk_callback
+ * to request an asynchronous callback when the flush request is complete.
+ * In this case, the flag to the ioctl must include FKIOCTL and the
+ * dkc_callback field of the pointed to struct must be non-null or the
+ * request is made synchronously.
+ *
+ * In the callback case: if the ioctl returns 0, a callback WILL be performed.
+ * If the ioctl returns non-zero, a callback will NOT be performed.
+ * NOTE: In some cases, the callback may be done BEFORE the ioctl call
+ * returns.  The caller's locking strategy should be prepared for this case.
+ */
+#define	DKIOCFLUSHWRITECACHE	(DKIOC|34)	/* flush cache to phys medium */
+
+struct dk_callback {
+	void (*dkc_callback)(void *dkc_cookie, int error);
+	void *dkc_cookie;
+	int dkc_flag;
+};
+
+/* bit flag definitions for dkc_flag */
+#define	FLUSH_VOLATILE		0x1	/* Bit 0: if set, only flush */
+					/* volatile cache; otherwise, flush */
+					/* volatile and non-volatile cache */
+
+#define	DKIOCGETWCE		(DKIOC|36)	/* Get current write cache */
+						/* enablement status */
+#define	DKIOCSETWCE		(DKIOC|37)	/* Enable/Disable write cache */
+
+/*
+ * The following ioctls are used by Sun drivers to communicate
+ * with their associated format routines. Support of these ioctls
+ * is not required of foreign drivers
+ */
+#define	DKIOCSGEOM	(DKIOC|2)		/* Set geometry */
+#define	DKIOCSAPART	(DKIOC|4)		/* Set all partitions */
+#define	DKIOCGAPART	(DKIOC|5)		/* Get all partitions */
+#define	DKIOCG_PHYGEOM	(DKIOC|32)		/* get physical geometry */
+#define	DKIOCG_VIRTGEOM	(DKIOC|33)		/* get virtual geometry */
+
+/*
+ * The following ioctl's are removable media support
+ */
+#define	DKIOCLOCK	(DKIOC|7)	/* Generic 'lock' */
+#define	DKIOCUNLOCK	(DKIOC|8)	/* Generic 'unlock' */
+#define	DKIOCSTATE	(DKIOC|13)	/* Inquire insert/eject state */
+#define	DKIOCREMOVABLE	(DKIOC|16)	/* is media removable */
+
+
+/*
+ * ioctl for hotpluggable devices
+ */
+#define	DKIOCHOTPLUGGABLE	(DKIOC|35)	/* is hotpluggable */
+
+/*
+ * Ioctl to force driver to re-read the alternate partition and rebuild
+ * the internal defect map.
+ */
+#define	DKIOCADDBAD	(DKIOC|20)	/* Re-read the alternate map (IDE) */
+#define	DKIOCGETDEF	(DKIOC|21)	/* read defect list (IDE)	   */
+
+/*
+ * Used by applications to get disk defect information from IDE
+ * drives.
+ */
+#ifdef _SYSCALL32
+struct defect_header32 {
+	int		head;
+	caddr32_t	buffer;
+};
+#endif /* _SYSCALL32 */
+
+struct defect_header {
+	int		head;
+	caddr_t		buffer;
+};
+
+#define	DKIOCPARTINFO	(DKIOC|22)	/* Get partition or slice parameters */
+
+/*
+ * Used by applications to get partition or slice information
+ */
+#ifdef _SYSCALL32
+struct part_info32 {
+	daddr32_t	p_start;
+	int		p_length;
+};
+#endif /* _SYSCALL32 */
+
+struct part_info {
+	daddr_t		p_start;
+	int		p_length;
+};
+
+/* The following ioctls are for Optical Memory Device */
+#define	DKIOC_EBP_ENABLE  (DKIOC|40)	/* enable by pass erase on write */
+#define	DKIOC_EBP_DISABLE (DKIOC|41)	/* disable by pass erase on write */
+
+/*
+ * This state enum is the argument passed to the DKIOCSTATE ioctl.
+ */
+enum dkio_state { DKIO_NONE, DKIO_EJECTED, DKIO_INSERTED, DKIO_DEV_GONE };
+
+#define	DKIOCGMEDIAINFO	(DKIOC|42)	/* get information about the media */
+
+/*
+ * ioctls to read/write mboot info.
+ */
+#define	DKIOCGMBOOT	(DKIOC|43)	/* get mboot info */
+#define	DKIOCSMBOOT	(DKIOC|44)	/* set mboot info */
+
+/*
+ * ioctl to get the device temperature.
+ */
+#define	DKIOCGTEMPERATURE	(DKIOC|45)	/* get temperature */
+
+/*
+ * Used for providing the temperature.
+ */
+
+struct	dk_temperature	{
+	uint_t		dkt_flags;	/* Flags */
+	short		dkt_cur_temp;	/* Current disk temperature */
+	short		dkt_ref_temp;	/* reference disk temperature */
+};
+
+#define	DKT_BYPASS_PM		0x1
+#define	DKT_INVALID_TEMP	0xFFFF
+
+
+/*
+ * Used for Media info or the current profile info
+ */
+struct dk_minfo {
+	uint_t		dki_media_type;	/* Media type or profile info */
+	uint_t		dki_lbsize;	/* Logical blocksize of media */
+	diskaddr_t	dki_capacity;	/* Capacity as # of dki_lbsize blks */
+};
+
+/*
+ * Media types or profiles known
+ */
+#define	DK_UNKNOWN		0x00	/* Media inserted - type unknown */
+
+
+/*
+ * SFF 8090 Specification Version 3, media types 0x01 - 0xfffe are retained to
+ * maintain compatibility with SFF8090.  The following define the
+ * optical media type.
+ */
+#define	DK_REMOVABLE_DISK	0x02 /* Removable Disk */
+#define	DK_MO_ERASABLE		0x03 /* MO Erasable */
+#define	DK_MO_WRITEONCE		0x04 /* MO Write once */
+#define	DK_AS_MO		0x05 /* AS MO */
+#define	DK_CDROM		0x08 /* CDROM */
+#define	DK_CDR			0x09 /* CD-R */
+#define	DK_CDRW			0x0A /* CD-RW */
+#define	DK_DVDROM		0x10 /* DVD-ROM */
+#define	DK_DVDR			0x11 /* DVD-R */
+#define	DK_DVDRAM		0x12 /* DVD_RAM or DVD-RW */
+
+/*
+ * Media types for other rewritable magnetic media
+ */
+#define	DK_FIXED_DISK		0x10001	/* Fixed disk SCSI or otherwise */
+#define	DK_FLOPPY		0x10002 /* Floppy media */
+#define	DK_ZIP			0x10003 /* IOMEGA ZIP media */
+#define	DK_JAZ			0x10004 /* IOMEGA JAZ media */
+
+#define	DKIOCSETEFI	(DKIOC|17)		/* Set EFI info */
+#define	DKIOCGETEFI	(DKIOC|18)		/* Get EFI info */
+
+#define	DKIOCPARTITION	(DKIOC|9)		/* Get partition info */
+
+/*
+ * Ioctls to get/set volume capabilities related to Logical Volume Managers.
+ * They include the ability to get/set capabilities and to issue a read to a
+ * specific underlying device of a replicated device.
+ */
+
+#define	DKIOCGETVOLCAP	(DKIOC | 25)	/* Get volume capabilities */
+#define	DKIOCSETVOLCAP	(DKIOC | 26)	/* Set volume capabilities */
+#define	DKIOCDMR	(DKIOC | 27)	/* Issue a directed read */
+
+typedef uint_t volcapinfo_t;
+
+typedef uint_t volcapset_t;
+
+#define	DKV_ABR_CAP 0x00000001		/* Support Appl.Based Recovery */
+#define	DKV_DMR_CAP 0x00000002		/* Support Directed  Mirror Read */
+
+typedef struct volcap {
+	volcapinfo_t vc_info;	/* Capabilities available */
+	volcapset_t vc_set;	/* Capabilities set */
+} volcap_t;
+
+#define	VOL_SIDENAME 256
+
+typedef struct vol_directed_rd {
+	int		vdr_flags;
+	offset_t	vdr_offset;
+	size_t		vdr_nbytes;
+	size_t		vdr_bytesread;
+	void		*vdr_data;
+	int		vdr_side;
+	char		vdr_side_name[VOL_SIDENAME];
+} vol_directed_rd_t;
+
+#define	DKV_SIDE_INIT		(-1)
+#define	DKV_DMR_NEXT_SIDE	0x00000001
+#define	DKV_DMR_DONE		0x00000002
+#define	DKV_DMR_ERROR		0x00000004
+#define	DKV_DMR_SUCCESS		0x00000008
+#define	DKV_DMR_SHORT		0x00000010
+
+#ifdef _MULTI_DATAMODEL
+#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
+#pragma pack(4)
+#endif
+typedef struct vol_directed_rd32 {
+	int32_t		vdr_flags;
+	offset_t	vdr_offset;	/* 64-bit element on 32-bit alignment */
+	size32_t	vdr_nbytes;
+	size32_t	vdr_bytesread;
+	caddr32_t	vdr_data;
+	int32_t		vdr_side;
+	char		vdr_side_name[VOL_SIDENAME];
+} vol_directed_rd32_t;
+#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
+#pragma pack()
+#endif
+#endif	/* _MULTI_DATAMODEL */
+
+/*
+ * The ioctl is used to fetch disk's device type, vendor ID,
+ * model number/product ID, firmware revision and serial number together.
+ *
+ * Currently there are two device types - DKD_ATA_TYPE which means the
+ * disk is driven by cmdk/ata or dad/uata driver, and DKD_SCSI_TYPE
+ * which means the disk is driven by sd/scsi hba driver.
+ */
+#define	DKIOC_GETDISKID	(DKIOC|46)
+
+/* These two labels are for dkd_dtype of dk_disk_id_t */
+#define	DKD_ATA_TYPE	0x01 /* ATA disk or legacy mode SATA disk */
+#define	DKD_SCSI_TYPE	0x02 /* SCSI disk or native mode SATA disk */
+
+#define	DKD_ATA_MODEL	40	/* model number length */
+#define	DKD_ATA_FWVER	8	/* firmware revision length */
+#define	DKD_ATA_SERIAL	20	/* serial number length */
+
+#define	DKD_SCSI_VENDOR	8	/* vendor ID length */
+#define	DKD_SCSI_PRODUCT 16	/* product ID length */
+#define	DKD_SCSI_REVLEVEL 4	/* revision level length */
+#define	DKD_SCSI_SERIAL 12	/* serial number length */
+
+/*
+ * The argument type for DKIOC_GETDISKID ioctl.
+ */
+typedef struct dk_disk_id {
+	uint_t	dkd_dtype;
+	union {
+		struct {
+			char dkd_amodel[DKD_ATA_MODEL];		/* 40 bytes */
+			char dkd_afwver[DKD_ATA_FWVER];		/* 8 bytes */
+			char dkd_aserial[DKD_ATA_SERIAL];	/* 20 bytes */
+		} ata_disk_id;
+		struct {
+			char dkd_svendor[DKD_SCSI_VENDOR];	/* 8 bytes */
+			char dkd_sproduct[DKD_SCSI_PRODUCT];	/* 16 bytes */
+			char dkd_sfwver[DKD_SCSI_REVLEVEL];	/* 4 bytes */
+			char dkd_sserial[DKD_SCSI_SERIAL];	/* 12 bytes */
+		} scsi_disk_id;
+	} disk_id;
+} dk_disk_id_t;
+
+/*
+ * The ioctl is used to update the firmware of device.
+ */
+#define	DKIOC_UPDATEFW		(DKIOC|47)
+
+/* The argument type for DKIOC_UPDATEFW ioctl */
+typedef struct dk_updatefw {
+	caddr_t		dku_ptrbuf;	/* pointer to firmware buf */
+	uint_t		dku_size;	/* firmware buf length */
+	uint8_t		dku_type;	/* firmware update type */
+} dk_updatefw_t;
+
+#ifdef _SYSCALL32
+typedef struct dk_updatefw_32 {
+	caddr32_t	dku_ptrbuf;	/* pointer to firmware buf */
+	uint_t		dku_size;	/* firmware buf length */
+	uint8_t		dku_type;	/* firmware update type */
+} dk_updatefw_32_t;
+#endif /* _SYSCALL32 */
+
+/*
+ * firmware update type - temporary or permanent use
+ */
+#define	FW_TYPE_TEMP	0x0		/* temporary use */
+#define	FW_TYPE_PERM	0x1		/* permanent use */
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DKIO_H */

lib/libspl/include/sys/dklabel.h

@@ -0,0 +1,268 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 1990-2002 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_DKLABEL_H
+#define	_SYS_DKLABEL_H
+
+
+
+#include <sys/isa_defs.h>
+#include <sys/types32.h>
+#include <sys/isa_defs.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Miscellaneous defines
+ */
+#define	DKL_MAGIC	0xDABE		/* magic number */
+#define	FKL_MAGIC	0xff		/* magic number for DOS floppies */
+
+#if defined(_SUNOS_VTOC_16)
+#define	NDKMAP		16		/* # of logical partitions */
+#define	DK_LABEL_LOC	1		/* location of disk label */
+#elif defined(_SUNOS_VTOC_8)
+#define	NDKMAP		8		/* # of logical partitions */
+#define	DK_LABEL_LOC	0		/* location of disk label */
+#else
+#error "No VTOC format defined."
+#endif
+
+#define	LEN_DKL_ASCII	128		/* length of dkl_asciilabel */
+#define	LEN_DKL_VVOL	8		/* length of v_volume */
+#define	DK_LABEL_SIZE	512		/* size of disk label */
+#define	DK_MAX_BLOCKS	0x7fffffff	/* max # of blocks handled */
+
+/*
+ * Reserve two cylinders on SCSI disks.
+ * One is for the backup disk label and the other is for the deviceid.
+ *
+ * IPI disks only reserve one cylinder, but they will go away soon.
+ * CDROMs do not reserve any cylinders.
+ */
+#define	DK_ACYL		2
+
+/*
+ * Format of a Sun disk label.
+ * Resides in cylinder 0, head 0, sector 0.
+ *
+ * sizeof (struct dk_label) should be 512 (the current sector size),
+ * but should the sector size increase, this structure should remain
+ * at the beginning of the sector.
+ */
+
+/*
+ * partition headers:  section 1
+ * Returned in struct dk_allmap by ioctl DKIOC[SG]APART (dkio(7I))
+ */
+struct dk_map {
+	daddr_t	dkl_cylno;		/* starting cylinder */
+	daddr_t	dkl_nblk;		/* number of blocks;  if == 0, */
+					/* partition is undefined */
+};
+
+/*
+ * partition headers:  section 1
+ * Fixed size for on-disk dk_label
+ */
+struct dk_map32 {
+	daddr32_t	dkl_cylno;	/* starting cylinder */
+	daddr32_t	dkl_nblk;	/* number of blocks;  if == 0, */
+					/* partition is undefined */
+};
+
+/*
+ * partition headers:  section 2,
+ * brought over from AT&T SVr4 vtoc structure.
+ */
+struct dk_map2 {
+	uint16_t	p_tag;		/* ID tag of partition */
+	uint16_t	p_flag;		/* permission flag */
+};
+
+struct dkl_partition    {
+	uint16_t	p_tag;		/* ID tag of partition */
+	uint16_t	p_flag;		/* permision flags */
+	daddr32_t	p_start;	/* start sector no of partition */
+	int32_t		p_size;		/* # of blocks in partition */
+};
+
+
+/*
+ * VTOC inclusions from AT&T SVr4
+ * Fixed sized types for on-disk VTOC
+ */
+
+struct dk_vtoc {
+#if defined(_SUNOS_VTOC_16)
+	uint32_t v_bootinfo[3];		/* info for mboot (unsupported) */
+	uint32_t v_sanity;		/* to verify vtoc sanity */
+	uint32_t v_version;		/* layout version */
+	char    v_volume[LEN_DKL_VVOL];	/* volume name */
+	uint16_t v_sectorsz;		/* sector size in bytes */
+	uint16_t v_nparts;		/* number of partitions */
+	uint32_t v_reserved[10];	/* free space */
+	struct dkl_partition v_part[NDKMAP];	/* partition headers */
+	time32_t timestamp[NDKMAP];	/* partition timestamp (unsupported) */
+	char    v_asciilabel[LEN_DKL_ASCII];	/* for compatibility    */
+#elif defined(_SUNOS_VTOC_8)
+	uint32_t	v_version;		/* layout version */
+	char		v_volume[LEN_DKL_VVOL];	/* volume name */
+	uint16_t	v_nparts;		/* number of partitions  */
+	struct dk_map2	v_part[NDKMAP];		/* partition hdrs, sec 2 */
+	uint32_t	v_bootinfo[3];		/* info needed by mboot */
+	uint32_t	v_sanity;		/* to verify vtoc sanity */
+	uint32_t	v_reserved[10];		/* free space */
+	time32_t	v_timestamp[NDKMAP];	/* partition timestamp */
+#else
+#error "No VTOC format defined."
+#endif
+};
+
+/*
+ * define the amount of disk label padding needed to make
+ * the entire structure occupy 512 bytes.
+ */
+#if defined(_SUNOS_VTOC_16)
+#define	LEN_DKL_PAD	(DK_LABEL_SIZE - \
+			    ((sizeof (struct dk_vtoc) + \
+			    (4 * sizeof (uint32_t)) + \
+			    (12 * sizeof (uint16_t)) + \
+			    (2 * (sizeof (uint16_t))))))
+#elif defined(_SUNOS_VTOC_8)
+#define	LEN_DKL_PAD	(DK_LABEL_SIZE \
+			    - ((LEN_DKL_ASCII) + \
+			    (sizeof (struct dk_vtoc)) + \
+			    (sizeof (struct dk_map32)  * NDKMAP) + \
+			    (14 * (sizeof (uint16_t))) + \
+			    (2 * (sizeof (uint16_t)))))
+#else
+#error "No VTOC format defined."
+#endif
+
+
+struct dk_label {
+#if defined(_SUNOS_VTOC_16)
+	struct  dk_vtoc dkl_vtoc;	/* vtoc inclusions from AT&T SVr4 */
+	uint32_t	dkl_pcyl;	/* # of physical cylinders */
+	uint32_t	dkl_ncyl;	/* # of data cylinders */
+	uint16_t	dkl_acyl;	/* # of alternate cylinders */
+	uint16_t	dkl_bcyl;	/* cyl offset (for fixed head area) */
+	uint32_t	dkl_nhead;	/* # of heads */
+	uint32_t	dkl_nsect;	/* # of data sectors per track */
+	uint16_t	dkl_intrlv;	/* interleave factor */
+	uint16_t	dkl_skew;	/* skew factor */
+	uint16_t	dkl_apc;	/* alternates per cyl (SCSI only)   */
+	uint16_t	dkl_rpm;	/* revolutions per minute */
+	uint16_t	dkl_write_reinstruct;	/* # sectors to skip, writes */
+	uint16_t	dkl_read_reinstruct;	/* # sectors to skip, reads  */
+	uint16_t	dkl_extra[4];	/* for compatible expansion */
+	char		dkl_pad[LEN_DKL_PAD];	/* unused part of 512 bytes */
+#elif defined(_SUNOS_VTOC_8)
+	char		dkl_asciilabel[LEN_DKL_ASCII]; /* for compatibility */
+	struct dk_vtoc	dkl_vtoc;	/* vtoc inclusions from AT&T SVr4 */
+	uint16_t	dkl_write_reinstruct;	/* # sectors to skip, writes */
+	uint16_t	dkl_read_reinstruct;	/* # sectors to skip, reads */
+	char		dkl_pad[LEN_DKL_PAD]; /* unused part of 512 bytes */
+	uint16_t	dkl_rpm;	/* rotations per minute */
+	uint16_t	dkl_pcyl;	/* # physical cylinders */
+	uint16_t	dkl_apc;	/* alternates per cylinder */
+	uint16_t	dkl_obs1;	/* obsolete */
+	uint16_t	dkl_obs2;	/* obsolete */
+	uint16_t	dkl_intrlv;	/* interleave factor */
+	uint16_t	dkl_ncyl;	/* # of data cylinders */
+	uint16_t	dkl_acyl;	/* # of alternate cylinders */
+	uint16_t	dkl_nhead;	/* # of heads in this partition */
+	uint16_t	dkl_nsect;	/* # of 512 byte sectors per track */
+	uint16_t	dkl_obs3;	/* obsolete */
+	uint16_t	dkl_obs4;	/* obsolete */
+	struct dk_map32	dkl_map[NDKMAP]; /* logical partition headers */
+#else
+#error "No VTOC format defined."
+#endif
+	uint16_t	dkl_magic;	/* identifies this label format */
+	uint16_t	dkl_cksum;	/* xor checksum of sector */
+};
+
+#if defined(_SUNOS_VTOC_16)
+#define	dkl_asciilabel	dkl_vtoc.v_asciilabel
+#define	v_timestamp	timestamp
+
+#elif defined(_SUNOS_VTOC_8)
+
+/*
+ * These defines are for historic compatibility with old drivers.
+ */
+#define	dkl_gap1	dkl_obs1	/* used to be gap1 */
+#define	dkl_gap2	dkl_obs2	/* used to be gap2 */
+#define	dkl_bhead	dkl_obs3	/* used to be label head offset */
+#define	dkl_ppart	dkl_obs4	/* used to by physical partition */
+#else
+#error "No VTOC format defined."
+#endif
+
+struct fk_label {			/* DOS floppy label */
+	uchar_t  fkl_type;
+	uchar_t  fkl_magich;
+	uchar_t  fkl_magicl;
+	uchar_t  filler;
+};
+
+/*
+ * Layout of stored fabricated device id  (on-disk)
+ */
+#define	DK_DEVID_BLKSIZE	(512)
+#define	DK_DEVID_SIZE		(DK_DEVID_BLKSIZE - ((sizeof (uchar_t) * 7)))
+#define	DK_DEVID_REV_MSB	(0)
+#define	DK_DEVID_REV_LSB	(1)
+
+struct dk_devid {
+	uchar_t	dkd_rev_hi;			/* revision (MSB) */
+	uchar_t	dkd_rev_lo;			/* revision (LSB) */
+	uchar_t	dkd_flags;			/* flags (not used yet) */
+	uchar_t	dkd_devid[DK_DEVID_SIZE];	/* devid stored here */
+	uchar_t	dkd_checksum3;			/* checksum (MSB) */
+	uchar_t	dkd_checksum2;
+	uchar_t	dkd_checksum1;
+	uchar_t	dkd_checksum0;			/* checksum (LSB) */
+};
+
+#define	DKD_GETCHKSUM(dkd)	((dkd)->dkd_checksum3 << 24) + \
+				((dkd)->dkd_checksum2 << 16) + \
+				((dkd)->dkd_checksum1 << 8)  + \
+				((dkd)->dkd_checksum0)
+
+#define	DKD_FORMCHKSUM(c, dkd)	(dkd)->dkd_checksum3 = hibyte(hiword((c))); \
+				(dkd)->dkd_checksum2 = lobyte(hiword((c))); \
+				(dkd)->dkd_checksum1 = hibyte(loword((c))); \
+				(dkd)->dkd_checksum0 = lobyte(loword((c)));
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DKLABEL_H */

lib/libspl/include/sys/dktp/fdisk.h

@@ -0,0 +1,173 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*	Copyright (c) 1984, 1986, 1987, 1988 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+
+#ifndef _SYS_DKTP_FDISK_H
+#define	_SYS_DKTP_FDISK_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * fdisk.h
+ * This file defines the structure of physical disk sector 0 for use on
+ * AT386 systems.  The format of this sector is constrained by the ROM
+ * BIOS and MS-DOS conventions.
+ * Note that this block does not define the partitions used by the unix
+ * driver.  The unix partitions are obtained from the VTOC.
+ */
+
+/*
+ * the MAX values are the maximum usable values for BIOS chs values
+ * The MAX_CYL value of 1022 is the maximum usable value
+ *   the value of 1023 is a fence value,
+ *   indicating no CHS geometry exists for the corresponding LBA value.
+ * HEAD range [ 0 .. MAX_HEAD ], so number of heads is (MAX_HEAD + 1)
+ * SECT range [ 1 .. MAX_SECT ], so number of sectors is (MAX_SECT)
+ */
+#define	MAX_SECT	(63)
+#define	MAX_CYL		(1022)
+#define	MAX_HEAD	(254)
+
+/*
+ * BOOTSZ was reduced from 446 to 440 bytes to NOT overwrite the Windows
+ * Vista DISKID. Otherwise Vista won't boot from Solaris GRUB in a dual-boot
+ * setup.
+ * The actual size of mboot code is 425 bytes while that of GRUB stage1 is
+ * 423 bytes. So this changes does not harm them.
+ */
+#define	BOOTSZ		440	/* size of boot code in master boot block */
+#define	FD_NUMPART	4	/* number of 'partitions' in fdisk table */
+#define	MBB_MAGIC	0xAA55	/* magic number for mboot.signature */
+#define	DEFAULT_INTLV	4	/* default interleave for testing tracks */
+#define	MINPSIZE	4	/* minimum number of cylinders in a partition */
+#define	TSTPAT		0xE5	/* test pattern for verifying disk */
+
+/*
+ * structure to hold the fdisk partition table
+ */
+struct ipart {
+	unsigned char bootid;	/* bootable or not */
+	unsigned char beghead;	/* beginning head, sector, cylinder */
+	unsigned char begsect;	/* begcyl is a 10-bit number. High 2 bits */
+	unsigned char begcyl;	/*	are in begsect. */
+	unsigned char systid;	/* OS type */
+	unsigned char endhead;	/* ending head, sector, cylinder */
+	unsigned char endsect;	/* endcyl is a 10-bit number.  High 2 bits */
+	unsigned char endcyl;	/*	are in endsect. */
+	uint32_t relsect;	/* first sector relative to start of disk */
+	uint32_t numsect;	/* number of sectors in partition */
+};
+/*
+ * Values for bootid.
+ */
+#define	NOTACTIVE	0
+#define	ACTIVE		128
+/*
+ * Values for systid.
+ */
+#define	UNUSED		0	/* Empty Partition */
+#define	DOSOS12		1	/* DOS partition, 12-bit FAT */
+#define	PCIXOS		2	/* PC/IX partition */
+#define	DOSOS16		4	/* DOS partition, 16-bit FAT */
+#define	EXTDOS		5	/* EXT-DOS partition */
+#define	DOSHUGE		6	/* Huge DOS partition  > 32MB */
+#define	FDISK_IFS	7	/* Installable File System (IFS): HPFS & NTFS */
+#define	FDISK_AIXBOOT	8	/* AIX Boot */
+#define	FDISK_AIXDATA	9	/* AIX Data */
+#define	FDISK_OS2BOOT	10	/* OS/2 Boot Manager */
+#define	FDISK_WINDOWS	11	/* Windows 95 FAT32 (up to 2047GB) */
+#define	FDISK_EXT_WIN	12	/* Windows 95 FAT32 (extended-INT13) */
+#define	FDISK_FAT95	14	/* DOS 16-bit FAT, LBA-mapped */
+#define	FDISK_EXTLBA	15	/* Extended partition, LBA-mapped */
+#define	DIAGPART	18	/* Diagnostic boot partition (OS independent) */
+#define	FDISK_LINUX	65	/* Linux */
+#define	FDISK_LINUXDSWAP	66	/* Linux swap (sharing disk w/ DRDOS) */
+#define	FDISK_LINUXDNAT	67	/* Linux native (sharing disk with DRDOS) */
+#define	FDISK_CPM	82	/* CP/M */
+#define	DOSDATA		86	/* DOS data partition */
+#define	OTHEROS		98	/* part. type for appl. (DB?) needs */
+				/* raw partition.  ID was 0 but conflicted */
+				/* with DOS 3.3 fdisk    */
+#define	UNIXOS		99	/* UNIX V.x partition */
+#define	FDISK_NOVELL2	100	/* Novell Netware 286 */
+#define	FDISK_NOVELL3	101	/* Novell Netware 3.x and later */
+#define	FDISK_QNX4	119	/* QNX 4.x */
+#define	FDISK_QNX42	120	/* QNX 4.x 2nd part */
+#define	FDISK_QNX43	121	/* QNX 4.x 3rd part */
+#define	SUNIXOS		130	/* Solaris UNIX partition */
+#define	FDISK_LINUXNAT	131	/* Linux native */
+#define	FDISK_NTFSVOL1	134	/* NTFS volume set 1 */
+#define	FDISK_NTFSVOL2	135	/* NTFS volume set 2 */
+#define	FDISK_BSD	165	/* BSD/386, 386BSD, NetBSD, FreeBSD, OpenBSD */
+#define	FDISK_NEXTSTEP	167	/* NeXTSTEP */
+#define	FDISK_BSDIFS	183	/* BSDI file system */
+#define	FDISK_BSDISWAP	184	/* BSDI swap */
+#define	X86BOOT		190	/* x86 Solaris boot partition */
+#define	SUNIXOS2	191	/* Solaris UNIX partition */
+#define	EFI_PMBR	238	/* EFI PMBR */
+#define	EFI_FS		239	/* EFI File System (System Partition) */
+#define	MAXDOS		65535L	/* max size (sectors) for DOS partition */
+
+/*
+ * structure to hold master boot block in physical sector 0 of the disk.
+ * Note that partitions stuff can't be directly included in the structure
+ * because of lameo '386 compiler alignment design.
+ * Alignment issues also force us to have 2 16bit entities for a single
+ * 32bit win_volserno. It is not used anywhere anyway.
+ */
+
+struct mboot {	/* master boot block */
+	char	bootinst[BOOTSZ];
+	uint16_t win_volserno_lo;
+	uint16_t win_volserno_hi;
+	uint16_t reserved;
+	char	parts[FD_NUMPART * sizeof (struct ipart)];
+	ushort_t signature;
+};
+
+#if defined(__i386) || defined(__amd64)
+
+/* Byte offset of the start of the partition table within the sector */
+#define	FDISK_PART_TABLE_START	446
+
+/* Maximum number of valid partitions assumed as 32 */
+#define	MAX_EXT_PARTS	32
+
+#else
+
+#define	MAX_EXT_PARTS	0
+
+#endif	/* if defined(__i386) || defined(__amd64) */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_DKTP_FDISK_H */

lib/libspl/include/sys/feature_tests.h

@@ -0,0 +1,32 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_FEATURE_TESTS_H
+#define _SYS_FEATURE_TESTS_H
+
+#define __NORETURN __attribute__((__noreturn__))
+
+#endif

lib/libspl/include/sys/file.h

@@ -0,0 +1,50 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_FILE_H
+#define _LIBSPL_SYS_FILE_H
+
+#include_next <sys/file.h>
+
+#include <sys/user.h>
+
+#define FREAD   1
+#define FWRITE  2
+//#define FAPPEND  8
+
+#define FCREAT  O_CREAT
+#define FTRUNC  O_TRUNC
+#define FOFFMAX O_LARGEFILE
+#define FSYNC   O_SYNC
+#define FDSYNC  O_DSYNC
+#define FRSYNC  O_RSYNC
+#define FEXCL   O_EXCL
+
+#define FNODSYNC        0x10000 /* fsync pseudo flag */
+#define FNOFOLLOW       0x20000 /* don't follow symlinks */
+#define FIGNORECASE     0x80000 /* request case-insensitive lookups */
+
+#endif

lib/libspl/include/sys/frame.h

@@ -0,0 +1,131 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_FRAME_H
+#define _SYS_FRAME_H
+
+#include <sys/types.h>
+
+#if defined(_LP64) || defined(_I32LPx)
+typedef long	greg_t;
+#else
+typedef int	greg_t;
+#endif
+
+struct frame {
+	greg_t fr_savfp;  /* saved frame pointer */
+	greg_t fr_savpc;  /* saved program counter */
+};
+
+
+/*
+ * In the x86 world, a stack frame looks like this:
+ *
+ *		|--------------------------|
+ * 4n+8(%ebp) ->| argument word n	   |
+ *		| ...			   |	(Previous frame)
+ *    8(%ebp) ->| argument word 0	   |
+ *		|--------------------------|--------------------
+ *    4(%ebp) ->| return address	   |
+ *		|--------------------------|
+ *    0(%ebp) ->| previous %ebp (optional) |
+ *		|--------------------------|
+ *   -4(%ebp) ->| unspecified		   |	(Current frame)
+ *		| ...			   |
+ *    0(%esp) ->| variable size		   |
+ *		|--------------------------|
+ */
+
+/*
+ * Stack alignment macros.
+ */
+
+#define	STACK_ALIGN32		4
+#define	STACK_ENTRY_ALIGN32	4
+#define	STACK_BIAS32		0
+#define	SA32(x)			(((x)+(STACK_ALIGN32-1)) & ~(STACK_ALIGN32-1))
+#define	STACK_RESERVE32		0
+#define	MINFRAME32		0
+
+#if defined(__amd64)
+
+/*
+ * In the amd64 world, a stack frame looks like this:
+ *
+ *		|--------------------------|
+ * 8n+16(%rbp)->| argument word n	   |
+ *		| ...			   |	(Previous frame)
+ *   16(%rbp) ->| argument word 0	   |
+ *		|--------------------------|--------------------
+ *    8(%rbp) ->| return address	   |
+ *		|--------------------------|
+ *    0(%rbp) ->| previous %rbp            |
+ *		|--------------------------|
+ *   -8(%rbp) ->| unspecified		   |	(Current frame)
+ *		| ...			   |
+ *    0(%rsp) ->| variable size		   |
+ *		|--------------------------|
+ * -128(%rsp) ->| reserved for function	   |
+ *		|--------------------------|
+ *
+ * The end of the input argument area must be aligned on a 16-byte
+ * boundary; i.e. (%rsp - 8) % 16 == 0 at function entry.
+ *
+ * The 128-byte location beyond %rsp is considered to be reserved for
+ * functions and is NOT modified by signal handlers.  It can be used
+ * to store temporary data that is not needed across function calls.
+ */
+
+/*
+ * Stack alignment macros.
+ */
+
+#define	STACK_ALIGN64		16
+#define	STACK_ENTRY_ALIGN64	8
+#define	STACK_BIAS64		0
+#define	SA64(x)			(((x)+(STACK_ALIGN64-1)) & ~(STACK_ALIGN64-1))
+#define	STACK_RESERVE64		128
+#define	MINFRAME64		0
+
+#define	STACK_ALIGN		STACK_ALIGN64
+#define	STACK_ENTRY_ALIGN	STACK_ENTRY_ALIGN64
+#define	STACK_BIAS		STACK_BIAS64
+#define	SA(x)			SA64(x)
+#define	STACK_RESERVE		STACK_RESERVE64
+#define	MINFRAME		MINFRAME64
+
+#elif defined(__i386)
+
+#define	STACK_ALIGN		STACK_ALIGN32
+#define	STACK_ENTRY_ALIGN	STACK_ENTRY_ALIGN32
+#define	STACK_BIAS		STACK_BIAS32
+#define	SA(x)			SA32(x)
+#define	STACK_RESERVE		STACK_RESERVE32
+#define	MINFRAME		MINFRAME32
+
+#endif	/* __i386 */
+
+#endif /* _SYS_FRAME_H */

lib/libspl/include/sys/int_limits.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_INT_LIMITS_H
+#define _LIBSPL_SYS_INT_LIMITS_H
+
+#endif

lib/libspl/include/sys/int_types.h

@@ -0,0 +1,32 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SOL_SYS_INT_TYPES_H
+#define _SOL_SYS_INT_TYPES_H
+
+#include <inttypes.h>
+
+#endif

lib/libspl/include/sys/inttypes.h

@@ -0,0 +1,34 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SOL_SYS_INTTYPES_H
+#define _SOL_SYS_INTTYPES_H
+
+#include <inttypes.h>
+
+#define _INT64_TYPE
+
+#endif

lib/libspl/include/sys/isa_defs.h

@@ -0,0 +1,125 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_ISA_DEFS_H
+#define	_SYS_ISA_DEFS_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* x86_64 arch specific defines */
+#if defined(__x86_64) || defined(__x86_64__)
+
+#if !defined(__x86_64)
+#define __x86_64
+#endif
+
+#if !defined(__amd64)
+#define __amd64
+#endif
+
+#if !defined(__x86)
+#define __x86
+#endif
+
+#if !defined(_LP64)
+#define _LP64
+#endif
+
+#if !defined(_LITTLE_ENDIAN)
+#define _LITTLE_ENDIAN
+#endif
+
+#define        _SUNOS_VTOC_16
+
+/* i386 arch specific defines */
+#elif defined(__i386) || defined(__i386__)
+
+#if !defined(__i386)
+#define __i386
+#endif
+
+#if !defined(__x86)
+#define __x86
+#endif
+
+#if !defined(_ILP32)
+#define _ILP32
+#endif
+
+#if !defined(_LITTLE_ENDIAN)
+#define _LITTLE_ENDIAN
+#endif
+
+#define        _SUNOS_VTOC_16
+
+/* powerpc arch specific defines */
+#elif defined(__powerpc) || defined(__powerpc__)
+
+#if !defined(__powerpc)
+#define __powerpc
+#endif
+
+#if !defined(__powerpc__)
+#define __powerpc__
+#endif
+
+#if !defined(_LP64)
+#ifdef __powerpc64__
+#define _LP64
+#else
+#define _LP32
+#endif
+#endif
+
+#if !defined(_BIG_ENDIAN)
+#define _BIG_ENDIAN
+#endif
+
+#define        _SUNOS_VTOC_16
+
+#else /* Currently only x86_64, i386, and powerpc arches supported */
+#error "Unsupported ISA type"
+#endif
+
+#if defined(_ILP32) && defined(_LP64)
+#error "Both _ILP32 and _LP64 are defined"
+#endif
+
+#if defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN)
+#error "Both _LITTLE_ENDIAN and _BIG_ENDIAN are defined"
+#endif
+
+#if !defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
+#error "Neither _LITTLE_ENDIAN nor _BIG_ENDIAN are defined"
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif	/* _SYS_ISA_DEFS_H */

lib/libspl/include/sys/kmem.h

@@ -0,0 +1,45 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_KMEM_H
+#define	_SYS_KMEM_H
+
+#include <stdlib.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	KM_SLEEP	0x00000000	/* same as KM_SLEEP */
+#define	KM_NOSLEEP	0x00000001	/* same as KM_NOSLEEP */
+
+#define kmem_alloc(size, flags)		malloc(size)
+#define kmem_free(ptr, size)		free(ptr)
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_KMEM_H */

lib/libspl/include/sys/kstat.h

@@ -0,0 +1,820 @@
+/*
+ * 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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_KSTAT_H
+#define	_SYS_KSTAT_H
+
+
+
+/*
+ * Definition of general kernel statistics structures and /dev/kstat ioctls
+ */
+
+#include <sys/types.h>
+#include <sys/time.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef int	kid_t;		/* unique kstat id */
+
+/*
+ * Kernel statistics driver (/dev/kstat) ioctls
+ */
+
+#define	KSTAT_IOC_BASE		('K' << 8)
+
+#define	KSTAT_IOC_CHAIN_ID	KSTAT_IOC_BASE | 0x01
+#define	KSTAT_IOC_READ		KSTAT_IOC_BASE | 0x02
+#define	KSTAT_IOC_WRITE		KSTAT_IOC_BASE | 0x03
+
+/*
+ * /dev/kstat ioctl usage (kd denotes /dev/kstat descriptor):
+ *
+ *	kcid = ioctl(kd, KSTAT_IOC_CHAIN_ID, NULL);
+ *	kcid = ioctl(kd, KSTAT_IOC_READ, kstat_t *);
+ *	kcid = ioctl(kd, KSTAT_IOC_WRITE, kstat_t *);
+ */
+
+#define	KSTAT_STRLEN	31	/* 30 chars + NULL; must be 16 * n - 1 */
+
+/*
+ * The generic kstat header
+ */
+
+typedef struct kstat {
+	/*
+	 * Fields relevant to both kernel and user
+	 */
+	hrtime_t	ks_crtime;	/* creation time (from gethrtime()) */
+	struct kstat	*ks_next;	/* kstat chain linkage */
+	kid_t		ks_kid;		/* unique kstat ID */
+	char		ks_module[KSTAT_STRLEN]; /* provider module name */
+	uchar_t		ks_resv;	/* reserved, currently just padding */
+	int		ks_instance;	/* provider module's instance */
+	char		ks_name[KSTAT_STRLEN]; /* kstat name */
+	uchar_t		ks_type;	/* kstat data type */
+	char		ks_class[KSTAT_STRLEN]; /* kstat class */
+	uchar_t		ks_flags;	/* kstat flags */
+	void		*ks_data;	/* kstat type-specific data */
+	uint_t		ks_ndata;	/* # of type-specific data records */
+	size_t		ks_data_size;	/* total size of kstat data section */
+	hrtime_t	ks_snaptime;	/* time of last data shapshot */
+	/*
+	 * Fields relevant to kernel only
+	 */
+	int		(*ks_update)(struct kstat *, int); /* dynamic update */
+	void		*ks_private;	/* arbitrary provider-private data */
+	int		(*ks_snapshot)(struct kstat *, void *, int);
+	void		*ks_lock;	/* protects this kstat's data */
+} kstat_t;
+
+#ifdef _SYSCALL32
+
+typedef int32_t kid32_t;
+
+typedef struct kstat32 {
+	/*
+	 * Fields relevant to both kernel and user
+	 */
+	hrtime_t	ks_crtime;
+	caddr32_t	ks_next;		/* struct kstat pointer */
+	kid32_t		ks_kid;
+	char		ks_module[KSTAT_STRLEN];
+	uint8_t		ks_resv;
+	int32_t		ks_instance;
+	char		ks_name[KSTAT_STRLEN];
+	uint8_t		ks_type;
+	char		ks_class[KSTAT_STRLEN];
+	uint8_t		ks_flags;
+	caddr32_t	ks_data;		/* type-specific data */
+	uint32_t	ks_ndata;
+	size32_t	ks_data_size;
+	hrtime_t	ks_snaptime;
+	/*
+	 * Fields relevant to kernel only (only needed here for padding)
+	 */
+	int32_t		_ks_update;
+	caddr32_t	_ks_private;
+	int32_t		_ks_snapshot;
+	caddr32_t	_ks_lock;
+} kstat32_t;
+
+#endif	/* _SYSCALL32 */
+
+/*
+ * kstat structure and locking strategy
+ *
+ * Each kstat consists of a header section (a kstat_t) and a data section.
+ * The system maintains a set of kstats, protected by kstat_chain_lock.
+ * kstat_chain_lock protects all additions to/deletions from this set,
+ * as well as all changes to kstat headers.  kstat data sections are
+ * *optionally* protected by the per-kstat ks_lock.  If ks_lock is non-NULL,
+ * kstat clients (e.g. /dev/kstat) will acquire this lock for all of their
+ * operations on that kstat.  It is up to the kstat provider to decide whether
+ * guaranteeing consistent data to kstat clients is sufficiently important
+ * to justify the locking cost.  Note, however, that most statistic updates
+ * already occur under one of the provider's mutexes, so if the provider sets
+ * ks_lock to point to that mutex, then kstat data locking is free.
+ *
+ * NOTE: variable-size kstats MUST employ kstat data locking, to prevent
+ * data-size races with kstat clients.
+ *
+ * NOTE: ks_lock is really of type (kmutex_t *); it is declared as (void *)
+ * in the kstat header so that users don't have to be exposed to all of the
+ * kernel's lock-related data structures.
+ */
+
+#if	defined(_KERNEL)
+
+#define	KSTAT_ENTER(k)	\
+	{ kmutex_t *lp = (k)->ks_lock; if (lp) mutex_enter(lp); }
+
+#define	KSTAT_EXIT(k)	\
+	{ kmutex_t *lp = (k)->ks_lock; if (lp) mutex_exit(lp); }
+
+#define	KSTAT_UPDATE(k, rw)		(*(k)->ks_update)((k), (rw))
+
+#define	KSTAT_SNAPSHOT(k, buf, rw)	(*(k)->ks_snapshot)((k), (buf), (rw))
+
+#endif	/* defined(_KERNEL) */
+
+/*
+ * kstat time
+ *
+ * All times associated with kstats (e.g. creation time, snapshot time,
+ * kstat_timer_t and kstat_io_t timestamps, etc.) are 64-bit nanosecond values,
+ * as returned by gethrtime().  The accuracy of these timestamps is machine
+ * dependent, but the precision (units) is the same across all platforms.
+ */
+
+/*
+ * kstat identity (KID)
+ *
+ * Each kstat is assigned a unique KID (kstat ID) when it is added to the
+ * global kstat chain.  The KID is used as a cookie by /dev/kstat to
+ * request information about the corresponding kstat.  There is also
+ * an identity associated with the entire kstat chain, kstat_chain_id,
+ * which is bumped each time a kstat is added or deleted.  /dev/kstat uses
+ * the chain ID to detect changes in the kstat chain (e.g., a new disk
+ * coming online) between ioctl()s.
+ */
+
+/*
+ * kstat module, kstat instance
+ *
+ * ks_module and ks_instance contain the name and instance of the module
+ * that created the kstat.  In cases where there can only be one instance,
+ * ks_instance is 0.  The kernel proper (/kernel/unix) uses "unix" as its
+ * module name.
+ */
+
+/*
+ * kstat name
+ *
+ * ks_name gives a meaningful name to a kstat.  The full kstat namespace
+ * is module.instance.name, so the name only need be unique within a
+ * module.  kstat_create() will fail if you try to create a kstat with
+ * an already-used (ks_module, ks_instance, ks_name) triplet.  Spaces are
+ * allowed in kstat names, but strongly discouraged, since they hinder
+ * awk-style processing at user level.
+ */
+
+/*
+ * kstat type
+ *
+ * The kstat mechanism provides several flavors of kstat data, defined
+ * below.  The "raw" kstat type is just treated as an array of bytes; you
+ * can use this to export any kind of data you want.
+ *
+ * Some kstat types allow multiple data structures per kstat, e.g.
+ * KSTAT_TYPE_NAMED; others do not.  This is part of the spec for each
+ * kstat data type.
+ *
+ * User-level tools should *not* rely on the #define KSTAT_NUM_TYPES.  To
+ * get this information, read out the standard system kstat "kstat_types".
+ */
+
+#define	KSTAT_TYPE_RAW		0	/* can be anything */
+					/* ks_ndata >= 1 */
+#define	KSTAT_TYPE_NAMED	1	/* name/value pair */
+					/* ks_ndata >= 1 */
+#define	KSTAT_TYPE_INTR		2	/* interrupt statistics */
+					/* ks_ndata == 1 */
+#define	KSTAT_TYPE_IO		3	/* I/O statistics */
+					/* ks_ndata == 1 */
+#define	KSTAT_TYPE_TIMER	4	/* event timer */
+					/* ks_ndata >= 1 */
+
+#define	KSTAT_NUM_TYPES		5
+
+/*
+ * kstat class
+ *
+ * Each kstat can be characterized as belonging to some broad class
+ * of statistics, e.g. disk, tape, net, vm, streams, etc.  This field
+ * can be used as a filter to extract related kstats.  The following
+ * values are currently in use: disk, tape, net, controller, vm, kvm,
+ * hat, streams, kstat, and misc.  (The kstat class encompasses things
+ * like kstat_types.)
+ */
+
+/*
+ * kstat flags
+ *
+ * Any of the following flags may be passed to kstat_create().  They are
+ * all zero by default.
+ *
+ *	KSTAT_FLAG_VIRTUAL:
+ *
+ *		Tells kstat_create() not to allocate memory for the
+ *		kstat data section; instead, you will set the ks_data
+ *		field to point to the data you wish to export.  This
+ *		provides a convenient way to export existing data
+ *		structures.
+ *
+ *	KSTAT_FLAG_VAR_SIZE:
+ *
+ *		The size of the kstat you are creating will vary over time.
+ *		For example, you may want to use the kstat mechanism to
+ *		export a linked list.  NOTE: The kstat framework does not
+ *		manage the data section, so all variable-size kstats must be
+ *		virtual kstats.  Moreover, variable-size kstats MUST employ
+ *		kstat data locking to prevent data-size races with kstat
+ *		clients.  See the section on "kstat snapshot" for details.
+ *
+ *	KSTAT_FLAG_WRITABLE:
+ *
+ *		Makes the kstat's data section writable by root.
+ *		The ks_snapshot routine (see below) does not need to check for
+ *		this; permission checking is handled in the kstat driver.
+ *
+ *	KSTAT_FLAG_PERSISTENT:
+ *
+ *		Indicates that this kstat is to be persistent over time.
+ *		For persistent kstats, kstat_delete() simply marks the
+ *		kstat as dormant; a subsequent kstat_create() reactivates
+ *		the kstat.  This feature is provided so that statistics
+ *		are not lost across driver close/open (e.g., raw disk I/O
+ *		on a disk with no mounted partitions.)
+ *		NOTE: Persistent kstats cannot be virtual, since ks_data
+ *		points to garbage as soon as the driver goes away.
+ *
+ * The following flags are maintained by the kstat framework:
+ *
+ *	KSTAT_FLAG_DORMANT:
+ *
+ *		For persistent kstats, indicates that the kstat is in the
+ *		dormant state (e.g., the corresponding device is closed).
+ *
+ *	KSTAT_FLAG_INVALID:
+ *
+ *		This flag is set when a kstat is in a transitional state,
+ *		e.g. between kstat_create() and kstat_install().
+ *		kstat clients must not attempt to access the kstat's data
+ *		if this flag is set.
+ */
+
+#define	KSTAT_FLAG_VIRTUAL		0x01
+#define	KSTAT_FLAG_VAR_SIZE		0x02
+#define	KSTAT_FLAG_WRITABLE		0x04
+#define	KSTAT_FLAG_PERSISTENT		0x08
+#define	KSTAT_FLAG_DORMANT		0x10
+#define	KSTAT_FLAG_INVALID		0x20
+
+/*
+ * Dynamic update support
+ *
+ * The kstat mechanism allows for an optional ks_update function to update
+ * kstat data.  This is useful for drivers where the underlying device
+ * keeps cheap hardware stats, but extraction is expensive.  Instead of
+ * constantly keeping the kstat data section up to date, you can supply a
+ * ks_update function which updates the kstat's data section on demand.
+ * To take advantage of this feature, simply set the ks_update field before
+ * calling kstat_install().
+ *
+ * The ks_update function, if supplied, must have the following structure:
+ *
+ *	int
+ *	foo_kstat_update(kstat_t *ksp, int rw)
+ *	{
+ *		if (rw == KSTAT_WRITE) {
+ *			... update the native stats from ksp->ks_data;
+ *				return EACCES if you don't support this
+ *		} else {
+ *			... update ksp->ks_data from the native stats
+ *		}
+ *	}
+ *
+ * The ks_update return codes are: 0 for success, EACCES if you don't allow
+ * KSTAT_WRITE, and EIO for any other type of error.
+ *
+ * In general, the ks_update function may need to refer to provider-private
+ * data; for example, it may need a pointer to the provider's raw statistics.
+ * The ks_private field is available for this purpose.  Its use is entirely
+ * at the provider's discretion.
+ *
+ * All variable-size kstats MUST supply a ks_update routine, which computes
+ * and sets ks_data_size (and ks_ndata if that is meaningful), since these
+ * are needed to perform kstat snapshots (see below).
+ *
+ * No kstat locking should be done inside the ks_update routine.  The caller
+ * will already be holding the kstat's ks_lock (to ensure consistent data).
+ */
+
+#define	KSTAT_READ	0
+#define	KSTAT_WRITE	1
+
+/*
+ * Kstat snapshot
+ *
+ * In order to get a consistent view of a kstat's data, clients must obey
+ * the kstat's locking strategy.  However, these clients may need to perform
+ * operations on the data which could cause a fault (e.g. copyout()), or
+ * operations which are simply expensive.  Doing so could cause deadlock
+ * (e.g. if you're holding a disk's kstat lock which is ultimately required
+ * to resolve a copyout() fault), performance degradation (since the providers'
+ * activity is serialized at the kstat lock), device timing problems, etc.
+ *
+ * To avoid these problems, kstat data is provided via snapshots.  Taking
+ * a snapshot is a simple process: allocate a wired-down kernel buffer,
+ * acquire the kstat's data lock, copy the data into the buffer ("take the
+ * snapshot"), and release the lock.  This ensures that the kstat's data lock
+ * will be held as briefly as possible, and that no faults will occur while
+ * the lock is held.
+ *
+ * Normally, the snapshot is taken by default_kstat_snapshot(), which
+ * timestamps the data (sets ks_snaptime), copies it, and does a little
+ * massaging to deal with incomplete transactions on i/o kstats.  However,
+ * this routine only works for kstats with contiguous data (the typical case).
+ * If you create a kstat whose data is, say, a linked list, you must provide
+ * your own ks_snapshot routine.  The routine you supply must have the
+ * following prototype (replace "foo" with something appropriate):
+ *
+ *	int foo_kstat_snapshot(kstat_t *ksp, void *buf, int rw);
+ *
+ * The minimal snapshot routine -- one which copies contiguous data that
+ * doesn't need any massaging -- would be this:
+ *
+ *	ksp->ks_snaptime = gethrtime();
+ *	if (rw == KSTAT_WRITE)
+ *		bcopy(buf, ksp->ks_data, ksp->ks_data_size);
+ *	else
+ *		bcopy(ksp->ks_data, buf, ksp->ks_data_size);
+ *	return (0);
+ *
+ * A more illuminating example is taking a snapshot of a linked list:
+ *
+ *	ksp->ks_snaptime = gethrtime();
+ *	if (rw == KSTAT_WRITE)
+ *		return (EACCES);		... See below ...
+ *	for (foo = first_foo; foo; foo = foo->next) {
+ *		bcopy((char *) foo, (char *) buf, sizeof (struct foo));
+ *		buf = ((struct foo *) buf) + 1;
+ *	}
+ *	return (0);
+ *
+ * In the example above, we have decided that we don't want to allow
+ * KSTAT_WRITE access, so we return EACCES if this is attempted.
+ *
+ * The key points are:
+ *
+ *	(1) ks_snaptime must be set (via gethrtime()) to timestamp the data.
+ *	(2) Data gets copied from the kstat to the buffer on KSTAT_READ,
+ *		and from the buffer to the kstat on KSTAT_WRITE.
+ *	(3) ks_snapshot return values are: 0 for success, EACCES if you
+ *		don't allow KSTAT_WRITE, and EIO for any other type of error.
+ *
+ * Named kstats (see section on "Named statistics" below) containing long
+ * strings (KSTAT_DATA_STRING) need special handling.  The kstat driver
+ * assumes that all strings are copied into the buffer after the array of
+ * named kstats, and the pointers (KSTAT_NAMED_STR_PTR()) are updated to point
+ * into the copy within the buffer. The default snapshot routine does this,
+ * but overriding routines should contain at least the following:
+ *
+ * if (rw == KSTAT_READ) {
+ * 	kstat_named_t *knp = buf;
+ * 	char *end = knp + ksp->ks_ndata;
+ * 	uint_t i;
+ *
+ * 	... Do the regular copy ...
+ * 	bcopy(ksp->ks_data, buf, sizeof (kstat_named_t) * ksp->ks_ndata);
+ *
+ * 	for (i = 0; i < ksp->ks_ndata; i++, knp++) {
+ *		if (knp[i].data_type == KSTAT_DATA_STRING &&
+ *		    KSTAT_NAMED_STR_PTR(knp) != NULL) {
+ *			bcopy(KSTAT_NAMED_STR_PTR(knp), end,
+ *			    KSTAT_NAMED_STR_BUFLEN(knp));
+ *			KSTAT_NAMED_STR_PTR(knp) = end;
+ *			end += KSTAT_NAMED_STR_BUFLEN(knp);
+ *		}
+ *	}
+ */
+
+/*
+ * Named statistics.
+ *
+ * List of arbitrary name=value statistics.
+ */
+
+typedef struct kstat_named {
+	char	name[KSTAT_STRLEN];	/* name of counter */
+	uchar_t	data_type;		/* data type */
+	union {
+		char		c[16];	/* enough for 128-bit ints */
+		int32_t		i32;
+		uint32_t	ui32;
+		struct {
+			union {
+				char 		*ptr;	/* NULL-term string */
+#if defined(_KERNEL) && defined(_MULTI_DATAMODEL)
+				caddr32_t	ptr32;
+#endif
+				char 		__pad[8]; /* 64-bit padding */
+			} addr;
+			uint32_t	len;	/* # bytes for strlen + '\0' */
+		} str;
+/*
+ * The int64_t and uint64_t types are not valid for a maximally conformant
+ * 32-bit compilation environment (cc -Xc) using compilers prior to the
+ * introduction of C99 conforming compiler (reference ISO/IEC 9899:1990).
+ * In these cases, the visibility of i64 and ui64 is only permitted for
+ * 64-bit compilation environments or 32-bit non-maximally conformant
+ * C89 or C90 ANSI C compilation environments (cc -Xt and cc -Xa). In the
+ * C99 ANSI C compilation environment, the long long type is supported.
+ * The _INT64_TYPE is defined by the implementation (see sys/int_types.h).
+ */
+#if defined(_INT64_TYPE)
+		int64_t		i64;
+		uint64_t	ui64;
+#endif
+		long		l;
+		ulong_t		ul;
+
+		/* These structure members are obsolete */
+
+		longlong_t	ll;
+		u_longlong_t	ull;
+		float		f;
+		double		d;
+	} value;			/* value of counter */
+} kstat_named_t;
+
+#define	KSTAT_DATA_CHAR		0
+#define	KSTAT_DATA_INT32	1
+#define	KSTAT_DATA_UINT32	2
+#define	KSTAT_DATA_INT64	3
+#define	KSTAT_DATA_UINT64	4
+
+#if !defined(_LP64)
+#define	KSTAT_DATA_LONG		KSTAT_DATA_INT32
+#define	KSTAT_DATA_ULONG	KSTAT_DATA_UINT32
+#else
+#if !defined(_KERNEL)
+#define	KSTAT_DATA_LONG		KSTAT_DATA_INT64
+#define	KSTAT_DATA_ULONG	KSTAT_DATA_UINT64
+#else
+#define	KSTAT_DATA_LONG		7	/* only visible to the kernel */
+#define	KSTAT_DATA_ULONG	8	/* only visible to the kernel */
+#endif	/* !_KERNEL */
+#endif	/* !_LP64 */
+
+/*
+ * Statistics exporting named kstats with long strings (KSTAT_DATA_STRING)
+ * may not make the assumption that ks_data_size is equal to (ks_ndata * sizeof
+ * (kstat_named_t)).  ks_data_size in these cases is equal to the sum of the
+ * amount of space required to store the strings (ie, the sum of
+ * KSTAT_NAMED_STR_BUFLEN() for all KSTAT_DATA_STRING statistics) plus the
+ * space required to store the kstat_named_t's.
+ *
+ * The default update routine will update ks_data_size automatically for
+ * variable-length kstats containing long strings (using the default update
+ * routine only makes sense if the string is the only thing that is changing
+ * in size, and ks_ndata is constant).  Fixed-length kstats containing long
+ * strings must explicitly change ks_data_size (after creation but before
+ * initialization) to reflect the correct amount of space required for the
+ * long strings and the kstat_named_t's.
+ */
+#define	KSTAT_DATA_STRING	9
+
+/* These types are obsolete */
+
+#define	KSTAT_DATA_LONGLONG	KSTAT_DATA_INT64
+#define	KSTAT_DATA_ULONGLONG	KSTAT_DATA_UINT64
+#define	KSTAT_DATA_FLOAT	5
+#define	KSTAT_DATA_DOUBLE	6
+
+#define	KSTAT_NAMED_PTR(kptr)	((kstat_named_t *)(kptr)->ks_data)
+
+/*
+ * Retrieve the pointer of the string contained in the given named kstat.
+ */
+#define	KSTAT_NAMED_STR_PTR(knptr) ((knptr)->value.str.addr.ptr)
+
+/*
+ * Retrieve the length of the buffer required to store the string in the given
+ * named kstat.
+ */
+#define	KSTAT_NAMED_STR_BUFLEN(knptr) ((knptr)->value.str.len)
+
+/*
+ * Interrupt statistics.
+ *
+ * An interrupt is a hard interrupt (sourced from the hardware device
+ * itself), a soft interrupt (induced by the system via the use of
+ * some system interrupt source), a watchdog interrupt (induced by
+ * a periodic timer call), spurious (an interrupt entry point was
+ * entered but there was no interrupt condition to service),
+ * or multiple service (an interrupt condition was detected and
+ * serviced just prior to returning from any of the other types).
+ *
+ * Measurement of the spurious class of interrupts is useful for
+ * autovectored devices in order to pinpoint any interrupt latency
+ * problems in a particular system configuration.
+ *
+ * Devices that have more than one interrupt of the same
+ * type should use multiple structures.
+ */
+
+#define	KSTAT_INTR_HARD			0
+#define	KSTAT_INTR_SOFT			1
+#define	KSTAT_INTR_WATCHDOG		2
+#define	KSTAT_INTR_SPURIOUS		3
+#define	KSTAT_INTR_MULTSVC		4
+
+#define	KSTAT_NUM_INTRS			5
+
+typedef struct kstat_intr {
+	uint_t	intrs[KSTAT_NUM_INTRS];	/* interrupt counters */
+} kstat_intr_t;
+
+#define	KSTAT_INTR_PTR(kptr)	((kstat_intr_t *)(kptr)->ks_data)
+
+/*
+ * I/O statistics.
+ */
+
+typedef struct kstat_io {
+
+	/*
+	 * Basic counters.
+	 *
+	 * The counters should be updated at the end of service
+	 * (e.g., just prior to calling biodone()).
+	 */
+
+	u_longlong_t	nread;		/* number of bytes read */
+	u_longlong_t	nwritten;	/* number of bytes written */
+	uint_t		reads;		/* number of read operations */
+	uint_t		writes;		/* number of write operations */
+
+	/*
+	 * Accumulated time and queue length statistics.
+	 *
+	 * Accumulated time statistics are kept as a running sum
+	 * of "active" time.  Queue length statistics are kept as a
+	 * running sum of the product of queue length and elapsed time
+	 * at that length -- i.e., a Riemann sum for queue length
+	 * integrated against time.  (You can also think of the active time
+	 * as a Riemann sum, for the boolean function (queue_length > 0)
+	 * integrated against time, or you can think of it as the
+	 * Lebesgue measure of the set on which queue_length > 0.)
+	 *
+	 *		^
+	 *		|			_________
+	 *		8			| i4	|
+	 *		|			|	|
+	 *	Queue	6			|	|
+	 *	Length	|	_________	|	|
+	 *		4	| i2	|_______|	|
+	 *		|	|	    i3		|
+	 *		2_______|			|
+	 *		|    i1				|
+	 *		|_______________________________|
+	 *		Time->	t1	t2	t3	t4
+	 *
+	 * At each change of state (entry or exit from the queue),
+	 * we add the elapsed time (since the previous state change)
+	 * to the active time if the queue length was non-zero during
+	 * that interval; and we add the product of the elapsed time
+	 * times the queue length to the running length*time sum.
+	 *
+	 * This method is generalizable to measuring residency
+	 * in any defined system: instead of queue lengths, think
+	 * of "outstanding RPC calls to server X".
+	 *
+	 * A large number of I/O subsystems have at least two basic
+	 * "lists" of transactions they manage: one for transactions
+	 * that have been accepted for processing but for which processing
+	 * has yet to begin, and one for transactions which are actively
+	 * being processed (but not done). For this reason, two cumulative
+	 * time statistics are defined here: wait (pre-service) time,
+	 * and run (service) time.
+	 *
+	 * All times are 64-bit nanoseconds (hrtime_t), as returned by
+	 * gethrtime().
+	 *
+	 * The units of cumulative busy time are accumulated nanoseconds.
+	 * The units of cumulative length*time products are elapsed time
+	 * times queue length.
+	 *
+	 * Updates to the fields below are performed implicitly by calls to
+	 * these five functions:
+	 *
+	 *	kstat_waitq_enter()
+	 *	kstat_waitq_exit()
+	 *	kstat_runq_enter()
+	 *	kstat_runq_exit()
+	 *
+	 *	kstat_waitq_to_runq()		(see below)
+	 *	kstat_runq_back_to_waitq()	(see below)
+	 *
+	 * Since kstat_waitq_exit() is typically followed immediately
+	 * by kstat_runq_enter(), there is a single kstat_waitq_to_runq()
+	 * function which performs both operations.  This is a performance
+	 * win since only one timestamp is required.
+	 *
+	 * In some instances, it may be necessary to move a request from
+	 * the run queue back to the wait queue, e.g. for write throttling.
+	 * For these situations, call kstat_runq_back_to_waitq().
+	 *
+	 * These fields should never be updated by any other means.
+	 */
+
+	hrtime_t wtime;		/* cumulative wait (pre-service) time */
+	hrtime_t wlentime;	/* cumulative wait length*time product */
+	hrtime_t wlastupdate;	/* last time wait queue changed */
+	hrtime_t rtime;		/* cumulative run (service) time */
+	hrtime_t rlentime;	/* cumulative run length*time product */
+	hrtime_t rlastupdate;	/* last time run queue changed */
+
+	uint_t	wcnt;		/* count of elements in wait state */
+	uint_t	rcnt;		/* count of elements in run state */
+
+} kstat_io_t;
+
+#define	KSTAT_IO_PTR(kptr)	((kstat_io_t *)(kptr)->ks_data)
+
+/*
+ * Event timer statistics - cumulative elapsed time and number of events.
+ *
+ * Updates to these fields are performed implicitly by calls to
+ * kstat_timer_start() and kstat_timer_stop().
+ */
+
+typedef struct kstat_timer {
+	char		name[KSTAT_STRLEN];	/* event name */
+	uchar_t		resv;			/* reserved */
+	u_longlong_t	num_events;		/* number of events */
+	hrtime_t	elapsed_time;		/* cumulative elapsed time */
+	hrtime_t	min_time;		/* shortest event duration */
+	hrtime_t	max_time;		/* longest event duration */
+	hrtime_t	start_time;		/* previous event start time */
+	hrtime_t	stop_time;		/* previous event stop time */
+} kstat_timer_t;
+
+#define	KSTAT_TIMER_PTR(kptr)	((kstat_timer_t *)(kptr)->ks_data)
+
+#if	defined(_KERNEL)
+
+#include <sys/t_lock.h>
+
+extern kid_t	kstat_chain_id;		/* bumped at each state change */
+extern void	kstat_init(void);	/* initialize kstat framework */
+
+/*
+ * Adding and deleting kstats.
+ *
+ * The typical sequence to add a kstat is:
+ *
+ *	ksp = kstat_create(module, instance, name, class, type, ndata, flags);
+ *	if (ksp) {
+ *		... provider initialization, if necessary
+ *		kstat_install(ksp);
+ *	}
+ *
+ * There are three logically distinct steps here:
+ *
+ * Step 1: System Initialization (kstat_create)
+ *
+ * kstat_create() performs system initialization.  kstat_create()
+ * allocates memory for the entire kstat (header plus data), initializes
+ * all header fields, initializes the data section to all zeroes, assigns
+ * a unique KID, and puts the kstat onto the system's kstat chain.
+ * The returned kstat is marked invalid (KSTAT_FLAG_INVALID is set),
+ * because the provider (caller) has not yet had a chance to initialize
+ * the data section.
+ *
+ * By default, kstats are exported to all zones on the system.  A kstat may be
+ * created via kstat_create_zone() to specify a zone to which the statistics
+ * should be exported.  kstat_zone_add() may be used to specify additional
+ * zones to which the statistics are to be exported.
+ *
+ * Step 2: Provider Initialization
+ *
+ * The provider performs any necessary initialization of the data section,
+ * e.g. setting the name fields in a KSTAT_TYPE_NAMED.  Virtual kstats set
+ * the ks_data field at this time.  The provider may also set the ks_update,
+ * ks_snapshot, ks_private, and ks_lock fields if necessary.
+ *
+ * Step 3: Installation (kstat_install)
+ *
+ * Once the kstat is completely initialized, kstat_install() clears the
+ * INVALID flag, thus making the kstat accessible to the outside world.
+ * kstat_install() also clears the DORMANT flag for persistent kstats.
+ *
+ * Removing a kstat from the system
+ *
+ * kstat_delete(ksp) removes ksp from the kstat chain and frees all
+ * associated system resources.  NOTE: When you call kstat_delete(),
+ * you must NOT be holding that kstat's ks_lock.  Otherwise, you may
+ * deadlock with a kstat reader.
+ *
+ * Persistent kstats
+ *
+ * From the provider's point of view, persistence is transparent.  The only
+ * difference between ephemeral (normal) kstats and persistent kstats
+ * is that you pass KSTAT_FLAG_PERSISTENT to kstat_create().  Magically,
+ * this has the effect of making your data visible even when you're
+ * not home.  Persistence is important to tools like iostat, which want
+ * to get a meaningful picture of disk activity.  Without persistence,
+ * raw disk i/o statistics could never accumulate: they would come and
+ * go with each open/close of the raw device.
+ *
+ * The magic of persistence works by slightly altering the behavior of
+ * kstat_create() and kstat_delete().  The first call to kstat_create()
+ * creates a new kstat, as usual.  However, kstat_delete() does not
+ * actually delete the kstat: it performs one final update of the data
+ * (i.e., calls the ks_update routine), marks the kstat as dormant, and
+ * sets the ks_lock, ks_update, ks_private, and ks_snapshot fields back
+ * to their default values (since they might otherwise point to garbage,
+ * e.g. if the provider is going away).  kstat clients can still access
+ * the dormant kstat just like a live kstat; they just continue to see
+ * the final data values as long as the kstat remains dormant.
+ * All subsequent kstat_create() calls simply find the already-existing,
+ * dormant kstat and return a pointer to it, without altering any fields.
+ * The provider then performs its usual initialization sequence, and
+ * calls kstat_install().  kstat_install() uses the old data values to
+ * initialize the native data (i.e., ks_update is called with KSTAT_WRITE),
+ * thus making it seem like you were never gone.
+ */
+
+extern kstat_t *kstat_create(const char *, int, const char *, const char *,
+    uchar_t, uint_t, uchar_t);
+extern kstat_t *kstat_create_zone(const char *, int, const char *,
+    const char *, uchar_t, uint_t, uchar_t, zoneid_t);
+extern void kstat_install(kstat_t *);
+extern void kstat_delete(kstat_t *);
+extern void kstat_named_setstr(kstat_named_t *knp, const char *src);
+extern void kstat_set_string(char *, const char *);
+extern void kstat_delete_byname(const char *, int, const char *);
+extern void kstat_delete_byname_zone(const char *, int, const char *, zoneid_t);
+extern void kstat_named_init(kstat_named_t *, const char *, uchar_t);
+extern void kstat_timer_init(kstat_timer_t *, const char *);
+extern void kstat_waitq_enter(kstat_io_t *);
+extern void kstat_waitq_exit(kstat_io_t *);
+extern void kstat_runq_enter(kstat_io_t *);
+extern void kstat_runq_exit(kstat_io_t *);
+extern void kstat_waitq_to_runq(kstat_io_t *);
+extern void kstat_runq_back_to_waitq(kstat_io_t *);
+extern void kstat_timer_start(kstat_timer_t *);
+extern void kstat_timer_stop(kstat_timer_t *);
+
+extern void kstat_zone_add(kstat_t *, zoneid_t);
+extern void kstat_zone_remove(kstat_t *, zoneid_t);
+extern int kstat_zone_find(kstat_t *, zoneid_t);
+
+extern kstat_t *kstat_hold_bykid(kid_t kid, zoneid_t);
+extern kstat_t *kstat_hold_byname(const char *, int, const char *, zoneid_t);
+extern void kstat_rele(kstat_t *);
+
+#endif	/* defined(_KERNEL) */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_KSTAT_H */

lib/libspl/include/sys/list.h

@@ -0,0 +1,65 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_LIST_H
+#define	_SYS_LIST_H
+
+#include <sys/list_impl.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct list_node list_node_t;
+typedef struct list list_t;
+
+void list_create(list_t *, size_t, size_t);
+void list_destroy(list_t *);
+
+void list_insert_after(list_t *, void *, void *);
+void list_insert_before(list_t *, void *, void *);
+void list_insert_head(list_t *, void *);
+void list_insert_tail(list_t *, void *);
+void list_remove(list_t *, void *);
+void *list_remove_head(list_t *);
+void *list_remove_tail(list_t *);
+void list_move_tail(list_t *, list_t *);
+
+void *list_head(list_t *);
+void *list_tail(list_t *);
+void *list_next(list_t *, void *);
+void *list_prev(list_t *, void *);
+int list_is_empty(list_t *);
+
+void list_link_init(list_node_t *);
+void list_link_replace(list_node_t *, list_node_t *);
+
+int list_link_active(list_node_t *);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_LIST_H */

lib/libspl/include/sys/list_impl.h

@@ -0,0 +1,51 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2003 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_LIST_IMPL_H
+#define	_SYS_LIST_IMPL_H
+
+#include <sys/types.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+struct list_node {
+	struct list_node *list_next;
+	struct list_node *list_prev;
+};
+
+struct list {
+	size_t	list_size;
+	size_t	list_offset;
+	struct list_node list_head;
+};
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_LIST_IMPL_H */

lib/libspl/include/sys/machelf.h

@@ -0,0 +1,180 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_MACHELF_H
+#define	_SYS_MACHELF_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#if defined(__amd64)
+#include <sys/elf_amd64.h>
+#elif defined(__i386)
+#include <sys/elf_386.h>
+#elif defined(__sparc)
+#include <sys/elf_SPARC.h>
+#endif
+#ifndef	_ASM
+#include <sys/types.h>
+#include <sys/elf.h>
+#include <sys/link.h>	/* for Elf*_Dyn */
+#endif	/* _ASM */
+
+/*
+ * Make machine class dependent data types transparent to the common code
+ */
+#if defined(_ELF64) && !defined(_ELF32_COMPAT)
+
+#ifndef	_ASM
+typedef	Elf64_Xword	Xword;
+typedef	Elf64_Lword	Lword;
+typedef	Elf64_Sxword	Sxword;
+typedef	Elf64_Word	Word;
+typedef	Elf64_Sword	Sword;
+typedef	Elf64_Half	Half;
+typedef	Elf64_Addr	Addr;
+typedef	Elf64_Off	Off;
+typedef	uchar_t		Byte;
+#endif	/* _ASM */
+
+#if defined(_KERNEL)
+#define	ELF_R_TYPE	ELF64_R_TYPE
+#define	ELF_R_SYM	ELF64_R_SYM
+#define	ELF_R_TYPE_DATA ELF64_R_TYPE_DATA
+#define	ELF_R_INFO	ELF64_R_INFO
+#define	ELF_ST_BIND	ELF64_ST_BIND
+#define	ELF_ST_TYPE	ELF64_ST_TYPE
+#define	ELF_M_SYM	ELF64_M_SYM
+#define	ELF_M_SIZE	ELF64_M_SIZE
+#endif
+
+#ifndef	_ASM
+typedef	Elf64_Ehdr	Ehdr;
+typedef	Elf64_Shdr	Shdr;
+typedef	Elf64_Sym	Sym;
+typedef	Elf64_Syminfo	Syminfo;
+typedef	Elf64_Rela	Rela;
+typedef	Elf64_Rel	Rel;
+typedef	Elf64_Nhdr	Nhdr;
+typedef	Elf64_Phdr	Phdr;
+typedef	Elf64_Dyn	Dyn;
+typedef	Elf64_Boot	Boot;
+typedef	Elf64_Verdef	Verdef;
+typedef	Elf64_Verdaux	Verdaux;
+typedef	Elf64_Verneed	Verneed;
+typedef	Elf64_Vernaux	Vernaux;
+typedef	Elf64_Versym	Versym;
+typedef	Elf64_Move	Move;
+typedef	Elf64_Cap	Cap;
+#endif	/* _ASM */
+
+#else	/* _ILP32 */
+
+#ifndef	_ASM
+typedef	Elf32_Word	Xword;	/* Xword/Sxword are 32-bits in Elf32 */
+typedef	Elf32_Lword	Lword;
+typedef	Elf32_Sword	Sxword;
+typedef	Elf32_Word	Word;
+typedef	Elf32_Sword	Sword;
+typedef	Elf32_Half	Half;
+typedef	Elf32_Addr	Addr;
+typedef	Elf32_Off	Off;
+typedef	uchar_t		Byte;
+#endif	/* _ASM */
+
+#if defined(_KERNEL)
+#define	ELF_R_TYPE	ELF32_R_TYPE
+#define	ELF_R_SYM	ELF32_R_SYM
+#define	ELF_R_TYPE_DATA(x)	(0)
+#define	ELF_R_INFO	ELF32_R_INFO
+#define	ELF_ST_BIND	ELF32_ST_BIND
+#define	ELF_ST_TYPE	ELF32_ST_TYPE
+#define	ELF_M_SYM	ELF32_M_SYM
+#define	ELF_M_SIZE	ELF32_M_SIZE
+#endif
+
+#ifndef	_ASM
+typedef	Elf32_Ehdr	Ehdr;
+typedef	Elf32_Shdr	Shdr;
+typedef	Elf32_Sym	Sym;
+typedef	Elf32_Syminfo	Syminfo;
+typedef	Elf32_Rela	Rela;
+typedef	Elf32_Rel	Rel;
+typedef	Elf32_Nhdr	Nhdr;
+typedef	Elf32_Phdr	Phdr;
+typedef	Elf32_Dyn	Dyn;
+typedef	Elf32_Boot	Boot;
+typedef	Elf32_Verdef	Verdef;
+typedef	Elf32_Verdaux	Verdaux;
+typedef	Elf32_Verneed	Verneed;
+typedef	Elf32_Vernaux	Vernaux;
+typedef	Elf32_Versym	Versym;
+typedef	Elf32_Move	Move;
+typedef	Elf32_Cap	Cap;
+#endif	/* _ASM */
+
+#endif	/* _ILP32 */
+
+/*
+ * Elf `printf' type-cast macros.  These force arguments to be a fixed size
+ * so that Elf32 and Elf64 can share common format strings.
+ */
+#ifndef	__lint
+#define	EC_ADDR(a)	((Elf64_Addr)(a))		/* "ull" */
+#define	EC_OFF(a)	((Elf64_Off)(a))		/* "ull"  */
+#define	EC_HALF(a)	((Elf64_Half)(a))		/* "d"   */
+#define	EC_WORD(a)	((Elf64_Word)(a))		/* "u"   */
+#define	EC_SWORD(a)	((Elf64_Sword)(a))		/* "d"   */
+#define	EC_XWORD(a)	((Elf64_Xword)(a))		/* "ull" */
+#define	EC_SXWORD(a)	((Elf64_Sxword)(a))		/* "ll"  */
+#define	EC_LWORD(a)	((Elf64_Lword)(a))		/* "ull" */
+
+/*
+ * A native pointer is special.  Although it can be convenient to display
+ * these from a common format (ull), compilers may flag the cast of a pointer
+ * to an integer as illegal.  Casting these pointers to the native pointer
+ * size, suppresses any compiler errors.
+ */
+#define	EC_NATPTR(a)	((Elf64_Xword)(uintptr_t)(a))	/* "ull" */
+#else
+#define	EC_ADDR(a)	((u_longlong_t)(a))
+#define	EC_OFF(a)	((u_longlong_t)(a))
+#define	EC_HALF(a)	((ushort_t)(a))
+#define	EC_WORD(a)	((uint_t)(a))
+#define	EC_SWORD(a)	((int)(a))
+#define	EC_XWORD(a)	((u_longlong_t)(a))
+#define	EC_SXWORD(a)	((longlong_t)(a))
+#define	EC_LWORD(a)	((u_longlong_t)(a))
+
+#define	EC_NATPTR(a)	((u_longlong_t)(a))
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_MACHELF_H */

lib/libspl/include/sys/mhd.h

@@ -0,0 +1,159 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_MHD_H
+#define	_SYS_MHD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Definitions for multi-host device I/O control commands
+ */
+#define	MHIOC				('M'<<8)
+#define	MHIOCENFAILFAST			(MHIOC|1)
+#define	MHIOCTKOWN			(MHIOC|2)
+#define	MHIOCRELEASE			(MHIOC|3)
+#define	MHIOCSTATUS			(MHIOC|4)
+#define	MHIOCGRP_INKEYS 		(MHIOC|5)
+#define	MHIOCGRP_INRESV 		(MHIOC|6)
+#define	MHIOCGRP_REGISTER		(MHIOC|7)
+#define	MHIOCGRP_RESERVE		(MHIOC|8)
+#define	MHIOCGRP_PREEMPTANDABORT	(MHIOC|9)
+#define	MHIOCGRP_PREEMPT		(MHIOC|10)
+#define	MHIOCGRP_CLEAR			(MHIOC|11)
+#define	MHIOCGRP_REGISTERANDIGNOREKEY	(MHIOC|14)
+#define	MHIOCQRESERVE			(MHIOC|12)
+#define	MHIOCREREGISTERDEVID		(MHIOC|13)
+
+/*
+ * Following is the structure to specify the delay parameters in
+ * milliseconds, via the MHIOCTKOWN ioctl.
+ */
+struct mhioctkown {
+	int reinstate_resv_delay;
+	int min_ownership_delay;
+	int max_ownership_delay;
+};
+
+#define	MHIOC_RESV_KEY_SIZE	8
+typedef struct mhioc_resv_key {
+	uchar_t	key[MHIOC_RESV_KEY_SIZE];
+} mhioc_resv_key_t;
+
+typedef struct mhioc_key_list {
+	uint32_t		listsize;
+	uint32_t		listlen;
+	mhioc_resv_key_t	*list;
+} mhioc_key_list_t;
+
+typedef struct mhioc_inkeys {
+	uint32_t		generation;
+	mhioc_key_list_t	*li;
+} mhioc_inkeys_t;
+
+#if defined(_SYSCALL32)
+struct mhioc_key_list32 {
+	uint32_t		listsize;
+	uint32_t		listlen;
+	caddr32_t		list;
+} mhioc_key_list32_t;
+
+struct mhioc_inkeys32 {
+	uint32_t		generation;
+	caddr32_t		li;
+} mhioc_inkeys32_t;
+#endif
+
+typedef struct mhioc_resv_desc {
+	mhioc_resv_key_t	key;
+	uint8_t			type;
+	uint8_t			scope;
+	uint32_t		scope_specific_addr;
+} mhioc_resv_desc_t;
+
+typedef struct mhioc_resv_desc_list {
+	uint32_t		listsize;
+	uint32_t		listlen;
+	mhioc_resv_desc_t	*list;
+} mhioc_resv_desc_list_t;
+
+typedef struct mhioc_inresvs {
+	uint32_t		generation;
+	mhioc_resv_desc_list_t	*li;
+} mhioc_inresvs_t;
+
+#if defined(_SYSCALL32)
+struct mhioc_resv_desc_list32 {
+	uint32_t		listsize;
+	uint32_t		listlen;
+	caddr32_t		list;
+} mhioc_resv_desc_list32_t;
+
+typedef struct mhioc_inresvs32 {
+	uint32_t		generation;
+	caddr32_t		li;
+} mhioc_inresvs32_t;
+#endif
+
+typedef struct mhioc_register {
+    mhioc_resv_key_t	oldkey;
+    mhioc_resv_key_t	newkey;
+    boolean_t		aptpl;  /* True if persistent across power failures */
+} mhioc_register_t;
+
+typedef struct mhioc_preemptandabort {
+    mhioc_resv_desc_t	resvdesc;
+    mhioc_resv_key_t	victim_key;
+} mhioc_preemptandabort_t;
+
+typedef struct mhioc_registerandignorekey {
+    mhioc_resv_key_t	newkey;
+    boolean_t		aptpl;  /* True if persistent across power failures */
+} mhioc_registerandignorekey_t;
+
+/*
+ * SCSI-3 PGR Reservation Type Codes.  Codes with the _OBSOLETE suffix
+ * have been removed from the SCSI3 PGR standard.
+ */
+#define	SCSI3_RESV_READSHARED_OBSOLETE			0
+#define	SCSI3_RESV_WRITEEXCLUSIVE			1
+#define	SCSI3_RESV_READEXCLUSIVE_OBSOLETE		2
+#define	SCSI3_RESV_EXCLUSIVEACCESS			3
+#define	SCSI3_RESV_SHAREDACCESS_OBSOLETE		4
+#define	SCSI3_RESV_WRITEEXCLUSIVEREGISTRANTSONLY	5
+#define	SCSI3_RESV_EXCLUSIVEACCESSREGISTRANTSONLY	6
+
+#define	SCSI3_SCOPE_LOGICALUNIT				0
+#define	SCSI3_SCOPE_EXTENT_OBSOLETE			1
+#define	SCSI3_SCOPE_ELEMENT				2
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _SYS_MHD_H */

lib/libspl/include/sys/mkdev.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_MKDEV_H
+#define _LIBSPL_SYS_MKDEV_H
+
+#endif

lib/libspl/include/sys/mntent.h

@@ -0,0 +1,142 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ *
+ *	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
+ *		All Rights Reserved
+ */
+
+#ifndef _SYS_MNTENT_H
+#define	_SYS_MNTENT_H
+
+
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define	MNTTAB		"/proc/mounts"
+#define	VFSTAB		"/etc/vfstab"
+#define	MNTMAXSTR	128
+
+#define	MNTTYPE_ZFS	"zfs"		/* ZFS file system */
+#define	MNTTYPE_UFS	"ufs"		/* Unix file system */
+#define	MNTTYPE_SMBFS	"smbfs"		/* SMBFS file system */
+#define	MNTTYPE_NFS	"nfs"		/* NFS file system */
+#define	MNTTYPE_NFS3	"nfs3"		/* NFS Version 3 file system */
+#define	MNTTYPE_NFS4	"nfs4"		/* NFS Version 4 file system */
+#define	MNTTYPE_CACHEFS	"cachefs"	/* Cache File System */
+#define	MNTTYPE_PCFS	"pcfs"		/* PC (MSDOS) file system */
+#define	MNTTYPE_PC	MNTTYPE_PCFS	/* Deprecated name; use MNTTYPE_PCFS */
+#define	MNTTYPE_LOFS	"lofs"		/* Loop back file system */
+#define	MNTTYPE_LO	MNTTYPE_LOFS	/* Deprecated name; use MNTTYPE_LOFS */
+#define	MNTTYPE_HSFS	"hsfs"		/* High Sierra (9660) file system */
+#define	MNTTYPE_SWAP	"swap"		/* Swap file system */
+#define	MNTTYPE_TMPFS	"tmpfs"		/* Tmp volatile file system */
+#define	MNTTYPE_AUTOFS	"autofs"	/* Automounter ``file'' system */
+#define	MNTTYPE_MNTFS	"mntfs"		/* In-kernel mnttab */
+#define	MNTTYPE_DEV	"dev"		/* /dev file system */
+#define	MNTTYPE_CTFS	"ctfs"		/* Contract file system */
+#define	MNTTYPE_OBJFS	"objfs"		/* Kernel object file system */
+#define	MNTTYPE_SHAREFS	"sharefs"	/* Kernel sharetab file system */
+
+
+#define	MNTOPT_RO	"ro"		/* Read only */
+#define	MNTOPT_RW	"rw"		/* Read/write */
+#define	MNTOPT_RQ	"rq"		/* Read/write with quotas */
+#define	MNTOPT_QUOTA	"quota"		/* Check quotas */
+#define	MNTOPT_NOQUOTA	"noquota"	/* Don't check quotas */
+#define	MNTOPT_ONERROR	"onerror"	/* action to taken on error */
+#define	MNTOPT_SOFT	"soft"		/* Soft mount */
+#define	MNTOPT_SEMISOFT	"semisoft"	/* partial soft, uncommited interface */
+#define	MNTOPT_HARD	"hard"		/* Hard mount */
+#define	MNTOPT_SUID	"suid"		/* Both setuid and devices allowed */
+#define	MNTOPT_NOSUID	"nosuid"	/* Neither setuid nor devices allowed */
+#define	MNTOPT_DEVICES	"devices"	/* Device-special allowed */
+#define	MNTOPT_NODEVICES	"nodevices"	/* Device-special disallowed */
+#define	MNTOPT_SETUID	"setuid"	/* Set uid allowed */
+#define	MNTOPT_NOSETUID	"nosetuid"	/* Set uid not allowed */
+#define	MNTOPT_GRPID	"grpid"		/* SysV-compatible gid on create */
+#define	MNTOPT_REMOUNT	"remount"	/* Change mount options */
+#define	MNTOPT_NOSUB	"nosub"		/* Disallow mounts on subdirs */
+#define	MNTOPT_MULTI	"multi"		/* Do multi-component lookup */
+#define	MNTOPT_INTR	"intr"		/* Allow NFS ops to be interrupted */
+#define	MNTOPT_NOINTR	"nointr"	/* Don't allow interrupted ops */
+#define	MNTOPT_PORT	"port"		/* NFS server IP port number */
+#define	MNTOPT_SECURE	"secure"	/* Secure (AUTH_DES) mounting */
+#define	MNTOPT_RSIZE	"rsize"		/* Max NFS read size (bytes) */
+#define	MNTOPT_WSIZE	"wsize"		/* Max NFS write size (bytes) */
+#define	MNTOPT_TIMEO	"timeo"		/* NFS timeout (1/10 sec) */
+#define	MNTOPT_RETRANS	"retrans"	/* Max retransmissions (soft mnts) */
+#define	MNTOPT_ACTIMEO	"actimeo"	/* Attr cache timeout (sec) */
+#define	MNTOPT_ACREGMIN	"acregmin"	/* Min attr cache timeout (files) */
+#define	MNTOPT_ACREGMAX	"acregmax"	/* Max attr cache timeout (files) */
+#define	MNTOPT_ACDIRMIN	"acdirmin"	/* Min attr cache timeout (dirs) */
+#define	MNTOPT_ACDIRMAX	"acdirmax"	/* Max attr cache timeout (dirs) */
+#define	MNTOPT_NOAC	"noac"		/* Don't cache attributes at all */
+#define	MNTOPT_NOCTO	"nocto"		/* No close-to-open consistency */
+#define	MNTOPT_BG	"bg"		/* Do mount retries in background */
+#define	MNTOPT_FG	"fg"		/* Do mount retries in foreground */
+#define	MNTOPT_RETRY	"retry"		/* Number of mount retries */
+#define	MNTOPT_DEV	"dev"		/* Device id of mounted fs */
+#define	MNTOPT_POSIX	"posix"		/* Get static pathconf for mount */
+#define	MNTOPT_MAP	"map"		/* Automount map */
+#define	MNTOPT_DIRECT	"direct"	/* Automount   direct map mount */
+#define	MNTOPT_INDIRECT	"indirect"	/* Automount indirect map mount */
+#define	MNTOPT_LLOCK	"llock"		/* Local locking (no lock manager) */
+#define	MNTOPT_IGNORE	"ignore"	/* Ignore this entry */
+#define	MNTOPT_VERS	"vers"		/* protocol version number indicator */
+#define	MNTOPT_PROTO	"proto"		/* protocol network_id indicator */
+#define	MNTOPT_SEC	"sec"		/* Security flavor indicator */
+#define	MNTOPT_SYNCDIR	"syncdir"	/* Synchronous local directory ops */
+#define	MNTOPT_NOSETSEC	"nosec"		/* Do no allow setting sec attrs */
+#define	MNTOPT_NOPRINT	"noprint"	/* Do not print messages */
+#define	MNTOPT_LARGEFILES "largefiles"	/* allow large files */
+#define	MNTOPT_NOLARGEFILES "nolargefiles" /* don't allow large files */
+#define	MNTOPT_FORCEDIRECTIO "forcedirectio" /* Force DirectIO on all files */
+#define	MNTOPT_NOFORCEDIRECTIO "noforcedirectio" /* No Force DirectIO */
+#define	MNTOPT_DISABLEDIRECTIO "disabledirectio" /* Disable DirectIO ioctls */
+#define	MNTOPT_PUBLIC	"public"	/* Use NFS public file handlee */
+#define	MNTOPT_LOGGING "logging" 	/* enable logging */
+#define	MNTOPT_NOLOGGING "nologging" 	/* disable logging */
+#define	MNTOPT_ATIME	"atime"		/* update atime for files */
+#define	MNTOPT_NOATIME  "noatime"	/* do not update atime for files */
+#define	MNTOPT_GLOBAL	"global"	/* Cluster-wide global mount */
+#define	MNTOPT_NOGLOBAL	"noglobal"	/* Mount local to single node */
+#define	MNTOPT_DFRATIME	"dfratime"	/* Deferred access time updates */
+#define	MNTOPT_NODFRATIME "nodfratime"	/* No Deferred access time updates */
+#define	MNTOPT_NBMAND	"nbmand"	/* allow non-blocking mandatory locks */
+#define	MNTOPT_NONBMAND	"nonbmand"	/* deny non-blocking mandatory locks */
+#define	MNTOPT_XATTR	"xattr"		/* enable extended attributes */
+#define	MNTOPT_NOXATTR	"noxattr"	/* disable extended attributes */
+#define	MNTOPT_EXEC	"exec"		/* enable executables */
+#define	MNTOPT_NOEXEC	"noexec"	/* disable executables */
+#define	MNTOPT_RESTRICT	"restrict"	/* restricted autofs mount */
+#define	MNTOPT_BROWSE	"browse"	/* browsable autofs mount */
+#define	MNTOPT_NOBROWSE	"nobrowse"	/* non-browsable autofs mount */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_MNTENT_H */

lib/libspl/include/sys/mnttab.h

@@ -0,0 +1,86 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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) 1984, 1986, 1987, 1988, 1989 AT&T*/
+/*  All Rights Reserved  */
+/*
+ * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/* Copyright 2006 Ricardo Correia */
+
+#ifndef _SYS_MNTTAB_H
+#define _SYS_MNTTAB_H
+
+#include <stdio.h>
+#include <mntent.h>
+#include <sys/types.h>
+
+#ifdef MNTTAB
+#undef MNTTAB
+#endif
+
+#define MNTTAB "/proc/mounts"
+#define MNT_LINE_MAX 1024
+
+#define MNT_TOOLONG 1    /* entry exceeds MNT_LINE_MAX */
+#define MNT_TOOMANY 2    /* too many fields in line */
+#define MNT_TOOFEW  3    /* too few fields in line */
+
+struct mnttab {
+	char *mnt_special;
+	char *mnt_mountp;
+	char *mnt_fstype;
+	char *mnt_mntopts;
+};
+
+/*
+ * NOTE: fields in extmnttab should match struct mnttab till new fields
+ * are encountered, this allows hasmntopt to work properly when its arg is
+ * a pointer to an extmnttab struct cast to a mnttab struct pointer.
+ */
+
+struct extmnttab {
+	char *mnt_special;
+	char *mnt_mountp;
+	char *mnt_fstype;
+	char *mnt_mntopts;
+	uint_t mnt_major;
+	uint_t mnt_minor;
+};
+
+extern int getmntany(FILE *fp, struct mnttab *mp, struct mnttab *mpref);
+extern int _sol_getmntent(FILE *fp, struct mnttab *mp);
+extern int getextmntent(FILE *fp, struct extmnttab *mp, int len);
+
+static inline char *_sol_hasmntopt(struct mnttab *mnt, char *opt)
+{
+	struct mntent mnt_new;
+
+	mnt_new.mnt_opts = mnt->mnt_mntopts;
+
+	return hasmntopt(&mnt_new, opt);
+}
+
+#define hasmntopt _sol_hasmntopt
+#define getmntent _sol_getmntent
+
+#endif

lib/libspl/include/sys/mount.h

@@ -0,0 +1,50 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <sys/mount.h>
+
+#ifndef _LIBSPL_SYS_MOUNT_H
+#define _LIBSPL_SYS_MOUNT_H
+
+#include <sys/mntent.h>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+/*
+ * Some old glibc headers don't define BLKGETSIZE64
+ * and we don't want to require the kernel headers
+ */
+#if !defined(BLKGETSIZE64)
+#define BLKGETSIZE64		_IOR(0x12, 114, size_t)
+#endif
+
+#define MS_FORCE		MNT_FORCE
+#define MS_OVERLAY		32768
+#define MS_NOMNTTAB		0         /* Not supported in Linux */
+#define MS_OPTIONSTR		0         /* Not necessary in Linux */
+
+#endif /* _LIBSPL_SYS_MOUNT_H */

lib/libspl/include/sys/note.h

@@ -0,0 +1,54 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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) 1994 by Sun Microsystems, Inc.
+ */
+
+/*
+ * sys/note.h:	interface for annotating source with info for tools
+ *
+ * This is the underlying interface; NOTE (/usr/include/note.h) is the
+ * preferred interface, but all exported header files should include this
+ * file directly and use _NOTE so as not to take "NOTE" from the user's
+ * namespace.  For consistency, *all* kernel source should use _NOTE.
+ *
+ * By default, annotations expand to nothing.  This file implements
+ * that.  Tools using annotations will interpose a different version
+ * of this file that will expand annotations as needed.
+ */
+
+#ifndef	_SYS_NOTE_H
+#define	_SYS_NOTE_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifndef _NOTE
+#define	_NOTE(s)
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_NOTE_H */

lib/libspl/include/sys/param.h

@@ -0,0 +1,67 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_PARAM_H
+#define _LIBSPL_SYS_PARAM_H
+
+#include_next <sys/param.h>
+#include <unistd.h>
+
+/*
+ * File system parameters and macros.
+ *
+ * The file system is made out of blocks of at most MAXBSIZE units,
+ * with smaller units (fragments) only in the last direct block.
+ * MAXBSIZE primarily determines the size of buffers in the buffer
+ * pool. It may be made larger without any effect on existing
+ * file systems; however making it smaller make make some file
+ * systems unmountable.
+ *
+ * Note that the blocked devices are assumed to have DEV_BSIZE
+ * "sectors" and that fragments must be some multiple of this size.
+ */
+#define MAXBSIZE   8192
+#define DEV_BSIZE  512
+#define DEV_BSHIFT 9     /* log2(DEV_BSIZE) */
+
+#define MAXNAMELEN 256
+
+#ifdef _LP64
+#define MAXOFFSET_T 0x7fffffffffffffffl
+#else
+#define MAXOFFSET_T 0x7fffffffl
+#endif
+
+#define UID_NOBODY      60001   /* user ID no body */
+#define GID_NOBODY      UID_NOBODY
+#define UID_NOACCESS    60002   /* user ID no access */
+
+#define MAXUID          2147483647      /* max user id */
+#define MAXPROJID       MAXUID          /* max project id */
+
+#define PAGESIZE (sysconf(_SC_PAGESIZE))
+
+#endif

lib/libspl/include/sys/priv.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_PRIV_H
+#define _LIBSPL_SYS_PRIV_H
+
+#endif

lib/libspl/include/sys/processor.h

@@ -0,0 +1,34 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_PROCESSOR_H
+#define _LIBSPL_SYS_PROCESSOR_H
+
+#define getcpuid() (-1)
+
+typedef int	processorid_t;
+
+#endif

lib/libspl/include/sys/sdt.h

@@ -0,0 +1,36 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_SDT_H
+#define _LIBSPL_SYS_SDT_H
+
+#define DTRACE_PROBE(a)                  ((void) 0)
+#define DTRACE_PROBE1(a,b,c)             ((void) 0)
+#define DTRACE_PROBE2(a,b,c,d,e)         ((void) 0)
+#define DTRACE_PROBE3(a,b,c,d,e,f,g)     ((void) 0)
+#define DTRACE_PROBE4(a,b,c,d,e,f,g,h,i) ((void) 0)
+
+#endif

lib/libspl/include/sys/stack.h

@@ -0,0 +1,72 @@
+/*
+ * 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
+ */
+/*
+ * This header file distributed under the terms of the CDDL.
+ * Portions Copyright 2008 Sun Microsystems, Inc. All Rights reserved.
+ */
+#ifndef _SYS_STACK_H
+#define _SYS_STACK_H
+
+#include <pthread.h>
+
+#define STACK_BIAS	0
+
+#ifdef __USE_GNU
+
+static inline int
+stack_getbounds(stack_t *sp)
+{
+	pthread_attr_t attr;
+	int rc;
+
+	rc = pthread_getattr_np(pthread_self(), &attr);
+	if (rc)
+		return rc;
+
+	rc = pthread_attr_getstack(&attr, &sp->ss_sp, &sp->ss_size);
+	if (rc == 0)
+		sp->ss_flags = 0;
+
+	pthread_attr_destroy(&attr);
+
+	return rc;
+}
+
+static inline int
+thr_stksegment(stack_t *sp)
+{
+	int rc;
+
+	rc = stack_getbounds(sp);
+	if (rc)
+		return rc;
+
+         /* thr_stksegment() is expected to set sp.ss_sp to the high stack
+	  * address, but the stack_getbounds() interface is expected to
+	  * set sp.ss_sp to the low address.  Adjust accordingly. */
+	sp->ss_sp = (void *)(((uintptr_t)sp->ss_sp) + sp->ss_size);
+	sp->ss_flags = 0;
+
+	return rc;
+}
+
+#endif /* __USE_GNU */
+#endif /* _SYS_STACK_H */

lib/libspl/include/sys/stropts.h

@@ -0,0 +1,29 @@
+/*
+ * 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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_STROPTS_H
+#define _LIBSPL_SYS_STROPTS_H
+
+#endif /* _LIBSPL_SYS_STROPTS_H */

lib/libspl/include/sys/sunddi.h

@@ -0,0 +1,29 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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) 2008 by Sun Microsystems, Inc.
+ */
+
+#ifndef	_SYS_SUNDDI_H
+#define	_SYS_SUNDDI_H
+
+#endif	/* _SYS_SUNDDI_H */

lib/libspl/include/sys/sysevent.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_SYSEVENT_H
+#define _LIBSPL_SYS_SYSEVENT_H
+
+#endif

lib/libspl/include/sys/sysevent/eventdefs.h

@@ -0,0 +1,235 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_SYS_SYSEVENT_EVENTDEFS_H
+#define	_SYS_SYSEVENT_EVENTDEFS_H
+
+
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * eventdefs.h contains public definitions for sysevent types (classes
+ * and subclasses).  All additions/removal/changes are subject
+ * to PSARC approval.
+ */
+
+/* Sysevent Class definitions */
+#define	EC_NONE		"EC_none"
+#define	EC_PRIV		"EC_priv"
+#define	EC_PLATFORM	"EC_platform"	/* events private to platform */
+#define	EC_DR		"EC_dr"	/* Dynamic reconfiguration event class */
+#define	EC_ENV		"EC_env"	/* Environmental monitor event class */
+#define	EC_DOMAIN	"EC_domain"	/* Domain event class */
+#define	EC_AP_DRIVER	"EC_ap_driver"	/* Alternate Pathing event class */
+#define	EC_IPMP		"EC_ipmp"	/* IP Multipathing event class */
+#define	EC_DEV_ADD	"EC_dev_add"	/* device add event class */
+#define	EC_DEV_REMOVE	"EC_dev_remove"	/* device remove event class */
+#define	EC_DEV_BRANCH	"EC_dev_branch"	/* device tree branch event class */
+#define	EC_FM		"EC_fm"		/* FMA error report event */
+#define	EC_ZFS		"EC_zfs"	/* ZFS event */
+
+/*
+ * The following event class is reserved for exclusive use
+ * by Sun Cluster software.
+ */
+#define	EC_CLUSTER	"EC_Cluster"
+
+/*
+ * The following classes are exclusively reserved for use by the
+ * Solaris Volume Manager (SVM)
+ */
+#define	EC_SVM_CONFIG	"EC_SVM_Config"
+#define	EC_SVM_STATE	"EC_SVM_State"
+
+/*
+ * EC_SVM_CONFIG subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/svm.h
+ */
+#define	ESC_SVM_CREATE		"ESC_SVM_Create"
+#define	ESC_SVM_DELETE		"ESC_SVM_Delete"
+#define	ESC_SVM_ADD		"ESC_SVM_Add"
+#define	ESC_SVM_REMOVE		"ESC_SVM_Remove"
+#define	ESC_SVM_REPLACE		"ESC_SVM_Replace"
+#define	ESC_SVM_GROW		"ESC_SVM_Grow"
+#define	ESC_SVM_RENAME_SRC	"ESC_SVM_Rename_Src"
+#define	ESC_SVM_RENAME_DST	"ESC_SVM_Rename_Dst"
+#define	ESC_SVM_MEDIATOR_ADD	"ESC_SVM_Mediator_Add"
+#define	ESC_SVM_MEDIATOR_DELETE	"ESC_SVM_Mediator_Delete"
+#define	ESC_SVM_HOST_ADD	"ESC_SVM_Host_Add"
+#define	ESC_SVM_HOST_DELETE	"ESC_SVM_Host_Delete"
+#define	ESC_SVM_DRIVE_ADD	"ESC_SVM_Drive_Add"
+#define	ESC_SVM_DRIVE_DELETE	"ESC_SVM_Drive_Delete"
+#define	ESC_SVM_DETACH		"ESC_SVM_Detach"
+#define	ESC_SVM_DETACHING	"ESC_SVM_Detaching"
+#define	ESC_SVM_ATTACH		"ESC_SVM_Attach"
+#define	ESC_SVM_ATTACHING	"ESC_SVM_Attaching"
+
+/*
+ * EC_SVM_STATE subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/svm.h
+ */
+#define	ESC_SVM_INIT_START	"ESC_SVM_Init_Start"
+#define	ESC_SVM_INIT_FAILED	"ESC_SVM_Init_Failed"
+#define	ESC_SVM_INIT_FATAL	"ESC_SVM_Init_Fatal"
+#define	ESC_SVM_INIT_SUCCESS	"ESC_SVM_Init_Success"
+#define	ESC_SVM_IOERR		"ESC_SVM_Ioerr"
+#define	ESC_SVM_ERRED		"ESC_SVM_Erred"
+#define	ESC_SVM_LASTERRED	"ESC_SVM_Lasterred"
+#define	ESC_SVM_OK		"ESC_SVM_Ok"
+#define	ESC_SVM_ENABLE		"ESC_SVM_Enable"
+#define	ESC_SVM_RESYNC_START	"ESC_SVM_Resync_Start"
+#define	ESC_SVM_RESYNC_FAILED	"ESC_SVM_Resync_Failed"
+#define	ESC_SVM_RESYNC_SUCCESS	"ESC_SVM_Resync_Success"
+#define	ESC_SVM_RESYNC_DONE	"ESC_SVM_Resync_Done"
+#define	ESC_SVM_HOTSPARED	"ESC_SVM_Hotspared"
+#define	ESC_SVM_HS_FREED	"ESC_SVM_HS_Freed"
+#define	ESC_SVM_HS_CHANGED	"ESC_SVM_HS_Changed"
+#define	ESC_SVM_TAKEOVER	"ESC_SVM_Takeover"
+#define	ESC_SVM_RELEASE		"ESC_SVM_Release"
+#define	ESC_SVM_OPEN_FAIL	"ESC_SVM_Open_Fail"
+#define	ESC_SVM_OFFLINE		"ESC_SVM_Offline"
+#define	ESC_SVM_ONLINE		"ESC_SVM_Online"
+#define	ESC_SVM_CHANGE		"ESC_SVM_Change"
+#define	ESC_SVM_EXCHANGE	"ESC_SVM_Exchange"
+#define	ESC_SVM_REGEN_START	"ESC_SVM_Regen_Start"
+#define	ESC_SVM_REGEN_DONE	"ESC_SVM_Regen_Done"
+#define	ESC_SVM_REGEN_FAILED	"ESC_SVM_Regen_Failed"
+
+/*
+ * EC_DR subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/dr.h
+ */
+
+/* Attachment point state change */
+#define	ESC_DR_AP_STATE_CHANGE	"ESC_dr_ap_state_change"
+#define	ESC_DR_REQ		"ESC_dr_req"	/* Request DR */
+#define	ESC_DR_TARGET_STATE_CHANGE	"ESC_dr_target_state_change"
+
+/*
+ * EC_ENV subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/env.h
+ */
+#define	ESC_ENV_TEMP	"ESC_env_temp"	/* Temperature change event subclass */
+#define	ESC_ENV_FAN	"ESC_env_fan"	/* Fan status change event subclass */
+#define	ESC_ENV_POWER	"ESC_env_power"	/* Power supply change event subclass */
+#define	ESC_ENV_LED	"ESC_env_led"	/* LED change event subclass */
+
+/*
+ * EC_DOMAIN subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/domain.h
+ */
+
+/* Domain state change */
+#define	ESC_DOMAIN_STATE_CHANGE		"ESC_domain_state_change"
+/* Domain loghost name change */
+#define	ESC_DOMAIN_LOGHOST_CHANGE	"ESC_domain_loghost_change"
+
+/*
+ * EC_AP_DRIVER subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/ap_driver.h
+ */
+
+/* Alternate Pathing path switch */
+#define	ESC_AP_DRIVER_PATHSWITCH	"ESC_ap_driver_pathswitch"
+/* Alternate Pathing database commit */
+#define	ESC_AP_DRIVER_COMMIT		"ESC_ap_driver_commit"
+/* Alternate Pathing physical path status change */
+#define	ESC_AP_DRIVER_PHYS_PATH_STATUS_CHANGE	\
+	"ESC_ap_driver_phys_path_status_change"
+
+/*
+ * EC_IPMP subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/ipmp.h
+ */
+
+/* IPMP group has changed state */
+#define	ESC_IPMP_GROUP_STATE		"ESC_ipmp_group_state"
+
+/* IPMP group has been created or removed */
+#define	ESC_IPMP_GROUP_CHANGE		"ESC_ipmp_group_change"
+
+/* IPMP group has had an interface added or removed */
+#define	ESC_IPMP_GROUP_MEMBER_CHANGE	"ESC_ipmp_group_member_change"
+
+/* Interface within an IPMP group has changed state or type */
+#define	ESC_IPMP_IF_CHANGE		"ESC_ipmp_if_change"
+
+
+/*
+ * EC_DEV_ADD and EC_DEV_REMOVE subclass definitions - supporting attributes
+ * (name/value pairs) are found in sys/sysevent/dev.h
+ */
+#define	ESC_DISK	"disk"		/* disk device */
+#define	ESC_NETWORK	"network"	/* network interface */
+#define	ESC_PRINTER	"printer"	/* printer device */
+#define	ESC_LOFI	"lofi"		/* lofi device */
+
+/*
+ * EC_DEV_BRANCH subclass definitions - supporting attributes (name/value pairs)
+ * are found in sys/sysevent/dev.h
+ */
+
+/* device tree branch added */
+#define	ESC_DEV_BRANCH_ADD	"ESC_dev_branch_add"
+
+/* device tree branch removed */
+#define	ESC_DEV_BRANCH_REMOVE	"ESC_dev_branch_remove"
+
+/* FMA Fault and Error event protocol subclass */
+#define	ESC_FM_ERROR		"ESC_FM_error"
+#define	ESC_FM_ERROR_REPLAY	"ESC_FM_error_replay"
+
+/* Service processor subclass definitions */
+#define	ESC_PLATFORM_SP_RESET	"ESC_platform_sp_reset"
+
+/*
+ * EC_ACPIEV subclass definitions
+ */
+#define	EC_ACPIEV			"EC_acpiev"
+#define	ESC_ACPIEV_ADD			"ESC_acpiev_add"
+#define	ESC_ACPIEV_REMOVE		"ESC_acpiev_remove"
+#define	ESC_ACPIEV_WARN			"ESC_acpiev_warn"
+#define	ESC_ACPIEV_LOW			"ESC_acpiev_low"
+#define	ESC_ACPIEV_STATE_CHANGE		"ESC_acpiev_state_change"
+
+/*
+ * ZFS subclass definitions.  supporting attributes (name/value paris) are found
+ * in sys/fs/zfs.h
+ */
+#define	ESC_ZFS_RESILVER_START	"ESC_ZFS_resilver_start"
+#define	ESC_ZFS_RESILVER_FINISH	"ESC_ZFS_resilver_finish"
+#define	ESC_ZFS_VDEV_REMOVE	"ESC_ZFS_vdev_remove"
+#define	ESC_ZFS_POOL_DESTROY	"ESC_ZFS_pool_destroy"
+#define	ESC_ZFS_VDEV_CLEAR	"ESC_ZFS_vdev_clear"
+#define	ESC_ZFS_VDEV_CHECK	"ESC_ZFS_vdev_check"
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_SYSEVENT_EVENTDEFS_H */

lib/libspl/include/sys/sysmacros.h

@@ -0,0 +1,98 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_SYSMACROS_H
+#define _LIBSPL_SYS_SYSMACROS_H
+
+#include_next <sys/sysmacros.h>
+
+/* common macros */
+#ifndef MIN
+#define MIN(a, b)       ((a) < (b) ? (a) : (b))
+#endif
+#ifndef MAX
+#define MAX(a, b)       ((a) < (b) ? (b) : (a))
+#endif
+#ifndef ABS
+#define ABS(a)          ((a) < 0 ? -(a) : (a))
+#endif
+
+#define makedevice(maj,min)	makedev(maj,min)
+#define _sysconf(a)		sysconf(a)
+#define __NORETURN		__attribute__ ((noreturn))
+
+/*
+ * Compatibility macros/typedefs needed for Solaris -> Linux port
+ */
+#define P2ALIGN(x, align)	((x) & -(align))
+#define P2CROSS(x, y, align)	(((x) ^ (y)) > (align) - 1)
+#define P2ROUNDUP(x, align)	(-(-(x) & -(align)))
+#define P2ROUNDUP_TYPED(x, align, type) \
+				(-(-(type)(x) & -(type)(align)))
+#define P2BOUNDARY(off, len, align) \
+				(((off) ^ ((off) + (len) - 1)) > (align) - 1)
+#define P2PHASE(x, align)	((x) & ((align) - 1))
+#define P2NPHASE(x, align)	(-(x) & ((align) - 1))
+#define P2NPHASE_TYPED(x, align, type) \
+				(-(type)(x) & ((type)(align) - 1))
+#define ISP2(x)			(((x) & ((x) - 1)) == 0)
+#define IS_P2ALIGNED(v, a)	((((uintptr_t)(v)) & ((uintptr_t)(a) - 1)) == 0)
+
+/*
+ * Typed version of the P2* macros.  These macros should be used to ensure
+ * that the result is correctly calculated based on the data type of (x),
+ * which is passed in as the last argument, regardless of the data
+ * type of the alignment.  For example, if (x) is of type uint64_t,
+ * and we want to round it up to a page boundary using "PAGESIZE" as
+ * the alignment, we can do either
+ *      P2ROUNDUP(x, (uint64_t)PAGESIZE)
+ * or
+ *      P2ROUNDUP_TYPED(x, PAGESIZE, uint64_t)
+ */
+#define P2ALIGN_TYPED(x, align, type)   \
+        ((type)(x) & -(type)(align))
+#define P2PHASE_TYPED(x, align, type)   \
+        ((type)(x) & ((type)(align) - 1))
+#define P2NPHASE_TYPED(x, align, type)  \
+        (-(type)(x) & ((type)(align) - 1))
+#define P2ROUNDUP_TYPED(x, align, type) \
+        (-(-(type)(x) & -(type)(align)))
+#define P2END_TYPED(x, align, type)     \
+        (-(~(type)(x) & -(type)(align)))
+#define P2PHASEUP_TYPED(x, align, phase, type)  \
+        ((type)(phase) - (((type)(phase) - (type)(x)) & -(type)(align)))
+#define P2CROSS_TYPED(x, y, align, type)        \
+        (((type)(x) ^ (type)(y)) > (type)(align) - 1)
+#define P2SAMEHIGHBIT_TYPED(x, y, type) \
+        (((type)(x) ^ (type)(y)) < ((type)(x) & (type)(y)))
+
+
+/* avoid any possibility of clashing with <stddef.h> version */
+#if defined(_KERNEL) && !defined(_KMEMUSER) && !defined(offsetof)
+#define	offsetof(s, m)	((size_t)(&(((s *)0)->m)))
+#endif
+
+#endif /* _LIBSPL_SYS_SYSMACROS_H */

lib/libspl/include/sys/systeminfo.h

@@ -0,0 +1,37 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_SYSTEMINFO_H
+#define _LIBSPL_SYS_SYSTEMINFO_H
+
+#define HW_INVALID_HOSTID	0xFFFFFFFF	/* an invalid hostid */
+#define HW_HOSTID_LEN		11		/* minimum buffer size needed */
+						/* to hold a decimal or hex */
+						/* hostid string */
+
+#define sysinfo(cmd,buf,cnt)		(-1)
+
+#endif

lib/libspl/include/sys/systm.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_SYSTM_H
+#define _LIBSPL_SYS_SYSTM_H
+
+#endif /* _LIBSPL_SYS_SYSTM_H */

lib/libspl/include/sys/time.h

@@ -0,0 +1,56 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_TIME_H
+#define _LIBSPL_SYS_TIME_H
+
+#include_next <sys/time.h>
+#include <sys/types.h>
+
+#ifndef SEC
+#define SEC		1
+#endif
+
+#ifndef MILLISEC
+#define MILLISEC	1000
+#endif
+
+#ifndef MICROSEC
+#define MICROSEC	1000000
+#endif
+
+#ifndef NANOSEC
+#define NANOSEC		1000000000
+#endif
+
+#ifndef NSEC_PER_USEC
+#define NSEC_PER_USEC	1000L
+#endif
+
+extern hrtime_t gethrtime(void);
+extern void gethrestime(timestruc_t *);
+
+#endif /* _LIBSPL_SYS_TIME_H */

lib/libspl/include/sys/types.h

@@ -0,0 +1,99 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_TYPES_H
+#define _LIBSPL_SYS_TYPES_H
+
+#include <sys/isa_defs.h>
+#include <sys/feature_tests.h>
+#include_next <sys/types.h>
+#include <sys/param.h> /* for NBBY */
+#include <sys/types32.h>
+#include <sys/va_list.h>
+
+#ifndef HAVE_INTTYPES
+#include <inttypes.h>
+
+typedef enum boolean { B_FALSE, B_TRUE } boolean_t;
+
+typedef unsigned char	uchar_t;
+typedef unsigned short	ushort_t;
+typedef unsigned int	uint_t;
+typedef unsigned long	ulong_t;
+
+typedef long long	longlong_t;
+typedef unsigned long long u_longlong_t;
+#endif /* HAVE_INTTYPES */
+
+typedef longlong_t	offset_t;
+typedef u_longlong_t	u_offset_t;
+typedef u_longlong_t	len_t;
+typedef longlong_t	diskaddr_t;
+
+typedef ulong_t		pfn_t;          /* page frame number */
+typedef ulong_t		pgcnt_t;        /* number of pages */
+typedef long		spgcnt_t;       /* signed number of pages */
+
+typedef longlong_t	hrtime_t;
+typedef struct timespec	timestruc_t;
+typedef struct timespec timespec_t;
+
+typedef short		pri_t;
+
+typedef int		zoneid_t;
+typedef int		projid_t;
+
+typedef int		major_t;
+typedef int		minor_t;
+
+typedef ushort_t o_mode_t; /* old file attribute type */
+
+/*
+ * Definitions remaining from previous partial support for 64-bit file
+ * offsets.  This partial support for devices greater than 2gb requires
+ * compiler support for long long.
+ */
+#ifdef _LONG_LONG_LTOH
+typedef union {
+	offset_t _f;    /* Full 64 bit offset value */
+	struct {
+		int32_t _l; /* lower 32 bits of offset value */
+		int32_t _u; /* upper 32 bits of offset value */
+	} _p;
+} lloff_t;
+#endif
+
+#ifdef _LONG_LONG_HTOL
+typedef union {
+	offset_t _f;    /* Full 64 bit offset value */
+	struct {
+		int32_t _u; /* upper 32 bits of offset value */
+		int32_t _l; /* lower 32 bits of offset value */
+	} _p;
+} lloff_t;
+#endif
+
+#endif

lib/libspl/include/sys/types32.h

@@ -0,0 +1,91 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_TYPES32_H
+#define	_SYS_TYPES32_H
+
+
+
+#include <sys/inttypes.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Interoperability types for programs. Used for:
+ *
+ * Crossing between 32-bit and 64-bit domains.
+ *
+ * On disk data formats such as filesystem meta data
+ * and disk label.
+ *
+ * Note: Applications should never include this
+ *       header file.
+ */
+typedef	uint32_t	caddr32_t;
+typedef	int32_t		daddr32_t;
+typedef	int32_t		off32_t;
+typedef	uint32_t	ino32_t;
+typedef	int32_t		blkcnt32_t;
+typedef uint32_t	fsblkcnt32_t;
+typedef	uint32_t	fsfilcnt32_t;
+typedef	int32_t		id32_t;
+typedef	uint32_t	major32_t;
+typedef	uint32_t	minor32_t;
+typedef	int32_t		key32_t;
+typedef	uint32_t	mode32_t;
+typedef	uint32_t	uid32_t;
+typedef	uint32_t	gid32_t;
+typedef	uint32_t	nlink32_t;
+typedef	uint32_t	dev32_t;
+typedef	int32_t		pid32_t;
+typedef	uint32_t	size32_t;
+typedef	int32_t		ssize32_t;
+typedef	int32_t		time32_t;
+typedef	int32_t		clock32_t;
+
+struct timeval32 {
+	time32_t	tv_sec;		/* seconds */
+	int32_t		tv_usec;	/* and microseconds */
+};
+
+typedef struct timespec32 {
+	time32_t	tv_sec;		/* seconds */
+	int32_t		tv_nsec;	/* and nanoseconds */
+} timespec32_t;
+
+typedef struct timespec32 timestruc32_t;
+
+typedef	struct itimerspec32 {
+	struct timespec32 it_interval;
+	struct timespec32 it_value;
+} itimerspec32_t;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_TYPES32_H */

lib/libspl/include/sys/tzfile.h

@@ -0,0 +1,164 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ *	from Arthur Olson's 6.1
+ */
+
+#ifndef _LIBSPL_SYS_TZFILE_H
+#define	_LIBSPL_SYS_TZFILE_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Information about time zone files.
+ */
+
+#define	TZDIR	"/usr/share/lib/zoneinfo" /* Time zone object file directory */
+
+#define	TZDEFAULT	(getenv("TZ"))
+
+#define	TZDEFRULES	"posixrules"
+
+/*
+ * Each file begins with. . .
+ */
+
+struct tzhead {
+	char	tzh_reserved[24];	/* reserved for future use */
+	char	tzh_ttisstdcnt[4];	/* coded number of trans. time flags */
+	char	tzh_leapcnt[4];		/* coded number of leap seconds */
+	char	tzh_timecnt[4];		/* coded number of transition times */
+	char	tzh_typecnt[4];		/* coded number of local time types */
+	char	tzh_charcnt[4];		/* coded number of abbr. chars */
+};
+
+/*
+ * . . .followed by. . .
+ *
+ *	tzh_timecnt (char [4])s		coded transition times a la time(2)
+ *	tzh_timecnt (unsigned char)s	types of local time starting at above
+ *	tzh_typecnt repetitions of
+ *		one (char [4])		coded GMT offset in seconds
+ *		one (unsigned char)	used to set tm_isdst
+ *		one (unsigned char)	that's an abbreviation list index
+ *	tzh_charcnt (char)s		'\0'-terminated zone abbreviations
+ *	tzh_leapcnt repetitions of
+ *		one (char [4])		coded leap second transition times
+ *		one (char [4])		total correction after above
+ *	tzh_ttisstdcnt (char)s		indexed by type; if TRUE, transition
+ *					time is standard time, if FALSE,
+ *					transition time is wall clock time
+ *					if absent, transition times are
+ *					assumed to be wall clock time
+ */
+
+/*
+ * In the current implementation, "tzset()" refuses to deal with files that
+ * exceed any of the limits below.
+ */
+
+/*
+ * The TZ_MAX_TIMES value below is enough to handle a bit more than a
+ * year's worth of solar time (corrected daily to the nearest second) or
+ * 138 years of Pacific Presidential Election time
+ * (where there are three time zone transitions every fourth year).
+ */
+#define	TZ_MAX_TIMES	370
+
+#define	TZ_MAX_TYPES	256	/* Limited by what (unsigned char)'s can hold */
+
+#define	TZ_MAX_CHARS	50	/* Maximum number of abbreviation characters */
+
+#define	TZ_MAX_LEAPS	50	/* Maximum number of leap second corrections */
+
+#define	SECSPERMIN	60
+#define	MINSPERHOUR	60
+#define	HOURSPERDAY	24
+#define	DAYSPERWEEK	7
+#define	DAYSPERNYEAR	365
+#define	DAYSPERLYEAR	366
+#define	SECSPERHOUR	(SECSPERMIN * MINSPERHOUR)
+#define	SECSPERDAY	((long)SECSPERHOUR * HOURSPERDAY)
+#define	MONSPERYEAR	12
+
+#define	TM_SUNDAY	0
+#define	TM_MONDAY	1
+#define	TM_TUESDAY	2
+#define	TM_WEDNESDAY	3
+#define	TM_THURSDAY	4
+#define	TM_FRIDAY	5
+#define	TM_SATURDAY	6
+
+#define	TM_JANUARY	0
+#define	TM_FEBRUARY	1
+#define	TM_MARCH	2
+#define	TM_APRIL	3
+#define	TM_MAY		4
+#define	TM_JUNE		5
+#define	TM_JULY		6
+#define	TM_AUGUST	7
+#define	TM_SEPTEMBER	8
+#define	TM_OCTOBER	9
+#define	TM_NOVEMBER	10
+#define	TM_DECEMBER	11
+
+#define	TM_YEAR_BASE	1900
+
+#define	EPOCH_YEAR	1970
+#define	EPOCH_WDAY	TM_THURSDAY
+
+/*
+ * Accurate only for the past couple of centuries;
+ * that will probably do.
+ */
+
+#define	isleap(y) (((y) % 4) == 0 && ((y) % 100) != 0 || ((y) % 400) == 0)
+
+/*
+ * Use of the underscored variants may cause problems if you move your code to
+ * certain System-V-based systems; for maximum portability, use the
+ * underscore-free variants.  The underscored variants are provided for
+ * backward compatibility only; they may disappear from future versions of
+ * this file.
+ */
+
+#define	SECS_PER_MIN	SECSPERMIN
+#define	MINS_PER_HOUR	MINSPERHOUR
+#define	HOURS_PER_DAY	HOURSPERDAY
+#define	DAYS_PER_WEEK	DAYSPERWEEK
+#define	DAYS_PER_NYEAR	DAYSPERNYEAR
+#define	DAYS_PER_LYEAR	DAYSPERLYEAR
+#define	SECS_PER_HOUR	SECSPERHOUR
+#define	SECS_PER_DAY	SECSPERDAY
+#define	MONS_PER_YEAR	MONSPERYEAR
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _LIBSPL_SYS_TZFILE_H */

lib/libspl/include/sys/uio.h

@@ -0,0 +1,108 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2005 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+/*
+ * University Copyright- Copyright (c) 1982, 1986, 1988
+ * The Regents of the University of California
+ * All Rights Reserved
+ *
+ * University Acknowledgment- Portions of this document are derived from
+ * software developed by the University of California, Berkeley, and its
+ * contributors.
+ */
+
+#ifndef	_LIBSPL_SYS_UIO_H
+#define	_LIBSPL_SYS_UIO_H
+
+#include_next <sys/uio.h>
+
+typedef struct iovec iovec_t;
+
+typedef enum uio_rw {
+	UIO_READ =      0,
+	UIO_WRITE =     1,
+} uio_rw_t;
+
+typedef enum uio_seg {
+	UIO_USERSPACE = 0,
+	UIO_SYSSPACE =  1,
+	UIO_USERISPACE= 2,
+} uio_seg_t;
+
+typedef struct uio {
+	struct iovec	*uio_iov;	/* pointer to array of iovecs */
+	int		uio_iovcnt;	/* number of iovecs */
+	offset_t	uio_loffset;	/* file offset */
+	uio_seg_t	uio_segflg;	/* address space (kernel or user) */
+	uint16_t	uio_fmode;	/* file mode flags */
+	uint16_t	uio_extflg;	/* extended flags */
+	offset_t	uio_limit;	/* u-limit (maximum byte offset) */
+	ssize_t		uio_resid;	/* residual count */
+} uio_t;
+
+typedef enum xuio_type {
+	UIOTYPE_ASYNCIO,
+	UIOTYPE_ZEROCOPY,
+} xuio_type_t;
+
+#define	UIOA_IOV_MAX	16
+
+typedef struct uioa_page_s {		/* locked uio_iov state */
+	int	uioa_pfncnt;		/* count of pfn_t(s) in *uioa_ppp */
+	void	**uioa_ppp;		/* page_t or pfn_t arrary */
+	caddr_t	uioa_base;		/* address base */
+	size_t	uioa_len;		/* span length */
+} uioa_page_t;
+
+typedef struct xuio {
+	uio_t xu_uio;				/* embedded UIO structure */
+
+	/* Extended uio fields */
+	enum xuio_type xu_type;			/* uio type */
+	union {
+		struct {
+			uint32_t xu_a_state;	/* state of async i/o */
+			ssize_t xu_a_mbytes;	/* bytes moved */
+			uioa_page_t *xu_a_lcur;	/* uioa_locked[] pointer */
+			void **xu_a_lppp;	/* lcur->uioa_pppp[] pointer */
+			void *xu_a_hwst[4];	/* opaque hardware state */
+			uioa_page_t xu_a_locked[UIOA_IOV_MAX];
+		} xu_aio;
+
+		struct {
+			int xu_zc_rw;		/* read or write buffer */
+			void *xu_zc_priv;	/* fs specific */
+		} xu_zc;
+	} xu_ext;
+} xuio_t;
+
+#define XUIO_XUZC_PRIV(xuio)	xuio->xu_ext.xu_zc.xu_zc_priv
+#define XUIO_XUZC_RW(xuio)	xuio->xu_ext.xu_zc.xu_zc_rw
+
+#endif	/* _SYS_UIO_H */

lib/libspl/include/sys/utsname.h

@@ -0,0 +1,34 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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/OPENLIBSPLARIS.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/OPENLIBSPLARIS.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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_UTSNAME_H
+#define _LIBSPL_UTSNAME_H
+
+#include_next <sys/utsname.h>
+
+struct utsname utsname;
+
+#endif  /* _LIBSPL_UTSNAME_H */

lib/libspl/include/sys/va_list.h

@@ -0,0 +1,36 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_VA_LIST_H
+#define _SYS_VA_LIST_H
+
+#include <stdarg.h>
+
+#ifndef __va_list
+typedef __gnuc_va_list __va_list;
+#endif
+
+#endif

lib/libspl/include/sys/varargs.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_VARARGS_H
+#define _LIBSPL_SYS_VARARGS_H
+
+#endif

lib/libspl/include/sys/vnode.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_VNODE_H
+#define _LIBSPL_SYS_VNODE_H
+
+#endif /* _LIBSPL_SYS_VNODE_H */

lib/libspl/include/sys/vtoc.h

@@ -0,0 +1,350 @@
+/*
+ * 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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+
+/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+
+#ifndef _SYS_VTOC_H
+#define	_SYS_VTOC_H
+
+#include <sys/dklabel.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ *	Note:  the VTOC is not implemented fully, nor in the manner
+ *	that AT&T implements it.  AT&T puts the vtoc structure
+ *	into a sector, usually the second sector (pdsector is first).
+ *
+ *	Sun incorporates the tag, flag, version, and volume vtoc fields into
+ *	its Disk Label, which already has some vtoc-equivalent fields.
+ *	Upon reading the vtoc with read_vtoc(), the following exceptions
+ *	occur:
+ *		v_bootinfo [all]	returned as zero
+ *		v_sanity		returned as VTOC_SANE
+ *						if Disk Label was sane
+ *		v_sectorsz		returned as 512
+ *		v_reserved [all]	retunred as zero
+ *		timestamp [all]		returned as zero
+ *
+ *	See  dklabel.h, read_vtoc(), and write_vtoc().
+ */
+
+#define	V_NUMPAR 	NDKMAP		/* The number of partitions */
+					/* (from dkio.h) */
+
+#define	VTOC_SANE	0x600DDEEE	/* Indicates a sane VTOC */
+#define	V_VERSION	0x01		/* layout version number */
+#define	V_EXTVERSION	V_VERSION	/* extvtoc layout version number */
+
+/*
+ * Partition identification tags
+ */
+#define	V_UNASSIGNED	0x00		/* unassigned partition */
+#define	V_BOOT		0x01		/* Boot partition */
+#define	V_ROOT		0x02		/* Root filesystem */
+#define	V_SWAP		0x03		/* Swap filesystem */
+#define	V_USR		0x04		/* Usr filesystem */
+#define	V_BACKUP	0x05		/* full disk */
+#define	V_STAND		0x06		/* Stand partition */
+#define	V_VAR		0x07		/* Var partition */
+#define	V_HOME		0x08		/* Home partition */
+#define	V_ALTSCTR	0x09		/* Alternate sector partition */
+#define	V_CACHE		0x0a		/* Cache (cachefs) partition */
+#define	V_RESERVED	0x0b		/* SMI reserved data */
+
+/*
+ * Partition permission flags
+ */
+#define	V_UNMNT		0x01		/* Unmountable partition */
+#define	V_RONLY		0x10		/* Read only */
+
+/*
+ * error codes for reading & writing vtoc
+ */
+#define	VT_ERROR	(-2)		/* errno supplies specific error */
+#define	VT_EIO		(-3)		/* I/O error accessing vtoc */
+#define	VT_EINVAL	(-4)		/* illegal value in vtoc or request */
+#define	VT_ENOTSUP	(-5)		/* VTOC op. not supported */
+#define	VT_ENOSPC	(-6)		/* requested space not found */
+#define	VT_EOVERFLOW	(-7)		/* VTOC op. data struct limited */
+
+struct partition	{
+	ushort_t p_tag;			/* ID tag of partition */
+	ushort_t p_flag;		/* permission flags */
+	daddr_t	p_start;		/* start sector no of partition */
+	long	p_size;			/* # of blocks in partition */
+};
+
+struct vtoc {
+	unsigned long	v_bootinfo[3];	/* info needed by mboot (unsupported) */
+	unsigned long	v_sanity;	/* to verify vtoc sanity */
+	unsigned long	v_version;	/* layout version */
+	char	v_volume[LEN_DKL_VVOL];	/* volume name */
+	ushort_t	v_sectorsz;	/* sector size in bytes */
+	ushort_t	v_nparts;	/* number of partitions */
+	unsigned long	v_reserved[10];	/* free space */
+	struct partition v_part[V_NUMPAR]; /* partition headers */
+	time_t	timestamp[V_NUMPAR];	/* partition timestamp (unsupported) */
+	char	v_asciilabel[LEN_DKL_ASCII];	/* for compatibility */
+};
+
+struct extpartition {
+	ushort_t p_tag;			/* ID tag of partition */
+	ushort_t p_flag;		/* permission flags */
+	ushort_t p_pad[2];
+	diskaddr_t p_start;		/* start sector no of partition */
+	diskaddr_t p_size;			/* # of blocks in partition */
+};
+
+
+struct extvtoc {
+	uint64_t	v_bootinfo[3];	/* info needed by mboot (unsupported) */
+	uint64_t	v_sanity;	/* to verify vtoc sanity */
+	uint64_t	v_version;	/* layout version */
+	char	v_volume[LEN_DKL_VVOL];	/* volume name */
+	ushort_t	v_sectorsz;	/* sector size in bytes */
+	ushort_t	v_nparts;	/* number of partitions */
+	ushort_t	pad[2];
+	uint64_t	v_reserved[10];
+	struct extpartition v_part[V_NUMPAR]; /* partition headers */
+	uint64_t timestamp[V_NUMPAR];	/* partition timestamp (unsupported) */
+	char	v_asciilabel[LEN_DKL_ASCII];	/* for compatibility */
+};
+
+#ifdef _KERNEL
+#define	extvtoctovtoc(extv, v)						\
+	{								\
+	int i;								\
+	v.v_bootinfo[0]		= (unsigned long)extv.v_bootinfo[0];	\
+	v.v_bootinfo[1]		= (unsigned long)extv.v_bootinfo[1];	\
+	v.v_bootinfo[2]		= (unsigned long)extv.v_bootinfo[2];	\
+	v.v_sanity		= (unsigned long)extv.v_sanity;		\
+	v.v_version		= (unsigned long)extv.v_version;	\
+	bcopy(extv.v_volume, v.v_volume, LEN_DKL_VVOL);			\
+	v.v_sectorsz		= extv.v_sectorsz;			\
+	v.v_nparts		= extv.v_nparts;			\
+	for (i = 0; i < 10; i++)					\
+		v.v_reserved[i] = (unsigned long)extv.v_reserved[i];	\
+	for (i = 0; i < V_NUMPAR; i++) {				\
+		v.v_part[i].p_tag = extv.v_part[i].p_tag;		\
+		v.v_part[i].p_flag = extv.v_part[i].p_flag;		\
+		v.v_part[i].p_start = (daddr_t)extv.v_part[i].p_start;	\
+		v.v_part[i].p_size = (long)extv.v_part[i].p_size;	\
+		v.timestamp[i] = (time_t)extv.timestamp[i];		\
+	}								\
+	bcopy(extv.v_asciilabel, v.v_asciilabel, LEN_DKL_ASCII);	\
+	}
+
+#define	vtoctoextvtoc(v, extv)						\
+	{								\
+	int i;								\
+	extv.v_bootinfo[0]	= (uint64_t)v.v_bootinfo[0];		\
+	extv.v_bootinfo[1]	= (uint64_t)v.v_bootinfo[1];		\
+	extv.v_bootinfo[2]	= (uint64_t)v.v_bootinfo[2];		\
+	extv.v_sanity		= (uint64_t)v.v_sanity;			\
+	extv.v_version		= (uint64_t)v.v_version;		\
+	bcopy(v.v_volume, extv.v_volume, LEN_DKL_VVOL);			\
+	extv.v_sectorsz		= v.v_sectorsz;				\
+	extv.v_nparts		= v.v_nparts;				\
+	for (i = 0; i < 10; i++)					\
+		extv.v_reserved[i] = (uint64_t)v.v_reserved[i];		\
+	for (i = 0; i < V_NUMPAR; i++) {				\
+		extv.v_part[i].p_tag = v.v_part[i].p_tag;		\
+		extv.v_part[i].p_flag = v.v_part[i].p_flag;		\
+		extv.v_part[i].p_start =				\
+		    (diskaddr_t)(unsigned long)v.v_part[i].p_start;	\
+		extv.v_part[i].p_size =					\
+		    (diskaddr_t)(unsigned long)v.v_part[i].p_size;	\
+		extv.timestamp[i] = (uint64_t)v.timestamp[i];		\
+	}								\
+	bcopy(v.v_asciilabel, extv.v_asciilabel, LEN_DKL_ASCII);	\
+	}
+#endif /* _KERNEL */
+
+#if defined(_SYSCALL32)
+struct partition32	{
+	uint16_t	p_tag;		/* ID tag of partition */
+	uint16_t	p_flag;		/* permission flags */
+	daddr32_t	p_start;	/* start sector no of partition */
+	int32_t		p_size;		/* # of blocks in partition */
+};
+
+struct vtoc32 {
+	uint32_t	v_bootinfo[3];	/* info needed by mboot (unsupported) */
+	uint32_t	v_sanity;	/* to verify vtoc sanity */
+	uint32_t	v_version;	/* layout version */
+	char	v_volume[LEN_DKL_VVOL];	/* volume name */
+	uint16_t	v_sectorsz;	/* sector size in bytes */
+	uint16_t	v_nparts;	/* number of partitions */
+	uint32_t	v_reserved[10];	/* free space */
+	struct partition32 v_part[V_NUMPAR]; /* partition headers */
+	time32_t timestamp[V_NUMPAR];	/* partition timestamp (unsupported) */
+	char	v_asciilabel[LEN_DKL_ASCII];	/* for compatibility */
+};
+
+#define	vtoc32tovtoc(v32, v)				\
+	{						\
+	int i;						\
+	v.v_bootinfo[0]		= v32.v_bootinfo[0];	\
+	v.v_bootinfo[1]		= v32.v_bootinfo[1];	\
+	v.v_bootinfo[2]		= v32.v_bootinfo[2];	\
+	v.v_sanity		= v32.v_sanity;		\
+	v.v_version		= v32.v_version;	\
+	bcopy(v32.v_volume, v.v_volume, LEN_DKL_VVOL);	\
+	v.v_sectorsz		= v32.v_sectorsz;	\
+	v.v_nparts		= v32.v_nparts;		\
+	v.v_version		= v32.v_version;	\
+	for (i = 0; i < 10; i++)			\
+		v.v_reserved[i] = v32.v_reserved[i];	\
+	for (i = 0; i < V_NUMPAR; i++) {		\
+		v.v_part[i].p_tag = (ushort_t)v32.v_part[i].p_tag;	\
+		v.v_part[i].p_flag = (ushort_t)v32.v_part[i].p_flag;	\
+		v.v_part[i].p_start = (unsigned)v32.v_part[i].p_start;	\
+		v.v_part[i].p_size = (unsigned)v32.v_part[i].p_size;	\
+	}						\
+	for (i = 0; i < V_NUMPAR; i++)			\
+		v.timestamp[i] = (time_t)v32.timestamp[i];		\
+	bcopy(v32.v_asciilabel, v.v_asciilabel, LEN_DKL_ASCII);		\
+	}
+
+#define	vtoc32toextvtoc(v32, extv)					\
+	{								\
+	int i;								\
+	extv.v_bootinfo[0]		= v32.v_bootinfo[0];		\
+	extv.v_bootinfo[1]		= v32.v_bootinfo[1];		\
+	extv.v_bootinfo[2]		= v32.v_bootinfo[2];		\
+	extv.v_sanity		= v32.v_sanity;				\
+	extv.v_version		= v32.v_version;			\
+	bcopy(v32.v_volume, extv.v_volume, LEN_DKL_VVOL);		\
+	extv.v_sectorsz		= v32.v_sectorsz;			\
+	extv.v_nparts		= v32.v_nparts;				\
+	extv.v_version		= v32.v_version;			\
+	for (i = 0; i < 10; i++)					\
+		extv.v_reserved[i] = v32.v_reserved[i];			\
+	for (i = 0; i < V_NUMPAR; i++) {				\
+		extv.v_part[i].p_tag = (ushort_t)v32.v_part[i].p_tag;	\
+		extv.v_part[i].p_flag = (ushort_t)v32.v_part[i].p_flag;	\
+		extv.v_part[i].p_start = (diskaddr_t)v32.v_part[i].p_start; \
+		extv.v_part[i].p_size = (diskaddr_t)v32.v_part[i].p_size; \
+		extv.timestamp[i] = (time_t)v32.timestamp[i];		\
+	}								\
+	bcopy(v32.v_asciilabel, extv.v_asciilabel, LEN_DKL_ASCII);	\
+	}
+
+
+#define	vtoctovtoc32(v, v32)				\
+	{						\
+	int i;						\
+	v32.v_bootinfo[0]	= v.v_bootinfo[0];	\
+	v32.v_bootinfo[1]	= v.v_bootinfo[1];	\
+	v32.v_bootinfo[2]	= v.v_bootinfo[2];	\
+	v32.v_sanity		= v.v_sanity;		\
+	v32.v_version		= v.v_version;		\
+	bcopy(v.v_volume, v32.v_volume, LEN_DKL_VVOL);	\
+	v32.v_sectorsz		= v.v_sectorsz;		\
+	v32.v_nparts		= v.v_nparts;		\
+	v32.v_version		= v.v_version;		\
+	for (i = 0; i < 10; i++)			\
+		v32.v_reserved[i] = v.v_reserved[i];	\
+	for (i = 0; i < V_NUMPAR; i++) {		\
+		v32.v_part[i].p_tag = (ushort_t)v.v_part[i].p_tag;	\
+		v32.v_part[i].p_flag = (ushort_t)v.v_part[i].p_flag;	\
+		v32.v_part[i].p_start = (unsigned)v.v_part[i].p_start;	\
+		v32.v_part[i].p_size = (unsigned)v.v_part[i].p_size;	\
+	}						\
+	for (i = 0; i < V_NUMPAR; i++) {		\
+		if (v.timestamp[i] > TIME32_MAX)	\
+			v32.timestamp[i] = TIME32_MAX;	\
+		else 					\
+			v32.timestamp[i] = (time32_t)v.timestamp[i];	\
+	}						\
+	bcopy(v.v_asciilabel, v32.v_asciilabel, LEN_DKL_ASCII);		\
+	}
+
+#define	extvtoctovtoc32(extv, v32)				\
+	{						\
+	int i;						\
+	v32.v_bootinfo[0]	= extv.v_bootinfo[0];	\
+	v32.v_bootinfo[1]	= extv.v_bootinfo[1];	\
+	v32.v_bootinfo[2]	= extv.v_bootinfo[2];	\
+	v32.v_sanity		= extv.v_sanity;		\
+	v32.v_version		= extv.v_version;		\
+	bcopy(extv.v_volume, v32.v_volume, LEN_DKL_VVOL);	\
+	v32.v_sectorsz		= extv.v_sectorsz;		\
+	v32.v_nparts		= extv.v_nparts;		\
+	v32.v_version		= extv.v_version;		\
+	for (i = 0; i < 10; i++)			\
+		v32.v_reserved[i] = extv.v_reserved[i];	\
+	for (i = 0; i < V_NUMPAR; i++) {		\
+		v32.v_part[i].p_tag = (ushort_t)extv.v_part[i].p_tag;	\
+		v32.v_part[i].p_flag = (ushort_t)extv.v_part[i].p_flag;	\
+		v32.v_part[i].p_start = (unsigned)extv.v_part[i].p_start; \
+		v32.v_part[i].p_size = (unsigned)extv.v_part[i].p_size;	\
+	}						\
+	for (i = 0; i < V_NUMPAR; i++) {		\
+		if (extv.timestamp[i] > TIME32_MAX)	\
+			v32.timestamp[i] = TIME32_MAX;	\
+		else 					\
+			v32.timestamp[i] = (time32_t)extv.timestamp[i];	\
+	}						\
+	bcopy(extv.v_asciilabel, v32.v_asciilabel, LEN_DKL_ASCII);	\
+	}
+
+
+#endif /* _SYSCALL32 */
+
+/*
+ * These defines are the mode parameter for the checksum routines.
+ */
+#define	CK_CHECKSUM	0	/* check checksum */
+#define	CK_MAKESUM	1	/* generate checksum */
+
+#if defined(__STDC__)
+
+extern	int	read_vtoc(int, struct vtoc *);
+extern	int	write_vtoc(int, struct vtoc *);
+extern	int	read_extvtoc(int, struct extvtoc *);
+extern	int	write_extvtoc(int, struct extvtoc *);
+
+#else
+
+extern	int	read_vtoc();
+extern	int	write_vtoc();
+extern	int	read_extvtoc();
+extern	int	write_extvtoc();
+
+#endif 	/* __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _SYS_VTOC_H */

lib/libspl/include/sys/zone.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_SYS_ZONE_H
+#define _LIBSPL_SYS_ZONE_H
+
+#endif

lib/libspl/include/thread.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_THREAD_H
+#define _LIBSPL_THREAD_H
+
+#endif /* _LIBSPL_THREAD_H */

lib/libspl/include/tzfile.h

@@ -0,0 +1,32 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_TZFILE_H
+#define _LIBSPL_TZFILE_H
+
+#include <sys/tzfile.h>
+
+#endif /* _LIBSPL_TZFILE_H */

lib/libspl/include/ucred.h

@@ -0,0 +1,32 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_UCRED_H
+#define _LIBSPL_UCRED_H
+
+typedef int ucred_t;
+
+#endif

lib/libspl/include/umem.h

@@ -0,0 +1,195 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_UMEM_H
+#define _LIBSPL_UMEM_H
+
+/* XXX: We should use the real portable umem library if it is detected
+ * at configure time.  However, if the library is not available we can
+ * use a trivial malloc based implementation.  This obviously impacts
+ * performance but unless you using a full userspace build of zpool for
+ * something other than ztest your likely not going to notice or care.
+ *
+ * https://labs.omniti.com/trac/portableumem
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef void vmem_t;
+
+/*
+ * Flags for umem_alloc/umem_free
+ */
+#define UMEM_DEFAULT		0x0000  /* normal -- may fail */
+#define UMEM_NOFAIL		0x0100  /* Never fails */
+
+/*
+ * Flags for umem_cache_create()
+ */
+#define UMC_NOTOUCH		0x00010000
+#define UMC_NODEBUG		0x00020000
+#define UMC_NOMAGAZINE		0x00040000
+#define UMC_NOHASH		0x00080000
+
+#define UMEM_CACHE_NAMELEN	31
+
+typedef int umem_nofail_callback_t(void);
+typedef int umem_constructor_t(void *, void *, int);
+typedef void umem_destructor_t(void *, void *);
+typedef void umem_reclaim_t(void *);
+
+typedef struct umem_cache {
+	char			cache_name[UMEM_CACHE_NAMELEN + 1];
+	size_t			cache_bufsize;
+	size_t			cache_align;
+	umem_constructor_t	*cache_constructor;
+	umem_destructor_t	*cache_destructor;
+	umem_reclaim_t		*cache_reclaim;
+	void			*cache_private;
+	void			*cache_arena;
+	int			cache_cflags;
+} umem_cache_t;
+
+static inline void *
+umem_alloc(size_t size, int flags)
+{
+	void *ptr;
+
+	do {
+		ptr = malloc(size);
+	} while (ptr == NULL && (flags & UMEM_NOFAIL));
+
+	return ptr;
+}
+
+static inline void *
+umem_alloc_aligned(size_t size, size_t align, int flags)
+{
+	void *ptr;
+	int rc;
+
+	do {
+		rc = posix_memalign(&ptr, align, size);
+	} while (rc == ENOMEM && (flags & UMEM_NOFAIL));
+
+	if (rc == EINVAL) {
+		fprintf(stderr, "%s: invalid memory alignment (%zd)\n",
+		    __func__, align);
+		if (flags & UMEM_NOFAIL)
+			abort();
+		return NULL;
+	}
+
+	return ptr;
+}
+
+static inline void *
+umem_zalloc(size_t size, int flags)
+{
+	void *ptr;
+
+	ptr = umem_alloc(size, flags);
+	if (ptr)
+		memset(ptr, 0, size);
+
+	return ptr;
+}
+
+static inline void
+umem_free(void *ptr, size_t size)
+{
+	free(ptr);
+}
+
+static inline void
+umem_nofail_callback(umem_nofail_callback_t *cb) {}
+
+static inline umem_cache_t *
+umem_cache_create(char *name, size_t bufsize, size_t align,
+                  umem_constructor_t *constructor,
+                  umem_destructor_t *destructor,
+                  umem_reclaim_t *reclaim,
+		  void *priv, void *vmp, int cflags)
+{
+	umem_cache_t *cp;
+
+	cp = umem_alloc(sizeof(umem_cache_t), UMEM_DEFAULT);
+	if (cp) {
+		strncpy(cp->cache_name, name, UMEM_CACHE_NAMELEN);
+		cp->cache_bufsize = bufsize;
+		cp->cache_align = align;
+		cp->cache_constructor = constructor;
+		cp->cache_destructor = destructor;
+		cp->cache_reclaim = reclaim;
+		cp->cache_private = priv;
+		cp->cache_arena = vmp;
+		cp->cache_cflags = cflags;
+	}
+
+	return cp;
+}
+
+static inline void
+umem_cache_destroy(umem_cache_t *cp)
+{
+	umem_free(cp, sizeof(umem_cache_t));
+}
+
+static inline void *
+umem_cache_alloc(umem_cache_t *cp, int flags)
+{
+	void *ptr;
+
+	if (cp->cache_align != 0)
+		ptr = umem_alloc_aligned(cp->cache_bufsize, cp->cache_align, flags);
+	else
+		ptr = umem_alloc(cp->cache_bufsize, flags);
+
+	if (ptr && cp->cache_constructor)
+		cp->cache_constructor(ptr, cp->cache_private, UMEM_DEFAULT);
+
+	return ptr;
+}
+
+static inline void
+umem_cache_free(umem_cache_t *cp, void *ptr)
+{
+	if (cp->cache_destructor)
+		cp->cache_destructor(ptr, cp->cache_private);
+
+	umem_free(ptr, cp->cache_bufsize);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

lib/libspl/include/unistd.h

@@ -0,0 +1,57 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include_next <unistd.h>
+
+#ifndef _LIBSPL_UNISTD_H
+#define _LIBSPL_UNISTD_H
+
+#if !defined(HAVE_IOCTL_IN_UNISTD_H)
+# if defined(HAVE_IOCTL_IN_SYS_IOCTL_H)
+#  include <sys/ioctl.h>
+# elif defined(HAVE_IOCTL_IN_STROPTS_H)
+#  include <stropts.h>
+# else
+#  error "System call ioctl() unavailable"
+# endif
+#endif
+
+#if !defined(HAVE_ISSETUGID)
+# include <sys/types.h>
+# define issetugid() (geteuid() == 0 || getegid() == 0)
+#endif
+
+#if !defined(__sun__) && !defined(__sun)
+/* It seems Solaris only returns positive host ids */
+static inline long fake_gethostid(void)
+{
+	long id = gethostid();
+	return id >= 0 ? id : -id;
+}
+#define gethostid() fake_gethostid()
+#endif
+
+#endif /* _LIBSPL_UNISTD_H */

lib/libspl/include/util/sscanf.h

@@ -0,0 +1,30 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_UTIL_SSCANF_H
+#define _LIBSPL_UTIL_SSCANF_H
+
+#endif

lib/libspl/include/zone.h

@@ -0,0 +1,53 @@
+/*
+ * 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 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _LIBSPL_ZONE_H
+#define	_LIBSPL_ZONE_H
+
+
+
+#include <sys/types.h>
+#include <sys/zone.h>
+#include <sys/priv.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define GLOBAL_ZONEID 0
+#define GLOBAL_ZONEID_NAME "global"
+
+/*
+ * Functions for mapping between id and name for active zones.
+ */
+extern zoneid_t		getzoneid(void);
+extern zoneid_t		getzoneidbyname(const char *);
+extern ssize_t		getzonenamebyid(zoneid_t, char *, size_t);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _LIBSPL_ZONE_H */

lib/libspl/list.c

@@ -0,0 +1,243 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Generic doubly-linked list implementation
+ */
+
+#include <sys/list.h>
+#include <sys/list_impl.h>
+#include <sys/types.h>
+#include <sys/sysmacros.h>
+#include <sys/debug.h>
+
+#define	list_d2l(a, obj) ((list_node_t *)(((char *)obj) + (a)->list_offset))
+#define	list_object(a, node) ((void *)(((char *)node) - (a)->list_offset))
+#define	list_empty(a) ((a)->list_head.list_next == &(a)->list_head)
+
+#define	list_insert_after_node(list, node, object) {	\
+	list_node_t *lnew = list_d2l(list, object);	\
+	lnew->list_prev = (node);			\
+	lnew->list_next = (node)->list_next;		\
+	(node)->list_next->list_prev = lnew;		\
+	(node)->list_next = lnew;			\
+}
+
+#define	list_insert_before_node(list, node, object) {	\
+	list_node_t *lnew = list_d2l(list, object);	\
+	lnew->list_next = (node);			\
+	lnew->list_prev = (node)->list_prev;		\
+	(node)->list_prev->list_next = lnew;		\
+	(node)->list_prev = lnew;			\
+}
+
+#define	list_remove_node(node)					\
+	(node)->list_prev->list_next = (node)->list_next;	\
+	(node)->list_next->list_prev = (node)->list_prev;	\
+	(node)->list_next = (node)->list_prev = NULL
+
+void
+list_create(list_t *list, size_t size, size_t offset)
+{
+	ASSERT(list);
+	ASSERT(size > 0);
+	ASSERT(size >= offset + sizeof (list_node_t));
+
+	list->list_size = size;
+	list->list_offset = offset;
+	list->list_head.list_next = list->list_head.list_prev =
+	    &list->list_head;
+}
+
+void
+list_destroy(list_t *list)
+{
+	list_node_t *node = &list->list_head;
+
+	ASSERT(list);
+	ASSERT(list->list_head.list_next == node);
+	ASSERT(list->list_head.list_prev == node);
+
+	node->list_next = node->list_prev = NULL;
+}
+
+void
+list_insert_after(list_t *list, void *object, void *nobject)
+{
+	if (object == NULL) {
+		list_insert_head(list, nobject);
+	} else {
+		list_node_t *lold = list_d2l(list, object);
+		list_insert_after_node(list, lold, nobject);
+	}
+}
+
+void
+list_insert_before(list_t *list, void *object, void *nobject)
+{
+	if (object == NULL) {
+		list_insert_tail(list, nobject);
+	} else {
+		list_node_t *lold = list_d2l(list, object);
+		list_insert_before_node(list, lold, nobject);
+	}
+}
+
+void
+list_insert_head(list_t *list, void *object)
+{
+	list_node_t *lold = &list->list_head;
+	list_insert_after_node(list, lold, object);
+}
+
+void
+list_insert_tail(list_t *list, void *object)
+{
+	list_node_t *lold = &list->list_head;
+	list_insert_before_node(list, lold, object);
+}
+
+void
+list_remove(list_t *list, void *object)
+{
+	list_node_t *lold = list_d2l(list, object);
+	ASSERT(!list_empty(list));
+	ASSERT(lold->list_next != NULL);
+	list_remove_node(lold);
+}
+
+void *
+list_remove_head(list_t *list)
+{
+	list_node_t *head = list->list_head.list_next;
+	if (head == &list->list_head)
+		return (NULL);
+	list_remove_node(head);
+	return (list_object(list, head));
+}
+
+void *
+list_remove_tail(list_t *list)
+{
+	list_node_t *tail = list->list_head.list_prev;
+	if (tail == &list->list_head)
+		return (NULL);
+	list_remove_node(tail);
+	return (list_object(list, tail));
+}
+
+void *
+list_head(list_t *list)
+{
+	if (list_empty(list))
+		return (NULL);
+	return (list_object(list, list->list_head.list_next));
+}
+
+void *
+list_tail(list_t *list)
+{
+	if (list_empty(list))
+		return (NULL);
+	return (list_object(list, list->list_head.list_prev));
+}
+
+void *
+list_next(list_t *list, void *object)
+{
+	list_node_t *node = list_d2l(list, object);
+
+	if (node->list_next != &list->list_head)
+		return (list_object(list, node->list_next));
+
+	return (NULL);
+}
+
+void *
+list_prev(list_t *list, void *object)
+{
+	list_node_t *node = list_d2l(list, object);
+
+	if (node->list_prev != &list->list_head)
+		return (list_object(list, node->list_prev));
+
+	return (NULL);
+}
+
+/*
+ *  Insert src list after dst list. Empty src list thereafter.
+ */
+void
+list_move_tail(list_t *dst, list_t *src)
+{
+	list_node_t *dstnode = &dst->list_head;
+	list_node_t *srcnode = &src->list_head;
+
+	ASSERT(dst->list_size == src->list_size);
+	ASSERT(dst->list_offset == src->list_offset);
+
+	if (list_empty(src))
+		return;
+
+	dstnode->list_prev->list_next = srcnode->list_next;
+	srcnode->list_next->list_prev = dstnode->list_prev;
+	dstnode->list_prev = srcnode->list_prev;
+	srcnode->list_prev->list_next = dstnode;
+
+	/* empty src list */
+	srcnode->list_next = srcnode->list_prev = srcnode;
+}
+
+void
+list_link_replace(list_node_t *lold, list_node_t *lnew)
+{
+	ASSERT(list_link_active(lold));
+	ASSERT(!list_link_active(lnew));
+
+	lnew->list_next = lold->list_next;
+	lnew->list_prev = lold->list_prev;
+	lold->list_prev->list_next = lnew;
+	lold->list_next->list_prev = lnew;
+	lold->list_next = lold->list_prev = NULL;
+}
+
+void
+list_link_init(list_node_t *ln)
+{
+	ln->list_next = NULL;
+	ln->list_prev = NULL;
+}
+
+int
+list_link_active(list_node_t *ln)
+{
+	return (ln->list_next != NULL);
+}
+
+int
+list_is_empty(list_t *list)
+{
+	return (list_empty(list));
+}

lib/libspl/mkdirp.c

@@ -0,0 +1,210 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*	Copyright (c) 1988 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+/*
+ * Creates directory and it's parents if the parents do not
+ * exist yet.
+ *
+ * Returns -1 if fails for reasons other than non-existing
+ * parents.
+ * Does NOT simplify pathnames with . or .. in them.
+ */
+
+#include <sys/types.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+
+static char *simplify(const char *str);
+
+int
+mkdirp(const char *d, mode_t mode)
+{
+	char  *endptr, *ptr, *slash, *str;
+
+	str = simplify(d);
+
+	/* If space couldn't be allocated for the simplified names, return. */
+
+	if (str == NULL)
+		return (-1);
+
+		/* Try to make the directory */
+
+	if (mkdir(str, mode) == 0) {
+		free(str);
+		return (0);
+	}
+	if (errno != ENOENT) {
+		free(str);
+		return (-1);
+	}
+	endptr = strrchr(str, '\0');
+	slash = strrchr(str, '/');
+
+		/* Search upward for the non-existing parent */
+
+	while (slash != NULL) {
+
+		ptr = slash;
+		*ptr = '\0';
+
+			/* If reached an existing parent, break */
+
+		if (access(str, F_OK) == 0)
+			break;
+
+			/* If non-existing parent */
+
+		else {
+			slash = strrchr(str, '/');
+
+				/* If under / or current directory, make it. */
+
+			if (slash == NULL || slash == str) {
+				if (mkdir(str, mode) != 0 && errno != EEXIST) {
+					free(str);
+					return (-1);
+				}
+				break;
+			}
+		}
+	}
+
+	/* Create directories starting from upmost non-existing parent */
+
+	while ((ptr = strchr(str, '\0')) != endptr) {
+		*ptr = '/';
+		if (mkdir(str, mode) != 0 && errno != EEXIST) {
+			/*
+			 *  If the mkdir fails because str already
+			 *  exists (EEXIST), then str has the form
+			 *  "existing-dir/..", and this is really
+			 *  ok. (Remember, this loop is creating the
+			 *  portion of the path that didn't exist)
+			 */
+			free(str);
+			return (-1);
+		}
+	}
+	free(str);
+	return (0);
+}
+
+/*
+ *	simplify - given a pathname, simplify that path by removing
+ *		   duplicate contiguous slashes.
+ *
+ *		   A simplified copy of the argument is returned to the
+ *		   caller, or NULL is returned on error.
+ *
+ *		   The caller should handle error reporting based upon the
+ *		   returned vlaue, and should free the returned value,
+ *		   when appropriate.
+ */
+
+static char *
+simplify(const char *str)
+{
+	int i;
+	size_t mbPathlen;	/* length of multi-byte path */
+	size_t wcPathlen;	/* length of wide-character path */
+	wchar_t *wptr;		/* scratch pointer */
+	wchar_t *wcPath;	/* wide-character version of the path */
+	char *mbPath;		/* The copy fo the path to be returned */
+
+	/*
+	 *  bail out if there is nothing there.
+	 */
+
+	if (!str)
+		return (NULL);
+
+	/*
+	 *  Get a copy of the argument.
+	 */
+
+	if ((mbPath = strdup(str)) == NULL) {
+		return (NULL);
+	}
+
+	/*
+	 *  convert the multi-byte version of the path to a
+	 *  wide-character rendering, for doing our figuring.
+	 */
+
+	mbPathlen = strlen(mbPath);
+
+	if ((wcPath = calloc(sizeof (wchar_t), mbPathlen+1)) == NULL) {
+		free(mbPath);
+		return (NULL);
+	}
+
+	if ((wcPathlen = mbstowcs(wcPath, mbPath, mbPathlen)) == (size_t)-1) {
+		free(mbPath);
+		free(wcPath);
+		return (NULL);
+	}
+
+	/*
+	 *  remove duplicate slashes first ("//../" -> "/")
+	 */
+
+	for (wptr = wcPath, i = 0; i < wcPathlen; i++) {
+		*wptr++ = wcPath[i];
+
+		if (wcPath[i] == '/') {
+			i++;
+
+			while (wcPath[i] == '/') {
+				i++;
+			}
+
+			i--;
+		}
+	}
+
+	*wptr = '\0';
+
+	/*
+	 *  now convert back to the multi-byte format.
+	 */
+
+	if (wcstombs(mbPath, wcPath, mbPathlen) == (size_t)-1) {
+		free(mbPath);
+		free(wcPath);
+		return (NULL);
+	}
+
+	free(wcPath);
+	return (mbPath);
+}

lib/libspl/strlcat.c

@@ -0,0 +1,56 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <string.h>
+#include <sys/types.h>
+
+/*
+ * Appends src to the dstsize buffer at dst. The append will never
+ * overflow the destination buffer and the buffer will always be null
+ * terminated. Never reference beyond &dst[dstsize-1] when computing
+ * the length of the pre-existing string.
+ */
+
+size_t
+strlcat(char *dst, const char *src, size_t dstsize)
+{
+	char *df = dst;
+	size_t left = dstsize;
+	size_t l1;
+	size_t l2 = strlen(src);
+	size_t copied;
+
+	while (left-- != 0 && *df != '\0')
+		df++;
+	l1 = df - dst;
+	if (dstsize == l1)
+		return (l1 + l2);
+
+	copied = l1 + l2 >= dstsize ? dstsize - l1 - 1 : l2;
+	(void) memcpy(dst + l1, src, copied);
+	dst[l1+copied] = '\0';
+	return (l1 + l2);
+}

lib/libspl/strlcpy.c

@@ -0,0 +1,52 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <string.h>
+#include <sys/types.h>
+
+/*
+ * Copies src to the dstsize buffer at dst. The copy will never
+ * overflow the destination buffer and the buffer will always be null
+ * terminated.
+ */
+
+size_t
+strlcpy(char *dst, const char *src, size_t len)
+{
+	size_t slen = strlen(src);
+	size_t copied;
+
+	if (len == 0)
+		return (slen);
+
+	if (slen >= len)
+		copied = len - 1;
+	else
+		copied = slen;
+	(void) memcpy(dst, src, copied);
+	dst[copied] = '\0';
+	return (slen);
+}

lib/libspl/strnlen.c

@@ -0,0 +1,44 @@
+/*
+ * 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 2008 Sun Microsystems, Inc.
+ * All rights reserved.  Use is subject to license terms.
+ */
+
+#include <string.h>
+#include <sys/types.h>
+
+/*
+ * Returns the number of non-NULL bytes in string argument,
+ * but not more than maxlen.  Does not look past str + maxlen.
+ */
+size_t
+strnlen(const char *str, size_t maxlen)
+{
+	const char *ptr;
+
+	ptr = memchr(str, 0, maxlen);
+	if (ptr == NULL)
+		return (maxlen);
+
+	return (ptr - str);
+}