ram.c 24.4 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
89
90
91
	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 */
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
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)++;

136
137
	/* Give up if we never existed or have hit the end. */
	if (!przs || i >= max)
138
139
140
		return NULL;

	prz = przs[i];
141
142
	if (!prz)
		return NULL;
143

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

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

	*typep = type;
	*id = i;

	return prz;
}

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

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

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

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
237
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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

358
359
static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
				     bool compressed)
360
361
{
	char *hdr;
362
	struct timespec timestamp;
363
364
	size_t len;

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

	return len;
}

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

392
393
394
	if (type == PSTORE_TYPE_CONSOLE) {
		if (!cxt->cprz)
			return -ENOMEM;
395
		persistent_ram_write(cxt->cprz, buf, size);
396
		return 0;
397
	} else if (type == PSTORE_TYPE_FTRACE) {
398
399
400
		int zonenum;

		if (!cxt->fprzs)
401
			return -ENOMEM;
402
403
404
405
406
407
408
409
410
		/*
		 * 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);
411
		return 0;
412
	} else if (type == PSTORE_TYPE_PMSG) {
413
414
		pr_warn_ratelimited("PMSG shouldn't call %s\n", __func__);
		return -EINVAL;
415
416
	}

Kees Cook's avatar
Kees Cook committed
417
418
	if (type != PSTORE_TYPE_DMESG)
		return -EINVAL;
419

Kees Cook's avatar
Kees Cook committed
420
421
422
	/* Out of the various dmesg dump types, ramoops is currently designed
	 * to only store crash logs, rather than storing general kernel logs.
	 */
423
	if (reason != KMSG_DUMP_OOPS &&
WANG Cong's avatar
WANG Cong committed
424
	    reason != KMSG_DUMP_PANIC)
Kees Cook's avatar
Kees Cook committed
425
		return -EINVAL;
426

Kees Cook's avatar
Kees Cook committed
427
	/* Skip Oopes when configured to do so. */
428
	if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
Kees Cook's avatar
Kees Cook committed
429
430
431
432
433
434
435
436
437
		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;
438

439
	if (!cxt->dprzs)
440
441
		return -ENOSPC;

442
	prz = cxt->dprzs[cxt->dump_write_cnt];
443

444
	hlen = ramoops_write_kmsg_hdr(prz, compressed);
445
446
	if (size + hlen > prz->buffer_size)
		size = prz->buffer_size - hlen;
447
	persistent_ram_write(prz, buf, size);
448

449
	cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
Kees Cook's avatar
Kees Cook committed
450
451
452
453

	return 0;
}

Mark Salyzyn's avatar
Mark Salyzyn committed
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
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;
}

472
static int ramoops_pstore_erase(struct pstore_record *record)
Kees Cook's avatar
Kees Cook committed
473
{
474
	struct ramoops_context *cxt = record->psi->data;
475
	struct persistent_ram_zone *prz;
Kees Cook's avatar
Kees Cook committed
476

477
	switch (record->type) {
478
	case PSTORE_TYPE_DMESG:
479
		if (record->id >= cxt->max_dump_cnt)
480
			return -EINVAL;
481
		prz = cxt->dprzs[record->id];
482
483
484
485
		break;
	case PSTORE_TYPE_CONSOLE:
		prz = cxt->cprz;
		break;
486
	case PSTORE_TYPE_FTRACE:
487
		if (record->id >= cxt->max_ftrace_cnt)
488
			return -EINVAL;
489
		prz = cxt->fprzs[record->id];
490
		break;
491
492
493
	case PSTORE_TYPE_PMSG:
		prz = cxt->mprz;
		break;
494
	default:
Kees Cook's avatar
Kees Cook committed
495
		return -EINVAL;
496
	}
Kees Cook's avatar
Kees Cook committed
497

498
499
	persistent_ram_free_old(prz);
	persistent_ram_zap(prz);
Kees Cook's avatar
Kees Cook committed
500
501

	return 0;
502
503
}

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

