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