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