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