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