ram.c 23.6 KB
Newer Older
1
2
3
4
/*
 * RAM Oops/Panic logger
 *
 * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
Kees Cook's avatar
Kees Cook committed
5
 * Copyright (C) 2011 Kees Cook <keescook@chromium.org>
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 *
 * 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
 *
 */

23
24
#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>
Kees Cook's avatar
Kees Cook committed
29
#include <linux/pstore.h>
30
31
32
#include <linux/time.h>
#include <linux/io.h>
#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
#include <linux/of.h>
#include <linux/of_address.h>
39
40

#define RAMOOPS_KERNMSG_HDR "===="
41
#define MIN_MEM_SIZE 4096UL
42

43
44
45
46
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");
47

48
49
50
51
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");

52
53
54
55
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");

56
57
58
59
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");

60
61
static unsigned long long mem_address;
module_param(mem_address, ullong, 0400);
62
63
64
65
66
67
68
69
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");

70
71
72
73
74
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)");

75
76
77
78
79
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)");

Anton Vorontsov's avatar
Anton Vorontsov committed
80
81
82
static int ramoops_ecc;
module_param_named(ecc, ramoops_ecc, int, 0600);
MODULE_PARM_DESC(ramoops_ecc,
83
84
85
		"if non-zero, the option enables ECC support and specifies "
		"ECC buffer size in bytes (1 is a special value, means 16 "
		"bytes ECC)");
Anton Vorontsov's avatar
Anton Vorontsov committed
86

Kees Cook's avatar
Kees Cook committed
87
struct ramoops_context {
88
	struct persistent_ram_zone **przs;
89
	struct persistent_ram_zone *cprz;
90
	struct persistent_ram_zone **fprzs;
91
	struct persistent_ram_zone *mprz;
92
93
	phys_addr_t phys_addr;
	unsigned long size;
94
	unsigned int memtype;
Kees Cook's avatar
Kees Cook committed
95
	size_t record_size;
96
	size_t console_size;
97
	size_t ftrace_size;
98
	size_t pmsg_size;
99
	int dump_oops;
100
	u32 flags;
101
	struct persistent_ram_ecc_info ecc_info;
102
103
	unsigned int max_dump_cnt;
	unsigned int dump_write_cnt;
104
	/* _read_cnt need clear on ramoops_pstore_open */
105
	unsigned int dump_read_cnt;
106
	unsigned int console_read_cnt;
107
	unsigned int max_ftrace_cnt;
108
	unsigned int ftrace_read_cnt;
109
	unsigned int pmsg_read_cnt;
Kees Cook's avatar
Kees Cook committed
110
111
	struct pstore_info pstore;
};
112

113
114
115
static struct platform_device *dummy;
static struct ramoops_platform_data *dummy_data;

Kees Cook's avatar
Kees Cook committed
116
117
118
119
static int ramoops_pstore_open(struct pstore_info *psi)
{
	struct ramoops_context *cxt = psi->data;

120
	cxt->dump_read_cnt = 0;
121
	cxt->console_read_cnt = 0;
122
	cxt->ftrace_read_cnt = 0;
123
	cxt->pmsg_read_cnt = 0;
Kees Cook's avatar
Kees Cook committed
124
125
126
	return 0;
}

127
128
129
130
131
132
133
134
135
136
137
138
139
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];
140
141
	if (!prz)
		return NULL;
142

143
144
	/* Update old/shadowed buffer. */
	if (update)
145
		persistent_ram_save_old(prz);
146
147
148

	if (!persistent_ram_old_size(prz))
		return NULL;
149
150
151
152
153
154
155

	*typep = type;
	*id = i;

	return prz;
}

156
static int ramoops_read_kmsg_hdr(char *buffer, struct timespec *time,
157
158
159
				  bool *compressed)
{
	char data_type;
160
	int header_length = 0;
161

162
163
	if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n%n", &time->tv_sec,
			&time->tv_nsec, &data_type, &header_length) == 3) {
164
165
166
167
		if (data_type == 'C')
			*compressed = true;
		else
			*compressed = false;
168
169
	} else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu\n%n",
			&time->tv_sec, &time->tv_nsec, &header_length) == 2) {
170
171
172
173
174
175
			*compressed = false;
	} else {
		time->tv_sec = 0;
		time->tv_nsec = 0;
		*compressed = false;
	}
