[mirror_spl-debian.git] / module / spl / spl-generic.c

/*
 *  This file is part of the SPL: Solaris Porting Layer.
 *
 *  Copyright (c) 2008 Lawrence Livermore National Security, LLC.
 *  Produced at Lawrence Livermore National Laboratory
 *  Written by:
 *          Brian Behlendorf <behlendorf1@llnl.gov>,
 *          Herb Wartens <wartens2@llnl.gov>,
 *          Jim Garlick <garlick@llnl.gov>
 *  UCRL-CODE-235197
 *
 *  This is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
 */

#include <sys/sysmacros.h>
#include <sys/systeminfo.h>
#include <sys/vmsystm.h>
#include <sys/vnode.h>
#include <sys/kmem.h>
#include <sys/mutex.h>
#include <sys/taskq.h>
#include <sys/debug.h>
#include <sys/proc.h>
#include <sys/kstat.h>
#include <sys/utsname.h>
#include <linux/kmod.h>

#ifdef DEBUG_SUBSYSTEM
#undef DEBUG_SUBSYSTEM
#endif

#define DEBUG_SUBSYSTEM S_GENERIC

char spl_version[16] = "SPL v" SPL_META_VERSION;

long spl_hostid = 0;
EXPORT_SYMBOL(spl_hostid);

char hw_serial[HW_HOSTID_LEN] = "<none>";
EXPORT_SYMBOL(hw_serial);

int p0 = 0;
EXPORT_SYMBOL(p0);

#ifndef HAVE_KALLSYMS_LOOKUP_NAME
kallsyms_lookup_name_t spl_kallsyms_lookup_name_fn = NULL;
#endif

int
highbit(unsigned long i)
{
        register int h = 1;
        ENTRY;

        if (i == 0)
                RETURN(0);
#if BITS_PER_LONG == 64
        if (i & 0xffffffff00000000ul) {
                h += 32; i >>= 32;
        }
#endif
        if (i & 0xffff0000) {
                h += 16; i >>= 16;
        }
        if (i & 0xff00) {
                h += 8; i >>= 8;
        }
        if (i & 0xf0) {
                h += 4; i >>= 4;
        }
        if (i & 0xc) {
                h += 2; i >>= 2;
        }
        if (i & 0x2) {
                h += 1;
        }
        RETURN(h);
}
EXPORT_SYMBOL(highbit);

/*
 * Implementation of 64 bit division for 32-bit machines.
 */
#if BITS_PER_LONG == 32
uint64_t __udivdi3(uint64_t dividend, uint64_t divisor)
{
#ifdef HAVE_DIV64_64
	return div64_64(dividend, divisor);
#else
	/* Taken from a 2.6.24 kernel. */
	uint32_t high, d;

	high = divisor >> 32;
	if (high) {
		unsigned int shift = fls(high);

		d = divisor >> shift;
		dividend >>= shift;
	} else
		d = divisor;

	do_div(dividend, d);

	return dividend;
#endif
}
EXPORT_SYMBOL(__udivdi3);

/*
 * Implementation of 64 bit modulo for 32-bit machines.
 */
uint64_t __umoddi3(uint64_t dividend, uint64_t divisor)
{
	return dividend - divisor * (dividend / divisor);
}
EXPORT_SYMBOL(__umoddi3);
#endif

/* NOTE: The strtoxx behavior is solely based on my reading of the Solaris
 * ddi_strtol(9F) man page.  I have not verified the behavior of these
 * functions against their Solaris counterparts.  It is possible that I
 * may have misinterpretted the man page or the man page is incorrect.
 */
int ddi_strtoul(const char *, char **, int, unsigned long *);
int ddi_strtol(const char *, char **, int, long *);
int ddi_strtoull(const char *, char **, int, unsigned long long *);
int ddi_strtoll(const char *, char **, int, long long *);

