2006-01-29 02:52:42 +00:00
|
|
|
/*-
|
2008-04-09 19:07:48 +00:00
|
|
|
* Copyright (c) 2005-2008, Sam Leffler <sam@errno.com>
|
2006-01-29 02:52:42 +00:00
|
|
|
* 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 unmodified, 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 ``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 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/queue.h>
|
|
|
|
#include <sys/taskqueue.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/linker.h>
|
|
|
|
#include <sys/firmware.h>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
2006-01-29 02:52:42 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/module.h>
|
2008-04-09 19:07:48 +00:00
|
|
|
#include <sys/eventhandler.h>
|
|
|
|
|
|
|
|
#include <sys/filedesc.h>
|
|
|
|
#include <sys/vnode.h>
|
2006-01-29 02:52:42 +00:00
|
|
|
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
/*
|
|
|
|
* Loadable firmware support. See sys/sys/firmware.h and firmware(9)
|
|
|
|
* form more details on the subsystem.
|
|
|
|
*
|
|
|
|
* 'struct firmware' is the user-visible part of the firmware table.
|
|
|
|
* Additional internal information is stored in a 'struct priv_fw'
|
|
|
|
* (currently a static array). A slot is in use if FW_INUSE is true:
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define FW_INUSE(p) ((p)->file != NULL || (p)->fw.name != NULL)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fw.name != NULL when an image is registered; file != NULL for
|
|
|
|
* autoloaded images whose handling has not been completed.
|
|
|
|
*
|
|
|
|
* The state of a slot evolves as follows:
|
|
|
|
* firmware_register --> fw.name = image_name
|
|
|
|
* (autoloaded image) --> file = module reference
|
|
|
|
* firmware_unregister --> fw.name = NULL
|
|
|
|
* (unloadentry complete) --> file = NULL
|
|
|
|
*
|
|
|
|
* In order for the above to work, the 'file' field must remain
|
|
|
|
* unchanged in firmware_unregister().
|
|
|
|
*
|
|
|
|
* Images residing in the same module are linked to each other
|
|
|
|
* through the 'parent' argument of firmware_register().
|
|
|
|
* One image (typically, one with the same name as the module to let
|
|
|
|
* the autoloading mechanism work) is considered the parent image for
|
|
|
|
* all other images in the same module. Children affect the refcount
|
|
|
|
* on the parent image preventing improper unloading of the image itself.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct priv_fw {
|
|
|
|
int refcnt; /* reference count */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* parent entry, see above. Set on firmware_register(),
|
|
|
|
* cleared on firmware_unregister().
|
|
|
|
*/
|
|
|
|
struct priv_fw *parent;
|
|
|
|
|
|
|
|
int flags; /* record FIRMWARE_UNLOAD requests */
|
|
|
|
#define FW_UNLOAD 0x100
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'file' is private info managed by the autoload/unload code.
|
|
|
|
* Set at the end of firmware_get(), cleared only in the
|
2008-04-09 19:07:48 +00:00
|
|
|
* firmware_unload_task, so the latter can depend on its value even
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
* while the lock is not held.
|
|
|
|
*/
|
|
|
|
linker_file_t file; /* module file, if autoloaded */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'fw' is the externally visible image information.
|
|
|
|
* We do not make it the first field in priv_fw, to avoid the
|
|
|
|
* temptation of casting pointers to each other.
|
|
|
|
* Use PRIV_FW(fw) to get a pointer to the cointainer of fw.
|
|
|
|
* Beware, PRIV_FW does not work for a NULL pointer.
|
|
|
|
*/
|
|
|
|
struct firmware fw; /* externally visible information */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PRIV_FW returns the pointer to the container of struct firmware *x.
|
|
|
|
* Cast to intptr_t to override the 'const' attribute of x
|
|
|
|
*/
|
|
|
|
#define PRIV_FW(x) ((struct priv_fw *) \
|
|
|
|
((intptr_t)(x) - offsetof(struct priv_fw, fw)) )
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At the moment we use a static array as backing store for the registry.
|
|
|
|
* Should we move to a dynamic structure, keep in mind that we cannot
|
|
|
|
* reallocate the array because pointers are held externally.
|
|
|
|
* A list may work, though.
|
|
|
|
*/
|
2010-03-07 22:37:35 +00:00
|
|
|
#define FIRMWARE_MAX 50
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
static struct priv_fw firmware_table[FIRMWARE_MAX];
|
|
|
|
|
|
|
|
/*
|
2008-04-09 19:07:48 +00:00
|
|
|
* Firmware module operations are handled in a separate task as they
|
|
|
|
* might sleep and they require directory context to do i/o.
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
*/
|
2008-04-09 19:07:48 +00:00
|
|
|
static struct taskqueue *firmware_tq;
|
|
|
|
static struct task firmware_unload_task;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This mutex protects accesses to the firmware table.
|
|
|
|
*/
|
2008-04-09 19:07:48 +00:00
|
|
|
static struct mtx firmware_mtx;
|
2006-01-29 02:52:42 +00:00
|
|
|
MTX_SYSINIT(firmware, &firmware_mtx, "firmware table", MTX_DEF);
|
|
|
|
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
/*
|
|
|
|
* Helper function to lookup a name.
|
|
|
|
* As a side effect, it sets the pointer to a free slot, if any.
|
|
|
|
* This way we can concentrate most of the registry scanning in
|
|
|
|
* this function, which makes it easier to replace the registry
|
|
|
|
* with some other data structure.
|
|
|
|
*/
|
|
|
|
static struct priv_fw *
|
|
|
|
lookup(const char *name, struct priv_fw **empty_slot)
|
|
|
|
{
|
|
|
|
struct priv_fw *fp = NULL;
|
|
|
|
struct priv_fw *dummy;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (empty_slot == NULL)
|
|
|
|
empty_slot = &dummy;
|
|
|
|
*empty_slot = NULL;
|
|
|
|
for (i = 0; i < FIRMWARE_MAX; i++) {
|
|
|
|
fp = &firmware_table[i];
|
|
|
|
if (fp->fw.name != NULL && strcasecmp(name, fp->fw.name) == 0)
|
|
|
|
break;
|
|
|
|
else if (!FW_INUSE(fp))
|
|
|
|
*empty_slot = fp;
|
|
|
|
}
|
|
|
|
return (i < FIRMWARE_MAX ) ? fp : NULL;
|
|
|
|
}
|
|
|
|
|
2006-01-29 02:52:42 +00:00
|
|
|
/*
|
|
|
|
* Register a firmware image with the specified name. The
|
|
|
|
* image name must not already be registered. If this is a
|
|
|
|
* subimage then parent refers to a previously registered
|
|
|
|
* image that this should be associated with.
|
|
|
|
*/
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
const struct firmware *
|
2006-01-29 02:52:42 +00:00
|
|
|
firmware_register(const char *imagename, const void *data, size_t datasize,
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
unsigned int version, const struct firmware *parent)
|
2006-01-29 02:52:42 +00:00
|
|
|
{
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
struct priv_fw *match, *frp;
|
2012-04-13 04:22:42 +00:00
|
|
|
char *str;
|
|
|
|
|
|
|
|
str = strdup(imagename, M_TEMP);
|
2006-01-29 02:52:42 +00:00
|
|
|
|
|
|
|
mtx_lock(&firmware_mtx);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
/*
|
|
|
|
* Do a lookup to make sure the name is unique or find a free slot.
|
|
|
|
*/
|
|
|
|
match = lookup(imagename, &frp);
|
|
|
|
if (match != NULL) {
|
|
|
|
mtx_unlock(&firmware_mtx);
|
|
|
|
printf("%s: image %s already registered!\n",
|
|
|
|
__func__, imagename);
|
2012-04-13 04:22:42 +00:00
|
|
|
free(str, M_TEMP);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
return NULL;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
|
|
|
if (frp == NULL) {
|
|
|
|
mtx_unlock(&firmware_mtx);
|
|
|
|
printf("%s: cannot register image %s, firmware table full!\n",
|
|
|
|
__func__, imagename);
|
2012-04-13 04:22:42 +00:00
|
|
|
free(str, M_TEMP);
|
2006-01-29 02:52:42 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
bzero(frp, sizeof(frp)); /* start from a clean record */
|
2012-04-13 04:22:42 +00:00
|
|
|
frp->fw.name = str;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
frp->fw.data = data;
|
|
|
|
frp->fw.datasize = datasize;
|
|
|
|
frp->fw.version = version;
|
2011-11-19 00:20:28 +00:00
|
|
|
if (parent != NULL)
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
frp->parent = PRIV_FW(parent);
|
2006-01-29 02:52:42 +00:00
|
|
|
mtx_unlock(&firmware_mtx);
|
2007-02-03 16:01:46 +00:00
|
|
|
if (bootverbose)
|
|
|
|
printf("firmware: '%s' version %u: %zu bytes loaded at %p\n",
|
|
|
|
imagename, version, datasize, data);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
return &frp->fw;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unregister/remove a firmware image. If there are outstanding
|
|
|
|
* references an error is returned and the image is not removed
|
|
|
|
* from the registry.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
firmware_unregister(const char *imagename)
|
|
|
|
{
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
struct priv_fw *fp;
|
|
|
|
int err;
|
2006-01-29 02:52:42 +00:00
|
|
|
|
|
|
|
mtx_lock(&firmware_mtx);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
fp = lookup(imagename, NULL);
|
|
|
|
if (fp == NULL) {
|
|
|
|
/*
|
|
|
|
* It is ok for the lookup to fail; this can happen
|
|
|
|
* when a module is unloaded on last reference and the
|
|
|
|
* module unload handler unregister's each of it's
|
|
|
|
* firmware images.
|
|
|
|
*/
|
|
|
|
err = 0;
|
|
|
|
} else if (fp->refcnt != 0) { /* cannot unregister */
|
|
|
|
err = EBUSY;
|
2012-04-13 04:22:42 +00:00
|
|
|
} else {
|
2008-04-09 19:07:48 +00:00
|
|
|
linker_file_t x = fp->file; /* save value */
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the whole entry with bzero to make sure we
|
|
|
|
* do not forget anything. Then restore 'file' which is
|
|
|
|
* non-null for autoloaded images.
|
|
|
|
*/
|
2012-04-13 04:22:42 +00:00
|
|
|
free((void *) (uintptr_t) fp->fw.name, M_TEMP);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
bzero(fp, sizeof(struct priv_fw));
|
|
|
|
fp->file = x;
|
|
|
|
err = 0;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
|
|
|
mtx_unlock(&firmware_mtx);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
return err;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
|
|
|
|
2008-04-09 19:07:48 +00:00
|
|
|
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 */
|
|
|
|
}
|
|
|
|
|
2006-01-29 02:52:42 +00:00
|
|
|
/*
|
|
|
|
* Lookup and potentially load the specified firmware image.
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
* If the firmware is not found in the registry, try to load a kernel
|
|
|
|
* module named as the image name.
|
|
|
|
* If the firmware is located, a reference is returned. The caller must
|
|
|
|
* release this reference for the image to be eligible for removal/unload.
|
2006-01-29 02:52:42 +00:00
|
|
|
*/
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
const struct firmware *
|
2006-01-29 02:52:42 +00:00
|
|
|
firmware_get(const char *imagename)
|
|
|
|
{
|
2008-04-09 19:07:48 +00:00
|
|
|
struct task fwload_task;
|
2006-01-29 02:52:42 +00:00
|
|
|
struct thread *td;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
struct priv_fw *fp;
|
2006-01-29 02:52:42 +00:00
|
|
|
|
|
|
|
mtx_lock(&firmware_mtx);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
fp = lookup(imagename, NULL);
|
|
|
|
if (fp != NULL)
|
|
|
|
goto found;
|
2006-01-29 02:52:42 +00:00
|
|
|
/*
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
* Image not present, try to load the module holding it.
|
2006-01-29 02:52:42 +00:00
|
|
|
*/
|
|
|
|
td = curthread;
|
2006-11-06 13:42:10 +00:00
|
|
|
if (priv_check(td, PRIV_FIRMWARE_LOAD) != 0 ||
|
|
|
|
securelevel_gt(td->td_ucred, 0) != 0) {
|
2008-04-09 19:07:48 +00:00
|
|
|
mtx_unlock(&firmware_mtx);
|
2006-01-29 02:52:42 +00:00
|
|
|
printf("%s: insufficient privileges to "
|
|
|
|
"load firmware image %s\n", __func__, imagename);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-04-09 19:07:48 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-11-11 12:25:08 +00:00
|
|
|
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);
|
|
|
|
}
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
/*
|
2008-04-09 19:07:48 +00:00
|
|
|
* After attempting to load the module, see if the image is registered.
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
*/
|
|
|
|
fp = lookup(imagename, NULL);
|
|
|
|
if (fp == NULL) {
|
2006-01-29 02:52:42 +00:00
|
|
|
mtx_unlock(&firmware_mtx);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
return NULL;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
found: /* common exit point on success */
|
2011-11-19 00:20:28 +00:00
|
|
|
if (fp->refcnt == 0 && fp->parent != NULL)
|
|
|
|
fp->parent->refcnt++;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
fp->refcnt++;
|
2006-01-29 02:52:42 +00:00
|
|
|
mtx_unlock(&firmware_mtx);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
return &fp->fw;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
* Release a reference to a firmware image returned by firmware_get.
|
|
|
|
* The caller may specify, with the FIRMWARE_UNLOAD flag, its desire
|
|
|
|
* to release the resource, but the flag is only advisory.
|
|
|
|
*
|
|
|
|
* If this is the last reference to the firmware image, and this is an
|
2008-04-09 19:07:48 +00:00
|
|
|
* autoloaded module, wake up the firmware_unload_task to figure out
|
|
|
|
* what to do with the associated module.
|
2006-01-29 02:52:42 +00:00
|
|
|
*/
|
|
|
|
void
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
firmware_put(const struct firmware *p, int flags)
|
2006-01-29 02:52:42 +00:00
|
|
|
{
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
struct priv_fw *fp = PRIV_FW(p);
|
|
|
|
|
2006-01-29 02:52:42 +00:00
|
|
|
mtx_lock(&firmware_mtx);
|
|
|
|
fp->refcnt--;
|
2006-06-10 17:04:07 +00:00
|
|
|
if (fp->refcnt == 0) {
|
2011-11-19 00:20:28 +00:00
|
|
|
if (fp->parent != NULL)
|
|
|
|
fp->parent->refcnt--;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
if (flags & FIRMWARE_UNLOAD)
|
|
|
|
fp->flags |= FW_UNLOAD;
|
|
|
|
if (fp->file)
|
2008-04-09 19:07:48 +00:00
|
|
|
taskqueue_enqueue(firmware_tq, &firmware_unload_task);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
}
|
|
|
|
mtx_unlock(&firmware_mtx);
|
|
|
|
}
|
|
|
|
|
2008-04-09 19:07:48 +00:00
|
|
|
/*
|
|
|
|
* 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_XLOCK(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_XUNLOCK(p->p_fd);
|
2008-10-04 23:58:02 +00:00
|
|
|
|
|
|
|
free(arg, M_TEMP);
|
2008-04-09 19:07:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
2008-10-04 23:58:02 +00:00
|
|
|
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__);
|
2008-04-09 19:07:48 +00:00
|
|
|
}
|
|
|
|
EVENTHANDLER_DEFINE(mountroot, firmware_mountroot, NULL, 0);
|
|
|
|
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
/*
|
|
|
|
* 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,
|
|
|
|
* but the time we spend in the loop is bounded because we clear entries
|
|
|
|
* as we touch them.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
unloadentry(void *unused1, int unused2)
|
|
|
|
{
|
|
|
|
int limit = FIRMWARE_MAX;
|
|
|
|
int i; /* current cycle */
|
|
|
|
|
|
|
|
mtx_lock(&firmware_mtx);
|
|
|
|
/*
|
|
|
|
* Scan the table. limit is set to make sure we make another
|
|
|
|
* full sweep after matching an entry that requires unloading.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < limit; i++) {
|
|
|
|
struct priv_fw *fp;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
fp = &firmware_table[i % FIRMWARE_MAX];
|
|
|
|
if (fp->fw.name == NULL || fp->file == NULL ||
|
|
|
|
fp->refcnt != 0 || (fp->flags & FW_UNLOAD) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Found an entry. Now:
|
|
|
|
* 1. bump up limit to make sure we make another full round;
|
|
|
|
* 2. clear FW_UNLOAD so we don't try this entry again.
|
|
|
|
* 3. release the lock while trying to unload the module.
|
|
|
|
* 'file' remains set so that the entry cannot be reused
|
|
|
|
* in the meantime (it also means that fp->file will
|
|
|
|
* not change while we release the lock).
|
|
|
|
*/
|
|
|
|
limit = i + FIRMWARE_MAX; /* make another full round */
|
|
|
|
fp->flags &= ~FW_UNLOAD; /* do not try again */
|
|
|
|
|
|
|
|
mtx_unlock(&firmware_mtx);
|
|
|
|
err = linker_release_module(NULL, NULL, fp->file);
|
|
|
|
mtx_lock(&firmware_mtx);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We rely on the module to call firmware_unregister()
|
|
|
|
* on unload to actually release the entry.
|
|
|
|
* If err = 0 we can drop our reference as the system
|
|
|
|
* accepted it. Otherwise unloading failed (e.g. the
|
|
|
|
* module itself gave an error) so our reference is
|
|
|
|
* still valid.
|
|
|
|
*/
|
|
|
|
if (err == 0)
|
|
|
|
fp->file = NULL;
|
2006-06-10 17:04:07 +00:00
|
|
|
}
|
2006-01-29 02:52:42 +00:00
|
|
|
mtx_unlock(&firmware_mtx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Module glue.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
firmware_modevent(module_t mod, int type, void *unused)
|
|
|
|
{
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
struct priv_fw *fp;
|
2008-04-09 19:07:48 +00:00
|
|
|
int i, err;
|
2006-06-10 17:04:07 +00:00
|
|
|
|
2006-01-29 02:52:42 +00:00
|
|
|
switch (type) {
|
|
|
|
case MOD_LOAD:
|
2008-04-09 19:07:48 +00:00
|
|
|
TASK_INIT(&firmware_unload_task, 0, unloadentry, NULL);
|
|
|
|
firmware_tq = taskqueue_create("taskqueue_firmware", M_WAITOK,
|
|
|
|
taskqueue_thread_enqueue, &firmware_tq);
|
|
|
|
/* 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);
|
|
|
|
}
|
2006-01-29 02:52:42 +00:00
|
|
|
return 0;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
|
2006-01-29 02:52:42 +00:00
|
|
|
case MOD_UNLOAD:
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
/* request all autoloaded modules to be released */
|
|
|
|
mtx_lock(&firmware_mtx);
|
2006-06-10 17:04:07 +00:00
|
|
|
for (i = 0; i < FIRMWARE_MAX; i++) {
|
2006-06-13 21:34:12 +00:00
|
|
|
fp = &firmware_table[i];
|
2010-01-07 21:01:37 +00:00
|
|
|
fp->flags |= FW_UNLOAD;
|
2006-06-10 17:04:07 +00:00
|
|
|
}
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
mtx_unlock(&firmware_mtx);
|
2008-04-09 19:07:48 +00:00
|
|
|
taskqueue_enqueue(firmware_tq, &firmware_unload_task);
|
|
|
|
taskqueue_drain(firmware_tq, &firmware_unload_task);
|
|
|
|
err = 0;
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
for (i = 0; i < FIRMWARE_MAX; i++) {
|
|
|
|
fp = &firmware_table[i];
|
|
|
|
if (fp->fw.name != NULL) {
|
|
|
|
printf("%s: image %p ref %d still active slot %d\n",
|
|
|
|
__func__, fp->fw.name,
|
|
|
|
fp->refcnt, i);
|
|
|
|
err = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2008-04-09 19:07:48 +00:00
|
|
|
if (err == 0)
|
|
|
|
taskqueue_free(firmware_tq);
|
Cleanup and document the implementation of firmware(9) based on
a version that i posted earlier on the -current mailing list,
and subsequent feedback received.
The core of the change is just in sys/firmware.h and kern/subr_firmware.c,
while other files are just adaptation of the clients to the ABI change
(const-ification of some parameters and hiding of internal info,
so this is fully compatible at the binary level).
In detail:
- reduce the amount of information exported to clients in struct firmware,
and constify the pointer;
- internally, document and simplify the implementation of the various
functions, and make sure error conditions are dealt with properly.
The diffs are large, but the code is really straightforward now (i hope).
Note also that there is a subtle issue with the implementation of
firmware_register(): currently, as in the previous version, we just
store a reference to the 'imagename' argument, but we should rather
copy it because there is no guarantee that this is a static string.
I realised this while testing this code, but i prefer to fix it in
a later commit -- there is no regression with respect to the past.
Note, too, that the version in RELENG_6 has various bugs including
missing locks around the module release calls, mishandling of modules
loaded by /boot/loader, and so on, so an MFC is absolutely necessary
there. I was just postponing it until this cleanup to avoid doing
things twice.
MFC after: 1 week
2007-02-15 17:21:31 +00:00
|
|
|
return err;
|
2006-01-29 02:52:42 +00:00
|
|
|
}
|
|
|
|
return EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static moduledata_t firmware_mod = {
|
|
|
|
"firmware",
|
|
|
|
firmware_modevent,
|
2009-02-03 07:51:11 +00:00
|
|
|
NULL
|
2006-01-29 02:52:42 +00:00
|
|
|
};
|
|
|
|
DECLARE_MODULE(firmware, firmware_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
|
|
|
|
MODULE_VERSION(firmware, 1);
|