ram.c 12.1 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>
K
Kees Cook 已提交
28
#include <linux/pstore.h>
29 30 31
#include <linux/time.h>
#include <linux/io.h>
#include <linux/ioport.h>
32
#include <linux/platform_device.h>
33
#include <linux/slab.h>
34
#include <linux/pstore_ram.h>
35 36

#define RAMOOPS_KERNMSG_HDR "===="
37
#define MIN_MEM_SIZE 4096UL
38

39 40 41 42
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");
43

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

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
static ulong mem_address;
module_param(mem_address, ulong, 0400);
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");

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 已提交
63 64 65 66 67
static int ramoops_ecc;
module_param_named(ecc, ramoops_ecc, int, 0600);
MODULE_PARM_DESC(ramoops_ecc,
		"set to 1 to enable ECC support");

K
Kees Cook 已提交
68
struct ramoops_context {
69
	struct persistent_ram_zone **przs;
70
	struct persistent_ram_zone *cprz;
71 72
	phys_addr_t phys_addr;
	unsigned long size;
K
Kees Cook 已提交
73
	size_t record_size;
74
	size_t console_size;
75
	int dump_oops;
A
Anton Vorontsov 已提交
76
	bool ecc;
77 78 79
	unsigned int max_dump_cnt;
	unsigned int dump_write_cnt;
	unsigned int dump_read_cnt;
80
	unsigned int console_read_cnt;
K
Kees Cook 已提交
81 82
	struct pstore_info pstore;
};
83

84 85 86
static struct platform_device *dummy;
static struct ramoops_platform_data *dummy_data;

K
Kees Cook 已提交
87 88 89 90
static int ramoops_pstore_open(struct pstore_info *psi)
{
	struct ramoops_context *cxt = psi->data;

91
	cxt->dump_read_cnt = 0;
92
	cxt->console_read_cnt = 0;
K
Kees Cook 已提交
93 94 95
	return 0;
}

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
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];

	if (update) {
		/* Update old/shadowed buffer. */
		persistent_ram_save_old(prz);
		if (!persistent_ram_old_size(prz))
			return NULL;
	}

	*typep = type;
	*id = i;

	return prz;
}

K
Kees Cook 已提交
123 124 125 126
static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
				   struct timespec *time,
				   char **buf,
				   struct pstore_info *psi)
127
{
K
Kees Cook 已提交
128 129
	ssize_t size;
	struct ramoops_context *cxt = psi->data;
130
	struct persistent_ram_zone *prz;
K
Kees Cook 已提交
131

132 133 134
	prz = ramoops_get_next_prz(cxt->przs, &cxt->dump_read_cnt,
				   cxt->max_dump_cnt, id, type,
				   PSTORE_TYPE_DMESG, 1);
135 136 137
	if (!prz)
		prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt,
					   1, id, type, PSTORE_TYPE_CONSOLE, 0);
138 139
	if (!prz)
		return 0;
140

K
Kees Cook 已提交
141 142 143 144
	/* TODO(kees): Bogus time for the moment. */
	time->tv_sec = 0;
	time->tv_nsec = 0;

145
	size = persistent_ram_old_size(prz);
K
Kees Cook 已提交
146 147 148
	*buf = kmalloc(size, GFP_KERNEL);
	if (*buf == NULL)
		return -ENOMEM;
149
	memcpy(*buf, persistent_ram_old(prz), size);
K
Kees Cook 已提交
150 151 152 153

	return size;
}

154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz)
{
	char *hdr;
	struct timeval timestamp;
	size_t len;

	do_gettimeofday(&timestamp);
	hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu\n",
		(long)timestamp.tv_sec, (long)timestamp.tv_usec);
	WARN_ON_ONCE(!hdr);
	len = hdr ? strlen(hdr) : 0;
	persistent_ram_write(prz, hdr, len);
	kfree(hdr);

	return len;
}

