1/*
2 * RAM Oops/Panic logger
3 *
4 * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
5 * Copyright (C) 2011 Kees Cook <keescook@chromium.org>
6 *
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.
10 *
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.
15 *
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
19 * 02110-1301 USA
20 *
21 */
22
23#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
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>
30#include <linux/time.h>
31#include <linux/io.h>
32#include <linux/ioport.h>
33#include <linux/platform_device.h>
34#include <linux/slab.h>
35#include <linux/compiler.h>
36#include <linux/pstore_ram.h>
37
38#define RAMOOPS_KERNMSG_HDR "===="
39#define MIN_MEM_SIZE 4096UL
40
41static ulong record_size = MIN_MEM_SIZE;
42module_param(record_size, ulong, 0400);
43MODULE_PARM_DESC(record_size,
44		"size of each dump done on oops/panic");
45
46static ulong ramoops_console_size = MIN_MEM_SIZE;
47module_param_named(console_size, ramoops_console_size, ulong, 0400);
48MODULE_PARM_DESC(console_size, "size of kernel console log");
49
50static ulong ramoops_ftrace_size = MIN_MEM_SIZE;
51module_param_named(ftrace_size, ramoops_ftrace_size, ulong, 0400);
52MODULE_PARM_DESC(ftrace_size, "size of ftrace log");
53
54static ulong ramoops_pmsg_size = MIN_MEM_SIZE;
55module_param_named(pmsg_size, ramoops_pmsg_size, ulong, 0400);
56MODULE_PARM_DESC(pmsg_size, "size of user space message log");
57
58static ulong mem_address;
59module_param(mem_address, ulong, 0400);
60MODULE_PARM_DESC(mem_address,
61		"start of reserved RAM used to store oops/panic logs");
62
63static ulong mem_size;
64module_param(mem_size, ulong, 0400);
65MODULE_PARM_DESC(mem_size,
66		"size of reserved RAM used to store oops/panic logs");
67
68static unsigned int mem_type;
69module_param(mem_type, uint, 0600);
70MODULE_PARM_DESC(mem_type,
71		"set to 1 to try to use unbuffered memory (default 0)");
72
73static int dump_oops = 1;
74module_param(dump_oops, int, 0600);
75MODULE_PARM_DESC(dump_oops,
76		"set to 1 to dump oopses, 0 to only dump panics (default 1)");
77
78static int ramoops_ecc;
79module_param_named(ecc, ramoops_ecc, int, 0600);
80MODULE_PARM_DESC(ramoops_ecc,
81		"if non-zero, the option enables ECC support and specifies "
82		"ECC buffer size in bytes (1 is a special value, means 16 "
83		"bytes ECC)");
84
85struct ramoops_context {
86	struct persistent_ram_zone **przs;
87	struct persistent_ram_zone *cprz;
88	struct persistent_ram_zone *fprz;
89	struct persistent_ram_zone *mprz;
90	phys_addr_t phys_addr;
91	unsigned long size;
92	unsigned int memtype;
93	size_t record_size;
94	size_t console_size;
95	size_t ftrace_size;
96	size_t pmsg_size;
97	int dump_oops;
98	struct persistent_ram_ecc_info ecc_info;
99	unsigned int max_dump_cnt;
100	unsigned int dump_write_cnt;
101	/* _read_cnt need clear on ramoops_pstore_open */
102	unsigned int dump_read_cnt;
103	unsigned int console_read_cnt;
104	unsigned int ftrace_read_cnt;
105	unsigned int pmsg_read_cnt;
106	struct pstore_info pstore;
107};
108
109static struct platform_device *dummy;
110static struct ramoops_platform_data *dummy_data;
111
112static int ramoops_pstore_open(struct pstore_info *psi)
113{
114	struct ramoops_context *cxt = psi->data;
115
116	cxt->dump_read_cnt = 0;
117	cxt->console_read_cnt = 0;
118	cxt->ftrace_read_cnt = 0;
119	cxt->pmsg_read_cnt = 0;
120	return 0;
121}
122
123static struct persistent_ram_zone *
124ramoops_get_next_prz(struct persistent_ram_zone *przs[], uint *c, uint max,
125		     u64 *id,
126		     enum pstore_type_id *typep, enum pstore_type_id type,
127		     bool update)
128{
129	struct persistent_ram_zone *prz;
130	int i = (*c)++;
131
132	if (i >= max)
133		return NULL;
134
135	prz = przs[i];
136	if (!prz)
137		return NULL;
138
139	/* Update old/shadowed buffer. */
140	if (update)
141		persistent_ram_save_old(prz);
142
143	if (!persistent_ram_old_size(prz))
144		return NULL;
145
146	*typep = type;
147	*id = i;
148
149	return prz;
150}
151
152static int ramoops_read_kmsg_hdr(char *buffer, struct timespec *time,
153				  bool *compressed)
154{
155	char data_type;
156	int header_length = 0;
157
158	if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n%n", &time->tv_sec,
159			&time->tv_nsec, &data_type, &header_length) == 3) {
160		if (data_type == 'C')
161			*compressed = true;
162		else
163			*compressed = false;
164	} else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu\n%n",
165			&time->tv_sec, &time->tv_nsec, &header_length) == 2) {
166			*compressed = false;
167	} else {
168		time->tv_sec = 0;
169		time->tv_nsec = 0;
170		*compressed = false;
171	}
172	return header_length;
173}
174
175static bool prz_ok(struct persistent_ram_zone *prz)
176{
177	return !!prz && !!(persistent_ram_old_size(prz) +
178			   persistent_ram_ecc_string(prz, NULL, 0));
179}
180
181static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
182				   int *count, struct timespec *time,
183				   char **buf, bool *compressed,
184				   struct pstore_info *psi)
185{
186	ssize_t size;
187	ssize_t ecc_notice_size;
188	struct ramoops_context *cxt = psi->data;
189	struct persistent_ram_zone *prz;
190	int header_length;
191
192	prz = ramoops_get_next_prz(cxt->przs, &cxt->dump_read_cnt,
193				   cxt->max_dump_cnt, id, type,
194				   PSTORE_TYPE_DMESG, 1);
195	if (!prz_ok(prz))
196		prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt,
197					   1, id, type, PSTORE_TYPE_CONSOLE, 0);
198	if (!prz_ok(prz))
199		prz = ramoops_get_next_prz(&cxt->fprz, &cxt->ftrace_read_cnt,
200					   1, id, type, PSTORE_TYPE_FTRACE, 0);
201	if (!prz_ok(prz))
202		prz = ramoops_get_next_prz(&cxt->mprz, &cxt->pmsg_read_cnt,
203					   1, id, type, PSTORE_TYPE_PMSG, 0);
204	if (!prz_ok(prz))
205		return 0;
206
207	if (!persistent_ram_old(prz))
208		return 0;
209
210	size = persistent_ram_old_size(prz);
211	header_length = ramoops_read_kmsg_hdr(persistent_ram_old(prz), time,
212			compressed);
213	size -= header_length;
214
215	/* ECC correction notice */
216	ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0);
217
218	*buf = kmalloc(size + ecc_notice_size + 1, GFP_KERNEL);
219	if (*buf == NULL)
220		return -ENOMEM;
221
222	memcpy(*buf, (char *)persistent_ram_old(prz) + header_length, size);
223	persistent_ram_ecc_string(prz, *buf + size, ecc_notice_size + 1);
224
225	return size + ecc_notice_size;
226}
227
228static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
229				     bool compressed)
230{
231	char *hdr;
232	struct timespec timestamp;
233	size_t len;
234
235	/* Report zeroed timestamp if called before timekeeping has resumed. */
236	if (__getnstimeofday(&timestamp)) {
237		timestamp.tv_sec = 0;
238		timestamp.tv_nsec = 0;
239	}
240	hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n",
241		(long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000),
242		compressed ? 'C' : 'D');
243	WARN_ON_ONCE(!hdr);
244	len = hdr ? strlen(hdr) : 0;
245	persistent_ram_write(prz, hdr, len);
246	kfree(hdr);
247
248	return len;
249}
250
251static int notrace ramoops_pstore_write_buf(enum pstore_type_id type,
252					    enum kmsg_dump_reason reason,
253					    u64 *id, unsigned int part,
254					    const char *buf,
255					    bool compressed, size_t size,
256					    struct pstore_info *psi)
257{
258	struct ramoops_context *cxt = psi->data;
259	struct persistent_ram_zone *prz;
260	size_t hlen;
261
262	if (type == PSTORE_TYPE_CONSOLE) {
263		if (!cxt->cprz)
264			return -ENOMEM;
265		persistent_ram_write(cxt->cprz, buf, size);
266		return 0;
267	} else if (type == PSTORE_TYPE_FTRACE) {
268		if (!cxt->fprz)
269			return -ENOMEM;
270		persistent_ram_write(cxt->fprz, buf, size);
271		return 0;
272	} else if (type == PSTORE_TYPE_PMSG) {
273		if (!cxt->mprz)
274			return -ENOMEM;
275		persistent_ram_write(cxt->mprz, buf, size);
276		return 0;
277	}
278
279	if (type != PSTORE_TYPE_DMESG)
280		return -EINVAL;
281
282	/* Out of the various dmesg dump types, ramoops is currently designed
283	 * to only store crash logs, rather than storing general kernel logs.
284	 */
285	if (reason != KMSG_DUMP_OOPS &&
286	    reason != KMSG_DUMP_PANIC)
287		return -EINVAL;
288
289	/* Skip Oopes when configured to do so. */
290	if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
291		return -EINVAL;
292
293	/* Explicitly only take the first part of any new crash.
294	 * If our buffer is larger than kmsg_bytes, this can never happen,
295	 * and if our buffer is smaller than kmsg_bytes, we don't want the
296	 * report split across multiple records.
297	 */
298	if (part != 1)
299		return -ENOSPC;
300
301	if (!cxt->przs)
302		return -ENOSPC;
303
304	prz = cxt->przs[cxt->dump_write_cnt];
305
306	hlen = ramoops_write_kmsg_hdr(prz, compressed);
307	if (size + hlen > prz->buffer_size)
308		size = prz->buffer_size - hlen;
309	persistent_ram_write(prz, buf, size);
310
311	cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
312
313	return 0;
314}
315
316static int ramoops_pstore_erase(enum pstore_type_id type, u64 id, int count,
317				struct timespec time, struct pstore_info *psi)
318{
319	struct ramoops_context *cxt = psi->data;
320	struct persistent_ram_zone *prz;
321
322	switch (type) {
323	case PSTORE_TYPE_DMESG:
324		if (id >= cxt->max_dump_cnt)
325			return -EINVAL;
326		prz = cxt->przs[id];
327		break;
328	case PSTORE_TYPE_CONSOLE:
329		prz = cxt->cprz;
330		break;
331	case PSTORE_TYPE_FTRACE:
332		prz = cxt->fprz;
333		break;
334	case PSTORE_TYPE_PMSG:
335		prz = cxt->mprz;
336		break;
337	default:
338		return -EINVAL;
339	}
340
341	persistent_ram_free_old(prz);
342	persistent_ram_zap(prz);
343
344	return 0;
345}
346
347static struct ramoops_context oops_cxt = {
348	.pstore = {
349		.owner	= THIS_MODULE,
350		.name	= "ramoops",
351		.open	= ramoops_pstore_open,
352		.read	= ramoops_pstore_read,
353		.write_buf	= ramoops_pstore_write_buf,
354		.erase	= ramoops_pstore_erase,
355	},
356};
357
358static void ramoops_free_przs(struct ramoops_context *cxt)
359{
360	int i;
361
362	cxt->max_dump_cnt = 0;
363	if (!cxt->przs)
364		return;
365
366	for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++)
367		persistent_ram_free(cxt->przs[i]);
368	kfree(cxt->przs);
369}
370
371static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt,
372			     phys_addr_t *paddr, size_t dump_mem_sz)
373{
374	int err = -ENOMEM;
375	int i;
376
377	if (!cxt->record_size)
378		return 0;
379
380	if (*paddr + dump_mem_sz - cxt->phys_addr > cxt->size) {
381		dev_err(dev, "no room for dumps\n");
382		return -ENOMEM;
383	}
384
385	cxt->max_dump_cnt = dump_mem_sz / cxt->record_size;
386	if (!cxt->max_dump_cnt)
387		return -ENOMEM;
388
389	cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt,
390			     GFP_KERNEL);
391	if (!cxt->przs) {
392		dev_err(dev, "failed to initialize a prz array for dumps\n");
393		goto fail_prz;
394	}
395
396	for (i = 0; i < cxt->max_dump_cnt; i++) {
397		size_t sz = cxt->record_size;
398
399		cxt->przs[i] = persistent_ram_new(*paddr, sz, 0,
400						  &cxt->ecc_info,
401						  cxt->memtype);
402		if (IS_ERR(cxt->przs[i])) {
403			err = PTR_ERR(cxt->przs[i]);
404			dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
405				sz, (unsigned long long)*paddr, err);
406			goto fail_prz;
407		}
408		*paddr += sz;
409	}
410
411	return 0;
412fail_prz:
413	ramoops_free_przs(cxt);
414	return err;
415}
416
417static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt,
418			    struct persistent_ram_zone **prz,
419			    phys_addr_t *paddr, size_t sz, u32 sig)
420{
421	if (!sz)
422		return 0;
423
424	if (*paddr + sz - cxt->phys_addr > cxt->size) {
425		dev_err(dev, "no room for mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
426			sz, (unsigned long long)*paddr,
427			cxt->size, (unsigned long long)cxt->phys_addr);
428		return -ENOMEM;
429	}
430
431	*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info, cxt->memtype);
432	if (IS_ERR(*prz)) {
433		int err = PTR_ERR(*prz);
434
435		dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
436			sz, (unsigned long long)*paddr, err);
437		return err;
438	}
439
440	persistent_ram_zap(*prz);
441
442	*paddr += sz;
443
444	return 0;
445}
446
447static int ramoops_probe(struct platform_device *pdev)
448{
449	struct device *dev = &pdev->dev;
450	struct ramoops_platform_data *pdata = pdev->dev.platform_data;
451	struct ramoops_context *cxt = &oops_cxt;
452	size_t dump_mem_sz;
453	phys_addr_t paddr;
454	int err = -EINVAL;
455
456	/* Only a single ramoops area allowed at a time, so fail extra
457	 * probes.
458	 */
459	if (cxt->max_dump_cnt)
460		goto fail_out;
461
462	if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
463			!pdata->ftrace_size && !pdata->pmsg_size)) {
464		pr_err("The memory size and the record/console size must be "
465			"non-zero\n");
466		goto fail_out;
467	}
468
469	if (pdata->record_size && !is_power_of_2(pdata->record_size))
470		pdata->record_size = rounddown_pow_of_two(pdata->record_size);
471	if (pdata->console_size && !is_power_of_2(pdata->console_size))
472		pdata->console_size = rounddown_pow_of_two(pdata->console_size);
473	if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
474		pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
475	if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
476		pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
477
478	cxt->size = pdata->mem_size;
479	cxt->phys_addr = pdata->mem_address;
480	cxt->memtype = pdata->mem_type;
481	cxt->record_size = pdata->record_size;
482	cxt->console_size = pdata->console_size;
483	cxt->ftrace_size = pdata->ftrace_size;
484	cxt->pmsg_size = pdata->pmsg_size;
485	cxt->dump_oops = pdata->dump_oops;
486	cxt->ecc_info = pdata->ecc_info;
487
488	paddr = cxt->phys_addr;
489
490	dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size
491			- cxt->pmsg_size;
492	err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz);
493	if (err)
494		goto fail_out;
495
496	err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr,
497			       cxt->console_size, 0);
498	if (err)
499		goto fail_init_cprz;
500
501	err = ramoops_init_prz(dev, cxt, &cxt->fprz, &paddr, cxt->ftrace_size,
502			       LINUX_VERSION_CODE);
503	if (err)
504		goto fail_init_fprz;
505
506	err = ramoops_init_prz(dev, cxt, &cxt->mprz, &paddr, cxt->pmsg_size, 0);
507	if (err)
508		goto fail_init_mprz;
509
510	cxt->pstore.data = cxt;
511	/*
512	 * Console can handle any buffer size, so prefer LOG_LINE_MAX. If we
513	 * have to handle dumps, we must have at least record_size buffer. And
514	 * for ftrace, bufsize is irrelevant (if bufsize is 0, buf will be
515	 * ZERO_SIZE_PTR).
516	 */
517	if (cxt->console_size)
518		cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */
519	cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize);
520	cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
521	spin_lock_init(&cxt->pstore.buf_lock);
522	if (!cxt->pstore.buf) {
523		pr_err("cannot allocate pstore buffer\n");
524		err = -ENOMEM;
525		goto fail_clear;
526	}
527
528	err = pstore_register(&cxt->pstore);
529	if (err) {
530		pr_err("registering with pstore failed\n");
531		goto fail_buf;
532	}
533
534	/*
535	 * Update the module parameter variables as well so they are visible
536	 * through /sys/module/ramoops/parameters/
537	 */
538	mem_size = pdata->mem_size;
539	mem_address = pdata->mem_address;
540	record_size = pdata->record_size;
541	dump_oops = pdata->dump_oops;
542	ramoops_console_size = pdata->console_size;
543	ramoops_pmsg_size = pdata->pmsg_size;
544	ramoops_ftrace_size = pdata->ftrace_size;
545
546	pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n",
547		cxt->size, (unsigned long long)cxt->phys_addr,
548		cxt->ecc_info.ecc_size, cxt->ecc_info.block_size);
549
550	return 0;
551
552fail_buf:
553	kfree(cxt->pstore.buf);
554fail_clear:
555	cxt->pstore.bufsize = 0;
556	kfree(cxt->mprz);
557fail_init_mprz:
558	kfree(cxt->fprz);
559fail_init_fprz:
560	kfree(cxt->cprz);
561fail_init_cprz:
562	ramoops_free_przs(cxt);
563fail_out:
564	return err;
565}
566
567static int __exit ramoops_remove(struct platform_device *pdev)
568{
569#if 0
570	/* TODO(kees): We cannot unload ramoops since pstore doesn't support
571	 * unregistering yet.
572	 */
573	struct ramoops_context *cxt = &oops_cxt;
574
575	iounmap(cxt->virt_addr);
576	release_mem_region(cxt->phys_addr, cxt->size);
577	cxt->max_dump_cnt = 0;
578
579	/* TODO(kees): When pstore supports unregistering, call it here. */
580	kfree(cxt->pstore.buf);
581	cxt->pstore.bufsize = 0;
582
583	return 0;
584#endif
585	return -EBUSY;
586}
587
588static struct platform_driver ramoops_driver = {
589	.probe		= ramoops_probe,
590	.remove		= __exit_p(ramoops_remove),
591	.driver		= {
592		.name	= "ramoops",
593	},
594};
595
596static void ramoops_register_dummy(void)
597{
598	if (!mem_size)
599		return;
600
601	pr_info("using module parameters\n");
602
603	dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL);
604	if (!dummy_data) {
605		pr_info("could not allocate pdata\n");
606		return;
607	}
608
609	dummy_data->mem_size = mem_size;
610	dummy_data->mem_address = mem_address;
611	dummy_data->mem_type = 0;
612	dummy_data->record_size = record_size;
613	dummy_data->console_size = ramoops_console_size;
614	dummy_data->ftrace_size = ramoops_ftrace_size;
615	dummy_data->pmsg_size = ramoops_pmsg_size;
616	dummy_data->dump_oops = dump_oops;
617	/*
618	 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
619	 * (using 1 byte for ECC isn't much of use anyway).
620	 */
621	dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
622
623	dummy = platform_device_register_data(NULL, "ramoops", -1,
624			dummy_data, sizeof(struct ramoops_platform_data));
625	if (IS_ERR(dummy)) {
626		pr_info("could not create platform device: %ld\n",
627			PTR_ERR(dummy));
628	}
629}
630
631static int __init ramoops_init(void)
632{
633	ramoops_register_dummy();
634	return platform_driver_register(&ramoops_driver);
635}
636postcore_initcall(ramoops_init);
637
638static void __exit ramoops_exit(void)
639{
640	platform_driver_unregister(&ramoops_driver);
641	platform_device_unregister(dummy);
642	kfree(dummy_data);
643}
644module_exit(ramoops_exit);
645
646MODULE_LICENSE("GPL");
647MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
648MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");
649