 @@ -1,1239 +1,1239 @@
-/*	$NetBSD: kern_module.c,v 1.48 2009/06/09 20:35:02 jnemeth Exp $	*/
+/*	$NetBSD: kern_module.c,v 1.49 2009/06/17 21:04:25 dyoung Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software developed for The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Kernel module support.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_module.c,v 1.48 2009/06/09 20:35:02 jnemeth Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_module.c,v 1.49 2009/06/17 21:04:25 dyoung Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_modular.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/fcntl.h>
 #include <sys/proc.h>
 #include <sys/kauth.h>
 #include <sys/kobj.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <sys/kauth.h>
 #include <sys/kthread.h>
 #include <sys/sysctl.h>
 #include <sys/namei.h>
 #include <sys/lock.h>
 #include <sys/vnode.h>
 #include <sys/stat.h>
 #include <uvm/uvm_extern.h>
 #include <machine/stdarg.h>
 struct vm_map *module_map;
 struct modlist	module_list = TAILQ_HEAD_INITIALIZER(module_list);
 struct modlist	module_bootlist = TAILQ_HEAD_INITIALIZER(module_bootlist);
 static module_t	*module_active;
 static char	module_base[64];
 static int	module_verbose_on;
 static int	module_autoload_on = 1;
 u_int		module_count;
 kmutex_t	module_lock;
 u_int		module_autotime = 10;
 u_int		module_gen = 1;
 static kcondvar_t module_thread_cv;
 static kmutex_t module_thread_lock;
 static int	module_thread_ticks;
 /* Ensure that the kernel's link set isn't empty. */
 static modinfo_t module_dummy;
 __link_set_add_rodata(modules, module_dummy);
 static module_t	*module_lookup(const char *);
 static int	module_do_load(const char *, bool, int, prop_dictionary_t,
 		    module_t **, modclass_t class, bool);
 static int	module_do_unload(const char *);
 static void	module_error(const char *, ...)
 			__attribute__((__format__(__printf__,1,2)));
 static void	module_print(const char *, ...)
 			__attribute__((__format__(__printf__,1,2)));
 static int	module_do_builtin(const char *, module_t **);
 static int	module_fetch_info(module_t *);
 static void	module_thread(void *);
 static int	module_load_plist_file(const char *, const bool, void **,
 		    size_t *);
 static bool	module_merge_dicts(prop_dictionary_t, const prop_dictionary_t);
 /*
  * module_error:
+ *
  *	Utility function: log an error.
  */
 static void
 module_error(const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	printf("WARNING: module error: ");
 	vprintf(fmt, ap);
 	printf("\n");
 	va_end(ap);
+}
 /*
  * module_print:
+ *
  *	Utility function: log verbose output.
  */
 static void
 module_print(const char *fmt, ...)
+{
 	va_list ap;
 	if (module_verbose_on) {
 		va_start(ap, fmt);
 		printf("DEBUG: module: ");
 		vprintf(fmt, ap);
 		printf("\n");
 		va_end(ap);
+	}
+}
 /*
  * module_init:
+ *
  *	Initialize the module subsystem.
  */
 void
 module_init(void)
+{
 	extern struct vm_map *module_map;
 	int error;
 	if (module_map == NULL) {
 		module_map = kernel_map;
+	}
 	mutex_init(&module_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&module_thread_cv, "modunload");
 	mutex_init(&module_thread_lock, MUTEX_DEFAULT, IPL_NONE);
 #ifdef MODULAR	/* XXX */
 	module_init_md();
 #endif
 #if __NetBSD_Version__ / 1000000 % 100 == 99	/* -current */
 	snprintf(module_base, sizeof(module_base), "/stand/%s/%s/modules",
 	    machine, osrelease);
 #else						/* release */
 	snprintf(module_base, sizeof(module_base), "/stand/%s/%d.%d/modules",
 	    machine, __NetBSD_Version__ / 100000000,
 	    __NetBSD_Version__ / 1000000 % 100);
 #endif
 	error = kthread_create(PRI_VM, KTHREAD_MPSAFE, NULL, module_thread,
 	    NULL, NULL, "modunload");
 	if (error != 0)
 		panic("module_init: %d", error);
+}
 SYSCTL_SETUP(sysctl_module_setup, "sysctl module setup")
+{
 	const struct sysctlnode *node = NULL;
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_NODE, "kern", NULL,
 		NULL, 0, NULL, 0,
 		CTL_KERN, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, &node,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_NODE, "module",
 		SYSCTL_DESCR("Module options"),
 		NULL, 0, NULL, 0,
 		CTL_KERN, CTL_CREATE, CTL_EOL);
 	if (node == NULL)
 		return;
 	sysctl_createv(clog, 0, &node, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_INT, "autoload",
 		SYSCTL_DESCR("Enable automatic load of modules"),
 		NULL, 0, &module_autoload_on, 0,
 		CTL_CREATE, CTL_EOL);
 	sysctl_createv(clog, 0, &node, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_INT, "verbose",
 		SYSCTL_DESCR("Enable verbose output"),
 		NULL, 0, &module_verbose_on, 0,
 		CTL_CREATE, CTL_EOL);
+}
 /*
  * module_init_class:
+ *
  *	Initialize all built-in and pre-loaded modules of the
  *	specified class.
  */
 void
 module_init_class(modclass_t class)
+{
 	__link_set_decl(modules, modinfo_t);
 	modinfo_t *const *mip, *mi;
 	module_t *mod;
 	mutex_enter(&module_lock);
 	/*
 	 * Builtins first.  These can't depend on pre-loaded modules.
 	 */
 	__link_set_foreach(mip, modules) {
 		mi = *mip;
 		if (mi == &module_dummy) {
 			continue;
+		}
 		if (class != MODULE_CLASS_ANY && class != mi->mi_class) {
 			continue;
+		}
 		(void)module_do_builtin(mi->mi_name, NULL);
+	}
 	/*
 	 * Now preloaded modules.  These will be pulled off the
 	 * list as we call module_do_load();
 	 */
 	do {
 		TAILQ_FOREACH(mod, &module_bootlist, mod_chain) {
 			mi = mod->mod_info;
 			if (class != MODULE_CLASS_ANY &&
 			    class != mi->mi_class)
 				continue;
 			module_do_load(mi->mi_name, false, 0, NULL, NULL,
 			    class, false);
 			break;
+		}
 	} while (mod != NULL);
 	mutex_exit(&module_lock);
+}
 /*
  * module_compatible:
+ *
  *	Return true if the two supplied kernel versions are said to
  *	have the same binary interface for kernel code.  The entire
  *	version is signficant for the development tree (-current),
  *	major and minor versions are significant for official
  *	releases of the system.
  */
 bool
 module_compatible(int v1, int v2)
+{
 #if __NetBSD_Version__ / 1000000 % 100 == 99	/* -current */
 	return v1 == v2;
 #else						/* release */
 	return abs(v1 - v2) < 10000;
 #endif
+}
 /*
  * module_load:
+ *
  *	Load a single module from the file system.
  */
 int
 module_load(const char *filename, int flags, prop_dictionary_t props,
 	    modclass_t class)
+{
 	int error;
 	/* Authorize. */
 	error = kauth_authorize_system(kauth_cred_get(), KAUTH_SYSTEM_MODULE,
 , (void *)(uintptr_t)MODCTL_LOAD, NULL, NULL);
 	if (error != 0) {
 		return error;
+	}
 	mutex_enter(&module_lock);
 	error = module_do_load(filename, false, flags, props, NULL, class,
 	    false);
 	mutex_exit(&module_lock);
 	return error;
+}
 /*
  * module_autoload:
+ *
  *	Load a single module from the file system, system initiated.
  */
 int
 module_autoload(const char *filename, modclass_t class)
+{
 	int error;
 	KASSERT(mutex_owned(&module_lock));
 	/* Nothing if the user has disabled it. */
 	if (!module_autoload_on) {
 		return EPERM;
+	}
         /* Disallow path seperators and magic symlinks. */
         if (strchr(filename, '/') != NULL || strchr(filename, '@') != NULL ||
             strchr(filename, '.') != NULL) {
         	return EPERM;
+	}
 	/* Authorize. */
 	error = kauth_authorize_system(kauth_cred_get(), KAUTH_SYSTEM_MODULE,
 , (void *)(uintptr_t)MODCTL_LOAD, (void *)(uintptr_t)1, NULL);
 	if (error != 0) {
 		return error;
+	}
 	return module_do_load(filename, false, 0, NULL, NULL, class, true);
+}
 /*
  * module_unload:
+ *
  *	Find and unload a module by name.
  */
 int
 module_unload(const char *name)
