Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Swap block device support for MTDs
0004  * Turns an MTD device into a swap device with block wear leveling
0005  *
0006  * Copyright © 2007,2011 Nokia Corporation. All rights reserved.
0007  *
0008  * Authors: Jarkko Lavinen <jarkko.lavinen@nokia.com>
0009  *
0010  * Based on Richard Purdie's earlier implementation in 2007. Background
0011  * support and lock-less operation written by Adrian Hunter.
0012  */
0013 
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/mtd/mtd.h>
0017 #include <linux/mtd/blktrans.h>
0018 #include <linux/rbtree.h>
0019 #include <linux/sched.h>
0020 #include <linux/slab.h>
0021 #include <linux/vmalloc.h>
0022 #include <linux/blkdev.h>
0023 #include <linux/swap.h>
0024 #include <linux/debugfs.h>
0025 #include <linux/seq_file.h>
0026 #include <linux/device.h>
0027 #include <linux/math64.h>
0028 
0029 #define MTDSWAP_PREFIX "mtdswap"
0030 
0031 /*
0032  * The number of free eraseblocks when GC should stop
0033  */
0034 #define CLEAN_BLOCK_THRESHOLD   20
0035 
0036 /*
0037  * Number of free eraseblocks below which GC can also collect low frag
0038  * blocks.
0039  */
0040 #define LOW_FRAG_GC_THRESHOLD   5
0041 
0042 /*
0043  * Wear level cost amortization. We want to do wear leveling on the background
0044  * without disturbing gc too much. This is made by defining max GC frequency.
0045  * Frequency value 6 means 1/6 of the GC passes will pick an erase block based
0046  * on the biggest wear difference rather than the biggest dirtiness.
0047  *
0048  * The lower freq2 should be chosen so that it makes sure the maximum erase
0049  * difference will decrease even if a malicious application is deliberately
0050  * trying to make erase differences large.
0051  */
0052 #define MAX_ERASE_DIFF      4000
0053 #define COLLECT_NONDIRTY_BASE   MAX_ERASE_DIFF
0054 #define COLLECT_NONDIRTY_FREQ1  6
0055 #define COLLECT_NONDIRTY_FREQ2  4
0056 
0057 #define PAGE_UNDEF      UINT_MAX
0058 #define BLOCK_UNDEF     UINT_MAX
0059 #define BLOCK_ERROR     (UINT_MAX - 1)
0060 #define BLOCK_MAX       (UINT_MAX - 2)
0061 
0062 #define EBLOCK_BAD      (1 << 0)
0063 #define EBLOCK_NOMAGIC      (1 << 1)
0064 #define EBLOCK_BITFLIP      (1 << 2)
0065 #define EBLOCK_FAILED       (1 << 3)
0066 #define EBLOCK_READERR      (1 << 4)
0067 #define EBLOCK_IDX_SHIFT    5
0068 
0069 struct swap_eb {
0070     struct rb_node rb;
0071     struct rb_root *root;
0072 
0073     unsigned int flags;
0074     unsigned int active_count;
0075     unsigned int erase_count;
0076     unsigned int pad;       /* speeds up pointer decrement */
0077 };
0078 
0079 #define MTDSWAP_ECNT_MIN(rbroot) (rb_entry(rb_first(rbroot), struct swap_eb, \
0080                 rb)->erase_count)
0081 #define MTDSWAP_ECNT_MAX(rbroot) (rb_entry(rb_last(rbroot), struct swap_eb, \
0082                 rb)->erase_count)
0083 
0084 struct mtdswap_tree {
0085     struct rb_root root;
0086     unsigned int count;
0087 };
0088 
0089 enum {
0090     MTDSWAP_CLEAN,
0091     MTDSWAP_USED,
0092     MTDSWAP_LOWFRAG,
0093     MTDSWAP_HIFRAG,
0094     MTDSWAP_DIRTY,
0095     MTDSWAP_BITFLIP,
0096     MTDSWAP_FAILING,
0097     MTDSWAP_TREE_CNT,
0098 };
0099 
0100 struct mtdswap_dev {
0101     struct mtd_blktrans_dev *mbd_dev;
0102     struct mtd_info *mtd;
0103     struct device *dev;
0104 
0105     unsigned int *page_data;
0106     unsigned int *revmap;
0107 
0108     unsigned int eblks;
0109     unsigned int spare_eblks;
0110     unsigned int pages_per_eblk;
0111     unsigned int max_erase_count;
0112     struct swap_eb *eb_data;
0113 
0114     struct mtdswap_tree trees[MTDSWAP_TREE_CNT];
0115 
0116     unsigned long long sect_read_count;
0117     unsigned long long sect_write_count;
0118     unsigned long long mtd_write_count;
0119     unsigned long long mtd_read_count;
0120     unsigned long long discard_count;
0121     unsigned long long discard_page_count;
0122 
0123     unsigned int curr_write_pos;
0124     struct swap_eb *curr_write;
0125 
0126     char *page_buf;
0127     char *oob_buf;
0128 };
0129 
0130 struct mtdswap_oobdata {
0131     __le16 magic;
0132     __le32 count;
0133 } __packed;
0134 
0135 #define MTDSWAP_MAGIC_CLEAN 0x2095
0136 #define MTDSWAP_MAGIC_DIRTY (MTDSWAP_MAGIC_CLEAN + 1)
0137 #define MTDSWAP_TYPE_CLEAN  0
0138 #define MTDSWAP_TYPE_DIRTY  1
0139 #define MTDSWAP_OOBSIZE     sizeof(struct mtdswap_oobdata)
0140 
0141 #define MTDSWAP_ERASE_RETRIES   3 /* Before marking erase block bad */
0142 #define MTDSWAP_IO_RETRIES  3
0143 
0144 enum {
0145     MTDSWAP_SCANNED_CLEAN,
0146     MTDSWAP_SCANNED_DIRTY,
0147     MTDSWAP_SCANNED_BITFLIP,
0148     MTDSWAP_SCANNED_BAD,
0149 };
0150 
0151 /*
0152  * In the worst case mtdswap_writesect() has allocated the last clean
0153  * page from the current block and is then pre-empted by the GC
0154  * thread. The thread can consume a full erase block when moving a
0155  * block.
0156  */
0157 #define MIN_SPARE_EBLOCKS   2
0158 #define MIN_ERASE_BLOCKS    (MIN_SPARE_EBLOCKS + 1)
0159 
0160 #define TREE_ROOT(d, name) (&d->trees[MTDSWAP_ ## name].root)
0161 #define TREE_EMPTY(d, name) (TREE_ROOT(d, name)->rb_node == NULL)
0162 #define TREE_NONEMPTY(d, name) (!TREE_EMPTY(d, name))
0163 #define TREE_COUNT(d, name) (d->trees[MTDSWAP_ ## name].count)
0164 
0165 #define MTDSWAP_MBD_TO_MTDSWAP(dev) ((struct mtdswap_dev *)dev->priv)
0166 
0167 static char partitions[128] = "";
0168 module_param_string(partitions, partitions, sizeof(partitions), 0444);
0169 MODULE_PARM_DESC(partitions, "MTD partition numbers to use as swap "
0170         "partitions=\"1,3,5\"");
0171 
0172 static unsigned int spare_eblocks = 10;
0173 module_param(spare_eblocks, uint, 0444);
0174 MODULE_PARM_DESC(spare_eblocks, "Percentage of spare erase blocks for "
0175         "garbage collection (default 10%)");
0176 
0177 static bool header; /* false */
0178 module_param(header, bool, 0444);
0179 MODULE_PARM_DESC(header,
0180         "Include builtin swap header (default 0, without header)");
0181 
0182 static int mtdswap_gc(struct mtdswap_dev *d, unsigned int background);
0183 
0184 static loff_t mtdswap_eb_offset(struct mtdswap_dev *d, struct swap_eb *eb)
0185 {
0186     return (loff_t)(eb - d->eb_data) * d->mtd->erasesize;
0187 }
0188 
0189 static void mtdswap_eb_detach(struct mtdswap_dev *d, struct swap_eb *eb)
0190 {
0191     unsigned int oldidx;
0192     struct mtdswap_tree *tp;
0193 
0194     if (eb->root) {
0195         tp = container_of(eb->root, struct mtdswap_tree, root);
0196         oldidx = tp - &d->trees[0];
0197 
0198         d->trees[oldidx].count--;
0199         rb_erase(&eb->rb, eb->root);
0200     }
0201 }
0202 
0203 static void __mtdswap_rb_add(struct rb_root *root, struct swap_eb *eb)
0204 {
0205     struct rb_node **p, *parent = NULL;
0206     struct swap_eb *cur;
0207 
0208     p = &root->rb_node;
0209     while (*p) {
0210         parent = *p;
0211         cur = rb_entry(parent, struct swap_eb, rb);
0212         if (eb->erase_count > cur->erase_count)
0213             p = &(*p)->rb_right;
0214         else
0215             p = &(*p)->rb_left;
0216     }
0217 
0218     rb_link_node(&eb->rb, parent, p);
0219     rb_insert_color(&eb->rb, root);
0220 }
0221 
0222 static void mtdswap_rb_add(struct mtdswap_dev *d, struct swap_eb *eb, int idx)
0223 {
0224     struct rb_root *root;
0225 
0226     if (eb->root == &d->trees[idx].root)
0227         return;
0228 
0229     mtdswap_eb_detach(d, eb);
0230     root = &d->trees[idx].root;
0231     __mtdswap_rb_add(root, eb);
0232     eb->root = root;
0233     d->trees[idx].count++;
0234 }
0235 
0236 static struct rb_node *mtdswap_rb_index(struct rb_root *root, unsigned int idx)
0237 {
0238     struct rb_node *p;
0239     unsigned int i;
0240 
0241     p = rb_first(root);
0242     i = 0;
0243     while (i < idx && p) {
0244         p = rb_next(p);
0245         i++;
0246     }
0247 
0248     return p;
0249 }
0250 
0251 static int mtdswap_handle_badblock(struct mtdswap_dev *d, struct swap_eb *eb)
0252 {
0253     int ret;
0254     loff_t offset;
0255 
0256     d->spare_eblks--;
0257     eb->flags |= EBLOCK_BAD;
0258     mtdswap_eb_detach(d, eb);
0259     eb->root = NULL;
0260 
0261     /* badblocks not supported */
0262     if (!mtd_can_have_bb(d->mtd))
0263         return 1;
0264 
0265     offset = mtdswap_eb_offset(d, eb);
0266     dev_warn(d->dev, "Marking bad block at %08llx\n", offset);
0267     ret = mtd_block_markbad(d->mtd, offset);
0268 
0269     if (ret) {
0270         dev_warn(d->dev, "Mark block bad failed for block at %08llx "
0271             "error %d\n", offset, ret);
0272         return ret;
0273     }
0274 
0275     return 1;
0276 
0277 }
0278 
0279 static int mtdswap_handle_write_error(struct mtdswap_dev *d, struct swap_eb *eb)
0280 {
0281     unsigned int marked = eb->flags & EBLOCK_FAILED;
0282     struct swap_eb *curr_write = d->curr_write;
0283 
0284     eb->flags |= EBLOCK_FAILED;
0285     if (curr_write == eb) {
0286         d->curr_write = NULL;
0287 
0288         if (!marked && d->curr_write_pos != 0) {
0289             mtdswap_rb_add(d, eb, MTDSWAP_FAILING);
0290             return 0;
0291         }
0292     }
0293 
0294     return mtdswap_handle_badblock(d, eb);
0295 }
0296 
0297 static int mtdswap_read_oob(struct mtdswap_dev *d, loff_t from,
0298             struct mtd_oob_ops *ops)
0299 {
0300     int ret = mtd_read_oob(d->mtd, from, ops);
0301 
0302     if (mtd_is_bitflip(ret))
0303         return ret;
0304 
0305     if (ret) {
0306         dev_warn(d->dev, "Read OOB failed %d for block at %08llx\n",
0307             ret, from);
0308         return ret;
0309     }
0310 
0311     if (ops->oobretlen < ops->ooblen) {
0312         dev_warn(d->dev, "Read OOB return short read (%zd bytes not "
0313             "%zd) for block at %08llx\n",
0314             ops->oobretlen, ops->ooblen, from);
0315         return -EIO;
0316     }
0317 
0318     return 0;
0319 }
0320 
0321 static int mtdswap_read_markers(struct mtdswap_dev *d, struct swap_eb *eb)
0322 {
0323     struct mtdswap_oobdata *data, *data2;
0324     int ret;
0325     loff_t offset;
0326     struct mtd_oob_ops ops;
0327 
0328     offset = mtdswap_eb_offset(d, eb);
0329 
0330     /* Check first if the block is bad. */
0331     if (mtd_can_have_bb(d->mtd) && mtd_block_isbad(d->mtd, offset))
0332         return MTDSWAP_SCANNED_BAD;
0333 
0334     ops.ooblen = 2 * d->mtd->oobavail;
0335     ops.oobbuf = d->oob_buf;
0336     ops.ooboffs = 0;
0337     ops.datbuf = NULL;
0338     ops.mode = MTD_OPS_AUTO_OOB;
0339 
0340     ret = mtdswap_read_oob(d, offset, &ops);
0341 
0342     if (ret && !mtd_is_bitflip(ret))
0343         return ret;
0344 
0345     data = (struct mtdswap_oobdata *)d->oob_buf;
0346     data2 = (struct mtdswap_oobdata *)
0347         (d->oob_buf + d->mtd->oobavail);
0348 
0349     if (le16_to_cpu(data->magic) == MTDSWAP_MAGIC_CLEAN) {
0350         eb->erase_count = le32_to_cpu(data->count);
0351         if (mtd_is_bitflip(ret))
0352             ret = MTDSWAP_SCANNED_BITFLIP;
0353         else {
0354             if (le16_to_cpu(data2->magic) == MTDSWAP_MAGIC_DIRTY)
0355                 ret = MTDSWAP_SCANNED_DIRTY;
0356             else
0357                 ret = MTDSWAP_SCANNED_CLEAN;
0358         }
0359     } else {
0360         eb->flags |= EBLOCK_NOMAGIC;
0361         ret = MTDSWAP_SCANNED_DIRTY;
0362     }
0363 
0364     return ret;
0365 }
0366 
0367 static int mtdswap_write_marker(struct mtdswap_dev *d, struct swap_eb *eb,
0368                 u16 marker)
0369 {
0370     struct mtdswap_oobdata n;
0371     int ret;
0372     loff_t offset;
0373     struct mtd_oob_ops ops;
0374 
0375     ops.ooboffs = 0;
0376     ops.oobbuf = (uint8_t *)&n;
0377     ops.mode = MTD_OPS_AUTO_OOB;
0378     ops.datbuf = NULL;
0379 
0380     if (marker == MTDSWAP_TYPE_CLEAN) {
0381         n.magic = cpu_to_le16(MTDSWAP_MAGIC_CLEAN);
0382         n.count = cpu_to_le32(eb->erase_count);
0383         ops.ooblen = MTDSWAP_OOBSIZE;
0384         offset = mtdswap_eb_offset(d, eb);
0385     } else {
0386         n.magic = cpu_to_le16(MTDSWAP_MAGIC_DIRTY);
0387         ops.ooblen = sizeof(n.magic);
0388         offset = mtdswap_eb_offset(d, eb) + d->mtd->writesize;
0389     }
0390 
0391     ret = mtd_write_oob(d->mtd, offset, &ops);
0392 
0393     if (ret) {
0394         dev_warn(d->dev, "Write OOB failed for block at %08llx "
0395             "error %d\n", offset, ret);
0396         if (ret == -EIO || mtd_is_eccerr(ret))
0397             mtdswap_handle_write_error(d, eb);
0398         return ret;
0399     }
0400 
0401     if (ops.oobretlen != ops.ooblen) {
0402         dev_warn(d->dev, "Short OOB write for block at %08llx: "
0403             "%zd not %zd\n",
0404             offset, ops.oobretlen, ops.ooblen);
0405         return ret;
0406     }
0407 
0408     return 0;
0409 }
0410 
0411 /*
0412  * Are there any erase blocks without MAGIC_CLEAN header, presumably
0413  * because power was cut off after erase but before header write? We
0414  * need to guestimate the erase count.
0415  */
0416 static void mtdswap_check_counts(struct mtdswap_dev *d)
0417 {
0418     struct rb_root hist_root = RB_ROOT;
0419     struct rb_node *medrb;
0420     struct swap_eb *eb;
0421     unsigned int i, cnt, median;
0422 
0423     cnt = 0;
0424     for (i = 0; i < d->eblks; i++) {
0425         eb = d->eb_data + i;
0426 
0427         if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_BAD | EBLOCK_READERR))
0428             continue;
0429 
0430         __mtdswap_rb_add(&hist_root, eb);
0431         cnt++;
0432     }
0433 
0434     if (cnt == 0)
0435         return;
0436 
0437     medrb = mtdswap_rb_index(&hist_root, cnt / 2);
0438     median = rb_entry(medrb, struct swap_eb, rb)->erase_count;
0439 
0440     d->max_erase_count = MTDSWAP_ECNT_MAX(&hist_root);
0441 
0442     for (i = 0; i < d->eblks; i++) {
0443         eb = d->eb_data + i;
0444 
0445         if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_READERR))
0446             eb->erase_count = median;
0447 
0448         if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_BAD | EBLOCK_READERR))
0449             continue;
0450 
0451         rb_erase(&eb->rb, &hist_root);
0452     }
0453 }
0454 
0455 static void mtdswap_scan_eblks(struct mtdswap_dev *d)
0456 {
0457     int status;
0458     unsigned int i, idx;
0459     struct swap_eb *eb;
0460 
0461     for (i = 0; i < d->eblks; i++) {
0462         eb = d->eb_data + i;
0463 
0464         status = mtdswap_read_markers(d, eb);
0465         if (status < 0)
0466             eb->flags |= EBLOCK_READERR;
0467         else if (status == MTDSWAP_SCANNED_BAD) {
0468             eb->flags |= EBLOCK_BAD;
0469             continue;
0470         }
0471 
0472         switch (status) {
0473         case MTDSWAP_SCANNED_CLEAN:
0474             idx = MTDSWAP_CLEAN;
0475             break;
0476         case MTDSWAP_SCANNED_DIRTY:
0477         case MTDSWAP_SCANNED_BITFLIP:
0478             idx = MTDSWAP_DIRTY;
0479             break;
0480         default:
0481             idx = MTDSWAP_FAILING;
0482         }
0483 
0484         eb->flags |= (idx << EBLOCK_IDX_SHIFT);
0485     }
0486 
0487     mtdswap_check_counts(d);
0488 
0489     for (i = 0; i < d->eblks; i++) {
0490         eb = d->eb_data + i;
0491 
0492         if (eb->flags & EBLOCK_BAD)
0493             continue;
0494 
0495         idx = eb->flags >> EBLOCK_IDX_SHIFT;
0496         mtdswap_rb_add(d, eb, idx);
0497     }
0498 }
0499 
0500 /*
0501  * Place eblk into a tree corresponding to its number of active blocks
0502  * it contains.
0503  */
0504 static void mtdswap_store_eb(struct mtdswap_dev *d, struct swap_eb *eb)
0505 {
0506     unsigned int weight = eb->active_count;
0507     unsigned int maxweight = d->pages_per_eblk;
0508 
0509     if (eb == d->curr_write)
0510         return;
0511 
0512     if (eb->flags & EBLOCK_BITFLIP)
0513         mtdswap_rb_add(d, eb, MTDSWAP_BITFLIP);
0514     else if (eb->flags & (EBLOCK_READERR | EBLOCK_FAILED))
0515         mtdswap_rb_add(d, eb, MTDSWAP_FAILING);
0516     if (weight == maxweight)
0517         mtdswap_rb_add(d, eb, MTDSWAP_USED);
0518     else if (weight == 0)
0519         mtdswap_rb_add(d, eb, MTDSWAP_DIRTY);
0520     else if (weight > (maxweight/2))
0521         mtdswap_rb_add(d, eb, MTDSWAP_LOWFRAG);
0522     else
0523         mtdswap_rb_add(d, eb, MTDSWAP_HIFRAG);
0524 }
0525 
0526 static int mtdswap_erase_block(struct mtdswap_dev *d, struct swap_eb *eb)
0527 {
0528     struct mtd_info *mtd = d->mtd;
0529     struct erase_info erase;
0530     unsigned int retries = 0;
0531     int ret;
0532 
0533     eb->erase_count++;
0534     if (eb->erase_count > d->max_erase_count)
0535         d->max_erase_count = eb->erase_count;
0536 
0537 retry:
0538     memset(&erase, 0, sizeof(struct erase_info));
0539     erase.addr  = mtdswap_eb_offset(d, eb);
0540     erase.len   = mtd->erasesize;
0541 
0542     ret = mtd_erase(mtd, &erase);
0543     if (ret) {
0544         if (retries++ < MTDSWAP_ERASE_RETRIES) {
0545             dev_warn(d->dev,
0546                 "erase of erase block %#llx on %s failed",
0547                 erase.addr, mtd->name);
0548             yield();
0549             goto retry;
0550         }
0551 
0552         dev_err(d->dev, "Cannot erase erase block %#llx on %s\n",
0553             erase.addr, mtd->name);
0554 
0555         mtdswap_handle_badblock(d, eb);
0556         return -EIO;
0557     }
0558 
0559     return 0;
0560 }
0561 
0562 static int mtdswap_map_free_block(struct mtdswap_dev *d, unsigned int page,
0563                 unsigned int *block)
0564 {
0565     int ret;
0566     struct swap_eb *old_eb = d->curr_write;
0567     struct rb_root *clean_root;
0568     struct swap_eb *eb;
0569 
0570     if (old_eb == NULL || d->curr_write_pos >= d->pages_per_eblk) {
0571         do {
0572             if (TREE_EMPTY(d, CLEAN))
0573                 return -ENOSPC;
0574 
0575             clean_root = TREE_ROOT(d, CLEAN);
0576             eb = rb_entry(rb_first(clean_root), struct swap_eb, rb);
0577             rb_erase(&eb->rb, clean_root);
0578             eb->root = NULL;
0579             TREE_COUNT(d, CLEAN)--;
0580 
0581             ret = mtdswap_write_marker(d, eb, MTDSWAP_TYPE_DIRTY);
0582         } while (ret == -EIO || mtd_is_eccerr(ret));
0583 
0584         if (ret)
0585             return ret;
0586 
0587         d->curr_write_pos = 0;
0588         d->curr_write = eb;
0589         if (old_eb)
0590             mtdswap_store_eb(d, old_eb);
0591     }
0592 
0593     *block = (d->curr_write - d->eb_data) * d->pages_per_eblk +
0594         d->curr_write_pos;
0595 
0596     d->curr_write->active_count++;
0597     d->revmap[*block] = page;
0598     d->curr_write_pos++;
0599 
0600     return 0;
0601 }
0602 
0603 static unsigned int mtdswap_free_page_cnt(struct mtdswap_dev *d)
0604 {
0605     return TREE_COUNT(d, CLEAN) * d->pages_per_eblk +
0606         d->pages_per_eblk - d->curr_write_pos;
0607 }
0608 
0609 static unsigned int mtdswap_enough_free_pages(struct mtdswap_dev *d)
0610 {
0611     return mtdswap_free_page_cnt(d) > d->pages_per_eblk;
0612 }
0613 
0614 static int mtdswap_write_block(struct mtdswap_dev *d, char *buf,
0615             unsigned int page, unsigned int *bp, int gc_context)
0616 {
0617     struct mtd_info *mtd = d->mtd;
0618     struct swap_eb *eb;
0619     size_t retlen;
0620     loff_t writepos;
0621     int ret;
0622 
0623 retry:
0624     if (!gc_context)
0625         while (!mtdswap_enough_free_pages(d))
0626             if (mtdswap_gc(d, 0) > 0)
0627                 return -ENOSPC;
0628 
0629     ret = mtdswap_map_free_block(d, page, bp);
0630     eb = d->eb_data + (*bp / d->pages_per_eblk);
0631 
0632     if (ret == -EIO || mtd_is_eccerr(ret)) {
0633         d->curr_write = NULL;
0634         eb->active_count--;
0635         d->revmap[*bp] = PAGE_UNDEF;
0636         goto retry;
0637     }
0638 
0639     if (ret < 0)
0640         return ret;
0641 
0642     writepos = (loff_t)*bp << PAGE_SHIFT;
0643     ret =  mtd_write(mtd, writepos, PAGE_SIZE, &retlen, buf);
0644     if (ret == -EIO || mtd_is_eccerr(ret)) {
0645         d->curr_write_pos--;
0646         eb->active_count--;
0647         d->revmap[*bp] = PAGE_UNDEF;
0648         mtdswap_handle_write_error(d, eb);
0649         goto retry;
0650     }
0651 
0652     if (ret < 0) {
0653         dev_err(d->dev, "Write to MTD device failed: %d (%zd written)",
0654             ret, retlen);
0655         goto err;
0656     }
0657 
0658     if (retlen != PAGE_SIZE) {
0659         dev_err(d->dev, "Short write to MTD device: %zd written",
0660             retlen);
0661         ret = -EIO;
0662         goto err;
0663     }
0664 
0665     return ret;
0666 
0667 err:
0668     d->curr_write_pos--;
0669     eb->active_count--;
0670     d->revmap[*bp] = PAGE_UNDEF;
0671 
0672     return ret;
0673 }
0674 
0675 static int mtdswap_move_block(struct mtdswap_dev *d, unsigned int oldblock,
0676         unsigned int *newblock)
0677 {
0678     struct mtd_info *mtd = d->mtd;
0679     struct swap_eb *eb, *oldeb;
0680     int ret;
0681     size_t retlen;
0682     unsigned int page, retries;
0683     loff_t readpos;
0684 
0685     page = d->revmap[oldblock];
0686     readpos = (loff_t) oldblock << PAGE_SHIFT;
0687     retries = 0;
0688 
0689 retry:
0690     ret = mtd_read(mtd, readpos, PAGE_SIZE, &retlen, d->page_buf);
0691 
0692     if (ret < 0 && !mtd_is_bitflip(ret)) {
0693         oldeb = d->eb_data + oldblock / d->pages_per_eblk;
0694         oldeb->flags |= EBLOCK_READERR;
0695 
0696         dev_err(d->dev, "Read Error: %d (block %u)\n", ret,
0697             oldblock);
0698         retries++;
0699         if (retries < MTDSWAP_IO_RETRIES)
0700             goto retry;
0701 
0702         goto read_error;
0703     }
0704 
0705     if (retlen != PAGE_SIZE) {
0706         dev_err(d->dev, "Short read: %zd (block %u)\n", retlen,
0707                oldblock);
0708         ret = -EIO;
0709         goto read_error;
0710     }
0711 
0712     ret = mtdswap_write_block(d, d->page_buf, page, newblock, 1);
0713     if (ret < 0) {
0714         d->page_data[page] = BLOCK_ERROR;
0715         dev_err(d->dev, "Write error: %d\n", ret);
0716         return ret;
0717     }
0718 
0719     d->page_data[page] = *newblock;
0720     d->revmap[oldblock] = PAGE_UNDEF;
0721     eb = d->eb_data + oldblock / d->pages_per_eblk;
0722     eb->active_count--;
0723 
0724     return 0;
0725 
0726 read_error:
0727     d->page_data[page] = BLOCK_ERROR;
0728     d->revmap[oldblock] = PAGE_UNDEF;
0729     return ret;
0730 }
0731 
0732 static int mtdswap_gc_eblock(struct mtdswap_dev *d, struct swap_eb *eb)
0733 {
0734     unsigned int i, block, eblk_base, newblock;
0735     int ret, errcode;
0736 
0737     errcode = 0;
0738     eblk_base = (eb - d->eb_data) * d->pages_per_eblk;
0739 
0740     for (i = 0; i < d->pages_per_eblk; i++) {
0741         if (d->spare_eblks < MIN_SPARE_EBLOCKS)
0742             return -ENOSPC;
0743 
0744         block = eblk_base + i;
0745         if (d->revmap[block] == PAGE_UNDEF)
0746             continue;
0747 
0748         ret = mtdswap_move_block(d, block, &newblock);
0749         if (ret < 0 && !errcode)
0750             errcode = ret;
0751     }
0752 
0753     return errcode;
0754 }
0755 
0756 static int __mtdswap_choose_gc_tree(struct mtdswap_dev *d)
0757 {
0758     int idx, stopat;
0759 
0760     if (TREE_COUNT(d, CLEAN) < LOW_FRAG_GC_THRESHOLD)
0761         stopat = MTDSWAP_LOWFRAG;
0762     else
0763         stopat = MTDSWAP_HIFRAG;
0764 
0765     for (idx = MTDSWAP_BITFLIP; idx >= stopat; idx--)
0766         if (d->trees[idx].root.rb_node != NULL)
0767             return idx;
0768 
0769     return -1;
0770 }
0771 
0772 static int mtdswap_wlfreq(unsigned int maxdiff)
0773 {
0774     unsigned int h, x, y, dist, base;
0775 
0776     /*
0777      * Calculate linear ramp down from f1 to f2 when maxdiff goes from
0778      * MAX_ERASE_DIFF to MAX_ERASE_DIFF + COLLECT_NONDIRTY_BASE.  Similar
0779      * to triangle with height f1 - f1 and width COLLECT_NONDIRTY_BASE.
0780      */
0781 
0782     dist = maxdiff - MAX_ERASE_DIFF;
0783     if (dist > COLLECT_NONDIRTY_BASE)
0784         dist = COLLECT_NONDIRTY_BASE;
0785 
0786     /*
0787      * Modelling the slop as right angular triangle with base
0788      * COLLECT_NONDIRTY_BASE and height freq1 - freq2. The ratio y/x is
0789      * equal to the ratio h/base.
0790      */
0791     h = COLLECT_NONDIRTY_FREQ1 - COLLECT_NONDIRTY_FREQ2;
0792     base = COLLECT_NONDIRTY_BASE;
0793 
0794     x = dist - base;
0795     y = (x * h + base / 2) / base;
0796 
0797     return COLLECT_NONDIRTY_FREQ2 + y;
0798 }
0799 
0800 static int mtdswap_choose_wl_tree(struct mtdswap_dev *d)
0801 {
0802     static unsigned int pick_cnt;
0803     unsigned int i, idx = -1, wear, max;
0804     struct rb_root *root;
0805 
0806     max = 0;
0807     for (i = 0; i <= MTDSWAP_DIRTY; i++) {
0808         root = &d->trees[i].root;
0809         if (root->rb_node == NULL)
0810             continue;
0811 
0812         wear = d->max_erase_count - MTDSWAP_ECNT_MIN(root);
0813         if (wear > max) {
0814             max = wear;
0815             idx = i;
0816         }
0817     }
0818 
0819     if (max > MAX_ERASE_DIFF && pick_cnt >= mtdswap_wlfreq(max) - 1) {
0820         pick_cnt = 0;
0821         return idx;
0822     }
0823 
0824     pick_cnt++;
0825     return -1;
0826 }
0827 
0828 static int mtdswap_choose_gc_tree(struct mtdswap_dev *d,
0829                 unsigned int background)
0830 {
0831     int idx;
0832 
0833     if (TREE_NONEMPTY(d, FAILING) &&
0834         (background || (TREE_EMPTY(d, CLEAN) && TREE_EMPTY(d, DIRTY))))
0835         return MTDSWAP_FAILING;
0836 
0837     idx = mtdswap_choose_wl_tree(d);
0838     if (idx >= MTDSWAP_CLEAN)
0839         return idx;
0840 
0841     return __mtdswap_choose_gc_tree(d);
0842 }
0843 
0844 static struct swap_eb *mtdswap_pick_gc_eblk(struct mtdswap_dev *d,
0845                     unsigned int background)
0846 {
0847     struct rb_root *rp = NULL;
0848     struct swap_eb *eb = NULL;
0849     int idx;
0850 
0851     if (background && TREE_COUNT(d, CLEAN) > CLEAN_BLOCK_THRESHOLD &&
0852         TREE_EMPTY(d, DIRTY) && TREE_EMPTY(d, FAILING))
0853         return NULL;
0854 
0855     idx = mtdswap_choose_gc_tree(d, background);
0856     if (idx < 0)
0857         return NULL;
0858 
0859     rp = &d->trees[idx].root;
0860     eb = rb_entry(rb_first(rp), struct swap_eb, rb);
0861 
0862     rb_erase(&eb->rb, rp);
0863     eb->root = NULL;
0864     d->trees[idx].count--;
0865     return eb;
0866 }
0867 
0868 static unsigned int mtdswap_test_patt(unsigned int i)
0869 {
0870     return i % 2 ? 0x55555555 : 0xAAAAAAAA;
0871 }
0872 
0873 static unsigned int mtdswap_eblk_passes(struct mtdswap_dev *d,
0874                     struct swap_eb *eb)
0875 {
0876     struct mtd_info *mtd = d->mtd;
0877     unsigned int test, i, j, patt, mtd_pages;
0878     loff_t base, pos;
0879     unsigned int *p1 = (unsigned int *)d->page_buf;
0880     unsigned char *p2 = (unsigned char *)d->oob_buf;
0881     struct mtd_oob_ops ops;
0882     int ret;
0883 
0884     ops.mode = MTD_OPS_AUTO_OOB;
0885     ops.len = mtd->writesize;
0886     ops.ooblen = mtd->oobavail;
0887     ops.ooboffs = 0;
0888     ops.datbuf = d->page_buf;
0889     ops.oobbuf = d->oob_buf;
0890     base = mtdswap_eb_offset(d, eb);
0891     mtd_pages = d->pages_per_eblk * PAGE_SIZE / mtd->writesize;
0892 
0893     for (test = 0; test < 2; test++) {
0894         pos = base;
0895         for (i = 0; i < mtd_pages; i++) {
0896             patt = mtdswap_test_patt(test + i);
0897             memset(d->page_buf, patt, mtd->writesize);
0898             memset(d->oob_buf, patt, mtd->oobavail);
0899             ret = mtd_write_oob(mtd, pos, &ops);
0900             if (ret)
0901                 goto error;
0902 
0903             pos += mtd->writesize;
0904         }
0905 
0906         pos = base;
0907         for (i = 0; i < mtd_pages; i++) {
0908             ret = mtd_read_oob(mtd, pos, &ops);
0909             if (ret)
0910                 goto error;
0911 
0912             patt = mtdswap_test_patt(test + i);
0913             for (j = 0; j < mtd->writesize/sizeof(int); j++)
0914                 if (p1[j] != patt)
0915                     goto error;
0916 
0917             for (j = 0; j < mtd->oobavail; j++)
0918                 if (p2[j] != (unsigned char)patt)
0919                     goto error;
0920 
0921             pos += mtd->writesize;
0922         }
0923 
0924         ret = mtdswap_erase_block(d, eb);
0925         if (ret)
0926             goto error;
0927     }
0928 
0929     eb->flags &= ~EBLOCK_READERR;
0930     return 1;
0931 
0932 error:
0933     mtdswap_handle_badblock(d, eb);
0934     return 0;
0935 }
0936 
0937 static int mtdswap_gc(struct mtdswap_dev *d, unsigned int background)
0938 {
0939     struct swap_eb *eb;
0940     int ret;
0941 
0942     if (d->spare_eblks < MIN_SPARE_EBLOCKS)
0943         return 1;
0944 
0945     eb = mtdswap_pick_gc_eblk(d, background);
0946     if (!eb)
0947         return 1;
0948 
0949     ret = mtdswap_gc_eblock(d, eb);
0950     if (ret == -ENOSPC)
0951         return 1;
0952 
0953     if (eb->flags & EBLOCK_FAILED) {
0954         mtdswap_handle_badblock(d, eb);
0955         return 0;
0956     }
0957 
0958     eb->flags &= ~EBLOCK_BITFLIP;
0959     ret = mtdswap_erase_block(d, eb);
0960     if ((eb->flags & EBLOCK_READERR) &&
0961         (ret || !mtdswap_eblk_passes(d, eb)))
0962         return 0;
0963 
0964     if (ret == 0)
0965         ret = mtdswap_write_marker(d, eb, MTDSWAP_TYPE_CLEAN);
0966 
0967     if (ret == 0)
0968         mtdswap_rb_add(d, eb, MTDSWAP_CLEAN);
0969     else if (ret != -EIO && !mtd_is_eccerr(ret))
0970         mtdswap_rb_add(d, eb, MTDSWAP_DIRTY);
0971 
0972     return 0;
0973 }
0974 
0975 static void mtdswap_background(struct mtd_blktrans_dev *dev)
0976 {
0977     struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
0978     int ret;
0979 
0980     while (1) {
0981         ret = mtdswap_gc(d, 1);
0982         if (ret || mtd_blktrans_cease_background(dev))
0983             return;
0984     }
0985 }
0986 
0987 static void mtdswap_cleanup(struct mtdswap_dev *d)
0988 {
0989     vfree(d->eb_data);
0990     vfree(d->revmap);
0991     vfree(d->page_data);
0992     kfree(d->oob_buf);
0993     kfree(d->page_buf);
0994 }
0995 
0996 static int mtdswap_flush(struct mtd_blktrans_dev *dev)
0997 {
0998     struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
0999 
1000     mtd_sync(d->mtd);
1001     return 0;
1002 }
1003 
1004 static unsigned int mtdswap_badblocks(struct mtd_info *mtd, uint64_t size)
1005 {
1006     loff_t offset;
1007     unsigned int badcnt;
1008 
1009     badcnt = 0;
1010 
1011     if (mtd_can_have_bb(mtd))
1012         for (offset = 0; offset < size; offset += mtd->erasesize)
1013             if (mtd_block_isbad(mtd, offset))
1014                 badcnt++;
1015 
1016     return badcnt;
1017 }
1018 
1019 static int mtdswap_writesect(struct mtd_blktrans_dev *dev,
1020             unsigned long page, char *buf)
1021 {
1022     struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1023     unsigned int newblock, mapped;
1024     struct swap_eb *eb;
1025     int ret;
1026 
1027     d->sect_write_count++;
1028 
1029     if (d->spare_eblks < MIN_SPARE_EBLOCKS)
1030         return -ENOSPC;
1031 
1032     if (header) {
1033         /* Ignore writes to the header page */
1034         if (unlikely(page == 0))
1035             return 0;
1036 
1037         page--;
1038     }
1039 
1040     mapped = d->page_data[page];
1041     if (mapped <= BLOCK_MAX) {
1042         eb = d->eb_data + (mapped / d->pages_per_eblk);
1043         eb->active_count--;
1044         mtdswap_store_eb(d, eb);
1045         d->page_data[page] = BLOCK_UNDEF;
1046         d->revmap[mapped] = PAGE_UNDEF;
1047     }
1048 
1049     ret = mtdswap_write_block(d, buf, page, &newblock, 0);
1050     d->mtd_write_count++;
1051 
1052     if (ret < 0)
1053         return ret;
1054 
1055     d->page_data[page] = newblock;
1056 
1057     return 0;
1058 }
1059 
1060 /* Provide a dummy swap header for the kernel */
1061 static int mtdswap_auto_header(struct mtdswap_dev *d, char *buf)
1062 {
1063     union swap_header *hd = (union swap_header *)(buf);
1064 
1065     memset(buf, 0, PAGE_SIZE - 10);
1066 
1067     hd->info.version = 1;
1068     hd->info.last_page = d->mbd_dev->size - 1;
1069     hd->info.nr_badpages = 0;
1070 
1071     memcpy(buf + PAGE_SIZE - 10, "SWAPSPACE2", 10);
1072 
1073     return 0;
1074 }
1075 
1076 static int mtdswap_readsect(struct mtd_blktrans_dev *dev,
1077             unsigned long page, char *buf)
1078 {
1079     struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1080     struct mtd_info *mtd = d->mtd;
1081     unsigned int realblock, retries;
1082     loff_t readpos;
1083     struct swap_eb *eb;
1084     size_t retlen;
1085     int ret;
1086 
1087     d->sect_read_count++;
1088 
1089     if (header) {
1090         if (unlikely(page == 0))
1091             return mtdswap_auto_header(d, buf);
1092 
1093         page--;
1094     }
1095 
1096     realblock = d->page_data[page];
1097     if (realblock > BLOCK_MAX) {
1098         memset(buf, 0x0, PAGE_SIZE);
1099         if (realblock == BLOCK_UNDEF)
1100             return 0;
1101         else
1102             return -EIO;
1103     }
1104 
1105     eb = d->eb_data + (realblock / d->pages_per_eblk);
1106     BUG_ON(d->revmap[realblock] == PAGE_UNDEF);
1107 
1108     readpos = (loff_t)realblock << PAGE_SHIFT;
1109     retries = 0;
1110 
1111 retry:
1112     ret = mtd_read(mtd, readpos, PAGE_SIZE, &retlen, buf);
1113 
1114     d->mtd_read_count++;
1115     if (mtd_is_bitflip(ret)) {
1116         eb->flags |= EBLOCK_BITFLIP;
1117         mtdswap_rb_add(d, eb, MTDSWAP_BITFLIP);
1118         ret = 0;
1119     }
1120 
1121     if (ret < 0) {
1122         dev_err(d->dev, "Read error %d\n", ret);
1123         eb->flags |= EBLOCK_READERR;
1124         mtdswap_rb_add(d, eb, MTDSWAP_FAILING);
1125         retries++;
1126         if (retries < MTDSWAP_IO_RETRIES)
1127             goto retry;
1128 
1129         return ret;
1130     }
1131 
1132     if (retlen != PAGE_SIZE) {
1133         dev_err(d->dev, "Short read %zd\n", retlen);
1134         return -EIO;
1135     }
1136 
1137     return 0;
1138 }
1139 
1140 static int mtdswap_discard(struct mtd_blktrans_dev *dev, unsigned long first,
1141             unsigned nr_pages)
1142 {
1143     struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1144     unsigned long page;
1145     struct swap_eb *eb;
1146     unsigned int mapped;
1147 
1148     d->discard_count++;
1149 
1150     for (page = first; page < first + nr_pages; page++) {
1151         mapped = d->page_data[page];
1152         if (mapped <= BLOCK_MAX) {
1153             eb = d->eb_data + (mapped / d->pages_per_eblk);
1154             eb->active_count--;
1155             mtdswap_store_eb(d, eb);
1156             d->page_data[page] = BLOCK_UNDEF;
1157             d->revmap[mapped] = PAGE_UNDEF;
1158             d->discard_page_count++;
1159         } else if (mapped == BLOCK_ERROR) {
1160             d->page_data[page] = BLOCK_UNDEF;
1161             d->discard_page_count++;
1162         }
1163     }
1164 
1165     return 0;
1166 }
1167 
1168 static int mtdswap_show(struct seq_file *s, void *data)
1169 {
1170     struct mtdswap_dev *d = (struct mtdswap_dev *) s->private;
1171     unsigned long sum;
1172     unsigned int count[MTDSWAP_TREE_CNT];
1173     unsigned int min[MTDSWAP_TREE_CNT];
1174     unsigned int max[MTDSWAP_TREE_CNT];
1175     unsigned int i, cw = 0, cwp = 0, cwecount = 0, bb_cnt, mapped, pages;
1176     uint64_t use_size;
1177     static const char * const name[] = {
1178         "clean", "used", "low", "high", "dirty", "bitflip", "failing"
1179     };
1180 
1181     mutex_lock(&d->mbd_dev->lock);
1182 
1183     for (i = 0; i < MTDSWAP_TREE_CNT; i++) {
1184         struct rb_root *root = &d->trees[i].root;
1185 
1186         if (root->rb_node) {
1187             count[i] = d->trees[i].count;
1188             min[i] = MTDSWAP_ECNT_MIN(root);
1189             max[i] = MTDSWAP_ECNT_MAX(root);
1190         } else
1191             count[i] = 0;
1192     }
1193 
1194     if (d->curr_write) {
1195         cw = 1;
1196         cwp = d->curr_write_pos;
1197         cwecount = d->curr_write->erase_count;
1198     }
1199 
1200     sum = 0;
1201     for (i = 0; i < d->eblks; i++)
1202         sum += d->eb_data[i].erase_count;
1203 
1204     use_size = (uint64_t)d->eblks * d->mtd->erasesize;
1205     bb_cnt = mtdswap_badblocks(d->mtd, use_size);
1206 
1207     mapped = 0;
1208     pages = d->mbd_dev->size;
1209     for (i = 0; i < pages; i++)
1210         if (d->page_data[i] != BLOCK_UNDEF)
1211             mapped++;
1212 
1213     mutex_unlock(&d->mbd_dev->lock);
1214 
1215     for (i = 0; i < MTDSWAP_TREE_CNT; i++) {
1216         if (!count[i])
1217             continue;
1218 
1219         if (min[i] != max[i])
1220             seq_printf(s, "%s:\t%5d erase blocks, erased min %d, "
1221                 "max %d times\n",
1222                 name[i], count[i], min[i], max[i]);
1223         else
1224             seq_printf(s, "%s:\t%5d erase blocks, all erased %d "
1225                 "times\n", name[i], count[i], min[i]);
1226     }
1227 
1228     if (bb_cnt)
1229         seq_printf(s, "bad:\t%5u erase blocks\n", bb_cnt);
1230 
1231     if (cw)
1232         seq_printf(s, "current erase block: %u pages used, %u free, "
1233             "erased %u times\n",
1234             cwp, d->pages_per_eblk - cwp, cwecount);
1235 
1236     seq_printf(s, "total erasures: %lu\n", sum);
1237 
1238     seq_puts(s, "\n");
1239 
1240     seq_printf(s, "mtdswap_readsect count: %llu\n", d->sect_read_count);
1241     seq_printf(s, "mtdswap_writesect count: %llu\n", d->sect_write_count);
1242     seq_printf(s, "mtdswap_discard count: %llu\n", d->discard_count);
1243     seq_printf(s, "mtd read count: %llu\n", d->mtd_read_count);
1244     seq_printf(s, "mtd write count: %llu\n", d->mtd_write_count);
1245     seq_printf(s, "discarded pages count: %llu\n", d->discard_page_count);
1246 
1247     seq_puts(s, "\n");
1248     seq_printf(s, "total pages: %u\n", pages);
1249     seq_printf(s, "pages mapped: %u\n", mapped);
1250 
1251     return 0;
1252 }
1253 DEFINE_SHOW_ATTRIBUTE(mtdswap);
1254 
1255 static int mtdswap_add_debugfs(struct mtdswap_dev *d)
1256 {
1257     struct dentry *root = d->mtd->dbg.dfs_dir;
1258 
1259     if (!IS_ENABLED(CONFIG_DEBUG_FS))
1260         return 0;
1261 
1262     if (IS_ERR_OR_NULL(root))
1263         return -1;
1264 
1265     debugfs_create_file("mtdswap_stats", S_IRUSR, root, d, &mtdswap_fops);
1266 
1267     return 0;
1268 }
1269 
1270 static int mtdswap_init(struct mtdswap_dev *d, unsigned int eblocks,
1271             unsigned int spare_cnt)
1272 {
1273     struct mtd_info *mtd = d->mbd_dev->mtd;
1274     unsigned int i, eblk_bytes, pages, blocks;
1275     int ret = -ENOMEM;
1276 
1277     d->mtd = mtd;
1278     d->eblks = eblocks;
1279     d->spare_eblks = spare_cnt;
1280     d->pages_per_eblk = mtd->erasesize >> PAGE_SHIFT;
1281 
1282     pages = d->mbd_dev->size;
1283     blocks = eblocks * d->pages_per_eblk;
1284 
1285     for (i = 0; i < MTDSWAP_TREE_CNT; i++)
1286         d->trees[i].root = RB_ROOT;
1287 
1288     d->page_data = vmalloc(array_size(pages, sizeof(int)));
1289     if (!d->page_data)
1290         goto page_data_fail;
1291 
1292     d->revmap = vmalloc(array_size(blocks, sizeof(int)));
1293     if (!d->revmap)
1294         goto revmap_fail;
1295 
1296     eblk_bytes = sizeof(struct swap_eb)*d->eblks;
1297     d->eb_data = vzalloc(eblk_bytes);
1298     if (!d->eb_data)
1299         goto eb_data_fail;
1300 
1301     for (i = 0; i < pages; i++)
1302         d->page_data[i] = BLOCK_UNDEF;
1303 
1304     for (i = 0; i < blocks; i++)
1305         d->revmap[i] = PAGE_UNDEF;
1306 
1307     d->page_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1308     if (!d->page_buf)
1309         goto page_buf_fail;
1310 
1311     d->oob_buf = kmalloc_array(2, mtd->oobavail, GFP_KERNEL);
1312     if (!d->oob_buf)
1313         goto oob_buf_fail;
1314 
1315     mtdswap_scan_eblks(d);
1316 
1317     return 0;
1318 
1319 oob_buf_fail:
1320     kfree(d->page_buf);
1321 page_buf_fail:
1322     vfree(d->eb_data);
1323 eb_data_fail:
1324     vfree(d->revmap);
1325 revmap_fail:
1326     vfree(d->page_data);
1327 page_data_fail:
1328     printk(KERN_ERR "%s: init failed (%d)\n", MTDSWAP_PREFIX, ret);
1329     return ret;
1330 }
1331 
1332 static void mtdswap_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1333 {
1334     struct mtdswap_dev *d;
1335     struct mtd_blktrans_dev *mbd_dev;
1336     char *parts;
1337     char *this_opt;
1338     unsigned long part;
1339     unsigned int eblocks, eavailable, bad_blocks, spare_cnt;
1340     uint64_t swap_size, use_size, size_limit;
1341     int ret;
1342 
1343     parts = &partitions[0];
1344     if (!*parts)
1345         return;
1346 
1347     while ((this_opt = strsep(&parts, ",")) != NULL) {
1348         if (kstrtoul(this_opt, 0, &part) < 0)
1349             return;
1350 
1351         if (mtd->index == part)
1352             break;
1353     }
1354 
1355     if (mtd->index != part)
1356         return;
1357 
1358     if (mtd->erasesize < PAGE_SIZE || mtd->erasesize % PAGE_SIZE) {
1359         printk(KERN_ERR "%s: Erase size %u not multiple of PAGE_SIZE "
1360             "%lu\n", MTDSWAP_PREFIX, mtd->erasesize, PAGE_SIZE);
1361         return;
1362     }
1363 
1364     if (PAGE_SIZE % mtd->writesize || mtd->writesize > PAGE_SIZE) {
1365         printk(KERN_ERR "%s: PAGE_SIZE %lu not multiple of write size"
1366             " %u\n", MTDSWAP_PREFIX, PAGE_SIZE, mtd->writesize);
1367         return;
1368     }
1369 
1370     if (!mtd->oobsize || mtd->oobavail < MTDSWAP_OOBSIZE) {
1371         printk(KERN_ERR "%s: Not enough free bytes in OOB, "
1372             "%d available, %zu needed.\n",
1373             MTDSWAP_PREFIX, mtd->oobavail, MTDSWAP_OOBSIZE);
1374         return;
1375     }
1376 
1377     if (spare_eblocks > 100)
1378         spare_eblocks = 100;
1379 
1380     use_size = mtd->size;
1381     size_limit = (uint64_t) BLOCK_MAX * PAGE_SIZE;
1382 
1383     if (mtd->size > size_limit) {
1384         printk(KERN_WARNING "%s: Device too large. Limiting size to "
1385             "%llu bytes\n", MTDSWAP_PREFIX, size_limit);
1386         use_size = size_limit;
1387     }
1388 
1389     eblocks = mtd_div_by_eb(use_size, mtd);
1390     use_size = (uint64_t)eblocks * mtd->erasesize;
1391     bad_blocks = mtdswap_badblocks(mtd, use_size);
1392     eavailable = eblocks - bad_blocks;
1393 
1394     if (eavailable < MIN_ERASE_BLOCKS) {
1395         printk(KERN_ERR "%s: Not enough erase blocks. %u available, "
1396             "%d needed\n", MTDSWAP_PREFIX, eavailable,
1397             MIN_ERASE_BLOCKS);
1398         return;
1399     }
1400 
1401     spare_cnt = div_u64((uint64_t)eavailable * spare_eblocks, 100);
1402 
1403     if (spare_cnt < MIN_SPARE_EBLOCKS)
1404         spare_cnt = MIN_SPARE_EBLOCKS;
1405 
1406     if (spare_cnt > eavailable - 1)
1407         spare_cnt = eavailable - 1;
1408 
1409     swap_size = (uint64_t)(eavailable - spare_cnt) * mtd->erasesize +
1410         (header ? PAGE_SIZE : 0);
1411 
1412     printk(KERN_INFO "%s: Enabling MTD swap on device %lu, size %llu KB, "
1413         "%u spare, %u bad blocks\n",
1414         MTDSWAP_PREFIX, part, swap_size / 1024, spare_cnt, bad_blocks);
1415 
1416     d = kzalloc(sizeof(struct mtdswap_dev), GFP_KERNEL);
1417     if (!d)
1418         return;
1419 
1420     mbd_dev = kzalloc(sizeof(struct mtd_blktrans_dev), GFP_KERNEL);
1421     if (!mbd_dev) {
1422         kfree(d);
1423         return;
1424     }
1425 
1426     d->mbd_dev = mbd_dev;
1427     mbd_dev->priv = d;
1428 
1429     mbd_dev->mtd = mtd;
1430     mbd_dev->devnum = mtd->index;
1431     mbd_dev->size = swap_size >> PAGE_SHIFT;
1432     mbd_dev->tr = tr;
1433 
1434     if (!(mtd->flags & MTD_WRITEABLE))
1435         mbd_dev->readonly = 1;
1436 
1437     if (mtdswap_init(d, eblocks, spare_cnt) < 0)
1438         goto init_failed;
1439 
1440     if (add_mtd_blktrans_dev(mbd_dev) < 0)
1441         goto cleanup;
1442 
1443     d->dev = disk_to_dev(mbd_dev->disk);
1444 
1445     ret = mtdswap_add_debugfs(d);
1446     if (ret < 0)
1447         goto debugfs_failed;
1448 
1449     return;
1450 
1451 debugfs_failed:
1452     del_mtd_blktrans_dev(mbd_dev);
1453 
1454 cleanup:
1455     mtdswap_cleanup(d);
1456 
1457 init_failed:
1458     kfree(mbd_dev);
1459     kfree(d);
1460 }
1461 
1462 static void mtdswap_remove_dev(struct mtd_blktrans_dev *dev)
1463 {
1464     struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1465 
1466     del_mtd_blktrans_dev(dev);
1467     mtdswap_cleanup(d);
1468     kfree(d);
1469 }
1470 
1471 static struct mtd_blktrans_ops mtdswap_ops = {
1472     .name       = "mtdswap",
1473     .major      = 0,
1474     .part_bits  = 0,
1475     .blksize    = PAGE_SIZE,
1476     .flush      = mtdswap_flush,
1477     .readsect   = mtdswap_readsect,
1478     .writesect  = mtdswap_writesect,
1479     .discard    = mtdswap_discard,
1480     .background = mtdswap_background,
1481     .add_mtd    = mtdswap_add_mtd,
1482     .remove_dev = mtdswap_remove_dev,
1483     .owner      = THIS_MODULE,
1484 };
1485 
1486 module_mtd_blktrans(mtdswap_ops);
1487 
1488 MODULE_LICENSE("GPL");
1489 MODULE_AUTHOR("Jarkko Lavinen <jarkko.lavinen@nokia.com>");
1490 MODULE_DESCRIPTION("Block device access to an MTD suitable for using as "
1491         "swap space");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!