drivers/mtd/mtdpstore.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #define dev_fmt(fmt) "mtdoops-pstore: " fmt
   4
   5 #include <linux/kernel.h>
   6 #include <linux/module.h>
   7 #include <linux/pstore_blk.h>
   8 #include <linux/mtd/mtd.h>
   9 #include <linux/bitops.h>
  10 #include <linux/slab.h>
  11
  12 static struct mtdpstore_context {
  13         int index;
  14         struct pstore_blk_config info;
  15         struct pstore_device_info dev;
  16         struct mtd_info *mtd;
  17         unsigned long *rmmap;           /* removed bit map */
  18         unsigned long *usedmap;         /* used bit map */
  19         /*
  20          * used for panic write
  21          * As there are no block_isbad for panic case, we should keep this
  22          * status before panic to ensure panic_write not failed.
  23          */
  24         unsigned long *badmap;          /* bad block bit map */
  25 } oops_cxt;
  26
  27 static int mtdpstore_block_isbad(struct mtdpstore_context *cxt, loff_t off)
  28 {
  29         int ret;
  30         struct mtd_info *mtd = cxt->mtd;
  31         u64 blknum;
  32
  33         off = ALIGN_DOWN(off, mtd->erasesize);
  34         blknum = div_u64(off, mtd->erasesize);
  35
  36         if (test_bit(blknum, cxt->badmap))
  37                 return true;
  38         ret = mtd_block_isbad(mtd, off);
  39         if (ret < 0) {
  40                 dev_err(&mtd->dev, "mtd_block_isbad failed, aborting\n");
  41                 return ret;
  42         } else if (ret > 0) {
  43                 set_bit(blknum, cxt->badmap);
  44                 return true;
  45         }
  46         return false;
  47 }
  48
  49 static inline int mtdpstore_panic_block_isbad(struct mtdpstore_context *cxt,
  50                 loff_t off)
  51 {
  52         struct mtd_info *mtd = cxt->mtd;
  53         u64 blknum;
  54
  55         off = ALIGN_DOWN(off, mtd->erasesize);
  56         blknum = div_u64(off, mtd->erasesize);
  57         return test_bit(blknum, cxt->badmap);
  58 }
  59
  60 static inline void mtdpstore_mark_used(struct mtdpstore_context *cxt,
  61                 loff_t off)
  62 {
  63         struct mtd_info *mtd = cxt->mtd;
  64         u64 zonenum = div_u64(off, cxt->info.kmsg_size);
  65
  66         dev_dbg(&mtd->dev, "mark zone %llu used\n", zonenum);
  67         set_bit(zonenum, cxt->usedmap);
  68 }
  69
  70 static inline void mtdpstore_mark_unused(struct mtdpstore_context *cxt,
  71                 loff_t off)
  72 {
  73         struct mtd_info *mtd = cxt->mtd;
  74         u64 zonenum = div_u64(off, cxt->info.kmsg_size);
  75
  76         dev_dbg(&mtd->dev, "mark zone %llu unused\n", zonenum);
  77         clear_bit(zonenum, cxt->usedmap);
  78 }
  79
  80 static inline void mtdpstore_block_mark_unused(struct mtdpstore_context *cxt,
  81                 loff_t off)
  82 {
  83         struct mtd_info *mtd = cxt->mtd;
  84         u32 zonecnt = mtd->erasesize / cxt->info.kmsg_size;
  85         u64 zonenum;
  86
  87         off = ALIGN_DOWN(off, mtd->erasesize);
  88         zonenum = div_u64(off, cxt->info.kmsg_size);
  89         while (zonecnt > 0) {
  90                 dev_dbg(&mtd->dev, "mark zone %llu unused\n", zonenum);
  91                 clear_bit(zonenum, cxt->usedmap);
  92                 zonenum++;
  93                 zonecnt--;
  94         }
  95 }
  96
  97 static inline int mtdpstore_is_used(struct mtdpstore_context *cxt, loff_t off)
  98 {
  99         u64 zonenum = div_u64(off, cxt->info.kmsg_size);
 100         u64 blknum = div_u64(off, cxt->mtd->erasesize);
 101
 102         if (test_bit(blknum, cxt->badmap))
 103                 return true;
 104         return test_bit(zonenum, cxt->usedmap);
 105 }
 106
 107 static int mtdpstore_block_is_used(struct mtdpstore_context *cxt,
 108                 loff_t off)
 109 {
 110         struct mtd_info *mtd = cxt->mtd;
 111         u32 zonecnt = mtd->erasesize / cxt->info.kmsg_size;
 112         u64 zonenum;
 113
 114         off = ALIGN_DOWN(off, mtd->erasesize);
 115         zonenum = div_u64(off, cxt->info.kmsg_size);
 116         while (zonecnt > 0) {
 117                 if (test_bit(zonenum, cxt->usedmap))
 118                         return true;
 119                 zonenum++;
 120                 zonecnt--;
 121         }
 122         return false;
 123 }
 124
 125 static int mtdpstore_is_empty(struct mtdpstore_context *cxt, char *buf,
 126                 size_t size)
 127 {
 128         struct mtd_info *mtd = cxt->mtd;
 129         size_t sz;
 130         int i;
 131
 132         sz = min_t(uint32_t, size, mtd->writesize / 4);
 133         for (i = 0; i < sz; i++) {
 134                 if (buf[i] != (char)0xFF)
 135                         return false;
 136         }
 137         return true;
 138 }
 139
 140 static void mtdpstore_mark_removed(struct mtdpstore_context *cxt, loff_t off)
 141 {
 142         struct mtd_info *mtd = cxt->mtd;
 143         u64 zonenum = div_u64(off, cxt->info.kmsg_size);
 144
 145         dev_dbg(&mtd->dev, "mark zone %llu removed\n", zonenum);
 146         set_bit(zonenum, cxt->rmmap);
 147 }
 148
 149 static void mtdpstore_block_clear_removed(struct mtdpstore_context *cxt,
 150                 loff_t off)
 151 {
 152         struct mtd_info *mtd = cxt->mtd;
 153         u32 zonecnt = mtd->erasesize / cxt->info.kmsg_size;
 154         u64 zonenum;
 155
 156         off = ALIGN_DOWN(off, mtd->erasesize);
 157         zonenum = div_u64(off, cxt->info.kmsg_size);
 158         while (zonecnt > 0) {
 159                 clear_bit(zonenum, cxt->rmmap);
 160                 zonenum++;
 161                 zonecnt--;
 162         }
 163 }
 164
 165 static int mtdpstore_block_is_removed(struct mtdpstore_context *cxt,
 166                 loff_t off)
 167 {
 168         struct mtd_info *mtd = cxt->mtd;
 169         u32 zonecnt = mtd->erasesize / cxt->info.kmsg_size;
 170         u64 zonenum;
 171
 172         off = ALIGN_DOWN(off, mtd->erasesize);
 173         zonenum = div_u64(off, cxt->info.kmsg_size);
 174         while (zonecnt > 0) {
 175                 if (test_bit(zonenum, cxt->rmmap))
 176                         return true;
 177                 zonenum++;
 178                 zonecnt--;
 179         }
 180         return false;
 181 }
 182
 183 static int mtdpstore_erase_do(struct mtdpstore_context *cxt, loff_t off)
 184 {
 185         struct mtd_info *mtd = cxt->mtd;
 186         struct erase_info erase;
 187         int ret;
 188
 189         off = ALIGN_DOWN(off, cxt->mtd->erasesize);
 190         dev_dbg(&mtd->dev, "try to erase off 0x%llx\n", off);
 191         erase.len = cxt->mtd->erasesize;
 192         erase.addr = off;
 193         ret = mtd_erase(cxt->mtd, &erase);
 194         if (!ret)
 195                 mtdpstore_block_clear_removed(cxt, off);
 196         else
 197                 dev_err(&mtd->dev, "erase of region [0x%llx, 0x%llx] on \"%s\" failed\n",
 198                        (unsigned long long)erase.addr,
 199                        (unsigned long long)erase.len, cxt->info.device);
 200         return ret;
 201 }
 202
 203 /*
 204  * called while removing file
 205  *
 206  * Avoiding over erasing, do erase block only when the whole block is unused.
 207  * If the block contains valid log, do erase lazily on flush_removed() when
 208  * unregister.
 209  */
 210 static ssize_t mtdpstore_erase(size_t size, loff_t off)
 211 {
 212         struct mtdpstore_context *cxt = &oops_cxt;
 213
 214         if (mtdpstore_block_isbad(cxt, off))
 215                 return -EIO;
 216
 217         mtdpstore_mark_unused(cxt, off);
 218
 219         /* If the block still has valid data, mtdpstore do erase lazily */
 220         if (likely(mtdpstore_block_is_used(cxt, off))) {
 221                 mtdpstore_mark_removed(cxt, off);
 222                 return 0;
 223         }
 224
 225         /* all zones are unused, erase it */
 226         return mtdpstore_erase_do(cxt, off);
 227 }
 228
 229 /*
 230  * What is security for mtdpstore?
 231  * As there is no erase for panic case, we should ensure at least one zone
 232  * is writable. Otherwise, panic write will fail.
 233  * If zone is used, write operation will return -ENOMSG, which means that
 234  * pstore/blk will try one by one until gets an empty zone. So, it is not
 235  * needed to ensure the next zone is empty, but at least one.
 236  */
 237 static int mtdpstore_security(struct mtdpstore_context *cxt, loff_t off)
 238 {
 239         int ret = 0, i;
 240         struct mtd_info *mtd = cxt->mtd;
 241         u32 zonenum = (u32)div_u64(off, cxt->info.kmsg_size);
 242         u32 zonecnt = (u32)div_u64(cxt->mtd->size, cxt->info.kmsg_size);
 243         u32 blkcnt = (u32)div_u64(cxt->mtd->size, cxt->mtd->erasesize);
 244         u32 erasesize = cxt->mtd->erasesize;
 245
 246         for (i = 0; i < zonecnt; i++) {
 247                 u32 num = (zonenum + i) % zonecnt;
 248
 249                 /* found empty zone */
 250                 if (!test_bit(num, cxt->usedmap))
 251                         return 0;
 252         }
 253
 254         /* If there is no any empty zone, we have no way but to do erase */
 255         while (blkcnt--) {
 256                 div64_u64_rem(off + erasesize, cxt->mtd->size, (u64 *)&off);
 257
 258                 if (mtdpstore_block_isbad(cxt, off))
 259                         continue;
 260
 261                 ret = mtdpstore_erase_do(cxt, off);
 262                 if (!ret) {
 263                         mtdpstore_block_mark_unused(cxt, off);
 264                         break;
 265                 }
 266         }
 267
 268         if (ret)
 269                 dev_err(&mtd->dev, "all blocks bad!\n");
 270         dev_dbg(&mtd->dev, "end security\n");
 271         return ret;
 272 }
 273
 274 static ssize_t mtdpstore_write(const char *buf, size_t size, loff_t off)
 275 {
 276         struct mtdpstore_context *cxt = &oops_cxt;
 277         struct mtd_info *mtd = cxt->mtd;
 278         size_t retlen;
 279         int ret;
 280
 281         if (mtdpstore_block_isbad(cxt, off))
 282                 return -ENOMSG;
 283
 284         /* zone is used, please try next one */
 285         if (mtdpstore_is_used(cxt, off))
 286                 return -ENOMSG;
 287
 288         dev_dbg(&mtd->dev, "try to write off 0x%llx size %zu\n", off, size);
 289         ret = mtd_write(cxt->mtd, off, size, &retlen, (u_char *)buf);
 290         if (ret < 0 || retlen != size) {
 291                 dev_err(&mtd->dev, "write failure at %lld (%zu of %zu written), err %d\n",
 292                                 off, retlen, size, ret);
 293                 return -EIO;
 294         }
 295         mtdpstore_mark_used(cxt, off);
 296
 297         mtdpstore_security(cxt, off);
 298         return retlen;
 299 }
 300
 301 static inline bool mtdpstore_is_io_error(int ret)
 302 {
 303         return ret < 0 && !mtd_is_bitflip(ret) && !mtd_is_eccerr(ret);
 304 }
 305
 306 /*
 307  * All zones will be read as pstore/blk will read zone one by one when do
 308  * recover.
 309  */
 310 static ssize_t mtdpstore_read(char *buf, size_t size, loff_t off)
 311 {
 312         struct mtdpstore_context *cxt = &oops_cxt;
 313         struct mtd_info *mtd = cxt->mtd;
 314         size_t retlen, done;
 315         int ret;
 316
 317         if (mtdpstore_block_isbad(cxt, off))
 318                 return -ENOMSG;
 319
 320         dev_dbg(&mtd->dev, "try to read off 0x%llx size %zu\n", off, size);
 321         for (done = 0, retlen = 0; done < size; done += retlen) {
 322                 retlen = 0;
 323
 324                 ret = mtd_read(cxt->mtd, off + done, size - done, &retlen,
 325                                 (u_char *)buf + done);
 326                 if (mtdpstore_is_io_error(ret)) {
 327                         dev_err(&mtd->dev, "read failure at %lld (%zu of %zu read), err %d\n",
 328                                         off + done, retlen, size - done, ret);
 329                         /* the zone may be broken, try next one */
 330                         return -ENOMSG;
 331                 }
 332
 333                 /*
 334                  * ECC error. The impact on log data is so small. Maybe we can
 335                  * still read it and try to understand. So mtdpstore just hands
 336                  * over what it gets and user can judge whether the data is
 337                  * valid or not.
 338                  */
 339                 if (mtd_is_eccerr(ret)) {
 340                         dev_err(&mtd->dev, "ecc error at %lld (%zu of %zu read), err %d\n",
 341                                         off + done, retlen, size - done, ret);
 342                         /* driver may not set retlen when ecc error */
 343                         retlen = retlen == 0 ? size - done : retlen;
 344                 }
 345         }
 346
 347         if (mtdpstore_is_empty(cxt, buf, size))
 348                 mtdpstore_mark_unused(cxt, off);
 349         else
 350                 mtdpstore_mark_used(cxt, off);
 351
 352         mtdpstore_security(cxt, off);
 353         return retlen;
 354 }
 355
 356 static ssize_t mtdpstore_panic_write(const char *buf, size_t size, loff_t off)
 357 {
 358         struct mtdpstore_context *cxt = &oops_cxt;
 359         struct mtd_info *mtd = cxt->mtd;
 360         size_t retlen;
 361         int ret;
 362
 363         if (mtdpstore_panic_block_isbad(cxt, off))
 364                 return -ENOMSG;
 365
 366         /* zone is used, please try next one */
 367         if (mtdpstore_is_used(cxt, off))
 368                 return -ENOMSG;
 369
 370         ret = mtd_panic_write(cxt->mtd, off, size, &retlen, (u_char *)buf);
 371         if (ret < 0 || size != retlen) {
 372                 dev_err(&mtd->dev, "panic write failure at %lld (%zu of %zu read), err %d\n",
 373                                 off, retlen, size, ret);
 374                 return -EIO;
 375         }
 376         mtdpstore_mark_used(cxt, off);
 377
 378         return retlen;
 379 }
 380
 381 static void mtdpstore_notify_add(struct mtd_info *mtd)
 382 {
 383         int ret;
 384         struct mtdpstore_context *cxt = &oops_cxt;
 385         struct pstore_blk_config *info = &cxt->info;
 386         unsigned long longcnt;
 387
 388         if (!strcmp(mtd->name, info->device))
 389                 cxt->index = mtd->index;
 390
 391         if (mtd->index != cxt->index || cxt->index < 0)
 392                 return;
 393
 394         dev_dbg(&mtd->dev, "found matching MTD device %s\n", mtd->name);
 395
 396         if (mtd->size < info->kmsg_size * 2) {
 397                 dev_err(&mtd->dev, "MTD partition %d not big enough\n",
 398                                 mtd->index);
 399                 return;
 400         }
 401         /*
 402          * kmsg_size must be aligned to 4096 Bytes, which is limited by
 403          * psblk. The default value of kmsg_size is 64KB. If kmsg_size
 404          * is larger than erasesize, some errors will occur since mtdpstore
 405          * is designed on it.
 406          */
 407         if (mtd->erasesize < info->kmsg_size) {
 408                 dev_err(&mtd->dev, "eraseblock size of MTD partition %d too small\n",
 409                                 mtd->index);
 410                 return;
 411         }
 412         if (unlikely(info->kmsg_size % mtd->writesize)) {
 413                 dev_err(&mtd->dev, "record size %lu KB must align to write size %d KB\n",
 414                                 info->kmsg_size / 1024,
 415                                 mtd->writesize / 1024);
 416                 return;
 417         }
 418
 419         longcnt = BITS_TO_LONGS(div_u64(mtd->size, info->kmsg_size));
 420         cxt->rmmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
 421         cxt->usedmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
 422
 423         longcnt = BITS_TO_LONGS(div_u64(mtd->size, mtd->erasesize));
 424         cxt->badmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);
 425
 426         /* just support dmesg right now */
 427         cxt->dev.flags = PSTORE_FLAGS_DMESG;
 428         cxt->dev.zone.read = mtdpstore_read;
 429         cxt->dev.zone.write = mtdpstore_write;
 430         cxt->dev.zone.erase = mtdpstore_erase;
 431         cxt->dev.zone.panic_write = mtdpstore_panic_write;
 432         cxt->dev.zone.total_size = mtd->size;
 433
 434         ret = register_pstore_device(&cxt->dev);
 435         if (ret) {
 436                 dev_err(&mtd->dev, "mtd%d register to psblk failed\n",
 437                                 mtd->index);
 438                 return;
 439         }
 440         cxt->mtd = mtd;
 441         dev_info(&mtd->dev, "Attached to MTD device %d\n", mtd->index);
 442 }
 443
 444 static int mtdpstore_flush_removed_do(struct mtdpstore_context *cxt,
 445                 loff_t off, size_t size)
 446 {
 447         struct mtd_info *mtd = cxt->mtd;
 448         u_char *buf;
 449         int ret;
 450         size_t retlen;
 451         struct erase_info erase;
 452
 453         buf = kmalloc(mtd->erasesize, GFP_KERNEL);
 454         if (!buf)
 455                 return -ENOMEM;
 456
 457         /* 1st. read to cache */
 458         ret = mtd_read(mtd, off, mtd->erasesize, &retlen, buf);
 459         if (mtdpstore_is_io_error(ret))
 460                 goto free;
 461
 462         /* 2nd. erase block */
 463         erase.len = mtd->erasesize;
 464         erase.addr = off;
 465         ret = mtd_erase(mtd, &erase);
 466         if (ret)
 467                 goto free;
 468
 469         /* 3rd. write back */
 470         while (size) {
 471                 unsigned int zonesize = cxt->info.kmsg_size;
 472
 473                 /* there is valid data on block, write back */
 474                 if (mtdpstore_is_used(cxt, off)) {
 475                         ret = mtd_write(mtd, off, zonesize, &retlen, buf);
 476                         if (ret)
 477                                 dev_err(&mtd->dev, "write failure at %lld (%zu of %u written), err %d\n",
 478                                                 off, retlen, zonesize, ret);
 479                 }
 480
 481                 off += zonesize;
 482                 size -= min_t(unsigned int, zonesize, size);
 483         }
 484
 485 free:
 486         kfree(buf);
 487         return ret;
 488 }
 489
 490 /*
 491  * What does mtdpstore_flush_removed() do?
 492  * When user remove any log file on pstore filesystem, mtdpstore should do
 493  * something to ensure log file removed. If the whole block is no longer used,
 494  * it's nice to erase the block. However if the block still contains valid log,
 495  * what mtdpstore can do is to erase and write the valid log back.
 496  */
 497 static int mtdpstore_flush_removed(struct mtdpstore_context *cxt)
 498 {
 499         struct mtd_info *mtd = cxt->mtd;
 500         int ret;
 501         loff_t off;
 502         u32 blkcnt = (u32)div_u64(mtd->size, mtd->erasesize);
 503
 504         for (off = 0; blkcnt > 0; blkcnt--, off += mtd->erasesize) {
 505                 ret = mtdpstore_block_isbad(cxt, off);
 506                 if (ret)
 507                         continue;
 508
 509                 ret = mtdpstore_block_is_removed(cxt, off);
 510                 if (!ret)
 511                         continue;
 512
 513                 ret = mtdpstore_flush_removed_do(cxt, off, mtd->erasesize);
 514                 if (ret)
 515                         return ret;
 516         }
 517         return 0;
 518 }
 519
 520 static void mtdpstore_notify_remove(struct mtd_info *mtd)
 521 {
 522         struct mtdpstore_context *cxt = &oops_cxt;
 523
 524         if (mtd->index != cxt->index || cxt->index < 0)
 525                 return;
 526
 527         mtdpstore_flush_removed(cxt);
 528
 529         unregister_pstore_device(&cxt->dev);
 530         kfree(cxt->badmap);
 531         kfree(cxt->usedmap);
 532         kfree(cxt->rmmap);
 533         cxt->mtd = NULL;
 534         cxt->index = -1;
 535 }
 536
 537 static struct mtd_notifier mtdpstore_notifier = {
 538         .add    = mtdpstore_notify_add,
 539         .remove = mtdpstore_notify_remove,
 540 };
 541
 542 static int __init mtdpstore_init(void)
 543 {
 544         int ret;
 545         struct mtdpstore_context *cxt = &oops_cxt;
 546         struct pstore_blk_config *info = &cxt->info;
 547
 548         ret = pstore_blk_get_config(info);
 549         if (unlikely(ret))
 550                 return ret;
 551
 552         if (strlen(info->device) == 0) {
 553                 pr_err("mtd device must be supplied (device name is empty)\n");
 554                 return -EINVAL;
 555         }
 556         if (!info->kmsg_size) {
 557                 pr_err("no backend enabled (kmsg_size is 0)\n");
 558                 return -EINVAL;
 559         }
 560
 561         /* Setup the MTD device to use */
 562         ret = kstrtoint((char *)info->device, 0, &cxt->index);
 563         if (ret)
 564                 cxt->index = -1;
 565
 566         register_mtd_user(&mtdpstore_notifier);
 567         return 0;
 568 }
 569 module_init(mtdpstore_init);
 570
 571 static void __exit mtdpstore_exit(void)
 572 {
 573         unregister_mtd_user(&mtdpstore_notifier);
 574 }
 575 module_exit(mtdpstore_exit);
 576
 577 MODULE_LICENSE("GPL");
 578 MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
 579 MODULE_DESCRIPTION("MTD backend for pstore/blk");