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