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 #include <linux/of.h> 38 #include <linux/of_address.h> 39 40 #define RAMOOPS_KERNMSG_HDR "====" 41 #define MIN_MEM_SIZE 4096UL 42 43 static ulong record_size = MIN_MEM_SIZE; 44 module_param(record_size, ulong, 0400); 45 MODULE_PARM_DESC(record_size, 46 "size of each dump done on oops/panic"); 47 48 static ulong ramoops_console_size = MIN_MEM_SIZE; 49 module_param_named(console_size, ramoops_console_size, ulong, 0400); 50 MODULE_PARM_DESC(console_size, "size of kernel console log"); 51 52 static ulong ramoops_ftrace_size = MIN_MEM_SIZE; 53 module_param_named(ftrace_size, ramoops_ftrace_size, ulong, 0400); 54 MODULE_PARM_DESC(ftrace_size, "size of ftrace log"); 55 56 static ulong ramoops_pmsg_size = MIN_MEM_SIZE; 57 module_param_named(pmsg_size, ramoops_pmsg_size, ulong, 0400); 58 MODULE_PARM_DESC(pmsg_size, "size of user space message log"); 59 60 static unsigned long long mem_address; 61 module_param(mem_address, ullong, 0400); 62 MODULE_PARM_DESC(mem_address, 63 "start of reserved RAM used to store oops/panic logs"); 64 65 static ulong mem_size; 66 module_param(mem_size, ulong, 0400); 67 MODULE_PARM_DESC(mem_size, 68 "size of reserved RAM used to store oops/panic logs"); 69 70 static unsigned int mem_type; 71 module_param(mem_type, uint, 0600); 72 MODULE_PARM_DESC(mem_type, 73 "set to 1 to try to use unbuffered memory (default 0)"); 74 75 static int dump_oops = 1; 76 module_param(dump_oops, int, 0600); 77 MODULE_PARM_DESC(dump_oops, 78 "set to 1 to dump oopses, 0 to only dump panics (default 1)"); 79 80 static int ramoops_ecc; 81 module_param_named(ecc, ramoops_ecc, int, 0600); 82 MODULE_PARM_DESC(ramoops_ecc, 83 "if non-zero, the option enables ECC support and specifies " 84 "ECC buffer size in bytes (1 is a special value, means 16 " 85 "bytes ECC)"); 86 87 struct ramoops_context { 88 struct persistent_ram_zone **dprzs; /* Oops dump zones */ 89 struct persistent_ram_zone *cprz; /* Console zone */ 90 struct persistent_ram_zone **fprzs; /* Ftrace zones */ 91 struct persistent_ram_zone *mprz; /* PMSG zone */ 92 phys_addr_t phys_addr; 93 unsigned long size; 94 unsigned int memtype; 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 unsigned int max_dump_cnt; 103 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; 110 struct pstore_info pstore; 111 }; 112 113 static struct platform_device *dummy; 114 static struct ramoops_platform_data *dummy_data; 115 116 static int ramoops_pstore_open(struct pstore_info *psi) 117 { 118 struct ramoops_context *cxt = psi->data; 119 120 cxt->dump_read_cnt = 0; 121 cxt->console_read_cnt = 0; 122 cxt->ftrace_read_cnt = 0; 123 cxt->pmsg_read_cnt = 0; 124 return 0; 125 } 126 127 static struct persistent_ram_zone * 128 ramoops_get_next_prz(struct persistent_ram_zone *przs[], uint *c, uint max, 129 u64 *id, 130 enum pstore_type_id *typep, enum pstore_type_id type, 131 bool update) 132 { 133 struct persistent_ram_zone *prz; 134 int i = (*c)++; 135 136 if (i >= max) 137 return NULL; 138 139 prz = przs[i]; 140 if (!prz) 141 return NULL; 142 143 /* Update old/shadowed buffer. */ 144 if (update) 145 persistent_ram_save_old(prz); 146 147 if (!persistent_ram_old_size(prz)) 148 return NULL; 149 150 *typep = type; 151 *id = i; 152 153 return prz; 154 } 155 156 static int ramoops_read_kmsg_hdr(char *buffer, struct timespec *time, 157 bool *compressed) 158 { 159 char data_type; 160 int header_length = 0; 161 162 if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n%n", &time->tv_sec, 163 &time->tv_nsec, &data_type, &header_length) == 3) { 164 if (data_type == 'C') 165 *compressed = true; 166 else 167 *compressed = false; 168 } else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lu.%lu\n%n", 169 &time->tv_sec, &time->tv_nsec, &header_length) == 2) { 170 *compressed = false; 171 } else { 172 time->tv_sec = 0; 173 time->tv_nsec = 0; 174 *compressed = false; 175 } 176 return header_length; 177 } 178 179 static bool prz_ok(struct persistent_ram_zone *prz) 180 { 181 return !!prz && !!(persistent_ram_old_size(prz) + 182 persistent_ram_ecc_string(prz, NULL, 0)); 183 } 184 185 static ssize_t ftrace_log_combine(struct persistent_ram_zone *dest, 186 struct persistent_ram_zone *src) 187 { 188 size_t dest_size, src_size, total, dest_off, src_off; 189 size_t dest_idx = 0, src_idx = 0, merged_idx = 0; 190 void *merged_buf; 191 struct pstore_ftrace_record *drec, *srec, *mrec; 192 size_t record_size = sizeof(struct pstore_ftrace_record); 193 194 dest_off = dest->old_log_size % record_size; 195 dest_size = dest->old_log_size - dest_off; 196 197 src_off = src->old_log_size % record_size; 198 src_size = src->old_log_size - src_off; 199 200 total = dest_size + src_size; 201 merged_buf = kmalloc(total, GFP_KERNEL); 202 if (!merged_buf) 203 return -ENOMEM; 204 205 drec = (struct pstore_ftrace_record *)(dest->old_log + dest_off); 206 srec = (struct pstore_ftrace_record *)(src->old_log + src_off); 207 mrec = (struct pstore_ftrace_record *)(merged_buf); 208 209 while (dest_size > 0 && src_size > 0) { 210 if (pstore_ftrace_read_timestamp(&drec[dest_idx]) < 211 pstore_ftrace_read_timestamp(&srec[src_idx])) { 212 mrec[merged_idx++] = drec[dest_idx++]; 213 dest_size -= record_size; 214 } else { 215 mrec[merged_idx++] = srec[src_idx++]; 216 src_size -= record_size; 217 } 218 } 219 220 while (dest_size > 0) { 221 mrec[merged_idx++] = drec[dest_idx++]; 222 dest_size -= record_size; 223 } 224 225 while (src_size > 0) { 226 mrec[merged_idx++] = srec[src_idx++]; 227 src_size -= record_size; 228 } 229 230 kfree(dest->old_log); 231 dest->old_log = merged_buf; 232 dest->old_log_size = total; 233 234 return 0; 235 } 236 237 static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type, 238 int *count, struct timespec *time, 239 char **buf, bool *compressed, 240 ssize_t *ecc_notice_size, 241 struct pstore_info *psi) 242 { 243 ssize_t size = 0; 244 struct ramoops_context *cxt = psi->data; 245 struct persistent_ram_zone *prz = NULL; 246 int header_length = 0; 247 bool free_prz = false; 248 249 /* Ramoops headers provide time stamps for PSTORE_TYPE_DMESG, but 250 * PSTORE_TYPE_CONSOLE and PSTORE_TYPE_FTRACE don't currently have 251 * valid time stamps, so it is initialized to zero. 252 */ 253 time->tv_sec = 0; 254 time->tv_nsec = 0; 255 *compressed = false; 256 257 /* Find the next valid persistent_ram_zone for DMESG */ 258 while (cxt->dump_read_cnt < cxt->max_dump_cnt && !prz) { 259 prz = ramoops_get_next_prz(cxt->dprzs, &cxt->dump_read_cnt, 260 cxt->max_dump_cnt, id, type, 261 PSTORE_TYPE_DMESG, 1); 262 if (!prz_ok(prz)) 263 continue; 264 header_length = ramoops_read_kmsg_hdr(persistent_ram_old(prz), 265 time, compressed); 266 /* Clear and skip this DMESG record if it has no valid header */ 267 if (!header_length) { 268 persistent_ram_free_old(prz); 269 persistent_ram_zap(prz); 270 prz = NULL; 271 } 272 } 273 274 if (!prz_ok(prz)) 275 prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt, 276 1, id, type, PSTORE_TYPE_CONSOLE, 0); 277 278 if (!prz_ok(prz)) 279 prz = ramoops_get_next_prz(&cxt->mprz, &cxt->pmsg_read_cnt, 280 1, id, type, PSTORE_TYPE_PMSG, 0); 281 282 /* ftrace is last since it may want to dynamically allocate memory. */ 283 if (!prz_ok(prz) && cxt->fprzs) { 284 if (!(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)) { 285 prz = ramoops_get_next_prz(cxt->fprzs, 286 &cxt->ftrace_read_cnt, 1, id, type, 287 PSTORE_TYPE_FTRACE, 0); 288 } else { 289 /* 290 * Build a new dummy record which combines all the 291 * per-cpu records including metadata and ecc info. 292 */ 293 struct persistent_ram_zone *tmp_prz, *prz_next; 294 295 tmp_prz = kzalloc(sizeof(struct persistent_ram_zone), 296 GFP_KERNEL); 297 if (!tmp_prz) 298 return -ENOMEM; 299 free_prz = true; 300 301 while (cxt->ftrace_read_cnt < cxt->max_ftrace_cnt) { 302 prz_next = ramoops_get_next_prz(cxt->fprzs, 303 &cxt->ftrace_read_cnt, 304 cxt->max_ftrace_cnt, id, 305 type, PSTORE_TYPE_FTRACE, 0); 306 307 if (!prz_ok(prz_next)) 308 continue; 309 310 tmp_prz->ecc_info = prz_next->ecc_info; 311 tmp_prz->corrected_bytes += 312 prz_next->corrected_bytes; 313 tmp_prz->bad_blocks += prz_next->bad_blocks; 314 size = ftrace_log_combine(tmp_prz, prz_next); 315 if (size) 316 goto out; 317 } 318 *id = 0; 319 prz = tmp_prz; 320 } 321 } 322 323 if (!prz_ok(prz)) { 324 size = 0; 325 goto out; 326 } 327 328 size = persistent_ram_old_size(prz) - header_length; 329 330 /* ECC correction notice */ 331 *ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0); 332 333 *buf = kmalloc(size + *ecc_notice_size + 1, GFP_KERNEL); 334 if (*buf == NULL) { 335 size = -ENOMEM; 336 goto out; 337 } 338 339 memcpy(*buf, (char *)persistent_ram_old(prz) + header_length, size); 340 341 persistent_ram_ecc_string(prz, *buf + size, *ecc_notice_size + 1); 342 343 out: 344 if (free_prz) { 345 kfree(prz->old_log); 346 kfree(prz); 347 } 348 349 return size; 350 } 351 352 static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz, 353 bool compressed) 354 { 355 char *hdr; 356 struct timespec timestamp; 357 size_t len; 358 359 /* Report zeroed timestamp if called before timekeeping has resumed. */ 360 if (__getnstimeofday(×tamp)) { 361 timestamp.tv_sec = 0; 362 timestamp.tv_nsec = 0; 363 } 364 hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu-%c\n", 365 (long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000), 366 compressed ? 'C' : 'D'); 367 WARN_ON_ONCE(!hdr); 368 len = hdr ? strlen(hdr) : 0; 369 persistent_ram_write(prz, hdr, len); 370 kfree(hdr); 371 372 return len; 373 } 374 375 static int notrace ramoops_pstore_write_buf(enum pstore_type_id type, 376 enum kmsg_dump_reason reason, 377 u64 *id, unsigned int part, 378 const char *buf, 379 bool compressed, size_t size, 380 struct pstore_info *psi) 381 { 382 struct ramoops_context *cxt = psi->data; 383 struct persistent_ram_zone *prz; 384 size_t hlen; 385 386 if (type == PSTORE_TYPE_CONSOLE) { 387 if (!cxt->cprz) 388 return -ENOMEM; 389 persistent_ram_write(cxt->cprz, buf, size); 390 return 0; 391 } else if (type == PSTORE_TYPE_FTRACE) { 392 int zonenum; 393 394 if (!cxt->fprzs) 395 return -ENOMEM; 396 /* 397 * Choose zone by if we're using per-cpu buffers. 398 */ 399 if (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU) 400 zonenum = smp_processor_id(); 401 else 402 zonenum = 0; 403 404 persistent_ram_write(cxt->fprzs[zonenum], buf, size); 405 return 0; 406 } else if (type == PSTORE_TYPE_PMSG) { 407 pr_warn_ratelimited("PMSG shouldn't call %s\n", __func__); 408 return -EINVAL; 409 } 410 411 if (type != PSTORE_TYPE_DMESG) 412 return -EINVAL; 413 414 /* Out of the various dmesg dump types, ramoops is currently designed 415 * to only store crash logs, rather than storing general kernel logs. 416 */ 417 if (reason != KMSG_DUMP_OOPS && 418 reason != KMSG_DUMP_PANIC) 419 return -EINVAL; 420 421 /* Skip Oopes when configured to do so. */ 422 if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops) 423 return -EINVAL; 424 425 /* Explicitly only take the first part of any new crash. 426 * If our buffer is larger than kmsg_bytes, this can never happen, 427 * and if our buffer is smaller than kmsg_bytes, we don't want the 428 * report split across multiple records. 429 */ 430 if (part != 1) 431 return -ENOSPC; 432 433 if (!cxt->dprzs) 434 return -ENOSPC; 435 436 prz = cxt->dprzs[cxt->dump_write_cnt]; 437 438 hlen = ramoops_write_kmsg_hdr(prz, compressed); 439 if (size + hlen > prz->buffer_size) 440 size = prz->buffer_size - hlen; 441 persistent_ram_write(prz, buf, size); 442 443 cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt; 444 445 return 0; 446 } 447 448 static int notrace ramoops_pstore_write_buf_user(enum pstore_type_id type, 449 enum kmsg_dump_reason reason, 450 u64 *id, unsigned int part, 451 const char __user *buf, 452 bool compressed, size_t size, 453 struct pstore_info *psi) 454 { 455 if (type == PSTORE_TYPE_PMSG) { 456 struct ramoops_context *cxt = psi->data; 457 458 if (!cxt->mprz) 459 return -ENOMEM; 460 return persistent_ram_write_user(cxt->mprz, buf, size); 461 } 462 463 return -EINVAL; 464 } 465 466 static int ramoops_pstore_erase(enum pstore_type_id type, u64 id, int count, 467 struct timespec time, struct pstore_info *psi) 468 { 469 struct ramoops_context *cxt = psi->data; 470 struct persistent_ram_zone *prz; 471 472 switch (type) { 473 case PSTORE_TYPE_DMESG: 474 if (id >= cxt->max_dump_cnt) 475 return -EINVAL; 476 prz = cxt->dprzs[id]; 477 break; 478 case PSTORE_TYPE_CONSOLE: 479 prz = cxt->cprz; 480 break; 481 case PSTORE_TYPE_FTRACE: 482 if (id >= cxt->max_ftrace_cnt) 483 return -EINVAL; 484 prz = cxt->fprzs[id]; 485 break; 486 case PSTORE_TYPE_PMSG: 487 prz = cxt->mprz; 488 break; 489 default: 490 return -EINVAL; 491 } 492 493 persistent_ram_free_old(prz); 494 persistent_ram_zap(prz); 495 496 return 0; 497 } 498 499 static struct ramoops_context oops_cxt = { 500 .pstore = { 501 .owner = THIS_MODULE, 502 .name = "ramoops", 503 .open = ramoops_pstore_open, 504 .read = ramoops_pstore_read, 505 .write_buf = ramoops_pstore_write_buf, 506 .write_buf_user = ramoops_pstore_write_buf_user, 507 .erase = ramoops_pstore_erase, 508 }, 509 }; 510 511 static void ramoops_free_przs(struct ramoops_context *cxt) 512 { 513 int i; 514 515 /* Free dump PRZs */ 516 if (cxt->dprzs) { 517 for (i = 0; i < cxt->max_dump_cnt; i++) 518 persistent_ram_free(cxt->dprzs[i]); 519 520 kfree(cxt->dprzs); 521 cxt->max_dump_cnt = 0; 522 } 523 524 /* Free ftrace PRZs */ 525 if (cxt->fprzs) { 526 for (i = 0; i < cxt->max_ftrace_cnt; i++) 527 persistent_ram_free(cxt->fprzs[i]); 528 kfree(cxt->fprzs); 529 cxt->max_ftrace_cnt = 0; 530 } 531 } 532 533 static int ramoops_init_przs(const char *name, 534 struct device *dev, struct ramoops_context *cxt, 535 struct persistent_ram_zone ***przs, 536 phys_addr_t *paddr, size_t mem_sz, 537 ssize_t record_size, 538 unsigned int *cnt, u32 sig, u32 flags) 539 { 540 int err = -ENOMEM; 541 int i; 542 size_t zone_sz; 543 struct persistent_ram_zone **prz_ar; 544 545 /* Allocate nothing for 0 mem_sz or 0 record_size. */ 546 if (mem_sz == 0 || record_size == 0) { 547 *cnt = 0; 548 return 0; 549 } 550 551 /* 552 * If we have a negative record size, calculate it based on 553 * mem_sz / *cnt. If we have a positive record size, calculate 554 * cnt from mem_sz / record_size. 555 */ 556 if (record_size < 0) { 557 if (*cnt == 0) 558 return 0; 559 record_size = mem_sz / *cnt; 560 if (record_size == 0) { 561 dev_err(dev, "%s record size == 0 (%zu / %u)\n", 562 name, mem_sz, *cnt); 563 goto fail; 564 } 565 } else { 566 *cnt = mem_sz / record_size; 567 if (*cnt == 0) { 568 dev_err(dev, "%s record count == 0 (%zu / %zu)\n", 569 name, mem_sz, record_size); 570 goto fail; 571 } 572 } 573 574 if (*paddr + mem_sz - cxt->phys_addr > cxt->size) { 575 dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n", 576 name, 577 mem_sz, (unsigned long long)*paddr, 578 cxt->size, (unsigned long long)cxt->phys_addr); 579 goto fail; 580 } 581 582 zone_sz = mem_sz / *cnt; 583 if (!zone_sz) { 584 dev_err(dev, "%s zone size == 0\n", name); 585 goto fail; 586 } 587 588 prz_ar = kcalloc(*cnt, sizeof(**przs), GFP_KERNEL); 589 if (!prz_ar) 590 goto fail; 591 592 for (i = 0; i < *cnt; i++) { 593 prz_ar[i] = persistent_ram_new(*paddr, zone_sz, sig, 594 &cxt->ecc_info, 595 cxt->memtype, flags); 596 if (IS_ERR(prz_ar[i])) { 597 err = PTR_ERR(prz_ar[i]); 598 dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n", 599 name, record_size, 600 (unsigned long long)*paddr, err); 601 602 while (i > 0) { 603 i--; 604 persistent_ram_free(prz_ar[i]); 605 } 606 kfree(prz_ar); 607 goto fail; 608 } 609 *paddr += zone_sz; 610 } 611 612 *przs = prz_ar; 613 return 0; 614 615 fail: 616 *cnt = 0; 617 return err; 618 } 619 620 static int ramoops_init_prz(const char *name, 621 struct device *dev, struct ramoops_context *cxt, 622 struct persistent_ram_zone **prz, 623 phys_addr_t *paddr, size_t sz, u32 sig) 624 { 625 if (!sz) 626 return 0; 627 628 if (*paddr + sz - cxt->phys_addr > cxt->size) { 629 dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n", 630 name, sz, (unsigned long long)*paddr, 631 cxt->size, (unsigned long long)cxt->phys_addr); 632 return -ENOMEM; 633 } 634 635 *prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info, 636 cxt->memtype, 0); 637 if (IS_ERR(*prz)) { 638 int err = PTR_ERR(*prz); 639 640 dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n", 641 name, sz, (unsigned long long)*paddr, err); 642 return err; 643 } 644 645 persistent_ram_zap(*prz); 646 647 *paddr += sz; 648 649 return 0; 650 } 651 652 static int ramoops_parse_dt_size(struct platform_device *pdev, 653 const char *propname, u32 *value) 654 { 655 u32 val32 = 0; 656 int ret; 657 658 ret = of_property_read_u32(pdev->dev.of_node, propname, &val32); 659 if (ret < 0 && ret != -EINVAL) { 660 dev_err(&pdev->dev, "failed to parse property %s: %d\n", 661 propname, ret); 662 return ret; 663 } 664 665 if (val32 > INT_MAX) { 666 dev_err(&pdev->dev, "%s %u > INT_MAX\n", propname, val32); 667 return -EOVERFLOW; 668 } 669 670 *value = val32; 671 return 0; 672 } 673 674 static int ramoops_parse_dt(struct platform_device *pdev, 675 struct ramoops_platform_data *pdata) 676 { 677 struct device_node *of_node = pdev->dev.of_node; 678 struct resource *res; 679 u32 value; 680 int ret; 681 682 dev_dbg(&pdev->dev, "using Device Tree\n"); 683 684 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 685 if (!res) { 686 dev_err(&pdev->dev, 687 "failed to locate DT /reserved-memory resource\n"); 688 return -EINVAL; 689 } 690 691 pdata->mem_size = resource_size(res); 692 pdata->mem_address = res->start; 693 pdata->mem_type = of_property_read_bool(of_node, "unbuffered"); 694 pdata->dump_oops = !of_property_read_bool(of_node, "no-dump-oops"); 695 696 #define parse_size(name, field) { \ 697 ret = ramoops_parse_dt_size(pdev, name, &value); \ 698 if (ret < 0) \ 699 return ret; \ 700 field = value; \ 701 } 702 703 parse_size("record-size", pdata->record_size); 704 parse_size("console-size", pdata->console_size); 705 parse_size("ftrace-size", pdata->ftrace_size); 706 parse_size("pmsg-size", pdata->pmsg_size); 707 parse_size("ecc-size", pdata->ecc_info.ecc_size); 708 parse_size("flags", pdata->flags); 709 710 #undef parse_size 711 712 return 0; 713 } 714 715 static int ramoops_probe(struct platform_device *pdev) 716 { 717 struct device *dev = &pdev->dev; 718 struct ramoops_platform_data *pdata = dev->platform_data; 719 struct ramoops_context *cxt = &oops_cxt; 720 size_t dump_mem_sz; 721 phys_addr_t paddr; 722 int err = -EINVAL; 723 724 if (dev_of_node(dev) && !pdata) { 725 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 726 if (!pdata) { 727 pr_err("cannot allocate platform data buffer\n"); 728 err = -ENOMEM; 729 goto fail_out; 730 } 731 732 err = ramoops_parse_dt(pdev, pdata); 733 if (err < 0) 734 goto fail_out; 735 } 736 737 /* 738 * Only a single ramoops area allowed at a time, so fail extra 739 * probes. 740 */ 741 if (cxt->max_dump_cnt) { 742 pr_err("already initialized\n"); 743 goto fail_out; 744 } 745 746 /* Make sure we didn't get bogus platform data pointer. */ 747 if (!pdata) { 748 pr_err("NULL platform data\n"); 749 goto fail_out; 750 } 751 752 if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size && 753 !pdata->ftrace_size && !pdata->pmsg_size)) { 754 pr_err("The memory size and the record/console size must be " 755 "non-zero\n"); 756 goto fail_out; 757 } 758 759 if (pdata->record_size && !is_power_of_2(pdata->record_size)) 760 pdata->record_size = rounddown_pow_of_two(pdata->record_size); 761 if (pdata->console_size && !is_power_of_2(pdata->console_size)) 762 pdata->console_size = rounddown_pow_of_two(pdata->console_size); 763 if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size)) 764 pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size); 765 if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size)) 766 pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size); 767 768 cxt->size = pdata->mem_size; 769 cxt->phys_addr = pdata->mem_address; 770 cxt->memtype = pdata->mem_type; 771 cxt->record_size = pdata->record_size; 772 cxt->console_size = pdata->console_size; 773 cxt->ftrace_size = pdata->ftrace_size; 774 cxt->pmsg_size = pdata->pmsg_size; 775 cxt->dump_oops = pdata->dump_oops; 776 cxt->flags = pdata->flags; 777 cxt->ecc_info = pdata->ecc_info; 778 779 paddr = cxt->phys_addr; 780 781 dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size 782 - cxt->pmsg_size; 783 err = ramoops_init_przs("dump", dev, cxt, &cxt->dprzs, &paddr, 784 dump_mem_sz, cxt->record_size, 785 &cxt->max_dump_cnt, 0, 0); 786 if (err) 787 goto fail_out; 788 789 err = ramoops_init_prz("console", dev, cxt, &cxt->cprz, &paddr, 790 cxt->console_size, 0); 791 if (err) 792 goto fail_init_cprz; 793 794 cxt->max_ftrace_cnt = (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU) 795 ? nr_cpu_ids 796 : 1; 797 err = ramoops_init_przs("ftrace", dev, cxt, &cxt->fprzs, &paddr, 798 cxt->ftrace_size, -1, 799 &cxt->max_ftrace_cnt, LINUX_VERSION_CODE, 800 (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU) 801 ? PRZ_FLAG_NO_LOCK : 0); 802 if (err) 803 goto fail_init_fprz; 804 805 err = ramoops_init_prz("pmsg", dev, cxt, &cxt->mprz, &paddr, 806 cxt->pmsg_size, 0); 807 if (err) 808 goto fail_init_mprz; 809 810 cxt->pstore.data = cxt; 811 /* 812 * Console can handle any buffer size, so prefer LOG_LINE_MAX. If we 813 * have to handle dumps, we must have at least record_size buffer. And 814 * for ftrace, bufsize is irrelevant (if bufsize is 0, buf will be 815 * ZERO_SIZE_PTR). 816 */ 817 if (cxt->console_size) 818 cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */ 819 cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize); 820 cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL); 821 if (!cxt->pstore.buf) { 822 pr_err("cannot allocate pstore buffer\n"); 823 err = -ENOMEM; 824 goto fail_clear; 825 } 826 spin_lock_init(&cxt->pstore.buf_lock); 827 828 cxt->pstore.flags = PSTORE_FLAGS_DMESG; 829 if (cxt->console_size) 830 cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE; 831 if (cxt->ftrace_size) 832 cxt->pstore.flags |= PSTORE_FLAGS_FTRACE; 833 if (cxt->pmsg_size) 834 cxt->pstore.flags |= PSTORE_FLAGS_PMSG; 835 836 err = pstore_register(&cxt->pstore); 837 if (err) { 838 pr_err("registering with pstore failed\n"); 839 goto fail_buf; 840 } 841 842 /* 843 * Update the module parameter variables as well so they are visible 844 * through /sys/module/ramoops/parameters/ 845 */ 846 mem_size = pdata->mem_size; 847 mem_address = pdata->mem_address; 848 record_size = pdata->record_size; 849 dump_oops = pdata->dump_oops; 850 ramoops_console_size = pdata->console_size; 851 ramoops_pmsg_size = pdata->pmsg_size; 852 ramoops_ftrace_size = pdata->ftrace_size; 853 854 pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n", 855 cxt->size, (unsigned long long)cxt->phys_addr, 856 cxt->ecc_info.ecc_size, cxt->ecc_info.block_size); 857 858 return 0; 859 860 fail_buf: 861 kfree(cxt->pstore.buf); 862 fail_clear: 863 cxt->pstore.bufsize = 0; 864 persistent_ram_free(cxt->mprz); 865 fail_init_mprz: 866 fail_init_fprz: 867 persistent_ram_free(cxt->cprz); 868 fail_init_cprz: 869 ramoops_free_przs(cxt); 870 fail_out: 871 return err; 872 } 873 874 static int ramoops_remove(struct platform_device *pdev) 875 { 876 struct ramoops_context *cxt = &oops_cxt; 877 878 pstore_unregister(&cxt->pstore); 879 880 kfree(cxt->pstore.buf); 881 cxt->pstore.bufsize = 0; 882 883 persistent_ram_free(cxt->mprz); 884 persistent_ram_free(cxt->cprz); 885 ramoops_free_przs(cxt); 886 887 return 0; 888 } 889 890 static const struct of_device_id dt_match[] = { 891 { .compatible = "ramoops" }, 892 {} 893 }; 894 895 static struct platform_driver ramoops_driver = { 896 .probe = ramoops_probe, 897 .remove = ramoops_remove, 898 .driver = { 899 .name = "ramoops", 900 .of_match_table = dt_match, 901 }, 902 }; 903 904 static void ramoops_register_dummy(void) 905 { 906 if (!mem_size) 907 return; 908 909 pr_info("using module parameters\n"); 910 911 dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL); 912 if (!dummy_data) { 913 pr_info("could not allocate pdata\n"); 914 return; 915 } 916 917 dummy_data->mem_size = mem_size; 918 dummy_data->mem_address = mem_address; 919 dummy_data->mem_type = mem_type; 920 dummy_data->record_size = record_size; 921 dummy_data->console_size = ramoops_console_size; 922 dummy_data->ftrace_size = ramoops_ftrace_size; 923 dummy_data->pmsg_size = ramoops_pmsg_size; 924 dummy_data->dump_oops = dump_oops; 925 dummy_data->flags = RAMOOPS_FLAG_FTRACE_PER_CPU; 926 927 /* 928 * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC 929 * (using 1 byte for ECC isn't much of use anyway). 930 */ 931 dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc; 932 933 dummy = platform_device_register_data(NULL, "ramoops", -1, 934 dummy_data, sizeof(struct ramoops_platform_data)); 935 if (IS_ERR(dummy)) { 936 pr_info("could not create platform device: %ld\n", 937 PTR_ERR(dummy)); 938 } 939 } 940 941 static int __init ramoops_init(void) 942 { 943 ramoops_register_dummy(); 944 return platform_driver_register(&ramoops_driver); 945 } 946 postcore_initcall(ramoops_init); 947 948 static void __exit ramoops_exit(void) 949 { 950 platform_driver_unregister(&ramoops_driver); 951 platform_device_unregister(dummy); 952 kfree(dummy_data); 953 } 954 module_exit(ramoops_exit); 955 956 MODULE_LICENSE("GPL"); 957 MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>"); 958 MODULE_DESCRIPTION("RAM Oops/Panic logger/driver"); 959