drivers/mtd/nftlmount.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * NFTL mount code with extensive checks
   4  *
   5  * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
   6  * Copyright © 2000 Netgem S.A.
   7  * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <asm/errno.h>
  12 #include <linux/delay.h>
  13 #include <linux/slab.h>
  14 #include <linux/mtd/mtd.h>
  15 #include <linux/mtd/rawnand.h>
  16 #include <linux/mtd/nftl.h>
  17
  18 #define SECTORSIZE 512
  19
  20 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
  21  *      various device information of the NFTL partition and Bad Unit Table. Update
  22  *      the ReplUnitTable[] table according to the Bad Unit Table. ReplUnitTable[]
  23  *      is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
  24  */
  25 static int find_boot_record(struct NFTLrecord *nftl)
  26 {
  27         struct nftl_uci1 h1;
  28         unsigned int block, boot_record_count = 0;
  29         size_t retlen;
  30         u8 buf[SECTORSIZE];
  31         struct NFTLMediaHeader *mh = &nftl->MediaHdr;
  32         struct mtd_info *mtd = nftl->mbd.mtd;
  33         unsigned int i;
  34
  35         /* Assume logical EraseSize == physical erasesize for starting the scan.
  36            We'll sort it out later if we find a MediaHeader which says otherwise */
  37         /* Actually, we won't.  The new DiskOnChip driver has already scanned
  38            the MediaHeader and adjusted the virtual erasesize it presents in
  39            the mtd device accordingly.  We could even get rid of
  40            nftl->EraseSize if there were any point in doing so. */
  41         nftl->EraseSize = nftl->mbd.mtd->erasesize;
  42         nftl->nb_blocks = (u32)nftl->mbd.mtd->size / nftl->EraseSize;
  43
  44         nftl->MediaUnit = BLOCK_NIL;
  45         nftl->SpareMediaUnit = BLOCK_NIL;
  46
  47         /* search for a valid boot record */
  48         for (block = 0; block < nftl->nb_blocks; block++) {
  49                 int ret;
  50
  51                 /* Check for ANAND header first. Then can whinge if it's found but later
  52                    checks fail */
  53                 ret = mtd_read(mtd, block * nftl->EraseSize, SECTORSIZE,
  54                                &retlen, buf);
  55                 /* We ignore ret in case the ECC of the MediaHeader is invalid
  56                    (which is apparently acceptable) */
  57                 if (retlen != SECTORSIZE) {
  58                         static int warncount = 5;
  59
  60                         if (warncount) {
  61                                 printk(KERN_WARNING "Block read at 0x%x of mtd%d failed: %d\n",
  62                                        block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
  63                                 if (!--warncount)
  64                                         printk(KERN_WARNING "Further failures for this block will not be printed\n");
  65                         }
  66                         continue;
  67                 }
  68
  69                 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
  70                         /* ANAND\0 not found. Continue */
  71 #if 0
  72                         printk(KERN_DEBUG "ANAND header not found at 0x%x in mtd%d\n",
  73                                block * nftl->EraseSize, nftl->mbd.mtd->index);
  74 #endif
  75                         continue;
  76                 }
  77
  78                 /* To be safer with BIOS, also use erase mark as discriminant */
  79                 ret = nftl_read_oob(mtd, block * nftl->EraseSize +
  80                                          SECTORSIZE + 8, 8, &retlen,
  81                                          (char *)&h1);
  82                 if (ret < 0) {
  83                         printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
  84                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
  85                         continue;
  86                 }
  87
  88 #if 0 /* Some people seem to have devices without ECC or erase marks
  89          on the Media Header blocks. There are enough other sanity
  90          checks in here that we can probably do without it.
  91       */
  92                 if (le16_to_cpu(h1.EraseMark | h1.EraseMark1) != ERASE_MARK) {
  93                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but erase mark not present (0x%04x,0x%04x instead)\n",
  94                                block * nftl->EraseSize, nftl->mbd.mtd->index,
  95                                le16_to_cpu(h1.EraseMark), le16_to_cpu(h1.EraseMark1));
  96                         continue;
  97                 }
  98
  99                 /* Finally reread to check ECC */
 100                 ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
 101                                 &retlen, buf);
 102                 if (ret < 0) {
 103                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
 104                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
 105                         continue;
 106                 }
 107
 108                 /* Paranoia. Check the ANAND header is still there after the ECC read */
 109                 if (memcmp(buf, "ANAND", 6)) {
 110                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but went away on reread!\n",
 111                                block * nftl->EraseSize, nftl->mbd.mtd->index);
 112                         printk(KERN_NOTICE "New data are: %6ph\n", buf);
 113                         continue;
 114                 }
 115 #endif
 116                 /* OK, we like it. */
 117
 118                 if (boot_record_count) {
 119                         /* We've already processed one. So we just check if
 120                            this one is the same as the first one we found */
 121                         if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
 122                                 printk(KERN_NOTICE "NFTL Media Headers at 0x%x and 0x%x disagree.\n",
 123                                        nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
 124                                 /* if (debug) Print both side by side */
 125                                 if (boot_record_count < 2) {
 126                                         /* We haven't yet seen two real ones */
 127                                         return -1;
 128                                 }
 129                                 continue;
 130                         }
 131                         if (boot_record_count == 1)
 132                                 nftl->SpareMediaUnit = block;
 133
 134                         /* Mark this boot record (NFTL MediaHeader) block as reserved */
 135                         nftl->ReplUnitTable[block] = BLOCK_RESERVED;
 136
 137
 138                         boot_record_count++;
 139                         continue;
 140                 }
 141
 142                 /* This is the first we've seen. Copy the media header structure into place */
 143                 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
 144
 145                 /* Do some sanity checks on it */
 146 #if 0
 147 The new DiskOnChip driver scans the MediaHeader itself, and presents a virtual
 148 erasesize based on UnitSizeFactor.  So the erasesize we read from the mtd
 149 device is already correct.
 150                 if (mh->UnitSizeFactor == 0) {
 151                         printk(KERN_NOTICE "NFTL: UnitSizeFactor 0x00 detected. This violates the spec but we think we know what it means...\n");
 152                 } else if (mh->UnitSizeFactor < 0xfc) {
 153                         printk(KERN_NOTICE "Sorry, we don't support UnitSizeFactor 0x%02x\n",
 154                                mh->UnitSizeFactor);
 155                         return -1;
 156                 } else if (mh->UnitSizeFactor != 0xff) {
 157                         printk(KERN_NOTICE "WARNING: Support for NFTL with UnitSizeFactor 0x%02x is experimental\n",
 158                                mh->UnitSizeFactor);
 159                         nftl->EraseSize = nftl->mbd.mtd->erasesize << (0xff - mh->UnitSizeFactor);
 160                         nftl->nb_blocks = (u32)nftl->mbd.mtd->size / nftl->EraseSize;
 161                 }
 162 #endif
 163                 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
 164                 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
 165                         printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
 166                         printk(KERN_NOTICE "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
 167                                nftl->nb_boot_blocks, nftl->nb_blocks);
 168                         return -1;
 169                 }
 170
 171                 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
 172                 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
 173                         printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
 174                         printk(KERN_NOTICE "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
 175                                nftl->numvunits, nftl->nb_blocks, nftl->nb_boot_blocks);
 176                         return -1;
 177                 }
 178
 179                 nftl->mbd.size  = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
 180
 181                 /* If we're not using the last sectors in the device for some reason,
 182                    reduce nb_blocks accordingly so we forget they're there */
 183                 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
 184
 185                 /* XXX: will be suppressed */
 186                 nftl->lastEUN = nftl->nb_blocks - 1;
 187
 188                 /* memory alloc */
 189                 nftl->EUNtable = kmalloc_array(nftl->nb_blocks, sizeof(u16),
 190                                                GFP_KERNEL);
 191                 if (!nftl->EUNtable)
 192                         return -ENOMEM;
 193
 194                 nftl->ReplUnitTable = kmalloc_array(nftl->nb_blocks,
 195                                                     sizeof(u16),
 196                                                     GFP_KERNEL);
 197                 if (!nftl->ReplUnitTable) {
 198                         kfree(nftl->EUNtable);
 199                         return -ENOMEM;
 200                 }
 201
 202                 /* mark the bios blocks (blocks before NFTL MediaHeader) as reserved */
 203                 for (i = 0; i < nftl->nb_boot_blocks; i++)
 204                         nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 205                 /* mark all remaining blocks as potentially containing data */
 206                 for (; i < nftl->nb_blocks; i++) {
 207                         nftl->ReplUnitTable[i] = BLOCK_NOTEXPLORED;
 208                 }
 209
 210                 /* Mark this boot record (NFTL MediaHeader) block as reserved */
 211                 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
 212
 213                 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
 214                 for (i = 0; i < nftl->nb_blocks; i++) {
 215 #if 0
 216 The new DiskOnChip driver already scanned the bad block table.  Just query it.
 217                         if ((i & (SECTORSIZE - 1)) == 0) {
 218                                 /* read one sector for every SECTORSIZE of blocks */
 219                                 ret = mtd->read(nftl->mbd.mtd,
 220                                                 block * nftl->EraseSize + i +
 221                                                 SECTORSIZE, SECTORSIZE,
 222                                                 &retlen, buf);
 223                                 if (ret < 0) {
 224                                         printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
 225                                                ret);
 226                                         kfree(nftl->ReplUnitTable);
 227                                         kfree(nftl->EUNtable);
 228                                         return -1;
 229                                 }
 230                         }
 231                         /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
 232                         if (buf[i & (SECTORSIZE - 1)] != 0xff)
 233                                 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 234 #endif
 235                         if (mtd_block_isbad(nftl->mbd.mtd,
 236                                             i * nftl->EraseSize))
 237                                 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 238                 }
 239
 240                 nftl->MediaUnit = block;
 241                 boot_record_count++;
 242
 243         } /* foreach (block) */
 244
 245         return boot_record_count?0:-1;
 246 }
 247
 248 static int memcmpb(void *a, int c, int n)
 249 {
 250         int i;
 251         for (i = 0; i < n; i++) {
 252                 if (c != ((unsigned char *)a)[i])
 253                         return 1;
 254         }
 255         return 0;
 256 }
 257
 258 /* check_free_sector: check if a free sector is actually FREE, i.e. All 0xff in data and oob area */
 259 static int check_free_sectors(struct NFTLrecord *nftl, unsigned int address, int len,
 260                               int check_oob)
 261 {
 262         struct mtd_info *mtd = nftl->mbd.mtd;
 263         size_t retlen;
 264         int i, ret;
 265         u8 *buf;
 266
 267         buf = kmalloc(SECTORSIZE + mtd->oobsize, GFP_KERNEL);
 268         if (!buf)
 269                 return -ENOMEM;
 270
 271         ret = -1;
 272         for (i = 0; i < len; i += SECTORSIZE) {
 273                 if (mtd_read(mtd, address, SECTORSIZE, &retlen, buf))
 274                         goto out;
 275                 if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
 276                         goto out;
 277
 278                 if (check_oob) {
 279                         if(nftl_read_oob(mtd, address, mtd->oobsize,
 280                                          &retlen, &buf[SECTORSIZE]) < 0)
 281                                 goto out;
 282                         if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
 283                                 goto out;
 284                 }
 285                 address += SECTORSIZE;
 286         }
 287
 288         ret = 0;
 289
 290 out:
 291         kfree(buf);
 292         return ret;
 293 }
 294
 295 /* NFTL_format: format a Erase Unit by erasing ALL Erase Zones in the Erase Unit and
 296  *              Update NFTL metadata. Each erase operation is checked with check_free_sectors
 297  *
 298  * Return: 0 when succeed, -1 on error.
 299  *
 300  *  ToDo: 1. Is it necessary to check_free_sector after erasing ??
 301  */
 302 int NFTL_formatblock(struct NFTLrecord *nftl, int block)
 303 {
 304         size_t retlen;
 305         unsigned int nb_erases, erase_mark;
 306         struct nftl_uci1 uci;
 307         struct erase_info *instr = &nftl->instr;
 308         struct mtd_info *mtd = nftl->mbd.mtd;
 309
 310         /* Read the Unit Control Information #1 for Wear-Leveling */
 311         if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8,
 312                           8, &retlen, (char *)&uci) < 0)
 313                 goto default_uci1;
 314
 315         erase_mark = le16_to_cpu ((uci.EraseMark | uci.EraseMark1));
 316         if (erase_mark != ERASE_MARK) {
 317         default_uci1:
 318                 uci.EraseMark = cpu_to_le16(ERASE_MARK);
 319                 uci.EraseMark1 = cpu_to_le16(ERASE_MARK);
 320                 uci.WearInfo = cpu_to_le32(0);
 321         }
 322
 323         memset(instr, 0, sizeof(struct erase_info));
 324
 325         /* XXX: use async erase interface, XXX: test return code */
 326         instr->addr = block * nftl->EraseSize;
 327         instr->len = nftl->EraseSize;
 328         if (mtd_erase(mtd, instr)) {
 329                 printk("Error while formatting block %d\n", block);
 330                 goto fail;
 331         }
 332
 333         /* increase and write Wear-Leveling info */
 334         nb_erases = le32_to_cpu(uci.WearInfo);
 335         nb_erases++;
 336
 337         /* wrap (almost impossible with current flash) or free block */
 338         if (nb_erases == 0)
 339                 nb_erases = 1;
 340
 341         /* check the "freeness" of Erase Unit before updating metadata
 342          * FixMe:  is this check really necessary ? since we have check the
 343          *         return code after the erase operation.
 344          */
 345         if (check_free_sectors(nftl, instr->addr, nftl->EraseSize, 1) != 0)
 346                 goto fail;
 347
 348         uci.WearInfo = le32_to_cpu(nb_erases);
 349         if (nftl_write_oob(mtd, block * nftl->EraseSize + SECTORSIZE +
 350                            8, 8, &retlen, (char *)&uci) < 0)
 351                 goto fail;
 352         return 0;
 353 fail:
 354         /* could not format, update the bad block table (caller is responsible
 355            for setting the ReplUnitTable to BLOCK_RESERVED on failure) */
 356         mtd_block_markbad(nftl->mbd.mtd, instr->addr);
 357         return -1;
 358 }
 359
 360 /* check_sectors_in_chain: Check that each sector of a Virtual Unit Chain is correct.
 361  *      Mark as 'IGNORE' each incorrect sector. This check is only done if the chain
 362  *      was being folded when NFTL was interrupted.
 363  *
 364  *      The check_free_sectors in this function is necessary. There is a possible
 365  *      situation that after writing the Data area, the Block Control Information is
 366  *      not updated according (due to power failure or something) which leaves the block
 367  *      in an inconsistent state. So we have to check if a block is really FREE in this
 368  *      case. */
 369 static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_block)
 370 {
 371         struct mtd_info *mtd = nftl->mbd.mtd;
 372         unsigned int block, i, status;
 373         struct nftl_bci bci;
 374         int sectors_per_block;
 375         size_t retlen;
 376
 377         sectors_per_block = nftl->EraseSize / SECTORSIZE;
 378         block = first_block;
 379         for (;;) {
 380                 for (i = 0; i < sectors_per_block; i++) {
 381                         if (nftl_read_oob(mtd,
 382                                           block * nftl->EraseSize + i * SECTORSIZE,
 383                                           8, &retlen, (char *)&bci) < 0)
 384                                 status = SECTOR_IGNORE;
 385                         else
 386                                 status = bci.Status | bci.Status1;
 387
 388                         switch(status) {
 389                         case SECTOR_FREE:
 390                                 /* verify that the sector is really free. If not, mark
 391                                    as ignore */
 392                                 if (memcmpb(&bci, 0xff, 8) != 0 ||
 393                                     check_free_sectors(nftl, block * nftl->EraseSize + i * SECTORSIZE,
 394                                                        SECTORSIZE, 0) != 0) {
 395                                         printk("Incorrect free sector %d in block %d: "
 396                                                "marking it as ignored\n",
 397                                                i, block);
 398
 399                                         /* sector not free actually : mark it as SECTOR_IGNORE  */
 400                                         bci.Status = SECTOR_IGNORE;
 401                                         bci.Status1 = SECTOR_IGNORE;
 402                                         nftl_write_oob(mtd, block *
 403                                                        nftl->EraseSize +
 404                                                        i * SECTORSIZE, 8,
 405                                                        &retlen, (char *)&bci);
 406                                 }
 407                                 break;
 408                         default:
 409                                 break;
 410                         }
 411                 }
 412
 413                 /* proceed to next Erase Unit on the chain */
 414                 block = nftl->ReplUnitTable[block];
 415                 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
 416                         printk("incorrect ReplUnitTable[] : %d\n", block);
 417                 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
 418                         break;
 419         }
 420 }
 421
 422 /* calc_chain_length: Walk through a Virtual Unit Chain and estimate chain length */
 423 static int calc_chain_length(struct NFTLrecord *nftl, unsigned int first_block)
 424 {
 425         unsigned int length = 0, block = first_block;
 426
 427         for (;;) {
 428                 length++;
 429                 /* avoid infinite loops, although this is guaranteed not to
 430                    happen because of the previous checks */
 431                 if (length >= nftl->nb_blocks) {
 432                         printk("nftl: length too long %d !\n", length);
 433                         break;
 434                 }
 435
 436                 block = nftl->ReplUnitTable[block];
 437                 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
 438                         printk("incorrect ReplUnitTable[] : %d\n", block);
 439                 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
 440                         break;
 441         }
 442         return length;
 443 }
 444
 445 /* format_chain: Format an invalid Virtual Unit chain. It frees all the Erase Units in a
 446  *      Virtual Unit Chain, i.e. all the units are disconnected.
 447  *
 448  *      It is not strictly correct to begin from the first block of the chain because
 449  *      if we stop the code, we may see again a valid chain if there was a first_block
 450  *      flag in a block inside it. But is it really a problem ?
 451  *
 452  * FixMe: Figure out what the last statement means. What if power failure when we are
 453  *      in the for (;;) loop formatting blocks ??
 454  */
 455 static void format_chain(struct NFTLrecord *nftl, unsigned int first_block)
 456 {
 457         unsigned int block = first_block, block1;
 458
 459         printk("Formatting chain at block %d\n", first_block);
 460
 461         for (;;) {
 462                 block1 = nftl->ReplUnitTable[block];
 463
 464                 printk("Formatting block %d\n", block);
 465                 if (NFTL_formatblock(nftl, block) < 0) {
 466                         /* cannot format !!!! Mark it as Bad Unit */
 467                         nftl->ReplUnitTable[block] = BLOCK_RESERVED;
 468                 } else {
 469                         nftl->ReplUnitTable[block] = BLOCK_FREE;
 470                 }
 471
 472                 /* goto next block on the chain */
 473                 block = block1;
 474
 475                 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
 476                         printk("incorrect ReplUnitTable[] : %d\n", block);
 477                 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
 478                         break;
 479         }
 480 }
 481
 482 /* check_and_mark_free_block: Verify that a block is free in the NFTL sense (valid erase mark) or
 483  *      totally free (only 0xff).
 484  *
 485  * Definition: Free Erase Unit -- A properly erased/formatted Free Erase Unit should have meet the
 486  *      following criteria:
 487  *      1. */
 488 static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
 489 {
 490         struct mtd_info *mtd = nftl->mbd.mtd;
 491         struct nftl_uci1 h1;
 492         unsigned int erase_mark;
 493         size_t retlen;
 494
 495         /* check erase mark. */
 496         if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
 497                           &retlen, (char *)&h1) < 0)
 498                 return -1;
 499
 500         erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
 501         if (erase_mark != ERASE_MARK) {
 502                 /* if no erase mark, the block must be totally free. This is
 503                    possible in two cases : empty filesystem or interrupted erase (very unlikely) */
 504                 if (check_free_sectors (nftl, block * nftl->EraseSize, nftl->EraseSize, 1) != 0)
 505                         return -1;
 506
 507                 /* free block : write erase mark */
 508                 h1.EraseMark = cpu_to_le16(ERASE_MARK);
 509                 h1.EraseMark1 = cpu_to_le16(ERASE_MARK);
 510                 h1.WearInfo = cpu_to_le32(0);
 511                 if (nftl_write_oob(mtd,
 512                                    block * nftl->EraseSize + SECTORSIZE + 8, 8,
 513                                    &retlen, (char *)&h1) < 0)
 514                         return -1;
 515         } else {
 516 #if 0
 517                 /* if erase mark present, need to skip it when doing check */
 518                 for (i = 0; i < nftl->EraseSize; i += SECTORSIZE) {
 519                         /* check free sector */
 520                         if (check_free_sectors (nftl, block * nftl->EraseSize + i,
 521                                                 SECTORSIZE, 0) != 0)
 522                                 return -1;
 523
 524                         if (nftl_read_oob(mtd, block * nftl->EraseSize + i,
 525                                           16, &retlen, buf) < 0)
 526                                 return -1;
 527                         if (i == SECTORSIZE) {
 528                                 /* skip erase mark */
 529                                 if (memcmpb(buf, 0xff, 8))
 530                                         return -1;
 531                         } else {
 532                                 if (memcmpb(buf, 0xff, 16))
 533                                         return -1;
 534                         }
 535                 }
 536 #endif
 537         }
 538
 539         return 0;
 540 }
 541
 542 /* get_fold_mark: Read fold mark from Unit Control Information #2, we use FOLD_MARK_IN_PROGRESS
 543  *      to indicate that we are in the progression of a Virtual Unit Chain folding. If the UCI #2
 544  *      is FOLD_MARK_IN_PROGRESS when mounting the NFTL, the (previous) folding process is interrupted
 545  *      for some reason. A clean up/check of the VUC is necessary in this case.
 546  *
 547  * WARNING: return 0 if read error
 548  */
 549 static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block)
 550 {
 551         struct mtd_info *mtd = nftl->mbd.mtd;
 552         struct nftl_uci2 uci;
 553         size_t retlen;
 554
 555         if (nftl_read_oob(mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
 556                           8, &retlen, (char *)&uci) < 0)
 557                 return 0;
 558
 559         return le16_to_cpu((uci.FoldMark | uci.FoldMark1));
 560 }
 561
 562 int NFTL_mount(struct NFTLrecord *s)
 563 {
 564         int i;
 565         unsigned int first_logical_block, logical_block, rep_block, erase_mark;
 566         unsigned int block, first_block, is_first_block;
 567         int chain_length, do_format_chain;
 568         struct nftl_uci0 h0;
 569         struct nftl_uci1 h1;
 570         struct mtd_info *mtd = s->mbd.mtd;
 571         size_t retlen;
 572
 573         /* search for NFTL MediaHeader and Spare NFTL Media Header */
 574         if (find_boot_record(s) < 0) {
 575                 printk("Could not find valid boot record\n");
 576                 return -1;
 577         }
 578
 579         /* init the logical to physical table */
 580         for (i = 0; i < s->nb_blocks; i++) {
 581                 s->EUNtable[i] = BLOCK_NIL;
 582         }
 583
 584         /* first pass : explore each block chain */
 585         first_logical_block = 0;
 586         for (first_block = 0; first_block < s->nb_blocks; first_block++) {
 587                 /* if the block was not already explored, we can look at it */
 588                 if (s->ReplUnitTable[first_block] == BLOCK_NOTEXPLORED) {
 589                         block = first_block;
 590                         chain_length = 0;
 591                         do_format_chain = 0;
 592
 593                         for (;;) {
 594                                 /* read the block header. If error, we format the chain */
 595                                 if (nftl_read_oob(mtd,
 596                                                   block * s->EraseSize + 8, 8,
 597                                                   &retlen, (char *)&h0) < 0 ||
 598                                     nftl_read_oob(mtd,
 599                                                   block * s->EraseSize +
 600                                                   SECTORSIZE + 8, 8,
 601                                                   &retlen, (char *)&h1) < 0) {
 602                                         s->ReplUnitTable[block] = BLOCK_NIL;
 603                                         do_format_chain = 1;
 604                                         break;
 605                                 }
 606
 607                                 logical_block = le16_to_cpu ((h0.VirtUnitNum | h0.SpareVirtUnitNum));
 608                                 rep_block = le16_to_cpu ((h0.ReplUnitNum | h0.SpareReplUnitNum));
 609                                 erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
 610
 611                                 is_first_block = !(logical_block >> 15);
 612                                 logical_block = logical_block & 0x7fff;
 613
 614                                 /* invalid/free block test */
 615                                 if (erase_mark != ERASE_MARK || logical_block >= s->nb_blocks) {
 616                                         if (chain_length == 0) {
 617                                                 /* if not currently in a chain, we can handle it safely */
 618                                                 if (check_and_mark_free_block(s, block) < 0) {
 619                                                         /* not really free: format it */
 620                                                         printk("Formatting block %d\n", block);
 621                                                         if (NFTL_formatblock(s, block) < 0) {
 622                                                                 /* could not format: reserve the block */
 623                                                                 s->ReplUnitTable[block] = BLOCK_RESERVED;
 624                                                         } else {
 625                                                                 s->ReplUnitTable[block] = BLOCK_FREE;
 626                                                         }
 627                                                 } else {
 628                                                         /* free block: mark it */
 629                                                         s->ReplUnitTable[block] = BLOCK_FREE;
 630                                                 }
 631                                                 /* directly examine the next block. */
 632                                                 goto examine_ReplUnitTable;
 633                                         } else {
 634                                                 /* the block was in a chain : this is bad. We
 635                                                    must format all the chain */
 636                                                 printk("Block %d: free but referenced in chain %d\n",
 637                                                        block, first_block);
 638                                                 s->ReplUnitTable[block] = BLOCK_NIL;
 639                                                 do_format_chain = 1;
 640                                                 break;
 641                                         }
 642                                 }
 643
 644                                 /* we accept only first blocks here */
 645                                 if (chain_length == 0) {
 646                                         /* this block is not the first block in chain :
 647                                            ignore it, it will be included in a chain
 648                                            later, or marked as not explored */
 649                                         if (!is_first_block)
 650                                                 goto examine_ReplUnitTable;
 651                                         first_logical_block = logical_block;
 652                                 } else {
 653                                         if (logical_block != first_logical_block) {
 654                                                 printk("Block %d: incorrect logical block: %d expected: %d\n",
 655                                                        block, logical_block, first_logical_block);
 656                                                 /* the chain is incorrect : we must format it,
 657                                                    but we need to read it completely */
 658                                                 do_format_chain = 1;
 659                                         }
 660                                         if (is_first_block) {
 661                                                 /* we accept that a block is marked as first
 662                                                    block while being last block in a chain
 663                                                    only if the chain is being folded */
 664                                                 if (get_fold_mark(s, block) != FOLD_MARK_IN_PROGRESS ||
 665                                                     rep_block != 0xffff) {
 666                                                         printk("Block %d: incorrectly marked as first block in chain\n",
 667                                                                block);
 668                                                         /* the chain is incorrect : we must format it,
 669                                                            but we need to read it completely */
 670                                                         do_format_chain = 1;
 671                                                 } else {
 672                                                         printk("Block %d: folding in progress - ignoring first block flag\n",
 673                                                                block);
 674                                                 }
 675                                         }
 676                                 }
 677                                 chain_length++;
 678                                 if (rep_block == 0xffff) {
 679                                         /* no more blocks after */
 680                                         s->ReplUnitTable[block] = BLOCK_NIL;
 681                                         break;
 682                                 } else if (rep_block >= s->nb_blocks) {
 683                                         printk("Block %d: referencing invalid block %d\n",
 684                                                block, rep_block);
 685                                         do_format_chain = 1;
 686                                         s->ReplUnitTable[block] = BLOCK_NIL;
 687                                         break;
 688                                 } else if (s->ReplUnitTable[rep_block] != BLOCK_NOTEXPLORED) {
 689                                         /* same problem as previous 'is_first_block' test:
 690                                            we accept that the last block of a chain has
 691                                            the first_block flag set if folding is in
 692                                            progress. We handle here the case where the
 693                                            last block appeared first */
 694                                         if (s->ReplUnitTable[rep_block] == BLOCK_NIL &&
 695                                             s->EUNtable[first_logical_block] == rep_block &&
 696                                             get_fold_mark(s, first_block) == FOLD_MARK_IN_PROGRESS) {
 697                                                 /* EUNtable[] will be set after */
 698                                                 printk("Block %d: folding in progress - ignoring first block flag\n",
 699                                                        rep_block);
 700                                                 s->ReplUnitTable[block] = rep_block;
 701                                                 s->EUNtable[first_logical_block] = BLOCK_NIL;
 702                                         } else {
 703                                                 printk("Block %d: referencing block %d already in another chain\n",
 704                                                        block, rep_block);
 705                                                 /* XXX: should handle correctly fold in progress chains */
 706                                                 do_format_chain = 1;
 707                                                 s->ReplUnitTable[block] = BLOCK_NIL;
 708                                         }
 709                                         break;
 710                                 } else {
 711                                         /* this is OK */
 712                                         s->ReplUnitTable[block] = rep_block;
 713                                         block = rep_block;
 714                                 }
 715                         }
 716
 717                         /* the chain was completely explored. Now we can decide
 718                            what to do with it */
 719                         if (do_format_chain) {
 720                                 /* invalid chain : format it */
 721                                 format_chain(s, first_block);
 722                         } else {
 723                                 unsigned int first_block1, chain_to_format, chain_length1;
 724                                 int fold_mark;
 725
 726                                 /* valid chain : get foldmark */
 727                                 fold_mark = get_fold_mark(s, first_block);
 728                                 if (fold_mark == 0) {
 729                                         /* cannot get foldmark : format the chain */
 730                                         printk("Could read foldmark at block %d\n", first_block);
 731                                         format_chain(s, first_block);
 732                                 } else {
 733                                         if (fold_mark == FOLD_MARK_IN_PROGRESS)
 734                                                 check_sectors_in_chain(s, first_block);
 735
 736                                         /* now handle the case where we find two chains at the
 737                                            same virtual address : we select the longer one,
 738                                            because the shorter one is the one which was being
 739                                            folded if the folding was not done in place */
 740                                         first_block1 = s->EUNtable[first_logical_block];
 741                                         if (first_block1 != BLOCK_NIL) {
 742                                                 /* XXX: what to do if same length ? */
 743                                                 chain_length1 = calc_chain_length(s, first_block1);
 744                                                 printk("Two chains at blocks %d (len=%d) and %d (len=%d)\n",
 745                                                        first_block1, chain_length1, first_block, chain_length);
 746
 747                                                 if (chain_length >= chain_length1) {
 748                                                         chain_to_format = first_block1;
 749                                                         s->EUNtable[first_logical_block] = first_block;
 750                                                 } else {
 751                                                         chain_to_format = first_block;
 752                                                 }
 753                                                 format_chain(s, chain_to_format);
 754                                         } else {
 755                                                 s->EUNtable[first_logical_block] = first_block;
 756                                         }
 757                                 }
 758                         }
 759                 }
 760         examine_ReplUnitTable:;
 761         }
 762
 763         /* second pass to format unreferenced blocks  and init free block count */
 764         s->numfreeEUNs = 0;
 765         s->LastFreeEUN = le16_to_cpu(s->MediaHdr.FirstPhysicalEUN);
 766
 767         for (block = 0; block < s->nb_blocks; block++) {
 768                 if (s->ReplUnitTable[block] == BLOCK_NOTEXPLORED) {
 769                         printk("Unreferenced block %d, formatting it\n", block);
 770                         if (NFTL_formatblock(s, block) < 0)
 771                                 s->ReplUnitTable[block] = BLOCK_RESERVED;
 772                         else
 773                                 s->ReplUnitTable[block] = BLOCK_FREE;
 774                 }
 775                 if (s->ReplUnitTable[block] == BLOCK_FREE) {
 776                         s->numfreeEUNs++;
 777                         s->LastFreeEUN = block;
 778                 }
 779         }
 780
 781         return 0;
 782 }