svn commit: r198245 - in stable/6/sys: . conf contrib/pf dev/cxgb kern sys

Andrew Gallatin gallatin at FreeBSD.org
Mon Oct 19 19:14:04 UTC 2009


Author: gallatin
Date: Mon Oct 19 19:14:04 2009
New Revision: 198245
URL: http://svn.freebsd.org/changeset/base/198245

Log:
  MFC of 178042 to allow safe firmware(9) loading from NIC watchdog handlers.
       Also MFCed are the related changes 178016, 183614 and 184842.
  
  178042: Do firmare image loading in a context known to have a root directory
  183614: Dynamically allocate the task struct in firmware mountroot
  184842: Avoid scheduling firmware taskqueues when cold
  178016: Add a mountroot event handler.  Removal of SI_SUB_MOUNT_ROOT
          was not merged.  178042 is dependant upon this.
  
  This fixes a panic in at least mxge(4) if the NIC has a hardware fault
  when the firmware image is not resident.
  
  Reviewed by:	jhb

Modified:
  stable/6/sys/   (props changed)
  stable/6/sys/conf/   (props changed)
  stable/6/sys/contrib/pf/   (props changed)
  stable/6/sys/dev/cxgb/   (props changed)
  stable/6/sys/kern/subr_firmware.c
  stable/6/sys/kern/vfs_mount.c
  stable/6/sys/sys/eventhandler.h

Modified: stable/6/sys/kern/subr_firmware.c
==============================================================================
--- stable/6/sys/kern/subr_firmware.c	Mon Oct 19 19:11:00 2009	(r198244)
+++ stable/6/sys/kern/subr_firmware.c	Mon Oct 19 19:14:04 2009	(r198245)
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2005, Sam Leffler <sam at errno.com>
+ * Copyright (c) 2005-2008, Sam Leffler <sam at errno.com>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,6 +40,10 @@ __FBSDID("$FreeBSD$");
 #include <sys/firmware.h>
 #include <sys/proc.h>
 #include <sys/module.h>
+#include <sys/eventhandler.h>
+
+#include <sys/filedesc.h>
+#include <sys/vnode.h>
 
 /*
  * Loadable firmware support. See sys/sys/firmware.h and firmware(9)
@@ -88,7 +92,7 @@ struct priv_fw {
 	/*
 	 * 'file' is private info managed by the autoload/unload code.
 	 * Set at the end of firmware_get(), cleared only in the
-	 * firmware_task, so the latter can depend on its value even
+	 * firmware_unload_task, so the latter can depend on its value even
 	 * while the lock is not held.
 	 */
 	linker_file_t   file;	/* module file, if autoloaded */