176
	return header_length;
177
178
}

179
180
181
182
183
184
static bool prz_ok(struct persistent_ram_zone *prz)
{
	return !!prz && !!(persistent_ram_old_size(prz) +
			   persistent_ram_ecc_string(prz, NULL, 0));
}

185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
static ssize_t ftrace_log_combine(struct persistent_ram_zone *dest,
				  struct persistent_ram_zone *src)
{
	size_t dest_size, src_size, total, dest_off, src_off;
	size_t dest_idx = 0, src_idx = 0, merged_idx = 0;
	void *merged_buf;
	struct pstore_ftrace_record *drec, *srec, *mrec;
	size_t record_size = sizeof(struct pstore_ftrace_record);

	dest_off = dest->old_log_size % record_size;
	dest_size = dest->old_log_size - dest_off;

	src_off = src->old_log_size % record_size;
	src_size = src->old_log_size - src_off;

	total = dest_size + src_size;
	merged_buf = kmalloc(total, GFP_KERNEL);
	if (!merged_buf)
		return -ENOMEM;

	drec = (struct pstore_ftrace_record *)(dest->old_log + dest_off);
	srec = (struct pstore_ftrace_record *)(src->old_log + src_off);
	mrec = (struct pstore_ftrace_record *)(merged_buf);

	while (dest_size > 0 && src_size > 0) {
		if (pstore_ftrace_read_timestamp(&drec[dest_idx]) <
		    pstore_ftrace_read_timestamp(&srec[src_idx])) {
			mrec[merged_idx++] = drec[dest_idx++];
			dest_size -= record_size;
		} else {
			mrec[merged_idx++] = srec[src_idx++];
			src_size -= record_size;
		}
	}

	while (dest_size > 0) {
		mrec[merged_idx++] = drec[dest_idx++];
		dest_size -= record_size;
	}

	while (src_size > 0) {
		mrec[merged_idx++] = srec[src_idx++];
		src_size -= record_size;
	}

	kfree(dest->old_log);
	dest->old_log = merged_buf;
	dest->old_log_size = total;

	return 0;
}

Kees Cook's avatar
Kees Cook committed
237
static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
238
				   int *count, struct timespec *time,
239
				   char **buf, bool *compressed,
240
				   ssize_t *ecc_notice_size,
241
				   struct pstore_info *psi)
242
{
243
	ssize_t size = 0;
Kees Cook's avatar
Kees Cook committed
244
	struct ramoops_context *cxt = psi->data;
245
246
	struct persistent_ram_zone *prz = NULL;
	int header_length = 0;
247
	bool free_prz = false;
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272

	/* 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;
		}
	}
Kees Cook's avatar
Kees Cook committed
273

274
	if (!prz_ok(prz))
275
276
		prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt,
					   1, id, type, PSTORE_TYPE_CONSOLE, 0);
277
278
279
280
281
282

	if (!prz_ok(prz))
		prz = ramoops_get_next_prz(&cxt->mprz, &cxt->pmsg_read_cnt,
					   1, id, type, PSTORE_TYPE_PMSG, 0);

	/* ftrace is last since it may want to dynamically allocate memory. */
283
	if (!prz_ok(prz)) {
284
		if (!(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)) {
285
			prz = ramoops_get_next_prz(cxt->fprzs,
286
					&cxt->ftrace_read_cnt, 1, id, type,
287
					PSTORE_TYPE_FTRACE, 0);
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
		} else {
			/*
			 * Build a new dummy record which combines all the
			 * per-cpu records including metadata and ecc info.
			 */
			struct persistent_ram_zone *tmp_prz, *prz_next;

			tmp_prz = kzalloc(sizeof(struct persistent_ram_zone),
					  GFP_KERNEL);
			if (!tmp_prz)
				return -ENOMEM;
			free_prz = true;

			while (cxt->ftrace_read_cnt < cxt->max_ftrace_cnt) {
				prz_next = ramoops_get_next_prz(cxt->fprzs,
						&cxt->ftrace_read_cnt,
						cxt->max_ftrace_cnt, id,
						type, PSTORE_TYPE_FTRACE, 0);

				if (!prz_ok(prz_next))
					continue;

				tmp_prz->ecc_info = prz_next->ecc_info;
				tmp_prz->corrected_bytes +=
						prz_next->corrected_bytes;
				tmp_prz->bad_blocks += prz_next->bad_blocks;
				size = ftrace_log_combine(tmp_prz, prz_next);
				if (size)
					goto out;
			}
			*id = 0;
			prz = tmp_prz;
320
321
322
		}
	}

323
324
325
326
	if (!prz_ok(prz)) {
		size = 0;
		goto out;
	}
327

328
	size = persistent_ram_old_size(prz) - header_length;
329
330

	/* ECC correction notice */
331
	*ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0);
