1 /* 2 * RAM Oops/Panic logger 3 * 4 * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com> 5 * Copyright (C) 2011 Kees Cook <keescook@chromium.org> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * version 2 as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 19 * 02110-1301 USA 20 * 21 */ 22 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 25 #include <linux/kernel.h> 26 #include <linux/err.h> 27 #include <linux/module.h> 28 #include <linux/version.h> 29 #include <linux/pstore.h> 30 #include <linux/time.h> 31 #include <linux/io.h> 32 #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 #define RAMOOPS_KERNMSG_HDR "====" 39 #define MIN_MEM_SIZE 4096UL 40 41 static ulong record_size = MIN_MEM_SIZE; 42 module_param(record_size, ulong, 0400); 43 MODULE_PARM_DESC(record_size, 44 "size of each dump done on oops/panic"); 45 46 static ulong ramoops_console_size = MIN_MEM_SIZE; 47 module_param_named(console_size, ramoops_console_size, ulong, 0400); 48 MODULE_PARM_DESC(console_size, "size of kernel console log"); 49 50 static ulong ramoops_ftrace_size = MIN_MEM_SIZE; 51 module_param_named(ftrace_size, ramoops_ftrace_size, ulong, 0400); 52 MODULE_PARM_DESC(ftrace_size, "size of ftrace log"); 53 54 static ulong mem_address; 55 module_param(mem_address, ulong, 0400); 56 MODULE_PARM_DESC(mem_address, 57 "start of reserved RAM used to store oops/panic logs"); 58 59 static ulong mem_size; 60 module_param(mem_size, ulong, 0400); 61 MODULE_PARM_DESC(mem_size, 62 "size of reserved RAM used to store oops/panic logs"); 63 64 static int dump_oops = 1; 65 module_param(dump_oops, int, 0600); 66 MODULE_PARM_DESC(dump_oops, 67 "set to 1 to dump oopses, 0 to only dump panics (default 1)"); 68 69 static int ramoops_ecc; 70 module_param_named(ecc, ramoops_ecc, int, 0600); 71 MODULE_PARM_DESC(ramoops_ecc, 72 "if non-zero, the option enables ECC support and specifies " 73 "ECC buffer size in bytes (1 is a special value, means 16 " 74 "bytes ECC)"); 75 76 struct ramoops_context { 77 struct persistent_ram_zone **przs; 78 struct persistent_ram_zone *cprz; 79 struct persistent_ram_zone *fprz; 80 phys_addr_t phys_addr; 81 unsigned long size; 82 size_t record_size; 83 size_t console_size; 84 size_t ftrace_size; 85 int dump_oops; 86 struct persistent_ram_ecc_info ecc_info; 87 unsigned int max_dump_cnt; 88 unsigned int dump_write_cnt; 89 unsigned int dump_read_cnt; 90 unsigned int console_read_cnt; 91 unsigned int ftrace_read_cnt; 92 struct pstore_info pstore; 93 }; 94 95 static struct platform_device *dummy; 96 static struct ramoops_platform_data *dummy_data; 97 98 static int ramoops_pstore_open(struct pstore_info *psi) 99 { 100 struct ramoops_context *cxt = psi->data; 101 102 cxt->dump_read_cnt = 0; 103 cxt->console_read_cnt = 0; 104 return 0; 105 } 106 107 static struct persistent_ram_zone * 108 ramoops_get_next_prz(struct persistent_ram_zone *przs[], uint *c, uint max, 109 u64 *id, 110 enum pstore_type_id *typep, enum pstore_type_id type, 111 bool update) 112 { 113 struct persistent_ram_zone *prz; 114 int i = (*c)++; 115 116 if (i >= max) 117 return NULL; 118 119 prz = przs[i]; 120 121 if (update) { 122 /* Update old/shadowed buffer. */ 123 persistent_ram_save_old(prz); 124 if (!persistent_ram_old_size(prz)) 125 return NULL; 126 } 127 128 *typep = type; 129 *id = i; 130 131 return prz; 132 } 133 134 static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type, 135 int *count, struct timespec *time, 136 char **buf, struct pstore_info *psi) 137 { 138 ssize_t size; 139 ssize_t ecc_notice_size; 140 struct ramoops_context *cxt = psi->data; 141 struct persistent_ram_zone *prz; 142 143 prz = ramoops_get_next_prz(cxt->przs, &cxt->dump_read_cnt, 144 cxt->max_dump_cnt, id, type, 145 PSTORE_TYPE_DMESG, 1); 146 if (!prz) 147 prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt, 148 1, id, type, PSTORE_TYPE_CONSOLE, 0); 149 if (!prz) 150 prz = ramoops_get_next_prz(&cxt->fprz, &cxt->ftrace_read_cnt, 151 1, id, type, PSTORE_TYPE_FTRACE, 0); 152 if (!prz) 153 return 0; 154 155 /* TODO(kees): Bogus time for the moment. */ 156 time->tv_sec = 0; 157 time->tv_nsec = 0; 158 159 size = persistent_ram_old_size(prz); 160 161 /* ECC correction notice */ 162 ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0); 163 164 *buf = kmalloc(size + ecc_notice_size + 1, GFP_KERNEL); 165 if (*buf == NULL) 166 return -ENOMEM; 167 168 memcpy(*buf, persistent_ram_old(prz), size); 169 persistent_ram_ecc_string(prz, *buf + size, ecc_notice_size + 1); 170 171 return size + ecc_notice_size; 172 } 173 174 static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz) 175 { 176 char *hdr; 177 struct timespec timestamp; 178 size_t len; 179 180 /* Report zeroed timestamp if called before timekeeping has resumed. */ 181 if (__getnstimeofday(×tamp)) { 182 timestamp.tv_sec = 0; 183 timestamp.tv_nsec = 0; 184 } 185 hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu\n", 186 (long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000)); 187 WARN_ON_ONCE(!hdr); 188 len = hdr ? strlen(hdr) : 0; 189 persistent_ram_write(prz, hdr, len); 190 kfree(hdr); 191 192 return len; 193 } 194 195 static int notrace ramoops_pstore_write_buf(enum pstore_type_id type, 196 enum kmsg_dump_reason reason, 197 u64 *id, unsigned int part, 198 const char *buf, 199 size_t hsize, size_t size, 200 struct pstore_info *psi) 201 { 202 struct ramoops_context *cxt = psi->data; 203 struct persistent_ram_zone *prz; 204 size_t hlen; 205 206 if (type == PSTORE_TYPE_CONSOLE) { 207 if (!cxt->cprz) 208 return -ENOMEM; 209 persistent_ram_write(cxt->cprz, buf, size); 210 return 0; 211 } else if (type == PSTORE_TYPE_FTRACE) { 212 if (!cxt->fprz) 213 return -ENOMEM; 214 persistent_ram_write(cxt->fprz, buf, size); 215 return 0; 216 } 217 218 if (type != PSTORE_TYPE_DMESG) 219 return -EINVAL; 220 221 /* Out of the various dmesg dump types, ramoops is currently designed 222 * to only store crash logs, rather than storing general kernel logs. 223 */ 224 if (reason != KMSG_DUMP_OOPS && 225 reason != KMSG_DUMP_PANIC) 226 return -EINVAL; 227 228 /* Skip Oopes when configured to do so. */ 229 if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops) 230 return -EINVAL; 231 232 /* Explicitly only take the first part of any new crash. 233 * If our buffer is larger than kmsg_bytes, this can never happen, 234 * and if our buffer is smaller than kmsg_bytes, we don't want the 235 * report split across multiple records. 236 */ 237 if (part != 1) 238 return -ENOSPC; 239 240 if (!cxt->przs) 241 return -ENOSPC; 242 243 prz = cxt->przs[cxt->dump_write_cnt]; 244 245 hlen = ramoops_write_kmsg_hdr(prz); 246 if (size + hlen > prz->buffer_size) 247 size = prz->buffer_size - hlen; 248 persistent_ram_write(prz, buf, size); 249 250 cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt; 251 252 return 0; 253 } 254 255 static int ramoops_pstore_erase(enum pstore_type_id type, u64 id, int count, 256 struct timespec time, struct pstore_info *psi) 257 { 258 struct ramoops_context *cxt = psi->data; 259 struct persistent_ram_zone *prz; 260 261 switch (type) { 262 case PSTORE_TYPE_DMESG: 263 if (id >= cxt->max_dump_cnt) 264 return -EINVAL; 265 prz = cxt->przs[id]; 266 break; 267 case PSTORE_TYPE_CONSOLE: 268 prz = cxt->cprz; 269 break; 270 case PSTORE_TYPE_FTRACE: 271 prz = cxt->fprz; 272 break; 273 default: 274 return -EINVAL; 275 } 276 277 persistent_ram_free_old(prz); 278 persistent_ram_zap(prz); 279 280 return 0; 281 } 282 283 static struct ramoops_context oops_cxt = { 284 .pstore = { 285 .owner = THIS_MODULE, 286 .name = "ramoops", 287 .open = ramoops_pstore_open, 288 .read = ramoops_pstore_read, 289 .write_buf = ramoops_pstore_write_buf, 290 .erase = ramoops_pstore_erase, 291 }, 292 }; 293 294 static void ramoops_free_przs(struct ramoops_context *cxt) 295 { 296 int i; 297 298 if (!cxt->przs) 299 return; 300 301 for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++) 302 persistent_ram_free(cxt->przs[i]); 303 kfree(cxt->przs); 304 } 305 306 static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt, 307 phys_addr_t *paddr, size_t dump_mem_sz) 308 { 309 int err = -ENOMEM; 310 int i; 311 312 if (!cxt->record_size) 313 return 0; 314 315 if (*paddr + dump_mem_sz - cxt->phys_addr > cxt->size) { 316 dev_err(dev, "no room for dumps\n"); 317 return -ENOMEM; 318 } 319 320 cxt->max_dump_cnt = dump_mem_sz / cxt->record_size; 321 if (!cxt->max_dump_cnt) 322 return -ENOMEM; 323 324 cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt, 325 GFP_KERNEL); 326 if (!cxt->przs) { 327 dev_err(dev, "failed to initialize a prz array for dumps\n"); 328 return -ENOMEM; 329 } 330 331 for (i = 0; i < cxt->max_dump_cnt; i++) { 332 size_t sz = cxt->record_size; 333 334 cxt->przs[i] = persistent_ram_new(*paddr, sz, 0, 335 &cxt->ecc_info); 336 if (IS_ERR(cxt->przs[i])) { 337 err = PTR_ERR(cxt->przs[i]); 338 dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n", 339 sz, (unsigned long long)*paddr, err); 340 goto fail_prz; 341 } 342 *paddr += sz; 343 } 344 345 return 0; 346 fail_prz: 347 ramoops_free_przs(cxt); 348 return err; 349 } 350 351 static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt, 352 struct persistent_ram_zone **prz, 353 phys_addr_t *paddr, size_t sz, u32 sig) 354 { 355 if (!sz) 356 return 0; 357 358 if (*paddr + sz - cxt->phys_addr > cxt->size) { 359 dev_err(dev, "no room for mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n", 360 sz, (unsigned long long)*paddr, 361 cxt->size, (unsigned long long)cxt->phys_addr); 362 return -ENOMEM; 363 } 364 365 *prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info); 366 if (IS_ERR(*prz)) { 367 int err = PTR_ERR(*prz); 368 369 dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n", 370 sz, (unsigned long long)*paddr, err); 371 return err; 372 } 373 374 persistent_ram_zap(*prz); 375 376 *paddr += sz; 377 378 return 0; 379 } 380 381 static int ramoops_probe(struct platform_device *pdev) 382 { 383 struct device *dev = &pdev->dev; 384 struct ramoops_platform_data *pdata = pdev->dev.platform_data; 385 struct ramoops_context *cxt = &oops_cxt; 386 size_t dump_mem_sz; 387 phys_addr_t paddr; 388 int err = -EINVAL; 389 390 /* Only a single ramoops area allowed at a time, so fail extra 391 * probes. 392 */ 393 if (cxt->max_dump_cnt) 394 goto fail_out; 395 396 if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size && 397 !pdata->ftrace_size)) { 398 pr_err("The memory size and the record/console size must be " 399 "non-zero\n"); 400 goto fail_out; 401 } 402 403 if (!is_power_of_2(pdata->record_size)) 404 pdata->record_size = rounddown_pow_of_two(pdata->record_size); 405 if (!is_power_of_2(pdata->console_size)) 406 pdata->console_size = rounddown_pow_of_two(pdata->console_size); 407 if (!is_power_of_2(pdata->ftrace_size)) 408 pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size); 409 410 cxt->dump_read_cnt = 0; 411 cxt->size = pdata->mem_size; 412 cxt->phys_addr = pdata->mem_address; 413 cxt->record_size = pdata->record_size; 414 cxt->console_size = pdata->console_size; 415 cxt->ftrace_size = pdata->ftrace_size; 416 cxt->dump_oops = pdata->dump_oops; 417 cxt->ecc_info = pdata->ecc_info; 418 419 paddr = cxt->phys_addr; 420 421 dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size; 422 err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz); 423 if (err) 424 goto fail_out; 425 426 err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr, 427 cxt->console_size, 0); 428 if (err) 429 goto fail_init_cprz; 430 431 err = ramoops_init_prz(dev, cxt, &cxt->fprz, &paddr, cxt->ftrace_size, 432 LINUX_VERSION_CODE); 433 if (err) 434 goto fail_init_fprz; 435 436 if (!cxt->przs && !cxt->cprz && !cxt->fprz) { 437 pr_err("memory size too small, minimum is %zu\n", 438 cxt->console_size + cxt->record_size + 439 cxt->ftrace_size); 440 err = -EINVAL; 441 goto fail_cnt; 442 } 443 444 cxt->pstore.data = cxt; 445 /* 446 * Console can handle any buffer size, so prefer LOG_LINE_MAX. If we 447 * have to handle dumps, we must have at least record_size buffer. And 448 * for ftrace, bufsize is irrelevant (if bufsize is 0, buf will be 449 * ZERO_SIZE_PTR). 450 */ 451 if (cxt->console_size) 452 cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */ 453 cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize); 454 cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL); 455 spin_lock_init(&cxt->pstore.buf_lock); 456 if (!cxt->pstore.buf) { 457 pr_err("cannot allocate pstore buffer\n"); 458 err = -ENOMEM; 459 goto fail_clear; 460 } 461 462 err = pstore_register(&cxt->pstore); 463 if (err) { 464 pr_err("registering with pstore failed\n"); 465 goto fail_buf; 466 } 467 468 /* 469 * Update the module parameter variables as well so they are visible 470 * through /sys/module/ramoops/parameters/ 471 */ 472 mem_size = pdata->mem_size; 473 mem_address = pdata->mem_address; 474 record_size = pdata->record_size; 475 dump_oops = pdata->dump_oops; 476 477 pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n", 478 cxt->size, (unsigned long long)cxt->phys_addr, 479 cxt->ecc_info.ecc_size, cxt->ecc_info.block_size); 480 481 return 0; 482 483 fail_buf: 484 kfree(cxt->pstore.buf); 485 fail_clear: 486 cxt->pstore.bufsize = 0; 487 cxt->max_dump_cnt = 0; 488 fail_cnt: 489 kfree(cxt->fprz); 490 fail_init_fprz: 491 kfree(cxt->cprz); 492 fail_init_cprz: 493 ramoops_free_przs(cxt); 494 fail_out: 495 return err; 496 } 497 498 static int __exit ramoops_remove(struct platform_device *pdev) 499 { 500 #if 0 501 /* TODO(kees): We cannot unload ramoops since pstore doesn't support 502 * unregistering yet. 503 */ 504 struct ramoops_context *cxt = &oops_cxt; 505 506 iounmap(cxt->virt_addr); 507 release_mem_region(cxt->phys_addr, cxt->size); 508 cxt->max_dump_cnt = 0; 509 510 /* TODO(kees): When pstore supports unregistering, call it here. */ 511 kfree(cxt->pstore.buf); 512 cxt->pstore.bufsize = 0; 513 514 return 0; 515 #endif 516 return -EBUSY; 517 } 518 519 static struct platform_driver ramoops_driver = { 520 .probe = ramoops_probe, 521 .remove = __exit_p(ramoops_remove), 522 .driver = { 523 .name = "ramoops", 524 .owner = THIS_MODULE, 525 }, 526 }; 527 528 static void ramoops_register_dummy(void) 529 { 530 if (!mem_size) 531 return; 532 533 pr_info("using module parameters\n"); 534 535 dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL); 536 if (!dummy_data) { 537 pr_info("could not allocate pdata\n"); 538 return; 539 } 540 541 dummy_data->mem_size = mem_size; 542 dummy_data->mem_address = mem_address; 543 dummy_data->record_size = record_size; 544 dummy_data->console_size = ramoops_console_size; 545 dummy_data->ftrace_size = ramoops_ftrace_size; 546 dummy_data->dump_oops = dump_oops; 547 /* 548 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC 549 * (using 1 byte for ECC isn't much of use anyway). 550 */ 551 dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc; 552 553 dummy = platform_device_register_data(NULL, "ramoops", -1, 554 dummy_data, sizeof(struct ramoops_platform_data)); 555 if (IS_ERR(dummy)) { 556 pr_info("could not create platform device: %ld\n", 557 PTR_ERR(dummy)); 558 } 559 } 560 561 static int __init ramoops_init(void) 562 { 563 ramoops_register_dummy(); 564 return platform_driver_register(&ramoops_driver); 565 } 566 postcore_initcall(ramoops_init); 567 568 static void __exit ramoops_exit(void) 569 { 570 platform_driver_unregister(&ramoops_driver); 571 platform_device_unregister(dummy); 572 kfree(dummy_data); 573 } 574 module_exit(ramoops_exit); 575 576 MODULE_LICENSE("GPL"); 577 MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>"); 578 MODULE_DESCRIPTION("RAM Oops/Panic logger/driver"); 579