+{
 	int error;
 	/* Authorize. */
 	error = kauth_authorize_system(kauth_cred_get(), KAUTH_SYSTEM_MODULE,
 , (void *)(uintptr_t)MODCTL_UNLOAD, NULL, NULL);
 	if (error != 0) {
 		return error;
+	}
 	mutex_enter(&module_lock);
 	error = module_do_unload(name);
 	mutex_exit(&module_lock);
 	return error;
+}
 /*
  * module_lookup:
+ *
  *	Look up a module by name.
  */
 module_t *
 module_lookup(const char *name)
+{
 	module_t *mod;
 	KASSERT(mutex_owned(&module_lock));
 	TAILQ_FOREACH(mod, &module_list, mod_chain) {
 		if (strcmp(mod->mod_info->mi_name, name) == 0) {
 			break;
+		}
+	}
 	return mod;
+}
 /*
  * module_hold:
+ *
  *	Add a single reference to a module.  It's the caller's
  *	responsibility to ensure that the reference is dropped
  *	later.
  */
 int
 module_hold(const char *name)
+{
 	module_t *mod;
 	mutex_enter(&module_lock);
 	mod = module_lookup(name);
 	if (mod == NULL) {
 		mutex_exit(&module_lock);
 		return ENOENT;
+	}
 	mod->mod_refcnt++;
 	mutex_exit(&module_lock);
 	return 0;
+}
 /*
  * module_rele:
+ *
  *	Release a reference acquired with module_hold().
  */
 void
 module_rele(const char *name)
+{
 	module_t *mod;
 	mutex_enter(&module_lock);
 	mod = module_lookup(name);
 	if (mod == NULL) {
 		mutex_exit(&module_lock);
 		panic("module_rele: gone");
+	}
 	mod->mod_refcnt--;
 	mutex_exit(&module_lock);
+}
 /*
  * module_enqueue:
+ *
  *	Put a module onto the global list and update counters.
  */
 static void
 module_enqueue(module_t *mod)
+{
 	int i;
 	/*
 	 * If there are requisite modules, put at the head of the queue.
 	 * This is so that autounload can unload requisite modules with
 	 * only one pass through the queue.
 	 */
 	if (mod->mod_nrequired) {
 		TAILQ_INSERT_HEAD(&module_list, mod, mod_chain);
 		/* Add references to the requisite modules. */
 		for (i = 0; i < mod->mod_nrequired; i++) {
 			KASSERT(mod->mod_required[i] != NULL);
 			mod->mod_required[i]->mod_refcnt++;
+		}
 	} else {
 		TAILQ_INSERT_TAIL(&module_list, mod, mod_chain);
+	}
 	module_count++;
 	module_gen++;
+}
 /*
  * module_do_builtin:
+ *
  *	Initialize a single module from the list of modules that are
  *	built into the kernel (linked into the kernel image).
  */
 static int
 module_do_builtin(const char *name, module_t **modp)
+{
 	__link_set_decl(modules, modinfo_t);
 	modinfo_t *const *mip;
 	const char *p, *s;
 	char buf[MAXMODNAME];
 	modinfo_t *mi;
 	module_t *mod, *mod2;
 	size_t len;
 	int error;
 	KASSERT(mutex_owned(&module_lock));
 	/*
 	 * Check to see if already loaded.
 	 */
 	if ((mod = module_lookup(name)) != NULL) {
 		if (modp != NULL) {
 			*modp = mod;
+		}
 		return 0;
+	}
 	/*
 	 * Search the list to see if we have a module by this name.
 	 */
 	error = ENOENT;
 	__link_set_foreach(mip, modules) {
 		mi = *mip;
 		if (mi == &module_dummy) {
 			continue;
+		}
 		if (strcmp(mi->mi_name, name) == 0) {
 			error = 0;
 			break;
+		}
+	}
 	if (error != 0) {
 		module_error("can't find `%s'", name);
 		return error;
+	}
 	/*
 	 * Initialize pre-requisites.
 	 */
 	mod = kmem_zalloc(sizeof(*mod), KM_SLEEP);
 	if (mod == NULL) {
 		module_error("out of memory for `%s'", name);
 		return ENOMEM;
+	}
 	if (modp != NULL) {
 		*modp = mod;
+	}
 	if (mi->mi_required != NULL) {
 		for (s = mi->mi_required; *s != '\0'; s = p) {
 			if (*s == ',')
 				s++;
 			p = s;
 			while (*p != '\0' && *p != ',')
 				p++;
 			len = min(p - s + 1, sizeof(buf));
 			strlcpy(buf, s, len);
 			if (buf[0] == '\0')
 				break;
 			if (mod->mod_nrequired == MAXMODDEPS - 1) {
 				module_error("too many required modules");
 				kmem_free(mod, sizeof(*mod));
 				return EINVAL;
+			}
 			error = module_do_builtin(buf, &mod2);
 			if (error != 0) {
 				kmem_free(mod, sizeof(*mod));
 				return error;
+			}
 			mod->mod_required[mod->mod_nrequired++] = mod2;
+		}
+	}
 	/*
 	 * Try to initialize the module.
 	 */
 	KASSERT(module_active == NULL);
 	module_active = mod;
 	error = (*mi->mi_modcmd)(MODULE_CMD_INIT, NULL);
 	module_active = NULL;
 	if (error != 0) {
 		module_error("builtin module `%s' "
 		    "failed to init", mi->mi_name);
 		kmem_free(mod, sizeof(*mod));
 		return error;
+	}
 	mod->mod_info = mi;
 	mod->mod_source = MODULE_SOURCE_KERNEL;
 	module_enqueue(mod);
 	return 0;
+}
 /*
  * module_do_load:
+ *
  *	Helper routine: load a module from the file system, or one
  *	pushed by the boot loader.
  */
 static int
 module_do_load(const char *name, bool isdep, int flags,
 	       prop_dictionary_t props, module_t **modp, modclass_t class,
 	       bool autoload)