332

333
	*buf = kmalloc(size + *ecc_notice_size + 1, GFP_KERNEL);
334
335
336
337
	if (*buf == NULL) {
		size = -ENOMEM;
		goto out;
	}
Kees Cook's avatar
Kees Cook committed
338

339
	memcpy(*buf, (char *)persistent_ram_old(prz) + header_length, size);
340

341
	persistent_ram_ecc_string(prz, *buf + size, *ecc_notice_size + 1);
342

343
344
345
346
347
348
out:
	if (free_prz) {
		kfree(prz->old_log);
		kfree(prz);
	}

349
	return size;
Kees Cook's avatar
Kees Cook committed
350
351
}

352
353
static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
				     bool compressed)
354
355
{
	char *hdr;
356
	struct timespec timestamp;
357
358
	size_t len;

359
360
361
362
363
	/* Report zeroed timestamp if called before timekeeping has resumed. */
	if (__getnstimeofday(&timestamp)) {
		timestamp.tv_sec = 0;
		timestamp.tv_nsec = 0;
	}
364
365
366
	hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n",
		(long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000),
		compressed ? 'C' : 'D');
367
368
369
370
371
372
373
374
	WARN_ON_ONCE(!hdr);
	len = hdr ? strlen(hdr) : 0;
	persistent_ram_write(prz, hdr, len);
	kfree(hdr);

	return len;
}

375
376
377
static int notrace ramoops_pstore_write_buf(enum pstore_type_id type,
					    enum kmsg_dump_reason reason,
					    u64 *id, unsigned int part,
378
					    const char *buf,
379
					    bool compressed, size_t size,
380
					    struct pstore_info *psi)
