ram.c 24 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
#include <linux/io.h>
#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>
36
37
#include <linux/of.h>
#include <linux/of_address.h>
38
39

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

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

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

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

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

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

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

74
75
76
77
78
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
79
80
81
static int ramoops_ecc;
module_param_named(ecc, ramoops_ecc, int, 0600);
MODULE_PARM_DESC(ramoops_ecc,
82
83
84
		"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
85

Kees Cook's avatar
Kees Cook committed
86
struct ramoops_context {
87
88
89
90
	struct persistent_ram_zone **dprzs;	/* Oops dump zones */
	struct persistent_ram_zone *cprz;	/* Console zone */
	struct persistent_ram_zone **fprzs;	/* Ftrace zones */
	struct persistent_ram_zone *mprz;	/* PMSG zone */
91
92
	phys_addr_t phys_addr;
	unsigned long size;
93
	unsigned int memtype;
Kees Cook's avatar
Kees Cook committed
94
	size_t record_size;
95
	size_t console_size;
96
	size_t ftrace_size;
97
	size_t pmsg_size;
98
	int dump_oops;
99
	u32 flags;
100
	struct persistent_ram_ecc_info ecc_info;
101
102
	unsigned int max_dump_cnt;
	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;
Kees Cook's avatar
Kees Cook committed
109
110
	struct pstore_info pstore;
};
111

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

Kees Cook's avatar
Kees Cook committed
115
116
117
118
static int ramoops_pstore_open(struct pstore_info *psi)
{
	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;
Kees Cook's avatar
Kees Cook committed
123
124
125
	return 0;
}

126
127
128
129
130
131
132
133
134
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)++;

135
136
	/* Give up if we never existed or have hit the end. */
	if (!przs || i >= max)
137
138
139
		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;
}

237
static ssize_t ramoops_pstore_read(struct pstore_record *record)
238
{
239
	ssize_t size = 0;
240
	struct ramoops_context *cxt = record->psi->data;
241
242
	struct persistent_ram_zone *prz = NULL;
	int header_length = 0;
243
	bool free_prz = false;
244

245
246
	/*
	 * Ramoops headers provide time stamps for PSTORE_TYPE_DMESG, but
247
248
249
	 * PSTORE_TYPE_CONSOLE and PSTORE_TYPE_FTRACE don't currently have
	 * valid time stamps, so it is initialized to zero.
	 */
250
251
252
	record->time.tv_sec = 0;
	record->time.tv_nsec = 0;
	record->compressed = false;
253
254
255

	/* Find the next valid persistent_ram_zone for DMESG */
	while (cxt->dump_read_cnt < cxt->max_dump_cnt && !prz) {
256
		prz = ramoops_get_next_prz(cxt->dprzs, &cxt->dump_read_cnt,
257
258
					   cxt->max_dump_cnt, &record->id,
					   &record->type,
259
260
261
262
					   PSTORE_TYPE_DMESG, 1);
		if (!prz_ok(prz))
			continue;
		header_length = ramoops_read_kmsg_hdr(persistent_ram_old(prz),
263
264
						      &record->time,
						      &record->compressed);
265
266
267
268
269
270
271
		/* 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
272

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

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

	/* ftrace is last since it may want to dynamically allocate memory. */
284
	if (!prz_ok(prz)) {
285
		if (!(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)) {
286
			prz = ramoops_get_next_prz(cxt->fprzs,
287
288
					&cxt->ftrace_read_cnt, 1, &record->id,
					&record->type, PSTORE_TYPE_FTRACE, 0);
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
		} 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,
305
306
307
308
						cxt->max_ftrace_cnt,
						&record->id,
						&record->type,
						PSTORE_TYPE_FTRACE, 0);
309
310
311
312
313
314
315
316
317
318
319
320

				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;
			}
321
			record->id = 0;
322
			prz = tmp_prz;
323
324
325
		}
	}

326
327
328
329
	if (!prz_ok(prz)) {
		size = 0;
		goto out;
	}
330

331
	size = persistent_ram_old_size(prz) - header_length;
332
333

	/* ECC correction notice */
334
	record->ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0);
335

336
337
	record->buf = kmalloc(size + record->ecc_notice_size + 1, GFP_KERNEL);
	if (record->buf == NULL) {
338
339
340
		size = -ENOMEM;
		goto out;
	}
Kees Cook's avatar
Kees Cook committed
341