+{
 	static TAILQ_HEAD(,module) pending = TAILQ_HEAD_INITIALIZER(pending);
 	static int depth;
 	const int maxdepth = 6;
 	modinfo_t *mi;
 	module_t *mod, *mod2;
 	prop_dictionary_t filedict;
 	void *plist;
 	char buf[MAXMODNAME], *path;
 	const char *s, *p;
 	int error;
 	size_t len, plistlen;
 	bool nochroot;
 	KASSERT(mutex_owned(&module_lock));
 	filedict = NULL;
 	path = NULL;
 	error = 0;
 	nochroot = false;
 	/*
 	 * Avoid recursing too far.
 	 */
 	if (++depth > maxdepth) {
 		module_error("too many required modules");
 		depth--;
 		return EMLINK;
+	}
 	/*
 	 * Load the module and link.  Before going to the file system,
 	 * scan the list of modules loaded by the boot loader.  Just
 	 * before init is started the list of modules loaded at boot
 	 * will be purged.  Before init is started we can assume that
 	 * `name' is a module name and not a path name.
 	 */
 	TAILQ_FOREACH(mod, &module_bootlist, mod_chain) {
 		if (strcmp(mod->mod_info->mi_name, name) == 0) {
 			TAILQ_REMOVE(&module_bootlist, mod, mod_chain);
 			break;
+		}
+	}
 	if (mod != NULL) {
 		TAILQ_INSERT_TAIL(&pending, mod, mod_chain);
 	} else {
 		/*
 		 * If a requisite module, check to see if it is
 		 * already present.
 		 */
 		if (isdep) {
 			TAILQ_FOREACH(mod, &module_list, mod_chain) {
 				if (strcmp(mod->mod_info->mi_name, name) == 0) {
 					break;
+				}
+			}
 			if (mod != NULL) {
 				if (modp != NULL) {
 					*modp = mod;
+				}
 				depth--;
 				return 0;
+			}
+		}
 		mod = kmem_zalloc(sizeof(*mod), KM_SLEEP);
 		if (mod == NULL) {
 			module_error("out of memory for `%s'", name);
 			depth--;
 			return ENOMEM;
+		}
 		path = PNBUF_GET();
 		if (!autoload) {
 			nochroot = false;
 			snprintf(path, MAXPATHLEN, "%s", name);
 			error = kobj_load_file(&mod->mod_kobj, path, nochroot);
+		}
 		if (autoload || (error == ENOENT)) {
 			nochroot = true;
 			snprintf(path, MAXPATHLEN, "%s/%s/%s.kmod",
 			    module_base, name, name);
 			error = kobj_load_file(&mod->mod_kobj, path, nochroot);
+		}
 		if (error != 0) {
 			kmem_free(mod, sizeof(*mod));
 			depth--;
 			PNBUF_PUT(path);
 			if (autoload) {
 				module_print("Cannot load kernel object `%s'"
 				    " error=%d", name, error);
 			} else {
 				module_error("Cannot load kernel object `%s'"
 				    " error=%d", name, error);
+			}
 			return error;
+		}
 		TAILQ_INSERT_TAIL(&pending, mod, mod_chain);
 		mod->mod_source = MODULE_SOURCE_FILESYS;
 		error = module_fetch_info(mod);
 		if (error != 0) {
 			module_error("cannot fetch module info for `%s'",
 			    name);
 			goto fail;
+		}
+	}
 	/*
 	 * Check compatibility.
 	 */
 	mi = mod->mod_info;
 	if (strlen(mi->mi_name) >= MAXMODNAME) {
 		error = EINVAL;
 		module_error("module name `%s' too long", mi->mi_name);
 		goto fail;
+	}
 	if (!module_compatible(mi->mi_version, __NetBSD_Version__)) {
 		module_error("module built for `%d', system `%d'",
 		    mi->mi_version, __NetBSD_Version__);
 		if ((flags & MODCTL_LOAD_FORCE) != 0) {
 			module_error("forced load, system may be unstable");
 		} else {
 			error = EPROGMISMATCH;
 			goto fail;
+		}
+	}
 	/*
 	 * If a specific kind of module was requested, ensure that we have
 	 * a match.
 	 */
 	if (class != MODULE_CLASS_ANY && class != mi->mi_class) {
 		module_print("incompatible module class for `%s' (%d != %d)",
 		    name, class, mi->mi_class);
 		error = ENOENT;
 		goto fail;
+	}
 	/*
 	 * If loading a dependency, `name' is a plain module name.
 	 * The name must match.
 	 */
 	if (isdep && strcmp(mi->mi_name, name) != 0) {
 		module_error("dependency name mismatch (`%s' != `%s')",
 		    name, mi->mi_name);
 		error = ENOENT;
 		goto fail;
+	}
 	/*
 	 * Check to see if the module is already loaded.  If so, we may
 	 * have been recursively called to handle a dependency, so be sure
 	 * to set modp.
 	 */
 	if ((mod2 = module_lookup(mi->mi_name)) != NULL) {
 		if (modp != NULL)
 			*modp = mod2;
 		module_print("module `%s' already loaded", mi->mi_name);
 		error = EEXIST;
 		goto fail;
+	}
 	/*
 	 * Block circular dependencies.
 	 */
 	TAILQ_FOREACH(mod2, &pending, mod_chain) {
 		if (mod == mod2) {
 			continue;
+		}
 		if (strcmp(mod2->mod_info->mi_name, mi->mi_name) == 0) {
 		    	error = EDEADLK;
 			module_error("circular dependency detected for `%s'",
 			    mi->mi_name);
 		    	goto fail;
+		}
+	}
 	/*
 	 * Now try to load any requisite modules.
 	 */
 	if (mi->mi_required != NULL) {
 		for (s = mi->mi_required; *s != '\0'; s = p) {
 			if (*s == ',')
 				s++;
 			p = s;
 			while (*p != '\0' && *p != ',')
 				p++;
 			len = p - s + 1;
 			if (len >= MAXMODNAME) {
 				error = EINVAL;
 				module_error("required module name `%s'"
 				    " too long", mi->mi_required);
 				goto fail;
+			}
 			strlcpy(buf, s, len);
 			if (buf[0] == '\0')
 				break;
 			if (mod->mod_nrequired == MAXMODDEPS - 1) {
 				error = EINVAL;
 				module_error("too many required modules (%d)",
 				    mod->mod_nrequired);
 				goto fail;
+			}
 			if (strcmp(buf, mi->mi_name) == 0) {
 				error = EDEADLK;
 				module_error("self-dependency detected for "
 				   "`%s'", mi->mi_name);
 				goto fail;
+			}
 			error = module_do_load(buf, true, flags, NULL,
 			    &mod->mod_required[mod->mod_nrequired++],
 			    MODULE_CLASS_ANY, true);
 			if (error != 0)
 				goto fail;
+		}
+	}
 	/*
 	 * We loaded all needed modules successfully: perform global
 	 * relocations and initialize.
 	 */
 	error = kobj_affix(mod->mod_kobj, mi->mi_name);
 	if (error != 0) {
 		/* Cannot touch 'mi' as the module is now gone. */
 		module_error("unable to affix module `%s'", name);
 		goto fail2;
+	}
 	/*
 	 * Load and process <module>.prop if it exists.
 	 */
 	if (((flags & MODCTL_NO_PROP) == 0) &&
 	    (mod->mod_source == MODULE_SOURCE_FILESYS)) {
 		error = module_load_plist_file(path, nochroot, &plist,
 		    &plistlen);
 		if (error != 0) {
 			module_print("plist load returned error %d for `%s'",
 			    error, path);
 		} else {
 			filedict = prop_dictionary_internalize(plist);
 			if (filedict == NULL) {
 				error = EINVAL;
 			} else if (!module_merge_dicts(filedict, props)) {
 				error = EINVAL;
 				prop_object_release(filedict);
 				filedict = NULL;
+			}
+		}
 		if (plist != NULL) {
 			kmem_free(plist, PAGE_SIZE);
+		}
 		if ((error != 0) && (error != ENOENT)) {
 			goto fail;
+		}
+	}
 	KASSERT(module_active == NULL);
 	module_active = mod;
 	error = (*mi->mi_modcmd)(MODULE_CMD_INIT, (filedict != NULL) ?
 	    filedict : props);	/* props will have been merged with filedict */
 	module_active = NULL;
 	if (filedict != NULL) {
 		prop_object_release(filedict);
+	}
 	if (error != 0) {
 		module_error("modcmd function returned error %d for `%s'",
 		    error, mi->mi_name);
 		goto fail;
+	}
 	/*
 	 * Good, the module loaded successfully.  Put it onto the
 	 * list and add references to its requisite modules.
 	 */
 	TAILQ_REMOVE(&pending, mod, mod_chain);
 	module_enqueue(mod);
 	if (modp != NULL) {
 		*modp = mod;
+	}
 	if (autoload) {
 		/*
 		 * Arrange to try unloading the module after
 		 * a short delay.
 		 */
 		mod->mod_autotime = time_second + module_autotime;
 		module_thread_kick();
+	}
 	depth--;
 	if (path != NULL)
 		PNBUF_PUT(path);
 	return 0;
  fail:
 	kobj_unload(mod->mod_kobj);
  fail2:
 	TAILQ_REMOVE(&pending, mod, mod_chain);
 	kmem_free(mod, sizeof(*mod));
 	depth--;
 	if (path != NULL)
 		PNBUF_PUT(path);
 	return error;
+}
 /*
  * module_do_unload:
+ *
  *	Helper routine: do the dirty work of unloading a module.
  */
 static int
 module_do_unload(const char *name)