Kees Cook's avatar
Kees Cook committed
381
382
{
	struct ramoops_context *cxt = psi->data;
383
	struct persistent_ram_zone *prz;
384
	size_t hlen;
Kees Cook's avatar
Kees Cook committed
385

386
387
388
	if (type == PSTORE_TYPE_CONSOLE) {
		if (!cxt->cprz)
			return -ENOMEM;
389
		persistent_ram_write(cxt->cprz, buf, size);
390
		return 0;
391
	} else if (type == PSTORE_TYPE_FTRACE) {
392
393
394
		int zonenum;

		if (!cxt->fprzs)
395
			return -ENOMEM;
396
397
398
399
400
401
402
403
404
		/*
		 * Choose zone by if we're using per-cpu buffers.
		 */
		if (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
			zonenum = smp_processor_id();
		else
			zonenum = 0;

		persistent_ram_write(cxt->fprzs[zonenum], buf, size);
405
		return 0;
406
	} else if (type == PSTORE_TYPE_PMSG) {
407
408
		pr_warn_ratelimited("PMSG shouldn't call %s\n", __func__);
		return -EINVAL;
409
410
	}

Kees Cook's avatar
Kees Cook committed
411
412
	if (type != PSTORE_TYPE_DMESG)
		return -EINVAL;
413

Kees Cook's avatar
Kees Cook committed
414
415
416
	/* Out of the various dmesg dump types, ramoops is currently designed
	 * to only store crash logs, rather than storing general kernel logs.
	 */
417
	if (reason != KMSG_DUMP_OOPS &&
WANG Cong's avatar
WANG Cong committed
418
	    reason != KMSG_DUMP_PANIC)
Kees Cook's avatar
Kees Cook committed
419
		return -EINVAL;
420

Kees Cook's avatar
Kees Cook committed
421
	/* Skip Oopes when configured to do so. */
422
	if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
Kees Cook's avatar
Kees Cook committed
423
424
425
426
427
428
429
430
431
		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;
432

433
434
435
436
437
	if (!cxt->przs)
		return -ENOSPC;

	prz = cxt->przs[cxt->dump_write_cnt];

438
	hlen = ramoops_write_kmsg_hdr(prz, compressed);
439
440
	if (size + hlen > prz->buffer_size)
		size = prz->buffer_size - hlen;
441
	persistent_ram_write(prz, buf, size);
442

443
	cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
Kees Cook's avatar
Kees Cook committed
444
445
446
447

	return 0;
}

Mark Salyzyn's avatar
Mark Salyzyn committed
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
static int notrace ramoops_pstore_write_buf_user(enum pstore_type_id type,
						 enum kmsg_dump_reason reason,
						 u64 *id, unsigned int part,
						 const char __user *buf,
						 bool compressed, size_t size,
						 struct pstore_info *psi)
{
	if (type == PSTORE_TYPE_PMSG) {
		struct ramoops_context *cxt = psi->data;

		if (!cxt->mprz)
			return -ENOMEM;
		return persistent_ram_write_user(cxt->mprz, buf, size);
	}

	return -EINVAL;
}

466
static int ramoops_pstore_erase(enum pstore_type_id type, u64 id, int count,
467
				struct timespec time, struct pstore_info *psi)
Kees Cook's avatar
Kees Cook committed
468
469
{
	struct ramoops_context *cxt = psi->data;
470
	struct persistent_ram_zone *prz;
Kees Cook's avatar
Kees Cook committed
471

472
473
474
475
476
477
478
479
480
	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;
481
	case PSTORE_TYPE_FTRACE:
482
483
484
		if (id >= cxt->max_ftrace_cnt)
			return -EINVAL;
		prz = cxt->fprzs[id];
485
		break;
486
487
488
	case PSTORE_TYPE_PMSG:
		prz = cxt->mprz;
		break;
489
	default:
Kees Cook's avatar
Kees Cook committed
490
		return -EINVAL;
491
	}
Kees Cook's avatar
Kees Cook committed
492

493
494
	persistent_ram_free_old(prz);
	persistent_ram_zap(prz);
Kees Cook's avatar
Kees Cook committed
495
496

	return 0;
497
498
}

Kees Cook's avatar
Kees Cook committed
499
500
501
502
503
504
static struct ramoops_context oops_cxt = {
	.pstore = {
		.owner	= THIS_MODULE,
		.name	= "ramoops",
		.open	= ramoops_pstore_open,
		.read	= ramoops_pstore_read,
505
		.write_buf	= ramoops_pstore_write_buf,
Mark Salyzyn's avatar
Mark Salyzyn committed
506
		.write_buf_user	= ramoops_pstore_write_buf_user,
Kees Cook's avatar
Kees Cook committed
507
508
509
510
		.erase	= ramoops_pstore_erase,
	},
};

511
512
513
514
static void ramoops_free_przs(struct ramoops_context *cxt)
{
	int i;

515
516
517
518
	/* Free dump PRZs */
	if (cxt->przs) {
		for (i = 0; i < cxt->max_dump_cnt; i++)
			persistent_ram_free(cxt->przs[i]);
519

520
521
522
		kfree(cxt->przs);
		cxt->max_dump_cnt = 0;
	}
523

524
525
526
527
528
529
530
	/* Free ftrace PRZs */
	if (cxt->fprzs) {
		for (i = 0; i < cxt->max_ftrace_cnt; i++)
			persistent_ram_free(cxt->fprzs[i]);
		kfree(cxt->fprzs);
		cxt->max_ftrace_cnt = 0;
	}
531
532
}

533
static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt,
534
535
536
537
			     struct persistent_ram_zone ***przs,
			     phys_addr_t *paddr, size_t mem_sz,
			     ssize_t record_size,
			     unsigned int *cnt, u32 sig, u32 flags)
