2 * NFTL mount code with extensive checks
4 * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
5 * Copyright (C) 2000 Netgem S.A.
7 * $Id: nftlmount.c,v 1.41 2005/11/07 11:14:21 gleixner Exp $
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.
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.
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
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>
32 #define SECTORSIZE 512
34 char nftlmountrev[]="$Revision: 1.41 $";
36 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
37 * various device information of the NFTL partition and Bad Unit Table. Update
38 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
39 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
41 static int find_boot_record(struct NFTLrecord *nftl)
44 unsigned int block, boot_record_count = 0;
47 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
50 /* Assume logical EraseSize == physical erasesize for starting the scan.
51 We'll sort it out later if we find a MediaHeader which says otherwise */
52 /* Actually, we won't. The new DiskOnChip driver has already scanned
53 the MediaHeader and adjusted the virtual erasesize it presents in
54 the mtd device accordingly. We could even get rid of
55 nftl->EraseSize if there were any point in doing so. */
56 nftl->EraseSize = nftl->mbd.mtd->erasesize;
57 nftl->nb_blocks = nftl->mbd.mtd->size / nftl->EraseSize;
59 nftl->MediaUnit = BLOCK_NIL;
60 nftl->SpareMediaUnit = BLOCK_NIL;
62 /* search for a valid boot record */
63 for (block = 0; block < nftl->nb_blocks; block++) {
66 /* Check for ANAND header first. Then can whinge if it's found but later
68 ret = MTD_READ(nftl->mbd.mtd, block * nftl->EraseSize, SECTORSIZE, &retlen, buf);
69 /* We ignore ret in case the ECC of the MediaHeader is invalid
70 (which is apparently acceptable) */
71 if (retlen != SECTORSIZE) {
72 static int warncount = 5;
75 printk(KERN_WARNING "Block read at 0x%x of mtd%d failed: %d\n",
76 block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
78 printk(KERN_WARNING "Further failures for this block will not be printed\n");
83 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
84 /* ANAND\0 not found. Continue */
86 printk(KERN_DEBUG "ANAND header not found at 0x%x in mtd%d\n",
87 block * nftl->EraseSize, nftl->mbd.mtd->index);
92 /* To be safer with BIOS, also use erase mark as discriminant */
93 if ((ret = MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8,
94 8, &retlen, (char *)&h1) < 0)) {
95 printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
96 block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
100 #if 0 /* Some people seem to have devices without ECC or erase marks
101 on the Media Header blocks. There are enough other sanity
102 checks in here that we can probably do without it.
104 if (le16_to_cpu(h1.EraseMark | h1.EraseMark1) != ERASE_MARK) {
105 printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but erase mark not present (0x%04x,0x%04x instead)\n",
106 block * nftl->EraseSize, nftl->mbd.mtd->index,
107 le16_to_cpu(h1.EraseMark), le16_to_cpu(h1.EraseMark1));
111 /* Finally reread to check ECC */
112 if ((ret = MTD_READECC(nftl->mbd.mtd, block * nftl->EraseSize, SECTORSIZE,
113 &retlen, buf, (char *)&oob, NULL) < 0)) {
114 printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
115 block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
119 /* Paranoia. Check the ANAND header is still there after the ECC read */
120 if (memcmp(buf, "ANAND", 6)) {
121 printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but went away on reread!\n",
122 block * nftl->EraseSize, nftl->mbd.mtd->index);
123 printk(KERN_NOTICE "New data are: %02x %02x %02x %02x %02x %02x\n",
124 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
128 /* OK, we like it. */
130 if (boot_record_count) {
131 /* We've already processed one. So we just check if
132 this one is the same as the first one we found */
133 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
134 printk(KERN_NOTICE "NFTL Media Headers at 0x%x and 0x%x disagree.\n",
135 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
136 /* if (debug) Print both side by side */
137 if (boot_record_count < 2) {
138 /* We haven't yet seen two real ones */
143 if (boot_record_count == 1)
144 nftl->SpareMediaUnit = block;
146 /* Mark this boot record (NFTL MediaHeader) block as reserved */
147 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
154 /* This is the first we've seen. Copy the media header structure into place */
155 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
157 /* Do some sanity checks on it */
159 The new DiskOnChip driver scans the MediaHeader itself, and presents a virtual
160 erasesize based on UnitSizeFactor. So the erasesize we read from the mtd
161 device is already correct.
162 if (mh->UnitSizeFactor == 0) {
163 printk(KERN_NOTICE "NFTL: UnitSizeFactor 0x00 detected. This violates the spec but we think we know what it means...\n");
164 } else if (mh->UnitSizeFactor < 0xfc) {
165 printk(KERN_NOTICE "Sorry, we don't support UnitSizeFactor 0x%02x\n",
168 } else if (mh->UnitSizeFactor != 0xff) {
169 printk(KERN_NOTICE "WARNING: Support for NFTL with UnitSizeFactor 0x%02x is experimental\n",
171 nftl->EraseSize = nftl->mbd.mtd->erasesize << (0xff - mh->UnitSizeFactor);
172 nftl->nb_blocks = nftl->mbd.mtd->size / nftl->EraseSize;
175 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
176 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
177 printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
178 printk(KERN_NOTICE "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
179 nftl->nb_boot_blocks, nftl->nb_blocks);
183 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
184 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
185 printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
186 printk(KERN_NOTICE "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
187 nftl->numvunits, nftl->nb_blocks, nftl->nb_boot_blocks);
191 nftl->mbd.size = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
193 /* If we're not using the last sectors in the device for some reason,
194 reduce nb_blocks accordingly so we forget they're there */
195 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
197 /* XXX: will be suppressed */
198 nftl->lastEUN = nftl->nb_blocks - 1;
201 nftl->EUNtable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
202 if (!nftl->EUNtable) {
203 printk(KERN_NOTICE "NFTL: allocation of EUNtable failed\n");
207 nftl->ReplUnitTable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
208 if (!nftl->ReplUnitTable) {
209 kfree(nftl->EUNtable);
210 printk(KERN_NOTICE "NFTL: allocation of ReplUnitTable failed\n");
214 /* mark the bios blocks (blocks before NFTL MediaHeader) as reserved */
215 for (i = 0; i < nftl->nb_boot_blocks; i++)
216 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
217 /* mark all remaining blocks as potentially containing data */
218 for (; i < nftl->nb_blocks; i++) {
219 nftl->ReplUnitTable[i] = BLOCK_NOTEXPLORED;
222 /* Mark this boot record (NFTL MediaHeader) block as reserved */
223 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
225 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
226 for (i = 0; i < nftl->nb_blocks; i++) {
228 The new DiskOnChip driver already scanned the bad block table. Just query it.
229 if ((i & (SECTORSIZE - 1)) == 0) {
230 /* read one sector for every SECTORSIZE of blocks */
231 if ((ret = MTD_READECC(nftl->mbd.mtd, block * nftl->EraseSize +
232 i + SECTORSIZE, SECTORSIZE, &retlen, buf,
233 (char *)&oob, NULL)) < 0) {
234 printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
236 kfree(nftl->ReplUnitTable);
237 kfree(nftl->EUNtable);
241 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
242 if (buf[i & (SECTORSIZE - 1)] != 0xff)
243 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
245 if (nftl->mbd.mtd->block_isbad(nftl->mbd.mtd, i * nftl->EraseSize))
246 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
249 nftl->MediaUnit = block;
252 } /* foreach (block) */
254 return boot_record_count?0:-1;
257 static int memcmpb(void *a, int c, int n)
260 for (i = 0; i < n; i++) {
261 if (c != ((unsigned char *)a)[i])
267 /* check_free_sector: check if a free sector is actually FREE, i.e. All 0xff in data and oob area */
268 static int check_free_sectors(struct NFTLrecord *nftl, unsigned int address, int len,
271 u8 buf[SECTORSIZE + nftl->mbd.mtd->oobsize];
272 struct mtd_info *mtd = nftl->mbd.mtd;
276 for (i = 0; i < len; i += SECTORSIZE) {
277 if (mtd->read(mtd, address, SECTORSIZE, &retlen, buf))
279 if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
283 if(mtd->read_oob(mtd, address, mtd->oobsize,
284 &retlen, &buf[SECTORSIZE]) < 0)
286 if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
289 address += SECTORSIZE;
295 /* NFTL_format: format a Erase Unit by erasing ALL Erase Zones in the Erase Unit and
296 * Update NFTL metadata. Each erase operation is checked with check_free_sectors
298 * Return: 0 when succeed, -1 on error.
300 * ToDo: 1. Is it neceressary to check_free_sector after erasing ??
302 int NFTL_formatblock(struct NFTLrecord *nftl, int block)
305 unsigned int nb_erases, erase_mark;
306 struct nftl_uci1 uci;
307 struct erase_info *instr = &nftl->instr;
309 /* Read the Unit Control Information #1 for Wear-Leveling */
310 if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8,
311 8, &retlen, (char *)&uci) < 0)
314 erase_mark = le16_to_cpu ((uci.EraseMark | uci.EraseMark1));
315 if (erase_mark != ERASE_MARK) {
317 uci.EraseMark = cpu_to_le16(ERASE_MARK);
318 uci.EraseMark1 = cpu_to_le16(ERASE_MARK);
319 uci.WearInfo = cpu_to_le32(0);
322 memset(instr, 0, sizeof(struct erase_info));
324 /* XXX: use async erase interface, XXX: test return code */
325 instr->mtd = nftl->mbd.mtd;
326 instr->addr = block * nftl->EraseSize;
327 instr->len = nftl->EraseSize;
328 MTD_ERASE(nftl->mbd.mtd, instr);
330 if (instr->state == MTD_ERASE_FAILED) {
331 printk("Error while formatting block %d\n", block);
335 /* increase and write Wear-Leveling info */
336 nb_erases = le32_to_cpu(uci.WearInfo);
339 /* wrap (almost impossible with current flashs) or free block */
343 /* check the "freeness" of Erase Unit before updating metadata
344 * FixMe: is this check really necessary ? since we have check the
345 * return code after the erase operation. */
346 if (check_free_sectors(nftl, instr->addr, nftl->EraseSize, 1) != 0)
349 uci.WearInfo = le32_to_cpu(nb_erases);
350 if (MTD_WRITEOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
351 &retlen, (char *)&uci) < 0)
355 /* could not format, update the bad block table (caller is responsible
356 for setting the ReplUnitTable to BLOCK_RESERVED on failure) */
357 nftl->mbd.mtd->block_markbad(nftl->mbd.mtd, instr->addr);
361 /* check_sectors_in_chain: Check that each sector of a Virtual Unit Chain is correct.
362 * Mark as 'IGNORE' each incorrect sector. This check is only done if the chain
363 * was being folded when NFTL was interrupted.
365 * The check_free_sectors in this function is neceressary. There is a possible
366 * situation that after writing the Data area, the Block Control Information is
367 * not updated according (due to power failure or something) which leaves the block
368 * in an umconsistent state. So we have to check if a block is really FREE in this
370 static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_block)
372 unsigned int block, i, status;
374 int sectors_per_block;
377 sectors_per_block = nftl->EraseSize / SECTORSIZE;
380 for (i = 0; i < sectors_per_block; i++) {
381 if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + i * SECTORSIZE,
382 8, &retlen, (char *)&bci) < 0)
383 status = SECTOR_IGNORE;
385 status = bci.Status | bci.Status1;
389 /* verify that the sector is really free. If not, mark
391 if (memcmpb(&bci, 0xff, 8) != 0 ||
392 check_free_sectors(nftl, block * nftl->EraseSize + i * SECTORSIZE,
393 SECTORSIZE, 0) != 0) {
394 printk("Incorrect free sector %d in block %d: "
395 "marking it as ignored\n",
398 /* sector not free actually : mark it as SECTOR_IGNORE */
399 bci.Status = SECTOR_IGNORE;
400 bci.Status1 = SECTOR_IGNORE;
401 MTD_WRITEOOB(nftl->mbd.mtd,
402 block * nftl->EraseSize + i * SECTORSIZE,
403 8, &retlen, (char *)&bci);
411 /* proceed to next Erase Unit on the chain */
412 block = nftl->ReplUnitTable[block];
413 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
414 printk("incorrect ReplUnitTable[] : %d\n", block);
415 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
420 /* calc_chain_lenght: Walk through a Virtual Unit Chain and estimate chain length */
421 static int calc_chain_length(struct NFTLrecord *nftl, unsigned int first_block)
423 unsigned int length = 0, block = first_block;
427 /* avoid infinite loops, although this is guaranted not to
428 happen because of the previous checks */
429 if (length >= nftl->nb_blocks) {
430 printk("nftl: length too long %d !\n", length);
434 block = nftl->ReplUnitTable[block];
435 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
436 printk("incorrect ReplUnitTable[] : %d\n", block);
437 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
443 /* format_chain: Format an invalid Virtual Unit chain. It frees all the Erase Units in a
444 * Virtual Unit Chain, i.e. all the units are disconnected.
446 * It is not stricly correct to begin from the first block of the chain because
447 * if we stop the code, we may see again a valid chain if there was a first_block
448 * flag in a block inside it. But is it really a problem ?
450 * FixMe: Figure out what the last statesment means. What if power failure when we are
451 * in the for (;;) loop formatting blocks ??
453 static void format_chain(struct NFTLrecord *nftl, unsigned int first_block)
455 unsigned int block = first_block, block1;
457 printk("Formatting chain at block %d\n", first_block);
460 block1 = nftl->ReplUnitTable[block];
462 printk("Formatting block %d\n", block);
463 if (NFTL_formatblock(nftl, block) < 0) {
464 /* cannot format !!!! Mark it as Bad Unit */
465 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
467 nftl->ReplUnitTable[block] = BLOCK_FREE;
470 /* goto next block on the chain */
473 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
474 printk("incorrect ReplUnitTable[] : %d\n", block);
475 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
480 /* check_and_mark_free_block: Verify that a block is free in the NFTL sense (valid erase mark) or
481 * totally free (only 0xff).
483 * Definition: Free Erase Unit -- A properly erased/formatted Free Erase Unit should have meet the
486 static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
489 unsigned int erase_mark;
492 /* check erase mark. */
493 if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
494 &retlen, (char *)&h1) < 0)
497 erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
498 if (erase_mark != ERASE_MARK) {
499 /* if no erase mark, the block must be totally free. This is
500 possible in two cases : empty filsystem or interrupted erase (very unlikely) */
501 if (check_free_sectors (nftl, block * nftl->EraseSize, nftl->EraseSize, 1) != 0)
504 /* free block : write erase mark */
505 h1.EraseMark = cpu_to_le16(ERASE_MARK);
506 h1.EraseMark1 = cpu_to_le16(ERASE_MARK);
507 h1.WearInfo = cpu_to_le32(0);
508 if (MTD_WRITEOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
509 &retlen, (char *)&h1) < 0)
513 /* if erase mark present, need to skip it when doing check */
514 for (i = 0; i < nftl->EraseSize; i += SECTORSIZE) {
515 /* check free sector */
516 if (check_free_sectors (nftl, block * nftl->EraseSize + i,
520 if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + i,
521 16, &retlen, buf) < 0)
523 if (i == SECTORSIZE) {
524 /* skip erase mark */
525 if (memcmpb(buf, 0xff, 8))
528 if (memcmpb(buf, 0xff, 16))
538 /* get_fold_mark: Read fold mark from Unit Control Information #2, we use FOLD_MARK_IN_PROGRESS
539 * to indicate that we are in the progression of a Virtual Unit Chain folding. If the UCI #2
540 * is FOLD_MARK_IN_PROGRESS when mounting the NFTL, the (previous) folding process is interrupted
541 * for some reason. A clean up/check of the VUC is neceressary in this case.
543 * WARNING: return 0 if read error
545 static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block)
547 struct nftl_uci2 uci;
550 if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
551 8, &retlen, (char *)&uci) < 0)
554 return le16_to_cpu((uci.FoldMark | uci.FoldMark1));
557 int NFTL_mount(struct NFTLrecord *s)
560 unsigned int first_logical_block, logical_block, rep_block, nb_erases, erase_mark;
561 unsigned int block, first_block, is_first_block;
562 int chain_length, do_format_chain;
567 /* search for NFTL MediaHeader and Spare NFTL Media Header */
568 if (find_boot_record(s) < 0) {
569 printk("Could not find valid boot record\n");
573 /* init the logical to physical table */
574 for (i = 0; i < s->nb_blocks; i++) {
575 s->EUNtable[i] = BLOCK_NIL;
578 /* first pass : explore each block chain */
579 first_logical_block = 0;
580 for (first_block = 0; first_block < s->nb_blocks; first_block++) {
581 /* if the block was not already explored, we can look at it */
582 if (s->ReplUnitTable[first_block] == BLOCK_NOTEXPLORED) {
588 /* read the block header. If error, we format the chain */
589 if (MTD_READOOB(s->mbd.mtd, block * s->EraseSize + 8, 8,
590 &retlen, (char *)&h0) < 0 ||
591 MTD_READOOB(s->mbd.mtd, block * s->EraseSize + SECTORSIZE + 8, 8,
592 &retlen, (char *)&h1) < 0) {
593 s->ReplUnitTable[block] = BLOCK_NIL;
598 logical_block = le16_to_cpu ((h0.VirtUnitNum | h0.SpareVirtUnitNum));
599 rep_block = le16_to_cpu ((h0.ReplUnitNum | h0.SpareReplUnitNum));
600 nb_erases = le32_to_cpu (h1.WearInfo);
601 erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
603 is_first_block = !(logical_block >> 15);
604 logical_block = logical_block & 0x7fff;
606 /* invalid/free block test */
607 if (erase_mark != ERASE_MARK || logical_block >= s->nb_blocks) {
608 if (chain_length == 0) {
609 /* if not currently in a chain, we can handle it safely */
610 if (check_and_mark_free_block(s, block) < 0) {
611 /* not really free: format it */
612 printk("Formatting block %d\n", block);
613 if (NFTL_formatblock(s, block) < 0) {
614 /* could not format: reserve the block */
615 s->ReplUnitTable[block] = BLOCK_RESERVED;
617 s->ReplUnitTable[block] = BLOCK_FREE;
620 /* free block: mark it */
621 s->ReplUnitTable[block] = BLOCK_FREE;
623 /* directly examine the next block. */
624 goto examine_ReplUnitTable;
626 /* the block was in a chain : this is bad. We
627 must format all the chain */
628 printk("Block %d: free but referenced in chain %d\n",
630 s->ReplUnitTable[block] = BLOCK_NIL;
636 /* we accept only first blocks here */
637 if (chain_length == 0) {
638 /* this block is not the first block in chain :
639 ignore it, it will be included in a chain
640 later, or marked as not explored */
642 goto examine_ReplUnitTable;
643 first_logical_block = logical_block;
645 if (logical_block != first_logical_block) {
646 printk("Block %d: incorrect logical block: %d expected: %d\n",
647 block, logical_block, first_logical_block);
648 /* the chain is incorrect : we must format it,
649 but we need to read it completly */
652 if (is_first_block) {
653 /* we accept that a block is marked as first
654 block while being last block in a chain
655 only if the chain is being folded */
656 if (get_fold_mark(s, block) != FOLD_MARK_IN_PROGRESS ||
657 rep_block != 0xffff) {
658 printk("Block %d: incorrectly marked as first block in chain\n",
660 /* the chain is incorrect : we must format it,
661 but we need to read it completly */
664 printk("Block %d: folding in progress - ignoring first block flag\n",
670 if (rep_block == 0xffff) {
671 /* no more blocks after */
672 s->ReplUnitTable[block] = BLOCK_NIL;
674 } else if (rep_block >= s->nb_blocks) {
675 printk("Block %d: referencing invalid block %d\n",
678 s->ReplUnitTable[block] = BLOCK_NIL;
680 } else if (s->ReplUnitTable[rep_block] != BLOCK_NOTEXPLORED) {
681 /* same problem as previous 'is_first_block' test:
682 we accept that the last block of a chain has
683 the first_block flag set if folding is in
684 progress. We handle here the case where the
685 last block appeared first */
686 if (s->ReplUnitTable[rep_block] == BLOCK_NIL &&
687 s->EUNtable[first_logical_block] == rep_block &&
688 get_fold_mark(s, first_block) == FOLD_MARK_IN_PROGRESS) {
689 /* EUNtable[] will be set after */
690 printk("Block %d: folding in progress - ignoring first block flag\n",
692 s->ReplUnitTable[block] = rep_block;
693 s->EUNtable[first_logical_block] = BLOCK_NIL;
695 printk("Block %d: referencing block %d already in another chain\n",
697 /* XXX: should handle correctly fold in progress chains */
699 s->ReplUnitTable[block] = BLOCK_NIL;
704 s->ReplUnitTable[block] = rep_block;
709 /* the chain was completely explored. Now we can decide
710 what to do with it */
711 if (do_format_chain) {
712 /* invalid chain : format it */
713 format_chain(s, first_block);
715 unsigned int first_block1, chain_to_format, chain_length1;
718 /* valid chain : get foldmark */
719 fold_mark = get_fold_mark(s, first_block);
720 if (fold_mark == 0) {
721 /* cannot get foldmark : format the chain */
722 printk("Could read foldmark at block %d\n", first_block);
723 format_chain(s, first_block);
725 if (fold_mark == FOLD_MARK_IN_PROGRESS)
726 check_sectors_in_chain(s, first_block);
728 /* now handle the case where we find two chains at the
729 same virtual address : we select the longer one,
730 because the shorter one is the one which was being
731 folded if the folding was not done in place */
732 first_block1 = s->EUNtable[first_logical_block];
733 if (first_block1 != BLOCK_NIL) {
734 /* XXX: what to do if same length ? */
735 chain_length1 = calc_chain_length(s, first_block1);
736 printk("Two chains at blocks %d (len=%d) and %d (len=%d)\n",
737 first_block1, chain_length1, first_block, chain_length);
739 if (chain_length >= chain_length1) {
740 chain_to_format = first_block1;
741 s->EUNtable[first_logical_block] = first_block;
743 chain_to_format = first_block;
745 format_chain(s, chain_to_format);
747 s->EUNtable[first_logical_block] = first_block;
752 examine_ReplUnitTable:;
755 /* second pass to format unreferenced blocks and init free block count */
757 s->LastFreeEUN = le16_to_cpu(s->MediaHdr.FirstPhysicalEUN);
759 for (block = 0; block < s->nb_blocks; block++) {
760 if (s->ReplUnitTable[block] == BLOCK_NOTEXPLORED) {
761 printk("Unreferenced block %d, formatting it\n", block);
762 if (NFTL_formatblock(s, block) < 0)
763 s->ReplUnitTable[block] = BLOCK_RESERVED;
765 s->ReplUnitTable[block] = BLOCK_FREE;
767 if (s->ReplUnitTable[block] == BLOCK_FREE) {
769 s->LastFreeEUN = block;