+{
 	module_t *mod;
 	int error;
 	u_int i;
 	KASSERT(mutex_owned(&module_lock));
 	mod = module_lookup(name);
 	if (mod == NULL) {
 		module_error("module `%s' not found", name);
 		return ENOENT;
+	}
 	if (mod->mod_refcnt != 0 || mod->mod_source == MODULE_SOURCE_KERNEL) {
 		module_print("module `%s' busy", name);
 		return EBUSY;
+	}
 	KASSERT(module_active == NULL);
 	module_active = mod;
 	error = (*mod->mod_info->mi_modcmd)(MODULE_CMD_FINI, NULL);
 	module_active = NULL;
 	if (error != 0) {
 		module_print("cannot unload module `%s' error=%d", name,
 		    error);
 		return error;
+	}
 	module_count--;
 	TAILQ_REMOVE(&module_list, mod, mod_chain);
 	for (i = 0; i < mod->mod_nrequired; i++) {
 		mod->mod_required[i]->mod_refcnt--;
+	}
 	if (mod->mod_kobj != NULL) {
 		kobj_unload(mod->mod_kobj);
+	}
 	kmem_free(mod, sizeof(*mod));
 	module_gen++;
 	return 0;
+}
 /*
  * module_prime:
+ *
  *	Push a module loaded by the bootloader onto our internal
  *	list.
  */
 int
 module_prime(void *base, size_t size)
+{
 	module_t *mod;
 	int error;
 	mod = kmem_zalloc(sizeof(*mod), KM_SLEEP);
 	if (mod == NULL) {
 		return ENOMEM;
+	}
 	mod->mod_source = MODULE_SOURCE_BOOT;
 	error = kobj_load_mem(&mod->mod_kobj, base, size);
 	if (error != 0) {
 		kmem_free(mod, sizeof(*mod));
 		module_error("unable to load object pushed by boot loader");
 		return error;
+	}
 	error = module_fetch_info(mod);
 	if (error != 0) {
 		kobj_unload(mod->mod_kobj);
 		kmem_free(mod, sizeof(*mod));
 		module_error("unable to load object pushed by boot loader");
 		return error;
+	}
 	TAILQ_INSERT_TAIL(&module_bootlist, mod, mod_chain);
 	return 0;
+}
 /*
  * module_fetch_into:
+ *
  *	Fetch modinfo record from a loaded module.
  */
 static int
 module_fetch_info(module_t *mod)
+{
 	int error;
 	void *addr;
 	size_t size;
 	/*
 	 * Find module info record and check compatibility.
 	 */
 	error = kobj_find_section(mod->mod_kobj, "link_set_modules",
 	    &addr, &size);
 	if (error != 0) {
 		module_error("`link_set_modules' section not present");
 		return error;
+	}
 	if (size != sizeof(modinfo_t **)) {
 		module_error("`link_set_modules' section wrong size");
 		return error;
+	}
 	mod->mod_info = *(modinfo_t **)addr;
 	return 0;
+}
 /*
  * module_find_section:
+ *
  *	Allows a module that is being initialized to look up a section
  *	within its ELF object.
  */
 int
 module_find_section(const char *name, void **addr, size_t *size)
+{
 	KASSERT(mutex_owned(&module_lock));
 	KASSERT(module_active != NULL);
 	return kobj_find_section(module_active->mod_kobj, name, addr, size);
+}
 /*
  * module_thread:
+ *
  *	Automatically unload modules.  We try once to unload autoloaded
  *	modules after module_autotime seconds.  If the system is under
  *	severe memory pressure, we'll try unloading all modules.
  */
 static void
 module_thread(void *cookie)
+{
 	module_t *mod, *next;
 	modinfo_t *mi;
 	int error;
 	for (;;) {
 		mutex_enter(&module_lock);
 		for (mod = TAILQ_FIRST(&module_list); mod != NULL; mod = next) {
 			next = TAILQ_NEXT(mod, mod_chain);
 			if (uvmexp.free < uvmexp.freemin) {
 				module_thread_ticks = hz;
 			} else if (mod->mod_autotime == 0) {
 				continue;
 			} else if (time_second < mod->mod_autotime) {
 				module_thread_ticks = hz;
 			    	continue;
 			} else {
 				mod->mod_autotime = 0;
+			}
 			/*
 			 * If this module wants to avoid autounload then
 			 * skip it.  Some modules can ping-pong in and out
 			 * because their use is transient but often.
 			 * Example: exec_script.
 			 */
 			mi = mod->mod_info;
 			error = (*mi->mi_modcmd)(MODULE_CMD_AUTOUNLOAD, NULL);
 			if (error == 0 || error == ENOTTY) {
 				(void)module_do_unload(mi->mi_name);
+			}
+		}
 		mutex_exit(&module_lock);
 		mutex_enter(&module_thread_lock);
 		(void)cv_timedwait(&module_thread_cv, &module_thread_lock,
 		    module_thread_ticks);
 		module_thread_ticks = 0;
 		mutex_exit(&module_thread_lock);
+	}
+}
 /*
  * module_thread:
+ *
  *	Kick the module thread into action, perhaps because the
  *	system is low on memory.
  */
 void
 module_thread_kick(void)
+{
 	mutex_enter(&module_thread_lock);
 	module_thread_ticks = hz;
 	cv_broadcast(&module_thread_cv);
 	mutex_exit(&module_thread_lock);
+}
 #ifdef DDB
 /*
  * module_whatis:
+ *
  *	Helper routine for DDB.
  */
 void
 module_whatis(uintptr_t addr, void (*pr)(const char *, ...))
+{
 	module_t *mod;
 	size_t msize;
 	vaddr_t maddr;
 	TAILQ_FOREACH(mod, &module_list, mod_chain) {
 		if (mod->mod_kobj == NULL) {
 			continue;
+		}
-		kobj_stat(mod->mod_kobj, &maddr, &msize);
+		if (kobj_stat(mod->mod_kobj, &maddr, &msize) != 0)
 			continue;
 		if (addr < maddr || addr >= maddr + msize) {
 			continue;
+		}
 		(*pr)("%p is %p+%zu, in kernel module `%s'\n",
 		    (void *)addr, (void *)maddr,
 		    (size_t)(addr - maddr), mod->mod_info->mi_name);
+	}
+}
 /*
  * module_print_list:
+ *
  *	Helper routine for DDB.
  */
 void
 module_print_list(void (*pr)(const char *, ...))
