fs/pstore/zone.c

   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                 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 */
1001 static 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
1023 out:
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
1032 static 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
1058 static 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
1071 next_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
1099 static 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
1113 static 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
1125 static 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
1140 static 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
1152 static 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
1195 static 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         memset(zones, 0, c * sizeof(*zones));
1221
1222         for (i = 0; i < c; i++) {
1223                 zone = psz_init_zone(type, off, record_size);
1224                 if (!zone || IS_ERR(zone)) {
1225                         pr_err("initialize zones %s failed\n", name);
1226                         psz_free_zones(&zones, &i);
1227                         return (void *)zone;
1228                 }
1229                 zones[i] = zone;
1230         }
1231
1232         *cnt = c;
1233         return zones;
1234 }
1235
1236 static int psz_alloc_zones(struct psz_context *cxt)
1237 {
1238         struct pstore_zone_info *info = cxt->pstore_zone_info;
1239         loff_t off = 0;
1240         int err;
1241         size_t off_size = 0;
1242
1243         off_size += info->pmsg_size;
1244         cxt->ppsz = psz_init_zone(PSTORE_TYPE_PMSG, &off, info->pmsg_size);
1245         if (IS_ERR(cxt->ppsz)) {
1246                 err = PTR_ERR(cxt->ppsz);
1247                 cxt->ppsz = NULL;
1248                 goto free_out;
1249         }
1250
1251         off_size += info->console_size;
1252         cxt->cpsz = psz_init_zone(PSTORE_TYPE_CONSOLE, &off,
1253                         info->console_size);
1254         if (IS_ERR(cxt->cpsz)) {
1255                 err = PTR_ERR(cxt->cpsz);
1256                 cxt->cpsz = NULL;
1257                 goto free_out;
1258         }
1259
1260         off_size += info->ftrace_size;
1261         cxt->fpszs = psz_init_zones(PSTORE_TYPE_FTRACE, &off,
1262                         info->ftrace_size,
1263                         info->ftrace_size / nr_cpu_ids,
1264                         &cxt->ftrace_max_cnt);
1265         if (IS_ERR(cxt->fpszs)) {
1266                 err = PTR_ERR(cxt->fpszs);
1267                 cxt->fpszs = NULL;
1268                 goto free_out;
1269         }
1270
1271         cxt->kpszs = psz_init_zones(PSTORE_TYPE_DMESG, &off,
1272                         info->total_size - off_size,
1273                         info->kmsg_size, &cxt->kmsg_max_cnt);
1274         if (IS_ERR(cxt->kpszs)) {
1275                 err = PTR_ERR(cxt->kpszs);
1276                 cxt->kpszs = NULL;
1277                 goto free_out;
1278         }
1279
1280         return 0;
1281 free_out:
1282         psz_free_all_zones(cxt);
1283         return err;
1284 }
1285
1286 /**
1287  * register_pstore_zone() - register to pstore/zone
1288  *
1289  * @info: back-end driver information. See &struct pstore_zone_info.
1290  *
1291  * Only one back-end at one time.
1292  *
1293  * Return: 0 on success, others on failure.
1294  */
1295 int register_pstore_zone(struct pstore_zone_info *info)
1296 {
1297         int err = -EINVAL;
1298         struct psz_context *cxt = &pstore_zone_cxt;
1299
1300         if (info->total_size < 4096) {
1301                 pr_warn("total_size must be >= 4096\n");
1302                 return -EINVAL;
1303         }
1304         if (info->total_size > SZ_128M) {
1305                 pr_warn("capping size to 128MiB\n");
1306                 info->total_size = SZ_128M;
1307         }
1308
1309         if (!info->kmsg_size && !info->pmsg_size && !info->console_size &&
1310             !info->ftrace_size) {
1311                 pr_warn("at least one record size must be non-zero\n");
1312                 return -EINVAL;
1313         }
1314
1315         if (!info->name || !info->name[0])
1316                 return -EINVAL;
1317
1318 #define check_size(name, size) {                                        \
1319                 if (info->name > 0 && info->name < (size)) {            \
1320                         pr_err(#name " must be over %d\n", (size));     \
1321                         return -EINVAL;                                 \
1322                 }                                                       \
1323                 if (info->name & (size - 1)) {                          \
1324                         pr_err(#name " must be a multiple of %d\n",     \
1325                                         (size));                        \
1326                         return -EINVAL;                                 \
1327                 }                                                       \
1328         }
1329
1330         check_size(total_size, 4096);
1331         check_size(kmsg_size, SECTOR_SIZE);
1332         check_size(pmsg_size, SECTOR_SIZE);
1333         check_size(console_size, SECTOR_SIZE);
1334         check_size(ftrace_size, SECTOR_SIZE);
1335
1336 #undef check_size
1337
1338         /*
1339          * the @read and @write must be applied.
1340          * if no @read, pstore may mount failed.
1341          * if no @write, pstore do not support to remove record file.
1342          */
1343         if (!info->read || !info->write) {
1344                 pr_err("no valid general read/write interface\n");
1345                 return -EINVAL;
1346         }
1347
1348         mutex_lock(&cxt->pstore_zone_info_lock);
1349         if (cxt->pstore_zone_info) {
1350                 pr_warn("'%s' already loaded: ignoring '%s'\n",
1351                                 cxt->pstore_zone_info->name, info->name);
1352                 mutex_unlock(&cxt->pstore_zone_info_lock);
1353                 return -EBUSY;
1354         }
1355         cxt->pstore_zone_info = info;
1356
1357         pr_debug("register %s with properties:\n", info->name);
1358         pr_debug("\ttotal size : %ld Bytes\n", info->total_size);
1359         pr_debug("\tkmsg size : %ld Bytes\n", info->kmsg_size);
1360         pr_debug("\tpmsg size : %ld Bytes\n", info->pmsg_size);
1361         pr_debug("\tconsole size : %ld Bytes\n", info->console_size);
1362         pr_debug("\tftrace size : %ld Bytes\n", info->ftrace_size);
1363
1364         err = psz_alloc_zones(cxt);
1365         if (err) {
1366                 pr_err("alloc zones failed\n");
1367                 goto fail_out;
1368         }
1369
1370         if (info->kmsg_size) {
1371                 cxt->pstore.bufsize = cxt->kpszs[0]->buffer_size -
1372                         sizeof(struct psz_kmsg_header);
1373                 cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL);
1374                 if (!cxt->pstore.buf) {
1375                         err = -ENOMEM;
1376                         goto fail_free;
1377                 }
1378         }
1379         cxt->pstore.data = cxt;
1380
1381         pr_info("registered %s as backend for", info->name);
1382         cxt->pstore.max_reason = info->max_reason;
1383         cxt->pstore.name = info->name;
1384         if (info->kmsg_size) {
1385                 cxt->pstore.flags |= PSTORE_FLAGS_DMESG;
1386                 pr_cont(" kmsg(%s",
1387                         kmsg_dump_reason_str(cxt->pstore.max_reason));
1388                 if (cxt->pstore_zone_info->panic_write)
1389                         pr_cont(",panic_write");
1390                 pr_cont(")");
1391         }
1392         if (info->pmsg_size) {
1393                 cxt->pstore.flags |= PSTORE_FLAGS_PMSG;
1394                 pr_cont(" pmsg");
1395         }
1396         if (info->console_size) {
1397                 cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE;
1398                 pr_cont(" console");
1399         }
1400         if (info->ftrace_size) {
1401                 cxt->pstore.flags |= PSTORE_FLAGS_FTRACE;
1402                 pr_cont(" ftrace");
1403         }
1404         pr_cont("\n");
1405
1406         err = pstore_register(&cxt->pstore);
1407         if (err) {
1408                 pr_err("registering with pstore failed\n");
1409                 goto fail_free;
1410         }
1411         mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);
1412
1413         return 0;
1414
1415 fail_free:
1416         kfree(cxt->pstore.buf);
1417         cxt->pstore.buf = NULL;
1418         cxt->pstore.bufsize = 0;
1419         psz_free_all_zones(cxt);
1420 fail_out:
1421         pstore_zone_cxt.pstore_zone_info = NULL;
1422         mutex_unlock(&pstore_zone_cxt.pstore_zone_info_lock);
1423         return err;
1424 }
1425 EXPORT_SYMBOL_GPL(register_pstore_zone);
1426
1427 /**
1428  * unregister_pstore_zone() - unregister to pstore/zone
1429  *
1430  * @info: back-end driver information. See struct pstore_zone_info.
1431  */
1432 void unregister_pstore_zone(struct pstore_zone_info *info)
1433 {
1434         struct psz_context *cxt = &pstore_zone_cxt;
1435
1436         mutex_lock(&cxt->pstore_zone_info_lock);
1437         if (!cxt->pstore_zone_info) {
1438                 mutex_unlock(&cxt->pstore_zone_info_lock);
1439                 return;
1440         }
1441
1442         /* Stop incoming writes from pstore. */
1443         pstore_unregister(&cxt->pstore);
1444
1445         /* Flush any pending writes. */
1446         psz_flush_all_dirty_zones(NULL);
1447         flush_delayed_work(&psz_cleaner);
1448
1449         /* Clean up allocations. */
1450         kfree(cxt->pstore.buf);
1451         cxt->pstore.buf = NULL;
1452         cxt->pstore.bufsize = 0;
1453         cxt->pstore_zone_info = NULL;
1454
1455         psz_free_all_zones(cxt);
1456
1457         /* Clear counters and zone state. */
1458         cxt->oops_counter = 0;
1459         cxt->panic_counter = 0;
1460         atomic_set(&cxt->recovered, 0);
1461         atomic_set(&cxt->on_panic, 0);
1462
1463         mutex_unlock(&cxt->pstore_zone_info_lock);
1464 }
1465 EXPORT_SYMBOL_GPL(unregister_pstore_zone);
1466
1467 MODULE_LICENSE("GPL");
1468 MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
1469 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
1470 MODULE_DESCRIPTION("Storage Manager for pstore/blk");