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 */ 33struct 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 */ 53struct 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 */ 77struct 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 */ 111struct 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}; 140static struct psz_context pstore_zone_cxt; 141 142static void psz_flush_all_dirty_zones(struct work_struct *); 143static 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 */ 153enum psz_flush_mode { 154 FLUSH_NONE = 0, 155 FLUSH_PART, 156 FLUSH_META, 157 FLUSH_ALL, 158}; 159 160static inline int buffer_datalen(struct pstore_zone *zone) 161{ 162 return atomic_read(&zone->buffer->datalen); 163} 164 165static inline int buffer_start(struct pstore_zone *zone) 166{ 167 return atomic_read(&zone->buffer->start); 168} 169 170static inline bool is_on_panic(void) 171{ 172 return atomic_read(&pstore_zone_cxt.on_panic); 173} 174 175static 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 187static 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 199static 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; 251dirty: 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 262static 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 281static 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 300static 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 315static 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 332static 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 371static 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 460static 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; 476recover_fail: 477 pr_debug("psz_recover_kmsg failed\n"); 478 return ret; 479} 480 481static 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 563free_oldbuf: 564 kfree(oldbuf); 565 return ret; 566} 567 568static 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; 588recover_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 */ 601static 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 622out: 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 632static 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 643static 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 650static 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 657static 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 680static 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 699static 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 720static 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 */ 745static 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 795static 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 823static 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 872static 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 906static 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 941static 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 958static 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 if (!buf) 977 return -ENOMEM; 978 hlen = strlen(buf); 979 record->buf = krealloc(buf, hlen + size, GFP_KERNEL); 980 if (!record->buf) { 981 kfree(buf); 982 return -ENOMEM; 983 } 984 } else { 985 record->buf = kmalloc(size, GFP_KERNEL); 986 if (!record->buf) 987 return -ENOMEM; 988 } 989 990 size = psz_zone_read_buffer(zone, record->buf + hlen, size, 991 sizeof(struct psz_kmsg_header)); 992 if (unlikely(size < 0)) { 993 kfree(record->buf); 994 return -ENOMSG; 995 } 996 997 return size + hlen; 998} 999 1000/* try to combine all ftrace zones */ 1001static ssize_t psz_ftrace_read(struct pstore_zone *zone, 1002 struct pstore_record *record) 1003{ 1004 struct psz_context *cxt; 1005 struct psz_buffer *buf; 1006 int ret; 1007 1008 if (!zone || !record) 1009 return -ENOSPC; 1010 1011 if (!psz_old_ok(zone)) 1012 goto out; 1013 1014 buf = (struct psz_buffer *)zone->oldbuf; 1015 if (!buf) 1016 return -ENOMSG; 1017 1018 ret = pstore_ftrace_combine_log(&record->buf, &record->size, 1019 (char *)buf->data, atomic_read(&buf->datalen)); 1020 if (unlikely(ret)) 1021 return ret; 1022 1023out: 1024 cxt = record->psi->data; 1025 if (cxt->ftrace_read_cnt < cxt->ftrace_max_cnt) 1026 /* then, read next ftrace zone */ 1027 return -ENOMSG; 1028 record->id = 0; 1029 return record->size ? record->size : -ENOMSG; 1030} 1031 1032static ssize_t psz_record_read(struct pstore_zone *zone, 1033 struct pstore_record *record) 1034{ 1035 size_t len; 1036 struct psz_buffer *buf; 1037 1038 if (!zone || !record) 1039 return -ENOSPC; 1040 1041 buf = (struct psz_buffer *)zone->oldbuf; 1042 if (!buf) 1043 return -ENOMSG; 1044 1045 len = atomic_read(&buf->datalen); 1046 record->buf = kmalloc(len, GFP_KERNEL); 1047 if (!record->buf) 1048 return -ENOMEM; 1049 1050 if (unlikely(psz_zone_read_oldbuf(zone, record->buf, len, 0))) { 1051 kfree(record->buf); 1052 return -ENOMSG; 1053 } 1054 1055 return len; 1056} 1057 1058static ssize_t psz_pstore_read(struct pstore_record *record) 1059{ 1060 struct psz_context *cxt = record->psi->data; 1061 ssize_t (*readop)(struct pstore_zone *zone, 1062 struct pstore_record *record); 1063 struct pstore_zone *zone; 1064 ssize_t ret; 1065 1066 /* before read, we must recover from storage */ 1067 ret = psz_recovery(cxt); 1068 if (ret) 1069 return ret; 1070 1071next_zone: 1072 zone = psz_read_next_zone(cxt); 1073 if (!zone) 1074 return 0; 1075 1076 record->type = zone->type; 1077 switch (record->type) { 1078 case PSTORE_TYPE_DMESG: 1079 readop = psz_kmsg_read; 1080 record->id = cxt->kmsg_read_cnt - 1; 1081 break; 1082 case PSTORE_TYPE_FTRACE: 1083 readop = psz_ftrace_read; 1084 break; 1085 case PSTORE_TYPE_CONSOLE: 1086 case PSTORE_TYPE_PMSG: 1087 readop = psz_record_read; 1088 break; 1089 default: 1090 goto next_zone; 1091 } 1092 1093 ret = readop(zone, record); 1094 if (ret == -ENOMSG) 1095 goto next_zone; 1096 return ret; 1097} 1098 1099static struct psz_context pstore_zone_cxt = { 1100 .pstore_zone_info_lock = 1101 __MUTEX_INITIALIZER(pstore_zone_cxt.pstore_zone_info_lock), 1102 .recovered = ATOMIC_INIT(0), 1103 .on_panic = ATOMIC_INIT(0), 1104 .pstore = { 1105 .owner = THIS_MODULE, 1106 .open = psz_pstore_open, 1107 .read = psz_pstore_read, 1108 .write = psz_pstore_write, 1109 .erase = psz_pstore_erase, 1110 }, 1111}; 1112 1113static void psz_free_zone(struct pstore_zone **pszone) 1114{ 1115 struct pstore_zone *zone = *pszone; 1116 1117 if (!zone) 1118 return; 1119 1120 kfree(zone->buffer); 1121 kfree(zone); 1122 *pszone = NULL; 1123} 1124 1125static void psz_free_zones(struct pstore_zone ***pszones, unsigned int *cnt) 1126{ 1127 struct pstore_zone **zones = *pszones; 1128 1129 if (!zones) 1130 return; 1131 1132 while (*cnt > 0) { 1133 (*cnt)--; 1134 psz_free_zone(&(zones[*cnt])); 1135 } 1136 kfree(zones); 1137 *pszones = NULL; 1138} 1139 1140static void psz_free_all_zones(struct psz_context *cxt) 1141{ 1142 if (cxt->kpszs) 1143 psz_free_zones(&cxt->kpszs, &cxt->kmsg_max_cnt); 1144 if (cxt->ppsz) 1145 psz_free_zone(&cxt->ppsz); 1146 if (cxt->cpsz) 1147 psz_free_zone(&cxt->cpsz); 1148 if (cxt->fpszs) 1149 psz_free_zones(&cxt->fpszs, &cxt->ftrace_max_cnt); 1150} 1151 1152static struct pstore_zone *psz_init_zone(enum pstore_type_id type, 1153 loff_t *off, size_t size) 1154{ 1155 struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info; 1156 struct pstore_zone *zone; 1157 const char *name = pstore_type_to_name(type); 1158 1159 if (!size) 1160 return NULL; 1161 1162 if (*off + size > info->total_size) { 1163 pr_err("no room for %s (0x%zx@0x%llx over 0x%lx)\n", 1164 name, size, *off, info->total_size); 1165 return ERR_PTR(-ENOMEM); 1166 } 1167 1168 zone = kzalloc(sizeof(struct pstore_zone), GFP_KERNEL); 1169 if (!zone) 1170 return ERR_PTR(-ENOMEM); 1171 1172 zone->buffer = kmalloc(size, GFP_KERNEL); 1173 if (!zone->buffer) { 1174 kfree(zone); 1175 return ERR_PTR(-ENOMEM); 1176 } 1177 memset(zone->buffer, 0xFF, size); 1178 zone->off = *off; 1179 zone->name = name; 1180 zone->type = type; 1181 zone->buffer_size = size - sizeof(struct psz_buffer); 1182 zone->buffer->sig = type ^ PSZ_SIG; 1183 zone->oldbuf = NULL; 1184 atomic_set(&zone->dirty, 0); 1185 atomic_set(&zone->buffer->datalen, 0); 1186 atomic_set(&zone->buffer->start, 0); 1187 1188 *off += size; 1189 1190 pr_debug("pszone %s: off 0x%llx, %zu header, %zu data\n", zone->name, 1191 zone->off, sizeof(*zone->buffer), zone->buffer_size); 1192 return zone; 1193} 1194 1195static struct pstore_zone **psz_init_zones(enum pstore_type_id type, 1196 loff_t *off, size_t total_size, ssize_t record_size, 1197 unsigned int *cnt) 1198{ 1199 struct pstore_zone_info *info = pstore_zone_cxt.pstore_zone_info; 1200 struct pstore_zone **zones, *zone; 1201 const char *name = pstore_type_to_name(type); 1202 int c, i; 1203 1204 *cnt = 0; 1205 if (!total_size || !record_size) 1206 return NULL; 1207 1208 if (*off + total_size > info->total_size) { 1209 pr_err("no room for zones %s (0x%zx@0x%llx over 0x%lx)\n", 1210 name, total_size, *off, info->total_size); 1211 return ERR_PTR(-ENOMEM); 1212 } 1213 1214 c = total_size / record_size; 1215 zones = kcalloc(c, sizeof(*zones), GFP_KERNEL); 1216 if (!zones) { 1217 pr_err("allocate for zones %s failed\n", name); 1218 return ERR_PTR(-ENOMEM); 1219 } 1220 1221 for (i = 0; i < c; i++) { 1222 zone = psz_init_zone(type, off, record_size); 1223 if (!zone || IS_ERR(zone)) { 1224 pr_err("initialize zones %s failed\n", name); 1225 psz_free_zones(&zones, &i); 1226 return (void *)zone; 1227 } 1228 zones[i] = zone; 1229 } 1230 1231 *cnt = c; 1232 return zones; 1233} 1234 1235static int psz_alloc_zones(struct psz_context *cxt) 1236{ 1237 struct pstore_zone_info *info = cxt->pstore_zone_info; 1238 loff_t off = 0; 1239 int err; 1240 size_t off_size = 0; 1241 1242 off_size += info->pmsg_size; 1243 cxt->ppsz = psz_init_zone(PSTORE_TYPE_PMSG, &off, info->pmsg_size); 1244 if (IS_ERR(cxt->ppsz)) { 1245 err = PTR_ERR(cxt->ppsz); 1246 cxt->ppsz = NULL; 1247 goto free_out; 1248 } 1249 1250 off_size += info->console_size; 1251 cxt->cpsz = psz_init_zone(PSTORE_TYPE_CONSOLE, &off, 1252 info->console_size); 1253 if (IS_ERR(cxt->cpsz)) { 1254 err = PTR_ERR(cxt->cpsz); 1255 cxt->cpsz = NULL; 1256 goto free_out; 1257 } 1258 1259 off_size += info->ftrace_size; 1260 cxt->fpszs = psz_init_zones(PSTORE_TYPE_FTRACE, &off, 1261 info->ftrace_size, 1262 info->ftrace_size / nr_cpu_ids, 1263 &cxt->ftrace_max_cnt); 1264 if (IS_ERR(cxt->fpszs)) { 1265 err = PTR_ERR(cxt->fpszs); 1266 cxt->fpszs = NULL; 1267 goto free_out; 1268 } 1269 1270 cxt->kpszs = psz_init_zones(PSTORE_TYPE_DMESG, &off, 1271 info->total_size - off_size, 1272 info->kmsg_size, &cxt->kmsg_max_cnt); 1273 if (IS_ERR(cxt->kpszs)) { 1274 err = PTR_ERR(cxt->kpszs); 1275 cxt->kpszs = NULL; 1276 goto free_out; 1277 } 1278 1279 return 0; 1280free_out: 1281 psz_free_all_zones(cxt); 1282 return err; 1283} 1284 1285/** 1286 * register_pstore_zone() - register to pstore/zone 1287 * 1288 * @info: back-end driver information. See &struct pstore_zone_info. 1289 * 1290 * Only one back-end at one time. 1291 * 1292 * Return: 0 on success, others on failure. 1293 */ 1294int register_pstore_zone(struct pstore_zone_info *info) 1295{ 1296 int err = -EINVAL; 1297 struct psz_context *cxt = &pstore_zone_cxt; 1298 1299 if (info->total_size < 4096) { 1300 pr_warn("total_size must be >= 4096\n"); 1301 return -EINVAL; 1302 } 1303 if (info->total_size > SZ_128M) { 1304 pr_warn("capping size to 128MiB\n"); 1305 info->total_size = SZ_128M; 1306 } 1307 1308 if (!info->kmsg_size && !info->pmsg_size && !info->console_size && 1309 !info->ftrace_size) { 1310 pr_warn("at least one record size must be non-zero\n"); 1311 return -EINVAL; 1312 } 1313 1314 if (!info->name || !info->name[0]) 1315 return -EINVAL; 1316 1317#define check_size(name, size) { \ 1318 if (info->name > 0 && info->name < (size)) { \ 1319 pr_err(#name " must be over %d\n", (size)); \ 1320 return -EINVAL; \ 1321 } \ 1322 if (info->name & (size - 1)) { \ 1323 pr_err(#name " must be a multiple of %d\n", \ 1324 (size)); \ 1325 return -EINVAL; \ 1326 } \ 1327 } 1328 1329 check_size(total_size, 4096); 1330 check_size(kmsg_size, SECTOR_SIZE); 1331 check_size(pmsg_size, SECTOR_SIZE); 1332 check_size(console_size, SECTOR_SIZE); 1333 check_size(ftrace_size, SECTOR_SIZE); 1334 1335#undef check_size 1336 1337 /* 1338 * the @read and @write must be applied. 1339 * if no @read, pstore may mount failed. 1340 * if no @write, pstore do not support to remove record file. 1341 */ 1342 if (!info->read || !info->write) { 1343 pr_err("no valid general read/write interface\n"); 1344 return -EINVAL; 1345 } 1346 1347 mutex_lock(&cxt->pstore_zone_info_lock); 1348 if (cxt->pstore_zone_info) { 1349 pr_warn("'%s' already loaded: ignoring '%s'\n", 1350 cxt->pstore_zone_info->name, info->name); 1351 mutex_unlock(&cxt->pstore_zone_info_lock); 1352 return -EBUSY; 1353 } 1354 cxt->pstore_zone_info = info; 1355 1356 pr_debug("register %s with properties:\n", info->name); 1357 pr_debug("\ttotal size : %ld Bytes\n", info->total_size); 1358 pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size); 1359 pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size); 1360 pr_debug("\tconsole size : %ld Bytes\n", info->console_size); 1361 pr_debug("\tftrace size : %ld Bytes\n", info->ftrace_size); 1362 1363 err = psz_alloc_zones(cxt); 1364 if (err) { 1365 pr_err("alloc zones failed\n"); 1366 goto fail_out; 1367 } 1368 1369 if (info->kmsg_size) { 1370 cxt->pstore.bufsize = cxt->kpszs[0]->buffer_size - 1371 sizeof(struct psz_kmsg_header); 1372 cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL); 1373 if (!cxt->pstore.buf) { 1374 err = -ENOMEM; 1375 goto fail_free; 1376 } 1377 } 1378 cxt->pstore.data = cxt; 1379 1380 pr_info("registered %s as backend for", info->name); 1381 cxt->pstore.max_reason = info->max_reason; 1382 cxt->pstore.name = info->name; 1383 if (info->kmsg_size) { 1384 cxt->pstore.flags |= PSTORE_FLAGS_DMESG; 1385 pr_cont(" kmsg(%s", 1386 kmsg_dump_reason_str(cxt->pstore.max_reason)); 1387 if (cxt->pstore_zone_info->panic_write) 1388 pr_cont(",panic_write"); 1389 pr_cont(")"); 1390 } 1391 if (info->pmsg_size) { 1392 cxt->pstore.flags |= PSTORE_FLAGS_PMSG; 1393 pr_cont(" pmsg"); 1394 } 1395 if (info->console_size) { 1396 cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE; 1397 pr_cont(" console"); 1398 } 1399 if (info->ftrace_size) { 1400 cxt->pstore.flags |= PSTORE_FLAGS_FTRACE; 1401 pr_cont(" ftrace"); 1402 } 1403 pr_cont("\n"); 1404 1405 err = pstore_register(&cxt->pstore); 1406 if (err) { 1407 pr_err("registering with pstore failed\n"); 1408 goto fail_free; 1409 } 1410 mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock); 1411 1412 return 0; 1413 1414fail_free: 1415 kfree(cxt->pstore.buf); 1416 cxt->pstore.buf = NULL; 1417 cxt->pstore.bufsize = 0; 1418 psz_free_all_zones(cxt); 1419fail_out: 1420 pstore_zone_cxt.pstore_zone_info = NULL; 1421 mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock); 1422 return err; 1423} 1424EXPORT_SYMBOL_GPL(register_pstore_zone); 1425 1426/** 1427 * unregister_pstore_zone() - unregister to pstore/zone 1428 * 1429 * @info: back-end driver information. See struct pstore_zone_info. 1430 */ 1431void unregister_pstore_zone(struct pstore_zone_info *info) 1432{ 1433 struct psz_context *cxt = &pstore_zone_cxt; 1434 1435 mutex_lock(&cxt->pstore_zone_info_lock); 1436 if (!cxt->pstore_zone_info) { 1437 mutex_unlock(&cxt->pstore_zone_info_lock); 1438 return; 1439 } 1440 1441 /* Stop incoming writes from pstore. */ 1442 pstore_unregister(&cxt->pstore); 1443 1444 /* Flush any pending writes. */ 1445 psz_flush_all_dirty_zones(NULL); 1446 flush_delayed_work(&psz_cleaner); 1447 1448 /* Clean up allocations. */ 1449 kfree(cxt->pstore.buf); 1450 cxt->pstore.buf = NULL; 1451 cxt->pstore.bufsize = 0; 1452 cxt->pstore_zone_info = NULL; 1453 1454 psz_free_all_zones(cxt); 1455 1456 /* Clear counters and zone state. */ 1457 cxt->oops_counter = 0; 1458 cxt->panic_counter = 0; 1459 atomic_set(&cxt->recovered, 0); 1460 atomic_set(&cxt->on_panic, 0); 1461 1462 mutex_unlock(&cxt->pstore_zone_info_lock); 1463} 1464EXPORT_SYMBOL_GPL(unregister_pstore_zone); 1465 1466MODULE_LICENSE("GPL"); 1467MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>"); 1468MODULE_AUTHOR("Kees Cook <keescook@chromium.org>"); 1469MODULE_DESCRIPTION("Storage Manager for pstore/blk"); 1470