#define define_ddi_strtoux(type, valtype)				\
int ddi_strtou##type(const char *str, char **endptr,			\
		     int base, valtype *result)				\
{									\
	valtype last_value, value = 0;					\
	char *ptr = (char *)str;					\
	int flag = 1, digit;						\
									\
	if (strlen(ptr) == 0)						\
		return EINVAL;						\
									\
	/* Auto-detect base based on prefix */				\
	if (!base) {							\
		if (str[0] == '0') {					\
			if (tolower(str[1])=='x' && isxdigit(str[2])) {	\
				base = 16; /* hex */			\
				ptr += 2;				\
			} else if (str[1] >= '0' && str[1] < 8) {	\
				base = 8; /* octal */			\
				ptr += 1;				\
			} else {					\
				return EINVAL;				\
			}						\
		} else {						\
			base = 10; /* decimal */			\
		}							\
	}								\
									\
	while (1) {							\
		if (isdigit(*ptr))					\
			digit = *ptr - '0';				\
		else if (isalpha(*ptr))					\
			digit = tolower(*ptr) - 'a' + 10;		\
		else							\
			break;						\
									\
		if (digit >= base)					\
			break;						\
									\
		last_value = value;					\
		value = value * base + digit;				\
		if (last_value > value) /* Overflow */			\
			return ERANGE;					\
									\
		flag = 1;						\
		ptr++;							\
	}								\
									\
	if (flag)							\
		*result = value;					\
									\
	if (endptr)							\
		*endptr = (char *)(flag ? ptr : str);			\
									\
	return 0;							\
}									\

#define define_ddi_strtox(type, valtype)				\
int ddi_strto##type(const char *str, char **endptr,			\
		       int base, valtype *result)			\
{									\
	int rc;								\
									\
	if (*str == '-') {						\
		rc = ddi_strtou##type(str + 1, endptr, base, result);	\
		if (!rc) {						\
			if (*endptr == str + 1)				\
				*endptr = (char *)str;			\
			else						\
				*result = -*result;			\
		}							\
	} else {							\
		rc = ddi_strtou##type(str, endptr, base, result);	\
	}								\
									\
	return rc;							\
}

define_ddi_strtoux(l, unsigned long)
define_ddi_strtox(l, long)
define_ddi_strtoux(ll, unsigned long long)
define_ddi_strtox(ll, long long)

EXPORT_SYMBOL(ddi_strtoul);
EXPORT_SYMBOL(ddi_strtol);
EXPORT_SYMBOL(ddi_strtoll);
EXPORT_SYMBOL(ddi_strtoull);

struct new_utsname *__utsname(void)
{
#ifdef HAVE_INIT_UTSNAME
	return init_utsname();
#else
	return &system_utsname;
#endif
}
EXPORT_SYMBOL(__utsname);

static int
set_hostid(void)
{
	char sh_path[] = "/bin/sh";
	char *argv[] = { sh_path,
	                 "-c",
	                 "/usr/bin/hostid >/proc/sys/kernel/spl/hostid",
	                 NULL };
	char *envp[] = { "HOME=/",
	                 "TERM=linux",
	                 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
	                 NULL };

	/* Doing address resolution in the kernel is tricky and just
	 * not a good idea in general.  So to set the proper 'hw_serial'
	 * use the usermodehelper support to ask '/bin/sh' to run
	 * '/usr/bin/hostid' and redirect the result to /proc/sys/spl/hostid
	 * for us to use.  It's a horific solution but it will do for now.
	 */
	return call_usermodehelper(sh_path, argv, envp, 1);
}

uint32_t
zone_get_hostid(void *zone)
{
	unsigned long hostid;

	/* Only the global zone is supported */
	ASSERT(zone == NULL);

	if (ddi_strtoul(hw_serial, NULL, HW_HOSTID_LEN-1, &hostid) != 0)
		return HW_INVALID_HOSTID;

	return (uint32_t)hostid;
}
EXPORT_SYMBOL(zone_get_hostid);

#ifdef HAVE_KALLSYMS_LOOKUP_NAME
#define set_kallsyms_lookup_name()	(0)
#else
/*
 * Because kallsyms_lookup_name() is no longer exported in the
 * mainline kernel we are forced to resort to somewhat drastic
 * measures.  This function replaces the functionality by performing
 * an upcall to user space where /proc/kallsyms is consulted for
 * the requested address.
 */
#define GET_KALLSYMS_ADDR_CMD						\
	"awk '{ if ( $3 == \"kallsyms_lookup_name\") { print $1 } }' "	\
	"/proc/kallsyms >/proc/sys/kernel/spl/kallsyms_lookup_name"

static int
set_kallsyms_lookup_name(void)
{
	char sh_path[] = "/bin/sh";
	char *argv[] = { sh_path,
	                 "-c",
			 GET_KALLSYMS_ADDR_CMD,
	                 NULL };
	char *envp[] = { "HOME=/",
	                 "TERM=linux",
	                 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
	                 NULL };
	int rc;

	rc = call_usermodehelper(sh_path, argv, envp, 1);
	if (rc)
		return rc;

	return spl_kmem_init_kallsyms_lookup();
}
#endif

