1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Provide a pstore intermediate backend, organized into kernel memory 4 * allocated zones that are then mapped and flushed into a single 5 * contiguous region on a storage backend of some kind (block, mtd, etc). 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/mount.h> 14 #include <linux/printk.h> 15 #include <linux/fs.h> 16 #include <linux/pstore_zone.h> 17 #include <linux/kdev_t.h> 18 #include <linux/device.h> 19 #include <linux/namei.h> 20 #include <linux/fcntl.h> 21 #include <linux/uio.h> 22 #include <linux/writeback.h> 23 #include "internal.h" 24 25 /** 26 * struct psz_buffer - header of zone to flush to storage 27 * 28 * @sig: signature to indicate header (PSZ_SIG xor PSZONE-type value) 29 * @datalen: length of data in @data 30 * @start: offset into @data where the beginning of the stored bytes begin 31 * @data: zone data. 32 */ 33 struct psz_buffer { 34 #define PSZ_SIG (0x43474244) /* DBGC */ 35 uint32_t sig; 36 atomic_t datalen; 37 atomic_t start; 38 uint8_t data[]; 39 }; 40 41 /** 42 * struct psz_kmsg_header - kmsg dump-specific header to flush to storage 43 * 44 * @magic: magic num for kmsg dump header 45 * @time: kmsg dump trigger time 46 * @compressed: whether conpressed 47 * @counter: kmsg dump counter 48 * @reason: the kmsg dump reason (e.g. oops, panic, etc) 49 * @data: pointer to log data 50 * 51 * This is a sub-header for a kmsg dump, trailing after &psz_buffer. 52 */ 53 struct psz_kmsg_header { 54 #define PSTORE_KMSG_HEADER_MAGIC 0x4dfc3ae5 /* Just a random number */ 55 uint32_t magic; 56 struct timespec64 time; 57 bool compressed; 58 uint32_t counter; 59 enum kmsg_dump_reason reason; 60 uint8_t data[]; 61 }; 62 63 /** 64 * struct pstore_zone - single stored buffer 65 * 66 * @off: zone offset of storage 67 * @type: front-end type for this zone 68 * @name: front-end name for this zone 69 * @buffer: pointer to data buffer managed by this zone 70 * @oldbuf: pointer to old data buffer 71 * @buffer_size: bytes in @buffer->data 72 * @should_recover: whether this zone should recover from storage 73 * @dirty: whether the data in @buffer dirty 74 * 75 * zone structure in memory. 76 */ 77 struct pstore_zone { 78 loff_t off; 79 const char *name; 80 enum pstore_type_id type; 81 82 struct psz_buffer *buffer; 83 struct psz_buffer *oldbuf; 84 size_t buffer_size; 85 bool should_recover; 86 atomic_t dirty; 87 }; 88 89 /** 90 * struct psz_context - all about running state of pstore/zone 91 * 92 * @kpszs: kmsg dump storage zones 93 * @ppsz: pmsg storage zone 94 * @cpsz: console storage zone 95 * @fpszs: ftrace storage zones 96 * @kmsg_max_cnt: max count of @kpszs 97 * @kmsg_read_cnt: counter of total read kmsg dumps 98 * @kmsg_write_cnt: counter of total kmsg dump writes 99 * @pmsg_read_cnt: counter of total read pmsg zone 100 * @console_read_cnt: counter of total read console zone 101 * @ftrace_max_cnt: max count of @fpszs 102 * @ftrace_read_cnt: counter of max read ftrace zone 103 * @oops_counter: counter of oops dumps 104 * @panic_counter: counter of panic dumps 105 * @recovered: whether finished recovering data from storage 106 * @on_panic: whether panic is happening 107 * @pstore_zone_info_lock: lock to @pstore_zone_info 108 * @pstore_zone_info: information from backend 109 * @pstore: structure for pstore 110 */ 111 struct psz_context { 112 struct pstore_zone **kpszs; 113 struct pstore_zone *ppsz; 114 struct pstore_zone *cpsz; 115 struct pstore_zone **fpszs; 116 unsigned int kmsg_max_cnt; 117 unsigned int kmsg_read_cnt; 118 unsigned int kmsg_write_cnt; 119 unsigned int pmsg_read_cnt; 120 unsigned int console_read_cnt; 121 unsigned int ftrace_max_cnt; 122 unsigned int ftrace_read_cnt; 123 /* 124 * These counters should be calculated during recovery. 125 * It records the oops/panic times after crashes rather than boots. 126 */ 127 unsigned int oops_counter; 128 unsigned int panic_counter; 129 atomic_t recovered; 130 atomic_t on_panic; 131 132 /* 133 * pstore_zone_info_lock protects this entire structure during calls 134 * to register_pstore_zone()/unregister_pstore_zone(). 135 */ 136 struct mutex pstore_zone_info_lock; 137 struct pstore_zone_info *pstore_zone_info; 138 struct pstore_info pstore; 139 }; 140 static struct psz_context pstore_zone_cxt; 141 142 static void psz_flush_all_dirty_zones(struct work_struct *); 143 static DECLARE_DELAYED_WORK(psz_cleaner, psz_flush_all_dirty_zones); 144 145 /** 146 * enum psz_flush_mode - flush mode for psz_zone_write() 147 * 148 * @FLUSH_NONE: do not flush to storage but update data on memory 149 * @FLUSH_PART: just flush part of data including meta data to storage 150 * @FLUSH_META: just flush meta data of zone to storage 151 * @FLUSH_ALL: flush all of zone 152 */ 153 enum psz_flush_mode { 154 FLUSH_NONE = 0, 155 FLUSH_PART, 156 FLUSH_META, 157 FLUSH_ALL, 158 }; 159 160 static inline int buffer_datalen(struct pstore_zone *zone) 161 { 162 return atomic_read(&zone->buffer->datalen); 163 } 164 165 static inline int buffer_start(struct pstore_zone *zone) 166 { 167 return atomic_read(&zone->buffer->start); 168 } 169 170 static inline bool is_on_panic(void) 171 { 172 return atomic_read(&pstore_zone_cxt.on_panic); 173 } 174 175 static ssize_t psz_zone_read_buffer(struct pstore_zone *zone, char *buf, 176 size_t len, unsigned long off) 177 { 178 if (!buf || !zone || !zone->buffer) 179 return -EINVAL; 180 if (off > zone->buffer_size) 181 return -EINVAL; 182 len = min_t(size_t, len, zone->buffer_size - off); 183 memcpy(buf, zone->buffer->data + off, len); 184 return len; 185 } 186 187 static int psz_zone_read_oldbuf(struct pstore_zone *zone, char *buf, 188 size_t len, unsigned long off) 189 { 190 if (!buf || !zone || !zone->oldbuf) 191 return -EINVAL; 192 if (off > zone->buffer_size) 193 return -EINVAL; 194 len = min_t(size_t, len, zone->buffer_size - off); 195 memcpy(buf, zone->oldbuf->data + off, len); 196 return 0; 197 } 198 199 static int psz_zone_write(struct pstore_zone *zone, 200 enum psz_flush_mode flush_mode, const char *buf, 201 size_t len, unsigned long off) 202 { 203 struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info; 204 ssize_t wcnt = 0; 205 ssize_t (*writeop)(const char *buf, size_t bytes, loff_t pos); 206 size_t wlen; 207 208 if (off > zone->buffer_size) 209 return -EINVAL; 210 211 wlen = min_t(size_t, len, zone->buffer_size - off); 212 if (buf && wlen) { 213 memcpy(zone->buffer->data + off, buf, wlen); 214 atomic_set(&zone->buffer->datalen, wlen + off); 215 } 216 217 /* avoid to damage old records */ 218 if (!is_on_panic() && !atomic_read(&pstore_zone_cxt.recovered)) 219 goto dirty; 220 221 writeop = is_on_panic() ? info->panic_write : info->write; 222 if (!writeop) 223 goto dirty; 224 225 switch (flush_mode) { 226 case FLUSH_NONE: 227 if (unlikely(buf && wlen)) 228 goto dirty; 229 return 0; 230 case FLUSH_PART: 231 wcnt = writeop((const char *)zone->buffer->data + off, wlen, 232 zone->off + sizeof(*zone->buffer) + off); 233 if (wcnt != wlen) 234 goto dirty; 235 fallthrough; 236 case FLUSH_META: 237 wlen = sizeof(struct psz_buffer); 238 wcnt = writeop((const char *)zone->buffer, wlen, zone->off); 239 if (wcnt != wlen) 240 goto dirty; 241 break; 242 case FLUSH_ALL: 243 wlen = zone->buffer_size + sizeof(*zone->buffer); 244 wcnt = writeop((const char *)zone->buffer, wlen, zone->off); 245 if (wcnt != wlen) 246 goto dirty; 247 break; 248 } 249 250 return 0; 251 dirty: 252 /* no need to mark dirty if going to try next zone */ 253 if (wcnt == -ENOMSG) 254 return -ENOMSG; 255 atomic_set(&zone->dirty, true); 256 /* flush dirty zones nicely */ 257 if (wcnt == -EBUSY && !is_on_panic()) 258 schedule_delayed_work(&psz_cleaner, msecs_to_jiffies(500)); 259 return -EBUSY; 260 } 261 262 static int psz_flush_dirty_zone(struct pstore_zone *zone) 263 { 264 int ret; 265 266 if (unlikely(!zone)) 267 return -EINVAL; 268 269 if (unlikely(!atomic_read(&pstore_zone_cxt.recovered))) 270 return -EBUSY; 271 272 if (!atomic_xchg(&zone->dirty, false)) 273 return 0; 274 275 ret = psz_zone_write(zone, FLUSH_ALL, NULL, 0, 0); 276 if (ret) 277 atomic_set(&zone->dirty, true); 278 return ret; 279 } 280 281 static int psz_flush_dirty_zones(struct pstore_zone **zones, unsigned int cnt) 282 { 283 int i, ret; 284 struct pstore_zone *zone; 285 286 if (!zones) 287 return -EINVAL; 288 289 for (i = 0; i < cnt; i++) { 290 zone = zones[i]; 291 if (!zone) 292 return -EINVAL; 293 ret = psz_flush_dirty_zone(zone); 294 if (ret) 295 return ret; 296 } 297 return 0; 298 } 299 300 static int psz_move_zone(struct pstore_zone *old, struct pstore_zone *new) 301 { 302 const char *data = (const char *)old->buffer->data; 303 int ret; 304 305 ret = psz_zone_write(new, FLUSH_ALL, data, buffer_datalen(old), 0); 306 if (ret) { 307 atomic_set(&new->buffer->datalen, 0); 308 atomic_set(&new->dirty, false); 309 return ret; 310 } 311 atomic_set(&old->buffer->datalen, 0); 312 return 0; 313 } 314 315 static void psz_flush_all_dirty_zones(struct work_struct *work) 316 { 317 struct psz_context *cxt = &pstore_zone_cxt; 318 int ret = 0; 319 320 if (cxt->ppsz) 321 ret |= psz_flush_dirty_zone(cxt->ppsz); 322 if (cxt->cpsz) 323 ret |= psz_flush_dirty_zone(cxt->cpsz); 324 if (cxt->kpszs) 325 ret |= psz_flush_dirty_zones(cxt->kpszs, cxt->kmsg_max_cnt); 326 if (cxt->fpszs) 327 ret |= psz_flush_dirty_zones(cxt->fpszs, cxt->ftrace_max_cnt); 328 if (ret && cxt->pstore_zone_info) 329 schedule_delayed_work(&psz_cleaner, msecs_to_jiffies(1000)); 330 } 331 332 static int psz_kmsg_recover_data(struct psz_context *cxt) 333 { 334 struct pstore_zone_info *info = cxt->pstore_zone_info; 335 struct pstore_zone *zone = NULL; 336 struct psz_buffer *buf; 337 unsigned long i; 338 ssize_t rcnt; 339 340 if (!info->read) 341 return -EINVAL; 342 343 for (i = 0; i < cxt->kmsg_max_cnt; i++) { 344 zone = cxt->kpszs[i]; 345 if (unlikely(!zone)) 346 return -EINVAL; 347 if (atomic_read(&zone->dirty)) { 348 unsigned int wcnt = cxt->kmsg_write_cnt; 349 struct pstore_zone *new = cxt->kpszs[wcnt]; 350 int ret; 351 352 ret = psz_move_zone(zone, new); 353 if (ret) { 354 pr_err("move zone from %lu to %d failed\n", 355 i, wcnt); 356 return ret; 357 } 358 cxt->kmsg_write_cnt = (wcnt + 1) % cxt->kmsg_max_cnt; 359 } 360 if (!zone->should_recover) 361 continue; 362 buf = zone->buffer; 363 rcnt = info->read((char *)buf, zone->buffer_size + sizeof(*buf), 364 zone->off); 365 if (rcnt != zone->buffer_size + sizeof(*buf)) 366 return rcnt < 0 ? rcnt : -EIO; 367 } 368 return 0; 369 } 370 371 static int psz_kmsg_recover_meta(struct psz_context *cxt) 372 { 373 struct pstore_zone_info *info = cxt->pstore_zone_info; 374 struct pstore_zone *zone; 375 ssize_t rcnt, len; 376 struct psz_buffer *buf; 377 struct psz_kmsg_header *hdr; 378 struct timespec64 time = { }; 379 unsigned long i; 380 /* 381 * Recover may on panic, we can't allocate any memory by kmalloc. 382 * So, we use local array instead. 383 */ 384 char buffer_header[sizeof(*buf) + sizeof(*hdr)] = {0}; 385 386 if (!info->read) 387 return -EINVAL; 388 389 len = sizeof(*buf) + sizeof(*hdr); 390 buf = (struct psz_buffer *)buffer_header; 391 for (i = 0; i < cxt->kmsg_max_cnt; i++) { 392 zone = cxt->kpszs[i]; 393 if (unlikely(!zone)) 394 return -EINVAL; 395 396 rcnt = info->read((char *)buf, len, zone->off); 397 if (rcnt == -ENOMSG) { 398 pr_debug("%s with id %lu may be broken, skip\n", 399 zone->name, i); 400 continue; 401 } else if (rcnt != len) { 402 pr_err("read %s with id %lu failed\n", zone->name, i); 403 return rcnt < 0 ? rcnt : -EIO; 404 } 405 406 if (buf->sig != zone->buffer->sig) { 407 pr_debug("no valid data in kmsg dump zone %lu\n", i); 408 continue; 409 } 410 411 if (zone->buffer_size < atomic_read(&buf->datalen)) { 412 pr_info("found overtop zone: %s: id %lu, off %lld, size %zu\n", 413 zone->name, i, zone->off, 414 zone->buffer_size); 415 continue; 416 } 417 418 hdr = (struct psz_kmsg_header *)buf->data; 419 if (hdr->magic != PSTORE_KMSG_HEADER_MAGIC) { 420 pr_info("found invalid zone: %s: id %lu, off %lld, size %zu\n", 421 zone->name, i, zone->off, 422 zone->buffer_size); 423 continue; 424 } 425 426 /* 427 * we get the newest zone, and the next one must be the oldest 428 * or unused zone, because we do write one by one like a circle. 429 */ 430 if (hdr->time.tv_sec >= time.tv_sec) { 431 time.tv_sec = hdr->time.tv_sec; 432 cxt->kmsg_write_cnt = (i + 1) % cxt->kmsg_max_cnt; 433 } 434 435 if (hdr->reason == KMSG_DUMP_OOPS) 436 cxt->oops_counter = 437 max(cxt->oops_counter, hdr->counter); 438 else if (hdr->reason == KMSG_DUMP_PANIC) 439 cxt->panic_counter = 440 max(cxt->panic_counter, hdr->counter); 441 442 if (!atomic_read(&buf->datalen)) { 443 pr_debug("found erased zone: %s: id %lu, off %lld, size %zu, datalen %d\n", 444 zone->name, i, zone->off, 445 zone->buffer_size, 446 atomic_read(&buf->datalen)); 447 continue; 448 } 449 450 if (!is_on_panic()) 451 zone->should_recover = true; 452 pr_debug("found nice zone: %s: id %lu, off %lld, size %zu, datalen %d\n", 453 zone->name, i, zone->off, 454 zone->buffer_size, atomic_read(&buf->datalen)); 455 } 456 457 return 0; 458 } 459 460 static int psz_kmsg_recover(struct psz_context *cxt) 461 { 462 int ret; 463 464 if (!cxt->kpszs) 465 return 0; 466 467 ret = psz_kmsg_recover_meta(cxt); 468 if (ret) 469 goto recover_fail; 470 471 ret = psz_kmsg_recover_data(cxt); 472 if (ret) 473 goto recover_fail; 474 475 return 0; 476 recover_fail: 477 pr_debug("psz_recover_kmsg failed\n"); 478 return ret; 479 } 480 481 static int psz_recover_zone(struct psz_context *cxt, struct pstore_zone *zone) 482 { 483 struct pstore_zone_info *info = cxt->pstore_zone_info; 484 struct psz_buffer *oldbuf, tmpbuf; 485 int ret = 0; 486 char *buf; 487 ssize_t rcnt, len, start, off; 488 489 if (!zone || zone->oldbuf) 490 return 0; 491 492 if (is_on_panic()) { 493 /* save data as much as possible */ 494 psz_flush_dirty_zone(zone); 495 return 0; 496 } 497 498 if (unlikely(!info->read)) 499 return -EINVAL; 500 501 len = sizeof(struct psz_buffer); 502 rcnt = info->read((char *)&tmpbuf, len, zone->off); 503 if (rcnt != len) { 504 pr_debug("read zone %s failed\n", zone->name); 505 return rcnt < 0 ? rcnt : -EIO; 506 } 507 508 if (tmpbuf.sig != zone->buffer->sig) { 509 pr_debug("no valid data in zone %s\n", zone->name); 510 return 0; 511 } 512 513 if (zone->buffer_size < atomic_read(&tmpbuf.datalen) || 514 zone->buffer_size < atomic_read(&tmpbuf.start)) { 515 pr_info("found overtop zone: %s: off %lld, size %zu\n", 516 zone->name, zone->off, zone->buffer_size); 517 /* just keep going */ 518 return 0; 519 } 520 521 if (!atomic_read(&tmpbuf.datalen)) { 522 pr_debug("found erased zone: %s: off %lld, size %zu, datalen %d\n", 523 zone->name, zone->off, zone->buffer_size, 524 atomic_read(&tmpbuf.datalen)); 525 return 0; 526 } 527 528 pr_debug("found nice zone: %s: off %lld, size %zu, datalen %d\n", 529 zone->name, zone->off, zone->buffer_size, 530 atomic_read(&tmpbuf.datalen)); 531 532 len = atomic_read(&tmpbuf.datalen) + sizeof(*oldbuf); 533 oldbuf = kzalloc(len, GFP_KERNEL); 534 if (!oldbuf) 535 return -ENOMEM; 536 537 memcpy(oldbuf, &tmpbuf, sizeof(*oldbuf)); 538 buf = (char *)oldbuf + sizeof(*oldbuf); 539 len = atomic_read(&oldbuf->datalen); 540 start = atomic_read(&oldbuf->start); 541 off = zone->off + sizeof(*oldbuf); 542 543 /* get part of data */ 544 rcnt = info->read(buf, len - start, off + start); 545 if (rcnt != len - start) { 546 pr_err("read zone %s failed\n", zone->name); 547 ret = rcnt < 0 ? rcnt : -EIO; 548 goto free_oldbuf; 549 } 550 551 /* get the rest of data */ 552 rcnt = info->read(buf + len - start, start, off); 553 if (rcnt != start) { 554 pr_err("read zone %s failed\n", zone->name); 555 ret = rcnt < 0 ? rcnt : -EIO; 556 goto free_oldbuf; 557 } 558 559 zone->oldbuf = oldbuf; 560 psz_flush_dirty_zone(zone); 561 return 0; 562 563 free_oldbuf: 564 kfree(oldbuf); 565 return ret; 566 } 567 568 static int psz_recover_zones(struct psz_context *cxt, 569 struct pstore_zone **zones, unsigned int cnt) 570 { 571 int ret; 572 unsigned int i; 573 struct pstore_zone *zone; 574 575 if (!zones) 576 return 0; 577 578 for (i = 0; i < cnt; i++) { 579 zone = zones[i]; 580 if (unlikely(!zone)) 581 continue; 582 ret = psz_recover_zone(cxt, zone); 583 if (ret) 584 goto recover_fail; 585 } 586 587 return 0; 588 recover_fail: 589 pr_debug("recover %s[%u] failed\n", zone->name, i); 590 return ret; 591 } 592 593 /** 594 * psz_recovery() - recover data from storage 595 * @cxt: the context of pstore/zone 596 * 597 * recovery means reading data back from storage after rebooting 598 * 599 * Return: 0 on success, others on failure. 600 */ 601 static inline int psz_recovery(struct psz_context *cxt) 602 { 603 int ret; 604 605 if (atomic_read(&cxt->recovered)) 606 return 0; 607 608 ret = psz_kmsg_recover(cxt); 609 if (ret) 610 goto out; 611 612 ret = psz_recover_zone(cxt, cxt->ppsz); 613 if (ret) 614 goto out; 615 616 ret = psz_recover_zone(cxt, cxt->cpsz); 617 if (ret) 618 goto out; 619 620 ret = psz_recover_zones(cxt, cxt->fpszs, cxt->ftrace_max_cnt); 621 622 out: 623 if (unlikely(ret)) 624 pr_err("recover failed\n"); 625 else { 626 pr_debug("recover end!\n"); 627 atomic_set(&cxt->recovered, 1); 628 } 629 return ret; 630 } 631 632 static int psz_pstore_open(struct pstore_info *psi) 633 { 634 struct psz_context *cxt = psi->data; 635 636 cxt->kmsg_read_cnt = 0; 637 cxt->pmsg_read_cnt = 0; 638 cxt->console_read_cnt = 0; 639 cxt->ftrace_read_cnt = 0; 640 return 0; 641 } 642 643 static inline bool psz_old_ok(struct pstore_zone *zone) 644 { 645 if (zone && zone->oldbuf && atomic_read(&zone->oldbuf->datalen)) 646 return true; 647 return false; 648 } 649 650 static inline bool psz_ok(struct pstore_zone *zone) 651 { 652 if (zone && zone->buffer && buffer_datalen(zone)) 653 return true; 654 return false; 655 } 656 657 static inline int psz_kmsg_erase(struct psz_context *cxt, 658 struct pstore_zone *zone, struct pstore_record *record) 659 { 660 struct psz_buffer *buffer = zone->buffer; 661 struct psz_kmsg_header *hdr = 662 (struct psz_kmsg_header *)buffer->data; 663 size_t size; 664 665 if (unlikely(!psz_ok(zone))) 666 return 0; 667 668 /* this zone is already updated, no need to erase */ 669 if (record->count != hdr->counter) 670 return 0; 671 672 size = buffer_datalen(zone) + sizeof(*zone->buffer); 673 atomic_set(&zone->buffer->datalen, 0); 674 if (cxt->pstore_zone_info->erase) 675 return cxt->pstore_zone_info->erase(size, zone->off); 676 else 677 return psz_zone_write(zone, FLUSH_META, NULL, 0, 0); 678 } 679 680 static inline int psz_record_erase(struct psz_context *cxt, 681 struct pstore_zone *zone) 682 { 683 if (unlikely(!psz_old_ok(zone))) 684 return 0; 685 686 kfree(zone->oldbuf); 687 zone->oldbuf = NULL; 688 /* 689 * if there are new data in zone buffer, that means the old data 690 * are already invalid. It is no need to flush 0 (erase) to 691 * block device. 692 */ 693 if (!buffer_datalen(zone)) 694 return psz_zone_write(zone, FLUSH_META, NULL, 0, 0); 695 psz_flush_dirty_zone(zone); 696 return 0; 697 } 698 699 static int psz_pstore_erase(struct pstore_record *record) 700 { 701 struct psz_context *cxt = record->psi->data; 702 703 switch (record->type) { 704 case PSTORE_TYPE_DMESG: 705 if (record->id >= cxt->kmsg_max_cnt) 706 return -EINVAL; 707 return psz_kmsg_erase(cxt, cxt->kpszs[record->id], record); 708 case PSTORE_TYPE_PMSG: 709 return psz_record_erase(cxt, cxt->ppsz); 710 case PSTORE_TYPE_CONSOLE: 711 return psz_record_erase(cxt, cxt->cpsz); 712 case PSTORE_TYPE_FTRACE: 713 if (record->id >= cxt->ftrace_max_cnt) 714 return -EINVAL; 715 return psz_record_erase(cxt, cxt->fpszs[record->id]); 716 default: return -EINVAL; 717 } 718 } 719 720 static void psz_write_kmsg_hdr(struct pstore_zone *zone, 721 struct pstore_record *record) 722 { 723 struct psz_context *cxt = record->psi->data; 724 struct psz_buffer *buffer = zone->buffer; 725 struct psz_kmsg_header *hdr = 726 (struct psz_kmsg_header *)buffer->data; 727 728 hdr->magic = PSTORE_KMSG_HEADER_MAGIC; 729 hdr->compressed = record->compressed; 730 hdr->time.tv_sec = record->time.tv_sec; 731 hdr->time.tv_nsec = record->time.tv_nsec; 732 hdr->reason = record->reason; 733 if (hdr->reason == KMSG_DUMP_OOPS) 734 hdr->counter = ++cxt->oops_counter; 735 else if (hdr->reason == KMSG_DUMP_PANIC) 736 hdr->counter = ++cxt->panic_counter; 737 else 738 hdr->counter = 0; 739 } 740 741 /* 742 * In case zone is broken, which may occur to MTD device, we try each zones, 743 * start at cxt->kmsg_write_cnt. 744 */ 745 static inline int notrace psz_kmsg_write_record(struct psz_context *cxt, 746 struct pstore_record *record) 747 { 748 size_t size, hlen; 749 struct pstore_zone *zone; 750 unsigned int i; 751 752 for (i = 0; i < cxt->kmsg_max_cnt; i++) { 753 unsigned int zonenum, len; 754 int ret; 755 756 zonenum = (cxt->kmsg_write_cnt + i) % cxt->kmsg_max_cnt; 757 zone = cxt->kpszs[zonenum]; 758 if (unlikely(!zone)) 759 return -ENOSPC; 760 761 /* avoid destroying old data, allocate a new one */ 762 len = zone->buffer_size + sizeof(*zone->buffer); 763 zone->oldbuf = zone->buffer; 764 zone->buffer = kzalloc(len, GFP_ATOMIC); 765 if (!zone->buffer) { 766 zone->buffer = zone->oldbuf; 767 return -ENOMEM; 768 } 769 zone->buffer->sig = zone->oldbuf->sig; 770 771 pr_debug("write %s to zone id %d\n", zone->name, zonenum); 772 psz_write_kmsg_hdr(zone, record); 773 hlen = sizeof(struct psz_kmsg_header); 774 size = min_t(size_t, record->size, zone->buffer_size - hlen); 775 ret = psz_zone_write(zone, FLUSH_ALL, record->buf, size, hlen); 776 if (likely(!ret || ret != -ENOMSG)) { 777 cxt->kmsg_write_cnt = zonenum + 1; 778 cxt->kmsg_write_cnt %= cxt->kmsg_max_cnt; 779 /* no need to try next zone, free last zone buffer */ 780 kfree(zone->oldbuf); 781 zone->oldbuf = NULL; 782 return ret; 783 } 784 785 pr_debug("zone %u may be broken, try next dmesg zone\n", 786 zonenum); 787 kfree(zone->buffer); 788 zone->buffer = zone->oldbuf; 789 zone->oldbuf = NULL; 790 } 791 792 return -EBUSY; 793 } 794 795 static int notrace psz_kmsg_write(struct psz_context *cxt, 796 struct pstore_record *record) 797 { 798 int ret; 799 800 /* 801 * Explicitly only take the first part of any new crash. 802 * If our buffer is larger than kmsg_bytes, this can never happen, 803 * and if our buffer is smaller than kmsg_bytes, we don't want the 804 * report split across multiple records. 805 */ 806 if (record->part != 1) 807 return -ENOSPC; 808 809 if (!cxt->kpszs) 810 return -ENOSPC; 811 812 ret = psz_kmsg_write_record(cxt, record); 813 if (!ret && is_on_panic()) { 814 /* ensure all data are flushed to storage when panic */ 815 pr_debug("try to flush other dirty zones\n"); 816 psz_flush_all_dirty_zones(NULL); 817 } 818 819 /* always return 0 as we had handled it on buffer */ 820 return 0; 821 } 822 823 static int notrace psz_record_write(struct pstore_zone *zone, 824 struct pstore_record *record) 825 { 826 size_t start, rem; 827 bool is_full_data = false; 828 char *buf; 829 int cnt; 830 831 if (!zone || !record) 832 return -ENOSPC; 833 834 if (atomic_read(&zone->buffer->datalen) >= zone->buffer_size) 835 is_full_data = true; 836 837 cnt = record->size; 838 buf = record->buf; 839 if (unlikely(cnt > zone->buffer_size)) { 840 buf += cnt - zone->buffer_size; 841 cnt = zone->buffer_size; 842 } 843 844 start = buffer_start(zone); 845 rem = zone->buffer_size - start; 846 if (unlikely(rem < cnt)) { 847 psz_zone_write(zone, FLUSH_PART, buf, rem, start); 848 buf += rem; 849 cnt -= rem; 850 start = 0; 851 is_full_data = true; 852 } 853 854 atomic_set(&zone->buffer->start, cnt + start); 855 psz_zone_write(zone, FLUSH_PART, buf, cnt, start); 856 857 /** 858 * psz_zone_write will set datalen as start + cnt. 859 * It work if actual data length lesser than buffer size. 860 * If data length greater than buffer size, pmsg will rewrite to 861 * beginning of zone, which make buffer->datalen wrongly. 862 * So we should reset datalen as buffer size once actual data length 863 * greater than buffer size. 864 */ 865 if (is_full_data) { 866 atomic_set(&zone->buffer->datalen, zone->buffer_size); 867 psz_zone_write(zone, FLUSH_META, NULL, 0, 0); 868 } 869 return 0; 870 } 871 872 static int notrace psz_pstore_write(struct pstore_record *record) 873 { 874 struct psz_context *cxt = record->psi->data; 875 876 if (record->type == PSTORE_TYPE_DMESG && 877 record->reason == KMSG_DUMP_PANIC) 878 atomic_set(&cxt->on_panic, 1); 879 880 /* 881 * if on panic, do not write except panic records 882 * Fix case that panic_write prints log which wakes up console backend. 883 */ 884 if (is_on_panic() && record->type != PSTORE_TYPE_DMESG) 885 return -EBUSY; 886 887 switch (record->type) { 888 case PSTORE_TYPE_DMESG: 889 return psz_kmsg_write(cxt, record); 890 case PSTORE_TYPE_CONSOLE: 891 return psz_record_write(cxt->cpsz, record); 892 case PSTORE_TYPE_PMSG: 893 return psz_record_write(cxt->ppsz, record); 894 case PSTORE_TYPE_FTRACE: { 895 int zonenum = smp_processor_id(); 896 897 if (!cxt->fpszs) 898 return -ENOSPC; 899 return psz_record_write(cxt->fpszs[zonenum], record); 900 } 901 default: 902 return -EINVAL; 903 } 904 } 905 906 static struct pstore_zone *psz_read_next_zone(struct psz_context *cxt) 907 { 908 struct pstore_zone *zone = NULL; 909 910 while (cxt->kmsg_read_cnt < cxt->kmsg_max_cnt) { 911 zone = cxt->kpszs[cxt->kmsg_read_cnt++]; 912 if (psz_ok(zone)) 913 return zone; 914 } 915 916 if (cxt->ftrace_read_cnt < cxt->ftrace_max_cnt) 917 /* 918 * No need psz_old_ok(). Let psz_ftrace_read() do so for 919 * combination. psz_ftrace_read() should traverse over 920 * all zones in case of some zone without data. 921 */ 922 return cxt->fpszs[cxt->ftrace_read_cnt++]; 923 924 if (cxt->pmsg_read_cnt == 0) { 925 cxt->pmsg_read_cnt++; 926 zone = cxt->ppsz; 927 if (psz_old_ok(zone)) 928 return zone; 929 } 930 931 if (cxt->console_read_cnt == 0) { 932 cxt->console_read_cnt++; 933 zone = cxt->cpsz; 934 if (psz_old_ok(zone)) 935 return zone; 936 } 937 938 return NULL; 939 } 940 941 static int psz_kmsg_read_hdr(struct pstore_zone *zone, 942 struct pstore_record *record) 943 { 944 struct psz_buffer *buffer = zone->buffer; 945 struct psz_kmsg_header *hdr = 946 (struct psz_kmsg_header *)buffer->data; 947 948 if (hdr->magic != PSTORE_KMSG_HEADER_MAGIC) 949 return -EINVAL; 950 record->compressed = hdr->compressed; 951 record->time.tv_sec = hdr->time.tv_sec; 952 record->time.tv_nsec = hdr->time.tv_nsec; 953 record->reason = hdr->reason; 954 record->count = hdr->counter; 955 return 0; 956 } 957 958 static ssize_t psz_kmsg_read(struct pstore_zone *zone, 959 struct pstore_record *record) 960 { 961 ssize_t size, hlen = 0; 962 963 size = buffer_datalen(zone); 964 /* Clear and skip this kmsg dump record if it has no valid header */ 965 if (psz_kmsg_read_hdr(zone, record)) { 966 atomic_set(&zone->buffer->datalen, 0); 967 atomic_set(&zone->dirty, 0); 968 return -ENOMSG; 969 } 970 size -= sizeof(struct psz_kmsg_header); 971 972 if (!record->compressed) { 973 char *buf = kasprintf(GFP_KERNEL, "%s: Total %d times\n", 974 kmsg_dump_reason_str(record->reason), 975 record->count); 976 hlen = strlen(buf); 977 record->buf = krealloc(buf, hlen + size, GFP_KERNEL); 978 if (!record->buf) { 979 kfree(buf); 980 return -ENOMEM; 981 } 982 } else { 983 record->buf = kmalloc(size, GFP_KERNEL); 984 if (!record->buf) 985 return -ENOMEM; 986 } 987 988 size = psz_zone_read_buffer(zone, record->buf + hlen, size, 989 sizeof(struct psz_kmsg_header)); 990 if (unlikely(size < 0)) { 991 kfree(record->buf); 992 return -ENOMSG; 993 } 994 995 return size + hlen; 996 } 997 998 /* try to combine all ftrace zones */ 999 static ssize_t psz_ftrace_read(struct pstore_zone *zone, 1000 struct pstore_record *record) 1001 { 1002 struct psz_context *cxt; 1003 struct psz_buffer *buf; 1004 int ret; 1005 1006 if (!zone || !record) 1007 return -ENOSPC; 1008 1009 if (!psz_old_ok(zone)) 1010 goto out; 1011 1012 buf = (struct psz_buffer *)zone->oldbuf; 1013 if (!buf) 1014 return -ENOMSG; 1015 1016 ret = pstore_ftrace_combine_log(&record->buf, &record->size, 1017 (char *)buf->data, atomic_read(&buf->datalen)); 1018 if (unlikely(ret)) 1019 return ret; 1020 1021 out: 1022 cxt = record->psi->data; 1023 if (cxt->ftrace_read_cnt < cxt->ftrace_max_cnt) 1024 /* then, read next ftrace zone */ 1025 return -ENOMSG; 1026 record->id = 0; 1027 return record->size ? record->size : -ENOMSG; 1028 } 1029 1030 static ssize_t psz_record_read(struct pstore_zone *zone, 1031 struct pstore_record *record) 1032 { 1033 size_t len; 1034 struct psz_buffer *buf; 1035 1036 if (!zone || !record) 1037 return -ENOSPC; 1038 1039 buf = (struct psz_buffer *)zone->oldbuf; 1040 if (!buf) 1041 return -ENOMSG; 1042 1043 len = atomic_read(&buf->datalen); 1044 record->buf = kmalloc(len, GFP_KERNEL); 1045 if (!record->buf) 1046 return -ENOMEM; 1047 1048 if (unlikely(psz_zone_read_oldbuf(zone, record->buf, len, 0))) { 1049 kfree(record->buf); 1050 return -ENOMSG; 1051 } 1052 1053 return len; 1054 } 1055 1056 static ssize_t psz_pstore_read(struct pstore_record *record) 1057 { 1058 struct psz_context *cxt = record->psi->data; 1059 ssize_t (*readop)(struct pstore_zone *zone, 1060 struct pstore_record *record); 1061 struct pstore_zone *zone; 1062 ssize_t ret; 1063 1064 /* before read, we must recover from storage */ 1065 ret = psz_recovery(cxt); 1066 if (ret) 1067 return ret; 1068 1069 next_zone: 1070 zone = psz_read_next_zone(cxt); 1071 if (!zone) 1072 return 0; 1073 1074 record->type = zone->type; 1075 switch (record->type) { 1076 case PSTORE_TYPE_DMESG: 1077 readop = psz_kmsg_read; 1078 record->id = cxt->kmsg_read_cnt - 1; 1079 break; 1080 case PSTORE_TYPE_FTRACE: 1081 readop = psz_ftrace_read; 1082 break; 1083 case PSTORE_TYPE_CONSOLE: 1084 case PSTORE_TYPE_PMSG: 1085 readop = psz_record_read; 1086 break; 1087 default: 1088 goto next_zone; 1089 } 1090 1091 ret = readop(zone, record); 1092 if (ret == -ENOMSG) 1093 goto next_zone; 1094 return ret; 1095 } 1096 1097 static struct psz_context pstore_zone_cxt = { 1098 .pstore_zone_info_lock = 1099 __MUTEX_INITIALIZER(pstore_zone_cxt.pstore_zone_info_lock), 1100 .recovered = ATOMIC_INIT(0), 1101 .on_panic = ATOMIC_INIT(0), 1102 .pstore = { 1103 .owner = THIS_MODULE, 1104 .open = psz_pstore_open, 1105 .read = psz_pstore_read, 1106 .write = psz_pstore_write, 1107 .erase = psz_pstore_erase, 1108 }, 1109 }; 1110 1111 static void psz_free_zone(struct pstore_zone **pszone) 1112 { 1113 struct pstore_zone *zone = *pszone; 1114 1115 if (!zone) 1116 return; 1117 1118 kfree(zone->buffer); 1119 kfree(zone); 1120 *pszone = NULL; 1121 } 1122 1123 static void psz_free_zones(struct pstore_zone ***pszones, unsigned int *cnt) 1124 { 1125 struct pstore_zone **zones = *pszones; 1126 1127 if (!zones) 1128 return; 1129 1130 while (*cnt > 0) { 1131 (*cnt)--; 1132 psz_free_zone(&(zones[*cnt])); 1133 } 1134 kfree(zones); 1135 *pszones = NULL; 1136 } 1137 1138 static void psz_free_all_zones(struct psz_context *cxt) 1139 { 1140 if (cxt->kpszs) 1141 psz_free_zones(&cxt->kpszs, &cxt->kmsg_max_cnt); 1142 if (cxt->ppsz) 1143 psz_free_zone(&cxt->ppsz); 1144 if (cxt->cpsz) 1145 psz_free_zone(&cxt->cpsz); 1146 if (cxt->fpszs) 1147 psz_free_zones(&cxt->fpszs, &cxt->ftrace_max_cnt); 1148 } 1149 1150 static struct pstore_zone *psz_init_zone(enum pstore_type_id type, 1151 loff_t *off, size_t size) 1152 { 1153 struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info; 1154 struct pstore_zone *zone; 1155 const char *name = pstore_type_to_name(type); 1156 1157 if (!size) 1158 return NULL; 1159 1160 if (*off + size > info->total_size) { 1161 pr_err("no room for %s (0x%zx@0x%llx over 0x%lx)\n", 1162 name, size, *off, info->total_size); 1163 return ERR_PTR(-ENOMEM); 1164 } 1165 1166 zone = kzalloc(sizeof(struct pstore_zone), GFP_KERNEL); 1167 if (!zone) 1168 return ERR_PTR(-ENOMEM); 1169 1170 zone->buffer = kmalloc(size, GFP_KERNEL); 1171 if (!zone->buffer) { 1172 kfree(zone); 1173 return ERR_PTR(-ENOMEM); 1174 } 1175 memset(zone->buffer, 0xFF, size); 1176 zone->off = *off; 1177 zone->name = name; 1178 zone->type = type; 1179 zone->buffer_size = size - sizeof(struct psz_buffer); 1180 zone->buffer->sig = type ^ PSZ_SIG; 1181 zone->oldbuf = NULL; 1182 atomic_set(&zone->dirty, 0); 1183 atomic_set(&zone->buffer->datalen, 0); 1184 atomic_set(&zone->buffer->start, 0); 1185 1186 *off += size; 1187 1188 pr_debug("pszone %s: off 0x%llx, %zu header, %zu data\n", zone->name, 1189 zone->off, sizeof(*zone->buffer), zone->buffer_size); 1190 return zone; 1191 } 1192 1193 static struct pstore_zone **psz_init_zones(enum pstore_type_id type, 1194 loff_t *off, size_t total_size, ssize_t record_size, 1195 unsigned int *cnt) 1196 { 1197 struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info; 1198 struct pstore_zone **zones, *zone; 1199 const char *name = pstore_type_to_name(type); 1200 int c, i; 1201 1202 *cnt = 0; 1203 if (!total_size || !record_size) 1204 return NULL; 1205 1206 if (*off + total_size > info->total_size) { 1207 pr_err("no room for zones %s (0x%zx@0x%llx over 0x%lx)\n", 1208 name, total_size, *off, info->total_size); 1209 return ERR_PTR(-ENOMEM); 1210 } 1211 1212 c = total_size / record_size; 1213 zones = kcalloc(c, sizeof(*zones), GFP_KERNEL); 1214 if (!zones) { 1215 pr_err("allocate for zones %s failed\n", name); 1216 return ERR_PTR(-ENOMEM); 1217 } 1218 memset(zones, 0, c * sizeof(*zones)); 1219 1220 for (i = 0; i < c; i++) { 1221 zone = psz_init_zone(type, off, record_size); 1222 if (!zone || IS_ERR(zone)) { 1223 pr_err("initialize zones %s failed\n", name); 1224 psz_free_zones(&zones, &i); 1225 return (void *)zone; 1226 } 1227 zones[i] = zone; 1228 } 1229 1230 *cnt = c; 1231 return zones; 1232 } 1233 1234 static int psz_alloc_zones(struct psz_context *cxt) 1235 { 1236 struct pstore_zone_info *info = cxt->pstore_zone_info; 1237 loff_t off = 0; 1238 int err; 1239 size_t off_size = 0; 1240 1241 off_size += info->pmsg_size; 1242 cxt->ppsz = psz_init_zone(PSTORE_TYPE_PMSG, &off, info->pmsg_size); 1243 if (IS_ERR(cxt->ppsz)) { 1244 err = PTR_ERR(cxt->ppsz); 1245 cxt->ppsz = NULL; 1246 goto free_out; 1247 } 1248 1249 off_size += info->console_size; 1250 cxt->cpsz = psz_init_zone(PSTORE_TYPE_CONSOLE, &off, 1251 info->console_size); 1252 if (IS_ERR(cxt->cpsz)) { 1253 err = PTR_ERR(cxt->cpsz); 1254 cxt->cpsz = NULL; 1255 goto free_out; 1256 } 1257 1258 off_size += info->ftrace_size; 1259 cxt->fpszs = psz_init_zones(PSTORE_TYPE_FTRACE, &off, 1260 info->ftrace_size, 1261 info->ftrace_size / nr_cpu_ids, 1262 &cxt->ftrace_max_cnt); 1263 if (IS_ERR(cxt->fpszs)) { 1264 err = PTR_ERR(cxt->fpszs); 1265 cxt->fpszs = NULL; 1266 goto free_out; 1267 } 1268 1269 cxt->kpszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, 1270 info->total_size - off_size, 1271 info->kmsg_size, &cxt->kmsg_max_cnt); 1272 if (IS_ERR(cxt->kpszs)) { 1273 err = PTR_ERR(cxt->kpszs); 1274 cxt->kpszs = NULL; 1275 goto free_out; 1276 } 1277 1278 return 0; 1279 free_out: 1280 psz_free_all_zones(cxt); 1281 return err; 1282 } 1283 1284 /** 1285 * register_pstore_zone() - register to pstore/zone 1286 * 1287 * @info: back-end driver information. See &struct pstore_zone_info. 1288 * 1289 * Only one back-end at one time. 1290 * 1291 * Return: 0 on success, others on failure. 1292 */ 1293 int register_pstore_zone(struct pstore_zone_info *info) 1294 { 1295 int err = -EINVAL; 1296 struct psz_context *cxt = &pstore_zone_cxt; 1297 1298 if (info->total_size < 4096) { 1299 pr_warn("total_size must be >= 4096\n"); 1300 return -EINVAL; 1301 } 1302 if (info->total_size > SZ_128M) { 1303 pr_warn("capping size to 128MiB\n"); 1304 info->total_size = SZ_128M; 1305 } 1306 1307 if (!info->kmsg_size && !info->pmsg_size && !info->console_size && 1308 !info->ftrace_size) { 1309 pr_warn("at least one record size must be non-zero\n"); 1310 return -EINVAL; 1311 } 1312 1313 if (!info->name || !info->name[0]) 1314 return -EINVAL; 1315 1316 #define check_size(name, size) { \ 1317 if (info->name > 0 && info->name < (size)) { \ 1318 pr_err(#name " must be over %d\n", (size)); \ 1319 return -EINVAL; \ 1320 } \ 1321 if (info->name & (size - 1)) { \ 1322 pr_err(#name " must be a multiple of %d\n", \ 1323 (size)); \ 1324 return -EINVAL; \ 1325 } \ 1326 } 1327 1328 check_size(total_size, 4096); 1329 check_size(kmsg_size, SECTOR_SIZE); 1330 check_size(pmsg_size, SECTOR_SIZE); 1331 check_size(console_size, SECTOR_SIZE); 1332 check_size(ftrace_size, SECTOR_SIZE); 1333 1334 #undef check_size 1335 1336 /* 1337 * the @read and @write must be applied. 1338 * if no @read, pstore may mount failed. 1339 * if no @write, pstore do not support to remove record file. 1340 */ 1341 if (!info->read || !info->write) { 1342 pr_err("no valid general read/write interface\n"); 1343 return -EINVAL; 1344 } 1345 1346 mutex_lock(&cxt->pstore_zone_info_lock); 1347 if (cxt->pstore_zone_info) { 1348 pr_warn("'%s' already loaded: ignoring '%s'\n", 1349 cxt->pstore_zone_info->name, info->name); 1350 mutex_unlock(&cxt->pstore_zone_info_lock); 1351 return -EBUSY; 1352 } 1353 cxt->pstore_zone_info = info; 1354 1355 pr_debug("register %s with properties:\n", info->name); 1356 pr_debug("\ttotal size : %ld Bytes\n", info->total_size); 1357 pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size); 1358 pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size); 1359 pr_debug("\tconsole size : %ld Bytes\n", info->console_size); 1360 pr_debug("\tftrace size : %ld Bytes\n", info->ftrace_size); 1361 1362 err = psz_alloc_zones(cxt); 1363 if (err) { 1364 pr_err("alloc zones failed\n"); 1365 goto fail_out; 1366 } 1367 1368 if (info->kmsg_size) { 1369 cxt->pstore.bufsize = cxt->kpszs[0]->buffer_size - 1370 sizeof(struct psz_kmsg_header); 1371 cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL); 1372 if (!cxt->pstore.buf) { 1373 err = -ENOMEM; 1374 goto fail_free; 1375 } 1376 } 1377 cxt->pstore.data = cxt; 1378 1379 pr_info("registered %s as backend for", info->name); 1380 cxt->pstore.max_reason = info->max_reason; 1381 cxt->pstore.name = info->name; 1382 if (info->kmsg_size) { 1383 cxt->pstore.flags |= PSTORE_FLAGS_DMESG; 1384 pr_cont(" kmsg(%s", 1385 kmsg_dump_reason_str(cxt->pstore.max_reason)); 1386 if (cxt->pstore_zone_info->panic_write) 1387 pr_cont(",panic_write"); 1388 pr_cont(")"); 1389 } 1390 if (info->pmsg_size) { 1391 cxt->pstore.flags |= PSTORE_FLAGS_PMSG; 1392 pr_cont(" pmsg"); 1393 } 1394 if (info->console_size) { 1395 cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE; 1396 pr_cont(" console"); 1397 } 1398 if (info->ftrace_size) { 1399 cxt->pstore.flags |= PSTORE_FLAGS_FTRACE; 1400 pr_cont(" ftrace"); 1401 } 1402 pr_cont("\n"); 1403 1404 err = pstore_register(&cxt->pstore); 1405 if (err) { 1406 pr_err("registering with pstore failed\n"); 1407 goto fail_free; 1408 } 1409 mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock); 1410 1411 return 0; 1412 1413 fail_free: 1414 kfree(cxt->pstore.buf); 1415 cxt->pstore.buf = NULL; 1416 cxt->pstore.bufsize = 0; 1417 psz_free_all_zones(cxt); 1418 fail_out: 1419 pstore_zone_cxt.pstore_zone_info = NULL; 1420 mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock); 1421 return err; 1422 } 1423 EXPORT_SYMBOL_GPL(register_pstore_zone); 1424 1425 /** 1426 * unregister_pstore_zone() - unregister to pstore/zone 1427 * 1428 * @info: back-end driver information. See struct pstore_zone_info. 1429 */ 1430 void unregister_pstore_zone(struct pstore_zone_info *info) 1431 { 1432 struct psz_context *cxt = &pstore_zone_cxt; 1433 1434 mutex_lock(&cxt->pstore_zone_info_lock); 1435 if (!cxt->pstore_zone_info) { 1436 mutex_unlock(&cxt->pstore_zone_info_lock); 1437 return; 1438 } 1439 1440 /* Stop incoming writes from pstore. */ 1441 pstore_unregister(&cxt->pstore); 1442 1443 /* Flush any pending writes. */ 1444 psz_flush_all_dirty_zones(NULL); 1445 flush_delayed_work(&psz_cleaner); 1446 1447 /* Clean up allocations. */ 1448 kfree(cxt->pstore.buf); 1449 cxt->pstore.buf = NULL; 1450 cxt->pstore.bufsize = 0; 1451 cxt->pstore_zone_info = NULL; 1452 1453 psz_free_all_zones(cxt); 1454 1455 /* Clear counters and zone state. */ 1456 cxt->oops_counter = 0; 1457 cxt->panic_counter = 0; 1458 atomic_set(&cxt->recovered, 0); 1459 atomic_set(&cxt->on_panic, 0); 1460 1461 mutex_unlock(&cxt->pstore_zone_info_lock); 1462 } 1463 EXPORT_SYMBOL_GPL(unregister_pstore_zone); 1464 1465 MODULE_LICENSE("GPL"); 1466 MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>"); 1467 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>"); 1468 MODULE_DESCRIPTION("Storage Manager for pstore/blk"); 1469