@@ -120,14 +124,16 @@ struct priv_fw {
 static struct priv_fw firmware_table[FIRMWARE_MAX];
 
 /*
- * module release are handled in a separate task as they might sleep.
+ * Firmware module operations are handled in a separate task as they
+ * might sleep and they require directory context to do i/o.
  */
-struct task firmware_task;
+static struct taskqueue *firmware_tq;
+static struct task firmware_unload_task;
 
 /*
  * This mutex protects accesses to the firmware table.
  */
-struct mtx firmware_mtx;
+static struct mtx firmware_mtx;
 MTX_SYSINIT(firmware, &firmware_mtx, "firmware table", MTX_DEF);
 
 /*
@@ -226,7 +232,7 @@ firmware_unregister(const char *imagenam
 	} else if (fp->refcnt != 0) {	/* cannot unregister */
 		err = EBUSY;
 	}  else {
-		linker_file_t   x = fp->file;	/* save value */
+		linker_file_t x = fp->file;	/* save value */
 
 		if (fp->parent != NULL)	/* release parent reference */
 			fp->parent->refcnt--;
@@ -243,6 +249,47 @@ firmware_unregister(const char *imagenam
 	return err;
 }
 
+static void
+loadimage(void *arg, int npending)
+{
+	struct thread *td = curthread;
+	char *imagename = arg;
+	struct priv_fw *fp;
+	linker_file_t result;
+	int error;
+
+	/* synchronize with the thread that dispatched us */
+	mtx_lock(&firmware_mtx);
+	mtx_unlock(&firmware_mtx);
+
+	if (td->td_proc->p_fd->fd_rdir == NULL) {
+		printf("%s: root not mounted yet, no way to load image\n",
+		    imagename);
+		goto done;
+	}
+	error = linker_reference_module(imagename, NULL, &result);
+	if (error != 0) {
+		printf("%s: could not load firmware image, error %d\n",
+		    imagename, error);
+		goto done;
+	}
+
+	mtx_lock(&firmware_mtx);
+	fp = lookup(imagename, NULL);
+	if (fp == NULL || fp->file != NULL) {
+		mtx_unlock(&firmware_mtx);
+		if (fp == NULL)
+			printf("%s: firmware image loaded, "
+			    "but did not register\n", imagename);
+		(void) linker_release_module(imagename, NULL, NULL);
+		goto done;
+	}
+	fp->file = result;	/* record the module identity */
+	mtx_unlock(&firmware_mtx);
+done:
+	wakeup_one(imagename);		/* we're done */
+}
+
 /*
  * Lookup and potentially load the specified firmware image.
  * If the firmware is not found in the registry, try to load a kernel
@@ -253,9 +300,9 @@ firmware_unregister(const char *imagenam
 const struct firmware *
 firmware_get(const char *imagename)
 {
+	struct task fwload_task;
 	struct thread *td;
 	struct priv_fw *fp;
-	linker_file_t result;
 
 	mtx_lock(&firmware_mtx);
 	fp = lookup(imagename, NULL);
@@ -264,29 +311,34 @@ firmware_get(const char *imagename)
 	/*
 	 * Image not present, try to load the module holding it.
 	 */
-	mtx_unlock(&firmware_mtx);
 	td = curthread;
 	if (suser(td) != 0 ||
 	    securelevel_gt(td->td_ucred, 0) != 0) {
+		mtx_unlock(&firmware_mtx);
 		printf("%s: insufficient privileges to "
 		    "load firmware image %s\n", __func__, imagename);
 		return NULL;
 	}
-	(void) linker_reference_module(imagename, NULL, &result);
+	/* 
+	 * Defer load to a thread with known context.  linker_reference_module
+	 * may do filesystem i/o which requires root & current dirs, etc.
+	 * Also we must not hold any mtx's over this call which is problematic.
+	 */
+	if (!cold) {
+		TASK_INIT(&fwload_task, 0, loadimage, __DECONST(void *,
+		    imagename));
+		taskqueue_enqueue(firmware_tq, &fwload_task);
+		msleep(__DECONST(void *, imagename), &firmware_mtx, 0,
+		    "fwload", 0);
+	}
 	/*
-	 * After loading the module, see if the image is registered now.
+	 * After attempting to load the module, see if the image is registered.
 	 */
-	mtx_lock(&firmware_mtx);
 	fp = lookup(imagename, NULL);
 	if (fp == NULL) {
 		mtx_unlock(&firmware_mtx);
-		printf("%s: failed to load firmware image %s\n",
-			__func__, imagename);
-		(void) linker_release_module(imagename, NULL, NULL);
 		return NULL;
 	}
-	fp->file = result;	/* record the module identity */
-
 found:				/* common exit point on success */
 	fp->refcnt++;
 	mtx_unlock(&firmware_mtx);
@@ -299,8 +351,8 @@ found:				/* common exit point on succes
  * to release the resource, but the flag is only advisory.
  *
  * If this is the last reference to the firmware image, and this is an
- * autoloaded module, wake up the firmware_task to figure out what to do
- * with the associated module.
+ * autoloaded module, wake up the firmware_unload_task to figure out
+ * what to do with the associated module.
  */
 void
 firmware_put(const struct firmware *p, int flags)
@@ -313,12 +365,62 @@ firmware_put(const struct firmware *p, i
 		if (flags & FIRMWARE_UNLOAD)
 			fp->flags |= FW_UNLOAD;
 		if (fp->file)
-			taskqueue_enqueue(taskqueue_thread, &firmware_task);
+			taskqueue_enqueue(firmware_tq, &firmware_unload_task);
 	}
 	mtx_unlock(&firmware_mtx);
 }
 
 /*
+ * Setup directory state for the firmware_tq thread so we can do i/o.
+ */
+static void
+set_rootvnode(void *arg, int npending)
+{
+	struct thread *td = curthread;
+	struct proc *p = td->td_proc;
+
+	FILEDESC_LOCK(p->p_fd);
+	if (p->p_fd->fd_cdir == NULL) {
+		p->p_fd->fd_cdir = rootvnode;
+		VREF(rootvnode);
+	}
+	if (p->p_fd->fd_rdir == NULL) {
+		p->p_fd->fd_rdir = rootvnode;
+		VREF(rootvnode);
+	}
+	FILEDESC_UNLOCK(p->p_fd);
+
+	free(arg, M_TEMP);
+}
+
+/*
+ * Event handler called on mounting of /; bounce a task
+ * into the task queue thread to setup it's directories.
+ */
+static void
+firmware_mountroot(void *arg)
+{
+	struct task *setroot_task;
+
+	setroot_task = malloc(sizeof(struct task), M_TEMP, M_NOWAIT);
+	if (setroot_task != NULL) {
+		TASK_INIT(setroot_task, 0, set_rootvnode, setroot_task);
+		taskqueue_enqueue(firmware_tq, setroot_task);
+	} else
+		printf("%s: no memory for task!\n", __func__);
+}
+
+static eventhandler_tag mountroot_tag;
+static void
+mountroot_evh_init(void *ctx)
+{
+	mountroot_tag = EVENTHANDLER_REGISTER(mountroot,
+	    firmware_mountroot, ctx, 0);
+}
+SYSINIT(mountroot_evh_init, SI_SUB_CONFIGURE, SI_ORDER_ANY,
+    mountroot_evh_init, NULL);
+
+/*
  * The body of the task in charge of unloading autoloaded modules
  * that are not needed anymore.
  * Images can be cross-linked so we may need to make multiple passes,
@@ -382,11 +484,23 @@ static int
 firmware_modevent(module_t mod, int type, void *unused)
 {
 	struct priv_fw *fp;
-	int i, err = EINVAL;
+	int i, err;
 
 	switch (type) {
 	case MOD_LOAD:
-		TASK_INIT(&firmware_task, 0, unloadentry, NULL);
+		TASK_INIT(&firmware_unload_task, 0, unloadentry, NULL);
+		firmware_tq = taskqueue_create("taskqueue_firmware", M_WAITOK,
+		    taskqueue_thread_enqueue, &firmware_tq, NULL);
+		/* NB: use our own loop routine that sets up context */
+		(void) taskqueue_start_threads(&firmware_tq, 1, PWAIT,
+		    "firmware taskq");
+		if (rootvnode != NULL) {
+			/* 
+			 * Root is already mounted so we won't get an event;
+			 * simulate one here.
+			 */
+			firmware_mountroot(NULL);
+		}
 		return 0;
 
 	case MOD_UNLOAD:
@@ -397,8 +511,9 @@ firmware_modevent(module_t mod, int type
 			fp->flags |= FW_UNLOAD;;
 		}
 		mtx_unlock(&firmware_mtx);
-		taskqueue_enqueue(taskqueue_thread, &firmware_task);
-		taskqueue_drain(taskqueue_thread, &firmware_task);
+		taskqueue_enqueue(firmware_tq, &firmware_unload_task);
+		taskqueue_drain(firmware_tq, &firmware_unload_task);
+		err = 0;
 		for (i = 0; i < FIRMWARE_MAX; i++) {
 			fp = &firmware_table[i];
 			if (fp->fw.name != NULL) {
@@ -408,6 +523,8 @@ firmware_modevent(module_t mod, int type
 				err = EINVAL;
 			}
 		}
+		if (err == 0)
+			taskqueue_free(firmware_tq);
 		return err;
 	}
 	return EINVAL;

Modified: stable/6/sys/kern/vfs_mount.c
==============================================================================
--- stable/6/sys/kern/vfs_mount.c	Mon Oct 19 19:11:00 2009	(r198244)
+++ stable/6/sys/kern/vfs_mount.c	Mon Oct 19 19:14:04 2009	(r198245)
@@ -1360,6 +1360,8 @@ set_rootvnode(struct thread *td)
 	FILEDESC_UNLOCK(p->p_fd);
 
 	VOP_UNLOCK(rootvnode, 0, td);
+
+	EVENTHANDLER_INVOKE(mountroot);
 }
 
 /*

Modified: stable/6/sys/sys/eventhandler.h
==============================================================================
--- stable/6/sys/sys/eventhandler.h	Mon Oct 19 19:11:00 2009	(r198244)
+++ stable/6/sys/sys/eventhandler.h	Mon Oct 19 19:14:04 2009	(r198245)
@@ -156,6 +156,10 @@ typedef void (*vm_lowmem_handler_t)(void
 #define	LOWMEM_PRI_DEFAULT	EVENTHANDLER_PRI_FIRST
 EVENTHANDLER_DECLARE(vm_lowmem, vm_lowmem_handler_t);
 
+/* Root mounted event */
+typedef void (*mountroot_handler_t)(void *);
+EVENTHANDLER_DECLARE(mountroot, mountroot_handler_t);
+
 /*
  * Process events
  * process_fork and exit handlers are called without Giant.


More information about the svn-src-stable-6 mailing list