static int __init spl_init(void)
{
	int rc = 0;

	if ((rc = debug_init()))
		return rc;

	if ((rc = spl_kmem_init()))
		GOTO(out , rc);

	if ((rc = spl_mutex_init()))
		GOTO(out2 , rc);

	if ((rc = spl_taskq_init()))
		GOTO(out3, rc);

	if ((rc = vn_init()))
		GOTO(out4, rc);

	if ((rc = proc_init()))
		GOTO(out5, rc);

	if ((rc = kstat_init()))
		GOTO(out6, rc);

	if ((rc = set_hostid()))
		GOTO(out7, rc = -EADDRNOTAVAIL);

	if ((rc = set_kallsyms_lookup_name()))
		GOTO(out7, rc = -EADDRNOTAVAIL);

	printk("SPL: Loaded Solaris Porting Layer v%s\n", SPL_META_VERSION);
	RETURN(rc);
out7:
	kstat_fini();
out6:
	proc_fini();
out5:
	vn_fini();
out4:
	spl_taskq_fini();
out3:
	spl_mutex_fini();
out2:
	spl_kmem_fini();
out:
	debug_fini();

	printk("SPL: Failed to Load Solaris Porting Layer v%s, "
	       "rc = %d\n", SPL_META_VERSION, rc);
	return rc;
}

static void spl_fini(void)
{
	ENTRY;

	printk("SPL: Unloaded Solaris Porting Layer v%s\n", SPL_META_VERSION);
	kstat_fini();
	proc_fini();
	vn_fini();
	spl_taskq_fini();
	spl_mutex_fini();
	spl_kmem_fini();
	debug_fini();
}

module_init(spl_init);
module_exit(spl_fini);

MODULE_AUTHOR("Lawrence Livermore National Labs");
MODULE_DESCRIPTION("Solaris Porting Layer");
MODULE_LICENSE("GPL");
Commit	Line	Data
715f6251	1	/*
	2	* This file is part of the SPL: Solaris Porting Layer.
	3	*
	4	* Copyright (c) 2008 Lawrence Livermore National Security, LLC.
	5	* Produced at Lawrence Livermore National Laboratory
	6	* Written by:
	7	* Brian Behlendorf <behlendorf1@llnl.gov>,
	8	* Herb Wartens <wartens2@llnl.gov>,
	9	* Jim Garlick <garlick@llnl.gov>
	10	* UCRL-CODE-235197
	11	*
	12	* This is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This is distributed in the hope that it will be useful, but WITHOUT
	18	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	19	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	20	* for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License along
	23	* with this program; if not, write to the Free Software Foundation, Inc.,
	24	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	25	*/
	26
14c5326c	27	#include <sys/sysmacros.h>
99639e4a	28	#include <sys/systeminfo.h>
af828292	29	#include <sys/vmsystm.h>
af828292	30	#include <sys/vnode.h>
c19c06f3	31	#include <sys/kmem.h>
9ab1ac14	32	#include <sys/mutex.h>
e9cb2b4f	33	#include <sys/taskq.h>
8d0f1ee9	34	#include <sys/debug.h>
57d1b188	35	#include <sys/proc.h>
04a479f7	36	#include <sys/kstat.h>
691d2bd7	37	#include <sys/utsname.h>
f23e92fa	38	#include <linux/kmod.h>
f1b59d26	39
57d1b188	40	#ifdef DEBUG_SUBSYSTEM
	41	#undef DEBUG_SUBSYSTEM
	42	#endif
8d0f1ee9	43
57d1b188	44	#define DEBUG_SUBSYSTEM S_GENERIC
f23e92fa	45
0cbaeb11	46	char spl_version[16] = "SPL v" SPL_META_VERSION;
3561541c	47
937879f1	48	long spl_hostid = 0;
f23e92fa	49	EXPORT_SYMBOL(spl_hostid);
8d0f1ee9	50
99639e4a	51	char hw_serial[HW_HOSTID_LEN] = "<none>";
937879f1	52	EXPORT_SYMBOL(hw_serial);
f1b59d26	53
	54	int p0 = 0;
	55	EXPORT_SYMBOL(p0);