538
539
540
{
	int err = -ENOMEM;
	int i;
541
542
	size_t zone_sz;
	struct persistent_ram_zone **prz_ar;
543

544
545
546
	/* Allocate nothing for 0 mem_sz or 0 record_size. */
	if (mem_sz == 0 || record_size == 0) {
		*cnt = 0;
547
		return 0;
548
549
	}

550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
	/*
	 * If we have a negative record size, calculate it based on
	 * mem_sz / *cnt. If we have a positive record size, calculate
	 * cnt from mem_sz / record_size.
	 */
	if (record_size < 0) {
		if (*cnt == 0)
			return 0;
		record_size = mem_sz / *cnt;
		if (record_size == 0)
			goto fail;
	} else {
		*cnt = mem_sz / record_size;
		if (*cnt == 0)
			goto fail;
	}
566

567
568
569
570
571
	if (*paddr + mem_sz - cxt->phys_addr > cxt->size) {
		dev_err(dev, "no room for mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
			mem_sz, (unsigned long long)*paddr,
			cxt->size, (unsigned long long)cxt->phys_addr);
		goto fail;
572
573
	}

574
575
576
577
578
579
580
581
582
583
	zone_sz = mem_sz / *cnt;
	if (!zone_sz)
		goto fail;

	prz_ar = kcalloc(*cnt, sizeof(**przs), GFP_KERNEL);
	if (!prz_ar)
		goto fail;

	for (i = 0; i < *cnt; i++) {
		prz_ar[i] = persistent_ram_new(*paddr, zone_sz, sig,
584
						  &cxt->ecc_info,
585
586
587
						  cxt->memtype, flags);
		if (IS_ERR(prz_ar[i])) {
			err = PTR_ERR(prz_ar[i]);
588
			dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
589
				record_size, (unsigned long long)*paddr, err);
590
591
592

			while (i > 0) {
				i--;
593
				persistent_ram_free(prz_ar[i]);
594
			}
595
596
			kfree(prz_ar);
			goto fail;
597
		}
598
		*paddr += zone_sz;
599
600
	}

601
	*przs = prz_ar;
602
	return 0;
603
604
605

fail:
	*cnt = 0;
606
607
608
	return err;
}

609
610
611
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)
612
613
614
615
{
	if (!sz)
		return 0;

616
617
618
619
	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);
620
		return -ENOMEM;
621
	}
622

623
624
	*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info,
				  cxt->memtype, 0);
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
	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;
}

640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
static int ramoops_parse_dt_size(struct platform_device *pdev,
				 const char *propname, u32 *value)
{
	u32 val32 = 0;
	int ret;

	ret = of_property_read_u32(pdev->dev.of_node, propname, &val32);
	if (ret < 0 && ret != -EINVAL) {
		dev_err(&pdev->dev, "failed to parse property %s: %d\n",
			propname, ret);
		return ret;
	}

	if (val32 > INT_MAX) {
		dev_err(&pdev->dev, "%s %u > INT_MAX\n", propname, val32);
		return -EOVERFLOW;
	}

	*value = val32;
	return 0;
}

static int ramoops_parse_dt(struct platform_device *pdev,
			    struct ramoops_platform_data *pdata)
{
	struct device_node *of_node = pdev->dev.of_node;
666
	struct resource *res;
667
668
669
670
671
	u32 value;
	int ret;

	dev_dbg(&pdev->dev, "using Device Tree\n");

672
673
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
674
		dev_err(&pdev->dev,
675
676
			"failed to locate DT /reserved-memory resource\n");
		return -EINVAL;
677
678
	}

679
680
	pdata->mem_size = resource_size(res);
	pdata->mem_address = res->start;
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
	pdata->mem_type = of_property_read_bool(of_node, "unbuffered");
	pdata->dump_oops = !of_property_read_bool(of_node, "no-dump-oops");

#define parse_size(name, field) {					\
		ret = ramoops_parse_dt_size(pdev, name, &value);	\
		if (ret < 0)						\
			return ret;					\
		field = value;						\
	}

	parse_size("record-size", pdata->record_size);
	parse_size("console-size", pdata->console_size);
	parse_size("ftrace-size", pdata->ftrace_size);
	parse_size("pmsg-size", pdata->pmsg_size);
	parse_size("ecc-size", pdata->ecc_info.ecc_size);
