2010-05-27 05:43:54 +08:00
|
|
|
/*
|
|
|
|
|
* RAM Oops/Panic logger
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
|
2012-05-03 13:45:02 +08:00
|
|
|
* Copyright (C) 2011 Kees Cook <keescook@chromium.org>
|
2010-05-27 05:43:54 +08:00
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* version 2 as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
|
|
|
* 02110-1301 USA
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2011-07-27 07:08:57 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
2010-05-27 05:43:54 +08:00
|
|
|
#include <linux/kernel.h>
|
2011-07-29 21:11:32 +08:00
|
|
|
#include <linux/err.h>
|
2010-05-27 05:43:54 +08:00
|
|
|
#include <linux/module.h>
|
pstore/ram: Make tracing log versioned
Decoding the binary trace w/ a different kernel might be troublesome
since we convert addresses to symbols. For kernels with minimal changes,
the mappings would probably match, but it's not guaranteed at all.
(But still we could convert the addresses by hand, since we do print
raw addresses.)
If we use modules, the symbols could be loaded at different addresses
from the previously booted kernel, and so this would also fail, but
there's nothing we can do about it.
Also, the binary data format that pstore/ram is using in its ringbuffer
may change between the kernels, so here we too must ensure that we're
running the same kernel.
So, there are two questions really:
1. How to compute the unique kernel tag;
2. Where to store it.
In this patch we're using LINUX_VERSION_CODE, just as hibernation
(suspend-to-disk) does. This way we are protecting from the kernel
version mismatch, making sure that we're running the same kernel
version and patch level. We could use CRC of a symbol table (as
suggested by Tony Luck), but for now let's not be that strict.
And as for storing, we are using a small trick here. Instead of
allocating a dedicated buffer for the tag (i.e. another prz), or
hacking ram_core routines to "reserve" some control data in the
buffer, we are just encoding the tag into the buffer signature
(and XOR'ing it with the actual signature value, so that buffers
not needing a tag can just pass zero, which will result into the
plain old PRZ signature).
Suggested-by: Steven Rostedt <rostedt@goodmis.org>
Suggested-by: Tony Luck <tony.luck@intel.com>
Suggested-by: Colin Cross <ccross@android.com>
Signed-off-by: Anton Vorontsov <anton.vorontsov@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-18 03:11:12 +08:00
|
|
|
#include <linux/version.h>
|
2012-05-03 13:45:02 +08:00
|
|
|
#include <linux/pstore.h>
|
2010-05-27 05:43:54 +08:00
|
|
|
#include <linux/time.h>
|
|
|
|
|
#include <linux/io.h>
|
|
|
|
|
#include <linux/ioport.h>
|
2010-10-28 06:34:52 +08:00
|
|
|
#include <linux/platform_device.h>
|
2011-07-27 07:08:57 +08:00
|
|
|
#include <linux/slab.h>
|
2012-07-18 10:49:37 +08:00
|
|
|
#include <linux/compiler.h>
|
2012-05-16 20:43:08 +08:00
|
|
|
#include <linux/pstore_ram.h>
|
2010-05-27 05:43:54 +08:00
|
|
|
|
|
|
|
|
#define RAMOOPS_KERNMSG_HDR "===="
|
2011-07-27 07:08:59 +08:00
|
|
|
#define MIN_MEM_SIZE 4096UL
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2011-07-27 07:08:59 +08:00
|
|
|
static ulong record_size = MIN_MEM_SIZE;
|
|
|
|
|
module_param(record_size, ulong, 0400);
|
|
|
|
|
MODULE_PARM_DESC(record_size,
|
|
|
|
|
"size of each dump done on oops/panic");
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2012-05-26 21:20:23 +08:00
|
|
|
static ulong ramoops_console_size = MIN_MEM_SIZE;
|
|
|
|
|
module_param_named(console_size, ramoops_console_size, ulong, 0400);
|
|
|
|
|
MODULE_PARM_DESC(console_size, "size of kernel console log");
|
|
|
|
|
|
2012-07-10 08:10:44 +08:00
|
|
|
static ulong ramoops_ftrace_size = MIN_MEM_SIZE;
|
|
|
|
|
module_param_named(ftrace_size, ramoops_ftrace_size, ulong, 0400);
|
|
|
|
|
MODULE_PARM_DESC(ftrace_size, "size of ftrace log");
|
|
|
|
|
|
2015-01-17 08:01:10 +08:00
|
|
|
static ulong ramoops_pmsg_size = MIN_MEM_SIZE;
|
|
|
|
|
module_param_named(pmsg_size, ramoops_pmsg_size, ulong, 0400);
|
|
|
|
|
MODULE_PARM_DESC(pmsg_size, "size of user space message log");
|
|
|
|
|
|
2010-05-27 05:43:54 +08:00
|
|
|
static ulong mem_address;
|
|
|
|
|
module_param(mem_address, ulong, 0400);
|
|
|
|
|
MODULE_PARM_DESC(mem_address,
|
|
|
|
|
"start of reserved RAM used to store oops/panic logs");
|
|
|
|
|
|
|
|
|
|
static ulong mem_size;
|
|
|
|
|
module_param(mem_size, ulong, 0400);
|
|
|
|
|
MODULE_PARM_DESC(mem_size,
|
|
|
|
|
"size of reserved RAM used to store oops/panic logs");
|
|
|
|
|
|
2014-09-17 04:50:01 +08:00
|
|
|
static unsigned int mem_type;
|
|
|
|
|
module_param(mem_type, uint, 0600);
|
|
|
|
|
MODULE_PARM_DESC(mem_type,
|
|
|
|
|
"set to 1 to try to use unbuffered memory (default 0)");
|
|
|
|
|
|
2010-05-27 05:43:54 +08:00
|
|
|
static int dump_oops = 1;
|
|
|
|
|
module_param(dump_oops, int, 0600);
|
|
|
|
|
MODULE_PARM_DESC(dump_oops,
|
|
|
|
|
"set to 1 to dump oopses, 0 to only dump panics (default 1)");
|
|
|
|
|
|
2012-05-17 15:15:34 +08:00
|
|
|
static int ramoops_ecc;
|
|
|
|
|
module_param_named(ecc, ramoops_ecc, int, 0600);
|
|
|
|
|
MODULE_PARM_DESC(ramoops_ecc,
|
2012-07-10 08:03:19 +08:00
|
|
|
"if non-zero, the option enables ECC support and specifies "
|
|
|
|
|
"ECC buffer size in bytes (1 is a special value, means 16 "
|
|
|
|
|
"bytes ECC)");
|
2012-05-17 15:15:34 +08:00
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
struct ramoops_context {
|
2012-05-17 15:15:18 +08:00
|
|
|
struct persistent_ram_zone **przs;
|
2012-05-26 21:20:23 +08:00
|
|
|
struct persistent_ram_zone *cprz;
|
2012-07-10 08:10:44 +08:00
|
|
|
struct persistent_ram_zone *fprz;
|
2015-01-17 08:01:10 +08:00
|
|
|
struct persistent_ram_zone *mprz;
|
2010-05-27 05:43:54 +08:00
|
|
|
phys_addr_t phys_addr;
|
|
|
|
|
unsigned long size;
|
2014-09-17 04:50:01 +08:00
|
|
|
unsigned int memtype;
|
2012-05-03 13:45:02 +08:00
|
|
|
size_t record_size;
|
2012-05-26 21:20:23 +08:00
|
|
|
size_t console_size;
|
2012-07-10 08:10:44 +08:00
|
|
|
size_t ftrace_size;
|
2015-01-17 08:01:10 +08:00
|
|
|
size_t pmsg_size;
|
2011-07-27 07:08:58 +08:00
|
|
|
int dump_oops;
|
2012-05-23 07:33:23 +08:00
|
|
|
struct persistent_ram_ecc_info ecc_info;
|
2012-05-26 21:20:20 +08:00
|
|
|
unsigned int max_dump_cnt;
|
|
|
|
|
unsigned int dump_write_cnt;
|
2014-03-17 08:24:49 +08:00
|
|
|
/* _read_cnt need clear on ramoops_pstore_open */
|
2012-05-26 21:20:20 +08:00
|
|
|
unsigned int dump_read_cnt;
|
2012-05-26 21:20:23 +08:00
|
|
|
unsigned int console_read_cnt;
|
2012-07-10 08:10:44 +08:00
|
|
|
unsigned int ftrace_read_cnt;
|
2015-01-17 08:01:10 +08:00
|
|
|
unsigned int pmsg_read_cnt;
|
2012-05-03 13:45:02 +08:00
|
|
|
struct pstore_info pstore;
|
|
|
|
|
};
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2011-07-27 07:08:57 +08:00
|
|
|
static struct platform_device *dummy;
|
|
|
|
|
static struct ramoops_platform_data *dummy_data;
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
static int ramoops_pstore_open(struct pstore_info *psi)
|
|
|
|
|
{
|
|
|
|
|
struct ramoops_context *cxt = psi->data;
|
|
|
|
|
|
2012-05-26 21:20:20 +08:00
|
|
|
cxt->dump_read_cnt = 0;
|
2012-05-26 21:20:23 +08:00
|
|
|
cxt->console_read_cnt = 0;
|
2014-03-17 08:24:49 +08:00
|
|
|
cxt->ftrace_read_cnt = 0;
|
2015-01-17 08:01:10 +08:00
|
|
|
cxt->pmsg_read_cnt = 0;
|
2012-05-03 13:45:02 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-26 21:20:22 +08:00
|
|
|
static struct persistent_ram_zone *
|
|
|
|
|
ramoops_get_next_prz(struct persistent_ram_zone *przs[], uint *c, uint max,
|
|
|
|
|
u64 *id,
|
|
|
|
|
enum pstore_type_id *typep, enum pstore_type_id type,
|
|
|
|
|
bool update)
|
|
|
|
|
{
|
|
|
|
|
struct persistent_ram_zone *prz;
|
|
|
|
|
int i = (*c)++;
|
|
|
|
|
|
|
|
|
|
if (i >= max)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
prz = przs[i];
|
2014-03-18 04:57:49 +08:00
|
|
|
if (!prz)
|
|
|
|
|
return NULL;
|
2012-05-26 21:20:22 +08:00
|
|
|
|
2014-03-17 08:24:49 +08:00
|
|
|
/* Update old/shadowed buffer. */
|
|
|
|
|
if (update)
|
2012-05-26 21:20:22 +08:00
|
|
|
persistent_ram_save_old(prz);
|
2014-03-17 08:24:49 +08:00
|
|
|
|
|
|
|
|
if (!persistent_ram_old_size(prz))
|
|
|
|
|
return NULL;
|
2012-05-26 21:20:22 +08:00
|
|
|
|
|
|
|
|
*typep = type;
|
|
|
|
|
*id = i;
|
|
|
|
|
|
|
|
|
|
return prz;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-31 08:14:21 +08:00
|
|
|
static int ramoops_read_kmsg_hdr(char *buffer, struct timespec *time,
|
2013-08-17 04:58:00 +08:00
|
|
|
bool *compressed)
|
|
|
|
|
{
|
|
|
|
|
char data_type;
|
2014-10-31 08:14:21 +08:00
|
|
|
int header_length = 0;
|
2013-08-17 04:58:00 +08:00
|
|
|
|
2014-10-31 08:14:21 +08:00
|
|
|
if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n%n", &time->tv_sec,
|
|
|
|
|
&time->tv_nsec, &data_type, &header_length) == 3) {
|
2013-08-17 04:58:00 +08:00
|
|
|
if (data_type == 'C')
|
|
|
|
|
*compressed = true;
|
|
|
|
|
else
|
|
|
|
|
*compressed = false;
|
2014-10-31 08:14:21 +08:00
|
|
|
} else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu\n%n",
|
|
|
|
|
&time->tv_sec, &time->tv_nsec, &header_length) == 2) {
|
2013-08-17 04:58:00 +08:00
|
|
|
*compressed = false;
|
|
|
|
|
} else {
|
|
|
|
|
time->tv_sec = 0;
|
|
|
|
|
time->tv_nsec = 0;
|
|
|
|
|
*compressed = false;
|
|
|
|
|
}
|
2014-10-31 08:14:21 +08:00
|
|
|
return header_length;
|
2013-08-17 04:58:00 +08:00
|
|
|
}
|
|
|
|
|
|
2015-01-14 06:32:50 +08:00
|
|
|
static bool prz_ok(struct persistent_ram_zone *prz)
|
|
|
|
|
{
|
|
|
|
|
return !!prz && !!(persistent_ram_old_size(prz) +
|
|
|
|
|
persistent_ram_ecc_string(prz, NULL, 0));
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
|
efi_pstore: Add a sequence counter to a variable name
[Issue]
Currently, a variable name, which identifies each entry, consists of type, id and ctime.
But if multiple events happens in a short time, a second/third event may fail to log because
efi_pstore can't distinguish each event with current variable name.
[Solution]
A reasonable way to identify all events precisely is introducing a sequence counter to
the variable name.
The sequence counter has already supported in a pstore layer with "oopscount".
So, this patch adds it to a variable name.
Also, it is passed to read/erase callbacks of platform drivers in accordance with
the modification of the variable name.
<before applying this patch>
a variable name of first event: dump-type0-1-12345678
a variable name of second event: dump-type0-1-12345678
type:0
id:1
ctime:12345678
If multiple events happen in a short time, efi_pstore can't distinguish them because
variable names are same among them.
<after applying this patch>
it can be distinguishable by adding a sequence counter as follows.
a variable name of first event: dump-type0-1-1-12345678
a variable name of Second event: dump-type0-1-2-12345678
type:0
id:1
sequence counter: 1(first event), 2(second event)
ctime:12345678
In case of a write callback executed in pstore_console_write(), "0" is added to
an argument of the write callback because it just logs all kernel messages and
doesn't need to care about multiple events.
Signed-off-by: Seiji Aguchi <seiji.aguchi@hds.com>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Mike Waychison <mikew@google.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2012-11-27 08:07:44 +08:00
|
|
|
int *count, struct timespec *time,
|
2013-08-17 04:53:19 +08:00
|
|
|
char **buf, bool *compressed,
|
|
|
|
|
struct pstore_info *psi)
|
2010-05-27 05:43:54 +08:00
|
|
|
{
|
2012-05-03 13:45:02 +08:00
|
|
|
ssize_t size;
|
2012-12-06 13:19:51 +08:00
|
|
|
ssize_t ecc_notice_size;
|
2012-05-03 13:45:02 +08:00
|
|
|
struct ramoops_context *cxt = psi->data;
|
2015-05-22 00:50:34 +08:00
|
|
|
struct persistent_ram_zone *prz = NULL;
|
|
|
|
|
int header_length = 0;
|
|
|
|
|
|
|
|
|
|
/* Ramoops headers provide time stamps for PSTORE_TYPE_DMESG, but
|
|
|
|
|
* PSTORE_TYPE_CONSOLE and PSTORE_TYPE_FTRACE don't currently have
|
|
|
|
|
* valid time stamps, so it is initialized to zero.
|
|
|
|
|
*/
|
|
|
|
|
time->tv_sec = 0;
|
|
|
|
|
time->tv_nsec = 0;
|
|
|
|
|
*compressed = false;
|
|
|
|
|
|
|
|
|
|
/* Find the next valid persistent_ram_zone for DMESG */
|
|
|
|
|
while (cxt->dump_read_cnt < cxt->max_dump_cnt && !prz) {
|
|
|
|
|
prz = ramoops_get_next_prz(cxt->przs, &cxt->dump_read_cnt,
|
|
|
|
|
cxt->max_dump_cnt, id, type,
|
|
|
|
|
PSTORE_TYPE_DMESG, 1);
|
|
|
|
|
if (!prz_ok(prz))
|
|
|
|
|
continue;
|
|
|
|
|
header_length = ramoops_read_kmsg_hdr(persistent_ram_old(prz),
|
|
|
|
|
time, compressed);
|
|
|
|
|
/* Clear and skip this DMESG record if it has no valid header */
|
|
|
|
|
if (!header_length) {
|
|
|
|
|
persistent_ram_free_old(prz);
|
|
|
|
|
persistent_ram_zap(prz);
|
|
|
|
|
prz = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-05-03 13:45:02 +08:00
|
|
|
|
2015-01-14 06:32:50 +08:00
|
|
|
if (!prz_ok(prz))
|
2012-05-26 21:20:23 +08:00
|
|
|
prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt,
|
|
|
|
|
1, id, type, PSTORE_TYPE_CONSOLE, 0);
|
2015-01-14 06:32:50 +08:00
|
|
|
if (!prz_ok(prz))
|
2012-07-10 08:10:44 +08:00
|
|
|
prz = ramoops_get_next_prz(&cxt->fprz, &cxt->ftrace_read_cnt,
|
|
|
|
|
1, id, type, PSTORE_TYPE_FTRACE, 0);
|
2015-01-17 08:01:10 +08:00
|
|
|
if (!prz_ok(prz))
|
|
|
|
|
prz = ramoops_get_next_prz(&cxt->mprz, &cxt->pmsg_read_cnt,
|
|
|
|
|
1, id, type, PSTORE_TYPE_PMSG, 0);
|
2015-01-14 06:32:50 +08:00
|
|
|
if (!prz_ok(prz))
|
2012-05-26 21:20:22 +08:00
|
|
|
return 0;
|
2012-05-17 15:15:18 +08:00
|
|
|
|
2015-05-22 00:50:34 +08:00
|
|
|
size = persistent_ram_old_size(prz) - header_length;
|
2012-12-06 13:19:51 +08:00
|
|
|
|
|
|
|
|
/* ECC correction notice */
|
|
|
|
|
ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0);
|
|
|
|
|
|
|
|
|
|
*buf = kmalloc(size + ecc_notice_size + 1, GFP_KERNEL);
|
2012-05-03 13:45:02 +08:00
|
|
|
if (*buf == NULL)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2014-10-31 08:14:21 +08:00
|
|
|
memcpy(*buf, (char *)persistent_ram_old(prz) + header_length, size);
|
2012-12-06 13:19:51 +08:00
|
|
|
persistent_ram_ecc_string(prz, *buf + size, ecc_notice_size + 1);
|
|
|
|
|
|
|
|
|
|
return size + ecc_notice_size;
|
2012-05-03 13:45:02 +08:00
|
|
|
}
|
|
|
|
|
|
2013-08-17 04:58:00 +08:00
|
|
|
static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
|
|
|
|
|
bool compressed)
|
2012-05-17 15:15:18 +08:00
|
|
|
{
|
|
|
|
|
char *hdr;
|
2012-11-20 02:26:16 +08:00
|
|
|
struct timespec timestamp;
|
2012-05-17 15:15:18 +08:00
|
|
|
size_t len;
|
|
|
|
|
|
2012-11-20 02:26:16 +08:00
|
|
|
/* Report zeroed timestamp if called before timekeeping has resumed. */
|
|
|
|
|
if (__getnstimeofday(×tamp)) {
|
|
|
|
|
timestamp.tv_sec = 0;
|
|
|
|
|
timestamp.tv_nsec = 0;
|
|
|
|
|
}
|
2013-08-17 04:58:00 +08:00
|
|
|
hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n",
|
|
|
|
|
(long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000),
|
|
|
|
|
compressed ? 'C' : 'D');
|
2012-05-17 15:15:18 +08:00
|
|
|
WARN_ON_ONCE(!hdr);
|
|
|
|
|
len = hdr ? strlen(hdr) : 0;
|
|
|
|
|
persistent_ram_write(prz, hdr, len);
|
|
|
|
|
kfree(hdr);
|
|
|
|
|
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-18 10:49:37 +08:00
|
|
|
static int notrace ramoops_pstore_write_buf(enum pstore_type_id type,
|
|
|
|
|
enum kmsg_dump_reason reason,
|
|
|
|
|
u64 *id, unsigned int part,
|
2013-06-27 16:32:56 +08:00
|
|
|
const char *buf,
|
2013-08-17 04:52:47 +08:00
|
|
|
bool compressed, size_t size,
|
2012-07-18 10:49:37 +08:00
|
|
|
struct pstore_info *psi)
|
2012-05-03 13:45:02 +08:00
|
|
|
{
|
|
|
|
|
struct ramoops_context *cxt = psi->data;
|
2012-12-12 09:49:24 +08:00
|
|
|
struct persistent_ram_zone *prz;
|
2012-05-17 15:15:18 +08:00
|
|
|
size_t hlen;
|
2012-05-03 13:45:02 +08:00
|
|
|
|
2012-05-26 21:20:23 +08:00
|
|
|
if (type == PSTORE_TYPE_CONSOLE) {
|
|
|
|
|
if (!cxt->cprz)
|
|
|
|
|
return -ENOMEM;
|
2012-07-10 08:10:43 +08:00
|
|
|
persistent_ram_write(cxt->cprz, buf, size);
|
2012-05-26 21:20:23 +08:00
|
|
|
return 0;
|
2012-07-10 08:10:44 +08:00
|
|
|
} else if (type == PSTORE_TYPE_FTRACE) {
|
|
|
|
|
if (!cxt->fprz)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
persistent_ram_write(cxt->fprz, buf, size);
|
|
|
|
|
return 0;
|
2015-01-17 08:01:10 +08:00
|
|
|
} else if (type == PSTORE_TYPE_PMSG) {
|
|
|
|
|
if (!cxt->mprz)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
persistent_ram_write(cxt->mprz, buf, size);
|
|
|
|
|
return 0;
|
2012-05-26 21:20:23 +08:00
|
|
|
}
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
if (type != PSTORE_TYPE_DMESG)
|
|
|
|
|
return -EINVAL;
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
/* Out of the various dmesg dump types, ramoops is currently designed
|
|
|
|
|
* to only store crash logs, rather than storing general kernel logs.
|
|
|
|
|
*/
|
2011-01-13 08:59:29 +08:00
|
|
|
if (reason != KMSG_DUMP_OOPS &&
|
2012-01-13 09:20:11 +08:00
|
|
|
reason != KMSG_DUMP_PANIC)
|
2012-05-03 13:45:02 +08:00
|
|
|
return -EINVAL;
|
2011-01-13 08:59:29 +08:00
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
/* Skip Oopes when configured to do so. */
|
2011-07-27 07:08:58 +08:00
|
|
|
if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
|
2012-05-03 13:45:02 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Explicitly only take the first part of any new crash.
|
|
|
|
|
* If our buffer is larger than kmsg_bytes, this can never happen,
|
|
|
|
|
* and if our buffer is smaller than kmsg_bytes, we don't want the
|
|
|
|
|
* report split across multiple records.
|
|
|
|
|
*/
|
|
|
|
|
if (part != 1)
|
|
|
|
|
return -ENOSPC;
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2012-12-12 09:49:24 +08:00
|
|
|
if (!cxt->przs)
|
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
|
|
prz = cxt->przs[cxt->dump_write_cnt];
|
|
|
|
|
|
2013-08-17 04:58:00 +08:00
|
|
|
hlen = ramoops_write_kmsg_hdr(prz, compressed);
|
2012-05-17 15:15:18 +08:00
|
|
|
if (size + hlen > prz->buffer_size)
|
|
|
|
|
size = prz->buffer_size - hlen;
|
2012-07-10 08:10:43 +08:00
|
|
|
persistent_ram_write(prz, buf, size);
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2012-05-26 21:20:20 +08:00
|
|
|
cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
|
2012-05-03 13:45:02 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
efi_pstore: Add a sequence counter to a variable name
[Issue]
Currently, a variable name, which identifies each entry, consists of type, id and ctime.
But if multiple events happens in a short time, a second/third event may fail to log because
efi_pstore can't distinguish each event with current variable name.
[Solution]
A reasonable way to identify all events precisely is introducing a sequence counter to
the variable name.
The sequence counter has already supported in a pstore layer with "oopscount".
So, this patch adds it to a variable name.
Also, it is passed to read/erase callbacks of platform drivers in accordance with
the modification of the variable name.
<before applying this patch>
a variable name of first event: dump-type0-1-12345678
a variable name of second event: dump-type0-1-12345678
type:0
id:1
ctime:12345678
If multiple events happen in a short time, efi_pstore can't distinguish them because
variable names are same among them.
<after applying this patch>
it can be distinguishable by adding a sequence counter as follows.
a variable name of first event: dump-type0-1-1-12345678
a variable name of Second event: dump-type0-1-2-12345678
type:0
id:1
sequence counter: 1(first event), 2(second event)
ctime:12345678
In case of a write callback executed in pstore_console_write(), "0" is added to
an argument of the write callback because it just logs all kernel messages and
doesn't need to care about multiple events.
Signed-off-by: Seiji Aguchi <seiji.aguchi@hds.com>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Mike Waychison <mikew@google.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2012-11-27 08:07:44 +08:00
|
|
|
static int ramoops_pstore_erase(enum pstore_type_id type, u64 id, int count,
|
efi_pstore: Add ctime to argument of erase callback
[Issue]
Currently, a variable name, which is used to identify each log entry, consists of type,
id and ctime. But an erase callback does not use ctime.
If efi_pstore supported just one log, type and id were enough.
However, in case of supporting multiple logs, it doesn't work because
it can't distinguish each entry without ctime at erasing time.
<Example>
As you can see below, efi_pstore can't differentiate first event from second one without ctime.
a variable name of first event: dump-type0-1-12345678
a variable name of second event: dump-type0-1-23456789
type:0
id:1
ctime:12345678, 23456789
[Solution]
This patch adds ctime to an argument of an erase callback.
It works across reboots because ctime of pstore means the date that the record was originally stored.
To do this, efi_pstore saves the ctime to variable name at writing time and passes it to pstore
at reading time.
Signed-off-by: Seiji Aguchi <seiji.aguchi@hds.com>
Acked-by: Mike Waychison <mikew@google.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2012-11-15 04:27:28 +08:00
|
|
|
struct timespec time, struct pstore_info *psi)
|
2012-05-03 13:45:02 +08:00
|
|
|
{
|
|
|
|
|
struct ramoops_context *cxt = psi->data;
|
2012-05-26 21:20:23 +08:00
|
|
|
struct persistent_ram_zone *prz;
|
2012-05-03 13:45:02 +08:00
|
|
|
|
2012-05-26 21:20:23 +08:00
|
|
|
switch (type) {
|
|
|
|
|
case PSTORE_TYPE_DMESG:
|
|
|
|
|
if (id >= cxt->max_dump_cnt)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
prz = cxt->przs[id];
|
|
|
|
|
break;
|
|
|
|
|
case PSTORE_TYPE_CONSOLE:
|
|
|
|
|
prz = cxt->cprz;
|
|
|
|
|
break;
|
2012-07-10 08:10:44 +08:00
|
|
|
case PSTORE_TYPE_FTRACE:
|
|
|
|
|
prz = cxt->fprz;
|
|
|
|
|
break;
|
2015-01-17 08:01:10 +08:00
|
|
|
case PSTORE_TYPE_PMSG:
|
|
|
|
|
prz = cxt->mprz;
|
|
|
|
|
break;
|
2012-05-26 21:20:23 +08:00
|
|
|
default:
|
2012-05-03 13:45:02 +08:00
|
|
|
return -EINVAL;
|
2012-05-26 21:20:23 +08:00
|
|
|
}
|
2012-05-03 13:45:02 +08:00
|
|
|
|
2012-05-26 21:20:23 +08:00
|
|
|
persistent_ram_free_old(prz);
|
|
|
|
|
persistent_ram_zap(prz);
|
2012-05-03 13:45:02 +08:00
|
|
|
|
|
|
|
|
return 0;
|
2010-05-27 05:43:54 +08:00
|
|
|
}
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
static struct ramoops_context oops_cxt = {
|
|
|
|
|
.pstore = {
|
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
|
.name = "ramoops",
|
|
|
|
|
.open = ramoops_pstore_open,
|
|
|
|
|
.read = ramoops_pstore_read,
|
2012-07-10 08:10:43 +08:00
|
|
|
.write_buf = ramoops_pstore_write_buf,
|
2012-05-03 13:45:02 +08:00
|
|
|
.erase = ramoops_pstore_erase,
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
|
2012-05-26 21:20:21 +08:00
|
|
|
static void ramoops_free_przs(struct ramoops_context *cxt)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2014-03-18 05:07:00 +08:00
|
|
|
cxt->max_dump_cnt = 0;
|
2012-05-26 21:20:21 +08:00
|
|
|
if (!cxt->przs)
|
|
|
|
|
return;
|
|
|
|
|
|
2012-06-19 10:15:51 +08:00
|
|
|
for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++)
|
2012-05-26 21:20:21 +08:00
|
|
|
persistent_ram_free(cxt->przs[i]);
|
|
|
|
|
kfree(cxt->przs);
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-22 07:02:05 +08:00
|
|
|
static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt,
|
|
|
|
|
phys_addr_t *paddr, size_t dump_mem_sz)
|
2012-05-26 21:20:21 +08:00
|
|
|
{
|
|
|
|
|
int err = -ENOMEM;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!cxt->record_size)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-12-12 09:49:24 +08:00
|
|
|
if (*paddr + dump_mem_sz - cxt->phys_addr > cxt->size) {
|
|
|
|
|
dev_err(dev, "no room for dumps\n");
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-26 21:20:21 +08:00
|
|
|
cxt->max_dump_cnt = dump_mem_sz / cxt->record_size;
|
|
|
|
|
if (!cxt->max_dump_cnt)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt,
|
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
if (!cxt->przs) {
|
|
|
|
|
dev_err(dev, "failed to initialize a prz array for dumps\n");
|
2014-03-18 05:07:00 +08:00
|
|
|
goto fail_prz;
|
2012-05-26 21:20:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < cxt->max_dump_cnt; i++) {
|
2015-05-22 00:47:22 +08:00
|
|
|
cxt->przs[i] = persistent_ram_new(*paddr, cxt->record_size, 0,
|
2014-09-17 04:50:01 +08:00
|
|
|
&cxt->ecc_info,
|
|
|
|
|
cxt->memtype);
|
2012-05-26 21:20:21 +08:00
|
|
|
if (IS_ERR(cxt->przs[i])) {
|
|
|
|
|
err = PTR_ERR(cxt->przs[i]);
|
|
|
|
|
dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
|
2015-05-22 00:47:22 +08:00
|
|
|
cxt->record_size, (unsigned long long)*paddr, err);
|
2012-05-26 21:20:21 +08:00
|
|
|
goto fail_prz;
|
|
|
|
|
}
|
2015-05-22 00:47:22 +08:00
|
|
|
*paddr += cxt->record_size;
|
2012-05-26 21:20:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
fail_prz:
|
|
|
|
|
ramoops_free_przs(cxt);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-22 07:02:05 +08:00
|
|
|
static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt,
|
|
|
|
|
struct persistent_ram_zone **prz,
|
|
|
|
|
phys_addr_t *paddr, size_t sz, u32 sig)
|
2012-05-26 21:20:23 +08:00
|
|
|
{
|
|
|
|
|
if (!sz)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-12-12 09:49:24 +08:00
|
|
|
if (*paddr + sz - cxt->phys_addr > cxt->size) {
|
|
|
|
|
dev_err(dev, "no room for mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
|
|
|
|
|
sz, (unsigned long long)*paddr,
|
|
|
|
|
cxt->size, (unsigned long long)cxt->phys_addr);
|
2012-05-26 21:20:23 +08:00
|
|
|
return -ENOMEM;
|
2012-12-12 09:49:24 +08:00
|
|
|
}
|
2012-05-26 21:20:23 +08:00
|
|
|
|
2014-09-17 04:50:01 +08:00
|
|
|
*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info, cxt->memtype);
|
2012-05-26 21:20:23 +08:00
|
|
|
if (IS_ERR(*prz)) {
|
|
|
|
|
int err = PTR_ERR(*prz);
|
|
|
|
|
|
|
|
|
|
dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
|
|
|
|
|
sz, (unsigned long long)*paddr, err);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
persistent_ram_zap(*prz);
|
|
|
|
|
|
|
|
|
|
*paddr += sz;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-22 07:02:05 +08:00
|
|
|
static int ramoops_probe(struct platform_device *pdev)
|
2010-05-27 05:43:54 +08:00
|
|
|
{
|
2012-05-17 15:15:18 +08:00
|
|
|
struct device *dev = &pdev->dev;
|
2010-10-28 06:34:52 +08:00
|
|
|
struct ramoops_platform_data *pdata = pdev->dev.platform_data;
|
2010-05-27 05:43:54 +08:00
|
|
|
struct ramoops_context *cxt = &oops_cxt;
|
2012-05-26 21:20:21 +08:00
|
|
|
size_t dump_mem_sz;
|
|
|
|
|
phys_addr_t paddr;
|
2010-05-27 05:43:54 +08:00
|
|
|
int err = -EINVAL;
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
/* Only a single ramoops area allowed at a time, so fail extra
|
|
|
|
|
* probes.
|
|
|
|
|
*/
|
2012-05-26 21:20:20 +08:00
|
|
|
if (cxt->max_dump_cnt)
|
2012-05-03 13:45:02 +08:00
|
|
|
goto fail_out;
|
|
|
|
|
|
2012-07-10 08:10:44 +08:00
|
|
|
if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
|
2015-01-17 08:01:10 +08:00
|
|
|
!pdata->ftrace_size && !pdata->pmsg_size)) {
|
2012-05-26 21:20:23 +08:00
|
|
|
pr_err("The memory size and the record/console size must be "
|
2011-07-27 07:08:59 +08:00
|
|
|
"non-zero\n");
|
2012-05-03 13:45:02 +08:00
|
|
|
goto fail_out;
|
2010-05-27 05:43:54 +08:00
|
|
|
}
|
|
|
|
|
|
2013-08-31 00:06:41 +08:00
|
|
|
if (pdata->record_size && !is_power_of_2(pdata->record_size))
|
2012-10-22 17:19:28 +08:00
|
|
|
pdata->record_size = rounddown_pow_of_two(pdata->record_size);
|
2013-08-31 00:06:41 +08:00
|
|
|
if (pdata->console_size && !is_power_of_2(pdata->console_size))
|
2012-10-22 17:19:28 +08:00
|
|
|
pdata->console_size = rounddown_pow_of_two(pdata->console_size);
|
2013-08-31 00:06:41 +08:00
|
|
|
if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
|
2012-10-22 17:19:28 +08:00
|
|
|
pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
|
2015-01-17 08:01:10 +08:00
|
|
|
if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
|
|
|
|
|
pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2011-07-27 07:08:57 +08:00
|
|
|
cxt->size = pdata->mem_size;
|
|
|
|
|
cxt->phys_addr = pdata->mem_address;
|
2014-09-17 04:50:01 +08:00
|
|
|
cxt->memtype = pdata->mem_type;
|
2011-07-27 07:08:59 +08:00
|
|
|
cxt->record_size = pdata->record_size;
|
2012-05-26 21:20:23 +08:00
|
|
|
cxt->console_size = pdata->console_size;
|
2012-07-10 08:10:44 +08:00
|
|
|
cxt->ftrace_size = pdata->ftrace_size;
|
2015-01-17 08:01:10 +08:00
|
|
|
cxt->pmsg_size = pdata->pmsg_size;
|
2011-07-27 07:08:58 +08:00
|
|
|
cxt->dump_oops = pdata->dump_oops;
|
2012-05-23 07:33:23 +08:00
|
|
|
cxt->ecc_info = pdata->ecc_info;
|
2010-05-27 05:43:54 +08:00
|
|
|
|
2012-05-26 21:20:21 +08:00
|
|
|
paddr = cxt->phys_addr;
|
2012-05-17 15:15:18 +08:00
|
|
|
|
2015-01-17 08:01:10 +08:00
|
|
|
dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size
|
|
|
|
|
- cxt->pmsg_size;
|
2012-05-26 21:20:21 +08:00
|
|
|
err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz);
|
2012-05-26 21:20:23 +08:00
|
|
|
if (err)
|
|
|
|
|
goto fail_out;
|
|
|
|
|
|
pstore/ram: Make tracing log versioned
Decoding the binary trace w/ a different kernel might be troublesome
since we convert addresses to symbols. For kernels with minimal changes,
the mappings would probably match, but it's not guaranteed at all.
(But still we could convert the addresses by hand, since we do print
raw addresses.)
If we use modules, the symbols could be loaded at different addresses
from the previously booted kernel, and so this would also fail, but
there's nothing we can do about it.
Also, the binary data format that pstore/ram is using in its ringbuffer
may change between the kernels, so here we too must ensure that we're
running the same kernel.
So, there are two questions really:
1. How to compute the unique kernel tag;
2. Where to store it.
In this patch we're using LINUX_VERSION_CODE, just as hibernation
(suspend-to-disk) does. This way we are protecting from the kernel
version mismatch, making sure that we're running the same kernel
version and patch level. We could use CRC of a symbol table (as
suggested by Tony Luck), but for now let's not be that strict.
And as for storing, we are using a small trick here. Instead of
allocating a dedicated buffer for the tag (i.e. another prz), or
hacking ram_core routines to "reserve" some control data in the
buffer, we are just encoding the tag into the buffer signature
(and XOR'ing it with the actual signature value, so that buffers
not needing a tag can just pass zero, which will result into the
plain old PRZ signature).
Suggested-by: Steven Rostedt <rostedt@goodmis.org>
Suggested-by: Tony Luck <tony.luck@intel.com>
Suggested-by: Colin Cross <ccross@android.com>
Signed-off-by: Anton Vorontsov <anton.vorontsov@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-18 03:11:12 +08:00
|
|
|
err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr,
|
|
|
|
|
cxt->console_size, 0);
|
2012-05-26 21:20:23 +08:00
|
|
|
if (err)
|
|
|
|
|
goto fail_init_cprz;
|
|
|
|
|
|
pstore/ram: Make tracing log versioned
Decoding the binary trace w/ a different kernel might be troublesome
since we convert addresses to symbols. For kernels with minimal changes,
the mappings would probably match, but it's not guaranteed at all.
(But still we could convert the addresses by hand, since we do print
raw addresses.)
If we use modules, the symbols could be loaded at different addresses
from the previously booted kernel, and so this would also fail, but
there's nothing we can do about it.
Also, the binary data format that pstore/ram is using in its ringbuffer
may change between the kernels, so here we too must ensure that we're
running the same kernel.
So, there are two questions really:
1. How to compute the unique kernel tag;
2. Where to store it.
In this patch we're using LINUX_VERSION_CODE, just as hibernation
(suspend-to-disk) does. This way we are protecting from the kernel
version mismatch, making sure that we're running the same kernel
version and patch level. We could use CRC of a symbol table (as
suggested by Tony Luck), but for now let's not be that strict.
And as for storing, we are using a small trick here. Instead of
allocating a dedicated buffer for the tag (i.e. another prz), or
hacking ram_core routines to "reserve" some control data in the
buffer, we are just encoding the tag into the buffer signature
(and XOR'ing it with the actual signature value, so that buffers
not needing a tag can just pass zero, which will result into the
plain old PRZ signature).
Suggested-by: Steven Rostedt <rostedt@goodmis.org>
Suggested-by: Tony Luck <tony.luck@intel.com>
Suggested-by: Colin Cross <ccross@android.com>
Signed-off-by: Anton Vorontsov <anton.vorontsov@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-07-18 03:11:12 +08:00
|
|
|
err = ramoops_init_prz(dev, cxt, &cxt->fprz, &paddr, cxt->ftrace_size,
|
|
|
|
|
LINUX_VERSION_CODE);
|
2012-07-10 08:10:44 +08:00
|
|
|
if (err)
|
|
|
|
|
goto fail_init_fprz;
|
|
|
|
|
|
2015-01-17 08:01:10 +08:00
|
|
|
err = ramoops_init_prz(dev, cxt, &cxt->mprz, &paddr, cxt->pmsg_size, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
goto fail_init_mprz;
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
cxt->pstore.data = cxt;
|
2012-05-26 21:20:23 +08:00
|
|
|
/*
|
pstore/ram: Fix possible NULL dereference
We can dereference 'cxt->cprz' if console and dump logging are disabled
(which is unlikely, but still possible to do). This patch fixes the issue
by changing the code so that we don't dereference przs at all, we can
just calculate bufsize from console_size and record_size values.
Plus, while at it, the patch improves the buffer size calculation.
After Kay's printk rework, we know the optimal buffer size for console
logging -- it is LOG_LINE_MAX (defined privately in printk.c). Previously,
if only console logging was enabled, we would allocate unnecessary large
buffer in pstore, while we only need LOG_LINE_MAX. (Pstore console logging
is still capable of handling buffers > LOG_LINE_MAX, it will just do
multiple calls to psinfo->write).
Note that I don't export the constant, since we will do even a better
thing soon: we will switch console logging to a new write_buf API, which
will eliminate the need for the additional buffer; and so we won't need
the constant.
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Anton Vorontsov <anton.vorontsov@linaro.org>
Acked-by: Kees Cook <keescook@chromium.org>
2012-07-20 06:47:11 +08:00
|
|
|
* Console can handle any buffer size, so prefer LOG_LINE_MAX. If we
|
|
|
|
|
* have to handle dumps, we must have at least record_size buffer. And
|
|
|
|
|
* for ftrace, bufsize is irrelevant (if bufsize is 0, buf will be
|
|
|
|
|
* ZERO_SIZE_PTR).
|
2012-05-26 21:20:23 +08:00
|
|
|
*/
|
pstore/ram: Fix possible NULL dereference
We can dereference 'cxt->cprz' if console and dump logging are disabled
(which is unlikely, but still possible to do). This patch fixes the issue
by changing the code so that we don't dereference przs at all, we can
just calculate bufsize from console_size and record_size values.
Plus, while at it, the patch improves the buffer size calculation.
After Kay's printk rework, we know the optimal buffer size for console
logging -- it is LOG_LINE_MAX (defined privately in printk.c). Previously,
if only console logging was enabled, we would allocate unnecessary large
buffer in pstore, while we only need LOG_LINE_MAX. (Pstore console logging
is still capable of handling buffers > LOG_LINE_MAX, it will just do
multiple calls to psinfo->write).
Note that I don't export the constant, since we will do even a better
thing soon: we will switch console logging to a new write_buf API, which
will eliminate the need for the additional buffer; and so we won't need
the constant.
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Anton Vorontsov <anton.vorontsov@linaro.org>
Acked-by: Kees Cook <keescook@chromium.org>
2012-07-20 06:47:11 +08:00
|
|
|
if (cxt->console_size)
|
|
|
|
|
cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */
|
|
|
|
|
cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize);
|
2012-05-03 13:45:02 +08:00
|
|
|
cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
|
|
|
|
|
spin_lock_init(&cxt->pstore.buf_lock);
|
|
|
|
|
if (!cxt->pstore.buf) {
|
|
|
|
|
pr_err("cannot allocate pstore buffer\n");
|
2013-05-07 19:39:20 +08:00
|
|
|
err = -ENOMEM;
|
2012-05-03 13:45:02 +08:00
|
|
|
goto fail_clear;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = pstore_register(&cxt->pstore);
|
2010-05-27 05:43:54 +08:00
|
|
|
if (err) {
|
2012-05-03 13:45:02 +08:00
|
|
|
pr_err("registering with pstore failed\n");
|
2012-05-17 15:15:18 +08:00
|
|
|
goto fail_buf;
|
2010-05-27 05:43:54 +08:00
|
|
|
}
|
|
|
|
|
|
2012-01-13 09:20:59 +08:00
|
|
|
/*
|
|
|
|
|
* Update the module parameter variables as well so they are visible
|
|
|
|
|
* through /sys/module/ramoops/parameters/
|
|
|
|
|
*/
|
|
|
|
|
mem_size = pdata->mem_size;
|
|
|
|
|
mem_address = pdata->mem_address;
|
|
|
|
|
record_size = pdata->record_size;
|
|
|
|
|
dump_oops = pdata->dump_oops;
|
2015-03-09 15:39:07 +08:00
|
|
|
ramoops_console_size = pdata->console_size;
|
|
|
|
|
ramoops_pmsg_size = pdata->pmsg_size;
|
|
|
|
|
ramoops_ftrace_size = pdata->ftrace_size;
|
2012-01-13 09:20:59 +08:00
|
|
|
|
2012-05-23 07:33:23 +08:00
|
|
|
pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n",
|
2012-05-03 13:45:03 +08:00
|
|
|
cxt->size, (unsigned long long)cxt->phys_addr,
|
2012-05-23 07:33:23 +08:00
|
|
|
cxt->ecc_info.ecc_size, cxt->ecc_info.block_size);
|
2012-05-03 13:45:02 +08:00
|
|
|
|
2010-05-27 05:43:54 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2012-05-03 13:45:02 +08:00
|
|
|
fail_buf:
|
|
|
|
|
kfree(cxt->pstore.buf);
|
|
|
|
|
fail_clear:
|
|
|
|
|
cxt->pstore.bufsize = 0;
|
2015-01-17 08:01:10 +08:00
|
|
|
kfree(cxt->mprz);
|
|
|
|
|
fail_init_mprz:
|
2012-07-10 08:10:44 +08:00
|
|
|
kfree(cxt->fprz);
|
|
|
|
|
fail_init_fprz:
|
2012-05-26 21:20:23 +08:00
|
|
|
kfree(cxt->cprz);
|
|
|
|
|
fail_init_cprz:
|
2012-05-26 21:20:21 +08:00
|
|
|
ramoops_free_przs(cxt);
|
2012-05-03 13:45:02 +08:00
|
|
|
fail_out:
|
2010-05-27 05:43:54 +08:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-28 06:34:52 +08:00
|
|
|
static int __exit ramoops_remove(struct platform_device *pdev)
|
2010-05-27 05:43:54 +08:00
|
|
|
{
|
2012-05-03 13:45:02 +08:00
|
|
|
#if 0
|
|
|
|
|
/* TODO(kees): We cannot unload ramoops since pstore doesn't support
|
|
|
|
|
* unregistering yet.
|
|
|
|
|
*/
|
2010-05-27 05:43:54 +08:00
|
|
|
struct ramoops_context *cxt = &oops_cxt;
|
|
|
|
|
|
|
|
|
|
iounmap(cxt->virt_addr);
|
|
|
|
|
release_mem_region(cxt->phys_addr, cxt->size);
|
2012-05-26 21:20:20 +08:00
|
|
|
cxt->max_dump_cnt = 0;
|
2012-05-03 13:45:02 +08:00
|
|
|
|
|
|
|
|
/* TODO(kees): When pstore supports unregistering, call it here. */
|
|
|
|
|
kfree(cxt->pstore.buf);
|
|
|
|
|
cxt->pstore.bufsize = 0;
|
|
|
|
|
|
2010-10-28 06:34:52 +08:00
|
|
|
return 0;
|
2012-05-03 13:45:02 +08:00
|
|
|
#endif
|
|
|
|
|
return -EBUSY;
|
2010-05-27 05:43:54 +08:00
|
|
|
}
|
|
|
|
|
|
2010-10-28 06:34:52 +08:00
|
|
|
static struct platform_driver ramoops_driver = {
|
2012-06-19 10:15:50 +08:00
|
|
|
.probe = ramoops_probe,
|
2010-10-28 06:34:52 +08:00
|
|
|
.remove = __exit_p(ramoops_remove),
|
|
|
|
|
.driver = {
|
|
|
|
|
.name = "ramoops",
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
|
2012-06-19 10:15:50 +08:00
|
|
|
static void ramoops_register_dummy(void)
|
2010-10-28 06:34:52 +08:00
|
|
|
{
|
2012-06-19 10:15:50 +08:00
|
|
|
if (!mem_size)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
pr_info("using module parameters\n");
|
|
|
|
|
|
|
|
|
|
dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL);
|
|
|
|
|
if (!dummy_data) {
|
|
|
|
|
pr_info("could not allocate pdata\n");
|
|
|
|
|
return;
|
2011-07-27 07:08:57 +08:00
|
|
|
}
|
|
|
|
|
|
2012-06-19 10:15:50 +08:00
|
|
|
dummy_data->mem_size = mem_size;
|
|
|
|
|
dummy_data->mem_address = mem_address;
|
2014-09-17 04:50:01 +08:00
|
|
|
dummy_data->mem_type = 0;
|
2012-06-19 10:15:50 +08:00
|
|
|
dummy_data->record_size = record_size;
|
|
|
|
|
dummy_data->console_size = ramoops_console_size;
|
2012-07-10 08:10:44 +08:00
|
|
|
dummy_data->ftrace_size = ramoops_ftrace_size;
|
2015-01-17 08:01:10 +08:00
|
|
|
dummy_data->pmsg_size = ramoops_pmsg_size;
|
2012-06-19 10:15:50 +08:00
|
|
|
dummy_data->dump_oops = dump_oops;
|
2012-07-10 08:03:19 +08:00
|
|
|
/*
|
|
|
|
|
* For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
|
|
|
|
|
* (using 1 byte for ECC isn't much of use anyway).
|
|
|
|
|
*/
|
2012-05-23 07:33:23 +08:00
|
|
|
dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
|
2012-06-19 10:15:50 +08:00
|
|
|
|
|
|
|
|
dummy = platform_device_register_data(NULL, "ramoops", -1,
|
|
|
|
|
dummy_data, sizeof(struct ramoops_platform_data));
|
|
|
|
|
if (IS_ERR(dummy)) {
|
|
|
|
|
pr_info("could not create platform device: %ld\n",
|
|
|
|
|
PTR_ERR(dummy));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init ramoops_init(void)
|
|
|
|
|
{
|
|
|
|
|
ramoops_register_dummy();
|
|
|
|
|
return platform_driver_register(&ramoops_driver);
|
2010-10-28 06:34:52 +08:00
|
|
|
}
|
2012-06-19 10:15:50 +08:00
|
|
|
postcore_initcall(ramoops_init);
|
2010-10-28 06:34:52 +08:00
|
|
|
|
|
|
|
|
static void __exit ramoops_exit(void)
|
|
|
|
|
{
|
|
|
|
|
platform_driver_unregister(&ramoops_driver);
|
2012-08-20 14:58:26 +08:00
|
|
|
platform_device_unregister(dummy);
|
2011-07-27 07:08:57 +08:00
|
|
|
kfree(dummy_data);
|
2010-10-28 06:34:52 +08:00
|
|
|
}
|
2010-05-27 05:43:54 +08:00
|
|
|
module_exit(ramoops_exit);
|
|
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
|
|
|
|
|
MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");
|