70eadc19	56
d1ff2312 BB	57	#ifndef HAVE_KALLSYMS_LOOKUP_NAME
	58	kallsyms_lookup_name_t spl_kallsyms_lookup_name_fn = NULL;
	59	#endif
	60
77b1fe8f	61	int
	62	highbit(unsigned long i)
	63	{
	64	register int h = 1;
3d061e9d	65	ENTRY;
77b1fe8f	66
77b1fe8f	67	if (i == 0)
57d1b188	68	RETURN(0);
77b1fe8f	69	#if BITS_PER_LONG == 64
	70	if (i & 0xffffffff00000000ul) {
	71	h += 32; i >>= 32;
	72	}
	73	#endif
	74	if (i & 0xffff0000) {
	75	h += 16; i >>= 16;
	76	}
	77	if (i & 0xff00) {
	78	h += 8; i >>= 8;
	79	}
	80	if (i & 0xf0) {
	81	h += 4; i >>= 4;
	82	}
	83	if (i & 0xc) {
	84	h += 2; i >>= 2;
	85	}
	86	if (i & 0x2) {
	87	h += 1;
	88	}
57d1b188	89	RETURN(h);
77b1fe8f	90	}
	91	EXPORT_SYMBOL(highbit);
	92
b61a6e8b	93	/*
550f1705	94	* Implementation of 64 bit division for 32-bit machines.
b61a6e8b	95	*/
550f1705	96	#if BITS_PER_LONG == 32
550f1705	97	uint64_t __udivdi3(uint64_t dividend, uint64_t divisor)
b61a6e8b	98	{
550f1705	99	#ifdef HAVE_DIV64_64
	100	return div64_64(dividend, divisor);
	101	#else
	102	/* Taken from a 2.6.24 kernel. */
b61a6e8b	103	uint32_t high, d;
	104
	105	high = divisor >> 32;
	106	if (high) {
	107	unsigned int shift = fls(high);
	108
	109	d = divisor >> shift;
	110	dividend >>= shift;
	111	} else
	112	d = divisor;
	113
	114	do_div(dividend, d);
	115
	116	return dividend;
550f1705	117	#endif
	118	}
	119	EXPORT_SYMBOL(__udivdi3);
	120
	121	/*
	122	* Implementation of 64 bit modulo for 32-bit machines.
	123	*/
	124	uint64_t __umoddi3(uint64_t dividend, uint64_t divisor)
	125	{
	126	return dividend - divisor * (dividend / divisor);
b61a6e8b	127	}
550f1705	128	EXPORT_SYMBOL(__umoddi3);
550f1705	129	#endif
b61a6e8b	130
b871b8cd BB	131	/* NOTE: The strtoxx behavior is solely based on my reading of the Solaris
	132	* ddi_strtol(9F) man page. I have not verified the behavior of these
	133	* functions against their Solaris counterparts. It is possible that I
	134	* may have misinterpretted the man page or the man page is incorrect.
	135	*/
2ee63a54 BB	136	int ddi_strtoul(const char , char , int, unsigned long );
	137	int ddi_strtol(const char , char , int, long );
	138	int ddi_strtoull(const char , char , int, unsigned long long );
	139	int ddi_strtoll(const char , char , int, long long );
	140
	141	#define define_ddi_strtoux(type, valtype) \
	142	int ddi_strtou##type(const char str, char *endptr, \
b871b8cd	143	int base, valtype *result) \
2ee63a54	144	{ \
b871b8cd BB	145	valtype last_value, value = 0; \
	146	char ptr = (char )str; \
	147	int flag = 1, digit; \
	148	\
	149	if (strlen(ptr) == 0) \
	150	return EINVAL; \
	151	\
	152	/* Auto-detect base based on prefix */ \
	153	if (!base) { \
	154	if (str[0] == '0') { \
	155	if (tolower(str[1])=='x' && isxdigit(str[2])) { \
	156	base = 16; /* hex */ \
	157	ptr += 2; \
	158	} else if (str[1] >= '0' && str[1] < 8) { \
	159	base = 8; /* octal */ \
	160	ptr += 1; \
	161	} else { \
	162	return EINVAL; \
	163	} \
	164	} else { \
	165	base = 10; /* decimal */ \
	166	} \
	167	} \
	168	\
	169	while (1) { \
	170	if (isdigit(*ptr)) \
	171	digit = *ptr - '0'; \
	172	else if (isalpha(*ptr)) \
	173	digit = tolower(*ptr) - 'a' + 10; \
	174	else \
	175	break; \
	176	\
	177	if (digit >= base) \
	178	break; \
2ee63a54	179	\
b871b8cd BB	180	last_value = value; \
	181	value = value * base + digit; \
	182	if (last_value > value) /* Overflow */ \
	183	return ERANGE; \
2ee63a54	184	\
b871b8cd BB	185	flag = 1; \
b871b8cd BB	186	ptr++; \
2ee63a54 BB	187	} \
2ee63a54 BB	188	\
b871b8cd BB	189	if (flag) \
	190	*result = value; \
	191	\
	192	if (endptr) \
	193	endptr = (char )(flag ? ptr : str); \
	194	\
	195	return 0; \
2ee63a54 BB	196	} \
	197
	198	#define define_ddi_strtox(type, valtype) \
	199	int ddi_strto##type(const char str, char *endptr, \
	200	int base, valtype *result) \
