2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* firmware_class.c - Multi purpose firmware loading support
|
|
|
|
*
|
2007-06-04 10:45:44 -06:00
|
|
|
* Copyright (c) 2003 Manuel Estrada Sainz
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Please see Documentation/firmware_class/ for more information.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-01-11 13:17:46 -07:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-05-23 15:22:38 -06:00
|
|
|
#include <linux/mutex.h>
|
2012-03-28 15:31:00 -06:00
|
|
|
#include <linux/workqueue.h>
|
2009-04-09 23:04:07 -06:00
|
|
|
#include <linux/highmem.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/firmware.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2012-03-28 15:31:00 -06:00
|
|
|
#include <linux/sched.h>
|
2012-10-03 16:58:32 -06:00
|
|
|
#include <linux/file.h>
|
2012-08-03 22:01:21 -06:00
|
|
|
#include <linux/list.h>
|
2015-11-19 10:39:22 -07:00
|
|
|
#include <linux/fs.h>
|
2012-08-03 22:01:27 -06:00
|
|
|
#include <linux/async.h>
|
|
|
|
#include <linux/pm.h>
|
2012-08-03 22:01:29 -06:00
|
|
|
#include <linux/suspend.h>
|
2012-08-20 05:04:16 -06:00
|
|
|
#include <linux/syscore_ops.h>
|
2013-05-22 10:28:38 -06:00
|
|
|
#include <linux/reboot.h>
|
2014-02-25 14:06:00 -07:00
|
|
|
#include <linux/security.h>
|
2012-08-03 22:01:27 -06:00
|
|
|
|
2012-10-03 16:58:32 -06:00
|
|
|
#include <generated/utsrelease.h>
|
|
|
|
|
2012-08-03 22:01:27 -06:00
|
|
|
#include "base.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-04 10:45:44 -06:00
|
|
|
MODULE_AUTHOR("Manuel Estrada Sainz");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_DESCRIPTION("Multi purpose firmware loading support");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2010-03-14 00:49:18 -07:00
|
|
|
/* Builtin firmware support */
|
|
|
|
|
|
|
|
#ifdef CONFIG_FW_LOADER
|
|
|
|
|
|
|
|
extern struct builtin_fw __start_builtin_fw[];
|
|
|
|
extern struct builtin_fw __end_builtin_fw[];
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
static bool fw_get_builtin_firmware(struct firmware *fw, const char *name,
|
|
|
|
void *buf, size_t size)
|
2010-03-14 00:49:18 -07:00
|
|
|
{
|
|
|
|
struct builtin_fw *b_fw;
|
|
|
|
|
|
|
|
for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
|
|
|
|
if (strcmp(name, b_fw->name) == 0) {
|
|
|
|
fw->size = b_fw->size;
|
|
|
|
fw->data = b_fw->data;
|
2016-08-02 15:04:28 -06:00
|
|
|
|
|
|
|
if (buf && fw->size <= size)
|
|
|
|
memcpy(buf, fw->data, fw->size);
|
2010-03-14 00:49:18 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool fw_is_builtin_firmware(const struct firmware *fw)
|
|
|
|
{
|
|
|
|
struct builtin_fw *b_fw;
|
|
|
|
|
|
|
|
for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
|
|
|
|
if (fw->data == b_fw->data)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* Module case - no builtin firmware support */
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
static inline bool fw_get_builtin_firmware(struct firmware *fw,
|
|
|
|
const char *name, void *buf,
|
|
|
|
size_t size)
|
2010-03-14 00:49:18 -07:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool fw_is_builtin_firmware(const struct firmware *fw)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
enum {
|
|
|
|
FW_STATUS_LOADING,
|
|
|
|
FW_STATUS_DONE,
|
|
|
|
FW_STATUS_ABORT,
|
|
|
|
};
|
|
|
|
|
2007-01-25 13:56:15 -07:00
|
|
|
static int loading_timeout = 60; /* In seconds */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-28 15:30:02 -06:00
|
|
|
static inline long firmware_loading_timeout(void)
|
|
|
|
{
|
2015-01-12 09:02:01 -07:00
|
|
|
return loading_timeout > 0 ? loading_timeout * HZ : MAX_JIFFY_OFFSET;
|
2012-03-28 15:30:02 -06:00
|
|
|
}
|
|
|
|
|
2013-12-02 07:38:18 -07:00
|
|
|
/* firmware behavior options */
|
|
|
|
#define FW_OPT_UEVENT (1U << 0)
|
|
|
|
#define FW_OPT_NOWAIT (1U << 1)
|
2013-12-02 07:38:19 -07:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
firmware loader: allow disabling of udev as firmware loader
[The patch was originally proposed by Tom Gundersen, and rewritten
afterwards by me; most of changelogs below borrowed from Tom's
original patch -- tiwai]
Currently (at least) the dell-rbu driver selects FW_LOADER_USER_HELPER,
which means that distros can't really stop loading firmware through
udev without breaking other users (though some have).
Ideally we would remove/disable the udev firmware helper in both the
kernel and in udev, but if we were to disable it in udev and not the
kernel, the result would be (seemingly) hung kernels as no one would
be around to cancel firmware requests.
This patch allows udev firmware loading to be disabled while still
allowing non-udev firmware loading, as done by the dell-rbu driver, to
continue working. This is achieved by only using the fallback
mechanism when the uevent is suppressed.
The patch renames the user-selectable Kconfig from FW_LOADER_USER_HELPER
to FW_LOADER_USER_HELPER_FALLBACK, and the former is reverse-selected
by the latter or the drivers that need userhelper like dell-rbu.
Also, the "default y" is removed together with this change, since it's
been deprecated in udev upstream, thus rather better to disable it
nowadays.
Tested with
FW_LOADER_USER_HELPER=n
LATTICE_ECP3_CONFIG=y
DELL_RBU=y
and udev without the firmware loading support, but I don't have the
hardware to test the lattice/dell drivers, so additional testing would
be appreciated.
Reviewed-by: Tom Gundersen <teg@jklm.no>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Abhay Salunke <Abhay_Salunke@dell.com>
Cc: Stefan Roese <sr@denx.de>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Kay Sievers <kay@vrfy.org>
Tested-by: Balaji Singh <B_B_Singh@DELL.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-06-04 09:48:15 -06:00
|
|
|
#define FW_OPT_USERHELPER (1U << 2)
|
2013-12-02 07:38:19 -07:00
|
|
|
#else
|
firmware loader: allow disabling of udev as firmware loader
[The patch was originally proposed by Tom Gundersen, and rewritten
afterwards by me; most of changelogs below borrowed from Tom's
original patch -- tiwai]
Currently (at least) the dell-rbu driver selects FW_LOADER_USER_HELPER,
which means that distros can't really stop loading firmware through
udev without breaking other users (though some have).
Ideally we would remove/disable the udev firmware helper in both the
kernel and in udev, but if we were to disable it in udev and not the
kernel, the result would be (seemingly) hung kernels as no one would
be around to cancel firmware requests.
This patch allows udev firmware loading to be disabled while still
allowing non-udev firmware loading, as done by the dell-rbu driver, to
continue working. This is achieved by only using the fallback
mechanism when the uevent is suppressed.
The patch renames the user-selectable Kconfig from FW_LOADER_USER_HELPER
to FW_LOADER_USER_HELPER_FALLBACK, and the former is reverse-selected
by the latter or the drivers that need userhelper like dell-rbu.
Also, the "default y" is removed together with this change, since it's
been deprecated in udev upstream, thus rather better to disable it
nowadays.
Tested with
FW_LOADER_USER_HELPER=n
LATTICE_ECP3_CONFIG=y
DELL_RBU=y
and udev without the firmware loading support, but I don't have the
hardware to test the lattice/dell drivers, so additional testing would
be appreciated.
Reviewed-by: Tom Gundersen <teg@jklm.no>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Abhay Salunke <Abhay_Salunke@dell.com>
Cc: Stefan Roese <sr@denx.de>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Kay Sievers <kay@vrfy.org>
Tested-by: Balaji Singh <B_B_Singh@DELL.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-06-04 09:48:15 -06:00
|
|
|
#define FW_OPT_USERHELPER 0
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK
|
|
|
|
#define FW_OPT_FALLBACK FW_OPT_USERHELPER
|
|
|
|
#else
|
|
|
|
#define FW_OPT_FALLBACK 0
|
2013-12-02 07:38:19 -07:00
|
|
|
#endif
|
2014-07-02 10:55:05 -06:00
|
|
|
#define FW_OPT_NO_WARN (1U << 3)
|
2016-08-02 15:04:25 -06:00
|
|
|
#define FW_OPT_NOCACHE (1U << 4)
|
2013-12-02 07:38:18 -07:00
|
|
|
|
2012-08-03 22:01:21 -06:00
|
|
|
struct firmware_cache {
|
|
|
|
/* firmware_buf instance will be added into the below list */
|
|
|
|
spinlock_t lock;
|
|
|
|
struct list_head head;
|
2012-09-08 03:32:30 -06:00
|
|
|
int state;
|
2012-08-03 22:01:27 -06:00
|
|
|
|
2012-09-08 03:32:30 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-08-03 22:01:27 -06:00
|
|
|
/*
|
|
|
|
* Names of firmware images which have been cached successfully
|
|
|
|
* will be added into the below list so that device uncache
|
|
|
|
* helper can trace which firmware images have been cached
|
|
|
|
* before.
|
|
|
|
*/
|
|
|
|
spinlock_t name_lock;
|
|
|
|
struct list_head fw_names;
|
|
|
|
|
|
|
|
struct delayed_work work;
|
2012-08-03 22:01:29 -06:00
|
|
|
|
|
|
|
struct notifier_block pm_notify;
|
2012-09-08 03:32:30 -06:00
|
|
|
#endif
|
2012-08-03 22:01:21 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-03 22:01:20 -06:00
|
|
|
struct firmware_buf {
|
2012-08-03 22:01:21 -06:00
|
|
|
struct kref ref;
|
|
|
|
struct list_head list;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct completion completion;
|
2012-08-03 22:01:21 -06:00
|
|
|
struct firmware_cache *fwc;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long status;
|
2012-08-03 22:01:16 -06:00
|
|
|
void *data;
|
|
|
|
size_t size;
|
2016-08-02 15:04:28 -06:00
|
|
|
size_t allocated_size;
|
2013-01-31 03:13:55 -07:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
2013-01-31 03:13:56 -07:00
|
|
|
bool is_paged_buf;
|
2013-05-27 04:30:04 -06:00
|
|
|
bool need_uevent;
|
2009-04-09 23:04:07 -06:00
|
|
|
struct page **pages;
|
|
|
|
int nr_pages;
|
|
|
|
int page_array_size;
|
2013-05-22 10:28:38 -06:00
|
|
|
struct list_head pending_list;
|
2013-01-31 03:13:55 -07:00
|
|
|
#endif
|
2015-05-12 15:49:43 -06:00
|
|
|
const char *fw_id;
|
2012-08-03 22:01:20 -06:00
|
|
|
};
|
|
|
|
|
2012-08-03 22:01:27 -06:00
|
|
|
struct fw_cache_entry {
|
|
|
|
struct list_head list;
|
2015-05-12 15:49:43 -06:00
|
|
|
const char *name;
|
2012-08-03 22:01:27 -06:00
|
|
|
};
|
|
|
|
|
2012-08-03 22:01:25 -06:00
|
|
|
struct fw_name_devm {
|
|
|
|
unsigned long magic;
|
2015-05-12 15:49:43 -06:00
|
|
|
const char *name;
|
2012-08-03 22:01:25 -06:00
|
|
|
};
|
|
|
|
|
2012-08-03 22:01:21 -06:00
|
|
|
#define to_fwbuf(d) container_of(d, struct firmware_buf, ref)
|
|
|
|
|
2012-08-20 05:04:16 -06:00
|
|
|
#define FW_LOADER_NO_CACHE 0
|
|
|
|
#define FW_LOADER_START_CACHE 1
|
|
|
|
|
|
|
|
static int fw_cache_piggyback_on_request(const char *name);
|
|
|
|
|
2012-08-03 22:01:21 -06:00
|
|
|
/* fw_lock could be moved to 'struct firmware_priv' but since it is just
|
|
|
|
* guarding for corner cases a global lock should be OK */
|
|
|
|
static DEFINE_MUTEX(fw_lock);
|
|
|
|
|
|
|
|
static struct firmware_cache fw_cache;
|
|
|
|
|
|
|
|
static struct firmware_buf *__allocate_fw_buf(const char *fw_name,
|
2016-08-02 15:04:28 -06:00
|
|
|
struct firmware_cache *fwc,
|
|
|
|
void *dbuf, size_t size)
|
2012-08-03 22:01:21 -06:00
|
|
|
{
|
|
|
|
struct firmware_buf *buf;
|
|
|
|
|
2015-05-12 15:49:43 -06:00
|
|
|
buf = kzalloc(sizeof(*buf), GFP_ATOMIC);
|
2012-08-03 22:01:21 -06:00
|
|
|
if (!buf)
|
2015-05-12 15:49:43 -06:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
buf->fw_id = kstrdup_const(fw_name, GFP_ATOMIC);
|
|
|
|
if (!buf->fw_id) {
|
|
|
|
kfree(buf);
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-08-03 22:01:21 -06:00
|
|
|
|
|
|
|
kref_init(&buf->ref);
|
|
|
|
buf->fwc = fwc;
|
2016-08-02 15:04:28 -06:00
|
|
|
buf->data = dbuf;
|
|
|
|
buf->allocated_size = size;
|
2012-08-03 22:01:21 -06:00
|
|
|
init_completion(&buf->completion);
|
2013-05-22 10:28:38 -06:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
|
|
|
INIT_LIST_HEAD(&buf->pending_list);
|
|
|
|
#endif
|
2012-08-03 22:01:21 -06:00
|
|
|
|
|
|
|
pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf);
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:22 -06:00
|
|
|
static struct firmware_buf *__fw_lookup_buf(const char *fw_name)
|
|
|
|
{
|
|
|
|
struct firmware_buf *tmp;
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
|
|
|
|
list_for_each_entry(tmp, &fwc->head, list)
|
|
|
|
if (!strcmp(tmp->fw_id, fw_name))
|
|
|
|
return tmp;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:21 -06:00
|
|
|
static int fw_lookup_and_allocate_buf(const char *fw_name,
|
|
|
|
struct firmware_cache *fwc,
|
2016-08-02 15:04:28 -06:00
|
|
|
struct firmware_buf **buf, void *dbuf,
|
|
|
|
size_t size)
|
2012-08-03 22:01:21 -06:00
|
|
|
{
|
|
|
|
struct firmware_buf *tmp;
|
|
|
|
|
|
|
|
spin_lock(&fwc->lock);
|
2012-08-03 22:01:22 -06:00
|
|
|
tmp = __fw_lookup_buf(fw_name);
|
|
|
|
if (tmp) {
|
|
|
|
kref_get(&tmp->ref);
|
|
|
|
spin_unlock(&fwc->lock);
|
|
|
|
*buf = tmp;
|
|
|
|
return 1;
|
|
|
|
}
|
2016-08-02 15:04:28 -06:00
|
|
|
tmp = __allocate_fw_buf(fw_name, fwc, dbuf, size);
|
2012-08-03 22:01:21 -06:00
|
|
|
if (tmp)
|
|
|
|
list_add(&tmp->list, &fwc->head);
|
|
|
|
spin_unlock(&fwc->lock);
|
|
|
|
|
|
|
|
*buf = tmp;
|
|
|
|
|
|
|
|
return tmp ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __fw_free_buf(struct kref *ref)
|
2014-01-04 06:20:36 -07:00
|
|
|
__releases(&fwc->lock)
|
2012-08-03 22:01:21 -06:00
|
|
|
{
|
|
|
|
struct firmware_buf *buf = to_fwbuf(ref);
|
|
|
|
struct firmware_cache *fwc = buf->fwc;
|
|
|
|
|
|
|
|
pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
|
|
|
|
__func__, buf->fw_id, buf, buf->data,
|
|
|
|
(unsigned int)buf->size);
|
|
|
|
|
|
|
|
list_del(&buf->list);
|
|
|
|
spin_unlock(&fwc->lock);
|
|
|
|
|
2013-01-31 03:13:55 -07:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
2013-01-31 03:13:56 -07:00
|
|
|
if (buf->is_paged_buf) {
|
2013-01-31 03:13:55 -07:00
|
|
|
int i;
|
2012-10-08 22:01:03 -06:00
|
|
|
vunmap(buf->data);
|
|
|
|
for (i = 0; i < buf->nr_pages; i++)
|
|
|
|
__free_page(buf->pages[i]);
|
2015-12-16 02:03:15 -07:00
|
|
|
vfree(buf->pages);
|
2012-10-08 22:01:03 -06:00
|
|
|
} else
|
2013-01-31 03:13:55 -07:00
|
|
|
#endif
|
2016-08-02 15:04:28 -06:00
|
|
|
if (!buf->allocated_size)
|
2012-10-08 22:01:03 -06:00
|
|
|
vfree(buf->data);
|
2015-05-12 15:49:43 -06:00
|
|
|
kfree_const(buf->fw_id);
|
2012-08-03 22:01:21 -06:00
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fw_free_buf(struct firmware_buf *buf)
|
|
|
|
{
|
2012-11-09 10:27:22 -07:00
|
|
|
struct firmware_cache *fwc = buf->fwc;
|
|
|
|
spin_lock(&fwc->lock);
|
|
|
|
if (!kref_put(&buf->ref, __fw_free_buf))
|
|
|
|
spin_unlock(&fwc->lock);
|
2012-08-03 22:01:21 -06:00
|
|
|
}
|
|
|
|
|
2012-10-08 22:01:03 -06:00
|
|
|
/* direct firmware loading support */
|
2012-11-03 03:47:58 -06:00
|
|
|
static char fw_path_para[256];
|
|
|
|
static const char * const fw_path[] = {
|
|
|
|
fw_path_para,
|
2012-10-08 22:01:03 -06:00
|
|
|
"/lib/firmware/updates/" UTS_RELEASE,
|
|
|
|
"/lib/firmware/updates",
|
|
|
|
"/lib/firmware/" UTS_RELEASE,
|
|
|
|
"/lib/firmware"
|
|
|
|
};
|
|
|
|
|
2012-11-03 03:47:58 -06:00
|
|
|
/*
|
|
|
|
* Typical usage is that passing 'firmware_class.path=$CUSTOMIZED_PATH'
|
|
|
|
* from kernel command line because firmware_class is generally built in
|
|
|
|
* kernel instead of module.
|
|
|
|
*/
|
|
|
|
module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
|
|
|
|
MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
|
|
|
|
|
2015-07-30 16:48:57 -06:00
|
|
|
static void fw_finish_direct_load(struct device *device,
|
|
|
|
struct firmware_buf *buf)
|
|
|
|
{
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
set_bit(FW_STATUS_DONE, &buf->status);
|
|
|
|
complete_all(&buf->completion);
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
}
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
static int
|
|
|
|
fw_get_filesystem_firmware(struct device *device, struct firmware_buf *buf)
|
2012-10-08 22:01:03 -06:00
|
|
|
{
|
2015-11-19 10:39:22 -07:00
|
|
|
loff_t size;
|
2015-05-12 15:49:41 -06:00
|
|
|
int i, len;
|
2013-09-06 13:36:08 -06:00
|
|
|
int rc = -ENOENT;
|
2015-05-12 15:49:40 -06:00
|
|
|
char *path;
|
2016-08-02 15:04:28 -06:00
|
|
|
enum kernel_read_file_id id = READING_FIRMWARE;
|
|
|
|
size_t msize = INT_MAX;
|
|
|
|
|
|
|
|
/* Already populated data member means we're loading into a buffer */
|
|
|
|
if (buf->data) {
|
|
|
|
id = READING_FIRMWARE_PREALLOC_BUFFER;
|
|
|
|
msize = buf->allocated_size;
|
|
|
|
}
|
2015-05-12 15:49:40 -06:00
|
|
|
|
|
|
|
path = __getname();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2012-10-08 22:01:03 -06:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
|
2012-11-03 03:47:58 -06:00
|
|
|
/* skip the unset customized path */
|
|
|
|
if (!fw_path[i][0])
|
|
|
|
continue;
|
|
|
|
|
2015-05-12 15:49:41 -06:00
|
|
|
len = snprintf(path, PATH_MAX, "%s/%s",
|
|
|
|
fw_path[i], buf->fw_id);
|
|
|
|
if (len >= PATH_MAX) {
|
|
|
|
rc = -ENAMETOOLONG;
|
|
|
|
break;
|
|
|
|
}
|
2012-10-08 22:01:03 -06:00
|
|
|
|
2015-11-19 10:39:22 -07:00
|
|
|
buf->size = 0;
|
2016-08-02 15:04:28 -06:00
|
|
|
rc = kernel_read_file_from_path(path, &buf->data, &size, msize,
|
|
|
|
id);
|
2016-02-04 14:15:02 -07:00
|
|
|
if (rc) {
|
2016-02-28 13:57:55 -07:00
|
|
|
if (rc == -ENOENT)
|
|
|
|
dev_dbg(device, "loading %s failed with error %d\n",
|
|
|
|
path, rc);
|
|
|
|
else
|
|
|
|
dev_warn(device, "loading %s failed with error %d\n",
|
|
|
|
path, rc);
|
2016-02-04 14:15:02 -07:00
|
|
|
continue;
|
|
|
|
}
|
2015-11-19 10:39:22 -07:00
|
|
|
dev_dbg(device, "direct-loading %s\n", buf->fw_id);
|
|
|
|
buf->size = size;
|
2015-07-30 16:48:57 -06:00
|
|
|
fw_finish_direct_load(device, buf);
|
2016-02-04 14:15:02 -07:00
|
|
|
break;
|
2013-01-31 03:13:54 -07:00
|
|
|
}
|
2016-02-04 14:15:02 -07:00
|
|
|
__putname(path);
|
2013-01-31 03:13:54 -07:00
|
|
|
|
2013-09-06 13:36:08 -06:00
|
|
|
return rc;
|
2012-10-08 22:01:03 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 03:13:55 -07:00
|
|
|
/* firmware holds the ownership of pages */
|
|
|
|
static void firmware_free_data(const struct firmware *fw)
|
|
|
|
{
|
|
|
|
/* Loaded directly? */
|
|
|
|
if (!fw->priv) {
|
|
|
|
vfree(fw->data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fw_free_buf(fw->priv);
|
|
|
|
}
|
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
/* store the pages buffer info firmware from buf */
|
|
|
|
static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
|
|
|
|
{
|
|
|
|
fw->priv = buf;
|
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
|
|
|
fw->pages = buf->pages;
|
|
|
|
#endif
|
|
|
|
fw->size = buf->size;
|
|
|
|
fw->data = buf->data;
|
|
|
|
|
|
|
|
pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
|
|
|
|
__func__, buf->fw_id, buf, buf->data,
|
|
|
|
(unsigned int)buf->size);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static void fw_name_devm_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
struct fw_name_devm *fwn = res;
|
|
|
|
|
|
|
|
if (fwn->magic == (unsigned long)&fw_cache)
|
|
|
|
pr_debug("%s: fw_name-%s devm-%p released\n",
|
|
|
|
__func__, fwn->name, res);
|
2015-05-12 15:49:43 -06:00
|
|
|
kfree_const(fwn->name);
|
2013-01-31 03:13:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int fw_devm_match(struct device *dev, void *res,
|
|
|
|
void *match_data)
|
|
|
|
{
|
|
|
|
struct fw_name_devm *fwn = res;
|
|
|
|
|
|
|
|
return (fwn->magic == (unsigned long)&fw_cache) &&
|
|
|
|
!strcmp(fwn->name, match_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct fw_name_devm *fw_find_devm_name(struct device *dev,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct fw_name_devm *fwn;
|
|
|
|
|
|
|
|
fwn = devres_find(dev, fw_name_devm_release,
|
|
|
|
fw_devm_match, (void *)name);
|
|
|
|
return fwn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add firmware name into devres list */
|
|
|
|
static int fw_add_devm_name(struct device *dev, const char *name)
|
|
|
|
{
|
|
|
|
struct fw_name_devm *fwn;
|
|
|
|
|
|
|
|
fwn = fw_find_devm_name(dev, name);
|
|
|
|
if (fwn)
|
|
|
|
return 1;
|
|
|
|
|
2015-05-12 15:49:43 -06:00
|
|
|
fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm),
|
|
|
|
GFP_KERNEL);
|
2013-01-31 03:13:56 -07:00
|
|
|
if (!fwn)
|
|
|
|
return -ENOMEM;
|
2015-05-12 15:49:43 -06:00
|
|
|
fwn->name = kstrdup_const(name, GFP_KERNEL);
|
|
|
|
if (!fwn->name) {
|
2015-07-29 14:26:28 -06:00
|
|
|
devres_free(fwn);
|
2015-05-12 15:49:43 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2013-01-31 03:13:56 -07:00
|
|
|
|
|
|
|
fwn->magic = (unsigned long)&fw_cache;
|
|
|
|
devres_add(dev, fwn);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static int fw_add_devm_name(struct device *dev, const char *name)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* user-mode helper code
|
|
|
|
*/
|
2013-01-31 03:13:55 -07:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
2013-01-31 03:13:56 -07:00
|
|
|
struct firmware_priv {
|
|
|
|
bool nowait;
|
|
|
|
struct device dev;
|
|
|
|
struct firmware_buf *buf;
|
|
|
|
struct firmware *fw;
|
|
|
|
};
|
2013-01-31 03:13:55 -07:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static struct firmware_priv *to_firmware_priv(struct device *dev)
|
|
|
|
{
|
|
|
|
return container_of(dev, struct firmware_priv, dev);
|
|
|
|
}
|
|
|
|
|
2013-06-19 21:26:43 -06:00
|
|
|
static void __fw_load_abort(struct firmware_buf *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-06-15 02:36:38 -06:00
|
|
|
/*
|
|
|
|
* There is a small window in which user can write to 'loading'
|
|
|
|
* between loading done and disappearance of 'loading'
|
|
|
|
*/
|
|
|
|
if (test_bit(FW_STATUS_DONE, &buf->status))
|
|
|
|
return;
|
|
|
|
|
2013-05-22 10:28:38 -06:00
|
|
|
list_del_init(&buf->pending_list);
|
2012-08-03 22:01:20 -06:00
|
|
|
set_bit(FW_STATUS_ABORT, &buf->status);
|
2012-08-03 22:01:21 -06:00
|
|
|
complete_all(&buf->completion);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-06-19 21:26:43 -06:00
|
|
|
static void fw_load_abort(struct firmware_priv *fw_priv)
|
|
|
|
{
|
|
|
|
struct firmware_buf *buf = fw_priv->buf;
|
|
|
|
|
|
|
|
__fw_load_abort(buf);
|
2013-06-15 02:36:38 -06:00
|
|
|
|
|
|
|
/* avoid user action after loading abort */
|
|
|
|
fw_priv->buf = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 03:13:57 -07:00
|
|
|
#define is_fw_load_aborted(buf) \
|
|
|
|
test_bit(FW_STATUS_ABORT, &(buf)->status)
|
|
|
|
|
2013-05-22 10:28:38 -06:00
|
|
|
static LIST_HEAD(pending_fw_head);
|
|
|
|
|
|
|
|
/* reboot notifier for avoid deadlock with usermode_lock */
|
|
|
|
static int fw_shutdown_notify(struct notifier_block *unused1,
|
|
|
|
unsigned long unused2, void *unused3)
|
|
|
|
{
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
while (!list_empty(&pending_fw_head))
|
2013-06-19 21:26:43 -06:00
|
|
|
__fw_load_abort(list_first_entry(&pending_fw_head,
|
2013-05-22 10:28:38 -06:00
|
|
|
struct firmware_buf,
|
|
|
|
pending_list));
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block fw_shutdown_nb = {
|
|
|
|
.notifier_call = fw_shutdown_notify,
|
|
|
|
};
|
|
|
|
|
2013-08-23 18:08:48 -06:00
|
|
|
static ssize_t timeout_show(struct class *class, struct class_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sprintf(buf, "%d\n", loading_timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-30 16:03:01 -07:00
|
|
|
* firmware_timeout_store - set number of seconds to wait for firmware
|
|
|
|
* @class: device class pointer
|
2010-03-10 12:47:58 -07:00
|
|
|
* @attr: device attribute pointer
|
2005-10-30 16:03:01 -07:00
|
|
|
* @buf: buffer to scan for timeout value
|
|
|
|
* @count: number of bytes in @buf
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Sets the number of seconds to wait for the firmware. Once
|
2005-10-30 16:03:01 -07:00
|
|
|
* this expires an error will be returned to the driver and no
|
2005-04-16 16:20:36 -06:00
|
|
|
* firmware will be provided.
|
|
|
|
*
|
2005-10-30 16:03:01 -07:00
|
|
|
* Note: zero means 'wait forever'.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2013-08-23 18:08:48 -06:00
|
|
|
static ssize_t timeout_store(struct class *class, struct class_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
loading_timeout = simple_strtol(buf, NULL, 10);
|
2005-06-28 21:44:51 -06:00
|
|
|
if (loading_timeout < 0)
|
|
|
|
loading_timeout = 0;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return count;
|
|
|
|
}
|
2016-11-28 08:42:30 -07:00
|
|
|
static CLASS_ATTR_RW(timeout);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-11-28 08:42:30 -07:00
|
|
|
static struct attribute *firmware_class_attrs[] = {
|
|
|
|
&class_attr_timeout.attr,
|
|
|
|
NULL,
|
2010-03-14 00:49:13 -07:00
|
|
|
};
|
2016-11-28 08:42:30 -07:00
|
|
|
ATTRIBUTE_GROUPS(firmware_class);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-03 22:01:20 -06:00
|
|
|
static void fw_dev_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2012-08-03 22:01:16 -06:00
|
|
|
|
2010-03-14 00:49:13 -07:00
|
|
|
kfree(fw_priv);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-07-09 12:20:01 -06:00
|
|
|
static int do_firmware_uevent(struct firmware_priv *fw_priv, struct kobj_uevent_env *env)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-08-03 22:01:20 -06:00
|
|
|
if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->buf->fw_id))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
2007-08-14 07:15:12 -06:00
|
|
|
if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
|
2005-04-18 22:57:31 -06:00
|
|
|
return -ENOMEM;
|
2010-03-29 09:57:20 -06:00
|
|
|
if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
|
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-09 12:20:01 -06:00
|
|
|
static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
if (fw_priv->buf)
|
|
|
|
err = do_firmware_uevent(fw_priv, env);
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-05-20 16:00:16 -06:00
|
|
|
static struct class firmware_class = {
|
|
|
|
.name = "firmware",
|
2016-11-28 08:42:30 -07:00
|
|
|
.class_groups = firmware_class_groups,
|
2006-09-14 08:30:59 -06:00
|
|
|
.dev_uevent = firmware_uevent,
|
|
|
|
.dev_release = fw_dev_release,
|
2006-05-20 16:00:16 -06:00
|
|
|
};
|
|
|
|
|
2006-09-14 08:30:59 -06:00
|
|
|
static ssize_t firmware_loading_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2013-06-15 02:36:38 -06:00
|
|
|
int loading = 0;
|
|
|
|
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
if (fw_priv->buf)
|
|
|
|
loading = test_bit(FW_STATUS_LOADING, &fw_priv->buf->status);
|
|
|
|
mutex_unlock(&fw_lock);
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return sprintf(buf, "%d\n", loading);
|
|
|
|
}
|
|
|
|
|
2009-04-09 23:04:07 -06:00
|
|
|
/* Some architectures don't have PAGE_KERNEL_RO */
|
|
|
|
#ifndef PAGE_KERNEL_RO
|
|
|
|
#define PAGE_KERNEL_RO PAGE_KERNEL
|
|
|
|
#endif
|
2012-10-08 22:01:02 -06:00
|
|
|
|
|
|
|
/* one pages buffer should be mapped/unmapped only once */
|
|
|
|
static int fw_map_pages_buf(struct firmware_buf *buf)
|
|
|
|
{
|
2013-01-31 03:13:56 -07:00
|
|
|
if (!buf->is_paged_buf)
|
2012-10-08 22:01:03 -06:00
|
|
|
return 0;
|
|
|
|
|
2014-11-19 03:38:38 -07:00
|
|
|
vunmap(buf->data);
|
2012-10-08 22:01:02 -06:00
|
|
|
buf->data = vmap(buf->pages, buf->nr_pages, 0, PAGE_KERNEL_RO);
|
|
|
|
if (!buf->data)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2005-10-30 16:03:01 -07:00
|
|
|
* firmware_loading_store - set value in the 'loading' control file
|
2006-09-14 08:30:59 -06:00
|
|
|
* @dev: device pointer
|
2006-12-22 02:06:52 -07:00
|
|
|
* @attr: device attribute pointer
|
2005-10-30 16:03:01 -07:00
|
|
|
* @buf: buffer to scan for loading control value
|
|
|
|
* @count: number of bytes in @buf
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* The relevant values are:
|
|
|
|
*
|
|
|
|
* 1: Start a load, discarding any previous partial load.
|
2005-10-30 16:03:01 -07:00
|
|
|
* 0: Conclude the load and hand the data to the driver code.
|
2005-04-16 16:20:36 -06:00
|
|
|
* -1: Conclude the load with an error and discard any written data.
|
|
|
|
**/
|
2006-09-14 08:30:59 -06:00
|
|
|
static ssize_t firmware_loading_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2013-06-15 02:36:38 -06:00
|
|
|
struct firmware_buf *fw_buf;
|
2014-02-25 14:06:00 -07:00
|
|
|
ssize_t written = count;
|
2005-04-16 16:20:36 -06:00
|
|
|
int loading = simple_strtol(buf, NULL, 10);
|
2009-04-09 23:04:07 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-01-02 13:31:23 -07:00
|
|
|
mutex_lock(&fw_lock);
|
2013-06-15 02:36:38 -06:00
|
|
|
fw_buf = fw_priv->buf;
|
2012-08-03 22:01:20 -06:00
|
|
|
if (!fw_buf)
|
2012-01-02 13:31:23 -07:00
|
|
|
goto out;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (loading) {
|
|
|
|
case 1:
|
2012-08-03 22:01:16 -06:00
|
|
|
/* discarding any previous partial load */
|
2012-08-03 22:01:20 -06:00
|
|
|
if (!test_bit(FW_STATUS_DONE, &fw_buf->status)) {
|
|
|
|
for (i = 0; i < fw_buf->nr_pages; i++)
|
|
|
|
__free_page(fw_buf->pages[i]);
|
2015-12-16 02:03:15 -07:00
|
|
|
vfree(fw_buf->pages);
|
2012-08-03 22:01:20 -06:00
|
|
|
fw_buf->pages = NULL;
|
|
|
|
fw_buf->page_array_size = 0;
|
|
|
|
fw_buf->nr_pages = 0;
|
|
|
|
set_bit(FW_STATUS_LOADING, &fw_buf->status);
|
2012-08-03 22:01:17 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case 0:
|
2012-08-03 22:01:20 -06:00
|
|
|
if (test_bit(FW_STATUS_LOADING, &fw_buf->status)) {
|
2014-02-25 14:06:00 -07:00
|
|
|
int rc;
|
|
|
|
|
2012-08-03 22:01:20 -06:00
|
|
|
set_bit(FW_STATUS_DONE, &fw_buf->status);
|
|
|
|
clear_bit(FW_STATUS_LOADING, &fw_buf->status);
|
2012-10-08 22:01:02 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Several loading requests may be pending on
|
|
|
|
* one same firmware buf, so let all requests
|
|
|
|
* see the mapped 'buf->data' once the loading
|
|
|
|
* is completed.
|
|
|
|
* */
|
2014-02-25 14:06:00 -07:00
|
|
|
rc = fw_map_pages_buf(fw_buf);
|
|
|
|
if (rc)
|
2014-02-13 00:18:47 -07:00
|
|
|
dev_err(dev, "%s: map pages failed\n",
|
|
|
|
__func__);
|
2014-02-25 14:06:00 -07:00
|
|
|
else
|
2015-11-19 10:39:22 -07:00
|
|
|
rc = security_kernel_post_read_file(NULL,
|
|
|
|
fw_buf->data, fw_buf->size,
|
|
|
|
READING_FIRMWARE);
|
2014-02-25 14:06:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Same logic as fw_load_abort, only the DONE bit
|
|
|
|
* is ignored and we set ABORT only on failure.
|
|
|
|
*/
|
2013-05-22 10:28:38 -06:00
|
|
|
list_del_init(&fw_buf->pending_list);
|
2014-02-25 14:06:00 -07:00
|
|
|
if (rc) {
|
|
|
|
set_bit(FW_STATUS_ABORT, &fw_buf->status);
|
|
|
|
written = rc;
|
|
|
|
}
|
2012-08-03 22:01:21 -06:00
|
|
|
complete_all(&fw_buf->completion);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fallthrough */
|
|
|
|
default:
|
2008-10-15 23:04:20 -06:00
|
|
|
dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* fallthrough */
|
|
|
|
case -1:
|
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
break;
|
|
|
|
}
|
2012-01-02 13:31:23 -07:00
|
|
|
out:
|
|
|
|
mutex_unlock(&fw_lock);
|
2014-02-25 14:06:00 -07:00
|
|
|
return written;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-14 08:30:59 -06:00
|
|
|
static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
static void firmware_rw_buf(struct firmware_buf *buf, char *buffer,
|
|
|
|
loff_t offset, size_t count, bool read)
|
|
|
|
{
|
|
|
|
if (read)
|
|
|
|
memcpy(buffer, buf->data + offset, count);
|
|
|
|
else
|
|
|
|
memcpy(buf->data + offset, buffer, count);
|
|
|
|
}
|
|
|
|
|
2016-08-02 15:04:22 -06:00
|
|
|
static void firmware_rw(struct firmware_buf *buf, char *buffer,
|
|
|
|
loff_t offset, size_t count, bool read)
|
|
|
|
{
|
|
|
|
while (count) {
|
|
|
|
void *page_data;
|
|
|
|
int page_nr = offset >> PAGE_SHIFT;
|
|
|
|
int page_ofs = offset & (PAGE_SIZE-1);
|
|
|
|
int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
|
|
|
|
|
|
|
|
page_data = kmap(buf->pages[page_nr]);
|
|
|
|
|
|
|
|
if (read)
|
|
|
|
memcpy(buffer, page_data + page_ofs, page_cnt);
|
|
|
|
else
|
|
|
|
memcpy(page_data + page_ofs, buffer, page_cnt);
|
|
|
|
|
|
|
|
kunmap(buf->pages[page_nr]);
|
|
|
|
buffer += page_cnt;
|
|
|
|
offset += page_cnt;
|
|
|
|
count -= page_cnt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static ssize_t firmware_data_read(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *bin_attr,
|
|
|
|
char *buffer, loff_t offset, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-03 10:49:36 -06:00
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2012-08-03 22:01:20 -06:00
|
|
|
struct firmware_buf *buf;
|
2008-07-25 02:48:23 -06:00
|
|
|
ssize_t ret_count;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_lock(&fw_lock);
|
2012-08-03 22:01:20 -06:00
|
|
|
buf = fw_priv->buf;
|
|
|
|
if (!buf || test_bit(FW_STATUS_DONE, &buf->status)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ret_count = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-03 22:01:20 -06:00
|
|
|
if (offset > buf->size) {
|
2009-06-21 15:57:31 -06:00
|
|
|
ret_count = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-03 22:01:20 -06:00
|
|
|
if (count > buf->size - offset)
|
|
|
|
count = buf->size - offset;
|
2009-04-09 23:04:07 -06:00
|
|
|
|
|
|
|
ret_count = count;
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
if (buf->data)
|
|
|
|
firmware_rw_buf(buf, buffer, offset, count, true);
|
|
|
|
else
|
|
|
|
firmware_rw(buf, buffer, offset, count, true);
|
2009-04-09 23:04:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret_count;
|
|
|
|
}
|
2005-10-30 16:03:01 -07:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-08-03 22:01:20 -06:00
|
|
|
struct firmware_buf *buf = fw_priv->buf;
|
2014-07-01 13:13:30 -06:00
|
|
|
int pages_needed = PAGE_ALIGN(min_size) >> PAGE_SHIFT;
|
2009-04-09 23:04:07 -06:00
|
|
|
|
|
|
|
/* If the array of pages is too small, grow it... */
|
2012-08-03 22:01:20 -06:00
|
|
|
if (buf->page_array_size < pages_needed) {
|
2009-04-09 23:04:07 -06:00
|
|
|
int new_array_size = max(pages_needed,
|
2012-08-03 22:01:20 -06:00
|
|
|
buf->page_array_size * 2);
|
2009-04-09 23:04:07 -06:00
|
|
|
struct page **new_pages;
|
|
|
|
|
2015-12-16 02:03:15 -07:00
|
|
|
new_pages = vmalloc(new_array_size * sizeof(void *));
|
2009-04-09 23:04:07 -06:00
|
|
|
if (!new_pages) {
|
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2012-08-03 22:01:20 -06:00
|
|
|
memcpy(new_pages, buf->pages,
|
|
|
|
buf->page_array_size * sizeof(void *));
|
|
|
|
memset(&new_pages[buf->page_array_size], 0, sizeof(void *) *
|
|
|
|
(new_array_size - buf->page_array_size));
|
2015-12-16 02:03:15 -07:00
|
|
|
vfree(buf->pages);
|
2012-08-03 22:01:20 -06:00
|
|
|
buf->pages = new_pages;
|
|
|
|
buf->page_array_size = new_array_size;
|
2009-04-09 23:04:07 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-03 22:01:20 -06:00
|
|
|
while (buf->nr_pages < pages_needed) {
|
|
|
|
buf->pages[buf->nr_pages] =
|
2009-04-09 23:04:07 -06:00
|
|
|
alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-03 22:01:20 -06:00
|
|
|
if (!buf->pages[buf->nr_pages]) {
|
2009-04-09 23:04:07 -06:00
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2012-08-03 22:01:20 -06:00
|
|
|
buf->nr_pages++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-30 16:03:01 -07:00
|
|
|
* firmware_data_write - write method for firmware
|
2010-05-12 19:28:57 -06:00
|
|
|
* @filp: open sysfs file
|
2006-09-14 08:30:59 -06:00
|
|
|
* @kobj: kobject for the device
|
2007-07-23 22:42:11 -06:00
|
|
|
* @bin_attr: bin_attr structure
|
2005-10-30 16:03:01 -07:00
|
|
|
* @buffer: buffer being written
|
|
|
|
* @offset: buffer offset for write in total data store area
|
|
|
|
* @count: buffer size
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-10-30 16:03:01 -07:00
|
|
|
* Data written to the 'data' attribute will be later handed to
|
2005-04-16 16:20:36 -06:00
|
|
|
* the driver as a firmware image.
|
|
|
|
**/
|
2010-06-04 01:54:43 -06:00
|
|
|
static ssize_t firmware_data_write(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *bin_attr,
|
|
|
|
char *buffer, loff_t offset, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-03 10:49:36 -06:00
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2012-08-03 22:01:20 -06:00
|
|
|
struct firmware_buf *buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
ssize_t retval;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_RAWIO))
|
|
|
|
return -EPERM;
|
2005-06-28 21:44:51 -06:00
|
|
|
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_lock(&fw_lock);
|
2012-08-03 22:01:20 -06:00
|
|
|
buf = fw_priv->buf;
|
|
|
|
if (!buf || test_bit(FW_STATUS_DONE, &buf->status)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-03 22:01:16 -06:00
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
if (buf->data) {
|
|
|
|
if (offset + count > buf->allocated_size) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
firmware_rw_buf(buf, buffer, offset, count, false);
|
|
|
|
retval = count;
|
|
|
|
} else {
|
|
|
|
retval = fw_realloc_buffer(fw_priv, offset + count);
|
|
|
|
if (retval)
|
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
retval = count;
|
|
|
|
firmware_rw(buf, buffer, offset, count, false);
|
|
|
|
}
|
2009-04-09 23:04:07 -06:00
|
|
|
|
2016-08-02 15:04:22 -06:00
|
|
|
buf->size = max_t(size_t, offset + count, buf->size);
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
2005-10-30 16:03:01 -07:00
|
|
|
|
2010-06-04 01:54:37 -06:00
|
|
|
static struct bin_attribute firmware_attr_data = {
|
|
|
|
.attr = { .name = "data", .mode = 0644 },
|
2005-04-16 16:20:36 -06:00
|
|
|
.size = 0,
|
|
|
|
.read = firmware_data_read,
|
|
|
|
.write = firmware_data_write,
|
|
|
|
};
|
|
|
|
|
2015-02-04 07:18:07 -07:00
|
|
|
static struct attribute *fw_dev_attrs[] = {
|
|
|
|
&dev_attr_loading.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bin_attribute *fw_dev_bin_attrs[] = {
|
|
|
|
&firmware_attr_data,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group fw_dev_attr_group = {
|
|
|
|
.attrs = fw_dev_attrs,
|
|
|
|
.bin_attrs = fw_dev_bin_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *fw_dev_attr_groups[] = {
|
|
|
|
&fw_dev_attr_group,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static struct firmware_priv *
|
2012-03-28 15:30:43 -06:00
|
|
|
fw_create_instance(struct firmware *firmware, const char *fw_name,
|
2013-12-02 07:38:18 -07:00
|
|
|
struct device *device, unsigned int opt_flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv;
|
|
|
|
struct device *f_dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-03 22:01:20 -06:00
|
|
|
fw_priv = kzalloc(sizeof(*fw_priv), GFP_KERNEL);
|
2010-06-04 01:54:43 -06:00
|
|
|
if (!fw_priv) {
|
2012-08-03 22:01:20 -06:00
|
|
|
fw_priv = ERR_PTR(-ENOMEM);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2013-12-02 07:38:18 -07:00
|
|
|
fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
|
2012-08-03 22:01:21 -06:00
|
|
|
fw_priv->fw = firmware;
|
2010-06-04 01:54:43 -06:00
|
|
|
f_dev = &fw_priv->dev;
|
|
|
|
|
|
|
|
device_initialize(f_dev);
|
2012-08-03 22:01:19 -06:00
|
|
|
dev_set_name(f_dev, "%s", fw_name);
|
2006-09-14 08:30:59 -06:00
|
|
|
f_dev->parent = device;
|
|
|
|
f_dev->class = &firmware_class;
|
2015-02-04 07:18:07 -07:00
|
|
|
f_dev->groups = fw_dev_attr_groups;
|
2012-08-03 22:01:20 -06:00
|
|
|
exit:
|
2010-06-04 01:54:43 -06:00
|
|
|
return fw_priv;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
/* load a firmware via user helper */
|
2013-12-02 07:38:18 -07:00
|
|
|
static int _request_firmware_load(struct firmware_priv *fw_priv,
|
|
|
|
unsigned int opt_flags, long timeout)
|
2012-08-03 22:01:21 -06:00
|
|
|
{
|
2013-01-31 03:13:56 -07:00
|
|
|
int retval = 0;
|
|
|
|
struct device *f_dev = &fw_priv->dev;
|
|
|
|
struct firmware_buf *buf = fw_priv->buf;
|
2012-08-03 22:01:21 -06:00
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
/* fall back on userspace loading */
|
2016-08-02 15:04:28 -06:00
|
|
|
if (!buf->data)
|
|
|
|
buf->is_paged_buf = true;
|
2012-08-03 22:01:21 -06:00
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
dev_set_uevent_suppress(f_dev, true);
|
2012-08-03 22:01:25 -06:00
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
retval = device_add(f_dev);
|
|
|
|
if (retval) {
|
|
|
|
dev_err(f_dev, "%s: device_register failed\n", __func__);
|
|
|
|
goto err_put_dev;
|
|
|
|
}
|
2012-08-03 22:01:25 -06:00
|
|
|
|
2013-08-29 12:28:13 -06:00
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
list_add(&buf->pending_list, &pending_fw_head);
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
|
2013-12-02 07:38:18 -07:00
|
|
|
if (opt_flags & FW_OPT_UEVENT) {
|
2013-05-27 04:30:04 -06:00
|
|
|
buf->need_uevent = true;
|
2013-01-31 03:13:56 -07:00
|
|
|
dev_set_uevent_suppress(f_dev, false);
|
|
|
|
dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
|
|
|
|
kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
|
2015-01-12 09:02:01 -07:00
|
|
|
} else {
|
|
|
|
timeout = MAX_JIFFY_OFFSET;
|
2013-01-31 03:13:56 -07:00
|
|
|
}
|
2012-08-03 22:01:25 -06:00
|
|
|
|
2015-01-12 09:02:01 -07:00
|
|
|
retval = wait_for_completion_interruptible_timeout(&buf->completion,
|
|
|
|
timeout);
|
|
|
|
if (retval == -ERESTARTSYS || !retval) {
|
2015-01-12 09:01:35 -07:00
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
mutex_unlock(&fw_lock);
|
2015-03-10 03:45:40 -06:00
|
|
|
} else if (retval > 0) {
|
|
|
|
retval = 0;
|
2015-01-12 09:01:35 -07:00
|
|
|
}
|
2012-08-03 22:01:25 -06:00
|
|
|
|
2014-07-22 18:10:38 -06:00
|
|
|
if (is_fw_load_aborted(buf))
|
|
|
|
retval = -EAGAIN;
|
2016-08-02 15:04:28 -06:00
|
|
|
else if (buf->is_paged_buf && !buf->data)
|
2014-02-13 00:18:47 -07:00
|
|
|
retval = -ENOMEM;
|
2012-08-03 22:01:25 -06:00
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
device_del(f_dev);
|
|
|
|
err_put_dev:
|
|
|
|
put_device(f_dev);
|
|
|
|
return retval;
|
2012-08-03 22:01:25 -06:00
|
|
|
}
|
2013-01-31 03:13:56 -07:00
|
|
|
|
|
|
|
static int fw_load_from_user_helper(struct firmware *firmware,
|
|
|
|
const char *name, struct device *device,
|
2013-12-02 07:38:18 -07:00
|
|
|
unsigned int opt_flags, long timeout)
|
2012-09-08 03:32:30 -06:00
|
|
|
{
|
2013-01-31 03:13:56 -07:00
|
|
|
struct firmware_priv *fw_priv;
|
|
|
|
|
2013-12-02 07:38:18 -07:00
|
|
|
fw_priv = fw_create_instance(firmware, name, device, opt_flags);
|
2013-01-31 03:13:56 -07:00
|
|
|
if (IS_ERR(fw_priv))
|
|
|
|
return PTR_ERR(fw_priv);
|
|
|
|
|
|
|
|
fw_priv->buf = firmware->priv;
|
2013-12-02 07:38:18 -07:00
|
|
|
return _request_firmware_load(fw_priv, opt_flags, timeout);
|
2012-09-08 03:32:30 -06:00
|
|
|
}
|
2013-06-03 20:01:13 -06:00
|
|
|
|
2013-06-06 05:52:54 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2013-06-03 20:01:13 -06:00
|
|
|
/* kill pending requests without uevent to avoid blocking suspend */
|
|
|
|
static void kill_requests_without_uevent(void)
|
|
|
|
{
|
|
|
|
struct firmware_buf *buf;
|
|
|
|
struct firmware_buf *next;
|
|
|
|
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
list_for_each_entry_safe(buf, next, &pending_fw_head, pending_list) {
|
|
|
|
if (!buf->need_uevent)
|
2013-06-19 21:26:43 -06:00
|
|
|
__fw_load_abort(buf);
|
2013-06-03 20:01:13 -06:00
|
|
|
}
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
}
|
2013-06-06 05:52:54 -06:00
|
|
|
#endif
|
2013-06-03 20:01:13 -06:00
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
#else /* CONFIG_FW_LOADER_USER_HELPER */
|
|
|
|
static inline int
|
|
|
|
fw_load_from_user_helper(struct firmware *firmware, const char *name,
|
2013-12-02 07:38:18 -07:00
|
|
|
struct device *device, unsigned int opt_flags,
|
2013-01-31 03:13:56 -07:00
|
|
|
long timeout)
|
|
|
|
{
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2013-01-31 03:13:57 -07:00
|
|
|
|
|
|
|
/* No abort during direct loading */
|
|
|
|
#define is_fw_load_aborted(buf) false
|
|
|
|
|
2013-06-06 05:52:54 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2013-06-03 20:01:13 -06:00
|
|
|
static inline void kill_requests_without_uevent(void) { }
|
2013-06-06 05:52:54 -06:00
|
|
|
#endif
|
2013-06-03 20:01:13 -06:00
|
|
|
|
2013-01-31 03:13:56 -07:00
|
|
|
#endif /* CONFIG_FW_LOADER_USER_HELPER */
|
|
|
|
|
2012-08-03 22:01:25 -06:00
|
|
|
|
2013-01-31 03:13:54 -07:00
|
|
|
/* wait until the shared firmware_buf becomes ready (or error) */
|
|
|
|
static int sync_cached_firmware_buf(struct firmware_buf *buf)
|
2012-08-03 22:01:21 -06:00
|
|
|
{
|
2013-01-31 03:13:54 -07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
while (!test_bit(FW_STATUS_DONE, &buf->status)) {
|
2013-01-31 03:13:57 -07:00
|
|
|
if (is_fw_load_aborted(buf)) {
|
2013-01-31 03:13:54 -07:00
|
|
|
ret = -ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&fw_lock);
|
2014-11-17 19:56:59 -07:00
|
|
|
ret = wait_for_completion_interruptible(&buf->completion);
|
2013-01-31 03:13:54 -07:00
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
}
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
return ret;
|
2012-08-03 22:01:21 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 03:13:54 -07:00
|
|
|
/* prepare firmware and firmware_buf structs;
|
|
|
|
* return 0 if a firmware is already assigned, 1 if need to load one,
|
|
|
|
* or a negative error code
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
_request_firmware_prepare(struct firmware **firmware_p, const char *name,
|
2016-08-02 15:04:28 -06:00
|
|
|
struct device *device, void *dbuf, size_t size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct firmware *firmware;
|
2012-08-03 22:01:21 -06:00
|
|
|
struct firmware_buf *buf;
|
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-13 02:25:01 -06:00
|
|
|
*firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!firmware) {
|
2008-10-15 23:04:20 -06:00
|
|
|
dev_err(device, "%s: kmalloc(struct firmware) failed\n",
|
|
|
|
__func__);
|
2013-01-31 03:13:54 -07:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
|
2015-04-29 17:30:43 -06:00
|
|
|
dev_dbg(device, "using built-in %s\n", name);
|
2013-01-31 03:13:54 -07:00
|
|
|
return 0; /* assigned */
|
2008-05-23 06:52:42 -06:00
|
|
|
}
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
ret = fw_lookup_and_allocate_buf(name, &fw_cache, &buf, dbuf, size);
|
2013-01-31 03:13:54 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* bind with 'buf' now to avoid warning in failure path
|
|
|
|
* of requesting firmware.
|
|
|
|
*/
|
|
|
|
firmware->priv = buf;
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
ret = sync_cached_firmware_buf(buf);
|
|
|
|
if (!ret) {
|
|
|
|
fw_set_page_data(buf, firmware);
|
|
|
|
return 0; /* assigned */
|
|
|
|
}
|
2012-03-28 15:30:43 -06:00
|
|
|
}
|
2012-03-28 15:29:55 -06:00
|
|
|
|
2013-01-31 03:13:54 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
return 1; /* need to load */
|
|
|
|
}
|
|
|
|
|
2013-05-27 04:30:03 -06:00
|
|
|
static int assign_firmware_buf(struct firmware *fw, struct device *device,
|
2013-12-02 07:38:18 -07:00
|
|
|
unsigned int opt_flags)
|
2013-01-31 03:13:54 -07:00
|
|
|
{
|
|
|
|
struct firmware_buf *buf = fw->priv;
|
|
|
|
|
2012-08-03 22:01:21 -06:00
|
|
|
mutex_lock(&fw_lock);
|
2013-01-31 03:13:57 -07:00
|
|
|
if (!buf->size || is_fw_load_aborted(buf)) {
|
2013-01-31 03:13:54 -07:00
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
return -ENOENT;
|
2012-08-03 22:01:21 -06:00
|
|
|
}
|
2012-08-03 22:01:16 -06:00
|
|
|
|
2013-01-31 03:13:54 -07:00
|
|
|
/*
|
|
|
|
* add firmware name into devres list so that we can auto cache
|
|
|
|
* and uncache firmware for device.
|
|
|
|
*
|
|
|
|
* device may has been deleted already, but the problem
|
|
|
|
* should be fixed in devres or driver core.
|
|
|
|
*/
|
2013-12-02 07:38:18 -07:00
|
|
|
/* don't cache firmware handled without uevent */
|
2016-08-02 15:04:25 -06:00
|
|
|
if (device && (opt_flags & FW_OPT_UEVENT) &&
|
|
|
|
!(opt_flags & FW_OPT_NOCACHE))
|
2013-01-31 03:13:54 -07:00
|
|
|
fw_add_devm_name(device, buf->fw_id);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After caching firmware image is started, let it piggyback
|
|
|
|
* on request firmware.
|
|
|
|
*/
|
2016-08-02 15:04:25 -06:00
|
|
|
if (!(opt_flags & FW_OPT_NOCACHE) &&
|
|
|
|
buf->fwc->state == FW_LOADER_START_CACHE) {
|
2013-01-31 03:13:54 -07:00
|
|
|
if (fw_cache_piggyback_on_request(buf->fw_id))
|
|
|
|
kref_get(&buf->ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* pass the pages buffer to driver at the last minute */
|
|
|
|
fw_set_page_data(buf, fw);
|
2012-08-03 22:01:21 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2013-01-31 03:13:54 -07:00
|
|
|
return 0;
|
2012-08-03 22:01:16 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 03:13:54 -07:00
|
|
|
/* called from request_firmware() and request_firmware_work_func() */
|
|
|
|
static int
|
|
|
|
_request_firmware(const struct firmware **firmware_p, const char *name,
|
2016-08-02 15:04:28 -06:00
|
|
|
struct device *device, void *buf, size_t size,
|
|
|
|
unsigned int opt_flags)
|
2013-01-31 03:13:54 -07:00
|
|
|
{
|
2015-12-09 15:50:28 -07:00
|
|
|
struct firmware *fw = NULL;
|
2013-01-31 03:13:54 -07:00
|
|
|
long timeout;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!firmware_p)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-12-09 15:50:28 -07:00
|
|
|
if (!name || name[0] == '\0') {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-09-18 12:25:37 -06:00
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
ret = _request_firmware_prepare(&fw, name, device, buf, size);
|
2013-01-31 03:13:54 -07:00
|
|
|
if (ret <= 0) /* error or already assigned */
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
timeout = firmware_loading_timeout();
|
2013-12-02 07:38:18 -07:00
|
|
|
if (opt_flags & FW_OPT_NOWAIT) {
|
2013-01-31 03:13:54 -07:00
|
|
|
timeout = usermodehelper_read_lock_wait(timeout);
|
|
|
|
if (!timeout) {
|
|
|
|
dev_dbg(device, "firmware: %s loading timed out\n",
|
|
|
|
name);
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret = usermodehelper_read_trylock();
|
|
|
|
if (WARN_ON(ret)) {
|
|
|
|
dev_err(device, "firmware: %s will not be loaded\n",
|
|
|
|
name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-06 13:36:08 -06:00
|
|
|
ret = fw_get_filesystem_firmware(device, fw->priv);
|
|
|
|
if (ret) {
|
2014-07-02 10:55:05 -06:00
|
|
|
if (!(opt_flags & FW_OPT_NO_WARN))
|
2013-12-02 07:38:16 -07:00
|
|
|
dev_warn(device,
|
2014-07-02 10:55:05 -06:00
|
|
|
"Direct firmware load for %s failed with error %d\n",
|
|
|
|
name, ret);
|
|
|
|
if (opt_flags & FW_OPT_USERHELPER) {
|
2013-12-02 07:38:16 -07:00
|
|
|
dev_warn(device, "Falling back to user helper\n");
|
|
|
|
ret = fw_load_from_user_helper(fw, name, device,
|
2013-12-02 07:38:18 -07:00
|
|
|
opt_flags, timeout);
|
2013-12-02 07:38:16 -07:00
|
|
|
}
|
2013-09-06 13:36:08 -06:00
|
|
|
}
|
2013-05-27 04:30:03 -06:00
|
|
|
|
2013-01-31 03:13:54 -07:00
|
|
|
if (!ret)
|
2013-12-02 07:38:18 -07:00
|
|
|
ret = assign_firmware_buf(fw, device, opt_flags);
|
2013-01-31 03:13:54 -07:00
|
|
|
|
|
|
|
usermodehelper_read_unlock();
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (ret < 0) {
|
|
|
|
release_firmware(fw);
|
|
|
|
fw = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*firmware_p = fw;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-09-06 16:17:13 -06:00
|
|
|
/**
|
2005-11-16 01:00:00 -07:00
|
|
|
* request_firmware: - send firmware request and wait for it
|
2005-10-30 16:03:01 -07:00
|
|
|
* @firmware_p: pointer to firmware image
|
|
|
|
* @name: name of firmware file
|
|
|
|
* @device: device for which firmware is being loaded
|
|
|
|
*
|
|
|
|
* @firmware_p will be used to return a firmware image by the name
|
2005-09-06 16:17:13 -06:00
|
|
|
* of @name for device @device.
|
|
|
|
*
|
|
|
|
* Should be called from user context where sleeping is allowed.
|
|
|
|
*
|
2005-11-16 01:00:00 -07:00
|
|
|
* @name will be used as $FIRMWARE in the uevent environment and
|
2005-09-06 16:17:13 -06:00
|
|
|
* should be distinctive enough not to be confused with any other
|
|
|
|
* firmware image for this or any other device.
|
2012-08-03 22:01:23 -06:00
|
|
|
*
|
|
|
|
* Caller must hold the reference count of @device.
|
2012-11-03 03:48:16 -06:00
|
|
|
*
|
|
|
|
* The function can be called safely inside device's suspend and
|
|
|
|
* resume callback.
|
2005-09-06 16:17:13 -06:00
|
|
|
**/
|
|
|
|
int
|
|
|
|
request_firmware(const struct firmware **firmware_p, const char *name,
|
2015-03-08 04:41:15 -06:00
|
|
|
struct device *device)
|
2005-09-06 16:17:13 -06:00
|
|
|
{
|
2013-06-06 06:01:48 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Need to pin this module until return */
|
|
|
|
__module_get(THIS_MODULE);
|
2016-08-02 15:04:28 -06:00
|
|
|
ret = _request_firmware(firmware_p, name, device, NULL, 0,
|
2013-12-02 07:38:18 -07:00
|
|
|
FW_OPT_UEVENT | FW_OPT_FALLBACK);
|
2013-06-06 06:01:48 -06:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
return ret;
|
2005-09-06 16:17:13 -06:00
|
|
|
}
|
2013-05-23 14:17:18 -06:00
|
|
|
EXPORT_SYMBOL(request_firmware);
|
2005-09-06 16:17:13 -06:00
|
|
|
|
2013-12-02 07:38:16 -07:00
|
|
|
/**
|
2014-12-03 14:46:37 -07:00
|
|
|
* request_firmware_direct: - load firmware directly without usermode helper
|
2013-12-02 07:38:16 -07:00
|
|
|
* @firmware_p: pointer to firmware image
|
|
|
|
* @name: name of firmware file
|
|
|
|
* @device: device for which firmware is being loaded
|
|
|
|
*
|
|
|
|
* This function works pretty much like request_firmware(), but this doesn't
|
|
|
|
* fall back to usermode helper even if the firmware couldn't be loaded
|
|
|
|
* directly from fs. Hence it's useful for loading optional firmwares, which
|
|
|
|
* aren't always present, without extra long timeouts of udev.
|
|
|
|
**/
|
|
|
|
int request_firmware_direct(const struct firmware **firmware_p,
|
|
|
|
const char *name, struct device *device)
|
|
|
|
{
|
|
|
|
int ret;
|
2015-03-08 04:41:15 -06:00
|
|
|
|
2013-12-02 07:38:16 -07:00
|
|
|
__module_get(THIS_MODULE);
|
2016-08-02 15:04:28 -06:00
|
|
|
ret = _request_firmware(firmware_p, name, device, NULL, 0,
|
2014-07-02 10:55:05 -06:00
|
|
|
FW_OPT_UEVENT | FW_OPT_NO_WARN);
|
2013-12-02 07:38:16 -07:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(request_firmware_direct);
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
/**
|
|
|
|
* request_firmware_into_buf - load firmware into a previously allocated buffer
|
|
|
|
* @firmware_p: pointer to firmware image
|
|
|
|
* @name: name of firmware file
|
|
|
|
* @device: device for which firmware is being loaded and DMA region allocated
|
|
|
|
* @buf: address of buffer to load firmware into
|
|
|
|
* @size: size of buffer
|
|
|
|
*
|
|
|
|
* This function works pretty much like request_firmware(), but it doesn't
|
|
|
|
* allocate a buffer to hold the firmware data. Instead, the firmware
|
|
|
|
* is loaded directly into the buffer pointed to by @buf and the @firmware_p
|
|
|
|
* data member is pointed at @buf.
|
|
|
|
*
|
|
|
|
* This function doesn't cache firmware either.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
request_firmware_into_buf(const struct firmware **firmware_p, const char *name,
|
|
|
|
struct device *device, void *buf, size_t size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
__module_get(THIS_MODULE);
|
|
|
|
ret = _request_firmware(firmware_p, name, device, buf, size,
|
|
|
|
FW_OPT_UEVENT | FW_OPT_FALLBACK |
|
|
|
|
FW_OPT_NOCACHE);
|
|
|
|
module_put(THIS_MODULE);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(request_firmware_into_buf);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* release_firmware: - release the resource associated with a firmware image
|
2005-10-30 16:03:01 -07:00
|
|
|
* @fw: firmware resource to release
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2010-03-14 00:49:18 -07:00
|
|
|
void release_firmware(const struct firmware *fw)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (fw) {
|
2010-03-14 00:49:18 -07:00
|
|
|
if (!fw_is_builtin_firmware(fw))
|
|
|
|
firmware_free_data(fw);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(fw);
|
|
|
|
}
|
|
|
|
}
|
2013-05-23 14:17:18 -06:00
|
|
|
EXPORT_SYMBOL(release_firmware);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Async support */
|
|
|
|
struct firmware_work {
|
|
|
|
struct work_struct work;
|
|
|
|
struct module *module;
|
|
|
|
const char *name;
|
|
|
|
struct device *device;
|
|
|
|
void *context;
|
|
|
|
void (*cont)(const struct firmware *fw, void *context);
|
2013-12-02 07:38:18 -07:00
|
|
|
unsigned int opt_flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2012-03-28 15:31:00 -06:00
|
|
|
static void request_firmware_work_func(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-03-28 15:31:00 -06:00
|
|
|
struct firmware_work *fw_work;
|
2005-04-16 16:20:36 -06:00
|
|
|
const struct firmware *fw;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2012-03-28 15:31:00 -06:00
|
|
|
fw_work = container_of(work, struct firmware_work, work);
|
2012-03-28 15:29:55 -06:00
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
_request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0,
|
2013-12-02 07:38:18 -07:00
|
|
|
fw_work->opt_flags);
|
2009-10-29 05:36:02 -06:00
|
|
|
fw_work->cont(fw, fw_work->context);
|
2013-01-31 03:13:54 -07:00
|
|
|
put_device(fw_work->device); /* taken in request_firmware_nowait() */
|
2009-10-29 05:36:02 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
module_put(fw_work->module);
|
firmware: fix possible use after free on name on asynchronous request
Asynchronous firmware loading copies the pointer to the
name passed as an argument only to be scheduled later and
used. This behaviour works well for synchronous calling
but in asynchronous mode there's a chance the caller could
immediately free the passed string after making the
asynchronous call. This could trigger a use after free
having the kernel look on disk for arbitrary file names.
In order to force-test the issue you can use a test-driver
designed to illustrate this issue on github [0], use the
next-20150505-fix-use-after-free branch.
With this patch applied you get:
[ 283.512445] firmware name: test_module_stuff.bin
[ 287.514020] firmware name: test_module_stuff.bin
[ 287.532489] firmware found
Without this patch applied you can end up with something such as:
[ 135.624216] firmware name: \xffffff80BJ
[ 135.624249] platform fake-dev.0: Direct firmware load for \xffffff80Bi failed with error -2
[ 135.624252] No firmware found
[ 135.624252] firmware found
Unfortunatley in the worst and most common case however you
can typically crash your system with a page fault by trying to
free something which you cannot, and/or a NULL pointer
dereference [1].
The fix and issue using schedule_work() for asynchronous
runs is generalized in the following SmPL grammar patch,
when applied to next-20150505 only the firmware_class
code is affected. This grammar patch can and should further
be generalized to vet for for other kernel asynchronous
mechanisms.
@ calls_schedule_work @
type T;
T *priv_work;
identifier func, work_func;
identifier work;
identifier priv_name, name;
expression gfp;
@@
func(..., const char *name, ...)
{
...
priv_work = kzalloc(sizeof(T), gfp);
...
- priv_work->priv_name = name;
+ priv_work->priv_name = kstrdup_const(name, gfp);
...
(... when any
if (...)
{
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
) ... when any
INIT_WORK(&priv_work->work, work_func);
...
schedule_work(&priv_work->work);
...
}
@ the_work_func depends on calls_schedule_work @
type calls_schedule_work.T;
T *priv_work;
identifier calls_schedule_work.work_func;
identifier calls_schedule_work.priv_name;
identifier calls_schedule_work.work;
identifier some_work;
@@
work_func(...)
{
...
priv_work = container_of(some_work, T, work);
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
[0] https://github.com/mcgrof/fake-firmware-test.git
[1] The following kernel ring buffer splat:
firmware name: test_module_stuff.bin
firmware name:
firmware found
general protection fault: 0000 [#1] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
Workqueue: events request_firmware_work_func
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff814a586c>] [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP: 0000:ffff8800c7f97d78 EFLAGS: 00010286
RAX: ffffffff81ae3700 RBX: ffffffff816d1181 RCX: 0000000000000006
RDX: 0001ee850ff68500 RSI: 0000000000000246 RDI: c35d5f415e415d41
RBP: ffff8800c7f97d88 R08: 000000000000000a R09: 0000000000000000
R10: 0000000000000358 R11: ffff8800c7f97a7e R12: ffff8800c7ec1e80
R13: ffff88021e2d4cc0 R14: ffff88021e2dff00 R15: 00000000000000c0
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000034b8cd8 CR3: 000000021073c000 CR4: 00000000001407e0
Stack:
ffffffff816d1181 ffff8800c7ec1e80 ffff8800c7f97da8 ffffffff814a58f8
000000000000000a ffffffff816d1181 ffff8800c7f97dc8 ffffffffa047002c
ffff88021e2dff00 ffff8802116ac1c0 ffff8800c7f97df8 ffffffff814a65fe
Call Trace:
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: c7 c6 dd ad a3 81 48 c7 c7 20 97 ce 81 31 c0 e8 0b b2 ed ff e9 78 ff ff ff 66 0f 1f 44 00 00 0f 1f 44 00 00 55 48 89 e5 41 54 53 <4c> 8b 67 38 48 89 fb 4c 89 e7 e8 85 f7 22 00 f0 83 2b 01 74 0f
RIP [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP <ffff8800c7f97d78>
---[ end trace 4e62c56a58d0eac1 ]---
BUG: unable to handle kernel paging request at ffffffffffffffd8
IP: [<ffffffff81093ee0>] kthread_data+0x10/0x20
PGD 1c13067 PUD 1c15067 PMD 0
Oops: 0000 [#2] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G D O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff81092ee0>] [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP: 0018:ffff8800c7f97b18 EFLAGS: 00010096
RAX: 0000000000000000 RBX: 0000000000000003 RCX: 000000000000000d
RDX: 0000000000000003 RSI: 0000000000000003 RDI: ffff8800c7f8e290
RBP: ffff8800c7f97b18 R08: 000000000000bc00 R09: 0000000000007e76
R10: 0000000000000001 R11: 000000000000002f R12: ffff8800c7f8e290
R13: 00000000000154c0 R14: 0000000000000003 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000000000028 CR3: 0000000210675000 CR4: 00000000001407e0
Stack:
ffff8800c7f97b38 ffffffff8108dcd5 ffff8800c7f97b38 ffff88021e2d54c0
ffff8800c7f97b88 ffffffff816d1500 ffff880213d42368 ffff8800c7f8e290
ffff8800c7f97b88 ffff8800c7f97fd8 ffff8800c7f8e710 0000000000000246
Call Trace:
[<ffffffff8108dcd5>] wq_worker_sleeping+0x15/0xa0
[<ffffffff816d1500>] __schedule+0x6e0/0x940
[<ffffffff816d1797>] schedule+0x37/0x90
[<ffffffff810779bc>] do_exit+0x6bc/0xb40
[<ffffffff8101898f>] oops_end+0x9f/0xe0
[<ffffffff81018efb>] die+0x4b/0x70
[<ffffffff81015622>] do_general_protection+0xe2/0x170
[<ffffffff816d74e8>] general_protection+0x28/0x30
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a586c>] ? fw_free_buf+0xc/0x40
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: 00 48 89 e5 5d 48 8b 40 c8 48 c1 e8 02 83 e0 01 c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 48 8b 87 30 05 00 00 55 48 89 e5 <48> 8b 40 d8 5d c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00
RIP [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP <ffff8800c7f97b18>
CR2: ffffffffffffffd8
---[ end trace 4e62c56a58d0eac2 ]---
Fixing recursive fault but reboot is needed!
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: David Howells <dhowells@redhat.com>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Seth Forshee <seth.forshee@canonical.com>
Cc: Kyle McMartin <kyle@kernel.org>
Generated-by: Coccinelle SmPL
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-05-12 15:49:42 -06:00
|
|
|
kfree_const(fw_work->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(fw_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-02-14 07:18:53 -07:00
|
|
|
* request_firmware_nowait - asynchronous version of request_firmware
|
2005-10-30 16:03:01 -07:00
|
|
|
* @module: module requesting the firmware
|
2005-11-16 01:00:00 -07:00
|
|
|
* @uevent: sends uevent to copy the firmware image if this flag
|
2005-10-30 16:03:01 -07:00
|
|
|
* is non-zero else the firmware copy must be done manually.
|
|
|
|
* @name: name of firmware file
|
|
|
|
* @device: device for which firmware is being loaded
|
2009-10-29 05:36:02 -06:00
|
|
|
* @gfp: allocation flags
|
2005-10-30 16:03:01 -07:00
|
|
|
* @context: will be passed over to @cont, and
|
|
|
|
* @fw may be %NULL if firmware request fails.
|
|
|
|
* @cont: function will be called asynchronously when the firmware
|
|
|
|
* request is over.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2012-08-03 22:01:23 -06:00
|
|
|
* Caller must hold the reference count of @device.
|
|
|
|
*
|
2012-08-03 22:01:24 -06:00
|
|
|
* Asynchronous variant of request_firmware() for user contexts:
|
|
|
|
* - sleep for as small periods as possible since it may
|
|
|
|
* increase kernel boot time of built-in device drivers
|
|
|
|
* requesting firmware in their ->probe() methods, if
|
|
|
|
* @gfp is GFP_KERNEL.
|
|
|
|
*
|
|
|
|
* - can't sleep at all if @gfp is GFP_ATOMIC.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
|
|
|
int
|
|
|
|
request_firmware_nowait(
|
2011-01-26 03:33:32 -07:00
|
|
|
struct module *module, bool uevent,
|
2009-10-29 05:36:02 -06:00
|
|
|
const char *name, struct device *device, gfp_t gfp, void *context,
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*cont)(const struct firmware *fw, void *context))
|
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_work *fw_work;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-03-08 04:41:15 -06:00
|
|
|
fw_work = kzalloc(sizeof(struct firmware_work), gfp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!fw_work)
|
|
|
|
return -ENOMEM;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
|
|
|
fw_work->module = module;
|
firmware: fix possible use after free on name on asynchronous request
Asynchronous firmware loading copies the pointer to the
name passed as an argument only to be scheduled later and
used. This behaviour works well for synchronous calling
but in asynchronous mode there's a chance the caller could
immediately free the passed string after making the
asynchronous call. This could trigger a use after free
having the kernel look on disk for arbitrary file names.
In order to force-test the issue you can use a test-driver
designed to illustrate this issue on github [0], use the
next-20150505-fix-use-after-free branch.
With this patch applied you get:
[ 283.512445] firmware name: test_module_stuff.bin
[ 287.514020] firmware name: test_module_stuff.bin
[ 287.532489] firmware found
Without this patch applied you can end up with something such as:
[ 135.624216] firmware name: \xffffff80BJ
[ 135.624249] platform fake-dev.0: Direct firmware load for \xffffff80Bi failed with error -2
[ 135.624252] No firmware found
[ 135.624252] firmware found
Unfortunatley in the worst and most common case however you
can typically crash your system with a page fault by trying to
free something which you cannot, and/or a NULL pointer
dereference [1].
The fix and issue using schedule_work() for asynchronous
runs is generalized in the following SmPL grammar patch,
when applied to next-20150505 only the firmware_class
code is affected. This grammar patch can and should further
be generalized to vet for for other kernel asynchronous
mechanisms.
@ calls_schedule_work @
type T;
T *priv_work;
identifier func, work_func;
identifier work;
identifier priv_name, name;
expression gfp;
@@
func(..., const char *name, ...)
{
...
priv_work = kzalloc(sizeof(T), gfp);
...
- priv_work->priv_name = name;
+ priv_work->priv_name = kstrdup_const(name, gfp);
...
(... when any
if (...)
{
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
) ... when any
INIT_WORK(&priv_work->work, work_func);
...
schedule_work(&priv_work->work);
...
}
@ the_work_func depends on calls_schedule_work @
type calls_schedule_work.T;
T *priv_work;
identifier calls_schedule_work.work_func;
identifier calls_schedule_work.priv_name;
identifier calls_schedule_work.work;
identifier some_work;
@@
work_func(...)
{
...
priv_work = container_of(some_work, T, work);
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
[0] https://github.com/mcgrof/fake-firmware-test.git
[1] The following kernel ring buffer splat:
firmware name: test_module_stuff.bin
firmware name:
firmware found
general protection fault: 0000 [#1] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
Workqueue: events request_firmware_work_func
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff814a586c>] [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP: 0000:ffff8800c7f97d78 EFLAGS: 00010286
RAX: ffffffff81ae3700 RBX: ffffffff816d1181 RCX: 0000000000000006
RDX: 0001ee850ff68500 RSI: 0000000000000246 RDI: c35d5f415e415d41
RBP: ffff8800c7f97d88 R08: 000000000000000a R09: 0000000000000000
R10: 0000000000000358 R11: ffff8800c7f97a7e R12: ffff8800c7ec1e80
R13: ffff88021e2d4cc0 R14: ffff88021e2dff00 R15: 00000000000000c0
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000034b8cd8 CR3: 000000021073c000 CR4: 00000000001407e0
Stack:
ffffffff816d1181 ffff8800c7ec1e80 ffff8800c7f97da8 ffffffff814a58f8
000000000000000a ffffffff816d1181 ffff8800c7f97dc8 ffffffffa047002c
ffff88021e2dff00 ffff8802116ac1c0 ffff8800c7f97df8 ffffffff814a65fe
Call Trace:
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: c7 c6 dd ad a3 81 48 c7 c7 20 97 ce 81 31 c0 e8 0b b2 ed ff e9 78 ff ff ff 66 0f 1f 44 00 00 0f 1f 44 00 00 55 48 89 e5 41 54 53 <4c> 8b 67 38 48 89 fb 4c 89 e7 e8 85 f7 22 00 f0 83 2b 01 74 0f
RIP [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP <ffff8800c7f97d78>
---[ end trace 4e62c56a58d0eac1 ]---
BUG: unable to handle kernel paging request at ffffffffffffffd8
IP: [<ffffffff81093ee0>] kthread_data+0x10/0x20
PGD 1c13067 PUD 1c15067 PMD 0
Oops: 0000 [#2] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G D O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff81092ee0>] [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP: 0018:ffff8800c7f97b18 EFLAGS: 00010096
RAX: 0000000000000000 RBX: 0000000000000003 RCX: 000000000000000d
RDX: 0000000000000003 RSI: 0000000000000003 RDI: ffff8800c7f8e290
RBP: ffff8800c7f97b18 R08: 000000000000bc00 R09: 0000000000007e76
R10: 0000000000000001 R11: 000000000000002f R12: ffff8800c7f8e290
R13: 00000000000154c0 R14: 0000000000000003 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000000000028 CR3: 0000000210675000 CR4: 00000000001407e0
Stack:
ffff8800c7f97b38 ffffffff8108dcd5 ffff8800c7f97b38 ffff88021e2d54c0
ffff8800c7f97b88 ffffffff816d1500 ffff880213d42368 ffff8800c7f8e290
ffff8800c7f97b88 ffff8800c7f97fd8 ffff8800c7f8e710 0000000000000246
Call Trace:
[<ffffffff8108dcd5>] wq_worker_sleeping+0x15/0xa0
[<ffffffff816d1500>] __schedule+0x6e0/0x940
[<ffffffff816d1797>] schedule+0x37/0x90
[<ffffffff810779bc>] do_exit+0x6bc/0xb40
[<ffffffff8101898f>] oops_end+0x9f/0xe0
[<ffffffff81018efb>] die+0x4b/0x70
[<ffffffff81015622>] do_general_protection+0xe2/0x170
[<ffffffff816d74e8>] general_protection+0x28/0x30
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a586c>] ? fw_free_buf+0xc/0x40
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: 00 48 89 e5 5d 48 8b 40 c8 48 c1 e8 02 83 e0 01 c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 48 8b 87 30 05 00 00 55 48 89 e5 <48> 8b 40 d8 5d c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00
RIP [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP <ffff8800c7f97b18>
CR2: ffffffffffffffd8
---[ end trace 4e62c56a58d0eac2 ]---
Fixing recursive fault but reboot is needed!
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: David Howells <dhowells@redhat.com>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Seth Forshee <seth.forshee@canonical.com>
Cc: Kyle McMartin <kyle@kernel.org>
Generated-by: Coccinelle SmPL
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-05-12 15:49:42 -06:00
|
|
|
fw_work->name = kstrdup_const(name, gfp);
|
2015-05-28 18:46:42 -06:00
|
|
|
if (!fw_work->name) {
|
|
|
|
kfree(fw_work);
|
firmware: fix possible use after free on name on asynchronous request
Asynchronous firmware loading copies the pointer to the
name passed as an argument only to be scheduled later and
used. This behaviour works well for synchronous calling
but in asynchronous mode there's a chance the caller could
immediately free the passed string after making the
asynchronous call. This could trigger a use after free
having the kernel look on disk for arbitrary file names.
In order to force-test the issue you can use a test-driver
designed to illustrate this issue on github [0], use the
next-20150505-fix-use-after-free branch.
With this patch applied you get:
[ 283.512445] firmware name: test_module_stuff.bin
[ 287.514020] firmware name: test_module_stuff.bin
[ 287.532489] firmware found
Without this patch applied you can end up with something such as:
[ 135.624216] firmware name: \xffffff80BJ
[ 135.624249] platform fake-dev.0: Direct firmware load for \xffffff80Bi failed with error -2
[ 135.624252] No firmware found
[ 135.624252] firmware found
Unfortunatley in the worst and most common case however you
can typically crash your system with a page fault by trying to
free something which you cannot, and/or a NULL pointer
dereference [1].
The fix and issue using schedule_work() for asynchronous
runs is generalized in the following SmPL grammar patch,
when applied to next-20150505 only the firmware_class
code is affected. This grammar patch can and should further
be generalized to vet for for other kernel asynchronous
mechanisms.
@ calls_schedule_work @
type T;
T *priv_work;
identifier func, work_func;
identifier work;
identifier priv_name, name;
expression gfp;
@@
func(..., const char *name, ...)
{
...
priv_work = kzalloc(sizeof(T), gfp);
...
- priv_work->priv_name = name;
+ priv_work->priv_name = kstrdup_const(name, gfp);
...
(... when any
if (...)
{
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
) ... when any
INIT_WORK(&priv_work->work, work_func);
...
schedule_work(&priv_work->work);
...
}
@ the_work_func depends on calls_schedule_work @
type calls_schedule_work.T;
T *priv_work;
identifier calls_schedule_work.work_func;
identifier calls_schedule_work.priv_name;
identifier calls_schedule_work.work;
identifier some_work;
@@
work_func(...)
{
...
priv_work = container_of(some_work, T, work);
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
[0] https://github.com/mcgrof/fake-firmware-test.git
[1] The following kernel ring buffer splat:
firmware name: test_module_stuff.bin
firmware name:
firmware found
general protection fault: 0000 [#1] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
Workqueue: events request_firmware_work_func
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff814a586c>] [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP: 0000:ffff8800c7f97d78 EFLAGS: 00010286
RAX: ffffffff81ae3700 RBX: ffffffff816d1181 RCX: 0000000000000006
RDX: 0001ee850ff68500 RSI: 0000000000000246 RDI: c35d5f415e415d41
RBP: ffff8800c7f97d88 R08: 000000000000000a R09: 0000000000000000
R10: 0000000000000358 R11: ffff8800c7f97a7e R12: ffff8800c7ec1e80
R13: ffff88021e2d4cc0 R14: ffff88021e2dff00 R15: 00000000000000c0
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000034b8cd8 CR3: 000000021073c000 CR4: 00000000001407e0
Stack:
ffffffff816d1181 ffff8800c7ec1e80 ffff8800c7f97da8 ffffffff814a58f8
000000000000000a ffffffff816d1181 ffff8800c7f97dc8 ffffffffa047002c
ffff88021e2dff00 ffff8802116ac1c0 ffff8800c7f97df8 ffffffff814a65fe
Call Trace:
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: c7 c6 dd ad a3 81 48 c7 c7 20 97 ce 81 31 c0 e8 0b b2 ed ff e9 78 ff ff ff 66 0f 1f 44 00 00 0f 1f 44 00 00 55 48 89 e5 41 54 53 <4c> 8b 67 38 48 89 fb 4c 89 e7 e8 85 f7 22 00 f0 83 2b 01 74 0f
RIP [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP <ffff8800c7f97d78>
---[ end trace 4e62c56a58d0eac1 ]---
BUG: unable to handle kernel paging request at ffffffffffffffd8
IP: [<ffffffff81093ee0>] kthread_data+0x10/0x20
PGD 1c13067 PUD 1c15067 PMD 0
Oops: 0000 [#2] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G D O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff81092ee0>] [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP: 0018:ffff8800c7f97b18 EFLAGS: 00010096
RAX: 0000000000000000 RBX: 0000000000000003 RCX: 000000000000000d
RDX: 0000000000000003 RSI: 0000000000000003 RDI: ffff8800c7f8e290
RBP: ffff8800c7f97b18 R08: 000000000000bc00 R09: 0000000000007e76
R10: 0000000000000001 R11: 000000000000002f R12: ffff8800c7f8e290
R13: 00000000000154c0 R14: 0000000000000003 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000000000028 CR3: 0000000210675000 CR4: 00000000001407e0
Stack:
ffff8800c7f97b38 ffffffff8108dcd5 ffff8800c7f97b38 ffff88021e2d54c0
ffff8800c7f97b88 ffffffff816d1500 ffff880213d42368 ffff8800c7f8e290
ffff8800c7f97b88 ffff8800c7f97fd8 ffff8800c7f8e710 0000000000000246
Call Trace:
[<ffffffff8108dcd5>] wq_worker_sleeping+0x15/0xa0
[<ffffffff816d1500>] __schedule+0x6e0/0x940
[<ffffffff816d1797>] schedule+0x37/0x90
[<ffffffff810779bc>] do_exit+0x6bc/0xb40
[<ffffffff8101898f>] oops_end+0x9f/0xe0
[<ffffffff81018efb>] die+0x4b/0x70
[<ffffffff81015622>] do_general_protection+0xe2/0x170
[<ffffffff816d74e8>] general_protection+0x28/0x30
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a586c>] ? fw_free_buf+0xc/0x40
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: 00 48 89 e5 5d 48 8b 40 c8 48 c1 e8 02 83 e0 01 c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 48 8b 87 30 05 00 00 55 48 89 e5 <48> 8b 40 d8 5d c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00
RIP [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP <ffff8800c7f97b18>
CR2: ffffffffffffffd8
---[ end trace 4e62c56a58d0eac2 ]---
Fixing recursive fault but reboot is needed!
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: David Howells <dhowells@redhat.com>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Seth Forshee <seth.forshee@canonical.com>
Cc: Kyle McMartin <kyle@kernel.org>
Generated-by: Coccinelle SmPL
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-05-12 15:49:42 -06:00
|
|
|
return -ENOMEM;
|
2015-05-28 18:46:42 -06:00
|
|
|
}
|
2010-06-04 01:54:43 -06:00
|
|
|
fw_work->device = device;
|
|
|
|
fw_work->context = context;
|
|
|
|
fw_work->cont = cont;
|
2013-12-02 07:38:18 -07:00
|
|
|
fw_work->opt_flags = FW_OPT_NOWAIT | FW_OPT_FALLBACK |
|
firmware loader: allow disabling of udev as firmware loader
[The patch was originally proposed by Tom Gundersen, and rewritten
afterwards by me; most of changelogs below borrowed from Tom's
original patch -- tiwai]
Currently (at least) the dell-rbu driver selects FW_LOADER_USER_HELPER,
which means that distros can't really stop loading firmware through
udev without breaking other users (though some have).
Ideally we would remove/disable the udev firmware helper in both the
kernel and in udev, but if we were to disable it in udev and not the
kernel, the result would be (seemingly) hung kernels as no one would
be around to cancel firmware requests.
This patch allows udev firmware loading to be disabled while still
allowing non-udev firmware loading, as done by the dell-rbu driver, to
continue working. This is achieved by only using the fallback
mechanism when the uevent is suppressed.
The patch renames the user-selectable Kconfig from FW_LOADER_USER_HELPER
to FW_LOADER_USER_HELPER_FALLBACK, and the former is reverse-selected
by the latter or the drivers that need userhelper like dell-rbu.
Also, the "default y" is removed together with this change, since it's
been deprecated in udev upstream, thus rather better to disable it
nowadays.
Tested with
FW_LOADER_USER_HELPER=n
LATTICE_ECP3_CONFIG=y
DELL_RBU=y
and udev without the firmware loading support, but I don't have the
hardware to test the lattice/dell drivers, so additional testing would
be appreciated.
Reviewed-by: Tom Gundersen <teg@jklm.no>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Abhay Salunke <Abhay_Salunke@dell.com>
Cc: Stefan Roese <sr@denx.de>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Kay Sievers <kay@vrfy.org>
Tested-by: Balaji Singh <B_B_Singh@DELL.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-06-04 09:48:15 -06:00
|
|
|
(uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!try_module_get(module)) {
|
firmware: fix possible use after free on name on asynchronous request
Asynchronous firmware loading copies the pointer to the
name passed as an argument only to be scheduled later and
used. This behaviour works well for synchronous calling
but in asynchronous mode there's a chance the caller could
immediately free the passed string after making the
asynchronous call. This could trigger a use after free
having the kernel look on disk for arbitrary file names.
In order to force-test the issue you can use a test-driver
designed to illustrate this issue on github [0], use the
next-20150505-fix-use-after-free branch.
With this patch applied you get:
[ 283.512445] firmware name: test_module_stuff.bin
[ 287.514020] firmware name: test_module_stuff.bin
[ 287.532489] firmware found
Without this patch applied you can end up with something such as:
[ 135.624216] firmware name: \xffffff80BJ
[ 135.624249] platform fake-dev.0: Direct firmware load for \xffffff80Bi failed with error -2
[ 135.624252] No firmware found
[ 135.624252] firmware found
Unfortunatley in the worst and most common case however you
can typically crash your system with a page fault by trying to
free something which you cannot, and/or a NULL pointer
dereference [1].
The fix and issue using schedule_work() for asynchronous
runs is generalized in the following SmPL grammar patch,
when applied to next-20150505 only the firmware_class
code is affected. This grammar patch can and should further
be generalized to vet for for other kernel asynchronous
mechanisms.
@ calls_schedule_work @
type T;
T *priv_work;
identifier func, work_func;
identifier work;
identifier priv_name, name;
expression gfp;
@@
func(..., const char *name, ...)
{
...
priv_work = kzalloc(sizeof(T), gfp);
...
- priv_work->priv_name = name;
+ priv_work->priv_name = kstrdup_const(name, gfp);
...
(... when any
if (...)
{
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
) ... when any
INIT_WORK(&priv_work->work, work_func);
...
schedule_work(&priv_work->work);
...
}
@ the_work_func depends on calls_schedule_work @
type calls_schedule_work.T;
T *priv_work;
identifier calls_schedule_work.work_func;
identifier calls_schedule_work.priv_name;
identifier calls_schedule_work.work;
identifier some_work;
@@
work_func(...)
{
...
priv_work = container_of(some_work, T, work);
...
+ kfree_const(priv_work->priv_name);
kfree(priv_work);
...
}
[0] https://github.com/mcgrof/fake-firmware-test.git
[1] The following kernel ring buffer splat:
firmware name: test_module_stuff.bin
firmware name:
firmware found
general protection fault: 0000 [#1] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
Workqueue: events request_firmware_work_func
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff814a586c>] [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP: 0000:ffff8800c7f97d78 EFLAGS: 00010286
RAX: ffffffff81ae3700 RBX: ffffffff816d1181 RCX: 0000000000000006
RDX: 0001ee850ff68500 RSI: 0000000000000246 RDI: c35d5f415e415d41
RBP: ffff8800c7f97d88 R08: 000000000000000a R09: 0000000000000000
R10: 0000000000000358 R11: ffff8800c7f97a7e R12: ffff8800c7ec1e80
R13: ffff88021e2d4cc0 R14: ffff88021e2dff00 R15: 00000000000000c0
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000034b8cd8 CR3: 000000021073c000 CR4: 00000000001407e0
Stack:
ffffffff816d1181 ffff8800c7ec1e80 ffff8800c7f97da8 ffffffff814a58f8
000000000000000a ffffffff816d1181 ffff8800c7f97dc8 ffffffffa047002c
ffff88021e2dff00 ffff8802116ac1c0 ffff8800c7f97df8 ffffffff814a65fe
Call Trace:
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: c7 c6 dd ad a3 81 48 c7 c7 20 97 ce 81 31 c0 e8 0b b2 ed ff e9 78 ff ff ff 66 0f 1f 44 00 00 0f 1f 44 00 00 55 48 89 e5 41 54 53 <4c> 8b 67 38 48 89 fb 4c 89 e7 e8 85 f7 22 00 f0 83 2b 01 74 0f
RIP [<ffffffff814a586c>] fw_free_buf+0xc/0x40
RSP <ffff8800c7f97d78>
---[ end trace 4e62c56a58d0eac1 ]---
BUG: unable to handle kernel paging request at ffffffffffffffd8
IP: [<ffffffff81093ee0>] kthread_data+0x10/0x20
PGD 1c13067 PUD 1c15067 PMD 0
Oops: 0000 [#2] SMP
Modules linked in: test(O) <...etc-it-does-not-matter>
drm sr_mod cdrom xhci_pci xhci_hcd rtsx_pci mfd_core video button sg
CPU: 3 PID: 87 Comm: kworker/3:2 Tainted: G D O 4.0.0-00010-g22b5bb0-dirty #176
Hardware name: LENOVO 20AW000LUS/20AW000LUS, BIOS GLET43WW (1.18 ) 12/04/2013
task: ffff8800c7f8e290 ti: ffff8800c7f94000 task.ti: ffff8800c7f94000
RIP: 0010:[<ffffffff81092ee0>] [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP: 0018:ffff8800c7f97b18 EFLAGS: 00010096
RAX: 0000000000000000 RBX: 0000000000000003 RCX: 000000000000000d
RDX: 0000000000000003 RSI: 0000000000000003 RDI: ffff8800c7f8e290
RBP: ffff8800c7f97b18 R08: 000000000000bc00 R09: 0000000000007e76
R10: 0000000000000001 R11: 000000000000002f R12: ffff8800c7f8e290
R13: 00000000000154c0 R14: 0000000000000003 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88021e2c0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000000000028 CR3: 0000000210675000 CR4: 00000000001407e0
Stack:
ffff8800c7f97b38 ffffffff8108dcd5 ffff8800c7f97b38 ffff88021e2d54c0
ffff8800c7f97b88 ffffffff816d1500 ffff880213d42368 ffff8800c7f8e290
ffff8800c7f97b88 ffff8800c7f97fd8 ffff8800c7f8e710 0000000000000246
Call Trace:
[<ffffffff8108dcd5>] wq_worker_sleeping+0x15/0xa0
[<ffffffff816d1500>] __schedule+0x6e0/0x940
[<ffffffff816d1797>] schedule+0x37/0x90
[<ffffffff810779bc>] do_exit+0x6bc/0xb40
[<ffffffff8101898f>] oops_end+0x9f/0xe0
[<ffffffff81018efb>] die+0x4b/0x70
[<ffffffff81015622>] do_general_protection+0xe2/0x170
[<ffffffff816d74e8>] general_protection+0x28/0x30
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a586c>] ? fw_free_buf+0xc/0x40
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff814a58f8>] release_firmware+0x58/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffffa047002c>] test_mod_cb+0x2c/0x43 [test]
[<ffffffff814a65fe>] request_firmware_work_func+0x5e/0x80
[<ffffffff816d1181>] ? __schedule+0x361/0x940
[<ffffffff8108d23a>] process_one_work+0x14a/0x3f0
[<ffffffff8108d911>] worker_thread+0x121/0x460
[<ffffffff8108d7f0>] ? rescuer_thread+0x310/0x310
[<ffffffff810928f9>] kthread+0xc9/0xe0
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
[<ffffffff816d52d8>] ret_from_fork+0x58/0x90
[<ffffffff81092830>] ? kthread_create_on_node+0x180/0x180
Code: 00 48 89 e5 5d 48 8b 40 c8 48 c1 e8 02 83 e0 01 c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 48 8b 87 30 05 00 00 55 48 89 e5 <48> 8b 40 d8 5d c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00
RIP [<ffffffff81092ee0>] kthread_data+0x10/0x20
RSP <ffff8800c7f97b18>
CR2: ffffffffffffffd8
---[ end trace 4e62c56a58d0eac2 ]---
Fixing recursive fault but reboot is needed!
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: David Howells <dhowells@redhat.com>
Cc: Ming Lei <ming.lei@canonical.com>
Cc: Seth Forshee <seth.forshee@canonical.com>
Cc: Kyle McMartin <kyle@kernel.org>
Generated-by: Coccinelle SmPL
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-05-12 15:49:42 -06:00
|
|
|
kfree_const(fw_work->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(fw_work);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:23 -06:00
|
|
|
get_device(fw_work->device);
|
2012-03-28 15:31:00 -06:00
|
|
|
INIT_WORK(&fw_work->work, request_firmware_work_func);
|
|
|
|
schedule_work(&fw_work->work);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-05-23 14:17:18 -06:00
|
|
|
EXPORT_SYMBOL(request_firmware_nowait);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-06-19 22:30:16 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
|
|
|
|
|
2012-08-03 22:01:22 -06:00
|
|
|
/**
|
|
|
|
* cache_firmware - cache one firmware image in kernel memory space
|
|
|
|
* @fw_name: the firmware image name
|
|
|
|
*
|
|
|
|
* Cache firmware in kernel memory so that drivers can use it when
|
|
|
|
* system isn't ready for them to request firmware image from userspace.
|
|
|
|
* Once it returns successfully, driver can use request_firmware or its
|
|
|
|
* nowait version to get the cached firmware without any interacting
|
|
|
|
* with userspace
|
|
|
|
*
|
|
|
|
* Return 0 if the firmware image has been cached successfully
|
|
|
|
* Return !0 otherwise
|
|
|
|
*
|
|
|
|
*/
|
2013-06-06 06:01:47 -06:00
|
|
|
static int cache_firmware(const char *fw_name)
|
2012-08-03 22:01:22 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
const struct firmware *fw;
|
|
|
|
|
|
|
|
pr_debug("%s: %s\n", __func__, fw_name);
|
|
|
|
|
|
|
|
ret = request_firmware(&fw, fw_name, NULL);
|
|
|
|
if (!ret)
|
|
|
|
kfree(fw);
|
|
|
|
|
|
|
|
pr_debug("%s: %s ret=%d\n", __func__, fw_name, ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-06-25 19:28:17 -06:00
|
|
|
static struct firmware_buf *fw_lookup_buf(const char *fw_name)
|
|
|
|
{
|
|
|
|
struct firmware_buf *tmp;
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
|
|
|
|
spin_lock(&fwc->lock);
|
|
|
|
tmp = __fw_lookup_buf(fw_name);
|
|
|
|
spin_unlock(&fwc->lock);
|
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:22 -06:00
|
|
|
/**
|
|
|
|
* uncache_firmware - remove one cached firmware image
|
|
|
|
* @fw_name: the firmware image name
|
|
|
|
*
|
|
|
|
* Uncache one firmware image which has been cached successfully
|
|
|
|
* before.
|
|
|
|
*
|
|
|
|
* Return 0 if the firmware cache has been removed successfully
|
|
|
|
* Return !0 otherwise
|
|
|
|
*
|
|
|
|
*/
|
2013-06-06 06:01:47 -06:00
|
|
|
static int uncache_firmware(const char *fw_name)
|
2012-08-03 22:01:22 -06:00
|
|
|
{
|
|
|
|
struct firmware_buf *buf;
|
|
|
|
struct firmware fw;
|
|
|
|
|
|
|
|
pr_debug("%s: %s\n", __func__, fw_name);
|
|
|
|
|
2016-08-02 15:04:28 -06:00
|
|
|
if (fw_get_builtin_firmware(&fw, fw_name, NULL, 0))
|
2012-08-03 22:01:22 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
buf = fw_lookup_buf(fw_name);
|
|
|
|
if (buf) {
|
|
|
|
fw_free_buf(buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:27 -06:00
|
|
|
static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
|
|
|
|
{
|
|
|
|
struct fw_cache_entry *fce;
|
|
|
|
|
2015-05-12 15:49:43 -06:00
|
|
|
fce = kzalloc(sizeof(*fce), GFP_ATOMIC);
|
2012-08-03 22:01:27 -06:00
|
|
|
if (!fce)
|
|
|
|
goto exit;
|
|
|
|
|
2015-05-12 15:49:43 -06:00
|
|
|
fce->name = kstrdup_const(name, GFP_ATOMIC);
|
|
|
|
if (!fce->name) {
|
|
|
|
kfree(fce);
|
|
|
|
fce = NULL;
|
|
|
|
goto exit;
|
|
|
|
}
|
2012-08-03 22:01:27 -06:00
|
|
|
exit:
|
|
|
|
return fce;
|
|
|
|
}
|
|
|
|
|
2012-10-08 22:01:01 -06:00
|
|
|
static int __fw_entry_found(const char *name)
|
2012-08-20 05:04:16 -06:00
|
|
|
{
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
struct fw_cache_entry *fce;
|
|
|
|
|
|
|
|
list_for_each_entry(fce, &fwc->fw_names, list) {
|
|
|
|
if (!strcmp(fce->name, name))
|
2012-10-08 22:01:01 -06:00
|
|
|
return 1;
|
2012-08-20 05:04:16 -06:00
|
|
|
}
|
2012-10-08 22:01:01 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fw_cache_piggyback_on_request(const char *name)
|
|
|
|
{
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
struct fw_cache_entry *fce;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
spin_lock(&fwc->name_lock);
|
|
|
|
if (__fw_entry_found(name))
|
|
|
|
goto found;
|
2012-08-20 05:04:16 -06:00
|
|
|
|
|
|
|
fce = alloc_fw_cache_entry(name);
|
|
|
|
if (fce) {
|
|
|
|
ret = 1;
|
|
|
|
list_add(&fce->list, &fwc->fw_names);
|
|
|
|
pr_debug("%s: fw: %s\n", __func__, name);
|
|
|
|
}
|
|
|
|
found:
|
|
|
|
spin_unlock(&fwc->name_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:27 -06:00
|
|
|
static void free_fw_cache_entry(struct fw_cache_entry *fce)
|
|
|
|
{
|
2015-05-12 15:49:43 -06:00
|
|
|
kfree_const(fce->name);
|
2012-08-03 22:01:27 -06:00
|
|
|
kfree(fce);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __async_dev_cache_fw_image(void *fw_entry,
|
|
|
|
async_cookie_t cookie)
|
|
|
|
{
|
|
|
|
struct fw_cache_entry *fce = fw_entry;
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = cache_firmware(fce->name);
|
2012-08-20 05:04:16 -06:00
|
|
|
if (ret) {
|
|
|
|
spin_lock(&fwc->name_lock);
|
|
|
|
list_del(&fce->list);
|
|
|
|
spin_unlock(&fwc->name_lock);
|
2012-08-03 22:01:27 -06:00
|
|
|
|
2012-08-20 05:04:16 -06:00
|
|
|
free_fw_cache_entry(fce);
|
|
|
|
}
|
2012-08-03 22:01:27 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* called with dev->devres_lock held */
|
|
|
|
static void dev_create_fw_entry(struct device *dev, void *res,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct fw_name_devm *fwn = res;
|
|
|
|
const char *fw_name = fwn->name;
|
|
|
|
struct list_head *head = data;
|
|
|
|
struct fw_cache_entry *fce;
|
|
|
|
|
|
|
|
fce = alloc_fw_cache_entry(fw_name);
|
|
|
|
if (fce)
|
|
|
|
list_add(&fce->list, head);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int devm_name_match(struct device *dev, void *res,
|
|
|
|
void *match_data)
|
|
|
|
{
|
|
|
|
struct fw_name_devm *fwn = res;
|
|
|
|
return (fwn->magic == (unsigned long)match_data);
|
|
|
|
}
|
|
|
|
|
2012-08-17 08:07:00 -06:00
|
|
|
static void dev_cache_fw_image(struct device *dev, void *data)
|
2012-08-03 22:01:27 -06:00
|
|
|
{
|
|
|
|
LIST_HEAD(todo);
|
|
|
|
struct fw_cache_entry *fce;
|
|
|
|
struct fw_cache_entry *fce_next;
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
|
|
|
|
devres_for_each_res(dev, fw_name_devm_release,
|
|
|
|
devm_name_match, &fw_cache,
|
|
|
|
dev_create_fw_entry, &todo);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(fce, fce_next, &todo, list) {
|
|
|
|
list_del(&fce->list);
|
|
|
|
|
|
|
|
spin_lock(&fwc->name_lock);
|
2012-10-08 22:01:01 -06:00
|
|
|
/* only one cache entry for one firmware */
|
|
|
|
if (!__fw_entry_found(fce->name)) {
|
|
|
|
list_add(&fce->list, &fwc->fw_names);
|
|
|
|
} else {
|
|
|
|
free_fw_cache_entry(fce);
|
|
|
|
fce = NULL;
|
|
|
|
}
|
2012-08-03 22:01:27 -06:00
|
|
|
spin_unlock(&fwc->name_lock);
|
|
|
|
|
2012-10-08 22:01:01 -06:00
|
|
|
if (fce)
|
2012-10-08 22:01:04 -06:00
|
|
|
async_schedule_domain(__async_dev_cache_fw_image,
|
|
|
|
(void *)fce,
|
|
|
|
&fw_cache_domain);
|
2012-08-03 22:01:27 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __device_uncache_fw_images(void)
|
|
|
|
{
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
|
|
|
struct fw_cache_entry *fce;
|
|
|
|
|
|
|
|
spin_lock(&fwc->name_lock);
|
|
|
|
while (!list_empty(&fwc->fw_names)) {
|
|
|
|
fce = list_entry(fwc->fw_names.next,
|
|
|
|
struct fw_cache_entry, list);
|
|
|
|
list_del(&fce->list);
|
|
|
|
spin_unlock(&fwc->name_lock);
|
|
|
|
|
|
|
|
uncache_firmware(fce->name);
|
|
|
|
free_fw_cache_entry(fce);
|
|
|
|
|
|
|
|
spin_lock(&fwc->name_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(&fwc->name_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_cache_fw_images - cache devices' firmware
|
|
|
|
*
|
|
|
|
* If one device called request_firmware or its nowait version
|
|
|
|
* successfully before, the firmware names are recored into the
|
|
|
|
* device's devres link list, so device_cache_fw_images can call
|
|
|
|
* cache_firmware() to cache these firmwares for the device,
|
|
|
|
* then the device driver can load its firmwares easily at
|
|
|
|
* time when system is not ready to complete loading firmware.
|
|
|
|
*/
|
|
|
|
static void device_cache_fw_images(void)
|
|
|
|
{
|
|
|
|
struct firmware_cache *fwc = &fw_cache;
|
2012-08-03 22:01:28 -06:00
|
|
|
int old_timeout;
|
2012-08-03 22:01:27 -06:00
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
pr_debug("%s\n", __func__);
|
|
|
|
|
2012-10-08 22:01:01 -06:00
|
|
|
/* cancel uncache work */
|
|
|
|
cancel_delayed_work_sync(&fwc->work);
|
|
|
|
|
2012-08-03 22:01:28 -06:00
|
|
|
/*
|
|
|
|
* use small loading timeout for caching devices' firmware
|
|
|
|
* because all these firmware images have been loaded
|
|
|
|
* successfully at lease once, also system is ready for
|
|
|
|
* completing firmware loading now. The maximum size of
|
|
|
|
* firmware in current distributions is about 2M bytes,
|
|
|
|
* so 10 secs should be enough.
|
|
|
|
*/
|
|
|
|
old_timeout = loading_timeout;
|
|
|
|
loading_timeout = 10;
|
|
|
|
|
2012-08-20 05:04:16 -06:00
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
fwc->state = FW_LOADER_START_CACHE;
|
2012-08-17 08:07:00 -06:00
|
|
|
dpm_for_each_dev(NULL, dev_cache_fw_image);
|
2012-08-20 05:04:16 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2012-08-03 22:01:27 -06:00
|
|
|
|
|
|
|
/* wait for completion of caching firmware for all devices */
|
2012-10-08 22:01:04 -06:00
|
|
|
async_synchronize_full_domain(&fw_cache_domain);
|
2012-08-03 22:01:28 -06:00
|
|
|
|
|
|
|
loading_timeout = old_timeout;
|
2012-08-03 22:01:27 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_uncache_fw_images - uncache devices' firmware
|
|
|
|
*
|
|
|
|
* uncache all firmwares which have been cached successfully
|
|
|
|
* by device_uncache_fw_images earlier
|
|
|
|
*/
|
|
|
|
static void device_uncache_fw_images(void)
|
|
|
|
{
|
|
|
|
pr_debug("%s\n", __func__);
|
|
|
|
__device_uncache_fw_images();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void device_uncache_fw_images_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
device_uncache_fw_images();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_uncache_fw_images_delay - uncache devices firmwares
|
|
|
|
* @delay: number of milliseconds to delay uncache device firmwares
|
|
|
|
*
|
|
|
|
* uncache all devices's firmwares which has been cached successfully
|
|
|
|
* by device_cache_fw_images after @delay milliseconds.
|
|
|
|
*/
|
|
|
|
static void device_uncache_fw_images_delay(unsigned long delay)
|
|
|
|
{
|
2014-01-31 16:44:58 -07:00
|
|
|
queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
|
|
|
|
msecs_to_jiffies(delay));
|
2012-08-03 22:01:27 -06:00
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:29 -06:00
|
|
|
static int fw_pm_notify(struct notifier_block *notify_block,
|
|
|
|
unsigned long mode, void *unused)
|
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case PM_HIBERNATION_PREPARE:
|
|
|
|
case PM_SUSPEND_PREPARE:
|
2014-02-18 18:52:08 -07:00
|
|
|
case PM_RESTORE_PREPARE:
|
2013-05-27 04:30:04 -06:00
|
|
|
kill_requests_without_uevent();
|
2012-08-03 22:01:29 -06:00
|
|
|
device_cache_fw_images();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PM_POST_SUSPEND:
|
|
|
|
case PM_POST_HIBERNATION:
|
|
|
|
case PM_POST_RESTORE:
|
2012-08-20 05:04:16 -06:00
|
|
|
/*
|
|
|
|
* In case that system sleep failed and syscore_suspend is
|
|
|
|
* not called.
|
|
|
|
*/
|
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
fw_cache.state = FW_LOADER_NO_CACHE;
|
|
|
|
mutex_unlock(&fw_lock);
|
|
|
|
|
2012-08-03 22:01:29 -06:00
|
|
|
device_uncache_fw_images_delay(10 * MSEC_PER_SEC);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-20 05:04:16 -06:00
|
|
|
/* stop caching firmware once syscore_suspend is reached */
|
|
|
|
static int fw_suspend(void)
|
|
|
|
{
|
|
|
|
fw_cache.state = FW_LOADER_NO_CACHE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct syscore_ops fw_syscore_ops = {
|
|
|
|
.suspend = fw_suspend,
|
|
|
|
};
|
2012-09-08 03:32:30 -06:00
|
|
|
#else
|
|
|
|
static int fw_cache_piggyback_on_request(const char *name)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2012-08-20 05:04:16 -06:00
|
|
|
|
2012-08-03 22:01:27 -06:00
|
|
|
static void __init fw_cache_init(void)
|
|
|
|
{
|
|
|
|
spin_lock_init(&fw_cache.lock);
|
|
|
|
INIT_LIST_HEAD(&fw_cache.head);
|
2012-09-08 03:32:30 -06:00
|
|
|
fw_cache.state = FW_LOADER_NO_CACHE;
|
2012-08-03 22:01:27 -06:00
|
|
|
|
2012-09-08 03:32:30 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-08-03 22:01:27 -06:00
|
|
|
spin_lock_init(&fw_cache.name_lock);
|
|
|
|
INIT_LIST_HEAD(&fw_cache.fw_names);
|
|
|
|
|
|
|
|
INIT_DELAYED_WORK(&fw_cache.work,
|
|
|
|
device_uncache_fw_images_work);
|
2012-08-03 22:01:29 -06:00
|
|
|
|
|
|
|
fw_cache.pm_notify.notifier_call = fw_pm_notify;
|
|
|
|
register_pm_notifier(&fw_cache.pm_notify);
|
2012-08-20 05:04:16 -06:00
|
|
|
|
|
|
|
register_syscore_ops(&fw_syscore_ops);
|
2012-09-08 03:32:30 -06:00
|
|
|
#endif
|
2012-08-03 22:01:27 -06:00
|
|
|
}
|
|
|
|
|
2010-03-14 00:49:13 -07:00
|
|
|
static int __init firmware_class_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-08-03 22:01:21 -06:00
|
|
|
fw_cache_init();
|
2013-01-31 03:13:55 -07:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
2013-05-22 10:28:38 -06:00
|
|
|
register_reboot_notifier(&fw_shutdown_nb);
|
2010-03-14 00:49:13 -07:00
|
|
|
return class_register(&firmware_class);
|
2013-01-31 03:13:55 -07:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-03-14 00:49:13 -07:00
|
|
|
|
|
|
|
static void __exit firmware_class_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-09-08 03:32:30 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-08-20 05:04:16 -06:00
|
|
|
unregister_syscore_ops(&fw_syscore_ops);
|
2012-08-03 22:01:29 -06:00
|
|
|
unregister_pm_notifier(&fw_cache.pm_notify);
|
2012-09-08 03:32:30 -06:00
|
|
|
#endif
|
2013-01-31 03:13:55 -07:00
|
|
|
#ifdef CONFIG_FW_LOADER_USER_HELPER
|
2013-05-22 10:28:38 -06:00
|
|
|
unregister_reboot_notifier(&fw_shutdown_nb);
|
2005-04-16 16:20:36 -06:00
|
|
|
class_unregister(&firmware_class);
|
2013-01-31 03:13:55 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-27 02:50:52 -06:00
|
|
|
fs_initcall(firmware_class_init);
|
2005-04-16 16:20:36 -06:00
|
|
|
module_exit(firmware_class_exit);
|