1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Swap block device support for MTDs 4 * Turns an MTD device into a swap device with block wear leveling 5 * 6 * Copyright © 2007,2011 Nokia Corporation. All rights reserved. 7 * 8 * Authors: Jarkko Lavinen <jarkko.lavinen@nokia.com> 9 * 10 * Based on Richard Purdie's earlier implementation in 2007. Background 11 * support and lock-less operation written by Adrian Hunter. 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/mtd/mtd.h> 17 #include <linux/mtd/blktrans.h> 18 #include <linux/rbtree.h> 19 #include <linux/sched.h> 20 #include <linux/slab.h> 21 #include <linux/vmalloc.h> 22 #include <linux/blkdev.h> 23 #include <linux/swap.h> 24 #include <linux/debugfs.h> 25 #include <linux/seq_file.h> 26 #include <linux/device.h> 27 #include <linux/math64.h> 28 29 #define MTDSWAP_PREFIX "mtdswap" 30 31 /* 32 * The number of free eraseblocks when GC should stop 33 */ 34 #define CLEAN_BLOCK_THRESHOLD 20 35 36 /* 37 * Number of free eraseblocks below which GC can also collect low frag 38 * blocks. 39 */ 40 #define LOW_FRAG_GC_THRESHOLD 5 41 42 /* 43 * Wear level cost amortization. We want to do wear leveling on the background 44 * without disturbing gc too much. This is made by defining max GC frequency. 45 * Frequency value 6 means 1/6 of the GC passes will pick an erase block based 46 * on the biggest wear difference rather than the biggest dirtiness. 47 * 48 * The lower freq2 should be chosen so that it makes sure the maximum erase 49 * difference will decrease even if a malicious application is deliberately 50 * trying to make erase differences large. 51 */ 52 #define MAX_ERASE_DIFF 4000 53 #define COLLECT_NONDIRTY_BASE MAX_ERASE_DIFF 54 #define COLLECT_NONDIRTY_FREQ1 6 55 #define COLLECT_NONDIRTY_FREQ2 4 56 57 #define PAGE_UNDEF UINT_MAX 58 #define BLOCK_UNDEF UINT_MAX 59 #define BLOCK_ERROR (UINT_MAX - 1) 60 #define BLOCK_MAX (UINT_MAX - 2) 61 62 #define EBLOCK_BAD (1 << 0) 63 #define EBLOCK_NOMAGIC (1 << 1) 64 #define EBLOCK_BITFLIP (1 << 2) 65 #define EBLOCK_FAILED (1 << 3) 66 #define EBLOCK_READERR (1 << 4) 67 #define EBLOCK_IDX_SHIFT 5 68 69 struct swap_eb { 70 struct rb_node rb; 71 struct rb_root *root; 72 73 unsigned int flags; 74 unsigned int active_count; 75 unsigned int erase_count; 76 unsigned int pad; /* speeds up pointer decrement */ 77 }; 78 79 #define MTDSWAP_ECNT_MIN(rbroot) (rb_entry(rb_first(rbroot), struct swap_eb, \ 80 rb)->erase_count) 81 #define MTDSWAP_ECNT_MAX(rbroot) (rb_entry(rb_last(rbroot), struct swap_eb, \ 82 rb)->erase_count) 83 84 struct mtdswap_tree { 85 struct rb_root root; 86 unsigned int count; 87 }; 88 89 enum { 90 MTDSWAP_CLEAN, 91 MTDSWAP_USED, 92 MTDSWAP_LOWFRAG, 93 MTDSWAP_HIFRAG, 94 MTDSWAP_DIRTY, 95 MTDSWAP_BITFLIP, 96 MTDSWAP_FAILING, 97 MTDSWAP_TREE_CNT, 98 }; 99 100 struct mtdswap_dev { 101 struct mtd_blktrans_dev *mbd_dev; 102 struct mtd_info *mtd; 103 struct device *dev; 104 105 unsigned int *page_data; 106 unsigned int *revmap; 107 108 unsigned int eblks; 109 unsigned int spare_eblks; 110 unsigned int pages_per_eblk; 111 unsigned int max_erase_count; 112 struct swap_eb *eb_data; 113 114 struct mtdswap_tree trees[MTDSWAP_TREE_CNT]; 115 116 unsigned long long sect_read_count; 117 unsigned long long sect_write_count; 118 unsigned long long mtd_write_count; 119 unsigned long long mtd_read_count; 120 unsigned long long discard_count; 121 unsigned long long discard_page_count; 122 123 unsigned int curr_write_pos; 124 struct swap_eb *curr_write; 125 126 char *page_buf; 127 char *oob_buf; 128 struct dentry *debugfs_stats; 129 }; 130 131 struct mtdswap_oobdata { 132 __le16 magic; 133 __le32 count; 134 } __packed; 135 136 #define MTDSWAP_MAGIC_CLEAN 0x2095 137 #define MTDSWAP_MAGIC_DIRTY (MTDSWAP_MAGIC_CLEAN + 1) 138 #define MTDSWAP_TYPE_CLEAN 0 139 #define MTDSWAP_TYPE_DIRTY 1 140 #define MTDSWAP_OOBSIZE sizeof(struct mtdswap_oobdata) 141 142 #define MTDSWAP_ERASE_RETRIES 3 /* Before marking erase block bad */ 143 #define MTDSWAP_IO_RETRIES 3 144 145 enum { 146 MTDSWAP_SCANNED_CLEAN, 147 MTDSWAP_SCANNED_DIRTY, 148 MTDSWAP_SCANNED_BITFLIP, 149 MTDSWAP_SCANNED_BAD, 150 }; 151 152 /* 153 * In the worst case mtdswap_writesect() has allocated the last clean 154 * page from the current block and is then pre-empted by the GC 155 * thread. The thread can consume a full erase block when moving a 156 * block. 157 */ 158 #define MIN_SPARE_EBLOCKS 2 159 #define MIN_ERASE_BLOCKS (MIN_SPARE_EBLOCKS + 1) 160 161 #define TREE_ROOT(d, name) (&d->trees[MTDSWAP_ ## name].root) 162 #define TREE_EMPTY(d, name) (TREE_ROOT(d, name)->rb_node == NULL) 163 #define TREE_NONEMPTY(d, name) (!TREE_EMPTY(d, name)) 164 #define TREE_COUNT(d, name) (d->trees[MTDSWAP_ ## name].count) 165 166 #define MTDSWAP_MBD_TO_MTDSWAP(dev) ((struct mtdswap_dev *)dev->priv) 167 168 static char partitions[128] = ""; 169 module_param_string(partitions, partitions, sizeof(partitions), 0444); 170 MODULE_PARM_DESC(partitions, "MTD partition numbers to use as swap " 171 "partitions=\"1,3,5\""); 172 173 static unsigned int spare_eblocks = 10; 174 module_param(spare_eblocks, uint, 0444); 175 MODULE_PARM_DESC(spare_eblocks, "Percentage of spare erase blocks for " 176 "garbage collection (default 10%)"); 177 178 static bool header; /* false */ 179 module_param(header, bool, 0444); 180 MODULE_PARM_DESC(header, 181 "Include builtin swap header (default 0, without header)"); 182 183 static int mtdswap_gc(struct mtdswap_dev *d, unsigned int background); 184 185 static loff_t mtdswap_eb_offset(struct mtdswap_dev *d, struct swap_eb *eb) 186 { 187 return (loff_t)(eb - d->eb_data) * d->mtd->erasesize; 188 } 189 190 static void mtdswap_eb_detach(struct mtdswap_dev *d, struct swap_eb *eb) 191 { 192 unsigned int oldidx; 193 struct mtdswap_tree *tp; 194 195 if (eb->root) { 196 tp = container_of(eb->root, struct mtdswap_tree, root); 197 oldidx = tp - &d->trees[0]; 198 199 d->trees[oldidx].count--; 200 rb_erase(&eb->rb, eb->root); 201 } 202 } 203 204 static void __mtdswap_rb_add(struct rb_root *root, struct swap_eb *eb) 205 { 206 struct rb_node **p, *parent = NULL; 207 struct swap_eb *cur; 208 209 p = &root->rb_node; 210 while (*p) { 211 parent = *p; 212 cur = rb_entry(parent, struct swap_eb, rb); 213 if (eb->erase_count > cur->erase_count) 214 p = &(*p)->rb_right; 215 else 216 p = &(*p)->rb_left; 217 } 218 219 rb_link_node(&eb->rb, parent, p); 220 rb_insert_color(&eb->rb, root); 221 } 222 223 static void mtdswap_rb_add(struct mtdswap_dev *d, struct swap_eb *eb, int idx) 224 { 225 struct rb_root *root; 226 227 if (eb->root == &d->trees[idx].root) 228 return; 229 230 mtdswap_eb_detach(d, eb); 231 root = &d->trees[idx].root; 232 __mtdswap_rb_add(root, eb); 233 eb->root = root; 234 d->trees[idx].count++; 235 } 236 237 static struct rb_node *mtdswap_rb_index(struct rb_root *root, unsigned int idx) 238 { 239 struct rb_node *p; 240 unsigned int i; 241 242 p = rb_first(root); 243 i = 0; 244 while (i < idx && p) { 245 p = rb_next(p); 246 i++; 247 } 248 249 return p; 250 } 251 252 static int mtdswap_handle_badblock(struct mtdswap_dev *d, struct swap_eb *eb) 253 { 254 int ret; 255 loff_t offset; 256 257 d->spare_eblks--; 258 eb->flags |= EBLOCK_BAD; 259 mtdswap_eb_detach(d, eb); 260 eb->root = NULL; 261 262 /* badblocks not supported */ 263 if (!mtd_can_have_bb(d->mtd)) 264 return 1; 265 266 offset = mtdswap_eb_offset(d, eb); 267 dev_warn(d->dev, "Marking bad block at %08llx\n", offset); 268 ret = mtd_block_markbad(d->mtd, offset); 269 270 if (ret) { 271 dev_warn(d->dev, "Mark block bad failed for block at %08llx " 272 "error %d\n", offset, ret); 273 return ret; 274 } 275 276 return 1; 277 278 } 279 280 static int mtdswap_handle_write_error(struct mtdswap_dev *d, struct swap_eb *eb) 281 { 282 unsigned int marked = eb->flags & EBLOCK_FAILED; 283 struct swap_eb *curr_write = d->curr_write; 284 285 eb->flags |= EBLOCK_FAILED; 286 if (curr_write == eb) { 287 d->curr_write = NULL; 288 289 if (!marked && d->curr_write_pos != 0) { 290 mtdswap_rb_add(d, eb, MTDSWAP_FAILING); 291 return 0; 292 } 293 } 294 295 return mtdswap_handle_badblock(d, eb); 296 } 297 298 static int mtdswap_read_oob(struct mtdswap_dev *d, loff_t from, 299 struct mtd_oob_ops *ops) 300 { 301 int ret = mtd_read_oob(d->mtd, from, ops); 302 303 if (mtd_is_bitflip(ret)) 304 return ret; 305 306 if (ret) { 307 dev_warn(d->dev, "Read OOB failed %d for block at %08llx\n", 308 ret, from); 309 return ret; 310 } 311 312 if (ops->oobretlen < ops->ooblen) { 313 dev_warn(d->dev, "Read OOB return short read (%zd bytes not " 314 "%zd) for block at %08llx\n", 315 ops->oobretlen, ops->ooblen, from); 316 return -EIO; 317 } 318 319 return 0; 320 } 321 322 static int mtdswap_read_markers(struct mtdswap_dev *d, struct swap_eb *eb) 323 { 324 struct mtdswap_oobdata *data, *data2; 325 int ret; 326 loff_t offset; 327 struct mtd_oob_ops ops = { }; 328 329 offset = mtdswap_eb_offset(d, eb); 330 331 /* Check first if the block is bad. */ 332 if (mtd_can_have_bb(d->mtd) && mtd_block_isbad(d->mtd, offset)) 333 return MTDSWAP_SCANNED_BAD; 334 335 ops.ooblen = 2 * d->mtd->oobavail; 336 ops.oobbuf = d->oob_buf; 337 ops.ooboffs = 0; 338 ops.datbuf = NULL; 339 ops.mode = MTD_OPS_AUTO_OOB; 340 341 ret = mtdswap_read_oob(d, offset, &ops); 342 343 if (ret && !mtd_is_bitflip(ret)) 344 return ret; 345 346 data = (struct mtdswap_oobdata *)d->oob_buf; 347 data2 = (struct mtdswap_oobdata *) 348 (d->oob_buf + d->mtd->oobavail); 349 350 if (le16_to_cpu(data->magic) == MTDSWAP_MAGIC_CLEAN) { 351 eb->erase_count = le32_to_cpu(data->count); 352 if (mtd_is_bitflip(ret)) 353 ret = MTDSWAP_SCANNED_BITFLIP; 354 else { 355 if (le16_to_cpu(data2->magic) == MTDSWAP_MAGIC_DIRTY) 356 ret = MTDSWAP_SCANNED_DIRTY; 357 else 358 ret = MTDSWAP_SCANNED_CLEAN; 359 } 360 } else { 361 eb->flags |= EBLOCK_NOMAGIC; 362 ret = MTDSWAP_SCANNED_DIRTY; 363 } 364 365 return ret; 366 } 367 368 static int mtdswap_write_marker(struct mtdswap_dev *d, struct swap_eb *eb, 369 u16 marker) 370 { 371 struct mtdswap_oobdata n; 372 int ret; 373 loff_t offset; 374 struct mtd_oob_ops ops = { }; 375 376 ops.ooboffs = 0; 377 ops.oobbuf = (uint8_t *)&n; 378 ops.mode = MTD_OPS_AUTO_OOB; 379 ops.datbuf = NULL; 380 381 if (marker == MTDSWAP_TYPE_CLEAN) { 382 n.magic = cpu_to_le16(MTDSWAP_MAGIC_CLEAN); 383 n.count = cpu_to_le32(eb->erase_count); 384 ops.ooblen = MTDSWAP_OOBSIZE; 385 offset = mtdswap_eb_offset(d, eb); 386 } else { 387 n.magic = cpu_to_le16(MTDSWAP_MAGIC_DIRTY); 388 ops.ooblen = sizeof(n.magic); 389 offset = mtdswap_eb_offset(d, eb) + d->mtd->writesize; 390 } 391 392 ret = mtd_write_oob(d->mtd, offset, &ops); 393 394 if (ret) { 395 dev_warn(d->dev, "Write OOB failed for block at %08llx " 396 "error %d\n", offset, ret); 397 if (ret == -EIO || mtd_is_eccerr(ret)) 398 mtdswap_handle_write_error(d, eb); 399 return ret; 400 } 401 402 if (ops.oobretlen != ops.ooblen) { 403 dev_warn(d->dev, "Short OOB write for block at %08llx: " 404 "%zd not %zd\n", 405 offset, ops.oobretlen, ops.ooblen); 406 return ret; 407 } 408 409 return 0; 410 } 411 412 /* 413 * Are there any erase blocks without MAGIC_CLEAN header, presumably 414 * because power was cut off after erase but before header write? We 415 * need to guestimate the erase count. 416 */ 417 static void mtdswap_check_counts(struct mtdswap_dev *d) 418 { 419 struct rb_root hist_root = RB_ROOT; 420 struct rb_node *medrb; 421 struct swap_eb *eb; 422 unsigned int i, cnt, median; 423 424 cnt = 0; 425 for (i = 0; i < d->eblks; i++) { 426 eb = d->eb_data + i; 427 428 if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_BAD | EBLOCK_READERR)) 429 continue; 430 431 __mtdswap_rb_add(&hist_root, eb); 432 cnt++; 433 } 434 435 if (cnt == 0) 436 return; 437 438 medrb = mtdswap_rb_index(&hist_root, cnt / 2); 439 median = rb_entry(medrb, struct swap_eb, rb)->erase_count; 440 441 d->max_erase_count = MTDSWAP_ECNT_MAX(&hist_root); 442 443 for (i = 0; i < d->eblks; i++) { 444 eb = d->eb_data + i; 445 446 if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_READERR)) 447 eb->erase_count = median; 448 449 if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_BAD | EBLOCK_READERR)) 450 continue; 451 452 rb_erase(&eb->rb, &hist_root); 453 } 454 } 455 456 static void mtdswap_scan_eblks(struct mtdswap_dev *d) 457 { 458 int status; 459 unsigned int i, idx; 460 struct swap_eb *eb; 461 462 for (i = 0; i < d->eblks; i++) { 463 eb = d->eb_data + i; 464 465 status = mtdswap_read_markers(d, eb); 466 if (status < 0) 467 eb->flags |= EBLOCK_READERR; 468 else if (status == MTDSWAP_SCANNED_BAD) { 469 eb->flags |= EBLOCK_BAD; 470 continue; 471 } 472 473 switch (status) { 474 case MTDSWAP_SCANNED_CLEAN: 475 idx = MTDSWAP_CLEAN; 476 break; 477 case MTDSWAP_SCANNED_DIRTY: 478 case MTDSWAP_SCANNED_BITFLIP: 479 idx = MTDSWAP_DIRTY; 480 break; 481 default: 482 idx = MTDSWAP_FAILING; 483 } 484 485 eb->flags |= (idx << EBLOCK_IDX_SHIFT); 486 } 487 488 mtdswap_check_counts(d); 489 490 for (i = 0; i < d->eblks; i++) { 491 eb = d->eb_data + i; 492 493 if (eb->flags & EBLOCK_BAD) 494 continue; 495 496 idx = eb->flags >> EBLOCK_IDX_SHIFT; 497 mtdswap_rb_add(d, eb, idx); 498 } 499 } 500 501 /* 502 * Place eblk into a tree corresponding to its number of active blocks 503 * it contains. 504 */ 505 static void mtdswap_store_eb(struct mtdswap_dev *d, struct swap_eb *eb) 506 { 507 unsigned int weight = eb->active_count; 508 unsigned int maxweight = d->pages_per_eblk; 509 510 if (eb == d->curr_write) 511 return; 512 513 if (eb->flags & EBLOCK_BITFLIP) 514 mtdswap_rb_add(d, eb, MTDSWAP_BITFLIP); 515 else if (eb->flags & (EBLOCK_READERR | EBLOCK_FAILED)) 516 mtdswap_rb_add(d, eb, MTDSWAP_FAILING); 517 if (weight == maxweight) 518 mtdswap_rb_add(d, eb, MTDSWAP_USED); 519 else if (weight == 0) 520 mtdswap_rb_add(d, eb, MTDSWAP_DIRTY); 521 else if (weight > (maxweight/2)) 522 mtdswap_rb_add(d, eb, MTDSWAP_LOWFRAG); 523 else 524 mtdswap_rb_add(d, eb, MTDSWAP_HIFRAG); 525 } 526 527 static int mtdswap_erase_block(struct mtdswap_dev *d, struct swap_eb *eb) 528 { 529 struct mtd_info *mtd = d->mtd; 530 struct erase_info erase; 531 unsigned int retries = 0; 532 int ret; 533 534 eb->erase_count++; 535 if (eb->erase_count > d->max_erase_count) 536 d->max_erase_count = eb->erase_count; 537 538 retry: 539 memset(&erase, 0, sizeof(struct erase_info)); 540 erase.addr = mtdswap_eb_offset(d, eb); 541 erase.len = mtd->erasesize; 542 543 ret = mtd_erase(mtd, &erase); 544 if (ret) { 545 if (retries++ < MTDSWAP_ERASE_RETRIES) { 546 dev_warn(d->dev, 547 "erase of erase block %#llx on %s failed", 548 erase.addr, mtd->name); 549 yield(); 550 goto retry; 551 } 552 553 dev_err(d->dev, "Cannot erase erase block %#llx on %s\n", 554 erase.addr, mtd->name); 555 556 mtdswap_handle_badblock(d, eb); 557 return -EIO; 558 } 559 560 return 0; 561 } 562 563 static int mtdswap_map_free_block(struct mtdswap_dev *d, unsigned int page, 564 unsigned int *block) 565 { 566 int ret; 567 struct swap_eb *old_eb = d->curr_write; 568 struct rb_root *clean_root; 569 struct swap_eb *eb; 570 571 if (old_eb == NULL || d->curr_write_pos >= d->pages_per_eblk) { 572 do { 573 if (TREE_EMPTY(d, CLEAN)) 574 return -ENOSPC; 575 576 clean_root = TREE_ROOT(d, CLEAN); 577 eb = rb_entry(rb_first(clean_root), struct swap_eb, rb); 578 rb_erase(&eb->rb, clean_root); 579 eb->root = NULL; 580 TREE_COUNT(d, CLEAN)--; 581 582 ret = mtdswap_write_marker(d, eb, MTDSWAP_TYPE_DIRTY); 583 } while (ret == -EIO || mtd_is_eccerr(ret)); 584 585 if (ret) 586 return ret; 587 588 d->curr_write_pos = 0; 589 d->curr_write = eb; 590 if (old_eb) 591 mtdswap_store_eb(d, old_eb); 592 } 593 594 *block = (d->curr_write - d->eb_data) * d->pages_per_eblk + 595 d->curr_write_pos; 596 597 d->curr_write->active_count++; 598 d->revmap[*block] = page; 599 d->curr_write_pos++; 600 601 return 0; 602 } 603 604 static unsigned int mtdswap_free_page_cnt(struct mtdswap_dev *d) 605 { 606 return TREE_COUNT(d, CLEAN) * d->pages_per_eblk + 607 d->pages_per_eblk - d->curr_write_pos; 608 } 609 610 static unsigned int mtdswap_enough_free_pages(struct mtdswap_dev *d) 611 { 612 return mtdswap_free_page_cnt(d) > d->pages_per_eblk; 613 } 614 615 static int mtdswap_write_block(struct mtdswap_dev *d, char *buf, 616 unsigned int page, unsigned int *bp, int gc_context) 617 { 618 struct mtd_info *mtd = d->mtd; 619 struct swap_eb *eb; 620 size_t retlen; 621 loff_t writepos; 622 int ret; 623 624 retry: 625 if (!gc_context) 626 while (!mtdswap_enough_free_pages(d)) 627 if (mtdswap_gc(d, 0) > 0) 628 return -ENOSPC; 629 630 ret = mtdswap_map_free_block(d, page, bp); 631 eb = d->eb_data + (*bp / d->pages_per_eblk); 632 633 if (ret == -EIO || mtd_is_eccerr(ret)) { 634 d->curr_write = NULL; 635 eb->active_count--; 636 d->revmap[*bp] = PAGE_UNDEF; 637 goto retry; 638 } 639 640 if (ret < 0) 641 return ret; 642 643 writepos = (loff_t)*bp << PAGE_SHIFT; 644 ret = mtd_write(mtd, writepos, PAGE_SIZE, &retlen, buf); 645 if (ret == -EIO || mtd_is_eccerr(ret)) { 646 d->curr_write_pos--; 647 eb->active_count--; 648 d->revmap[*bp] = PAGE_UNDEF; 649 mtdswap_handle_write_error(d, eb); 650 goto retry; 651 } 652 653 if (ret < 0) { 654 dev_err(d->dev, "Write to MTD device failed: %d (%zd written)", 655 ret, retlen); 656 goto err; 657 } 658 659 if (retlen != PAGE_SIZE) { 660 dev_err(d->dev, "Short write to MTD device: %zd written", 661 retlen); 662 ret = -EIO; 663 goto err; 664 } 665 666 return ret; 667 668 err: 669 d->curr_write_pos--; 670 eb->active_count--; 671 d->revmap[*bp] = PAGE_UNDEF; 672 673 return ret; 674 } 675 676 static int mtdswap_move_block(struct mtdswap_dev *d, unsigned int oldblock, 677 unsigned int *newblock) 678 { 679 struct mtd_info *mtd = d->mtd; 680 struct swap_eb *eb, *oldeb; 681 int ret; 682 size_t retlen; 683 unsigned int page, retries; 684 loff_t readpos; 685 686 page = d->revmap[oldblock]; 687 readpos = (loff_t) oldblock << PAGE_SHIFT; 688 retries = 0; 689 690 retry: 691 ret = mtd_read(mtd, readpos, PAGE_SIZE, &retlen, d->page_buf); 692 693 if (ret < 0 && !mtd_is_bitflip(ret)) { 694 oldeb = d->eb_data + oldblock / d->pages_per_eblk; 695 oldeb->flags |= EBLOCK_READERR; 696 697 dev_err(d->dev, "Read Error: %d (block %u)\n", ret, 698 oldblock); 699 retries++; 700 if (retries < MTDSWAP_IO_RETRIES) 701 goto retry; 702 703 goto read_error; 704 } 705 706 if (retlen != PAGE_SIZE) { 707 dev_err(d->dev, "Short read: %zd (block %u)\n", retlen, 708 oldblock); 709 ret = -EIO; 710 goto read_error; 711 } 712 713 ret = mtdswap_write_block(d, d->page_buf, page, newblock, 1); 714 if (ret < 0) { 715 d->page_data[page] = BLOCK_ERROR; 716 dev_err(d->dev, "Write error: %d\n", ret); 717 return ret; 718 } 719 720 d->page_data[page] = *newblock; 721 d->revmap[oldblock] = PAGE_UNDEF; 722 eb = d->eb_data + oldblock / d->pages_per_eblk; 723 eb->active_count--; 724 725 return 0; 726 727 read_error: 728 d->page_data[page] = BLOCK_ERROR; 729 d->revmap[oldblock] = PAGE_UNDEF; 730 return ret; 731 } 732 733 static int mtdswap_gc_eblock(struct mtdswap_dev *d, struct swap_eb *eb) 734 { 735 unsigned int i, block, eblk_base, newblock; 736 int ret, errcode; 737 738 errcode = 0; 739 eblk_base = (eb - d->eb_data) * d->pages_per_eblk; 740 741 for (i = 0; i < d->pages_per_eblk; i++) { 742 if (d->spare_eblks < MIN_SPARE_EBLOCKS) 743 return -ENOSPC; 744 745 block = eblk_base + i; 746 if (d->revmap[block] == PAGE_UNDEF) 747 continue; 748 749 ret = mtdswap_move_block(d, block, &newblock); 750 if (ret < 0 && !errcode) 751 errcode = ret; 752 } 753 754 return errcode; 755 } 756 757 static int __mtdswap_choose_gc_tree(struct mtdswap_dev *d) 758 { 759 int idx, stopat; 760 761 if (TREE_COUNT(d, CLEAN) < LOW_FRAG_GC_THRESHOLD) 762 stopat = MTDSWAP_LOWFRAG; 763 else 764 stopat = MTDSWAP_HIFRAG; 765 766 for (idx = MTDSWAP_BITFLIP; idx >= stopat; idx--) 767 if (d->trees[idx].root.rb_node != NULL) 768 return idx; 769 770 return -1; 771 } 772 773 static int mtdswap_wlfreq(unsigned int maxdiff) 774 { 775 unsigned int h, x, y, dist, base; 776 777 /* 778 * Calculate linear ramp down from f1 to f2 when maxdiff goes from 779 * MAX_ERASE_DIFF to MAX_ERASE_DIFF + COLLECT_NONDIRTY_BASE. Similar 780 * to triangle with height f1 - f1 and width COLLECT_NONDIRTY_BASE. 781 */ 782 783 dist = maxdiff - MAX_ERASE_DIFF; 784 if (dist > COLLECT_NONDIRTY_BASE) 785 dist = COLLECT_NONDIRTY_BASE; 786 787 /* 788 * Modelling the slop as right angular triangle with base 789 * COLLECT_NONDIRTY_BASE and height freq1 - freq2. The ratio y/x is 790 * equal to the ratio h/base. 791 */ 792 h = COLLECT_NONDIRTY_FREQ1 - COLLECT_NONDIRTY_FREQ2; 793 base = COLLECT_NONDIRTY_BASE; 794 795 x = dist - base; 796 y = (x * h + base / 2) / base; 797 798 return COLLECT_NONDIRTY_FREQ2 + y; 799 } 800 801 static int mtdswap_choose_wl_tree(struct mtdswap_dev *d) 802 { 803 static unsigned int pick_cnt; 804 unsigned int i, idx = -1, wear, max; 805 struct rb_root *root; 806 807 max = 0; 808 for (i = 0; i <= MTDSWAP_DIRTY; i++) { 809 root = &d->trees[i].root; 810 if (root->rb_node == NULL) 811 continue; 812 813 wear = d->max_erase_count - MTDSWAP_ECNT_MIN(root); 814 if (wear > max) { 815 max = wear; 816 idx = i; 817 } 818 } 819 820 if (max > MAX_ERASE_DIFF && pick_cnt >= mtdswap_wlfreq(max) - 1) { 821 pick_cnt = 0; 822 return idx; 823 } 824 825 pick_cnt++; 826 return -1; 827 } 828 829 static int mtdswap_choose_gc_tree(struct mtdswap_dev *d, 830 unsigned int background) 831 { 832 int idx; 833 834 if (TREE_NONEMPTY(d, FAILING) && 835 (background || (TREE_EMPTY(d, CLEAN) && TREE_EMPTY(d, DIRTY)))) 836 return MTDSWAP_FAILING; 837 838 idx = mtdswap_choose_wl_tree(d); 839 if (idx >= MTDSWAP_CLEAN) 840 return idx; 841 842 return __mtdswap_choose_gc_tree(d); 843 } 844 845 static struct swap_eb *mtdswap_pick_gc_eblk(struct mtdswap_dev *d, 846 unsigned int background) 847 { 848 struct rb_root *rp = NULL; 849 struct swap_eb *eb = NULL; 850 int idx; 851 852 if (background && TREE_COUNT(d, CLEAN) > CLEAN_BLOCK_THRESHOLD && 853 TREE_EMPTY(d, DIRTY) && TREE_EMPTY(d, FAILING)) 854 return NULL; 855 856 idx = mtdswap_choose_gc_tree(d, background); 857 if (idx < 0) 858 return NULL; 859 860 rp = &d->trees[idx].root; 861 eb = rb_entry(rb_first(rp), struct swap_eb, rb); 862 863 rb_erase(&eb->rb, rp); 864 eb->root = NULL; 865 d->trees[idx].count--; 866 return eb; 867 } 868 869 static unsigned int mtdswap_test_patt(unsigned int i) 870 { 871 return i % 2 ? 0x55555555 : 0xAAAAAAAA; 872 } 873 874 static unsigned int mtdswap_eblk_passes(struct mtdswap_dev *d, 875 struct swap_eb *eb) 876 { 877 struct mtd_info *mtd = d->mtd; 878 unsigned int test, i, j, patt, mtd_pages; 879 loff_t base, pos; 880 unsigned int *p1 = (unsigned int *)d->page_buf; 881 unsigned char *p2 = (unsigned char *)d->oob_buf; 882 struct mtd_oob_ops ops = { }; 883 int ret; 884 885 ops.mode = MTD_OPS_AUTO_OOB; 886 ops.len = mtd->writesize; 887 ops.ooblen = mtd->oobavail; 888 ops.ooboffs = 0; 889 ops.datbuf = d->page_buf; 890 ops.oobbuf = d->oob_buf; 891 base = mtdswap_eb_offset(d, eb); 892 mtd_pages = d->pages_per_eblk * PAGE_SIZE / mtd->writesize; 893 894 for (test = 0; test < 2; test++) { 895 pos = base; 896 for (i = 0; i < mtd_pages; i++) { 897 patt = mtdswap_test_patt(test + i); 898 memset(d->page_buf, patt, mtd->writesize); 899 memset(d->oob_buf, patt, mtd->oobavail); 900 ret = mtd_write_oob(mtd, pos, &ops); 901 if (ret) 902 goto error; 903 904 pos += mtd->writesize; 905 } 906 907 pos = base; 908 for (i = 0; i < mtd_pages; i++) { 909 ret = mtd_read_oob(mtd, pos, &ops); 910 if (ret) 911 goto error; 912 913 patt = mtdswap_test_patt(test + i); 914 for (j = 0; j < mtd->writesize/sizeof(int); j++) 915 if (p1[j] != patt) 916 goto error; 917 918 for (j = 0; j < mtd->oobavail; j++) 919 if (p2[j] != (unsigned char)patt) 920 goto error; 921 922 pos += mtd->writesize; 923 } 924 925 ret = mtdswap_erase_block(d, eb); 926 if (ret) 927 goto error; 928 } 929 930 eb->flags &= ~EBLOCK_READERR; 931 return 1; 932 933 error: 934 mtdswap_handle_badblock(d, eb); 935 return 0; 936 } 937 938 static int mtdswap_gc(struct mtdswap_dev *d, unsigned int background) 939 { 940 struct swap_eb *eb; 941 int ret; 942 943 if (d->spare_eblks < MIN_SPARE_EBLOCKS) 944 return 1; 945 946 eb = mtdswap_pick_gc_eblk(d, background); 947 if (!eb) 948 return 1; 949 950 ret = mtdswap_gc_eblock(d, eb); 951 if (ret == -ENOSPC) 952 return 1; 953 954 if (eb->flags & EBLOCK_FAILED) { 955 mtdswap_handle_badblock(d, eb); 956 return 0; 957 } 958 959 eb->flags &= ~EBLOCK_BITFLIP; 960 ret = mtdswap_erase_block(d, eb); 961 if ((eb->flags & EBLOCK_READERR) && 962 (ret || !mtdswap_eblk_passes(d, eb))) 963 return 0; 964 965 if (ret == 0) 966 ret = mtdswap_write_marker(d, eb, MTDSWAP_TYPE_CLEAN); 967 968 if (ret == 0) 969 mtdswap_rb_add(d, eb, MTDSWAP_CLEAN); 970 else if (ret != -EIO && !mtd_is_eccerr(ret)) 971 mtdswap_rb_add(d, eb, MTDSWAP_DIRTY); 972 973 return 0; 974 } 975 976 static void mtdswap_background(struct mtd_blktrans_dev *dev) 977 { 978 struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev); 979 int ret; 980 981 while (1) { 982 ret = mtdswap_gc(d, 1); 983 if (ret || mtd_blktrans_cease_background(dev)) 984 return; 985 } 986 } 987 988 static void mtdswap_cleanup(struct mtdswap_dev *d) 989 { 990 vfree(d->eb_data); 991 vfree(d->revmap); 992 vfree(d->page_data); 993 kfree(d->oob_buf); 994 kfree(d->page_buf); 995 } 996 997 static int mtdswap_flush(struct mtd_blktrans_dev *dev) 998 { 999 struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev); 1000 1001 mtd_sync(d->mtd); 1002 return 0; 1003 } 1004 1005 static unsigned int mtdswap_badblocks(struct mtd_info *mtd, uint64_t size) 1006 { 1007 loff_t offset; 1008 unsigned int badcnt; 1009 1010 badcnt = 0; 1011 1012 if (mtd_can_have_bb(mtd)) 1013 for (offset = 0; offset < size; offset += mtd->erasesize) 1014 if (mtd_block_isbad(mtd, offset)) 1015 badcnt++; 1016 1017 return badcnt; 1018 } 1019 1020 static int mtdswap_writesect(struct mtd_blktrans_dev *dev, 1021 unsigned long page, char *buf) 1022 { 1023 struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev); 1024 unsigned int newblock, mapped; 1025 struct swap_eb *eb; 1026 int ret; 1027 1028 d->sect_write_count++; 1029 1030 if (d->spare_eblks < MIN_SPARE_EBLOCKS) 1031 return -ENOSPC; 1032 1033 if (header) { 1034 /* Ignore writes to the header page */ 1035 if (unlikely(page == 0)) 1036 return 0; 1037 1038 page--; 1039 } 1040 1041 mapped = d->page_data[page]; 1042 if (mapped <= BLOCK_MAX) { 1043 eb = d->eb_data + (mapped / d->pages_per_eblk); 1044 eb->active_count--; 1045 mtdswap_store_eb(d, eb); 1046 d->page_data[page] = BLOCK_UNDEF; 1047 d->revmap[mapped] = PAGE_UNDEF; 1048 } 1049 1050 ret = mtdswap_write_block(d, buf, page, &newblock, 0); 1051 d->mtd_write_count++; 1052 1053 if (ret < 0) 1054 return ret; 1055 1056 d->page_data[page] = newblock; 1057 1058 return 0; 1059 } 1060 1061 /* Provide a dummy swap header for the kernel */ 1062 static int mtdswap_auto_header(struct mtdswap_dev *d, char *buf) 1063 { 1064 union swap_header *hd = (union swap_header *)(buf); 1065 1066 memset(buf, 0, PAGE_SIZE - 10); 1067 1068 hd->info.version = 1; 1069 hd->info.last_page = d->mbd_dev->size - 1; 1070 hd->info.nr_badpages = 0; 1071 1072 memcpy(buf + PAGE_SIZE - 10, "SWAPSPACE2", 10); 1073 1074 return 0; 1075 } 1076 1077 static int mtdswap_readsect(struct mtd_blktrans_dev *dev, 1078 unsigned long page, char *buf) 1079 { 1080 struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev); 1081 struct mtd_info *mtd = d->mtd; 1082 unsigned int realblock, retries; 1083 loff_t readpos; 1084 struct swap_eb *eb; 1085 size_t retlen; 1086 int ret; 1087 1088 d->sect_read_count++; 1089 1090 if (header) { 1091 if (unlikely(page == 0)) 1092 return mtdswap_auto_header(d, buf); 1093 1094 page--; 1095 } 1096 1097 realblock = d->page_data[page]; 1098 if (realblock > BLOCK_MAX) { 1099 memset(buf, 0x0, PAGE_SIZE); 1100 if (realblock == BLOCK_UNDEF) 1101 return 0; 1102 else 1103 return -EIO; 1104 } 1105 1106 eb = d->eb_data + (realblock / d->pages_per_eblk); 1107 BUG_ON(d->revmap[realblock] == PAGE_UNDEF); 1108 1109 readpos = (loff_t)realblock << PAGE_SHIFT; 1110 retries = 0; 1111 1112 retry: 1113 ret = mtd_read(mtd, readpos, PAGE_SIZE, &retlen, buf); 1114 1115 d->mtd_read_count++; 1116 if (mtd_is_bitflip(ret)) { 1117 eb->flags |= EBLOCK_BITFLIP; 1118 mtdswap_rb_add(d, eb, MTDSWAP_BITFLIP); 1119 ret = 0; 1120 } 1121 1122 if (ret < 0) { 1123 dev_err(d->dev, "Read error %d\n", ret); 1124 eb->flags |= EBLOCK_READERR; 1125 mtdswap_rb_add(d, eb, MTDSWAP_FAILING); 1126 retries++; 1127 if (retries < MTDSWAP_IO_RETRIES) 1128 goto retry; 1129 1130 return ret; 1131 } 1132 1133 if (retlen != PAGE_SIZE) { 1134 dev_err(d->dev, "Short read %zd\n", retlen); 1135 return -EIO; 1136 } 1137 1138 return 0; 1139 } 1140 1141 static int mtdswap_discard(struct mtd_blktrans_dev *dev, unsigned long first, 1142 unsigned nr_pages) 1143 { 1144 struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev); 1145 unsigned long page; 1146 struct swap_eb *eb; 1147 unsigned int mapped; 1148 1149 d->discard_count++; 1150 1151 for (page = first; page < first + nr_pages; page++) { 1152 mapped = d->page_data[page]; 1153 if (mapped <= BLOCK_MAX) { 1154 eb = d->eb_data + (mapped / d->pages_per_eblk); 1155 eb->active_count--; 1156 mtdswap_store_eb(d, eb); 1157 d->page_data[page] = BLOCK_UNDEF; 1158 d->revmap[mapped] = PAGE_UNDEF; 1159 d->discard_page_count++; 1160 } else if (mapped == BLOCK_ERROR) { 1161 d->page_data[page] = BLOCK_UNDEF; 1162 d->discard_page_count++; 1163 } 1164 } 1165 1166 return 0; 1167 } 1168 1169 static int mtdswap_show(struct seq_file *s, void *data) 1170 { 1171 struct mtdswap_dev *d = (struct mtdswap_dev *) s->private; 1172 unsigned long sum; 1173 unsigned int count[MTDSWAP_TREE_CNT]; 1174 unsigned int min[MTDSWAP_TREE_CNT]; 1175 unsigned int max[MTDSWAP_TREE_CNT]; 1176 unsigned int i, cw = 0, cwp = 0, cwecount = 0, bb_cnt, mapped, pages; 1177 uint64_t use_size; 1178 static const char * const name[] = { 1179 "clean", "used", "low", "high", "dirty", "bitflip", "failing" 1180 }; 1181 1182 mutex_lock(&d->mbd_dev->lock); 1183 1184 for (i = 0; i < MTDSWAP_TREE_CNT; i++) { 1185 struct rb_root *root = &d->trees[i].root; 1186 1187 if (root->rb_node) { 1188 count[i] = d->trees[i].count; 1189 min[i] = MTDSWAP_ECNT_MIN(root); 1190 max[i] = MTDSWAP_ECNT_MAX(root); 1191 } else 1192 count[i] = 0; 1193 } 1194 1195 if (d->curr_write) { 1196 cw = 1; 1197 cwp = d->curr_write_pos; 1198 cwecount = d->curr_write->erase_count; 1199 } 1200 1201 sum = 0; 1202 for (i = 0; i < d->eblks; i++) 1203 sum += d->eb_data[i].erase_count; 1204 1205 use_size = (uint64_t)d->eblks * d->mtd->erasesize; 1206 bb_cnt = mtdswap_badblocks(d->mtd, use_size); 1207 1208 mapped = 0; 1209 pages = d->mbd_dev->size; 1210 for (i = 0; i < pages; i++) 1211 if (d->page_data[i] != BLOCK_UNDEF) 1212 mapped++; 1213 1214 mutex_unlock(&d->mbd_dev->lock); 1215 1216 for (i = 0; i < MTDSWAP_TREE_CNT; i++) { 1217 if (!count[i]) 1218 continue; 1219 1220 if (min[i] != max[i]) 1221 seq_printf(s, "%s:\t%5d erase blocks, erased min %d, " 1222 "max %d times\n", 1223 name[i], count[i], min[i], max[i]); 1224 else 1225 seq_printf(s, "%s:\t%5d erase blocks, all erased %d " 1226 "times\n", name[i], count[i], min[i]); 1227 } 1228 1229 if (bb_cnt) 1230 seq_printf(s, "bad:\t%5u erase blocks\n", bb_cnt); 1231 1232 if (cw) 1233 seq_printf(s, "current erase block: %u pages used, %u free, " 1234 "erased %u times\n", 1235 cwp, d->pages_per_eblk - cwp, cwecount); 1236 1237 seq_printf(s, "total erasures: %lu\n", sum); 1238 1239 seq_puts(s, "\n"); 1240 1241 seq_printf(s, "mtdswap_readsect count: %llu\n", d->sect_read_count); 1242 seq_printf(s, "mtdswap_writesect count: %llu\n", d->sect_write_count); 1243 seq_printf(s, "mtdswap_discard count: %llu\n", d->discard_count); 1244 seq_printf(s, "mtd read count: %llu\n", d->mtd_read_count); 1245 seq_printf(s, "mtd write count: %llu\n", d->mtd_write_count); 1246 seq_printf(s, "discarded pages count: %llu\n", d->discard_page_count); 1247 1248 seq_puts(s, "\n"); 1249 seq_printf(s, "total pages: %u\n", pages); 1250 seq_printf(s, "pages mapped: %u\n", mapped); 1251 1252 return 0; 1253 } 1254 DEFINE_SHOW_ATTRIBUTE(mtdswap); 1255 1256 static int mtdswap_add_debugfs(struct mtdswap_dev *d) 1257 { 1258 struct dentry *root = d->mtd->dbg.dfs_dir; 1259 1260 if (!IS_ENABLED(CONFIG_DEBUG_FS)) 1261 return 0; 1262 1263 if (IS_ERR_OR_NULL(root)) 1264 return -1; 1265 1266 d->debugfs_stats = debugfs_create_file("mtdswap_stats", 0400, root, 1267 d, &mtdswap_fops); 1268 1269 return 0; 1270 } 1271 1272 static int mtdswap_init(struct mtdswap_dev *d, unsigned int eblocks, 1273 unsigned int spare_cnt) 1274 { 1275 struct mtd_info *mtd = d->mbd_dev->mtd; 1276 unsigned int i, eblk_bytes, pages, blocks; 1277 int ret = -ENOMEM; 1278 1279 d->mtd = mtd; 1280 d->eblks = eblocks; 1281 d->spare_eblks = spare_cnt; 1282 d->pages_per_eblk = mtd->erasesize >> PAGE_SHIFT; 1283 1284 pages = d->mbd_dev->size; 1285 blocks = eblocks * d->pages_per_eblk; 1286 1287 for (i = 0; i < MTDSWAP_TREE_CNT; i++) 1288 d->trees[i].root = RB_ROOT; 1289 1290 d->page_data = vmalloc_array(pages, sizeof(int)); 1291 if (!d->page_data) 1292 goto page_data_fail; 1293 1294 d->revmap = vmalloc_array(blocks, sizeof(int)); 1295 if (!d->revmap) 1296 goto revmap_fail; 1297 1298 eblk_bytes = sizeof(struct swap_eb)*d->eblks; 1299 d->eb_data = vzalloc(eblk_bytes); 1300 if (!d->eb_data) 1301 goto eb_data_fail; 1302 1303 for (i = 0; i < pages; i++) 1304 d->page_data[i] = BLOCK_UNDEF; 1305 1306 for (i = 0; i < blocks; i++) 1307 d->revmap[i] = PAGE_UNDEF; 1308 1309 d->page_buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 1310 if (!d->page_buf) 1311 goto page_buf_fail; 1312 1313 d->oob_buf = kmalloc_array(2, mtd->oobavail, GFP_KERNEL); 1314 if (!d->oob_buf) 1315 goto oob_buf_fail; 1316 1317 mtdswap_scan_eblks(d); 1318 1319 return 0; 1320 1321 oob_buf_fail: 1322 kfree(d->page_buf); 1323 page_buf_fail: 1324 vfree(d->eb_data); 1325 eb_data_fail: 1326 vfree(d->revmap); 1327 revmap_fail: 1328 vfree(d->page_data); 1329 page_data_fail: 1330 printk(KERN_ERR "%s: init failed (%d)\n", MTDSWAP_PREFIX, ret); 1331 return ret; 1332 } 1333 1334 static void mtdswap_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) 1335 { 1336 struct mtdswap_dev *d; 1337 struct mtd_blktrans_dev *mbd_dev; 1338 char *parts; 1339 char *this_opt; 1340 unsigned long part; 1341 unsigned int eblocks, eavailable, bad_blocks, spare_cnt; 1342 uint64_t swap_size, use_size, size_limit; 1343 int ret; 1344 1345 parts = &partitions[0]; 1346 if (!*parts) 1347 return; 1348 1349 while ((this_opt = strsep(&parts, ",")) != NULL) { 1350 if (kstrtoul(this_opt, 0, &part) < 0) 1351 return; 1352 1353 if (mtd->index == part) 1354 break; 1355 } 1356 1357 if (mtd->index != part) 1358 return; 1359 1360 if (mtd->erasesize < PAGE_SIZE || mtd->erasesize % PAGE_SIZE) { 1361 printk(KERN_ERR "%s: Erase size %u not multiple of PAGE_SIZE " 1362 "%lu\n", MTDSWAP_PREFIX, mtd->erasesize, PAGE_SIZE); 1363 return; 1364 } 1365 1366 if (PAGE_SIZE % mtd->writesize || mtd->writesize > PAGE_SIZE) { 1367 printk(KERN_ERR "%s: PAGE_SIZE %lu not multiple of write size" 1368 " %u\n", MTDSWAP_PREFIX, PAGE_SIZE, mtd->writesize); 1369 return; 1370 } 1371 1372 if (!mtd->oobsize || mtd->oobavail < MTDSWAP_OOBSIZE) { 1373 printk(KERN_ERR "%s: Not enough free bytes in OOB, " 1374 "%d available, %zu needed.\n", 1375 MTDSWAP_PREFIX, mtd->oobavail, MTDSWAP_OOBSIZE); 1376 return; 1377 } 1378 1379 if (spare_eblocks > 100) 1380 spare_eblocks = 100; 1381 1382 use_size = mtd->size; 1383 size_limit = (uint64_t) BLOCK_MAX * PAGE_SIZE; 1384 1385 if (mtd->size > size_limit) { 1386 printk(KERN_WARNING "%s: Device too large. Limiting size to " 1387 "%llu bytes\n", MTDSWAP_PREFIX, size_limit); 1388 use_size = size_limit; 1389 } 1390 1391 eblocks = mtd_div_by_eb(use_size, mtd); 1392 use_size = (uint64_t)eblocks * mtd->erasesize; 1393 bad_blocks = mtdswap_badblocks(mtd, use_size); 1394 eavailable = eblocks - bad_blocks; 1395 1396 if (eavailable < MIN_ERASE_BLOCKS) { 1397 printk(KERN_ERR "%s: Not enough erase blocks. %u available, " 1398 "%d needed\n", MTDSWAP_PREFIX, eavailable, 1399 MIN_ERASE_BLOCKS); 1400 return; 1401 } 1402 1403 spare_cnt = div_u64((uint64_t)eavailable * spare_eblocks, 100); 1404 1405 if (spare_cnt < MIN_SPARE_EBLOCKS) 1406 spare_cnt = MIN_SPARE_EBLOCKS; 1407 1408 if (spare_cnt > eavailable - 1) 1409 spare_cnt = eavailable - 1; 1410 1411 swap_size = (uint64_t)(eavailable - spare_cnt) * mtd->erasesize + 1412 (header ? PAGE_SIZE : 0); 1413 1414 printk(KERN_INFO "%s: Enabling MTD swap on device %lu, size %llu KB, " 1415 "%u spare, %u bad blocks\n", 1416 MTDSWAP_PREFIX, part, swap_size / 1024, spare_cnt, bad_blocks); 1417 1418 d = kzalloc_obj(struct mtdswap_dev); 1419 if (!d) 1420 return; 1421 1422 mbd_dev = kzalloc_obj(struct mtd_blktrans_dev); 1423 if (!mbd_dev) { 1424 kfree(d); 1425 return; 1426 } 1427 1428 d->mbd_dev = mbd_dev; 1429 mbd_dev->priv = d; 1430 1431 mbd_dev->mtd = mtd; 1432 mbd_dev->devnum = mtd->index; 1433 mbd_dev->size = swap_size >> PAGE_SHIFT; 1434 mbd_dev->tr = tr; 1435 1436 if (!(mtd->flags & MTD_WRITEABLE)) 1437 mbd_dev->readonly = 1; 1438 1439 if (mtdswap_init(d, eblocks, spare_cnt) < 0) 1440 goto init_failed; 1441 1442 if (add_mtd_blktrans_dev(mbd_dev) < 0) 1443 goto cleanup; 1444 1445 d->dev = disk_to_dev(mbd_dev->disk); 1446 1447 ret = mtdswap_add_debugfs(d); 1448 if (ret < 0) 1449 goto debugfs_failed; 1450 1451 return; 1452 1453 debugfs_failed: 1454 del_mtd_blktrans_dev(mbd_dev); 1455 1456 cleanup: 1457 mtdswap_cleanup(d); 1458 1459 init_failed: 1460 kfree(mbd_dev); 1461 kfree(d); 1462 } 1463 1464 static void mtdswap_remove_dev(struct mtd_blktrans_dev *dev) 1465 { 1466 struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev); 1467 1468 debugfs_remove(d->debugfs_stats); 1469 del_mtd_blktrans_dev(dev); 1470 mtdswap_cleanup(d); 1471 kfree(d); 1472 } 1473 1474 static struct mtd_blktrans_ops mtdswap_ops = { 1475 .name = "mtdswap", 1476 .major = 0, 1477 .part_bits = 0, 1478 .blksize = PAGE_SIZE, 1479 .flush = mtdswap_flush, 1480 .readsect = mtdswap_readsect, 1481 .writesect = mtdswap_writesect, 1482 .discard = mtdswap_discard, 1483 .background = mtdswap_background, 1484 .add_mtd = mtdswap_add_mtd, 1485 .remove_dev = mtdswap_remove_dev, 1486 .owner = THIS_MODULE, 1487 }; 1488 1489 module_mtd_blktrans(mtdswap_ops); 1490 1491 MODULE_LICENSE("GPL"); 1492 MODULE_AUTHOR("Jarkko Lavinen <jarkko.lavinen@nokia.com>"); 1493 MODULE_DESCRIPTION("Block device access to an MTD suitable for using as " 1494 "swap space"); 1495