b871b8cd BB	201	{ \
b871b8cd BB	202	int rc; \
2ee63a54 BB	203	\
2ee63a54 BB	204	if (*str == '-') { \
b871b8cd BB	205	rc = ddi_strtou##type(str + 1, endptr, base, result); \
	206	if (!rc) { \
	207	if (*endptr == str + 1) \
	208	endptr = (char )str; \
	209	else \
	210	result = -result; \
	211	} \
2ee63a54	212	} else { \
b871b8cd	213	rc = ddi_strtou##type(str, endptr, base, result); \
2ee63a54 BB	214	} \
2ee63a54 BB	215	\
b871b8cd BB	216	return rc; \
b871b8cd BB	217	}
2ee63a54 BB	218
	219	define_ddi_strtoux(l, unsigned long)
	220	define_ddi_strtox(l, long)
	221	define_ddi_strtoux(ll, unsigned long long)
	222	define_ddi_strtox(ll, long long)
	223
2f5d55aa	224	EXPORT_SYMBOL(ddi_strtoul);
2ee63a54 BB	225	EXPORT_SYMBOL(ddi_strtol);
	226	EXPORT_SYMBOL(ddi_strtoll);
	227	EXPORT_SYMBOL(ddi_strtoull);
2f5d55aa	228
691d2bd7	229	struct new_utsname *__utsname(void)
691d2bd7	230	{
3d061e9d	231	#ifdef HAVE_INIT_UTSNAME
691d2bd7	232	return init_utsname();
3d061e9d	233	#else
	234	return &system_utsname;
	235	#endif
691d2bd7	236	}
	237	EXPORT_SYMBOL(__utsname);
	238
8d0f1ee9	239	static int
57d1b188	240	set_hostid(void)
8d0f1ee9	241	{
f23e92fa	242	char sh_path[] = "/bin/sh";
	243	char *argv[] = { sh_path,
	244	"-c",
57d86234	245	"/usr/bin/hostid >/proc/sys/kernel/spl/hostid",
f23e92fa	246	NULL };
	247	char *envp[] = { "HOME=/",
	248	"TERM=linux",
	249	"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
	250	NULL };
8d0f1ee9	251
57d1b188	252	/* Doing address resolution in the kernel is tricky and just
937879f1	253	* not a good idea in general. So to set the proper 'hw_serial'
57d1b188	254	* use the usermodehelper support to ask '/bin/sh' to run
	255	* '/usr/bin/hostid' and redirect the result to /proc/sys/spl/hostid
	256	* for us to use. It's a horific solution but it will do for now.
	257	*/
	258	return call_usermodehelper(sh_path, argv, envp, 1);
	259	}
8d0f1ee9	260
99639e4a BB	261	uint32_t
	262	zone_get_hostid(void *zone)
	263	{
	264	unsigned long hostid;
	265
	266	/* Only the global zone is supported */
	267	ASSERT(zone == NULL);
	268
	269	if (ddi_strtoul(hw_serial, NULL, HW_HOSTID_LEN-1, &hostid) != 0)
	270	return HW_INVALID_HOSTID;
	271
	272	return (uint32_t)hostid;
	273	}
	274	EXPORT_SYMBOL(zone_get_hostid);
	275
