drivers/mtd/nftlmount.c

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