ram.c 24.3 KB
Newer Older
1 2 3 4
/*
 * RAM Oops/Panic logger
 *
 * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
K
Kees Cook 已提交
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>
K
Kees Cook 已提交
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
#if __BITS_PER_LONG == 64
# define TVSEC_FMT "%ld"
#else
# define TVSEC_FMT "%lld"
#endif
46

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

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

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

60 61 62 63
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");

64
static unsigned long long mem_address;
65
module_param_hw(mem_address, ullong, other, 0400);
66 67 68 69 70 71 72 73
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");

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

79 80 81 82 83
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)");

A
Anton Vorontsov 已提交
84 85 86
static int ramoops_ecc;
module_param_named(ecc, ramoops_ecc, int, 0600);
MODULE_PARM_DESC(ramoops_ecc,
87 88 89
		"if non-zero, the option enables ECC support and specifies "
		"ECC buffer size in bytes (1 is a special value, means 16 "
		"bytes ECC)");
A
Anton Vorontsov 已提交
90

K
Kees Cook 已提交
91
struct ramoops_context {
92 93 94 95
	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 */
96 97
	phys_addr_t phys_addr;
	unsigned long size;
98
	unsigned int memtype;
K
Kees Cook 已提交
99
	size_t record_size;
100
	size_t console_size;
101
	size_t ftrace_size;
102
	size_t pmsg_size;
103
	int dump_oops;
104
	u32 flags;
105
	struct persistent_ram_ecc_info ecc_info;
106 107
	unsigned int max_dump_cnt;
	unsigned int dump_write_cnt;
108
	/* _read_cnt need clear on ramoops_pstore_open */
109
	unsigned int dump_read_cnt;
110
	unsigned int console_read_cnt;
111
	unsigned int max_ftrace_cnt;
112
	unsigned int ftrace_read_cnt;
113
	unsigned int pmsg_read_cnt;
K
Kees Cook 已提交
114 115
	struct pstore_info pstore;
};
116

117 118 119
static struct platform_device *dummy;
static struct ramoops_platform_data *dummy_data;

K
Kees Cook 已提交
120 121 122 123
static int ramoops_pstore_open(struct pstore_info *psi)
{
	struct ramoops_context *cxt = psi->data;

124
	cxt->dump_read_cnt = 0;
125
	cxt->console_read_cnt = 0;
126
	cxt->ftrace_read_cnt = 0;
127
	cxt->pmsg_read_cnt = 0;
K
Kees Cook 已提交
128 129 130
	return 0;
}

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)++;

140 141
	/* Give up if we never existed or have hit the end. */
	if (!przs || i >= max)
142 143 144
		return NULL;

	prz = przs[i];
145 146
	if (!prz)
		return NULL;
147

148 149
	/* Update old/shadowed buffer. */
	if (update)
150
		persistent_ram_save_old(prz);
151 152 153

	if (!persistent_ram_old_size(prz))
		return NULL;
154 155 156 157 158 159 160

	*typep = type;
	*id = i;

	return prz;
}

161
static int ramoops_read_kmsg_hdr(char *buffer, struct timespec64 *time,
162 163 164
				  bool *compressed)
{
	char data_type;
165
	int header_length = 0;
166

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

186 187 188 189 190 191
static bool prz_ok(struct persistent_ram_zone *prz)
{
	return !!prz && !!(persistent_ram_old_size(prz) +
			   persistent_ram_ecc_string(prz, NULL, 0));
}

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 238 239 240 241 242 243
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;
}