+{
 	const char *src;
 	module_t *mod;
 	size_t msize;
 	vaddr_t maddr;
 	(*pr)("%16s %16s %8s %8s\n", "NAME", "TEXT/DATA", "SIZE", "SOURCE");
 	TAILQ_FOREACH(mod, &module_list, mod_chain) {
 		switch (mod->mod_source) {
 		case MODULE_SOURCE_KERNEL:
 			src = "builtin";
 			break;
 		case MODULE_SOURCE_FILESYS:
 			src = "filesys";
 			break;
 		case MODULE_SOURCE_BOOT:
 			src = "boot";
 			break;
 		default:
 			src = "unknown";
 			break;
+		}
-		if (mod->mod_kobj != NULL) {
+		if (mod->mod_kobj == NULL) {
 			kobj_stat(mod->mod_kobj, &maddr, &msize);
 		} else {
 			maddr = 0;
 			msize = 0;
 		} else if (kobj_stat(mod->mod_kobj, &maddr, &msize) != 0)
 			continue;
 		(*pr)("%16s %16lx %8ld %8s\n", mod->mod_info->mi_name,
 		    (long)maddr, (long)msize, src);
+	}
+}
 #endif	/* DDB */
 /*
  * module_load_plist_file:
+ *
  *	Load a plist located in the file system into memory.
  */
 static int
 module_load_plist_file(const char *modpath, const bool nochroot,
 		       void **basep, size_t *length)
+{
 	struct nameidata nd;
 	struct stat sb;
 	void *base;
 	char *proppath;
 	size_t resid;
 	int error, pathlen;
 	base = NULL;
 	*length = 0;
 	proppath = PNBUF_GET();
 	strcpy(proppath, modpath);
 	pathlen = strlen(proppath);
 	if ((pathlen >= 5) && (strcmp(&proppath[pathlen - 5], ".kmod") == 0)) {
 		strcpy(&proppath[pathlen - 5], ".prop");
 	} else if (pathlen < MAXPATHLEN - 5) {
 			strcat(proppath, ".prop");
 	} else {
 		error = ENOENT;
 		goto out1;
+	}
 	NDINIT(&nd, LOOKUP, FOLLOW | (nochroot ? NOCHROOT : 0),
 	    UIO_SYSSPACE, proppath);
 	error = namei(&nd);
 	if (error != 0) {
 		goto out1;
+	}
 	error = vn_stat(nd.ni_vp, &sb);
 	if (sb.st_size >= (PAGE_SIZE - 1)) {	/* leave space for term \0 */
 		error = EINVAL;
+	}
 	if (error != 0) {
 		goto out1;
+	}
 	error = vn_open(&nd, FREAD, 0);
  	if (error != 0) {
 	 	goto out1;
+	}
 	base = kmem_alloc(PAGE_SIZE, KM_SLEEP);
 	if (base == NULL) {
 		error = ENOMEM;
 		goto out;
+	}
 	error = vn_rdwr(UIO_READ, nd.ni_vp, base, sb.st_size, 0,
 	    UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid, curlwp);
 	*((uint8_t *)base + sb.st_size) = '\0';
 	if (error == 0 && resid != 0) {
 		error = EINVAL;
+	}
 	if (error != 0) {
 		kmem_free(base, PAGE_SIZE);
 		base = NULL;
+	}
 	*length = sb.st_size;
 out:
 	VOP_UNLOCK(nd.ni_vp, 0);
 	vn_close(nd.ni_vp, FREAD, kauth_cred_get());
 out1:
 	PNBUF_PUT(proppath);
 	*basep = base;
 	return error;
+}
 static bool
 module_merge_dicts(prop_dictionary_t existing_dict,
 		   const prop_dictionary_t new_dict)
+{
 	prop_dictionary_keysym_t props_keysym;
 	prop_object_iterator_t props_iter;
 	prop_object_t props_obj;
 	const char *props_key;
 	bool error;
 	error = false;
 	props_iter = prop_dictionary_iterator(new_dict);
 	if (props_iter == NULL) {
 		return false;
+	}
 	while ((props_obj = prop_object_iterator_next(props_iter)) != NULL) {
 		props_keysym = (prop_dictionary_keysym_t)props_obj;
 		props_key = prop_dictionary_keysym_cstring_nocopy(props_keysym);
 		props_obj = prop_dictionary_get_keysym(new_dict, props_keysym);
 		if ((props_obj == NULL) || !prop_dictionary_set(existing_dict,
 		    props_key, props_obj)) {
 			error = true;
 			goto out;
+		}
+	}
 	error = false;
 out:
 	prop_object_iterator_release(props_iter);
 	return !error;
+}

 @@ -1,1150 +1,1151 @@
-/*	$NetBSD: subr_kobj.c,v 1.38 2009/05/26 08:34:23 jnemeth Exp $	*/
+/*	$NetBSD: subr_kobj.c,v 1.39 2009/06/17 21:04:25 dyoung Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software developed for The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*-
  * Copyright (c) 1998-2000 Doug Rabson
  * Copyright (c) 2004 Peter Wemm
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Kernel loader for ELF objects.
+ *
  * TODO: adjust kmem_alloc() calls to avoid needless fragmentation.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_kobj.c,v 1.38 2009/05/26 08:34:23 jnemeth Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_kobj.c,v 1.39 2009/06/17 21:04:25 dyoung Exp $");
 #include "opt_modular.h"
 #include <sys/kobj_impl.h>
 #ifdef MODULAR
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/fcntl.h>
 #include <sys/ksyms.h>
 #include <sys/module.h>
 #include <machine/stdarg.h>
 #include <uvm/uvm_extern.h>
 static int	kobj_relocate(kobj_t, bool);
 static int	kobj_checksyms(kobj_t, bool);
 static void	kobj_error(const char *, ...);
 static int	kobj_read(kobj_t, void **, size_t, off_t);
 static int	kobj_read_bits(kobj_t, void *, size_t, off_t);
 static void	kobj_jettison(kobj_t);
 static void	kobj_free(kobj_t, void *, size_t);
 static void	kobj_close(kobj_t);
 static int	kobj_load(kobj_t);
 extern struct vm_map *module_map;
 /*
  * kobj_load_file:
+ *
  *	Load an object located in the file system.
  */
 int
 kobj_load_file(kobj_t *kop, const char *path, const bool nochroot)
+{
 	struct nameidata nd;
 	kauth_cred_t cred;
 	int error;
 	kobj_t ko;
 	cred = kauth_cred_get();
 	ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
 	if (ko == NULL) {
 		return ENOMEM;
+	}
 	NDINIT(&nd, LOOKUP, FOLLOW | (nochroot ? NOCHROOT : 0),
 	    UIO_SYSSPACE, path);
 	error = vn_open(&nd, FREAD, 0);
  	if (error != 0) {
 	 	kmem_free(ko, sizeof(*ko));
 	 	return error;
+	}
 	ko->ko_type = KT_VNODE;
 	ko->ko_source = nd.ni_vp;
 	*kop = ko;
 	return kobj_load(ko);
+}
 /*
  * kobj_load_mem:
+ *
  *	Load an object already resident in memory.  If size is not -1,
  *	the complete size of the object is known.
  */
 int
 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
+{
 	kobj_t ko;
 	ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
 	if (ko == NULL) {
 		return ENOMEM;
+	}
 	ko->ko_type = KT_MEMORY;
 	ko->ko_source = base;
 	ko->ko_memsize = size;
 	*kop = ko;
 	return kobj_load(ko);
+}
 /*
  * kobj_close:
+ *
  *	Close an open ELF object.
  */
 static void
 kobj_close(kobj_t ko)
+{
 	if (ko->ko_source == NULL) {
 		return;
+	}
 	switch (ko->ko_type) {
 	case KT_VNODE:
 		VOP_UNLOCK(ko->ko_source, 0);
 		vn_close(ko->ko_source, FREAD, kauth_cred_get());
 		break;
 	case KT_MEMORY:
 		/* nothing */
 		break;
 	default:
 		panic("kobj_close: unknown type");
 		break;
+	}
 	ko->ko_source = NULL;
+}
 /*
  * kobj_load:
+ *
  *	Load an ELF object and prepare to link into the running kernel
  *	image.
  */
 static int
 kobj_load(kobj_t ko)
+{
 	Elf_Ehdr *hdr;
 	Elf_Shdr *shdr;
 	Elf_Sym *es;
 	vaddr_t mapbase;
 	size_t mapsize;
 	int error;
 	int symtabindex;
 	int symstrindex;
 	int nsym;
 	int pb, rl, ra;
 	int alignmask;
 	int i, j;
 	void *addr;
 	KASSERT(ko->ko_type != KT_UNSET);
 	KASSERT(ko->ko_source != NULL);
 	shdr = NULL;
 	mapsize = 0;
 	error = 0;
 	hdr = NULL;
 	/*
 	 * Read the elf header from the file.
 	 */
 	error = kobj_read(ko, (void **)&hdr, sizeof(*hdr), 0);
 	if (error != 0)
 		goto out;
 	if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) {
 		kobj_error("not an ELF object");
 		error = ENOEXEC;
 		goto out;
+	}
 	if (hdr->e_ident[EI_VERSION] != EV_CURRENT ||
 	    hdr->e_version != EV_CURRENT) {
 		kobj_error("unsupported file version");
 		error = ENOEXEC;
 		goto out;
+	}
 	if (hdr->e_type != ET_REL) {
 		kobj_error("unsupported file type");
 		error = ENOEXEC;
 		goto out;
+	}
 	switch (hdr->e_machine) {
 #if ELFSIZE == 32
 	ELF32_MACHDEP_ID_CASES
 #else
 	ELF64_MACHDEP_ID_CASES
 #endif
 	default:
 		kobj_error("unsupported machine");
 		error = ENOEXEC;
 		goto out;
+	}
 	ko->ko_nprogtab = 0;
 	ko->ko_shdr = 0;
 	ko->ko_nrel = 0;
 	ko->ko_nrela = 0;
 	/*
 	 * Allocate and read in the section header.
 	 */
 	ko->ko_shdrsz = hdr->e_shnum * hdr->e_shentsize;
 	if (ko->ko_shdrsz == 0 || hdr->e_shoff == 0 ||
 	    hdr->e_shentsize != sizeof(Elf_Shdr)) {
 		error = ENOEXEC;
 		goto out;
+	}
 	error = kobj_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff);
 	if (error != 0) {
 		goto out;
+	}
 	ko->ko_shdr = shdr;
 	/*
 	 * Scan the section header for information and table sizing.
 	 */
 	nsym = 0;
 	symtabindex = -1;
 	symstrindex = -1;
 	for (i = 0; i < hdr->e_shnum; i++) {
 		switch (shdr[i].sh_type) {
 		case SHT_PROGBITS:
 		case SHT_NOBITS:
 			ko->ko_nprogtab++;
 			break;
 		case SHT_SYMTAB:
 			nsym++;
 			symtabindex = i;
 			symstrindex = shdr[i].sh_link;
 			break;
 		case SHT_REL:
 			ko->ko_nrel++;
 			break;
 		case SHT_RELA:
 			ko->ko_nrela++;
 			break;
 		case SHT_STRTAB:
 			break;
+		}
+	}
 	if (ko->ko_nprogtab == 0) {
 		kobj_error("file has no contents");
 		error = ENOEXEC;
 		goto out;
+	}
 	if (nsym != 1) {
 		/* Only allow one symbol table for now */
 		kobj_error("file has no valid symbol table");
 		error = ENOEXEC;
 		goto out;
+	}
 	if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
 	    shdr[symstrindex].sh_type != SHT_STRTAB) {
 		kobj_error("file has invalid symbol strings");
 		error = ENOEXEC;
 		goto out;
+	}
 	/*
 	 * Allocate space for tracking the load chunks.
 	 */
 	if (ko->ko_nprogtab != 0) {
 		ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab *
 		    sizeof(*ko->ko_progtab), KM_SLEEP);
 		if (ko->ko_progtab == NULL) {
 			error = ENOMEM;
 			goto out;
+		}
+	}
 	if (ko->ko_nrel != 0) {
 		ko->ko_reltab = kmem_zalloc(ko->ko_nrel *
 		    sizeof(*ko->ko_reltab), KM_SLEEP);
 		if (ko->ko_reltab == NULL) {
 			error = ENOMEM;
 			goto out;
+		}
+	}
 	if (ko->ko_nrela != 0) {
 		ko->ko_relatab = kmem_zalloc(ko->ko_nrela *
 		    sizeof(*ko->ko_relatab), KM_SLEEP);
 		if (ko->ko_relatab == NULL) {
 			error = ENOMEM;
 			goto out;
+		}
+	}
 	if (symtabindex == -1) {
 		kobj_error("lost symbol table index");
 		goto out;
+	}
 	/*
 	 * Allocate space for and load the symbol table.
 	 */
 	ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
 	if (ko->ko_symcnt == 0) {
 		kobj_error("no symbol table");
 		goto out;
+	}
 	error = kobj_read(ko, (void **)&ko->ko_symtab,
 	    ko->ko_symcnt * sizeof(Elf_Sym),
 	    shdr[symtabindex].sh_offset);
 	if (error != 0) {
 		goto out;
+	}
 	/*
 	 * Allocate space for and load the symbol strings.
 	 */
 	ko->ko_strtabsz = shdr[symstrindex].sh_size;
 	if (ko->ko_strtabsz == 0) {
 		kobj_error("no symbol strings");
 		goto out;
+	}
 	error = kobj_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz,
 	    shdr[symstrindex].sh_offset);
 	if (error != 0) {
 		goto out;
+	}
 	/*
 	 * Do we have a string table for the section names?
 	 */
 	if (hdr->e_shstrndx != 0 && shdr[hdr->e_shstrndx].sh_size != 0 &&
 	    shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
 		ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size;
 		error = kobj_read(ko, (void **)&ko->ko_shstrtab,
 		    shdr[hdr->e_shstrndx].sh_size,
 		    shdr[hdr->e_shstrndx].sh_offset);
 		if (error != 0) {
 			goto out;
+		}
+	}
 	/*
 	 * Size up code/data(progbits) and bss(nobits).
 	 */
 	alignmask = 0;
 	mapbase = 0;
 	for (i = 0; i < hdr->e_shnum; i++) {
 		switch (shdr[i].sh_type) {
 		case SHT_PROGBITS:
 		case SHT_NOBITS:
 			if (mapbase == 0)
 				mapbase = shdr[i].sh_offset;
 			alignmask = shdr[i].sh_addralign - 1;
 			mapsize += alignmask;
 			mapsize &= ~alignmask;
 			mapsize += shdr[i].sh_size;
 			break;
+		}
+	}
 	/*
 	 * We know how much space we need for the text/data/bss/etc.
 	 * This stuff needs to be in a single chunk so that profiling etc
 	 * can get the bounds and gdb can associate offsets with modules.
 	 */
 	if (mapsize == 0) {
 		kobj_error("no text/data/bss");
 		goto out;
+	}
 	if (ko->ko_type == KT_MEMORY) {
 		mapbase += (vaddr_t)ko->ko_source;
 	} else {
 		mapbase = uvm_km_alloc(module_map, round_page(mapsize),
 , UVM_KMF_WIRED | UVM_KMF_EXEC);
 		if (mapbase == 0) {
 			error = ENOMEM;
 			goto out;
+		}
+	}
 	ko->ko_address = mapbase;
 	ko->ko_size = mapsize;
 	/*
 	 * Now load code/data(progbits), zero bss(nobits), allocate space
 	 * for and load relocs
 	 */
 	pb = 0;
 	rl = 0;
 	ra = 0;
 	alignmask = 0;
 	for (i = 0; i < hdr->e_shnum; i++) {
 		switch (shdr[i].sh_type) {
 		case SHT_PROGBITS:
 		case SHT_NOBITS:
 			alignmask = shdr[i].sh_addralign - 1;
 			if (ko->ko_type == KT_MEMORY) {
 				addr = (void *)(shdr[i].sh_offset +
 				    (vaddr_t)ko->ko_source);
 				if (((vaddr_t)addr & alignmask) != 0) {
 					kobj_error("section %d not aligned\n",
 					    i);
 					goto out;
+				}
 			} else {
 				mapbase += alignmask;
 				mapbase &= ~alignmask;
 				addr = (void *)mapbase;
 				mapbase += shdr[i].sh_size;
+			}
 			ko->ko_progtab[pb].addr = addr;
 			if (shdr[i].sh_type == SHT_PROGBITS) {
 				ko->ko_progtab[pb].name = "<<PROGBITS>>";
 				error = kobj_read_bits(ko, addr,
 				    shdr[i].sh_size, shdr[i].sh_offset);
 				if (error != 0) {
 					goto out;
+				}
 			} else if (ko->ko_type == KT_MEMORY &&
 			    shdr[i].sh_size != 0) {
 			    	kobj_error("non-loadable BSS section in "
 			    	    "pre-loaded module");
 				error = EINVAL;
 			    	goto out;
 			} else {
 				ko->ko_progtab[pb].name = "<<NOBITS>>";
 				memset(addr, 0, shdr[i].sh_size);
+			}
 			ko->ko_progtab[pb].size = shdr[i].sh_size;
 			ko->ko_progtab[pb].sec = i;
 			if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) {
 				ko->ko_progtab[pb].name =
 				    ko->ko_shstrtab + shdr[i].sh_name;
+			}
 			/* Update all symbol values with the offset. */
 			for (j = 0; j < ko->ko_symcnt; j++) {
 				es = &ko->ko_symtab[j];
 				if (es->st_shndx != i) {
 					continue;
+				}
 				es->st_value += (Elf_Addr)addr;
+			}
 			pb++;
 			break;
 		case SHT_REL:
 			ko->ko_reltab[rl].size = shdr[i].sh_size;
 			ko->ko_reltab[rl].size -=
 			    shdr[i].sh_size % sizeof(Elf_Rel);
 			if (ko->ko_reltab[rl].size != 0) {
 				ko->ko_reltab[rl].nrel =
 				    shdr[i].sh_size / sizeof(Elf_Rel);
 				ko->ko_reltab[rl].sec = shdr[i].sh_info;
 				error = kobj_read(ko,
 				    (void **)&ko->ko_reltab[rl].rel,
 				    ko->ko_reltab[rl].size,
 				    shdr[i].sh_offset);
 				if (error != 0) {
 					goto out;
+				}
+			}
 			rl++;
 			break;
 		case SHT_RELA:
 			ko->ko_relatab[ra].size = shdr[i].sh_size;
 			ko->ko_relatab[ra].size -=
 			    shdr[i].sh_size % sizeof(Elf_Rela);
 			if (ko->ko_relatab[ra].size != 0) {
 				ko->ko_relatab[ra].nrela =
 				    shdr[i].sh_size / sizeof(Elf_Rela);
 				ko->ko_relatab[ra].sec = shdr[i].sh_info;
 				error = kobj_read(ko,
 				    (void **)&ko->ko_relatab[ra].rela,
 				    shdr[i].sh_size,
 				    shdr[i].sh_offset);
 				if (error != 0) {
 					goto out;
+				}
+			}
 			ra++;
 			break;
 		default:
 			break;
+		}
+	}
 	if (pb != ko->ko_nprogtab) {
 		panic("lost progbits");
+	}
 	if (rl != ko->ko_nrel) {
 		panic("lost rel");
+	}
 	if (ra != ko->ko_nrela) {
 		panic("lost rela");
+	}
 	if (ko->ko_type != KT_MEMORY && mapbase != ko->ko_address + mapsize) {
 		panic("mapbase 0x%lx != address %lx + mapsize %ld (0x%lx)\n",
 		    (long)mapbase, (long)ko->ko_address, (long)mapsize,
 		    (long)ko->ko_address + mapsize);
+	}
 	/*
 	 * Perform local relocations only.  Relocations relating to global
 	 * symbols will be done by kobj_affix().
 	 */
 	error = kobj_checksyms(ko, false);
 	if (error == 0) {
 		error = kobj_relocate(ko, true);
+	}
  out:
 	if (hdr != NULL) {
 		kobj_free(ko, hdr, sizeof(*hdr));
+	}
 	kobj_close(ko);
 	if (error != 0) {
 		kobj_unload(ko);
+	}
 	return error;