696
	parse_size("flags", pdata->flags);
697
698
699
700
701
702

#undef parse_size

	return 0;
}

703
static int ramoops_probe(struct platform_device *pdev)
704
{
705
	struct device *dev = &pdev->dev;
706
	struct ramoops_platform_data *pdata = dev->platform_data;
707
	struct ramoops_context *cxt = &oops_cxt;
708
709
	size_t dump_mem_sz;
	phys_addr_t paddr;
710
711
	int err = -EINVAL;

712
713
714
715
716
717
718
719
720
721
722
723
	if (dev_of_node(dev) && !pdata) {
		pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
		if (!pdata) {
			err = -ENOMEM;
			goto fail_out;
		}

		err = ramoops_parse_dt(pdev, pdata);
		if (err < 0)
			goto fail_out;
	}

Kees Cook's avatar
Kees Cook committed
724
725
726
	/* Only a single ramoops area allowed at a time, so fail extra
	 * probes.
	 */
727
	if (cxt->max_dump_cnt)
Kees Cook's avatar
Kees Cook committed
728
729
		goto fail_out;

730
	if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
731
			!pdata->ftrace_size && !pdata->pmsg_size)) {
732
		pr_err("The memory size and the record/console size must be "
733
			"non-zero\n");
Kees Cook's avatar
Kees Cook committed
734
		goto fail_out;
735
736
	}

737
	if (pdata->record_size && !is_power_of_2(pdata->record_size))
738
		pdata->record_size = rounddown_pow_of_two(pdata->record_size);
739
	if (pdata->console_size && !is_power_of_2(pdata->console_size))
740
		pdata->console_size = rounddown_pow_of_two(pdata->console_size);
741
	if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
742
		pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
743
744
	if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
		pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
745

746
747
	cxt->size = pdata->mem_size;
	cxt->phys_addr = pdata->mem_address;
748
	cxt->memtype = pdata->mem_type;
749
	cxt->record_size = pdata->record_size;
750
	cxt->console_size = pdata->console_size;
751
	cxt->ftrace_size = pdata->ftrace_size;
752
	cxt->pmsg_size = pdata->pmsg_size;
753
	cxt->dump_oops = pdata->dump_oops;
754
	cxt->flags = pdata->flags;
755
	cxt->ecc_info = pdata->ecc_info;
756

757
	paddr = cxt->phys_addr;
758

759
760
	dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size
			- cxt->pmsg_size;
761
762
	err = ramoops_init_przs(dev, cxt, &cxt->przs, &paddr, dump_mem_sz,
				cxt->record_size, &cxt->max_dump_cnt, 0, 0);
763
764
765
	if (err)
		goto fail_out;

766
767
	err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr,
			       cxt->console_size, 0);
768
769
770
	if (err)
		goto fail_init_cprz;