244
static ssize_t ramoops_pstore_read(struct pstore_record *record)
245
{
246
	ssize_t size = 0;
247
	struct ramoops_context *cxt = record->psi->data;
248 249
	struct persistent_ram_zone *prz = NULL;
	int header_length = 0;
250
	bool free_prz = false;
251

252 253
	/*
	 * Ramoops headers provide time stamps for PSTORE_TYPE_DMESG, but
254 255 256
	 * PSTORE_TYPE_CONSOLE and PSTORE_TYPE_FTRACE don't currently have
	 * valid time stamps, so it is initialized to zero.
	 */
257 258 259
	record->time.tv_sec = 0;
	record->time.tv_nsec = 0;
	record->compressed = false;
260 261 262

	/* Find the next valid persistent_ram_zone for DMESG */
	while (cxt->dump_read_cnt < cxt->max_dump_cnt && !prz) {
263
		prz = ramoops_get_next_prz(cxt->dprzs, &cxt->dump_read_cnt,
264 265
					   cxt->max_dump_cnt, &record->id,
					   &record->type,
266 267 268 269
					   PSTORE_TYPE_DMESG, 1);
		if (!prz_ok(prz))
			continue;
		header_length = ramoops_read_kmsg_hdr(persistent_ram_old(prz),
270 271
						      &record->time,
						      &record->compressed);
272 273 274 275 276 277 278
		/* 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;
		}
	}
K
Kees Cook 已提交
279

280
	if (!prz_ok(prz))
281
		prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt,
282 283
					   1, &record->id, &record->type,
					   PSTORE_TYPE_CONSOLE, 0);
284 285 286

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

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

				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;
			}
328
			record->id = 0;
329
			prz = tmp_prz;
330 331 332
		}
	}

333 334 335 336
	if (!prz_ok(prz)) {
		size = 0;
		goto out;
	}
337

338
	size = persistent_ram_old_size(prz) - header_length;
339 340

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

343 344
	record->buf = kmalloc(size + record->ecc_notice_size + 1, GFP_KERNEL);
	if (record->buf == NULL) {
345 346 347
		size = -ENOMEM;
		goto out;
	}
K
Kees Cook 已提交
348

349 350
	memcpy(record->buf, (char *)persistent_ram_old(prz) + header_length,
	       size);
351

352 353
	persistent_ram_ecc_string(prz, record->buf + size,
				  record->ecc_notice_size + 1);
354

355 356 357 358 359 360
out:
	if (free_prz) {
		kfree(prz->old_log);
		kfree(prz);
	}

361
	return size;
K
Kees Cook 已提交
362 363
}

364
static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
365
				     struct pstore_record *record)
366 367 368 369
{
	char *hdr;
	size_t len;

370
	hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR TVSEC_FMT ".%lu-%c\n",
371 372 373
		record->time.tv_sec,
		record->time.tv_nsec / 1000,
		record->compressed ? 'C' : 'D');
374 375 376 377 378 379 380 381
	WARN_ON_ONCE(!hdr);
	len = hdr ? strlen(hdr) : 0;
	persistent_ram_write(prz, hdr, len);
	kfree(hdr);

	return len;
}

K
Kees Cook 已提交
382
static int notrace ramoops_pstore_write(struct pstore_record *record)
K
Kees Cook 已提交
383
{
384
	struct ramoops_context *cxt = record->psi->data;
385
	struct persistent_ram_zone *prz;
386
	size_t size, hlen;
K
Kees Cook 已提交
387

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

		if (!cxt->fprzs)
397
			return -ENOMEM;
398 399 400 401 402 403 404 405
		/*
		 * 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;

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

414
	if (record->type != PSTORE_TYPE_DMESG)
K
Kees Cook 已提交
415
		return -EINVAL;
416

417 418
	/*
	 * Out of the various dmesg dump types, ramoops is currently designed
K
Kees Cook 已提交
419 420
	 * to only store crash logs, rather than storing general kernel logs.
	 */
421 422
	if (record->reason != KMSG_DUMP_OOPS &&
	    record->reason != KMSG_DUMP_PANIC)
K
Kees Cook 已提交
423
		return -EINVAL;
424

K
Kees Cook 已提交
425
	/* Skip Oopes when configured to do so. */
426
	if (record->reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
K
Kees Cook 已提交
427 428
		return -EINVAL;

429 430
	/*
	 * Explicitly only take the first part of any new crash.
K
Kees Cook 已提交
431 432 433 434
	 * 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.
	 */
435
	if (record->part != 1)
K
Kees Cook 已提交
436
		return -ENOSPC;
437

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

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

443
	/* Build header and append record contents. */
444
	hlen = ramoops_write_kmsg_hdr(prz, record);
445
	size = record->size;
446 447
	if (size + hlen > prz->buffer_size)
		size = prz->buffer_size - hlen;
448
	persistent_ram_write(prz, record->buf, size);
449

450
	cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
K
Kees Cook 已提交
451 452 453 454

	return 0;
}

K
Kees Cook 已提交
455 456
static int notrace ramoops_pstore_write_user(struct pstore_record *record,
					     const char __user *buf)
M
Mark Salyzyn 已提交
457
{
458 459
	if (record->type == PSTORE_TYPE_PMSG) {
		struct ramoops_context *cxt = record->psi->data;
M
Mark Salyzyn 已提交
460 461 462

		if (!cxt->mprz)
			return -ENOMEM;
463
		return persistent_ram_write_user(cxt->mprz, buf, record->size);
M
Mark Salyzyn 已提交
464 465 466 467 468
	}

	return -EINVAL;
}

469
static int ramoops_pstore_erase(struct pstore_record *record)
K
Kees Cook 已提交
470
{
471
	struct ramoops_context *cxt = record->psi->data;
472
	struct persistent_ram_zone *prz;
K
Kees Cook 已提交
473

474
	switch (record->type) {
475
	case PSTORE_TYPE_DMESG:
476
		if (record->id >= cxt->max_dump_cnt)
477
			return -EINVAL;
478
		prz = cxt->dprzs[record->id];
479 480 481 482
		break;
	case PSTORE_TYPE_CONSOLE:
		prz = cxt->cprz;
		break;
483
	case PSTORE_TYPE_FTRACE:
484
		if (record->id >= cxt->max_ftrace_cnt)
485
			return -EINVAL;
486
		prz = cxt->fprzs[record->id];
487
		break;
488 489 490
	case PSTORE_TYPE_PMSG:
		prz = cxt->mprz;
		break;
491
	default:
K
Kees Cook 已提交
492
		return -EINVAL;
493
	}
K
Kees Cook 已提交
494

495 496
	persistent_ram_free_old(prz);
	persistent_ram_zap(prz);
K
Kees Cook 已提交
497 498

	return 0;
499 500
}

K
Kees Cook 已提交
501 502 503 504 505 506
static struct ramoops_context oops_cxt = {
	.pstore = {
		.owner	= THIS_MODULE,
		.name	= "ramoops",
		.open	= ramoops_pstore_open,
		.read	= ramoops_pstore_read,
K
Kees Cook 已提交
507 508
		.write	= ramoops_pstore_write,
		.write_user	= ramoops_pstore_write_user,
K
Kees Cook 已提交
509 510 511 512
		.erase	= ramoops_pstore_erase,
	},
};

513 514 515 516
static void ramoops_free_przs(struct ramoops_context *cxt)
{
	int i;

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

522
		kfree(cxt->dprzs);
523 524
		cxt->max_dump_cnt = 0;
	}
525

526 527 528 529 530 531 532
	/* 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;
	}
533 534
}

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

547 548 549
	/* Allocate nothing for 0 mem_sz or 0 record_size. */
	if (mem_sz == 0 || record_size == 0) {
		*cnt = 0;
550
		return 0;
551 552
	}

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

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

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

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

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

614
	*przs = prz_ar;
615
	return 0;
616 617 618

fail:
	*cnt = 0;
619 620 621
	return err;
}

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

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

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

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

	persistent_ram_zap(*prz);

	*paddr += sz;

	return 0;
}

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

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

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

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