K
Kees Cook 已提交
171 172 173 174 175 176 177
static int ramoops_pstore_write(enum pstore_type_id type,
				enum kmsg_dump_reason reason,
				u64 *id,
				unsigned int part,
				size_t size, struct pstore_info *psi)
{
	struct ramoops_context *cxt = psi->data;
178
	struct persistent_ram_zone *prz = cxt->przs[cxt->dump_write_cnt];
179
	size_t hlen;
K
Kees Cook 已提交
180

181 182 183 184 185 186 187
	if (type == PSTORE_TYPE_CONSOLE) {
		if (!cxt->cprz)
			return -ENOMEM;
		persistent_ram_write(cxt->cprz, cxt->pstore.buf, size);
		return 0;
	}

K
Kees Cook 已提交
188 189
	if (type != PSTORE_TYPE_DMESG)
		return -EINVAL;
190

K
Kees Cook 已提交
191 192 193
	/* Out of the various dmesg dump types, ramoops is currently designed
	 * to only store crash logs, rather than storing general kernel logs.
	 */
194
	if (reason != KMSG_DUMP_OOPS &&
W
WANG Cong 已提交
195
	    reason != KMSG_DUMP_PANIC)
K
Kees Cook 已提交
196
		return -EINVAL;
197

K
Kees Cook 已提交
198
	/* Skip Oopes when configured to do so. */
199
	if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
K
Kees Cook 已提交
200 201 202 203 204 205 206 207 208
		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;
209

210 211 212 213
	hlen = ramoops_write_kmsg_hdr(prz);
	if (size + hlen > prz->buffer_size)
		size = prz->buffer_size - hlen;
	persistent_ram_write(prz, cxt->pstore.buf, size);
214

215
	cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
K
Kees Cook 已提交
216 217 218 219 220 221 222 223

	return 0;
}

static int ramoops_pstore_erase(enum pstore_type_id type, u64 id,
				struct pstore_info *psi)
{
	struct ramoops_context *cxt = psi->data;
224
	struct persistent_ram_zone *prz;
K
Kees Cook 已提交
225

226 227 228 229 230 231 232 233 234 235
	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;
	default:
K
Kees Cook 已提交
236
		return -EINVAL;
237
	}
K
Kees Cook 已提交
238

239 240
	persistent_ram_free_old(prz);
	persistent_ram_zap(prz);
K
Kees Cook 已提交
241 242

	return 0;
243 244
}

K
Kees Cook 已提交
245 246 247 248 249 250 251 252 253 254 255
static struct ramoops_context oops_cxt = {
	.pstore = {
		.owner	= THIS_MODULE,
		.name	= "ramoops",
		.open	= ramoops_pstore_open,
		.read	= ramoops_pstore_read,
		.write	= ramoops_pstore_write,
		.erase	= ramoops_pstore_erase,
	},
};

256 257 258 259 260 261 262
static void ramoops_free_przs(struct ramoops_context *cxt)
{
	int i;

	if (!cxt->przs)
		return;

263
	for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++)
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
		persistent_ram_free(cxt->przs[i]);
	kfree(cxt->przs);
}

static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt,
			      phys_addr_t *paddr, size_t dump_mem_sz)
{
	int err = -ENOMEM;
	int i;

	if (!cxt->record_size)
		return 0;

	cxt->max_dump_cnt = dump_mem_sz / cxt->record_size;
	if (!cxt->max_dump_cnt)
		return -ENOMEM;

	cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt,
			     GFP_KERNEL);
	if (!cxt->przs) {
		dev_err(dev, "failed to initialize a prz array for dumps\n");
		return -ENOMEM;
	}

	for (i = 0; i < cxt->max_dump_cnt; i++) {
		size_t sz = cxt->record_size;

		cxt->przs[i] = persistent_ram_new(*paddr, sz, cxt->ecc);
		if (IS_ERR(cxt->przs[i])) {
			err = PTR_ERR(cxt->przs[i]);
			dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
				sz, (unsigned long long)*paddr, err);
			goto fail_prz;
		}
		*paddr += sz;
	}

	return 0;
fail_prz:
	ramoops_free_przs(cxt);
	return err;
}

307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt,
			    struct persistent_ram_zone **prz,
			    phys_addr_t *paddr, size_t sz)
{
	if (!sz)
		return 0;

	if (*paddr + sz > *paddr + cxt->size)
		return -ENOMEM;

	*prz = persistent_ram_new(*paddr, sz, cxt->ecc);
	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;
}

333
static int __devinit ramoops_probe(struct platform_device *pdev)
334
{
335
	struct device *dev = &pdev->dev;
336
	struct ramoops_platform_data *pdata = pdev->dev.platform_data;
337
	struct ramoops_context *cxt = &oops_cxt;
338 339
	size_t dump_mem_sz;
	phys_addr_t paddr;
340 341
	int err = -EINVAL;

K
Kees Cook 已提交
342 343 344
	/* Only a single ramoops area allowed at a time, so fail extra
	 * probes.
	 */
345
	if (cxt->max_dump_cnt)
K
Kees Cook 已提交
346 347
		goto fail_out;

348 349
	if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size)) {
		pr_err("The memory size and the record/console size must be "
350
			"non-zero\n");
K
Kees Cook 已提交
351
		goto fail_out;
352 353
	}

354 355
	pdata->mem_size = rounddown_pow_of_two(pdata->mem_size);
	pdata->record_size = rounddown_pow_of_two(pdata->record_size);