771
772
773
774
775
776
777
778
	cxt->max_ftrace_cnt = (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
				? nr_cpu_ids
				: 1;
	err = ramoops_init_przs(dev, cxt, &cxt->fprzs, &paddr, cxt->ftrace_size,
				-1, &cxt->max_ftrace_cnt,
				LINUX_VERSION_CODE,
				(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
					? PRZ_FLAG_NO_LOCK : 0);
779
780
781
	if (err)
		goto fail_init_fprz;

782
783
784
785
	err = ramoops_init_prz(dev, cxt, &cxt->mprz, &paddr, cxt->pmsg_size, 0);
	if (err)
		goto fail_init_mprz;

Kees Cook's avatar
Kees Cook committed
786
	cxt->pstore.data = cxt;
787
	/*
788
789
790
791
	 * 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).
792
	 */
793
794
795
	if (cxt->console_size)
		cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */
	cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize);
Kees Cook's avatar
Kees Cook committed
796
797
798
	cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
	if (!cxt->pstore.buf) {
		pr_err("cannot allocate pstore buffer\n");
799
		err = -ENOMEM;
Kees Cook's avatar
Kees Cook committed
800
801
		goto fail_clear;
	}
802
	spin_lock_init(&cxt->pstore.buf_lock);
Kees Cook's avatar
Kees Cook committed
803

804
805
806
807
808
809
810
	cxt->pstore.flags = PSTORE_FLAGS_DMESG;
	if (cxt->console_size)
		cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE;
	if (cxt->ftrace_size)
		cxt->pstore.flags |= PSTORE_FLAGS_FTRACE;
	if (cxt->pmsg_size)
		cxt->pstore.flags |= PSTORE_FLAGS_PMSG;
811

Kees Cook's avatar
Kees Cook committed
812
	err = pstore_register(&cxt->pstore);
813
	if (err) {
Kees Cook's avatar
Kees Cook committed
814
		pr_err("registering with pstore failed\n");
815
		goto fail_buf;
816
817
	}

818
819
820
821
822
823
824
825
	/*
	 * 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;
826
827
828
	ramoops_console_size = pdata->console_size;
	ramoops_pmsg_size = pdata->pmsg_size;
	ramoops_ftrace_size = pdata->ftrace_size;
829

830
	pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n",
831
		cxt->size, (unsigned long long)cxt->phys_addr,
832
		cxt->ecc_info.ecc_size, cxt->ecc_info.block_size);
Kees Cook's avatar
Kees Cook committed
833

834
835
	return 0;

Kees Cook's avatar
Kees Cook committed
836
837
838
839
fail_buf:
	kfree(cxt->pstore.buf);
fail_clear:
	cxt->pstore.bufsize = 0;
840
	persistent_ram_free(cxt->mprz);
841
fail_init_mprz:
842
fail_init_fprz:
843
	persistent_ram_free(cxt->cprz);
844
fail_init_cprz:
845
	ramoops_free_przs(cxt);
Kees Cook's avatar
Kees Cook committed
846
fail_out:
847
848
849
	return err;
}

Geliang Tang's avatar
Geliang Tang committed
850
static int ramoops_remove(struct platform_device *pdev)
851
852
853
{
	struct ramoops_context *cxt = &oops_cxt;

Geliang Tang's avatar
Geliang Tang committed
854
	pstore_unregister(&cxt->pstore);
Kees Cook's avatar
Kees Cook committed
855
856
857
858

	kfree(cxt->pstore.buf);
	cxt->pstore.bufsize = 0;

Geliang Tang's avatar
Geliang Tang committed
859
860
861
862
	persistent_ram_free(cxt->mprz);
	persistent_ram_free(cxt->cprz);
	ramoops_free_przs(cxt);

863
	return 0;
864
865
}

866
867
868
869
870
static const struct of_device_id dt_match[] = {
	{ .compatible = "ramoops" },
	{}
};

871
static struct platform_driver ramoops_driver = {
872
	.probe		= ramoops_probe,
Geliang Tang's avatar
Geliang Tang committed
873
	.remove		= ramoops_remove,
874
	.driver		= {
875
876
		.name		= "ramoops",
		.of_match_table	= dt_match,
877
878
879
	},
};

880
static void ramoops_register_dummy(void)
881
{
882
883
884
885
886
887
888
889
890
	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;
891
892
	}

893
894
	dummy_data->mem_size = mem_size;
	dummy_data->mem_address = mem_address;
895
	dummy_data->mem_type = mem_type;
896
897
	dummy_data->record_size = record_size;
	dummy_data->console_size = ramoops_console_size;
898
	dummy_data->ftrace_size = ramoops_ftrace_size;
899
	dummy_data->pmsg_size = ramoops_pmsg_size;
900
	dummy_data->dump_oops = dump_oops;
901
902
	dummy_data->flags = RAMOOPS_FLAG_FTRACE_PER_CPU;

903
904
905
906
	/*
	 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
	 * (using 1 byte for ECC isn't much of use anyway).
	 */
907
	dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
908
909
910
911
912
913
914
915
916
917
918
919
920

	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);
921
}
922
postcore_initcall(ramoops_init);
923
924
925
926

static void __exit ramoops_exit(void)
{
	platform_driver_unregister(&ramoops_driver);
927
	platform_device_unregister(dummy);
928
	kfree(dummy_data);
929
}
930
931
932
933
934
module_exit(ramoops_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");