#undef parse_size

	return 0;
}

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

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

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

739 740
	/*
	 * Only a single ramoops area allowed at a time, so fail extra
K
Kees Cook 已提交
741 742
	 * probes.
	 */
743 744
	if (cxt->max_dump_cnt) {
		pr_err("already initialized\n");
K
Kees Cook 已提交
745
		goto fail_out;
746 747 748 749 750 751 752
	}

	/* Make sure we didn't get bogus platform data pointer. */
	if (!pdata) {
		pr_err("NULL platform data\n");
		goto fail_out;
	}
K
Kees Cook 已提交
753

754
	if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
755
			!pdata->ftrace_size && !pdata->pmsg_size)) {
756
		pr_err("The memory size and the record/console size must be "
757
			"non-zero\n");
K
Kees Cook 已提交
758
		goto fail_out;
759 760
	}

761
	if (pdata->record_size && !is_power_of_2(pdata->record_size))
762
		pdata->record_size = rounddown_pow_of_two(pdata->record_size);
763
	if (pdata->console_size && !is_power_of_2(pdata->console_size))
764
		pdata->console_size = rounddown_pow_of_two(pdata->console_size);
765
	if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
766
		pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
767 768
	if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
		pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
769

770 771
	cxt->size = pdata->mem_size;
	cxt->phys_addr = pdata->mem_address;
