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