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 | */ |
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, from: block * nftl->EraseSize, SECTORSIZE, |
54 | retlen: &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(p: buf, q: "ANAND" , size: 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, offs: block * nftl->EraseSize + |
80 | SECTORSIZE + 8, len: 8, retlen: &retlen, |
81 | buf: (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(p: mh, q: buf, size: 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(n: nftl->nb_blocks, size: sizeof(u16), |
190 | GFP_KERNEL); |
191 | if (!nftl->EUNtable) |
192 | return -ENOMEM; |
193 | |
194 | nftl->ReplUnitTable = kmalloc_array(n: nftl->nb_blocks, |
195 | size: sizeof(u16), |
196 | GFP_KERNEL); |
197 | if (!nftl->ReplUnitTable) { |
198 | kfree(objp: 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(mtd: nftl->mbd.mtd, |
236 | ofs: 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 | |
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 */ |
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, from: address, SECTORSIZE, retlen: &retlen, buf)) |
274 | goto out; |
275 | if (memcmpb(a: buf, c: 0xff, SECTORSIZE) != 0) |
276 | goto out; |
277 | |
278 | if (check_oob) { |
279 | if(nftl_read_oob(mtd, offs: address, len: mtd->oobsize, |
280 | retlen: &retlen, buf: &buf[SECTORSIZE]) < 0) |
281 | goto out; |
282 | if (memcmpb(a: buf + SECTORSIZE, c: 0xff, n: mtd->oobsize) != 0) |
283 | goto out; |
284 | } |
285 | address += SECTORSIZE; |
286 | } |
287 | |
288 | ret = 0; |
289 | |
290 | out: |
291 | kfree(objp: 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 | */ |
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, offs: block * nftl->EraseSize + SECTORSIZE + 8, |
312 | len: 8, retlen: &retlen, buf: (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, address: instr->addr, len: nftl->EraseSize, check_oob: 1) != 0) |
346 | goto fail; |
347 | |
348 | uci.WearInfo = le32_to_cpu(nb_erases); |
349 | if (nftl_write_oob(mtd, offs: block * nftl->EraseSize + SECTORSIZE + |
350 | 8, len: 8, retlen: &retlen, buf: (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(mtd: nftl->mbd.mtd, ofs: 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. */ |
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 | offs: block * nftl->EraseSize + i * SECTORSIZE, |
383 | len: 8, retlen: &retlen, buf: (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(a: &bci, c: 0xff, n: 8) != 0 || |
393 | check_free_sectors(nftl, address: block * nftl->EraseSize + i * SECTORSIZE, |
394 | SECTORSIZE, check_oob: 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, offs: block * |
403 | nftl->EraseSize + |
404 | i * SECTORSIZE, len: 8, |
405 | retlen: &retlen, buf: (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 */ |
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 | */ |
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. */ |
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, offs: block * nftl->EraseSize + SECTORSIZE + 8, len: 8, |
497 | retlen: &retlen, buf: (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, address: block * nftl->EraseSize, len: nftl->EraseSize, check_oob: 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 | offs: block * nftl->EraseSize + SECTORSIZE + 8, len: 8, |
513 | retlen: &retlen, buf: (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 | */ |
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, offs: block * nftl->EraseSize + 2 * SECTORSIZE + 8, |
556 | len: 8, retlen: &retlen, buf: (char *)&uci) < 0) |
557 | return 0; |
558 | |
559 | return le16_to_cpu((uci.FoldMark | uci.FoldMark1)); |
560 | } |
561 | |
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(nftl: 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 | offs: block * s->EraseSize + 8, len: 8, |
597 | retlen: &retlen, buf: (char *)&h0) < 0 || |
598 | nftl_read_oob(mtd, |
599 | offs: block * s->EraseSize + |
600 | SECTORSIZE + 8, len: 8, |
601 | retlen: &retlen, buf: (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(nftl: s, block) < 0) { |
619 | /* not really free: format it */ |
620 | printk("Formatting block %d\n" , block); |
621 | if (NFTL_formatblock(nftl: 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(nftl: 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(nftl: s, block: 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(nftl: 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(nftl: s, block: 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(nftl: s, first_block); |
732 | } else { |
733 | if (fold_mark == FOLD_MARK_IN_PROGRESS) |
734 | check_sectors_in_chain(nftl: 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(nftl: s, first_block: 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(nftl: s, first_block: 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(nftl: 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 | |