d1ff2312 BB	276	#ifdef HAVE_KALLSYMS_LOOKUP_NAME
	277	#define set_kallsyms_lookup_name() (0)
	278	#else
	279	/*
	280	* Because kallsyms_lookup_name() is no longer exported in the
	281	* mainline kernel we are forced to resort to somewhat drastic
	282	* measures. This function replaces the functionality by performing
	283	* an upcall to user space where /proc/kallsyms is consulted for
	284	* the requested address.
	285	*/
	286	#define GET_KALLSYMS_ADDR_CMD \
	287	"awk '{ if ( $3 == \"kallsyms_lookup_name\") { print $1 } }' " \
	288	"/proc/kallsyms >/proc/sys/kernel/spl/kallsyms_lookup_name"
	289
	290	static int
	291	set_kallsyms_lookup_name(void)
	292	{
	293	char sh_path[] = "/bin/sh";
	294	char *argv[] = { sh_path,
	295	"-c",
	296	GET_KALLSYMS_ADDR_CMD,
	297	NULL };
	298	char *envp[] = { "HOME=/",
	299	"TERM=linux",
	300	"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
	301	NULL };
	302	int rc;
	303
	304	rc = call_usermodehelper(sh_path, argv, envp, 1);
	305	if (rc)
	306	return rc;
	307
	308	return spl_kmem_init_kallsyms_lookup();
	309	}
	310	#endif
	311
57d1b188	312	static int __init spl_init(void)
	313	{
	314	int rc = 0;
f23e92fa	315
57d1b188	316	if ((rc = debug_init()))
18c9eadf	317	return rc;
f23e92fa	318
2fb9b26a	319	if ((rc = spl_kmem_init()))
57d1b188	320	GOTO(out , rc);
8d0f1ee9	321
9ab1ac14	322	if ((rc = spl_mutex_init()))
	323	GOTO(out2 , rc);
	324
e9cb2b4f	325	if ((rc = spl_taskq_init()))
9ab1ac14	326	GOTO(out3, rc);
8d0f1ee9	327
e9cb2b4f	328	if ((rc = vn_init()))
9ab1ac14	329	GOTO(out4, rc);
af828292	330
e9cb2b4f	331	if ((rc = proc_init()))
04a479f7	332	GOTO(out5, rc);
04a479f7	333
e9cb2b4f BB	334	if ((rc = kstat_init()))
	335	GOTO(out6, rc);
	336
57d1b188	337	if ((rc = set_hostid()))
e9cb2b4f	338	GOTO(out7, rc = -EADDRNOTAVAIL);
f23e92fa	339
d1ff2312 BB	340	if ((rc = set_kallsyms_lookup_name()))
	341	GOTO(out7, rc = -EADDRNOTAVAIL);
	342
0cbaeb11	343	printk("SPL: Loaded Solaris Porting Layer v%s\n", SPL_META_VERSION);
57d1b188	344	RETURN(rc);
e9cb2b4f	345	out7:
04a479f7	346	kstat_fini();
e9cb2b4f	347	out6:
57d1b188	348	proc_fini();
e9cb2b4f	349	out5:
57d1b188	350	vn_fini();
e9cb2b4f BB	351	out4:
e9cb2b4f BB	352	spl_taskq_fini();
9ab1ac14	353	out3:
9ab1ac14	354	spl_mutex_fini();
8d0f1ee9	355	out2:
2fb9b26a	356	spl_kmem_fini();
8d0f1ee9	357	out:
57d1b188	358	debug_fini();
8d0f1ee9	359
57d1b188	360	printk("SPL: Failed to Load Solaris Porting Layer v%s, "
0cbaeb11	361	"rc = %d\n", SPL_META_VERSION, rc);
18c9eadf	362	return rc;
70eadc19	363	}
	364
	365	static void spl_fini(void)
	366	{
57d1b188	367	ENTRY;
57d1b188	368
0cbaeb11	369	printk("SPL: Unloaded Solaris Porting Layer v%s\n", SPL_META_VERSION);
04a479f7	370	kstat_fini();
57d1b188	371	proc_fini();
af828292	372	vn_fini();
e9cb2b4f	373	spl_taskq_fini();
2fb9b26a	374	spl_mutex_fini();
2fb9b26a	375	spl_kmem_fini();
57d1b188	376	debug_fini();
70eadc19	377	}
	378
	379	module_init(spl_init);
	380	module_exit(spl_fini);
	381
	382	MODULE_AUTHOR("Lawrence Livermore National Labs");
	383	MODULE_DESCRIPTION("Solaris Porting Layer");
	384	MODULE_LICENSE("GPL");