772
	cxt->memtype = pdata->mem_type;
773
	cxt->record_size = pdata->record_size;
774
	cxt->console_size = pdata->console_size;
775
	cxt->ftrace_size = pdata->ftrace_size;
776
	cxt->pmsg_size = pdata->pmsg_size;
777
	cxt->dump_oops = pdata->dump_oops;
778
	cxt->flags = pdata->flags;
779
	cxt->ecc_info = pdata->ecc_info;
780

781
	paddr = cxt->phys_addr;
782

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

791
	err = ramoops_init_prz("console", dev, cxt, &cxt->cprz, &paddr,
792
			       cxt->console_size, 0);
793 794 795
	if (err)
		goto fail_init_cprz;

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

807 808
	err = ramoops_init_prz("pmsg", dev, cxt, &cxt->mprz, &paddr,
				cxt->pmsg_size, 0);
809 810 811
	if (err)
		goto fail_init_mprz;

K
Kees Cook 已提交
812
	cxt->pstore.data = cxt;
813
	/*
814 815 816 817
	 * 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).
818
	 */
819 820 821
	if (cxt->console_size)
		cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */
	cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize);
K
Kees Cook 已提交
822 823 824
	cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
	if (!cxt->pstore.buf) {
		pr_err("cannot allocate pstore buffer\n");
825
		err = -ENOMEM;
K
Kees Cook 已提交
826 827
		goto fail_clear;
	}
828
	spin_lock_init(&cxt->pstore.buf_lock);
K
Kees Cook 已提交
829

830 831 832 833 834 835 836
	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;
837

K
Kees Cook 已提交
838
	err = pstore_register(&cxt->pstore);
839
	if (err) {
K
Kees Cook 已提交
840
		pr_err("registering with pstore failed\n");
841
		goto fail_buf;
842 843
	}

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

856
	pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n",
857
		cxt->size, (unsigned long long)cxt->phys_addr,
858
		cxt->ecc_info.ecc_size, cxt->ecc_info.block_size);
K
Kees Cook 已提交
859

860 861
	return 0;

K
Kees Cook 已提交
862 863 864 865
fail_buf:
	kfree(cxt->pstore.buf);
fail_clear:
	cxt->pstore.bufsize = 0;
866
	persistent_ram_free(cxt->mprz);
867
fail_init_mprz:
868
fail_init_fprz:
869
	persistent_ram_free(cxt->cprz);
870
fail_init_cprz:
871
	ramoops_free_przs(cxt);
K
Kees Cook 已提交
872
fail_out:
873 874 875
	return err;
}

G
Geliang Tang 已提交
876
static int ramoops_remove(struct platform_device *pdev)
877 878 879
{
	struct ramoops_context *cxt = &oops_cxt;

G
Geliang Tang 已提交
880
	pstore_unregister(&cxt->pstore);
K
Kees Cook 已提交
881 882 883 884

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

G
Geliang Tang 已提交
885 886 887 888
	persistent_ram_free(cxt->mprz);
	persistent_ram_free(cxt->cprz);
	ramoops_free_przs(cxt);

889
	return 0;
890 891
}

892 893 894 895 896
static const struct of_device_id dt_match[] = {
	{ .compatible = "ramoops" },
	{}
};

897
static struct platform_driver ramoops_driver = {
898
	.probe		= ramoops_probe,
G
Geliang Tang 已提交
899
	.remove		= ramoops_remove,
900
	.driver		= {
901 902
		.name		= "ramoops",
		.of_match_table	= dt_match,
903 904 905
	},
};

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

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

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

	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);
947
}
G
Geliang Tang 已提交
948
late_initcall(ramoops_init);
949 950 951 952

static void __exit ramoops_exit(void)
{
	platform_driver_unregister(&ramoops_driver);
953
	platform_device_unregister(dummy);
954
	kfree(dummy_data);
955
}
956 957 958 959 960
module_exit(ramoops_exit);

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