+}
 /*
  * kobj_unload:
+ *
  *	Unload an object previously loaded by kobj_load().
  */
 void
 kobj_unload(kobj_t ko)
+{
 	int error;
 	kobj_close(ko);
 	kobj_jettison(ko);
 	/*
 	 * Notify MD code that a module has been unloaded.
 	 */
 	if (ko->ko_loaded) {
 		error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
 		    false);
 		if (error != 0) {
 			kobj_error("machine dependent deinit failed");
+		}
+	}
 	if (ko->ko_address != 0 && ko->ko_type != KT_MEMORY) {
 		uvm_km_free(module_map, ko->ko_address, round_page(ko->ko_size),
 		    UVM_KMF_WIRED);
+	}
 	if (ko->ko_ksyms == true) {
 		ksyms_modunload(ko->ko_name);
+	}
 	if (ko->ko_symtab != NULL) {
 		kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym));
+	}
 	if (ko->ko_strtab != NULL) {
 		kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz);
+	}
 	if (ko->ko_progtab != NULL) {
 		kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab *
 		    sizeof(*ko->ko_progtab));
 		ko->ko_progtab = NULL;
+	}
 	if (ko->ko_shstrtab) {
 		kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz);
 		ko->ko_shstrtab = NULL;
+	}
 	kmem_free(ko, sizeof(*ko));