516
517
518
519
static void ramoops_free_przs(struct ramoops_context *cxt)
{
	int i;

520
	/* Free dump PRZs */
521
	if (cxt->dprzs) {
522
		for (i = 0; i < cxt->max_dump_cnt; i++)
523
			persistent_ram_free(cxt->dprzs[i]);
524

525
		kfree(cxt->dprzs);
526
527
		cxt->max_dump_cnt = 0;
	}
528

529
530
531
532
533
534
535
	/* 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;
	}
536
537
}

538
539
static int ramoops_init_przs(const char *name,
			     struct device *dev, struct ramoops_context *cxt,
540
541
542
543
			     struct persistent_ram_zone ***przs,
			     phys_addr_t *paddr, size_t mem_sz,
			     ssize_t record_size,
			     unsigned int *cnt, u32 sig, u32 flags)
544
545
546
{
	int err = -ENOMEM;
	int i;
547
548
	size_t zone_sz;
	struct persistent_ram_zone **prz_ar;
549

550
551
552
	/* Allocate nothing for 0 mem_sz or 0 record_size. */
	if (mem_sz == 0 || record_size == 0) {
		*cnt = 0;
553
		return 0;
554
555
	}

556
557
558
559
560
561
562
563
564
	/*
	 * 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;
565
566
567
		if (record_size == 0) {
			dev_err(dev, "%s record size == 0 (%zu / %u)\n",
				name, mem_sz, *cnt);
568
			goto fail;
569
		}
570
571
	} else {
		*cnt = mem_sz / record_size;
572
573
574
		if (*cnt == 0) {
			dev_err(dev, "%s record count == 0 (%zu / %zu)\n",
				name, mem_sz, record_size);
575
			goto fail;
576
		}
577
	}
578

579
	if (*paddr + mem_sz - cxt->phys_addr > cxt->size) {
580
581
		dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
			name,
582
583
584
			mem_sz, (unsigned long long)*paddr,
			cxt->size, (unsigned long long)cxt->phys_addr);
		goto fail;
585
586
	}

587
	zone_sz = mem_sz / *cnt;
588
589
	if (!zone_sz) {
		dev_err(dev, "%s zone size == 0\n", name);
590
		goto fail;
591
	}
592
593
594
595
596
597
598

	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,
599
						  &cxt->ecc_info,
600
601
602
						  cxt->memtype, flags);
		if (IS_ERR(prz_ar[i])) {
			err = PTR_ERR(prz_ar[i]);
603
604
605
			dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
				name, record_size,
				(unsigned long long)*paddr, err);
606
607
608

			while (i > 0) {
				i--;
609
				persistent_ram_free(prz_ar[i]);
610
			}
611
612
			kfree(prz_ar);
			goto fail;
613
		}
614
		*paddr += zone_sz;
615
616
	}

617
	*przs = prz_ar;
618
	return 0;
619
620
621

fail:
	*cnt = 0;
622
623
624
	return err;
}

625
626
static int ramoops_init_prz(const char *name,
			    struct device *dev, struct ramoops_context *cxt,
627
628
			    struct persistent_ram_zone **prz,
			    phys_addr_t *paddr, size_t sz, u32 sig)
629
630
631
632
{
	if (!sz)
		return 0;

633
	if (*paddr + sz - cxt->phys_addr > cxt->size) {
634
635
		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,
636
			cxt->size, (unsigned long long)cxt->phys_addr);
637
		return -ENOMEM;
638
	}
639

640
641
	*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info,
				  cxt->memtype, 0);
642
643
644
	if (IS_ERR(*prz)) {
		int err = PTR_ERR(*prz);

645
646
		dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
			name, sz, (unsigned long long)*paddr, err);
647
648
649
650
651
652
653
654
655
656
		return err;
	}

	persistent_ram_zap(*prz);

	*paddr += sz;

	return 0;
}

657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
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;
683
	struct resource *res;
684
685
686
687
688
	u32 value;
	int ret;

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

689
690
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
691
		dev_err(&pdev->dev,
692
693
			"failed to locate DT /reserved-memory resource\n");
		return -EINVAL;
694
695
	}

696
697
	pdata->mem_size = resource_size(res);
	pdata->mem_address = res->start;
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
	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);
713
	parse_size("flags", pdata->flags);
714
715
716
717
718
719

#undef parse_size

	return 0;
}

720
static int ramoops_probe(struct platform_device *pdev)
721
{
722
	struct device *dev = &pdev->dev;
723
	struct ramoops_platform_data *pdata = dev->platform_data;
724
	struct ramoops_context *cxt = &oops_cxt;
725
726
	size_t dump_mem_sz;
	phys_addr_t paddr;
727
728
	int err = -EINVAL;

729
730
731
	if (dev_of_node(dev) && !pdata) {
		pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
		if (!pdata) {
732
			pr_err("cannot allocate platform data buffer\n");
733
734
735
736
737
738
739
740
741
			err = -ENOMEM;
			goto fail_out;
		}

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

742
743
	/*
	 * Only a single ramoops area allowed at a time, so fail extra
Kees Cook's avatar
Kees Cook committed
744
745
	 * probes.
	 */
746
747
	if (cxt->max_dump_cnt) {
		pr_err("already initialized\n");
Kees Cook's avatar
Kees Cook committed
748
		goto fail_out;
749
750
751
752
753
754
755
	}

	/* 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
756

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 "
760
			"non-zero\n");
Kees Cook's avatar
Kees Cook committed
761
		goto fail_out;
762
763
	}

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
771
	if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
		pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
772

773
774
	cxt->size = pdata->mem_size;
	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;
783

784
	paddr = cxt->phys_addr;
785

786
787
	dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size
			- cxt->pmsg_size;
788
	err = ramoops_init_przs("dump", dev, cxt, &cxt->dprzs, &paddr,
789
790
				dump_mem_sz, cxt->record_size,
				&cxt->max_dump_cnt, 0, 0);
791
792
793
	if (err)
		goto fail_out;

794
	err = ramoops_init_prz("console", dev, cxt, &cxt->cprz, &paddr,
795
			       cxt->console_size, 0);
796
797
798
	if (err)
		goto fail_init_cprz;

799
800
801
	cxt->max_ftrace_cnt = (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
				? nr_cpu_ids
				: 1;
802
803
804
	err = ramoops_init_przs("ftrace", dev, cxt, &cxt->fprzs, &paddr,
				cxt->ftrace_size, -1,
				&cxt->max_ftrace_cnt, LINUX_VERSION_CODE,
805
806
				(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
					? PRZ_FLAG_NO_LOCK : 0);
807
808
809
	if (err)
		goto fail_init_fprz;

810
811
	err = ramoops_init_prz("pmsg", dev, cxt, &cxt->mprz, &paddr,
				cxt->pmsg_size, 0);
812
813
814
	if (err)
		goto fail_init_mprz;

Kees Cook's avatar
Kees Cook committed
815
	cxt->pstore.data = cxt;
816
	/*
817
818
819
820
	 * 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).
821
	 */
822
823
824
	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
825
826
827
	cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
	if (!cxt->pstore.buf) {
		pr_err("cannot allocate pstore buffer\n");
828
		err = -ENOMEM;
Kees Cook's avatar
Kees Cook committed
829
830
		goto fail_clear;
	}
831
	spin_lock_init(&cxt->pstore.buf_lock);
Kees Cook's avatar
Kees Cook committed
832

833
834
835
836
837
838
839
	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;
840

Kees Cook's avatar
Kees Cook committed
841
	err = pstore_register(&cxt->pstore);
842
	if (err) {
Kees Cook's avatar
Kees Cook committed
843
		pr_err("registering with pstore failed\n");
844
		goto fail_buf;
845
846
	}

847
848
849
850
851
852
853
854
	/*
	 * 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;
855
856
857
	ramoops_console_size = pdata->console_size;
	ramoops_pmsg_size = pdata->pmsg_size;
	ramoops_ftrace_size = pdata->ftrace_size;
858

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

863
864
	return 0;

Kees Cook's avatar
Kees Cook committed
865
866
867
868
fail_buf:
	kfree(cxt->pstore.buf);
fail_clear:
	cxt->pstore.bufsize = 0;
869
	persistent_ram_free(cxt->mprz);
870
fail_init_mprz:
871
fail_init_fprz:
872
	persistent_ram_free(cxt->cprz);
873
fail_init_cprz:
874
	ramoops_free_przs(cxt);
Kees Cook's avatar
Kees Cook committed
875
fail_out:
876
877
878
	return err;
}

Geliang Tang's avatar
Geliang Tang committed
879
static int ramoops_remove(struct platform_device *pdev)
880
881
882
{
	struct ramoops_context *cxt = &oops_cxt;

Geliang Tang's avatar
Geliang Tang committed
883
	pstore_unregister(&cxt->pstore);
Kees Cook's avatar
Kees Cook committed
884
885
886
887

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

Geliang Tang's avatar
Geliang Tang committed
888
889
890
891
	persistent_ram_free(cxt->mprz);
	persistent_ram_free(cxt->cprz);
	ramoops_free_przs(cxt);

892
	return 0;
893
894
}

895
896
897
898
899
static const struct of_device_id dt_match[] = {
	{ .compatible = "ramoops" },
	{}
};

900
static struct platform_driver ramoops_driver = {
901
	.probe		= ramoops_probe,
Geliang Tang's avatar
Geliang Tang committed
902
	.remove		= ramoops_remove,
903
	.driver		= {
904
905
		.name		= "ramoops",
		.of_match_table	= dt_match,
906
907
908
	},
};

909
static void ramoops_register_dummy(void)
910
{
911
912
913
914
915
916
917
918
919
	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;
920
921
	}

922
923
	dummy_data->mem_size = mem_size;
	dummy_data->mem_address = mem_address;
924
	dummy_data->mem_type = mem_type;
925
926
	dummy_data->record_size = record_size;
	dummy_data->console_size = ramoops_console_size;
927
	dummy_data->ftrace_size = ramoops_ftrace_size;
928
	dummy_data->pmsg_size = ramoops_pmsg_size;
929
	dummy_data->dump_oops = dump_oops;
930
931
	dummy_data->flags = RAMOOPS_FLAG_FTRACE_PER_CPU;

932
933
934
935
	/*
	 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
	 * (using 1 byte for ECC isn't much of use anyway).
	 */
936
	dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
937
938
939
940
941
942
943
944
945
946
947
948
949

	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);
950
}
951
postcore_initcall(ramoops_init);
952
953
954
955

static void __exit ramoops_exit(void)
{
	platform_driver_unregister(&ramoops_driver);
956
	platform_device_unregister(dummy);
957
	kfree(dummy_data);
958
}
959
960
961
962
963
module_exit(ramoops_exit);

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