356
	pdata->console_size = rounddown_pow_of_two(pdata->console_size);
357

358
	cxt->dump_read_cnt = 0;
359 360
	cxt->size = pdata->mem_size;
	cxt->phys_addr = pdata->mem_address;
361
	cxt->record_size = pdata->record_size;
362
	cxt->console_size = pdata->console_size;
363
	cxt->dump_oops = pdata->dump_oops;
A
Anton Vorontsov 已提交
364
	cxt->ecc = pdata->ecc;
365

366
	paddr = cxt->phys_addr;
367

368
	dump_mem_sz = cxt->size - cxt->console_size;
369
	err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz);
370 371 372 373 374 375 376 377
	if (err)
		goto fail_out;

	err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr, cxt->console_size);
	if (err)
		goto fail_init_cprz;

	if (!cxt->przs && !cxt->cprz) {
378
		pr_err("memory size too small, minimum is %lu\n",
379 380
			cxt->console_size + cxt->record_size);
		goto fail_cnt;
381 382
	}

K
Kees Cook 已提交
383
	cxt->pstore.data = cxt;
384 385 386 387 388 389 390 391
	/*
	 * Console can handle any buffer size, so prefer dumps buffer
	 * size since usually it is smaller.
	 */
	if (cxt->przs)
		cxt->pstore.bufsize = cxt->przs[0]->buffer_size;
	else
		cxt->pstore.bufsize = cxt->cprz->buffer_size;
K
Kees Cook 已提交
392 393 394 395 396 397 398 399
	cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
	spin_lock_init(&cxt->pstore.buf_lock);
	if (!cxt->pstore.buf) {
		pr_err("cannot allocate pstore buffer\n");
		goto fail_clear;
	}

	err = pstore_register(&cxt->pstore);
400
	if (err) {
K
Kees Cook 已提交
401
		pr_err("registering with pstore failed\n");
402
		goto fail_buf;
403 404
	}

405 406 407 408 409 410 411 412 413
	/*
	 * 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;

414
	pr_info("attached 0x%lx@0x%llx, ecc: %s\n",
415
		cxt->size, (unsigned long long)cxt->phys_addr,
A
Anton Vorontsov 已提交
416
		ramoops_ecc ? "on" : "off");
K
Kees Cook 已提交
417

418 419
	return 0;

K
Kees Cook 已提交
420 421 422 423
fail_buf:
	kfree(cxt->pstore.buf);
fail_clear:
	cxt->pstore.bufsize = 0;
424
	cxt->max_dump_cnt = 0;
425 426 427
fail_cnt:
	kfree(cxt->cprz);
fail_init_cprz:
428
	ramoops_free_przs(cxt);
K
Kees Cook 已提交
429
fail_out:
430 431 432
	return err;
}

433
static int __exit ramoops_remove(struct platform_device *pdev)
434
{
K
Kees Cook 已提交
435 436 437 438
#if 0
	/* TODO(kees): We cannot unload ramoops since pstore doesn't support
	 * unregistering yet.
	 */
439 440 441 442
	struct ramoops_context *cxt = &oops_cxt;

	iounmap(cxt->virt_addr);
	release_mem_region(cxt->phys_addr, cxt->size);
443
	cxt->max_dump_cnt = 0;
K
Kees Cook 已提交
444 445 446 447 448

	/* TODO(kees): When pstore supports unregistering, call it here. */
	kfree(cxt->pstore.buf);
	cxt->pstore.bufsize = 0;

449
	return 0;
K
Kees Cook 已提交
450 451
#endif
	return -EBUSY;
452 453
}

454
static struct platform_driver ramoops_driver = {
455
	.probe		= ramoops_probe,
456 457 458 459 460 461 462
	.remove		= __exit_p(ramoops_remove),
	.driver		= {
		.name	= "ramoops",
		.owner	= THIS_MODULE,
	},
};

463
static void ramoops_register_dummy(void)
464
{
465 466 467 468 469 470 471 472 473
	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;
474 475
	}

476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
	dummy_data->mem_size = mem_size;
	dummy_data->mem_address = mem_address;
	dummy_data->record_size = record_size;
	dummy_data->console_size = ramoops_console_size;
	dummy_data->dump_oops = dump_oops;
	dummy_data->ecc = ramoops_ecc;

	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);
495
}
496
postcore_initcall(ramoops_init);
497 498 499 500

static void __exit ramoops_exit(void)
{
	platform_driver_unregister(&ramoops_driver);
501
	kfree(dummy_data);
502
}
503 504 505 506 507
module_exit(ramoops_exit);

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