+}
 /*
  * kobj_stat:
+ *
  *	Return size and load address of an object.
  */
-void
+int
 kobj_stat(kobj_t ko, vaddr_t *address, size_t *size)
+{
 	if (address != NULL) {
 		*address = ko->ko_address;
+	}
 	if (size != NULL) {
 		*size = ko->ko_size;
+	}
 	return 0;
+}
 /*
  * kobj_affix:
+ *
  *	Set an object's name and perform global relocs.  May only be
  *	called after the module and any requisite modules are loaded.
  */
 int
 kobj_affix(kobj_t ko, const char *name)
+{
 	int error;
 	KASSERT(ko->ko_ksyms == false);
 	KASSERT(ko->ko_loaded == false);
 	strlcpy(ko->ko_name, name, sizeof(ko->ko_name));
 	/* Cache addresses of undefined symbols. */
 	error = kobj_checksyms(ko, true);
 	/* Now do global relocations. */
 	if (error == 0)
 		error = kobj_relocate(ko, false);
 	/*
 	 * Now that we know the name, register the symbol table.
 	 * Do after global relocations because ksyms will pack
 	 * the table.
 	 */
 	if (error == 0) {
 		ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt *
 		    sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz);
 		ko->ko_ksyms = true;
+	}
 	/* Jettison unneeded memory post-link. */
 	kobj_jettison(ko);
 	/*
 	 * Notify MD code that a module has been loaded.
+	 *
 	 * Most architectures use this opportunity to flush their caches.
 	 */
 	if (error == 0) {
 		error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
 		    true);
 		if (error != 0) {
 			kobj_error("machine dependent init failed");
+		}
 		ko->ko_loaded = true;
+	}
 	/* If there was an error, destroy the whole object. */
 	if (error != 0) {
 		kobj_unload(ko);
+	}
 	return error;
+}
 /*
  * kobj_find_section:
+ *
  *	Given a section name, search the loaded object and return
  *	virtual address if present and loaded.
  */
 int
 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
+{
 	int i;
 	KASSERT(ko->ko_progtab != NULL);
 	for (i = 0; i < ko->ko_nprogtab; i++) {
 		if (strcmp(ko->ko_progtab[i].name, name) == 0) {
 			if (addr != NULL) {
 				*addr = ko->ko_progtab[i].addr;
+			}
 			if (size != NULL) {
 				*size = ko->ko_progtab[i].size;
+			}
 			return 0;
+		}
+	}
 	return ENOENT;
+}
 /*
  * kobj_jettison:
+ *
  *	Release object data not needed after performing relocations.
  */
 static void
 kobj_jettison(kobj_t ko)
+{
 	int i;
 	if (ko->ko_reltab != NULL) {
 		for (i = 0; i < ko->ko_nrel; i++) {
 			if (ko->ko_reltab[i].rel) {
 				kobj_free(ko, ko->ko_reltab[i].rel,
 				    ko->ko_reltab[i].size);
+			}
+		}
 		kobj_free(ko, ko->ko_reltab, ko->ko_nrel *
 		    sizeof(*ko->ko_reltab));
 		ko->ko_reltab = NULL;
 		ko->ko_nrel = 0;
+	}
 	if (ko->ko_relatab != NULL) {
 		for (i = 0; i < ko->ko_nrela; i++) {
 			if (ko->ko_relatab[i].rela) {
 				kobj_free(ko, ko->ko_relatab[i].rela,
 				    ko->ko_relatab[i].size);
+			}
+		}
 		kobj_free(ko, ko->ko_relatab, ko->ko_nrela *
 		    sizeof(*ko->ko_relatab));
 		ko->ko_relatab = NULL;
 		ko->ko_nrela = 0;
+	}
 	if (ko->ko_shdr != NULL) {
 		kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz);
 		ko->ko_shdr = NULL;
+	}
+}
 /*
  * kobj_sym_lookup:
+ *
  *	Symbol lookup function to be used when the symbol index
  *	is known (ie during relocation).
  */
 uintptr_t
 kobj_sym_lookup(kobj_t ko, uintptr_t symidx)
+{
 	const Elf_Sym *sym;
 	const char *symbol;
 	/* Don't even try to lookup the symbol if the index is bogus. */
 	if (symidx >= ko->ko_symcnt)
 		return 0;
 	sym = ko->ko_symtab + symidx;
 	/* Quick answer if there is a definition included. */
 	if (sym->st_shndx != SHN_UNDEF) {
 		return (uintptr_t)sym->st_value;
+	}
 	/* If we get here, then it is undefined and needs a lookup. */
 	switch (ELF_ST_BIND(sym->st_info)) {
 	case STB_LOCAL:
 		/* Local, but undefined? huh? */
 		kobj_error("local symbol undefined");
 		return 0;
 	case STB_GLOBAL:
 		/* Relative to Data or Function name */
 		symbol = ko->ko_strtab + sym->st_name;
 		/* Force a lookup failure if the symbol name is bogus. */
 		if (*symbol == 0) {
 			kobj_error("bad symbol name");
 			return 0;
+		}
 		return (uintptr_t)sym->st_value;
 	case STB_WEAK:
 		kobj_error("weak symbols not supported\n");
 		return 0;
 	default:
 		return 0;
+	}
+}
 /*
  * kobj_findbase:
+ *
  *	Return base address of the given section.
  */
 static uintptr_t
 kobj_findbase(kobj_t ko, int sec)
