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