2 * RAM Oops/Panic logger
4 * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
5 * Copyright (C) 2011 Kees Cook <keescook@chromium.org>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/kernel.h>
26 #include <linux/err.h>
27 #include <linux/module.h>
28 #include <linux/version.h>
29 #include <linux/pstore.h>
31 #include <linux/ioport.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
34 #include <linux/compiler.h>
35 #include <linux/pstore_ram.h>
37 #include <linux/of_address.h>
39 #define RAMOOPS_KERNMSG_HDR "===="
40 #define MIN_MEM_SIZE 4096UL
42 static ulong record_size
= MIN_MEM_SIZE
;
43 module_param(record_size
, ulong
, 0400);
44 MODULE_PARM_DESC(record_size
,
45 "size of each dump done on oops/panic");
47 static ulong ramoops_console_size
= MIN_MEM_SIZE
;
48 module_param_named(console_size
, ramoops_console_size
, ulong
, 0400);
49 MODULE_PARM_DESC(console_size
, "size of kernel console log");
51 static ulong ramoops_ftrace_size
= MIN_MEM_SIZE
;
52 module_param_named(ftrace_size
, ramoops_ftrace_size
, ulong
, 0400);
53 MODULE_PARM_DESC(ftrace_size
, "size of ftrace log");
55 static ulong ramoops_pmsg_size
= MIN_MEM_SIZE
;
56 module_param_named(pmsg_size
, ramoops_pmsg_size
, ulong
, 0400);
57 MODULE_PARM_DESC(pmsg_size
, "size of user space message log");
59 static unsigned long long mem_address
;
60 module_param_hw(mem_address
, ullong
, other
, 0400);
61 MODULE_PARM_DESC(mem_address
,
62 "start of reserved RAM used to store oops/panic logs");
64 static ulong mem_size
;
65 module_param(mem_size
, ulong
, 0400);
66 MODULE_PARM_DESC(mem_size
,
67 "size of reserved RAM used to store oops/panic logs");
69 static unsigned int mem_type
;
70 module_param(mem_type
, uint
, 0600);
71 MODULE_PARM_DESC(mem_type
,
72 "set to 1 to try to use unbuffered memory (default 0)");
74 static int dump_oops
= 1;
75 module_param(dump_oops
, int, 0600);
76 MODULE_PARM_DESC(dump_oops
,
77 "set to 1 to dump oopses, 0 to only dump panics (default 1)");
79 static int ramoops_ecc
;
80 module_param_named(ecc
, ramoops_ecc
, int, 0600);
81 MODULE_PARM_DESC(ramoops_ecc
,
82 "if non-zero, the option enables ECC support and specifies "
83 "ECC buffer size in bytes (1 is a special value, means 16 "
86 struct ramoops_context
{
87 struct persistent_ram_zone
**dprzs
; /* Oops dump zones */
88 struct persistent_ram_zone
*cprz
; /* Console zone */
89 struct persistent_ram_zone
**fprzs
; /* Ftrace zones */
90 struct persistent_ram_zone
*mprz
; /* PMSG zone */
91 phys_addr_t phys_addr
;
100 struct persistent_ram_ecc_info ecc_info
;
101 unsigned int max_dump_cnt
;
102 unsigned int dump_write_cnt
;
103 /* _read_cnt need clear on ramoops_pstore_open */
104 unsigned int dump_read_cnt
;
105 unsigned int console_read_cnt
;
106 unsigned int max_ftrace_cnt
;
107 unsigned int ftrace_read_cnt
;
108 unsigned int pmsg_read_cnt
;
109 struct pstore_info pstore
;
112 static struct platform_device
*dummy
;
113 static struct ramoops_platform_data
*dummy_data
;
115 static int ramoops_pstore_open(struct pstore_info
*psi
)
117 struct ramoops_context
*cxt
= psi
->data
;
119 cxt
->dump_read_cnt
= 0;
120 cxt
->console_read_cnt
= 0;
121 cxt
->ftrace_read_cnt
= 0;
122 cxt
->pmsg_read_cnt
= 0;
126 static struct persistent_ram_zone
*
127 ramoops_get_next_prz(struct persistent_ram_zone
*przs
[], uint
*c
, uint max
,
129 enum pstore_type_id
*typep
, enum pstore_type_id type
,
132 struct persistent_ram_zone
*prz
;
135 /* Give up if we never existed or have hit the end. */
136 if (!przs
|| i
>= max
)
143 /* Update old/shadowed buffer. */
145 persistent_ram_save_old(prz
);
147 if (!persistent_ram_old_size(prz
))
156 static int ramoops_read_kmsg_hdr(char *buffer
, struct timespec
*time
,
160 int header_length
= 0;
162 if (sscanf(buffer
, RAMOOPS_KERNMSG_HDR
"%lu.%lu-%c\n%n", &time
->tv_sec
,
163 &time
->tv_nsec
, &data_type
, &header_length
) == 3) {
164 time
->tv_nsec
*= 1000;
165 if (data_type
== 'C')
169 } else if (sscanf(buffer
, RAMOOPS_KERNMSG_HDR
"%lu.%lu\n%n",
170 &time
->tv_sec
, &time
->tv_nsec
, &header_length
) == 2) {
171 time
->tv_nsec
*= 1000;
178 return header_length
;
181 static bool prz_ok(struct persistent_ram_zone
*prz
)
183 return !!prz
&& !!(persistent_ram_old_size(prz
) +
184 persistent_ram_ecc_string(prz
, NULL
, 0));
187 static ssize_t
ftrace_log_combine(struct persistent_ram_zone
*dest
,
188 struct persistent_ram_zone
*src
)
190 size_t dest_size
, src_size
, total
, dest_off
, src_off
;
191 size_t dest_idx
= 0, src_idx
= 0, merged_idx
= 0;
193 struct pstore_ftrace_record
*drec
, *srec
, *mrec
;
194 size_t record_size
= sizeof(struct pstore_ftrace_record
);
196 dest_off
= dest
->old_log_size
% record_size
;
197 dest_size
= dest
->old_log_size
- dest_off
;
199 src_off
= src
->old_log_size
% record_size
;
200 src_size
= src
->old_log_size
- src_off
;
202 total
= dest_size
+ src_size
;
203 merged_buf
= kmalloc(total
, GFP_KERNEL
);
207 drec
= (struct pstore_ftrace_record
*)(dest
->old_log
+ dest_off
);
208 srec
= (struct pstore_ftrace_record
*)(src
->old_log
+ src_off
);
209 mrec
= (struct pstore_ftrace_record
*)(merged_buf
);
211 while (dest_size
> 0 && src_size
> 0) {
212 if (pstore_ftrace_read_timestamp(&drec
[dest_idx
]) <
213 pstore_ftrace_read_timestamp(&srec
[src_idx
])) {
214 mrec
[merged_idx
++] = drec
[dest_idx
++];
215 dest_size
-= record_size
;
217 mrec
[merged_idx
++] = srec
[src_idx
++];
218 src_size
-= record_size
;
222 while (dest_size
> 0) {
223 mrec
[merged_idx
++] = drec
[dest_idx
++];
224 dest_size
-= record_size
;
227 while (src_size
> 0) {
228 mrec
[merged_idx
++] = srec
[src_idx
++];
229 src_size
-= record_size
;
232 kfree(dest
->old_log
);
233 dest
->old_log
= merged_buf
;
234 dest
->old_log_size
= total
;
239 static ssize_t
ramoops_pstore_read(struct pstore_record
*record
)
242 struct ramoops_context
*cxt
= record
->psi
->data
;
243 struct persistent_ram_zone
*prz
= NULL
;
244 int header_length
= 0;
245 bool free_prz
= false;
248 * Ramoops headers provide time stamps for PSTORE_TYPE_DMESG, but
249 * PSTORE_TYPE_CONSOLE and PSTORE_TYPE_FTRACE don't currently have
250 * valid time stamps, so it is initialized to zero.
252 record
->time
.tv_sec
= 0;
253 record
->time
.tv_nsec
= 0;
254 record
->compressed
= false;
256 /* Find the next valid persistent_ram_zone for DMESG */
257 while (cxt
->dump_read_cnt
< cxt
->max_dump_cnt
&& !prz
) {
258 prz
= ramoops_get_next_prz(cxt
->dprzs
, &cxt
->dump_read_cnt
,
259 cxt
->max_dump_cnt
, &record
->id
,
261 PSTORE_TYPE_DMESG
, 1);
264 header_length
= ramoops_read_kmsg_hdr(persistent_ram_old(prz
),
266 &record
->compressed
);
267 /* Clear and skip this DMESG record if it has no valid header */
268 if (!header_length
) {
269 persistent_ram_free_old(prz
);
270 persistent_ram_zap(prz
);
276 prz
= ramoops_get_next_prz(&cxt
->cprz
, &cxt
->console_read_cnt
,
277 1, &record
->id
, &record
->type
,
278 PSTORE_TYPE_CONSOLE
, 0);
281 prz
= ramoops_get_next_prz(&cxt
->mprz
, &cxt
->pmsg_read_cnt
,
282 1, &record
->id
, &record
->type
,
283 PSTORE_TYPE_PMSG
, 0);
285 /* ftrace is last since it may want to dynamically allocate memory. */
287 if (!(cxt
->flags
& RAMOOPS_FLAG_FTRACE_PER_CPU
)) {
288 prz
= ramoops_get_next_prz(cxt
->fprzs
,
289 &cxt
->ftrace_read_cnt
, 1, &record
->id
,
290 &record
->type
, PSTORE_TYPE_FTRACE
, 0);
293 * Build a new dummy record which combines all the
294 * per-cpu records including metadata and ecc info.
296 struct persistent_ram_zone
*tmp_prz
, *prz_next
;
298 tmp_prz
= kzalloc(sizeof(struct persistent_ram_zone
),
305 while (cxt
->ftrace_read_cnt
< cxt
->max_ftrace_cnt
) {
306 prz_next
= ramoops_get_next_prz(cxt
->fprzs
,
307 &cxt
->ftrace_read_cnt
,
311 PSTORE_TYPE_FTRACE
, 0);
313 if (!prz_ok(prz_next
))
316 tmp_prz
->ecc_info
= prz_next
->ecc_info
;
317 tmp_prz
->corrected_bytes
+=
318 prz_next
->corrected_bytes
;
319 tmp_prz
->bad_blocks
+= prz_next
->bad_blocks
;
320 size
= ftrace_log_combine(tmp_prz
, prz_next
);
333 size
= persistent_ram_old_size(prz
) - header_length
;
335 /* ECC correction notice */
336 record
->ecc_notice_size
= persistent_ram_ecc_string(prz
, NULL
, 0);
338 record
->buf
= kmalloc(size
+ record
->ecc_notice_size
+ 1, GFP_KERNEL
);
339 if (record
->buf
== NULL
) {
344 memcpy(record
->buf
, (char *)persistent_ram_old(prz
) + header_length
,
347 persistent_ram_ecc_string(prz
, record
->buf
+ size
,
348 record
->ecc_notice_size
+ 1);
359 static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone
*prz
,
360 struct pstore_record
*record
)
365 hdr
= kasprintf(GFP_ATOMIC
, RAMOOPS_KERNMSG_HDR
"%lu.%lu-%c\n",
367 record
->time
.tv_nsec
/ 1000,
368 record
->compressed
? 'C' : 'D');
370 len
= hdr
? strlen(hdr
) : 0;
371 persistent_ram_write(prz
, hdr
, len
);
377 static int notrace
ramoops_pstore_write(struct pstore_record
*record
)
379 struct ramoops_context
*cxt
= record
->psi
->data
;
380 struct persistent_ram_zone
*prz
;
383 if (record
->type
== PSTORE_TYPE_CONSOLE
) {
386 persistent_ram_write(cxt
->cprz
, record
->buf
, record
->size
);
388 } else if (record
->type
== PSTORE_TYPE_FTRACE
) {
394 * Choose zone by if we're using per-cpu buffers.
396 if (cxt
->flags
& RAMOOPS_FLAG_FTRACE_PER_CPU
)
397 zonenum
= smp_processor_id();
401 persistent_ram_write(cxt
->fprzs
[zonenum
], record
->buf
,
404 } else if (record
->type
== PSTORE_TYPE_PMSG
) {
405 pr_warn_ratelimited("PMSG shouldn't call %s\n", __func__
);
409 if (record
->type
!= PSTORE_TYPE_DMESG
)
413 * Out of the various dmesg dump types, ramoops is currently designed
414 * to only store crash logs, rather than storing general kernel logs.
416 if (record
->reason
!= KMSG_DUMP_OOPS
&&
417 record
->reason
!= KMSG_DUMP_PANIC
)
420 /* Skip Oopes when configured to do so. */
421 if (record
->reason
== KMSG_DUMP_OOPS
&& !cxt
->dump_oops
)
425 * Explicitly only take the first part of any new crash.
426 * If our buffer is larger than kmsg_bytes, this can never happen,
427 * and if our buffer is smaller than kmsg_bytes, we don't want the
428 * report split across multiple records.
430 if (record
->part
!= 1)
436 prz
= cxt
->dprzs
[cxt
->dump_write_cnt
];
439 * Since this is a new crash dump, we need to reset the buffer in
440 * case it still has an old dump present. Without this, the new dump
441 * will get appended, which would seriously confuse anything trying
442 * to check dump file contents. Specifically, ramoops_read_kmsg_hdr()
443 * expects to find a dump header in the beginning of buffer data, so
444 * we must to reset the buffer values, in order to ensure that the
445 * header will be written to the beginning of the buffer.
447 persistent_ram_zap(prz
);
449 /* Build header and append record contents. */
450 hlen
= ramoops_write_kmsg_hdr(prz
, record
);
452 if (size
+ hlen
> prz
->buffer_size
)
453 size
= prz
->buffer_size
- hlen
;
454 persistent_ram_write(prz
, record
->buf
, size
);
456 cxt
->dump_write_cnt
= (cxt
->dump_write_cnt
+ 1) % cxt
->max_dump_cnt
;
461 static int notrace
ramoops_pstore_write_user(struct pstore_record
*record
,
462 const char __user
*buf
)
464 if (record
->type
== PSTORE_TYPE_PMSG
) {
465 struct ramoops_context
*cxt
= record
->psi
->data
;
469 return persistent_ram_write_user(cxt
->mprz
, buf
, record
->size
);
475 static int ramoops_pstore_erase(struct pstore_record
*record
)
477 struct ramoops_context
*cxt
= record
->psi
->data
;
478 struct persistent_ram_zone
*prz
;
480 switch (record
->type
) {
481 case PSTORE_TYPE_DMESG
:
482 if (record
->id
>= cxt
->max_dump_cnt
)
484 prz
= cxt
->dprzs
[record
->id
];
486 case PSTORE_TYPE_CONSOLE
:
489 case PSTORE_TYPE_FTRACE
:
490 if (record
->id
>= cxt
->max_ftrace_cnt
)
492 prz
= cxt
->fprzs
[record
->id
];
494 case PSTORE_TYPE_PMSG
:
501 persistent_ram_free_old(prz
);
502 persistent_ram_zap(prz
);
507 static struct ramoops_context oops_cxt
= {
509 .owner
= THIS_MODULE
,
511 .open
= ramoops_pstore_open
,
512 .read
= ramoops_pstore_read
,
513 .write
= ramoops_pstore_write
,
514 .write_user
= ramoops_pstore_write_user
,
515 .erase
= ramoops_pstore_erase
,
519 static void ramoops_free_przs(struct ramoops_context
*cxt
)
525 for (i
= 0; i
< cxt
->max_dump_cnt
; i
++)
526 persistent_ram_free(cxt
->dprzs
[i
]);
529 cxt
->max_dump_cnt
= 0;
532 /* Free ftrace PRZs */
534 for (i
= 0; i
< cxt
->max_ftrace_cnt
; i
++)
535 persistent_ram_free(cxt
->fprzs
[i
]);
537 cxt
->max_ftrace_cnt
= 0;
541 static int ramoops_init_przs(const char *name
,
542 struct device
*dev
, struct ramoops_context
*cxt
,
543 struct persistent_ram_zone
***przs
,
544 phys_addr_t
*paddr
, size_t mem_sz
,
546 unsigned int *cnt
, u32 sig
, u32 flags
)
551 struct persistent_ram_zone
**prz_ar
;
553 /* Allocate nothing for 0 mem_sz or 0 record_size. */
554 if (mem_sz
== 0 || record_size
== 0) {
560 * If we have a negative record size, calculate it based on
561 * mem_sz / *cnt. If we have a positive record size, calculate
562 * cnt from mem_sz / record_size.
564 if (record_size
< 0) {
567 record_size
= mem_sz
/ *cnt
;
568 if (record_size
== 0) {
569 dev_err(dev
, "%s record size == 0 (%zu / %u)\n",
574 *cnt
= mem_sz
/ record_size
;
576 dev_err(dev
, "%s record count == 0 (%zu / %zu)\n",
577 name
, mem_sz
, record_size
);
582 if (*paddr
+ mem_sz
- cxt
->phys_addr
> cxt
->size
) {
583 dev_err(dev
, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
585 mem_sz
, (unsigned long long)*paddr
,
586 cxt
->size
, (unsigned long long)cxt
->phys_addr
);
590 zone_sz
= mem_sz
/ *cnt
;
592 dev_err(dev
, "%s zone size == 0\n", name
);
596 prz_ar
= kcalloc(*cnt
, sizeof(**przs
), GFP_KERNEL
);
600 for (i
= 0; i
< *cnt
; i
++) {
601 prz_ar
[i
] = persistent_ram_new(*paddr
, zone_sz
, sig
,
603 cxt
->memtype
, flags
);
604 if (IS_ERR(prz_ar
[i
])) {
605 err
= PTR_ERR(prz_ar
[i
]);
606 dev_err(dev
, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
608 (unsigned long long)*paddr
, err
);
612 persistent_ram_free(prz_ar
[i
]);
628 static int ramoops_init_prz(const char *name
,
629 struct device
*dev
, struct ramoops_context
*cxt
,
630 struct persistent_ram_zone
**prz
,
631 phys_addr_t
*paddr
, size_t sz
, u32 sig
)
636 if (*paddr
+ sz
- cxt
->phys_addr
> cxt
->size
) {
637 dev_err(dev
, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
638 name
, sz
, (unsigned long long)*paddr
,
639 cxt
->size
, (unsigned long long)cxt
->phys_addr
);
643 *prz
= persistent_ram_new(*paddr
, sz
, sig
, &cxt
->ecc_info
,
646 int err
= PTR_ERR(*prz
);
648 dev_err(dev
, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
649 name
, sz
, (unsigned long long)*paddr
, err
);
653 persistent_ram_zap(*prz
);
660 static int ramoops_parse_dt_size(struct platform_device
*pdev
,
661 const char *propname
, u32
*value
)
666 ret
= of_property_read_u32(pdev
->dev
.of_node
, propname
, &val32
);
667 if (ret
< 0 && ret
!= -EINVAL
) {
668 dev_err(&pdev
->dev
, "failed to parse property %s: %d\n",
673 if (val32
> INT_MAX
) {
674 dev_err(&pdev
->dev
, "%s %u > INT_MAX\n", propname
, val32
);
682 static int ramoops_parse_dt(struct platform_device
*pdev
,
683 struct ramoops_platform_data
*pdata
)
685 struct device_node
*of_node
= pdev
->dev
.of_node
;
686 struct resource
*res
;
690 dev_dbg(&pdev
->dev
, "using Device Tree\n");
692 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
695 "failed to locate DT /reserved-memory resource\n");
699 pdata
->mem_size
= resource_size(res
);
700 pdata
->mem_address
= res
->start
;
701 pdata
->mem_type
= of_property_read_bool(of_node
, "unbuffered");
702 pdata
->dump_oops
= !of_property_read_bool(of_node
, "no-dump-oops");
704 #define parse_size(name, field) { \
705 ret = ramoops_parse_dt_size(pdev, name, &value); \
711 parse_size("record-size", pdata
->record_size
);
712 parse_size("console-size", pdata
->console_size
);
713 parse_size("ftrace-size", pdata
->ftrace_size
);
714 parse_size("pmsg-size", pdata
->pmsg_size
);
715 parse_size("ecc-size", pdata
->ecc_info
.ecc_size
);
716 parse_size("flags", pdata
->flags
);
723 static int ramoops_probe(struct platform_device
*pdev
)
725 struct device
*dev
= &pdev
->dev
;
726 struct ramoops_platform_data
*pdata
= dev
->platform_data
;
727 struct ramoops_platform_data pdata_local
;
728 struct ramoops_context
*cxt
= &oops_cxt
;
733 if (dev_of_node(dev
) && !pdata
) {
734 pdata
= &pdata_local
;
735 memset(pdata
, 0, sizeof(*pdata
));
737 err
= ramoops_parse_dt(pdev
, pdata
);
743 * Only a single ramoops area allowed at a time, so fail extra
746 if (cxt
->max_dump_cnt
) {
747 pr_err("already initialized\n");
751 /* Make sure we didn't get bogus platform data pointer. */
753 pr_err("NULL platform data\n");
757 if (!pdata
->mem_size
|| (!pdata
->record_size
&& !pdata
->console_size
&&
758 !pdata
->ftrace_size
&& !pdata
->pmsg_size
)) {
759 pr_err("The memory size and the record/console size must be "
764 if (pdata
->record_size
&& !is_power_of_2(pdata
->record_size
))
765 pdata
->record_size
= rounddown_pow_of_two(pdata
->record_size
);
766 if (pdata
->console_size
&& !is_power_of_2(pdata
->console_size
))
767 pdata
->console_size
= rounddown_pow_of_two(pdata
->console_size
);
768 if (pdata
->ftrace_size
&& !is_power_of_2(pdata
->ftrace_size
))
769 pdata
->ftrace_size
= rounddown_pow_of_two(pdata
->ftrace_size
);
770 if (pdata
->pmsg_size
&& !is_power_of_2(pdata
->pmsg_size
))
771 pdata
->pmsg_size
= rounddown_pow_of_two(pdata
->pmsg_size
);
773 cxt
->size
= pdata
->mem_size
;
774 cxt
->phys_addr
= pdata
->mem_address
;
775 cxt
->memtype
= pdata
->mem_type
;
776 cxt
->record_size
= pdata
->record_size
;
777 cxt
->console_size
= pdata
->console_size
;
778 cxt
->ftrace_size
= pdata
->ftrace_size
;
779 cxt
->pmsg_size
= pdata
->pmsg_size
;
780 cxt
->dump_oops
= pdata
->dump_oops
;
781 cxt
->flags
= pdata
->flags
;
782 cxt
->ecc_info
= pdata
->ecc_info
;
784 paddr
= cxt
->phys_addr
;
786 dump_mem_sz
= cxt
->size
- cxt
->console_size
- cxt
->ftrace_size
788 err
= ramoops_init_przs("dump", dev
, cxt
, &cxt
->dprzs
, &paddr
,
789 dump_mem_sz
, cxt
->record_size
,
790 &cxt
->max_dump_cnt
, 0, 0);
794 err
= ramoops_init_prz("console", dev
, cxt
, &cxt
->cprz
, &paddr
,
795 cxt
->console_size
, 0);
799 cxt
->max_ftrace_cnt
= (cxt
->flags
& RAMOOPS_FLAG_FTRACE_PER_CPU
)
802 err
= ramoops_init_przs("ftrace", dev
, cxt
, &cxt
->fprzs
, &paddr
,
803 cxt
->ftrace_size
, -1,
804 &cxt
->max_ftrace_cnt
, LINUX_VERSION_CODE
,
805 (cxt
->flags
& RAMOOPS_FLAG_FTRACE_PER_CPU
)
806 ? PRZ_FLAG_NO_LOCK
: 0);
810 err
= ramoops_init_prz("pmsg", dev
, cxt
, &cxt
->mprz
, &paddr
,
815 cxt
->pstore
.data
= cxt
;
817 * Prepare frontend flags based on which areas are initialized.
818 * For ramoops_init_przs() cases, the "max count" variable tells
819 * if there are regions present. For ramoops_init_prz() cases,
820 * the single region size is how to check.
822 cxt
->pstore
.flags
= 0;
823 if (cxt
->max_dump_cnt
)
824 cxt
->pstore
.flags
|= PSTORE_FLAGS_DMESG
;
825 if (cxt
->console_size
)
826 cxt
->pstore
.flags
|= PSTORE_FLAGS_CONSOLE
;
827 if (cxt
->max_ftrace_cnt
)
828 cxt
->pstore
.flags
|= PSTORE_FLAGS_FTRACE
;
830 cxt
->pstore
.flags
|= PSTORE_FLAGS_PMSG
;
833 * Since bufsize is only used for dmesg crash dumps, it
834 * must match the size of the dprz record (after PRZ header
835 * and ECC bytes have been accounted for).
837 if (cxt
->pstore
.flags
& PSTORE_FLAGS_DMESG
) {
838 cxt
->pstore
.bufsize
= cxt
->dprzs
[0]->buffer_size
;
839 cxt
->pstore
.buf
= kzalloc(cxt
->pstore
.bufsize
, GFP_KERNEL
);
840 if (!cxt
->pstore
.buf
) {
841 pr_err("cannot allocate pstore crash dump buffer\n");
847 err
= pstore_register(&cxt
->pstore
);
849 pr_err("registering with pstore failed\n");
854 * Update the module parameter variables as well so they are visible
855 * through /sys/module/ramoops/parameters/
857 mem_size
= pdata
->mem_size
;
858 mem_address
= pdata
->mem_address
;
859 record_size
= pdata
->record_size
;
860 dump_oops
= pdata
->dump_oops
;
861 ramoops_console_size
= pdata
->console_size
;
862 ramoops_pmsg_size
= pdata
->pmsg_size
;
863 ramoops_ftrace_size
= pdata
->ftrace_size
;
865 pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n",
866 cxt
->size
, (unsigned long long)cxt
->phys_addr
,
867 cxt
->ecc_info
.ecc_size
, cxt
->ecc_info
.block_size
);
872 kfree(cxt
->pstore
.buf
);
874 cxt
->pstore
.bufsize
= 0;
875 persistent_ram_free(cxt
->mprz
);
878 persistent_ram_free(cxt
->cprz
);
880 ramoops_free_przs(cxt
);
885 static int ramoops_remove(struct platform_device
*pdev
)
887 struct ramoops_context
*cxt
= &oops_cxt
;
889 pstore_unregister(&cxt
->pstore
);
891 kfree(cxt
->pstore
.buf
);
892 cxt
->pstore
.bufsize
= 0;
894 persistent_ram_free(cxt
->mprz
);
895 persistent_ram_free(cxt
->cprz
);
896 ramoops_free_przs(cxt
);
901 static const struct of_device_id dt_match
[] = {
902 { .compatible
= "ramoops" },
906 static struct platform_driver ramoops_driver
= {
907 .probe
= ramoops_probe
,
908 .remove
= ramoops_remove
,
911 .of_match_table
= dt_match
,
915 static inline void ramoops_unregister_dummy(void)
917 platform_device_unregister(dummy
);
924 static void __init
ramoops_register_dummy(void)
927 * Prepare a dummy platform data structure to carry the module
928 * parameters. If mem_size isn't set, then there are no module
929 * parameters, and we can skip this.
934 pr_info("using module parameters\n");
936 dummy_data
= kzalloc(sizeof(*dummy_data
), GFP_KERNEL
);
938 pr_info("could not allocate pdata\n");
942 dummy_data
->mem_size
= mem_size
;
943 dummy_data
->mem_address
= mem_address
;
944 dummy_data
->mem_type
= mem_type
;
945 dummy_data
->record_size
= record_size
;
946 dummy_data
->console_size
= ramoops_console_size
;
947 dummy_data
->ftrace_size
= ramoops_ftrace_size
;
948 dummy_data
->pmsg_size
= ramoops_pmsg_size
;
949 dummy_data
->dump_oops
= dump_oops
;
950 dummy_data
->flags
= RAMOOPS_FLAG_FTRACE_PER_CPU
;
953 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
954 * (using 1 byte for ECC isn't much of use anyway).
956 dummy_data
->ecc_info
.ecc_size
= ramoops_ecc
== 1 ? 16 : ramoops_ecc
;
958 dummy
= platform_device_register_data(NULL
, "ramoops", -1,
959 dummy_data
, sizeof(struct ramoops_platform_data
));
961 pr_info("could not create platform device: %ld\n",
964 ramoops_unregister_dummy();
968 static int __init
ramoops_init(void)
972 ramoops_register_dummy();
973 ret
= platform_driver_register(&ramoops_driver
);
975 ramoops_unregister_dummy();
979 postcore_initcall(ramoops_init
);
981 static void __exit
ramoops_exit(void)
983 platform_driver_unregister(&ramoops_driver
);
984 ramoops_unregister_dummy();
986 module_exit(ramoops_exit
);
988 MODULE_LICENSE("GPL");
989 MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
990 MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");