+{
 	int i;
 	for (i = 0; i < ko->ko_nprogtab; i++) {
 		if (sec == ko->ko_progtab[i].sec) {
 			return (uintptr_t)ko->ko_progtab[i].addr;
+		}
+	}
 	return 0;
+}
 /*
  * kobj_checksyms:
+ *
  *	Scan symbol table for duplicates or resolve references to
  *	exernal symbols.
  */
 static int
 kobj_checksyms(kobj_t ko, bool undefined)
+{
 	unsigned long rval;
 	Elf_Sym *sym, *ms;
 	const char *name;
 	int error;
 	error = 0;
 	for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) {
 		/* Check validity of the symbol. */
 		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL ||
 		    sym->st_name == 0)
 			continue;
 		if (undefined != (sym->st_shndx == SHN_UNDEF)) {
 			continue;
+		}
 		/*
 		 * Look it up.  Don't need to lock, as it is known that
 		 * the symbol tables aren't going to change (we hold
 		 * module_lock).
 		 */
 		name = ko->ko_strtab + sym->st_name;
 		if (ksyms_getval_unlocked(NULL, name, &rval,
 		    KSYMS_EXTERN) != 0) {
 			if (undefined) {
 				kobj_error("symbol `%s' not found", name);
 				error = ENOEXEC;
+			}
 			continue;
+		}
 		/* Save values of undefined globals. */
 		if (undefined) {
 			sym->st_value = (Elf_Addr)rval;
 			continue;
+		}
 		/* Check (and complain) about differing values. */
 		if (sym->st_value == rval) {
 			continue;
+		}
 		if (strcmp(name, "_bss_start") == 0 ||
 		    strcmp(name, "__bss_start") == 0 ||
 		    strcmp(name, "_bss_end__") == 0 ||
 		    strcmp(name, "__bss_end__") == 0 ||
 		    strcmp(name, "_edata") == 0 ||
 		    strcmp(name, "_end") == 0 ||
 		    strcmp(name, "__end") == 0 ||
 		    strcmp(name, "__end__") == 0 ||
 		    strncmp(name, "__start_link_set_", 17) == 0 ||
 		    strncmp(name, "__stop_link_set_", 16)) {
 		    	continue;
+		}
 		kobj_error("global symbol `%s' redefined\n", name);
 		error = ENOEXEC;
+	}
 	return error;
+}
 /*
  * kobj_relocate:
+ *
  *	Resolve relocations for the loaded object.
  */
 static int
 kobj_relocate(kobj_t ko, bool local)
+{
 	const Elf_Rel *rellim;
 	const Elf_Rel *rel;
 	const Elf_Rela *relalim;
 	const Elf_Rela *rela;
 	const Elf_Sym *sym;
 	uintptr_t base;
 	int i, error;
 	uintptr_t symidx;
 	/*
 	 * Perform relocations without addend if there are any.
 	 */
 	for (i = 0; i < ko->ko_nrel; i++) {
 		rel = ko->ko_reltab[i].rel;
 		if (rel == NULL) {
 			continue;
+		}
 		rellim = rel + ko->ko_reltab[i].nrel;
 		base = kobj_findbase(ko, ko->ko_reltab[i].sec);
 		if (base == 0) {
 			panic("lost base for e_reltab");
+		}
 		for (; rel < rellim; rel++) {
 			symidx = ELF_R_SYM(rel->r_info);
 			if (symidx >= ko->ko_symcnt) {
 				continue;
+			}
 			sym = ko->ko_symtab + symidx;
 			if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
 				continue;
+			}
 			error = kobj_reloc(ko, base, rel, false, local);
 			if (error != 0) {
 				return ENOENT;
+			}
+		}
+	}
 	/*
 	 * Perform relocations with addend if there are any.
 	 */
 	for (i = 0; i < ko->ko_nrela; i++) {
 		rela = ko->ko_relatab[i].rela;
 		if (rela == NULL) {
 			continue;
+		}
 		relalim = rela + ko->ko_relatab[i].nrela;
 		base = kobj_findbase(ko, ko->ko_relatab[i].sec);
 		if (base == 0) {
 			panic("lost base for e_relatab");
+		}
 		for (; rela < relalim; rela++) {
 			symidx = ELF_R_SYM(rela->r_info);
 			if (symidx >= ko->ko_symcnt) {
 				continue;
+			}
 			sym = ko->ko_symtab + symidx;
 			if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
 				continue;
+			}
 			error = kobj_reloc(ko, base, rela, true, local);
 			if (error != 0) {
 				return ENOENT;
+			}
+		}
+	}
 	return 0;
+}
 /*
  * kobj_error:
+ *
  *	Utility function: log an error.
  */
 static void
 kobj_error(const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	printf("WARNING: linker error: ");
 	vprintf(fmt, ap);
 	printf("\n");
 	va_end(ap);
+}
 /*
  * kobj_read:
+ *
  *	Utility function: read from the object.
  */
 static int
 kobj_read(kobj_t ko, void **basep, size_t size, off_t off)
+{
 	size_t resid;
 	void *base;
 	int error;
 	KASSERT(ko->ko_source != NULL);
 	switch (ko->ko_type) {
 	case KT_VNODE:
 		base = kmem_alloc(size, KM_SLEEP);
 		if (base == NULL) {
 			error = ENOMEM;
 			break;
+		}
 		error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
 		    UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
 		    curlwp);
 		if (error == 0 && resid != 0) {
 			error = EINVAL;
+		}
 		if (error != 0) {
 			kmem_free(base, size);
 			base = NULL;
+		}
 		break;
 	case KT_MEMORY:
 		if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
 			kobj_error("kobj_read: preloaded object short");
 			error = EINVAL;
 			base = NULL;
 		} else {
 			base = (uint8_t *)ko->ko_source + off;
 			error = 0;
+		}
 		break;
 	default:
 		panic("kobj_read: invalid type");
+	}
 	*basep = base;
 	return error;
+}
 /*
  * kobj_read_bits:
+ *
  *	Utility function: load a section from the object.
  */
 static int
 kobj_read_bits(kobj_t ko, void *base, size_t size, off_t off)
+{
 	size_t resid;
 	int error;
 	KASSERT(ko->ko_source != NULL);
 	switch (ko->ko_type) {
 	case KT_VNODE:
 		KASSERT((uintptr_t)base >= (uintptr_t)ko->ko_address);
 		KASSERT((uintptr_t)base + size <=
 		    (uintptr_t)ko->ko_address + ko->ko_size);
 		error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
 		    UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
 		    curlwp);
 		if (error == 0 && resid != 0) {
 			error = EINVAL;
+		}
 		break;
 	case KT_MEMORY:
 		if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
 			kobj_error("kobj_read_bits: preloaded object short");
 			error = EINVAL;
 		} else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) {
 			kobj_error("kobj_read_bits: object not aligned");
 			kobj_error("source=%p base=%p off=%d size=%zd",
 			    ko->ko_source, base, (int)off, size);
 			error = EINVAL;
 		} else {
 			/* Nothing to do.  Loading in-situ. */
 			error = 0;
+		}
 		break;
 	default:
 		panic("kobj_read: invalid type");
+	}
 	return error;
+}
 /*
  * kobj_free:
+ *
  *	Utility function: free memory if it was allocated from the heap.
  */
 static void
 kobj_free(kobj_t ko, void *base, size_t size)
+{
 	if (ko->ko_type != KT_MEMORY)
 		kmem_free(base, size);
+}
 #else	/* MODULAR */
 int
 kobj_load_file(kobj_t *kop, const char *name, const bool nochroot)
+{
 	return ENOSYS;
+}
 int
 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
+{
 	return ENOSYS;
+}
 void
 kobj_unload(kobj_t ko)
+{
 	panic("not modular");
+}
-void
+int
 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size)
+{
-	panic("not modular");
+	return ENOSYS;
+}
 int
 kobj_affix(kobj_t ko, const char *name)
+{
 	panic("not modular");
+}
 int
 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
+{
 	panic("not modular");
+}
 #endif	/* MODULAR */