342
343
	memcpy(record->buf, (char *)persistent_ram_old(prz) + header_length,
	       size);
344

345
346
	persistent_ram_ecc_string(prz, record->buf + size,
				  record->ecc_notice_size + 1);
347

348
349
350
351
352
353
out:
	if (free_prz) {
		kfree(prz->old_log);
		kfree(prz);
	}

354
	return size;
Kees Cook's avatar
Kees Cook committed
355
356
}

357
static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
358
				     struct pstore_record *record)
359
360
361
362
{
	char *hdr;
	size_t len;

363
	hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n",
364
365
366
		record->time.tv_sec,
		record->time.tv_nsec / 1000,
		record->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
static int notrace ramoops_pstore_write(struct pstore_record *record)
Kees Cook's avatar
Kees Cook committed
376
{
377
	struct ramoops_context *cxt = record->psi->data;
378
	struct persistent_ram_zone *prz;
379
	size_t size, hlen;
Kees Cook's avatar
Kees Cook committed
380

381
	if (record->type == PSTORE_TYPE_CONSOLE) {
382
383
		if (!cxt->cprz)
			return -ENOMEM;
384
		persistent_ram_write(cxt->cprz, record->buf, record->size);
385
		return 0;
386
	} else if (record->type == PSTORE_TYPE_FTRACE) {
387
388
389
		int zonenum;

		if (!cxt->fprzs)
390
			return -ENOMEM;
391
392
393
394
395
396
397
398
		/*
		 * 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;

399
400
		persistent_ram_write(cxt->fprzs[zonenum], record->buf,
				     record->size);
401
		return 0;
402
	} else if (record->type == PSTORE_TYPE_PMSG) {
403
404
		pr_warn_ratelimited("PMSG shouldn't call %s\n", __func__);
		return -EINVAL;
405
406
	}

407
	if (record->type != PSTORE_TYPE_DMESG)
Kees Cook's avatar
Kees Cook committed
408
		return -EINVAL;
409

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

Kees Cook's avatar
Kees Cook committed
418
	/* Skip Oopes when configured to do so. */
419
	if (record->reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
Kees Cook's avatar
Kees Cook committed
420
421
		return -EINVAL;

422
423
	/*
	 * Explicitly only take the first part of any new crash.
Kees Cook's avatar
Kees Cook committed
424
425
426
427
	 * 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.
	 */
428
	if (record->part != 1)
Kees Cook's avatar
Kees Cook committed
429
		return -ENOSPC;
430

431
	if (!cxt->dprzs)
432
433
		return -ENOSPC;

434
	prz = cxt->dprzs[cxt->dump_write_cnt];
435

436
	/* Build header and append record contents. */
437
	hlen = ramoops_write_kmsg_hdr(prz, record);
438
	size = record->size;
439
440
	if (size + hlen > prz->buffer_size)
		size = prz->buffer_size - hlen;
441
	persistent_ram_write(prz, record->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;
}

448
449
static int notrace ramoops_pstore_write_user(struct pstore_record *record,
					     const char __user *buf)
Mark Salyzyn's avatar
Mark Salyzyn committed
450
{
451
452
	if (record->type == PSTORE_TYPE_PMSG) {
		struct ramoops_context *cxt = record->psi->data;
Mark Salyzyn's avatar
Mark Salyzyn committed
453
454
455

		if (!cxt->mprz)
			return -ENOMEM;
456
		return persistent_ram_write_user(cxt->mprz, buf, record->size);
Mark Salyzyn's avatar
Mark Salyzyn committed
457
458
459
460
461
	}

	return -EINVAL;
}

462
static int ramoops_pstore_erase(struct pstore_record *record)
Kees Cook's avatar
Kees Cook committed
463
{
464
	struct ramoops_context *cxt = record->psi->data;
465
	struct persistent_ram_zone *prz;
Kees Cook's avatar
Kees Cook committed
466

467
	switch (record->type) {
468
	case PSTORE_TYPE_DMESG:
469
		if (record->id >= cxt->max_dump_cnt)
470
			return -EINVAL;
471
		prz = cxt->dprzs[record->id];
472
473
474
475
		break;
	case PSTORE_TYPE_CONSOLE:
		prz = cxt->cprz;
		break;
476
	case PSTORE_TYPE_FTRACE:
477
		if (record->id >= cxt->max_ftrace_cnt)
478
			return -EINVAL;
479
		prz = cxt->fprzs[record->id];
480
		break;
481
482
483
	case PSTORE_TYPE_PMSG:
		prz = cxt->mprz;
		break;
484
	default:
Kees Cook's avatar
Kees Cook committed
485
		return -EINVAL;
486
	}
Kees Cook's avatar
Kees Cook committed
487

488
489
	persistent_ram_free_old(prz);
	persistent_ram_zap(prz);
Kees Cook's avatar
Kees Cook committed
490
491

	return 0;
492
493
}

Kees Cook's avatar
Kees Cook committed
494
495
496
497
498
499
static struct ramoops_context oops_cxt = {
	.pstore = {
		.owner	= THIS_MODULE,
		.name	= "ramoops",
		.open	= ramoops_pstore_open,
		.read	= ramoops_pstore_read,
500
501
		.write	= ramoops_pstore_write,
		.write_user	= ramoops_pstore_write_user,
Kees Cook's avatar
Kees Cook committed
502
503
504
505
		.erase	= ramoops_pstore_erase,
	},
};

506
507
508
509
static void ramoops_free_przs(struct ramoops_context *cxt)
{
	int i;

510
	/* Free dump PRZs */
511
	if (cxt->dprzs) {
512
		for (i = 0; i < cxt->max_dump_cnt; i++)
513
			persistent_ram_free(cxt->dprzs[i]);
514

515
		kfree(cxt->dprzs);
516
517
		cxt->max_dump_cnt = 0;
	}
518

519
520
521
522
523
524
525
	/* 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;
	}
526
527
}

528
529
static int ramoops_init_przs(const char *name,
			     struct device *dev, struct ramoops_context *cxt,
530
531
532
533
			     struct persistent_ram_zone ***przs,
			     phys_addr_t *paddr, size_t mem_sz,
			     ssize_t record_size,
			     unsigned int *cnt, u32 sig, u32 flags)
534
535
536
{
	int err = -ENOMEM;
	int i;
537
538
	size_t zone_sz;
	struct persistent_ram_zone **prz_ar;
539

540
541
542
	/* Allocate nothing for 0 mem_sz or 0 record_size. */
	if (mem_sz == 0 || record_size == 0) {
		*cnt = 0;
543
		return 0;
544
545
	}

546
547
548
549
550
551
552
553
554
	/*
	 * 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;
555
556
557
		if (record_size == 0) {
			dev_err(dev, "%s record size == 0 (%zu / %u)\n",
				name, mem_sz, *cnt);
558
			goto fail;
559
		}
560
561
	} else {
		*cnt = mem_sz / record_size;
562
563
564
		if (*cnt == 0) {
			dev_err(dev, "%s record count == 0 (%zu / %zu)\n",
				name, mem_sz, record_size);
565
			goto fail;
566
		}
567
	}
568

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

577
	zone_sz = mem_sz / *cnt;
578
579
	if (!zone_sz) {
		dev_err(dev, "%s zone size == 0\n", name);
580
		goto fail;
581
	}
582
583
584
585
586
587
588

	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,
589
						  &cxt->ecc_info,
590
591
592
						  cxt->memtype, flags);
		if (IS_ERR(prz_ar[i])) {
			err = PTR_ERR(prz_ar[i]);
593
594
595
			dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
				name, record_size,
				(unsigned long long)*paddr, err);
596
597
598

			while (i > 0) {
				i--;
599
				persistent_ram_free(prz_ar[i]);
600
			}
601
602
			kfree(prz_ar);
			goto fail;
603
		}
604
		*paddr += zone_sz;
605
606
	}

607
	*przs = prz_ar;
608
	return 0;
609
610
611

fail:
	*cnt = 0;
612
613
614
	return err;
}

615
616
static int ramoops_init_prz(const char *name,
			    struct device *dev, struct ramoops_context *cxt,
617
618
			    struct persistent_ram_zone **prz,
			    phys_addr_t *paddr, size_t sz, u32 sig)
619
620
621
622
{
	if (!sz)
		return 0;

623
	if (*paddr + sz - cxt->phys_addr > cxt->size) {
624
625
		dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
			name, sz, (unsigned long long)*paddr,
626
			cxt->size, (unsigned long long)cxt->phys_addr);
627
		return -ENOMEM;
628
	}
629

630
631
	*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info,
				  cxt->memtype, 0);
632
633
634
	if (IS_ERR(*prz)) {
		int err = PTR_ERR(*prz);

635
636
		dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
			name, sz, (unsigned long long)*paddr, err);
637
638
639
640
641
642
643
644
645
646
		return err;
	}

	persistent_ram_zap(*prz);

	*paddr += sz;

	return 0;
}

647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
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;
673
	struct resource *res;
674
675
676
677
678
	u32 value;
	int ret;

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

679
680
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
681
		dev_err(&pdev->dev,
682
683
			"failed to locate DT /reserved-memory resource\n");
		return -EINVAL;
684
685
	}

686
687
	pdata->mem_size = resource_size(res);
	pdata->mem_address = res->start;
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
	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);
703
	parse_size("flags", pdata->flags);
704
705
706
707
708
709

#undef parse_size

	return 0;
}

710
static int ramoops_probe(struct platform_device *pdev)
711
{
712
	struct device *dev = &pdev->dev;
713
	struct ramoops_platform_data *pdata = dev->platform_data;
714
	struct ramoops_context *cxt = &oops_cxt;
715
716
	size_t dump_mem_sz;
	phys_addr_t paddr;
717
718
	int err = -EINVAL;

719
720
721
	if (dev_of_node(dev) && !pdata) {
		pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
		if (!pdata) {
722
			pr_err("cannot allocate platform data buffer\n");
723
724
725
726
727
728
729
730
731
			err = -ENOMEM;
			goto fail_out;
		}

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

732
733
	/*
	 * Only a single ramoops area allowed at a time, so fail extra
Kees Cook's avatar
Kees Cook committed
734
735
	 * probes.
	 */
736
737
	if (cxt->max_dump_cnt) {
		pr_err("already initialized\n");
Kees Cook's avatar
Kees Cook committed
738
		goto fail_out;
739
740
741
742
743
744
745
	}

	/* Make sure we didn't get bogus platform data pointer. */
	if (!pdata) {
		pr_err("NULL platform data\n");
		goto fail_out;
	}
Kees Cook's avatar
Kees Cook committed
746

747
	if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
748
			!pdata->ftrace_size && !pdata->pmsg_size)) {
749
		pr_err("The memory size and the record/console size must be "
750
			"non-zero\n");
Kees Cook's avatar
Kees Cook committed
751
		goto fail_out;
752
753
	}

754
	if (pdata->record_size && !is_power_of_2(pdata->record_size))
755
		pdata->record_size = rounddown_pow_of_two(pdata->record_size);
756
	if (pdata->console_size && !is_power_of_2(pdata->console_size))
757
		pdata->console_size = rounddown_pow_of_two(pdata->console_size);
758
	if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
759
		pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
760
761
	if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
		pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
762

763
764
	cxt->size = pdata->mem_size;
	cxt->phys_addr = pdata->mem_address;
765
	cxt->memtype = pdata->mem_type;
766
	cxt->record_size = pdata->record_size;
767
	cxt->console_size = pdata->console_size;
768
	cxt->ftrace_size = pdata->ftrace_size;
769
	cxt->pmsg_size = pdata->pmsg_size;
770
	cxt->dump_oops = pdata->dump_oops;
771
	cxt->flags = pdata->flags;
772
	cxt->ecc_info = pdata->ecc_info;
773

774
	paddr = cxt->phys_addr;
775

776
777
	dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size
			- cxt->pmsg_size;
778
	err = ramoops_init_przs("dump", dev, cxt, &cxt->dprzs, &paddr,
779
780
				dump_mem_sz, cxt->record_size,
				&cxt->max_dump_cnt, 0, 0);
781
782
783
	if (err)
		goto fail_out;

784
	err = ramoops_init_prz("console", dev, cxt, &cxt->cprz, &paddr,
785
			       cxt->console_size, 0);
786
787
788
	if (err)
		goto fail_init_cprz;

789
790
791
	cxt->max_ftrace_cnt = (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
				? nr_cpu_ids
				: 1;
792
793
794
	err = ramoops_init_przs("ftrace", dev, cxt, &cxt->fprzs, &paddr,
				cxt->ftrace_size, -1,
				&cxt->max_ftrace_cnt, LINUX_VERSION_CODE,
795
796
				(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
					? PRZ_FLAG_NO_LOCK : 0);
797
798
799
	if (err)
		goto fail_init_fprz;

800
801
	err = ramoops_init_prz("pmsg", dev, cxt, &cxt->mprz, &paddr,
				cxt->pmsg_size, 0);
802
803
804
	if (err)
		goto fail_init_mprz;

Kees Cook's avatar
Kees Cook committed
805
	cxt->pstore.data = cxt;
806
	/*
807
808
809
	 * Since bufsize is only used for dmesg crash dumps, it
	 * must match the size of the dprz record (after PRZ header
	 * and ECC bytes have been accounted for).
810
	 */
811
812
	cxt->pstore.bufsize = cxt->dprzs[0]->buffer_size;
	cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL);
Kees Cook's avatar
Kees Cook committed
813
	if (!cxt->pstore.buf) {
814
		pr_err("cannot allocate pstore crash dump buffer\n");
815
		err = -ENOMEM;
Kees Cook's avatar
Kees Cook committed
816
817
		goto fail_clear;
	}
818
	spin_lock_init(&cxt->pstore.buf_lock);
Kees Cook's avatar
Kees Cook committed
819

820
821
822
823
824
825
826
	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;
827

Kees Cook's avatar
Kees Cook committed
828
	err = pstore_register(&cxt->pstore);
829
	if (err) {
Kees Cook's avatar
Kees Cook committed
830
		pr_err("registering with pstore failed\n");
831
		goto fail_buf;
832
833
	}

834
835
836
837
838
839
840
841
	/*
	 * 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;
842
843
844
	ramoops_console_size = pdata->console_size;
	ramoops_pmsg_size = pdata->pmsg_size;
	ramoops_ftrace_size = pdata->ftrace_size;
845

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

850
851
	return 0;

Kees Cook's avatar
Kees Cook committed
852
853
854
855
fail_buf:
	kfree(cxt->pstore.buf);
fail_clear:
	cxt->pstore.bufsize = 0;
856
	persistent_ram_free(cxt->mprz);
857
fail_init_mprz:
858
fail_init_fprz:
859
	persistent_ram_free(cxt->cprz);
860
fail_init_cprz:
861
	ramoops_free_przs(cxt);
Kees Cook's avatar
Kees Cook committed
862
fail_out:
863
864
865
	return err;
}

Geliang Tang's avatar
Geliang Tang committed
866
static int ramoops_remove(struct platform_device *pdev)
867
868
869
{
	struct ramoops_context *cxt = &oops_cxt;

Geliang Tang's avatar
Geliang Tang committed
870
	pstore_unregister(&cxt->pstore);
Kees Cook's avatar
Kees Cook committed
871
872
873
874

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

Geliang Tang's avatar
Geliang Tang committed
875
876
877
878
	persistent_ram_free(cxt->mprz);
	persistent_ram_free(cxt->cprz);
	ramoops_free_przs(cxt);

879
	return 0;
880
881
}

882
883
884
885
886
static const struct of_device_id dt_match[] = {
	{ .compatible = "ramoops" },
	{}
};

887
static struct platform_driver ramoops_driver = {
888
	.probe		= ramoops_probe,
Geliang Tang's avatar
Geliang Tang committed
889
	.remove		= ramoops_remove,
890
	.driver		= {
891
892
		.name		= "ramoops",
		.of_match_table	= dt_match,
893
894
895
	},
};

896
static void ramoops_register_dummy(void)
897
{
898
899
900
901
902
903
904
905
906
	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;
907
908
	}

909
910
	dummy_data->mem_size = mem_size;
	dummy_data->mem_address = mem_address;
911
	dummy_data->mem_type = mem_type;
912
913
	dummy_data->record_size = record_size;
	dummy_data->console_size = ramoops_console_size;
914
	dummy_data->ftrace_size = ramoops_ftrace_size;
915
	dummy_data->pmsg_size = ramoops_pmsg_size;
916
	dummy_data->dump_oops = dump_oops;
917
918
	dummy_data->flags = RAMOOPS_FLAG_FTRACE_PER_CPU;

919
920
921
922
	/*
	 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
	 * (using 1 byte for ECC isn't much of use anyway).
	 */
923
	dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
924
925
926
927
928
929
930
931
932
933
934
935
936

	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);
937
}
938
postcore_initcall(ramoops_init);
939
940
941
942

static void __exit ramoops_exit(void)
{
	platform_driver_unregister(&ramoops_driver);
943
	platform_device_unregister(dummy);
944
	kfree(dummy_data);
945
}
946
947
948
949
950
module_exit(ramoops_exit);

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