projects / openwrt.git / blob
? search:


5c70e79a058d050e90224ac0ef80dcb1180235ab
[openwrt.git] / target / linux / generic-2.6 / patches-2.6.28 / 511-yaffs-cvs-2009-04-24.patch
1 --- a/fs/yaffs2/devextras.h
2 +++ b/fs/yaffs2/devextras.h
3 @@ -14,194 +14,135 @@
4 */
5
6 /*
7 - * This file is just holds extra declarations used during development.
8 - * Most of these are from kernel includes placed here so we can use them in
9 - * applications.
10 + * This file is just holds extra declarations of macros that would normally
11 + * be providesd in the Linux kernel. These macros have been written from
12 + * scratch but are functionally equivalent to the Linux ones.
13 *
14 */
15
16 #ifndef __EXTRAS_H__
17 #define __EXTRAS_H__
18
19 -#if defined WIN32
20 -#define __inline__ __inline
21 -#define new newHack
22 -#endif
23 -
24 -#if !(defined __KERNEL__) || (defined WIN32)
25
26 -/* User space defines */
27 +#if !(defined __KERNEL__)
28
29 +/* Definition of types */
30 typedef unsigned char __u8;
31 typedef unsigned short __u16;
32 typedef unsigned __u32;
33
34 +#endif
35 +
36 /*
37 - * Simple doubly linked list implementation.
38 - *
39 - * Some of the internal functions ("__xxx") are useful when
40 - * manipulating whole lists rather than single entries, as
41 - * sometimes we already know the next/prev entries and we can
42 - * generate better code by using them directly rather than
43 - * using the generic single-entry routines.
44 + * This is a simple doubly linked list implementation that matches the
45 + * way the Linux kernel doubly linked list implementation works.
46 */
47
48 -#define prefetch(x) 1
49 -
50 -struct list_head {
51 - struct list_head *next, *prev;
52 +struct ylist_head {
53 + struct ylist_head *next; /* next in chain */
54 + struct ylist_head *prev; /* previous in chain */
55 };
56
57 -#define LIST_HEAD_INIT(name) { &(name), &(name) }
58
59 -#define LIST_HEAD(name) \
60 - struct list_head name = LIST_HEAD_INIT(name)
61 +/* Initialise a static list */
62 +#define YLIST_HEAD(name) \
63 +struct ylist_head name = { &(name), &(name)}
64 +
65
66 -#define INIT_LIST_HEAD(ptr) do { \
67 - (ptr)->next = (ptr); (ptr)->prev = (ptr); \
68 +
69 +/* Initialise a list head to an empty list */
70 +#define YINIT_LIST_HEAD(p) \
71 +do { \
72 + (p)->next = (p);\
73 + (p)->prev = (p); \
74 } while (0)
75
76 -/*
77 - * Insert a new entry between two known consecutive entries.
78 - *
79 - * This is only for internal list manipulation where we know
80 - * the prev/next entries already!
81 - */
82 -static __inline__ void __list_add(struct list_head *new,
83 - struct list_head *prev,
84 - struct list_head *next)
85 -{
86 - next->prev = new;
87 - new->next = next;
88 - new->prev = prev;
89 - prev->next = new;
90 -}
91
92 -/**
93 - * list_add - add a new entry
94 - * @new: new entry to be added
95 - * @head: list head to add it after
96 - *
97 - * Insert a new entry after the specified head.
98 - * This is good for implementing stacks.
99 - */
100 -static __inline__ void list_add(struct list_head *new, struct list_head *head)
101 +/* Add an element to a list */
102 +static __inline__ void ylist_add(struct ylist_head *newEntry,
103 + struct ylist_head *list)
104 {
105 - __list_add(new, head, head->next);
106 -}
107 + struct ylist_head *listNext = list->next;
108 +
109 + list->next = newEntry;
110 + newEntry->prev = list;
111 + newEntry->next = listNext;
112 + listNext->prev = newEntry;
113
114 -/**
115 - * list_add_tail - add a new entry
116 - * @new: new entry to be added
117 - * @head: list head to add it before
118 - *
119 - * Insert a new entry before the specified head.
120 - * This is useful for implementing queues.
121 - */
122 -static __inline__ void list_add_tail(struct list_head *new,
123 - struct list_head *head)
124 -{
125 - __list_add(new, head->prev, head);
126 }
127
128 -/*
129 - * Delete a list entry by making the prev/next entries
130 - * point to each other.
131 - *
132 - * This is only for internal list manipulation where we know
133 - * the prev/next entries already!
134 - */
135 -static __inline__ void __list_del(struct list_head *prev,
136 - struct list_head *next)
137 +static __inline__ void ylist_add_tail(struct ylist_head *newEntry,
138 + struct ylist_head *list)
139 {
140 - next->prev = prev;
141 - prev->next = next;
142 + struct ylist_head *listPrev = list->prev;
143 +
144 + list->prev = newEntry;
145 + newEntry->next = list;
146 + newEntry->prev = listPrev;
147 + listPrev->next = newEntry;
148 +
149 }
150
151 -/**
152 - * list_del - deletes entry from list.
153 - * @entry: the element to delete from the list.
154 - * Note: list_empty on entry does not return true after this, the entry is
155 - * in an undefined state.
156 - */
157 -static __inline__ void list_del(struct list_head *entry)
158 +
159 +/* Take an element out of its current list, with or without
160 + * reinitialising the links.of the entry*/
161 +static __inline__ void ylist_del(struct ylist_head *entry)
162 {
163 - __list_del(entry->prev, entry->next);
164 + struct ylist_head *listNext = entry->next;
165 + struct ylist_head *listPrev = entry->prev;
166 +
167 + listNext->prev = listPrev;
168 + listPrev->next = listNext;
169 +
170 }
171
172 -/**
173 - * list_del_init - deletes entry from list and reinitialize it.
174 - * @entry: the element to delete from the list.
175 - */
176 -static __inline__ void list_del_init(struct list_head *entry)
177 +static __inline__ void ylist_del_init(struct ylist_head *entry)
178 {
179 - __list_del(entry->prev, entry->next);
180 - INIT_LIST_HEAD(entry);
181 + ylist_del(entry);
182 + entry->next = entry->prev = entry;
183 }
184
185 -/**
186 - * list_empty - tests whether a list is empty
187 - * @head: the list to test.
188 - */
189 -static __inline__ int list_empty(struct list_head *head)
190 +
191 +/* Test if the list is empty */
192 +static __inline__ int ylist_empty(struct ylist_head *entry)
193 {
194 - return head->next == head;
195 + return (entry->next == entry);
196 }
197
198 -/**
199 - * list_splice - join two lists
200 - * @list: the new list to add.
201 - * @head: the place to add it in the first list.
202 +
203 +/* ylist_entry takes a pointer to a list entry and offsets it to that
204 + * we can find a pointer to the object it is embedded in.
205 */
206 -static __inline__ void list_splice(struct list_head *list,
207 - struct list_head *head)
208 -{
209 - struct list_head *first = list->next;
210
211 - if (first != list) {
212 - struct list_head *last = list->prev;
213 - struct list_head *at = head->next;
214 -
215 - first->prev = head;
216 - head->next = first;
217 -
218 - last->next = at;
219 - at->prev = last;
220 - }
221 -}
222
223 -/**
224 - * list_entry - get the struct for this entry
225 - * @ptr: the &struct list_head pointer.
226 - * @type: the type of the struct this is embedded in.
227 - * @member: the name of the list_struct within the struct.
228 - */
229 -#define list_entry(ptr, type, member) \
230 - ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
231 -
232 -/**
233 - * list_for_each - iterate over a list
234 - * @pos: the &struct list_head to use as a loop counter.
235 - * @head: the head for your list.
236 - */
237 -#define list_for_each(pos, head) \
238 - for (pos = (head)->next, prefetch(pos->next); pos != (head); \
239 - pos = pos->next, prefetch(pos->next))
240 -
241 -/**
242 - * list_for_each_safe - iterate over a list safe against removal
243 - * of list entry
244 - * @pos: the &struct list_head to use as a loop counter.
245 - * @n: another &struct list_head to use as temporary storage
246 - * @head: the head for your list.
247 - */
248 -#define list_for_each_safe(pos, n, head) \
249 - for (pos = (head)->next, n = pos->next; pos != (head); \
250 - pos = n, n = pos->next)
251 +#define ylist_entry(entry, type, member) \
252 + ((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member)))
253
254 -/*
255 - * File types
256 +
257 +/* ylist_for_each and list_for_each_safe iterate over lists.
258 + * ylist_for_each_safe uses temporary storage to make the list delete safe
259 */
260 +
261 +#define ylist_for_each(itervar, list) \
262 + for (itervar = (list)->next; itervar != (list); itervar = itervar->next)
263 +
264 +#define ylist_for_each_safe(itervar, saveVar, list) \
265 + for (itervar = (list)->next, saveVar = (list)->next->next; \
266 + itervar != (list); itervar = saveVar, saveVar = saveVar->next)
267 +
268 +
269 +#if !(defined __KERNEL__)
270 +
271 +
272 +#ifndef WIN32
273 +#include <sys/stat.h>
274 +#endif
275 +
276 +
277 +#ifdef CONFIG_YAFFS_PROVIDE_DEFS
278 +/* File types */
279 +
280 +
281 #define DT_UNKNOWN 0
282 #define DT_FIFO 1
283 #define DT_CHR 2
284 @@ -212,6 +153,7 @@ static __inline__ void list_splice(struc
285 #define DT_SOCK 12
286 #define DT_WHT 14
287
288 +
289 #ifndef WIN32
290 #include <sys/stat.h>
291 #endif
292 @@ -227,10 +169,6 @@ static __inline__ void list_splice(struc
293 #define ATTR_ATIME 16
294 #define ATTR_MTIME 32
295 #define ATTR_CTIME 64
296 -#define ATTR_ATIME_SET 128
297 -#define ATTR_MTIME_SET 256
298 -#define ATTR_FORCE 512 /* Not a change, but a change it */
299 -#define ATTR_ATTR_FLAG 1024
300
301 struct iattr {
302 unsigned int ia_valid;
303 @@ -244,21 +182,15 @@ struct iattr {
304 unsigned int ia_attr_flags;
305 };
306
307 -#define KERN_DEBUG
308 +#endif
309
310 #else
311
312 -#ifndef WIN32
313 #include <linux/types.h>
314 -#include <linux/list.h>
315 #include <linux/fs.h>
316 #include <linux/stat.h>
317 -#endif
318
319 #endif
320
321 -#if defined WIN32
322 -#undef new
323 -#endif
324
325 #endif
326 --- a/fs/yaffs2/Kconfig
327 +++ b/fs/yaffs2/Kconfig
328 @@ -5,7 +5,7 @@
329 config YAFFS_FS
330 tristate "YAFFS2 file system support"
331 default n
332 - depends on MTD
333 + depends on MTD_BLOCK
334 select YAFFS_YAFFS1
335 select YAFFS_YAFFS2
336 help
337 @@ -43,7 +43,8 @@ config YAFFS_9BYTE_TAGS
338 format that you need to continue to support. New data written
339 also uses the older-style format. Note: Use of this option
340 generally requires that MTD's oob layout be adjusted to use the
341 - older-style format. See notes on tags formats and MTD versions.
342 + older-style format. See notes on tags formats and MTD versions
343 + in yaffs_mtdif1.c.
344
345 If unsure, say N.
346
347 @@ -109,26 +110,6 @@ config YAFFS_DISABLE_LAZY_LOAD
348
349 If unsure, say N.
350
351 -config YAFFS_CHECKPOINT_RESERVED_BLOCKS
352 - int "Reserved blocks for checkpointing"
353 - depends on YAFFS_YAFFS2
354 - default 10
355 - help
356 - Give the number of Blocks to reserve for checkpointing.
357 - Checkpointing saves the state at unmount so that mounting is
358 - much faster as a scan of all the flash to regenerate this state
359 - is not needed. These Blocks are reserved per partition, so if
360 - you have very small partitions the default (10) may be a mess
361 - for you. You can set this value to 0, but that does not mean
362 - checkpointing is disabled at all. There only won't be any
363 - specially reserved blocks for checkpointing, so if there is
364 - enough free space on the filesystem, it will be used for
365 - checkpointing.
366 -
367 - If unsure, leave at default (10), but don't wonder if there are
368 - always 2MB used on your large page device partition (10 x 2k
369 - pagesize). When using small partitions or when being very small
370 - on space, you probably want to set this to zero.
371
372 config YAFFS_DISABLE_WIDE_TNODES
373 bool "Turn off wide tnodes"
374 --- a/fs/yaffs2/Makefile
375 +++ b/fs/yaffs2/Makefile
376 @@ -5,7 +5,6 @@
377 obj-$(CONFIG_YAFFS_FS) += yaffs.o
378
379 yaffs-y := yaffs_ecc.o yaffs_fs.o yaffs_guts.o yaffs_checkptrw.o
380 -yaffs-y += yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
381 +yaffs-y += yaffs_packedtags1.o yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
382 yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o
383 -yaffs-y += yaffs_mtdif1.o yaffs_packedtags1.o
384 -yaffs-y += yaffs_mtdif.o yaffs_mtdif2.o
385 +yaffs-y += yaffs_mtdif.o yaffs_mtdif1.o yaffs_mtdif2.o
386 --- a/fs/yaffs2/moduleconfig.h
387 +++ b/fs/yaffs2/moduleconfig.h
388 @@ -27,12 +27,12 @@
389
390 /* Default: Not selected */
391 /* Meaning: Yaffs does its own ECC, rather than using MTD ECC */
392 -//#define CONFIG_YAFFS_DOES_ECC
393 +/* #define CONFIG_YAFFS_DOES_ECC */
394
395 /* Default: Not selected */
396 /* Meaning: ECC byte order is 'wrong'. Only meaningful if */
397 /* CONFIG_YAFFS_DOES_ECC is set */
398 -//#define CONFIG_YAFFS_ECC_WRONG_ORDER
399 +/* #define CONFIG_YAFFS_ECC_WRONG_ORDER */
400
401 /* Default: Selected */
402 /* Meaning: Disables testing whether chunks are erased before writing to them*/
403 @@ -54,11 +54,11 @@ that you need to continue to support. N
404 older-style format.
405 Note: Use of this option generally requires that MTD's oob layout be
406 adjusted to use the older-style format. See notes on tags formats and
407 -MTD versions.
408 +MTD versions in yaffs_mtdif1.c.
409 */
410 /* Default: Not selected */
411 /* Meaning: Use older-style on-NAND data format with pageStatus byte */
412 -#define CONFIG_YAFFS_9BYTE_TAGS
413 +/* #define CONFIG_YAFFS_9BYTE_TAGS */
414
415 #endif /* YAFFS_OUT_OF_TREE */
416
417 --- a/fs/yaffs2/yaffs_checkptrw.c
418 +++ b/fs/yaffs2/yaffs_checkptrw.c
419 @@ -12,48 +12,43 @@
420 */
421
422 const char *yaffs_checkptrw_c_version =
423 - "$Id: yaffs_checkptrw.c,v 1.14 2007-05-15 20:07:40 charles Exp $";
424 + "$Id: yaffs_checkptrw.c,v 1.18 2009-03-06 17:20:49 wookey Exp $";
425
426
427 #include "yaffs_checkptrw.h"
428 -
429 +#include "yaffs_getblockinfo.h"
430
431 static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
432 {
433 -
434 int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
435
436 T(YAFFS_TRACE_CHECKPOINT,
437 (TSTR("checkpt blocks available = %d" TENDSTR),
438 blocksAvailable));
439
440 -
441 return (blocksAvailable <= 0) ? 0 : 1;
442 }
443
444
445 static int yaffs_CheckpointErase(yaffs_Device *dev)
446 {
447 -
448 int i;
449
450 -
451 - if(!dev->eraseBlockInNAND)
452 + if (!dev->eraseBlockInNAND)
453 return 0;
454 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
455 - dev->internalStartBlock,dev->internalEndBlock));
456 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR),
457 + dev->internalStartBlock, dev->internalEndBlock));
458
459 - for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
460 - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
461 - if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
462 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i));
463 - if(dev->eraseBlockInNAND(dev,i- dev->blockOffset /* realign */)){
464 + for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
465 + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
466 + if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
467 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i));
468 + if (dev->eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) {
469 bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
470 dev->nErasedBlocks++;
471 dev->nFreeChunks += dev->nChunksPerBlock;
472 - }
473 - else {
474 - dev->markNANDBlockBad(dev,i);
475 + } else {
476 + dev->markNANDBlockBad(dev, i);
477 bi->blockState = YAFFS_BLOCK_STATE_DEAD;
478 }
479 }
480 @@ -71,23 +66,23 @@ static void yaffs_CheckpointFindNextEras
481 int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
482 T(YAFFS_TRACE_CHECKPOINT,
483 (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
484 - dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
485 + dev->nErasedBlocks, dev->nReservedBlocks, blocksAvailable, dev->checkpointNextBlock));
486
487 - if(dev->checkpointNextBlock >= 0 &&
488 - dev->checkpointNextBlock <= dev->internalEndBlock &&
489 - blocksAvailable > 0){
490 -
491 - for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
492 - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
493 - if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
494 + if (dev->checkpointNextBlock >= 0 &&
495 + dev->checkpointNextBlock <= dev->internalEndBlock &&
496 + blocksAvailable > 0) {
497 +
498 + for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) {
499 + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
500 + if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) {
501 dev->checkpointNextBlock = i + 1;
502 dev->checkpointCurrentBlock = i;
503 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i));
504 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i));
505 return;
506 }
507 }
508 }
509 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
510 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR)));
511
512 dev->checkpointNextBlock = -1;
513 dev->checkpointCurrentBlock = -1;
514 @@ -98,30 +93,31 @@ static void yaffs_CheckpointFindNextChec
515 int i;
516 yaffs_ExtendedTags tags;
517
518 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR),
519 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR),
520 dev->blocksInCheckpoint, dev->checkpointNextBlock));
521
522 - if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
523 - for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
524 + if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
525 + for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) {
526 int chunk = i * dev->nChunksPerBlock;
527 int realignedChunk = chunk - dev->chunkOffset;
528
529 - dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
530 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
531 - i, tags.objectId,tags.sequenceNumber,tags.eccResult));
532 + dev->readChunkWithTagsFromNAND(dev, realignedChunk,
533 + NULL, &tags);
534 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
535 + i, tags.objectId, tags.sequenceNumber, tags.eccResult));
536
537 - if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
538 + if (tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) {
539 /* Right kind of block */
540 dev->checkpointNextBlock = tags.objectId;
541 dev->checkpointCurrentBlock = i;
542 dev->checkpointBlockList[dev->blocksInCheckpoint] = i;
543 dev->blocksInCheckpoint++;
544 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i));
545 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i));
546 return;
547 }
548 }
549
550 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR)));
551 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR)));
552
553 dev->checkpointNextBlock = -1;
554 dev->checkpointCurrentBlock = -1;
555 @@ -133,17 +129,17 @@ int yaffs_CheckpointOpen(yaffs_Device *d
556
557 /* Got the functions we need? */
558 if (!dev->writeChunkWithTagsToNAND ||
559 - !dev->readChunkWithTagsFromNAND ||
560 - !dev->eraseBlockInNAND ||
561 - !dev->markNANDBlockBad)
562 + !dev->readChunkWithTagsFromNAND ||
563 + !dev->eraseBlockInNAND ||
564 + !dev->markNANDBlockBad)
565 return 0;
566
567 - if(forWriting && !yaffs_CheckpointSpaceOk(dev))
568 + if (forWriting && !yaffs_CheckpointSpaceOk(dev))
569 return 0;
570
571 - if(!dev->checkpointBuffer)
572 - dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
573 - if(!dev->checkpointBuffer)
574 + if (!dev->checkpointBuffer)
575 + dev->checkpointBuffer = YMALLOC_DMA(dev->totalBytesPerChunk);
576 + if (!dev->checkpointBuffer)
577 return 0;
578
579
580 @@ -159,12 +155,10 @@ int yaffs_CheckpointOpen(yaffs_Device *d
581 dev->checkpointNextBlock = dev->internalStartBlock;
582
583 /* Erase all the blocks in the checkpoint area */
584 - if(forWriting){
585 - memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
586 + if (forWriting) {
587 + memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk);
588 dev->checkpointByteOffset = 0;
589 return yaffs_CheckpointErase(dev);
590 -
591 -
592 } else {
593 int i;
594 /* Set to a value that will kick off a read */
595 @@ -174,7 +168,7 @@ int yaffs_CheckpointOpen(yaffs_Device *d
596 dev->blocksInCheckpoint = 0;
597 dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2;
598 dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks);
599 - for(i = 0; i < dev->checkpointMaxBlocks; i++)
600 + for (i = 0; i < dev->checkpointMaxBlocks; i++)
601 dev->checkpointBlockList[i] = -1;
602 }
603
604 @@ -191,18 +185,17 @@ int yaffs_GetCheckpointSum(yaffs_Device
605
606 static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
607 {
608 -
609 int chunk;
610 int realignedChunk;
611
612 yaffs_ExtendedTags tags;
613
614 - if(dev->checkpointCurrentBlock < 0){
615 + if (dev->checkpointCurrentBlock < 0) {
616 yaffs_CheckpointFindNextErasedBlock(dev);
617 dev->checkpointCurrentChunk = 0;
618 }
619
620 - if(dev->checkpointCurrentBlock < 0)
621 + if (dev->checkpointCurrentBlock < 0)
622 return 0;
623
624 tags.chunkDeleted = 0;
625 @@ -210,10 +203,10 @@ static int yaffs_CheckpointFlushBuffer(y
626 tags.chunkId = dev->checkpointPageSequence + 1;
627 tags.sequenceNumber = YAFFS_SEQUENCE_CHECKPOINT_DATA;
628 tags.byteCount = dev->nDataBytesPerChunk;
629 - if(dev->checkpointCurrentChunk == 0){
630 + if (dev->checkpointCurrentChunk == 0) {
631 /* First chunk we write for the block? Set block state to
632 checkpoint */
633 - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock);
634 + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointCurrentBlock);
635 bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
636 dev->blocksInCheckpoint++;
637 }
638 @@ -221,28 +214,29 @@ static int yaffs_CheckpointFlushBuffer(y
639 chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
640
641
642 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
643 - chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
644 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
645 + chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk, tags.objectId, tags.chunkId));
646
647 realignedChunk = chunk - dev->chunkOffset;
648
649 - dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
650 + dev->writeChunkWithTagsToNAND(dev, realignedChunk,
651 + dev->checkpointBuffer, &tags);
652 dev->checkpointByteOffset = 0;
653 dev->checkpointPageSequence++;
654 dev->checkpointCurrentChunk++;
655 - if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
656 + if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock) {
657 dev->checkpointCurrentChunk = 0;
658 dev->checkpointCurrentBlock = -1;
659 }
660 - memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
661 + memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk);
662
663 return 1;
664 }
665
666
667 -int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
668 +int yaffs_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes)
669 {
670 - int i=0;
671 + int i = 0;
672 int ok = 1;
673
674
675 @@ -250,17 +244,14 @@ int yaffs_CheckpointWrite(yaffs_Device *
676
677
678
679 - if(!dev->checkpointBuffer)
680 + if (!dev->checkpointBuffer)
681 return 0;
682
683 - if(!dev->checkpointOpenForWrite)
684 + if (!dev->checkpointOpenForWrite)
685 return -1;
686
687 - while(i < nBytes && ok) {
688 -
689 -
690 -
691 - dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
692 + while (i < nBytes && ok) {
693 + dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes;
694 dev->checkpointSum += *dataBytes;
695 dev->checkpointXor ^= *dataBytes;
696
697 @@ -270,18 +261,17 @@ int yaffs_CheckpointWrite(yaffs_Device *
698 dev->checkpointByteCount++;
699
700
701 - if(dev->checkpointByteOffset < 0 ||
702 + if (dev->checkpointByteOffset < 0 ||
703 dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
704 ok = yaffs_CheckpointFlushBuffer(dev);
705 -
706 }
707
708 - return i;
709 + return i;
710 }
711
712 int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
713 {
714 - int i=0;
715 + int i = 0;
716 int ok = 1;
717 yaffs_ExtendedTags tags;
718
719 @@ -291,52 +281,54 @@ int yaffs_CheckpointRead(yaffs_Device *d
720
721 __u8 *dataBytes = (__u8 *)data;
722
723 - if(!dev->checkpointBuffer)
724 + if (!dev->checkpointBuffer)
725 return 0;
726
727 - if(dev->checkpointOpenForWrite)
728 + if (dev->checkpointOpenForWrite)
729 return -1;
730
731 - while(i < nBytes && ok) {
732 + while (i < nBytes && ok) {
733
734
735 - if(dev->checkpointByteOffset < 0 ||
736 - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
737 + if (dev->checkpointByteOffset < 0 ||
738 + dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
739
740 - if(dev->checkpointCurrentBlock < 0){
741 + if (dev->checkpointCurrentBlock < 0) {
742 yaffs_CheckpointFindNextCheckpointBlock(dev);
743 dev->checkpointCurrentChunk = 0;
744 }
745
746 - if(dev->checkpointCurrentBlock < 0)
747 + if (dev->checkpointCurrentBlock < 0)
748 ok = 0;
749 else {
750 -
751 - chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
752 - dev->checkpointCurrentChunk;
753 + chunk = dev->checkpointCurrentBlock *
754 + dev->nChunksPerBlock +
755 + dev->checkpointCurrentChunk;
756
757 realignedChunk = chunk - dev->chunkOffset;
758
759 - /* read in the next chunk */
760 - /* printf("read checkpoint page %d\n",dev->checkpointPage); */
761 - dev->readChunkWithTagsFromNAND(dev, realignedChunk,
762 - dev->checkpointBuffer,
763 - &tags);
764 -
765 - if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
766 - tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
767 - ok = 0;
768 + /* read in the next chunk */
769 + /* printf("read checkpoint page %d\n",dev->checkpointPage); */
770 + dev->readChunkWithTagsFromNAND(dev,
771 + realignedChunk,
772 + dev->checkpointBuffer,
773 + &tags);
774 +
775 + if (tags.chunkId != (dev->checkpointPageSequence + 1) ||
776 + tags.eccResult > YAFFS_ECC_RESULT_FIXED ||
777 + tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
778 + ok = 0;
779
780 dev->checkpointByteOffset = 0;
781 dev->checkpointPageSequence++;
782 dev->checkpointCurrentChunk++;
783
784 - if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
785 + if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
786 dev->checkpointCurrentBlock = -1;
787 }
788 }
789
790 - if(ok){
791 + if (ok) {
792 *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
793 dev->checkpointSum += *dataBytes;
794 dev->checkpointXor ^= *dataBytes;
795 @@ -353,17 +345,17 @@ int yaffs_CheckpointRead(yaffs_Device *d
796 int yaffs_CheckpointClose(yaffs_Device *dev)
797 {
798
799 - if(dev->checkpointOpenForWrite){
800 - if(dev->checkpointByteOffset != 0)
801 + if (dev->checkpointOpenForWrite) {
802 + if (dev->checkpointByteOffset != 0)
803 yaffs_CheckpointFlushBuffer(dev);
804 } else {
805 int i;
806 - for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){
807 - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]);
808 - if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
809 + for (i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++) {
810 + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointBlockList[i]);
811 + if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
812 bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
813 else {
814 - // Todo this looks odd...
815 + /* Todo this looks odd... */
816 }
817 }
818 YFREE(dev->checkpointBlockList);
819 @@ -374,27 +366,25 @@ int yaffs_CheckpointClose(yaffs_Device *
820 dev->nErasedBlocks -= dev->blocksInCheckpoint;
821
822
823 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
824 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR),
825 dev->checkpointByteCount));
826
827 - if(dev->checkpointBuffer){
828 + if (dev->checkpointBuffer) {
829 /* free the buffer */
830 YFREE(dev->checkpointBuffer);
831 dev->checkpointBuffer = NULL;
832 return 1;
833 - }
834 - else
835 + } else
836 return 0;
837 -
838 }
839
840 int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
841 {
842 /* Erase the first checksum block */
843
844 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR)));
845 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate"TENDSTR)));
846
847 - if(!yaffs_CheckpointSpaceOk(dev))
848 + if (!yaffs_CheckpointSpaceOk(dev))
849 return 0;
850
851 return yaffs_CheckpointErase(dev);
852 --- a/fs/yaffs2/yaffs_checkptrw.h
853 +++ b/fs/yaffs2/yaffs_checkptrw.h
854 @@ -20,9 +20,9 @@
855
856 int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting);
857
858 -int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes);
859 +int yaffs_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes);
860
861 -int yaffs_CheckpointRead(yaffs_Device *dev,void *data, int nBytes);
862 +int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes);
863
864 int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum);
865
866 --- a/fs/yaffs2/yaffs_ecc.c
867 +++ b/fs/yaffs2/yaffs_ecc.c
868 @@ -29,7 +29,7 @@
869 */
870
871 const char *yaffs_ecc_c_version =
872 - "$Id: yaffs_ecc.c,v 1.9 2007-02-14 01:09:06 wookey Exp $";
873 + "$Id: yaffs_ecc.c,v 1.11 2009-03-06 17:20:50 wookey Exp $";
874
875 #include "yportenv.h"
876
877 @@ -109,12 +109,10 @@ void yaffs_ECCCalculate(const unsigned c
878 b = column_parity_table[*data++];
879 col_parity ^= b;
880
881 - if (b & 0x01) // odd number of bits in the byte
882 - {
883 + if (b & 0x01) { /* odd number of bits in the byte */
884 line_parity ^= i;
885 line_parity_prime ^= ~i;
886 }
887 -
888 }
889
890 ecc[2] = (~col_parity) | 0x03;
891 @@ -158,7 +156,7 @@ void yaffs_ECCCalculate(const unsigned c
892 ecc[0] = ~t;
893
894 #ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
895 - // Swap the bytes into the wrong order
896 + /* Swap the bytes into the wrong order */
897 t = ecc[0];
898 ecc[0] = ecc[1];
899 ecc[1] = t;
900 @@ -189,7 +187,7 @@ int yaffs_ECCCorrect(unsigned char *data
901 unsigned bit;
902
903 #ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
904 - // swap the bytes to correct for the wrong order
905 + /* swap the bytes to correct for the wrong order */
906 unsigned char t;
907
908 t = d0;
909 @@ -251,7 +249,7 @@ int yaffs_ECCCorrect(unsigned char *data
910 * ECCxxxOther does ECC calcs on arbitrary n bytes of data
911 */
912 void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
913 - yaffs_ECCOther * eccOther)
914 + yaffs_ECCOther *eccOther)
915 {
916 unsigned int i;
917
918 @@ -278,8 +276,8 @@ void yaffs_ECCCalculateOther(const unsig
919 }
920
921 int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
922 - yaffs_ECCOther * read_ecc,
923 - const yaffs_ECCOther * test_ecc)
924 + yaffs_ECCOther *read_ecc,
925 + const yaffs_ECCOther *test_ecc)
926 {
927 unsigned char cDelta; /* column parity delta */
928 unsigned lDelta; /* line parity delta */
929 @@ -294,8 +292,7 @@ int yaffs_ECCCorrectOther(unsigned char
930 return 0; /* no error */
931
932 if (lDelta == ~lDeltaPrime &&
933 - (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
934 - {
935 + (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15)) {
936 /* Single bit (recoverable) error in data */
937
938 bit = 0;
939 @@ -307,7 +304,7 @@ int yaffs_ECCCorrectOther(unsigned char
940 if (cDelta & 0x02)
941 bit |= 0x01;
942
943 - if(lDelta >= nBytes)
944 + if (lDelta >= nBytes)
945 return -1;
946
947 data[lDelta] ^= (1 << bit);
948 @@ -316,7 +313,7 @@ int yaffs_ECCCorrectOther(unsigned char
949 }
950
951 if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) +
952 - yaffs_CountBits(cDelta)) == 1) {
953 + yaffs_CountBits(cDelta)) == 1) {
954 /* Reccoverable error in ecc */
955
956 *read_ecc = *test_ecc;
957 @@ -326,6 +323,4 @@ int yaffs_ECCCorrectOther(unsigned char
958 /* Unrecoverable error */
959
960 return -1;
961 -
962 }
963 -
964 --- a/fs/yaffs2/yaffs_ecc.h
965 +++ b/fs/yaffs2/yaffs_ecc.h
966 @@ -13,15 +13,15 @@
967 * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
968 */
969
970 - /*
971 - * This code implements the ECC algorithm used in SmartMedia.
972 - *
973 - * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
974 - * The two unused bit are set to 1.
975 - * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
976 - * blocks are used on a 512-byte NAND page.
977 - *
978 - */
979 +/*
980 + * This code implements the ECC algorithm used in SmartMedia.
981 + *
982 + * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
983 + * The two unused bit are set to 1.
984 + * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
985 + * blocks are used on a 512-byte NAND page.
986 + *
987 + */
988
989 #ifndef __YAFFS_ECC_H__
990 #define __YAFFS_ECC_H__
991 @@ -34,11 +34,11 @@ typedef struct {
992
993 void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc);
994 int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
995 - const unsigned char *test_ecc);
996 + const unsigned char *test_ecc);
997
998 void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
999 - yaffs_ECCOther * ecc);
1000 + yaffs_ECCOther *ecc);
1001 int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
1002 - yaffs_ECCOther * read_ecc,
1003 - const yaffs_ECCOther * test_ecc);
1004 + yaffs_ECCOther *read_ecc,
1005 + const yaffs_ECCOther *test_ecc);
1006 #endif
1007 --- a/fs/yaffs2/yaffs_fs.c
1008 +++ b/fs/yaffs2/yaffs_fs.c
1009 @@ -1,7 +1,7 @@
1010 /*
1011 * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
1012 *
1013 - * Copyright (C) 2002-2007 Aleph One Ltd.
1014 + * Copyright (C) 2002-2009 Aleph One Ltd.
1015 * for Toby Churchill Ltd and Brightstar Engineering
1016 *
1017 * Created by Charles Manning <charles@aleph1.co.uk>
1018 @@ -32,18 +32,17 @@
1019 */
1020
1021 const char *yaffs_fs_c_version =
1022 - "$Id: yaffs_fs.c,v 1.63 2007-09-19 20:35:40 imcd Exp $";
1023 + "$Id: yaffs_fs.c,v 1.79 2009-03-17 01:12:00 wookey Exp $";
1024 extern const char *yaffs_guts_c_version;
1025
1026 #include <linux/version.h>
1027 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
1028 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
1029 #include <linux/config.h>
1030 #endif
1031 #include <linux/kernel.h>
1032 #include <linux/module.h>
1033 #include <linux/slab.h>
1034 #include <linux/init.h>
1035 -#include <linux/list.h>
1036 #include <linux/fs.h>
1037 #include <linux/proc_fs.h>
1038 #include <linux/smp_lock.h>
1039 @@ -53,10 +52,12 @@ extern const char *yaffs_guts_c_version;
1040 #include <linux/string.h>
1041 #include <linux/ctype.h>
1042
1043 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1044 +#include "asm/div64.h"
1045 +
1046 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1047
1048 #include <linux/statfs.h> /* Added NCB 15-8-2003 */
1049 -#include <asm/statfs.h>
1050 +#include <linux/statfs.h>
1051 #define UnlockPage(p) unlock_page(p)
1052 #define Page_Uptodate(page) test_bit(PG_uptodate, &(page)->flags)
1053
1054 @@ -69,22 +70,45 @@ extern const char *yaffs_guts_c_version;
1055 #define BDEVNAME_SIZE 0
1056 #define yaffs_devname(sb, buf) kdevname(sb->s_dev)
1057
1058 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1059 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0))
1060 /* added NCB 26/5/2006 for 2.4.25-vrs2-tcl1 kernel */
1061 #define __user
1062 #endif
1063
1064 #endif
1065
1066 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1067 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26))
1068 +#define YPROC_ROOT (&proc_root)
1069 +#else
1070 +#define YPROC_ROOT NULL
1071 +#endif
1072 +
1073 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1074 #define WRITE_SIZE_STR "writesize"
1075 -#define WRITE_SIZE(mtd) (mtd)->writesize
1076 +#define WRITE_SIZE(mtd) ((mtd)->writesize)
1077 #else
1078 #define WRITE_SIZE_STR "oobblock"
1079 -#define WRITE_SIZE(mtd) (mtd)->oobblock
1080 +#define WRITE_SIZE(mtd) ((mtd)->oobblock)
1081 #endif
1082
1083 -#include <asm/uaccess.h>
1084 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 27))
1085 +#define YAFFS_USE_WRITE_BEGIN_END 1
1086 +#else
1087 +#define YAFFS_USE_WRITE_BEGIN_END 0
1088 +#endif
1089 +
1090 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 28))
1091 +static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
1092 +{
1093 + uint64_t result = partition_size;
1094 + do_div(result, block_size);
1095 + return (uint32_t)result;
1096 +}
1097 +#else
1098 +#define YCALCBLOCKS(s, b) ((s)/(b))
1099 +#endif
1100 +
1101 +#include <linux/uaccess.h>
1102
1103 #include "yportenv.h"
1104 #include "yaffs_guts.h"
1105 @@ -96,28 +120,44 @@ extern const char *yaffs_guts_c_version;
1106
1107 unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS;
1108 unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
1109 +unsigned int yaffs_auto_checkpoint = 1;
1110
1111 /* Module Parameters */
1112 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1113 -module_param(yaffs_traceMask,uint,0644);
1114 -module_param(yaffs_wr_attempts,uint,0644);
1115 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1116 +module_param(yaffs_traceMask, uint, 0644);
1117 +module_param(yaffs_wr_attempts, uint, 0644);
1118 +module_param(yaffs_auto_checkpoint, uint, 0644);
1119 +#else
1120 +MODULE_PARM(yaffs_traceMask, "i");
1121 +MODULE_PARM(yaffs_wr_attempts, "i");
1122 +MODULE_PARM(yaffs_auto_checkpoint, "i");
1123 +#endif
1124 +
1125 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25))
1126 +/* use iget and read_inode */
1127 +#define Y_IGET(sb, inum) iget((sb), (inum))
1128 +static void yaffs_read_inode(struct inode *inode);
1129 +
1130 #else
1131 -MODULE_PARM(yaffs_traceMask,"i");
1132 -MODULE_PARM(yaffs_wr_attempts,"i");
1133 +/* Call local equivalent */
1134 +#define YAFFS_USE_OWN_IGET
1135 +#define Y_IGET(sb, inum) yaffs_iget((sb), (inum))
1136 +
1137 +static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
1138 #endif
1139
1140 /*#define T(x) printk x */
1141
1142 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
1143 -#define yaffs_InodeToObjectLV(iptr) (iptr)->i_private
1144 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18))
1145 +#define yaffs_InodeToObjectLV(iptr) ((iptr)->i_private)
1146 #else
1147 -#define yaffs_InodeToObjectLV(iptr) (iptr)->u.generic_ip
1148 +#define yaffs_InodeToObjectLV(iptr) ((iptr)->u.generic_ip)
1149 #endif
1150
1151 #define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr)))
1152 #define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
1153
1154 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1155 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1156 #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info)
1157 #else
1158 #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp)
1159 @@ -126,47 +166,49 @@ MODULE_PARM(yaffs_wr_attempts,"i");
1160 static void yaffs_put_super(struct super_block *sb);
1161
1162 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
1163 - loff_t * pos);
1164 + loff_t *pos);
1165 +static ssize_t yaffs_hold_space(struct file *f);
1166 +static void yaffs_release_space(struct file *f);
1167
1168 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1169 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1170 static int yaffs_file_flush(struct file *file, fl_owner_t id);
1171 #else
1172 static int yaffs_file_flush(struct file *file);
1173 #endif
1174
1175 static int yaffs_sync_object(struct file *file, struct dentry *dentry,
1176 - int datasync);
1177 + int datasync);
1178
1179 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
1180
1181 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1182 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1183 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
1184 struct nameidata *n);
1185 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
1186 - struct nameidata *n);
1187 + struct nameidata *n);
1188 #else
1189 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
1190 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
1191 #endif
1192 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
1193 - struct dentry *dentry);
1194 + struct dentry *dentry);
1195 static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
1196 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
1197 - const char *symname);
1198 + const char *symname);
1199 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
1200
1201 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1202 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1203 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
1204 - dev_t dev);
1205 + dev_t dev);
1206 #else
1207 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
1208 - int dev);
1209 + int dev);
1210 #endif
1211 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
1212 struct inode *new_dir, struct dentry *new_dentry);
1213 static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
1214
1215 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1216 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1217 static int yaffs_sync_fs(struct super_block *sb, int wait);
1218 static void yaffs_write_super(struct super_block *sb);
1219 #else
1220 @@ -174,33 +216,47 @@ static int yaffs_sync_fs(struct super_bl
1221 static int yaffs_write_super(struct super_block *sb);
1222 #endif
1223
1224 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1225 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1226 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf);
1227 -#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1228 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1229 static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf);
1230 #else
1231 static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
1232 #endif
1233 -static void yaffs_read_inode(struct inode *inode);
1234
1235 +#ifdef YAFFS_HAS_PUT_INODE
1236 static void yaffs_put_inode(struct inode *inode);
1237 +#endif
1238 +
1239 static void yaffs_delete_inode(struct inode *);
1240 static void yaffs_clear_inode(struct inode *);
1241
1242 static int yaffs_readpage(struct file *file, struct page *page);
1243 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1244 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1245 static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
1246 #else
1247 static int yaffs_writepage(struct page *page);
1248 #endif
1249 +
1250 +
1251 +#if (YAFFS_USE_WRITE_BEGIN_END != 0)
1252 +static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
1253 + loff_t pos, unsigned len, unsigned flags,
1254 + struct page **pagep, void **fsdata);
1255 +static int yaffs_write_end(struct file *filp, struct address_space *mapping,
1256 + loff_t pos, unsigned len, unsigned copied,
1257 + struct page *pg, void *fsdadata);
1258 +#else
1259 static int yaffs_prepare_write(struct file *f, struct page *pg,
1260 - unsigned offset, unsigned to);
1261 + unsigned offset, unsigned to);
1262 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
1263 - unsigned to);
1264 + unsigned to);
1265
1266 -static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
1267 - int buflen);
1268 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1269 +#endif
1270 +
1271 +static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
1272 + int buflen);
1273 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1274 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
1275 #else
1276 static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
1277 @@ -209,12 +265,17 @@ static int yaffs_follow_link(struct dent
1278 static struct address_space_operations yaffs_file_address_operations = {
1279 .readpage = yaffs_readpage,
1280 .writepage = yaffs_writepage,
1281 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1282 + .write_begin = yaffs_write_begin,
1283 + .write_end = yaffs_write_end,
1284 +#else
1285 .prepare_write = yaffs_prepare_write,
1286 .commit_write = yaffs_commit_write,
1287 +#endif
1288 };
1289
1290 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
1291 -static struct file_operations yaffs_file_operations = {
1292 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
1293 +static const struct file_operations yaffs_file_operations = {
1294 .read = do_sync_read,
1295 .write = do_sync_write,
1296 .aio_read = generic_file_aio_read,
1297 @@ -224,11 +285,12 @@ static struct file_operations yaffs_file
1298 .fsync = yaffs_sync_object,
1299 .splice_read = generic_file_splice_read,
1300 .splice_write = generic_file_splice_write,
1301 + .llseek = generic_file_llseek,
1302 };
1303
1304 -#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
1305 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18))
1306
1307 -static struct file_operations yaffs_file_operations = {
1308 +static const struct file_operations yaffs_file_operations = {
1309 .read = do_sync_read,
1310 .write = do_sync_write,
1311 .aio_read = generic_file_aio_read,
1312 @@ -241,29 +303,29 @@ static struct file_operations yaffs_file
1313
1314 #else
1315
1316 -static struct file_operations yaffs_file_operations = {
1317 +static const struct file_operations yaffs_file_operations = {
1318 .read = generic_file_read,
1319 .write = generic_file_write,
1320 .mmap = generic_file_mmap,
1321 .flush = yaffs_file_flush,
1322 .fsync = yaffs_sync_object,
1323 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1324 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1325 .sendfile = generic_file_sendfile,
1326 #endif
1327 };
1328 #endif
1329
1330 -static struct inode_operations yaffs_file_inode_operations = {
1331 +static const struct inode_operations yaffs_file_inode_operations = {
1332 .setattr = yaffs_setattr,
1333 };
1334
1335 -static struct inode_operations yaffs_symlink_inode_operations = {
1336 +static const struct inode_operations yaffs_symlink_inode_operations = {
1337 .readlink = yaffs_readlink,
1338 .follow_link = yaffs_follow_link,
1339 .setattr = yaffs_setattr,
1340 };
1341
1342 -static struct inode_operations yaffs_dir_inode_operations = {
1343 +static const struct inode_operations yaffs_dir_inode_operations = {
1344 .create = yaffs_create,
1345 .lookup = yaffs_lookup,
1346 .link = yaffs_link,
1347 @@ -276,16 +338,21 @@ static struct inode_operations yaffs_dir
1348 .setattr = yaffs_setattr,
1349 };
1350
1351 -static struct file_operations yaffs_dir_operations = {
1352 +static const struct file_operations yaffs_dir_operations = {
1353 .read = generic_read_dir,
1354 .readdir = yaffs_readdir,
1355 .fsync = yaffs_sync_object,
1356 };
1357
1358 -static struct super_operations yaffs_super_ops = {
1359 +static const struct super_operations yaffs_super_ops = {
1360 .statfs = yaffs_statfs,
1361 +
1362 +#ifndef YAFFS_USE_OWN_IGET
1363 .read_inode = yaffs_read_inode,
1364 +#endif
1365 +#ifdef YAFFS_HAS_PUT_INODE
1366 .put_inode = yaffs_put_inode,
1367 +#endif
1368 .put_super = yaffs_put_super,
1369 .delete_inode = yaffs_delete_inode,
1370 .clear_inode = yaffs_clear_inode,
1371 @@ -293,22 +360,21 @@ static struct super_operations yaffs_sup
1372 .write_super = yaffs_write_super,
1373 };
1374
1375 -static void yaffs_GrossLock(yaffs_Device * dev)
1376 +static void yaffs_GrossLock(yaffs_Device *dev)
1377 {
1378 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs locking\n"));
1379 -
1380 + T(YAFFS_TRACE_OS, ("yaffs locking %p\n", current));
1381 down(&dev->grossLock);
1382 + T(YAFFS_TRACE_OS, ("yaffs locked %p\n", current));
1383 }
1384
1385 -static void yaffs_GrossUnlock(yaffs_Device * dev)
1386 +static void yaffs_GrossUnlock(yaffs_Device *dev)
1387 {
1388 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs unlocking\n"));
1389 + T(YAFFS_TRACE_OS, ("yaffs unlocking %p\n", current));
1390 up(&dev->grossLock);
1391 -
1392 }
1393
1394 -static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
1395 - int buflen)
1396 +static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
1397 + int buflen)
1398 {
1399 unsigned char *alias;
1400 int ret;
1401 @@ -329,7 +395,7 @@ static int yaffs_readlink(struct dentry
1402 return ret;
1403 }
1404
1405 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1406 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1407 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
1408 #else
1409 static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
1410 @@ -345,32 +411,31 @@ static int yaffs_follow_link(struct dent
1411
1412 yaffs_GrossUnlock(dev);
1413
1414 - if (!alias)
1415 - {
1416 + if (!alias) {
1417 ret = -ENOMEM;
1418 goto out;
1419 - }
1420 + }
1421
1422 ret = vfs_follow_link(nd, alias);
1423 kfree(alias);
1424 out:
1425 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1426 - return ERR_PTR (ret);
1427 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1428 + return ERR_PTR(ret);
1429 #else
1430 return ret;
1431 #endif
1432 }
1433
1434 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
1435 - yaffs_Object * obj);
1436 + yaffs_Object *obj);
1437
1438 /*
1439 * Lookup is used to find objects in the fs
1440 */
1441 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1442 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1443
1444 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
1445 - struct nameidata *n)
1446 + struct nameidata *n)
1447 #else
1448 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
1449 #endif
1450 @@ -383,12 +448,11 @@ static struct dentry *yaffs_lookup(struc
1451 yaffs_GrossLock(dev);
1452
1453 T(YAFFS_TRACE_OS,
1454 - (KERN_DEBUG "yaffs_lookup for %d:%s\n",
1455 - yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
1456 + ("yaffs_lookup for %d:%s\n",
1457 + yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
1458
1459 - obj =
1460 - yaffs_FindObjectByName(yaffs_InodeToObject(dir),
1461 - dentry->d_name.name);
1462 + obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir),
1463 + dentry->d_name.name);
1464
1465 obj = yaffs_GetEquivalentObject(obj); /* in case it was a hardlink */
1466
1467 @@ -397,13 +461,13 @@ static struct dentry *yaffs_lookup(struc
1468
1469 if (obj) {
1470 T(YAFFS_TRACE_OS,
1471 - (KERN_DEBUG "yaffs_lookup found %d\n", obj->objectId));
1472 + ("yaffs_lookup found %d\n", obj->objectId));
1473
1474 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
1475
1476 if (inode) {
1477 T(YAFFS_TRACE_OS,
1478 - (KERN_DEBUG "yaffs_loookup dentry \n"));
1479 + ("yaffs_loookup dentry \n"));
1480 /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
1481 * d_add even if NULL inode */
1482 #if 0
1483 @@ -416,7 +480,7 @@ static struct dentry *yaffs_lookup(struc
1484 }
1485
1486 } else {
1487 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n"));
1488 + T(YAFFS_TRACE_OS, ("yaffs_lookup not found\n"));
1489
1490 }
1491
1492 @@ -425,20 +489,22 @@ static struct dentry *yaffs_lookup(struc
1493 d_add(dentry, inode);
1494
1495 return NULL;
1496 - /* return (ERR_PTR(-EIO)); */
1497 -
1498 }
1499
1500 +
1501 +#ifdef YAFFS_HAS_PUT_INODE
1502 +
1503 /* For now put inode is just for debugging
1504 * Put inode is called when the inode **structure** is put.
1505 */
1506 static void yaffs_put_inode(struct inode *inode)
1507 {
1508 T(YAFFS_TRACE_OS,
1509 - ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
1510 - atomic_read(&inode->i_count)));
1511 + ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
1512 + atomic_read(&inode->i_count)));
1513
1514 }
1515 +#endif
1516
1517 /* clear is called to tell the fs to release any per-inode data it holds */
1518 static void yaffs_clear_inode(struct inode *inode)
1519 @@ -449,9 +515,9 @@ static void yaffs_clear_inode(struct ino
1520 obj = yaffs_InodeToObject(inode);
1521
1522 T(YAFFS_TRACE_OS,
1523 - ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1524 - atomic_read(&inode->i_count),
1525 - obj ? "object exists" : "null object"));
1526 + ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1527 + atomic_read(&inode->i_count),
1528 + obj ? "object exists" : "null object"));
1529
1530 if (obj) {
1531 dev = obj->myDev;
1532 @@ -486,23 +552,23 @@ static void yaffs_delete_inode(struct in
1533 yaffs_Device *dev;
1534
1535 T(YAFFS_TRACE_OS,
1536 - ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1537 - atomic_read(&inode->i_count),
1538 - obj ? "object exists" : "null object"));
1539 + ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1540 + atomic_read(&inode->i_count),
1541 + obj ? "object exists" : "null object"));
1542
1543 if (obj) {
1544 dev = obj->myDev;
1545 yaffs_GrossLock(dev);
1546 - yaffs_DeleteFile(obj);
1547 + yaffs_DeleteObject(obj);
1548 yaffs_GrossUnlock(dev);
1549 }
1550 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1551 - truncate_inode_pages (&inode->i_data, 0);
1552 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1553 + truncate_inode_pages(&inode->i_data, 0);
1554 #endif
1555 clear_inode(inode);
1556 }
1557
1558 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1559 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1560 static int yaffs_file_flush(struct file *file, fl_owner_t id)
1561 #else
1562 static int yaffs_file_flush(struct file *file)
1563 @@ -513,8 +579,8 @@ static int yaffs_file_flush(struct file
1564 yaffs_Device *dev = obj->myDev;
1565
1566 T(YAFFS_TRACE_OS,
1567 - (KERN_DEBUG "yaffs_file_flush object %d (%s)\n", obj->objectId,
1568 - obj->dirty ? "dirty" : "clean"));
1569 + ("yaffs_file_flush object %d (%s)\n", obj->objectId,
1570 + obj->dirty ? "dirty" : "clean"));
1571
1572 yaffs_GrossLock(dev);
1573
1574 @@ -535,15 +601,15 @@ static int yaffs_readpage_nolock(struct
1575
1576 yaffs_Device *dev;
1577
1578 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage at %08x, size %08x\n",
1579 - (unsigned)(pg->index << PAGE_CACHE_SHIFT),
1580 - (unsigned)PAGE_CACHE_SIZE));
1581 + T(YAFFS_TRACE_OS, ("yaffs_readpage at %08x, size %08x\n",
1582 + (unsigned)(pg->index << PAGE_CACHE_SHIFT),
1583 + (unsigned)PAGE_CACHE_SIZE));
1584
1585 obj = yaffs_DentryToObject(f->f_dentry);
1586
1587 dev = obj->myDev;
1588
1589 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1590 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1591 BUG_ON(!PageLocked(pg));
1592 #else
1593 if (!PageLocked(pg))
1594 @@ -555,9 +621,9 @@ static int yaffs_readpage_nolock(struct
1595
1596 yaffs_GrossLock(dev);
1597
1598 - ret =
1599 - yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT,
1600 - PAGE_CACHE_SIZE);
1601 + ret = yaffs_ReadDataFromFile(obj, pg_buf,
1602 + pg->index << PAGE_CACHE_SHIFT,
1603 + PAGE_CACHE_SIZE);
1604
1605 yaffs_GrossUnlock(dev);
1606
1607 @@ -575,7 +641,7 @@ static int yaffs_readpage_nolock(struct
1608 flush_dcache_page(pg);
1609 kunmap(pg);
1610
1611 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage done\n"));
1612 + T(YAFFS_TRACE_OS, ("yaffs_readpage done\n"));
1613 return ret;
1614 }
1615
1616 @@ -593,7 +659,7 @@ static int yaffs_readpage(struct file *f
1617
1618 /* writepage inspired by/stolen from smbfs */
1619
1620 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1621 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1622 static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
1623 #else
1624 static int yaffs_writepage(struct page *page)
1625 @@ -616,12 +682,11 @@ static int yaffs_writepage(struct page *
1626
1627 if (offset > inode->i_size) {
1628 T(YAFFS_TRACE_OS,
1629 - (KERN_DEBUG
1630 - "yaffs_writepage at %08x, inode size = %08x!!!\n",
1631 - (unsigned)(page->index << PAGE_CACHE_SHIFT),
1632 - (unsigned)inode->i_size));
1633 + ("yaffs_writepage at %08x, inode size = %08x!!!\n",
1634 + (unsigned)(page->index << PAGE_CACHE_SHIFT),
1635 + (unsigned)inode->i_size));
1636 T(YAFFS_TRACE_OS,
1637 - (KERN_DEBUG " -> don't care!!\n"));
1638 + (" -> don't care!!\n"));
1639 unlock_page(page);
1640 return 0;
1641 }
1642 @@ -629,11 +694,10 @@ static int yaffs_writepage(struct page *
1643 end_index = inode->i_size >> PAGE_CACHE_SHIFT;
1644
1645 /* easy case */
1646 - if (page->index < end_index) {
1647 + if (page->index < end_index)
1648 nBytes = PAGE_CACHE_SIZE;
1649 - } else {
1650 + else
1651 nBytes = inode->i_size & (PAGE_CACHE_SIZE - 1);
1652 - }
1653
1654 get_page(page);
1655
1656 @@ -643,19 +707,18 @@ static int yaffs_writepage(struct page *
1657 yaffs_GrossLock(obj->myDev);
1658
1659 T(YAFFS_TRACE_OS,
1660 - (KERN_DEBUG "yaffs_writepage at %08x, size %08x\n",
1661 - (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
1662 + ("yaffs_writepage at %08x, size %08x\n",
1663 + (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
1664 T(YAFFS_TRACE_OS,
1665 - (KERN_DEBUG "writepag0: obj = %05x, ino = %05x\n",
1666 - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1667 + ("writepag0: obj = %05x, ino = %05x\n",
1668 + (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1669
1670 - nWritten =
1671 - yaffs_WriteDataToFile(obj, buffer, page->index << PAGE_CACHE_SHIFT,
1672 - nBytes, 0);
1673 + nWritten = yaffs_WriteDataToFile(obj, buffer,
1674 + page->index << PAGE_CACHE_SHIFT, nBytes, 0);
1675
1676 T(YAFFS_TRACE_OS,
1677 - (KERN_DEBUG "writepag1: obj = %05x, ino = %05x\n",
1678 - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1679 + ("writepag1: obj = %05x, ino = %05x\n",
1680 + (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1681
1682 yaffs_GrossUnlock(obj->myDev);
1683
1684 @@ -667,100 +730,207 @@ static int yaffs_writepage(struct page *
1685 return (nWritten == nBytes) ? 0 : -ENOSPC;
1686 }
1687
1688 +
1689 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1690 +static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
1691 + loff_t pos, unsigned len, unsigned flags,
1692 + struct page **pagep, void **fsdata)
1693 +{
1694 + struct page *pg = NULL;
1695 + pgoff_t index = pos >> PAGE_CACHE_SHIFT;
1696 + uint32_t offset = pos & (PAGE_CACHE_SIZE - 1);
1697 + uint32_t to = offset + len;
1698 +
1699 + int ret = 0;
1700 + int space_held = 0;
1701 +
1702 + T(YAFFS_TRACE_OS, ("start yaffs_write_begin\n"));
1703 + /* Get a page */
1704 +#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 28)
1705 + pg = grab_cache_page_write_begin(mapping, index, flags);
1706 +#else
1707 + pg = __grab_cache_page(mapping, index);
1708 +#endif
1709 +
1710 + *pagep = pg;
1711 + if (!pg) {
1712 + ret = -ENOMEM;
1713 + goto out;
1714 + }
1715 + /* Get fs space */
1716 + space_held = yaffs_hold_space(filp);
1717 +
1718 + if (!space_held) {
1719 + ret = -ENOSPC;
1720 + goto out;
1721 + }
1722 +
1723 + /* Update page if required */
1724 +
1725 + if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
1726 + ret = yaffs_readpage_nolock(filp, pg);
1727 +
1728 + if (ret)
1729 + goto out;
1730 +
1731 + /* Happy path return */
1732 + T(YAFFS_TRACE_OS, ("end yaffs_write_begin - ok\n"));
1733 +
1734 + return 0;
1735 +
1736 +out:
1737 + T(YAFFS_TRACE_OS, ("end yaffs_write_begin fail returning %d\n", ret));
1738 + if (space_held)
1739 + yaffs_release_space(filp);
1740 + if (pg) {
1741 + unlock_page(pg);
1742 + page_cache_release(pg);
1743 + }
1744 + return ret;
1745 +}
1746 +
1747 +#else
1748 +
1749 static int yaffs_prepare_write(struct file *f, struct page *pg,
1750 - unsigned offset, unsigned to)
1751 + unsigned offset, unsigned to)
1752 {
1753 + T(YAFFS_TRACE_OS, ("yaffs_prepair_write\n"));
1754
1755 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
1756 if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
1757 return yaffs_readpage_nolock(f, pg);
1758 -
1759 return 0;
1760 +}
1761 +#endif
1762 +
1763 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1764 +static int yaffs_write_end(struct file *filp, struct address_space *mapping,
1765 + loff_t pos, unsigned len, unsigned copied,
1766 + struct page *pg, void *fsdadata)
1767 +{
1768 + int ret = 0;
1769 + void *addr, *kva;
1770 + uint32_t offset_into_page = pos & (PAGE_CACHE_SIZE - 1);
1771 +
1772 + kva = kmap(pg);
1773 + addr = kva + offset_into_page;
1774 +
1775 + T(YAFFS_TRACE_OS,
1776 + ("yaffs_write_end addr %x pos %x nBytes %d\n",
1777 + (unsigned) addr,
1778 + (int)pos, copied));
1779 +
1780 + ret = yaffs_file_write(filp, addr, copied, &pos);
1781 +
1782 + if (ret != copied) {
1783 + T(YAFFS_TRACE_OS,
1784 + ("yaffs_write_end not same size ret %d copied %d\n",
1785 + ret, copied));
1786 + SetPageError(pg);
1787 + ClearPageUptodate(pg);
1788 + } else {
1789 + SetPageUptodate(pg);
1790 + }
1791 +
1792 + kunmap(pg);
1793
1794 + yaffs_release_space(filp);
1795 + unlock_page(pg);
1796 + page_cache_release(pg);
1797 + return ret;
1798 }
1799 +#else
1800
1801 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
1802 - unsigned to)
1803 + unsigned to)
1804 {
1805 + void *addr, *kva;
1806
1807 - void *addr = page_address(pg) + offset;
1808 loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
1809 int nBytes = to - offset;
1810 int nWritten;
1811
1812 unsigned spos = pos;
1813 - unsigned saddr = (unsigned)addr;
1814 + unsigned saddr;
1815 +
1816 + kva = kmap(pg);
1817 + addr = kva + offset;
1818 +
1819 + saddr = (unsigned) addr;
1820
1821 T(YAFFS_TRACE_OS,
1822 - (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
1823 - spos, nBytes));
1824 + ("yaffs_commit_write addr %x pos %x nBytes %d\n",
1825 + saddr, spos, nBytes));
1826
1827 nWritten = yaffs_file_write(f, addr, nBytes, &pos);
1828
1829 if (nWritten != nBytes) {
1830 T(YAFFS_TRACE_OS,
1831 - (KERN_DEBUG
1832 - "yaffs_commit_write not same size nWritten %d nBytes %d\n",
1833 - nWritten, nBytes));
1834 + ("yaffs_commit_write not same size nWritten %d nBytes %d\n",
1835 + nWritten, nBytes));
1836 SetPageError(pg);
1837 ClearPageUptodate(pg);
1838 } else {
1839 SetPageUptodate(pg);
1840 }
1841
1842 + kunmap(pg);
1843 +
1844 T(YAFFS_TRACE_OS,
1845 - (KERN_DEBUG "yaffs_commit_write returning %d\n",
1846 - nWritten == nBytes ? 0 : nWritten));
1847 + ("yaffs_commit_write returning %d\n",
1848 + nWritten == nBytes ? 0 : nWritten));
1849
1850 return nWritten == nBytes ? 0 : nWritten;
1851 -
1852 }
1853 +#endif
1854 +
1855
1856 -static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
1857 +static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj)
1858 {
1859 if (inode && obj) {
1860
1861
1862 /* Check mode against the variant type and attempt to repair if broken. */
1863 - __u32 mode = obj->yst_mode;
1864 - switch( obj->variantType ){
1865 - case YAFFS_OBJECT_TYPE_FILE :
1866 - if( ! S_ISREG(mode) ){
1867 - obj->yst_mode &= ~S_IFMT;
1868 - obj->yst_mode |= S_IFREG;
1869 - }
1870 -
1871 - break;
1872 - case YAFFS_OBJECT_TYPE_SYMLINK :
1873 - if( ! S_ISLNK(mode) ){
1874 - obj->yst_mode &= ~S_IFMT;
1875 - obj->yst_mode |= S_IFLNK;
1876 - }
1877 -
1878 - break;
1879 - case YAFFS_OBJECT_TYPE_DIRECTORY :
1880 - if( ! S_ISDIR(mode) ){
1881 - obj->yst_mode &= ~S_IFMT;
1882 - obj->yst_mode |= S_IFDIR;
1883 - }
1884 -
1885 - break;
1886 - case YAFFS_OBJECT_TYPE_UNKNOWN :
1887 - case YAFFS_OBJECT_TYPE_HARDLINK :
1888 - case YAFFS_OBJECT_TYPE_SPECIAL :
1889 - default:
1890 - /* TODO? */
1891 - break;
1892 - }
1893 + __u32 mode = obj->yst_mode;
1894 + switch (obj->variantType) {
1895 + case YAFFS_OBJECT_TYPE_FILE:
1896 + if (!S_ISREG(mode)) {
1897 + obj->yst_mode &= ~S_IFMT;
1898 + obj->yst_mode |= S_IFREG;
1899 + }
1900 +
1901 + break;
1902 + case YAFFS_OBJECT_TYPE_SYMLINK:
1903 + if (!S_ISLNK(mode)) {
1904 + obj->yst_mode &= ~S_IFMT;
1905 + obj->yst_mode |= S_IFLNK;
1906 + }
1907 +
1908 + break;
1909 + case YAFFS_OBJECT_TYPE_DIRECTORY:
1910 + if (!S_ISDIR(mode)) {
1911 + obj->yst_mode &= ~S_IFMT;
1912 + obj->yst_mode |= S_IFDIR;
1913 + }
1914 +
1915 + break;
1916 + case YAFFS_OBJECT_TYPE_UNKNOWN:
1917 + case YAFFS_OBJECT_TYPE_HARDLINK:
1918 + case YAFFS_OBJECT_TYPE_SPECIAL:
1919 + default:
1920 + /* TODO? */
1921 + break;
1922 + }
1923 +
1924 + inode->i_flags |= S_NOATIME;
1925
1926 inode->i_ino = obj->objectId;
1927 inode->i_mode = obj->yst_mode;
1928 inode->i_uid = obj->yst_uid;
1929 inode->i_gid = obj->yst_gid;
1930 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
1931 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
1932 inode->i_blksize = inode->i_sb->s_blocksize;
1933 #endif
1934 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1935 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1936
1937 inode->i_rdev = old_decode_dev(obj->yst_rdev);
1938 inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
1939 @@ -781,26 +951,25 @@ static void yaffs_FillInodeFromObject(st
1940 inode->i_nlink = yaffs_GetObjectLinkCount(obj);
1941
1942 T(YAFFS_TRACE_OS,
1943 - (KERN_DEBUG
1944 - "yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
1945 - inode->i_mode, inode->i_uid, inode->i_gid,
1946 - (int)inode->i_size, atomic_read(&inode->i_count)));
1947 + ("yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
1948 + inode->i_mode, inode->i_uid, inode->i_gid,
1949 + (int)inode->i_size, atomic_read(&inode->i_count)));
1950
1951 switch (obj->yst_mode & S_IFMT) {
1952 default: /* fifo, device or socket */
1953 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1954 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1955 init_special_inode(inode, obj->yst_mode,
1956 - old_decode_dev(obj->yst_rdev));
1957 + old_decode_dev(obj->yst_rdev));
1958 #else
1959 init_special_inode(inode, obj->yst_mode,
1960 - (dev_t) (obj->yst_rdev));
1961 + (dev_t) (obj->yst_rdev));
1962 #endif
1963 break;
1964 case S_IFREG: /* file */
1965 inode->i_op = &yaffs_file_inode_operations;
1966 inode->i_fop = &yaffs_file_operations;
1967 inode->i_mapping->a_ops =
1968 - &yaffs_file_address_operations;
1969 + &yaffs_file_address_operations;
1970 break;
1971 case S_IFDIR: /* directory */
1972 inode->i_op = &yaffs_dir_inode_operations;
1973 @@ -817,34 +986,36 @@ static void yaffs_FillInodeFromObject(st
1974
1975 } else {
1976 T(YAFFS_TRACE_OS,
1977 - (KERN_DEBUG "yaffs_FileInode invalid parameters\n"));
1978 + ("yaffs_FileInode invalid parameters\n"));
1979 }
1980
1981 }
1982
1983 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
1984 - yaffs_Object * obj)
1985 + yaffs_Object *obj)
1986 {
1987 struct inode *inode;
1988
1989 if (!sb) {
1990 T(YAFFS_TRACE_OS,
1991 - (KERN_DEBUG "yaffs_get_inode for NULL super_block!!\n"));
1992 + ("yaffs_get_inode for NULL super_block!!\n"));
1993 return NULL;
1994
1995 }
1996
1997 if (!obj) {
1998 T(YAFFS_TRACE_OS,
1999 - (KERN_DEBUG "yaffs_get_inode for NULL object!!\n"));
2000 + ("yaffs_get_inode for NULL object!!\n"));
2001 return NULL;
2002
2003 }
2004
2005 T(YAFFS_TRACE_OS,
2006 - (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
2007 + ("yaffs_get_inode for object %d\n", obj->objectId));
2008
2009 - inode = iget(sb, obj->objectId);
2010 + inode = Y_IGET(sb, obj->objectId);
2011 + if (IS_ERR(inode))
2012 + return NULL;
2013
2014 /* NB Side effect: iget calls back to yaffs_read_inode(). */
2015 /* iget also increments the inode's i_count */
2016 @@ -854,7 +1025,7 @@ struct inode *yaffs_get_inode(struct sup
2017 }
2018
2019 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
2020 - loff_t * pos)
2021 + loff_t *pos)
2022 {
2023 yaffs_Object *obj;
2024 int nWritten, ipos;
2025 @@ -869,28 +1040,26 @@ static ssize_t yaffs_file_write(struct f
2026
2027 inode = f->f_dentry->d_inode;
2028
2029 - if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) {
2030 + if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND)
2031 ipos = inode->i_size;
2032 - } else {
2033 + else
2034 ipos = *pos;
2035 - }
2036
2037 - if (!obj) {
2038 + if (!obj)
2039 T(YAFFS_TRACE_OS,
2040 - (KERN_DEBUG "yaffs_file_write: hey obj is null!\n"));
2041 - } else {
2042 + ("yaffs_file_write: hey obj is null!\n"));
2043 + else
2044 T(YAFFS_TRACE_OS,
2045 - (KERN_DEBUG
2046 - "yaffs_file_write about to write writing %d bytes"
2047 - "to object %d at %d\n",
2048 - n, obj->objectId, ipos));
2049 - }
2050 + ("yaffs_file_write about to write writing %zu bytes"
2051 + "to object %d at %d\n",
2052 + n, obj->objectId, ipos));
2053
2054 nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0);
2055
2056 T(YAFFS_TRACE_OS,
2057 - (KERN_DEBUG "yaffs_file_write writing %d bytes, %d written at %d\n",
2058 - n, nWritten, ipos));
2059 + ("yaffs_file_write writing %zu bytes, %d written at %d\n",
2060 + n, nWritten, ipos));
2061 +
2062 if (nWritten > 0) {
2063 ipos += nWritten;
2064 *pos = ipos;
2065 @@ -899,10 +1068,9 @@ static ssize_t yaffs_file_write(struct f
2066 inode->i_blocks = (ipos + 511) >> 9;
2067
2068 T(YAFFS_TRACE_OS,
2069 - (KERN_DEBUG
2070 - "yaffs_file_write size updated to %d bytes, "
2071 - "%d blocks\n",
2072 - ipos, (int)(inode->i_blocks)));
2073 + ("yaffs_file_write size updated to %d bytes, "
2074 + "%d blocks\n",
2075 + ipos, (int)(inode->i_blocks)));
2076 }
2077
2078 }
2079 @@ -910,13 +1078,54 @@ static ssize_t yaffs_file_write(struct f
2080 return nWritten == 0 ? -ENOSPC : nWritten;
2081 }
2082
2083 +/* Space holding and freeing is done to ensure we have space available for write_begin/end */
2084 +/* For now we just assume few parallel writes and check against a small number. */
2085 +/* Todo: need to do this with a counter to handle parallel reads better */
2086 +
2087 +static ssize_t yaffs_hold_space(struct file *f)
2088 +{
2089 + yaffs_Object *obj;
2090 + yaffs_Device *dev;
2091 +
2092 + int nFreeChunks;
2093 +
2094 +
2095 + obj = yaffs_DentryToObject(f->f_dentry);
2096 +
2097 + dev = obj->myDev;
2098 +
2099 + yaffs_GrossLock(dev);
2100 +
2101 + nFreeChunks = yaffs_GetNumberOfFreeChunks(dev);
2102 +
2103 + yaffs_GrossUnlock(dev);
2104 +
2105 + return (nFreeChunks > 20) ? 1 : 0;
2106 +}
2107 +
2108 +static void yaffs_release_space(struct file *f)
2109 +{
2110 + yaffs_Object *obj;
2111 + yaffs_Device *dev;
2112 +
2113 +
2114 + obj = yaffs_DentryToObject(f->f_dentry);
2115 +
2116 + dev = obj->myDev;
2117 +
2118 + yaffs_GrossLock(dev);
2119 +
2120 +
2121 + yaffs_GrossUnlock(dev);
2122 +}
2123 +
2124 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
2125 {
2126 yaffs_Object *obj;
2127 yaffs_Device *dev;
2128 struct inode *inode = f->f_dentry->d_inode;
2129 unsigned long offset, curoffs;
2130 - struct list_head *i;
2131 + struct ylist_head *i;
2132 yaffs_Object *l;
2133
2134 char name[YAFFS_MAX_NAME_LENGTH + 1];
2135 @@ -932,24 +1141,20 @@ static int yaffs_readdir(struct file *f,
2136
2137 if (offset == 0) {
2138 T(YAFFS_TRACE_OS,
2139 - (KERN_DEBUG "yaffs_readdir: entry . ino %d \n",
2140 - (int)inode->i_ino));
2141 - if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR)
2142 - < 0) {
2143 + ("yaffs_readdir: entry . ino %d \n",
2144 + (int)inode->i_ino));
2145 + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0)
2146 goto out;
2147 - }
2148 offset++;
2149 f->f_pos++;
2150 }
2151 if (offset == 1) {
2152 T(YAFFS_TRACE_OS,
2153 - (KERN_DEBUG "yaffs_readdir: entry .. ino %d \n",
2154 - (int)f->f_dentry->d_parent->d_inode->i_ino));
2155 - if (filldir
2156 - (dirent, "..", 2, offset,
2157 - f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
2158 + ("yaffs_readdir: entry .. ino %d \n",
2159 + (int)f->f_dentry->d_parent->d_inode->i_ino));
2160 + if (filldir(dirent, "..", 2, offset,
2161 + f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0)
2162 goto out;
2163 - }
2164 offset++;
2165 f->f_pos++;
2166 }
2167 @@ -965,35 +1170,32 @@ static int yaffs_readdir(struct file *f,
2168 f->f_version = inode->i_version;
2169 }
2170
2171 - list_for_each(i, &obj->variant.directoryVariant.children) {
2172 + ylist_for_each(i, &obj->variant.directoryVariant.children) {
2173 curoffs++;
2174 if (curoffs >= offset) {
2175 - l = list_entry(i, yaffs_Object, siblings);
2176 + l = ylist_entry(i, yaffs_Object, siblings);
2177
2178 yaffs_GetObjectName(l, name,
2179 YAFFS_MAX_NAME_LENGTH + 1);
2180 T(YAFFS_TRACE_OS,
2181 - (KERN_DEBUG "yaffs_readdir: %s inode %d\n", name,
2182 + ("yaffs_readdir: %s inode %d\n", name,
2183 yaffs_GetObjectInode(l)));
2184
2185 if (filldir(dirent,
2186 - name,
2187 - strlen(name),
2188 - offset,
2189 - yaffs_GetObjectInode(l),
2190 - yaffs_GetObjectType(l))
2191 - < 0) {
2192 + name,
2193 + strlen(name),
2194 + offset,
2195 + yaffs_GetObjectInode(l),
2196 + yaffs_GetObjectType(l)) < 0)
2197 goto up_and_out;
2198 - }
2199
2200 offset++;
2201 f->f_pos++;
2202 }
2203 }
2204
2205 - up_and_out:
2206 - out:
2207 -
2208 +up_and_out:
2209 +out:
2210 yaffs_GrossUnlock(dev);
2211
2212 return 0;
2213 @@ -1002,12 +1204,19 @@ static int yaffs_readdir(struct file *f,
2214 /*
2215 * File creation. Allocate an inode, and we're done..
2216 */
2217 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2218 +
2219 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
2220 +#define YCRED(x) x
2221 +#else
2222 +#define YCRED(x) (x->cred)
2223 +#endif
2224 +
2225 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2226 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
2227 - dev_t rdev)
2228 + dev_t rdev)
2229 #else
2230 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
2231 - int rdev)
2232 + int rdev)
2233 #endif
2234 {
2235 struct inode *inode;
2236 @@ -1018,25 +1227,25 @@ static int yaffs_mknod(struct inode *dir
2237 yaffs_Object *parent = yaffs_InodeToObject(dir);
2238
2239 int error = -ENOSPC;
2240 - uid_t uid = current->fsuid;
2241 - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
2242 + uid_t uid = YCRED(current)->fsuid;
2243 + gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
2244
2245 - if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
2246 + if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
2247 mode |= S_ISGID;
2248
2249 if (parent) {
2250 T(YAFFS_TRACE_OS,
2251 - (KERN_DEBUG "yaffs_mknod: parent object %d type %d\n",
2252 - parent->objectId, parent->variantType));
2253 + ("yaffs_mknod: parent object %d type %d\n",
2254 + parent->objectId, parent->variantType));
2255 } else {
2256 T(YAFFS_TRACE_OS,
2257 - (KERN_DEBUG "yaffs_mknod: could not get parent object\n"));
2258 + ("yaffs_mknod: could not get parent object\n"));
2259 return -EPERM;
2260 }
2261
2262 T(YAFFS_TRACE_OS, ("yaffs_mknod: making oject for %s, "
2263 - "mode %x dev %x\n",
2264 - dentry->d_name.name, mode, rdev));
2265 + "mode %x dev %x\n",
2266 + dentry->d_name.name, mode, rdev));
2267
2268 dev = parent->myDev;
2269
2270 @@ -1045,33 +1254,28 @@ static int yaffs_mknod(struct inode *dir
2271 switch (mode & S_IFMT) {
2272 default:
2273 /* Special (socket, fifo, device...) */
2274 - T(YAFFS_TRACE_OS, (KERN_DEBUG
2275 - "yaffs_mknod: making special\n"));
2276 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2277 - obj =
2278 - yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2279 - gid, old_encode_dev(rdev));
2280 -#else
2281 - obj =
2282 - yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2283 - gid, rdev);
2284 + T(YAFFS_TRACE_OS, ("yaffs_mknod: making special\n"));
2285 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2286 + obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2287 + gid, old_encode_dev(rdev));
2288 +#else
2289 + obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2290 + gid, rdev);
2291 #endif
2292 break;
2293 case S_IFREG: /* file */
2294 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
2295 - obj =
2296 - yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
2297 - gid);
2298 + T(YAFFS_TRACE_OS, ("yaffs_mknod: making file\n"));
2299 + obj = yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
2300 + gid);
2301 break;
2302 case S_IFDIR: /* directory */
2303 T(YAFFS_TRACE_OS,
2304 - (KERN_DEBUG "yaffs_mknod: making directory\n"));
2305 - obj =
2306 - yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
2307 - uid, gid);
2308 + ("yaffs_mknod: making directory\n"));
2309 + obj = yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
2310 + uid, gid);
2311 break;
2312 case S_IFLNK: /* symlink */
2313 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
2314 + T(YAFFS_TRACE_OS, ("yaffs_mknod: making symlink\n"));
2315 obj = NULL; /* Do we ever get here? */
2316 break;
2317 }
2318 @@ -1083,12 +1287,12 @@ static int yaffs_mknod(struct inode *dir
2319 inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
2320 d_instantiate(dentry, inode);
2321 T(YAFFS_TRACE_OS,
2322 - (KERN_DEBUG "yaffs_mknod created object %d count = %d\n",
2323 - obj->objectId, atomic_read(&inode->i_count)));
2324 + ("yaffs_mknod created object %d count = %d\n",
2325 + obj->objectId, atomic_read(&inode->i_count)));
2326 error = 0;
2327 } else {
2328 T(YAFFS_TRACE_OS,
2329 - (KERN_DEBUG "yaffs_mknod failed making object\n"));
2330 + ("yaffs_mknod failed making object\n"));
2331 error = -ENOMEM;
2332 }
2333
2334 @@ -1098,25 +1302,19 @@ static int yaffs_mknod(struct inode *dir
2335 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2336 {
2337 int retVal;
2338 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mkdir\n"));
2339 + T(YAFFS_TRACE_OS, ("yaffs_mkdir\n"));
2340 retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
2341 -#if 0
2342 - /* attempt to fix dir bug - didn't work */
2343 - if (!retVal) {
2344 - dget(dentry);
2345 - }
2346 -#endif
2347 return retVal;
2348 }
2349
2350 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2351 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2352 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
2353 struct nameidata *n)
2354 #else
2355 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
2356 #endif
2357 {
2358 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_create\n"));
2359 + T(YAFFS_TRACE_OS, ("yaffs_create\n"));
2360 return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
2361 }
2362
2363 @@ -1127,8 +1325,8 @@ static int yaffs_unlink(struct inode *di
2364 yaffs_Device *dev;
2365
2366 T(YAFFS_TRACE_OS,
2367 - (KERN_DEBUG "yaffs_unlink %d:%s\n", (int)(dir->i_ino),
2368 - dentry->d_name.name));
2369 + ("yaffs_unlink %d:%s\n", (int)(dir->i_ino),
2370 + dentry->d_name.name));
2371
2372 dev = yaffs_InodeToObject(dir)->myDev;
2373
2374 @@ -1151,82 +1349,74 @@ static int yaffs_unlink(struct inode *di
2375 * Create a link...
2376 */
2377 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
2378 - struct dentry *dentry)
2379 + struct dentry *dentry)
2380 {
2381 struct inode *inode = old_dentry->d_inode;
2382 yaffs_Object *obj = NULL;
2383 yaffs_Object *link = NULL;
2384 yaffs_Device *dev;
2385
2386 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_link\n"));
2387 + T(YAFFS_TRACE_OS, ("yaffs_link\n"));
2388
2389 obj = yaffs_InodeToObject(inode);
2390 dev = obj->myDev;
2391
2392 yaffs_GrossLock(dev);
2393
2394 - if (!S_ISDIR(inode->i_mode)) /* Don't link directories */
2395 - {
2396 - link =
2397 - yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
2398 - obj);
2399 - }
2400 + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */
2401 + link = yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
2402 + obj);
2403
2404 if (link) {
2405 old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj);
2406 d_instantiate(dentry, old_dentry->d_inode);
2407 atomic_inc(&old_dentry->d_inode->i_count);
2408 T(YAFFS_TRACE_OS,
2409 - (KERN_DEBUG "yaffs_link link count %d i_count %d\n",
2410 - old_dentry->d_inode->i_nlink,
2411 - atomic_read(&old_dentry->d_inode->i_count)));
2412 -
2413 + ("yaffs_link link count %d i_count %d\n",
2414 + old_dentry->d_inode->i_nlink,
2415 + atomic_read(&old_dentry->d_inode->i_count)));
2416 }
2417
2418 yaffs_GrossUnlock(dev);
2419
2420 - if (link) {
2421 -
2422 + if (link)
2423 return 0;
2424 - }
2425
2426 return -EPERM;
2427 }
2428
2429 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
2430 - const char *symname)
2431 + const char *symname)
2432 {
2433 yaffs_Object *obj;
2434 yaffs_Device *dev;
2435 - uid_t uid = current->fsuid;
2436 - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
2437 + uid_t uid = YCRED(current)->fsuid;
2438 + gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
2439
2440 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_symlink\n"));
2441 + T(YAFFS_TRACE_OS, ("yaffs_symlink\n"));
2442
2443 dev = yaffs_InodeToObject(dir)->myDev;
2444 yaffs_GrossLock(dev);
2445 obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name,
2446 - S_IFLNK | S_IRWXUGO, uid, gid, symname);
2447 + S_IFLNK | S_IRWXUGO, uid, gid, symname);
2448 yaffs_GrossUnlock(dev);
2449
2450 if (obj) {
2451 -
2452 struct inode *inode;
2453
2454 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
2455 d_instantiate(dentry, inode);
2456 - T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink created OK\n"));
2457 + T(YAFFS_TRACE_OS, ("symlink created OK\n"));
2458 return 0;
2459 } else {
2460 - T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink not created\n"));
2461 -
2462 + T(YAFFS_TRACE_OS, ("symlink not created\n"));
2463 }
2464
2465 return -ENOMEM;
2466 }
2467
2468 static int yaffs_sync_object(struct file *file, struct dentry *dentry,
2469 - int datasync)
2470 + int datasync)
2471 {
2472
2473 yaffs_Object *obj;
2474 @@ -1236,7 +1426,7 @@ static int yaffs_sync_object(struct file
2475
2476 dev = obj->myDev;
2477
2478 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_object\n"));
2479 + T(YAFFS_TRACE_OS, ("yaffs_sync_object\n"));
2480 yaffs_GrossLock(dev);
2481 yaffs_FlushFile(obj, 1);
2482 yaffs_GrossUnlock(dev);
2483 @@ -1255,41 +1445,36 @@ static int yaffs_rename(struct inode *ol
2484 int retVal = YAFFS_FAIL;
2485 yaffs_Object *target;
2486
2487 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_rename\n"));
2488 + T(YAFFS_TRACE_OS, ("yaffs_rename\n"));
2489 dev = yaffs_InodeToObject(old_dir)->myDev;
2490
2491 yaffs_GrossLock(dev);
2492
2493 /* Check if the target is an existing directory that is not empty. */
2494 - target =
2495 - yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
2496 - new_dentry->d_name.name);
2497 + target = yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
2498 + new_dentry->d_name.name);
2499
2500
2501
2502 - if (target &&
2503 - target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
2504 - !list_empty(&target->variant.directoryVariant.children)) {
2505 + if (target && target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
2506 + !ylist_empty(&target->variant.directoryVariant.children)) {
2507
2508 - T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
2509 + T(YAFFS_TRACE_OS, ("target is non-empty dir\n"));
2510
2511 retVal = YAFFS_FAIL;
2512 } else {
2513 -
2514 /* Now does unlinking internally using shadowing mechanism */
2515 - T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
2516 -
2517 - retVal =
2518 - yaffs_RenameObject(yaffs_InodeToObject(old_dir),
2519 - old_dentry->d_name.name,
2520 - yaffs_InodeToObject(new_dir),
2521 - new_dentry->d_name.name);
2522 + T(YAFFS_TRACE_OS, ("calling yaffs_RenameObject\n"));
2523
2524 + retVal = yaffs_RenameObject(yaffs_InodeToObject(old_dir),
2525 + old_dentry->d_name.name,
2526 + yaffs_InodeToObject(new_dir),
2527 + new_dentry->d_name.name);
2528 }
2529 yaffs_GrossUnlock(dev);
2530
2531 if (retVal == YAFFS_OK) {
2532 - if(target) {
2533 + if (target) {
2534 new_dentry->d_inode->i_nlink--;
2535 mark_inode_dirty(new_dentry->d_inode);
2536 }
2537 @@ -1298,7 +1483,6 @@ static int yaffs_rename(struct inode *ol
2538 } else {
2539 return -ENOTEMPTY;
2540 }
2541 -
2542 }
2543
2544 static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
2545 @@ -1308,15 +1492,15 @@ static int yaffs_setattr(struct dentry *
2546 yaffs_Device *dev;
2547
2548 T(YAFFS_TRACE_OS,
2549 - (KERN_DEBUG "yaffs_setattr of object %d\n",
2550 - yaffs_InodeToObject(inode)->objectId));
2551 -
2552 - if ((error = inode_change_ok(inode, attr)) == 0) {
2553 + ("yaffs_setattr of object %d\n",
2554 + yaffs_InodeToObject(inode)->objectId));
2555
2556 + error = inode_change_ok(inode, attr);
2557 + if (error == 0) {
2558 dev = yaffs_InodeToObject(inode)->myDev;
2559 yaffs_GrossLock(dev);
2560 if (yaffs_SetAttributes(yaffs_InodeToObject(inode), attr) ==
2561 - YAFFS_OK) {
2562 + YAFFS_OK) {
2563 error = 0;
2564 } else {
2565 error = -EPERM;
2566 @@ -1328,12 +1512,12 @@ static int yaffs_setattr(struct dentry *
2567 return error;
2568 }
2569
2570 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2571 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
2572 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
2573 {
2574 yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
2575 struct super_block *sb = dentry->d_sb;
2576 -#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2577 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2578 static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
2579 {
2580 yaffs_Device *dev = yaffs_SuperToDevice(sb);
2581 @@ -1343,32 +1527,53 @@ static int yaffs_statfs(struct super_blo
2582 yaffs_Device *dev = yaffs_SuperToDevice(sb);
2583 #endif
2584
2585 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n"));
2586 + T(YAFFS_TRACE_OS, ("yaffs_statfs\n"));
2587
2588 yaffs_GrossLock(dev);
2589
2590 buf->f_type = YAFFS_MAGIC;
2591 buf->f_bsize = sb->s_blocksize;
2592 buf->f_namelen = 255;
2593 - if (sb->s_blocksize > dev->nDataBytesPerChunk) {
2594 +
2595 + if (dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)) {
2596 + /* Do this if chunk size is not a power of 2 */
2597 +
2598 + uint64_t bytesInDev;
2599 + uint64_t bytesFree;
2600 +
2601 + bytesInDev = ((uint64_t)((dev->endBlock - dev->startBlock + 1))) *
2602 + ((uint64_t)(dev->nChunksPerBlock * dev->nDataBytesPerChunk));
2603 +
2604 + do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */
2605 + buf->f_blocks = bytesInDev;
2606 +
2607 + bytesFree = ((uint64_t)(yaffs_GetNumberOfFreeChunks(dev))) *
2608 + ((uint64_t)(dev->nDataBytesPerChunk));
2609 +
2610 + do_div(bytesFree, sb->s_blocksize);
2611 +
2612 + buf->f_bfree = bytesFree;
2613 +
2614 + } else if (sb->s_blocksize > dev->nDataBytesPerChunk) {
2615
2616 buf->f_blocks =
2617 - (dev->endBlock - dev->startBlock +
2618 - 1) * dev->nChunksPerBlock / (sb->s_blocksize /
2619 - dev->nDataBytesPerChunk);
2620 + (dev->endBlock - dev->startBlock + 1) *
2621 + dev->nChunksPerBlock /
2622 + (sb->s_blocksize / dev->nDataBytesPerChunk);
2623 buf->f_bfree =
2624 - yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
2625 - dev->nDataBytesPerChunk);
2626 + yaffs_GetNumberOfFreeChunks(dev) /
2627 + (sb->s_blocksize / dev->nDataBytesPerChunk);
2628 } else {
2629 -
2630 buf->f_blocks =
2631 - (dev->endBlock - dev->startBlock +
2632 - 1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk /
2633 - sb->s_blocksize);
2634 + (dev->endBlock - dev->startBlock + 1) *
2635 + dev->nChunksPerBlock *
2636 + (dev->nDataBytesPerChunk / sb->s_blocksize);
2637 +
2638 buf->f_bfree =
2639 - yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk /
2640 - sb->s_blocksize);
2641 + yaffs_GetNumberOfFreeChunks(dev) *
2642 + (dev->nDataBytesPerChunk / sb->s_blocksize);
2643 }
2644 +
2645 buf->f_files = 0;
2646 buf->f_ffree = 0;
2647 buf->f_bavail = buf->f_bfree;
2648 @@ -1378,18 +1583,19 @@ static int yaffs_statfs(struct super_blo
2649 }
2650
2651
2652 -/**
2653 static int yaffs_do_sync_fs(struct super_block *sb)
2654 {
2655
2656 yaffs_Device *dev = yaffs_SuperToDevice(sb);
2657 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_do_sync_fs\n"));
2658 + T(YAFFS_TRACE_OS, ("yaffs_do_sync_fs\n"));
2659
2660 - if(sb->s_dirt) {
2661 + if (sb->s_dirt) {
2662 yaffs_GrossLock(dev);
2663
2664 - if(dev)
2665 + if (dev) {
2666 + yaffs_FlushEntireDeviceCache(dev);
2667 yaffs_CheckpointSave(dev);
2668 + }
2669
2670 yaffs_GrossUnlock(dev);
2671
2672 @@ -1397,35 +1603,73 @@ static int yaffs_do_sync_fs(struct super
2673 }
2674 return 0;
2675 }
2676 -**/
2677
2678 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2679 +
2680 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
2681 static void yaffs_write_super(struct super_block *sb)
2682 #else
2683 static int yaffs_write_super(struct super_block *sb)
2684 #endif
2685 {
2686
2687 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n"));
2688 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
2689 - return 0; /* yaffs_do_sync_fs(sb);*/
2690 + T(YAFFS_TRACE_OS, ("yaffs_write_super\n"));
2691 + if (yaffs_auto_checkpoint >= 2)
2692 + yaffs_do_sync_fs(sb);
2693 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
2694 + return 0;
2695 #endif
2696 }
2697
2698
2699 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2700 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
2701 static int yaffs_sync_fs(struct super_block *sb, int wait)
2702 #else
2703 static int yaffs_sync_fs(struct super_block *sb)
2704 #endif
2705 {
2706 + T(YAFFS_TRACE_OS, ("yaffs_sync_fs\n"));
2707 +
2708 + if (yaffs_auto_checkpoint >= 1)
2709 + yaffs_do_sync_fs(sb);
2710 +
2711 + return 0;
2712 +}
2713 +
2714 +#ifdef YAFFS_USE_OWN_IGET
2715 +
2716 +static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
2717 +{
2718 + struct inode *inode;
2719 + yaffs_Object *obj;
2720 + yaffs_Device *dev = yaffs_SuperToDevice(sb);
2721 +
2722 + T(YAFFS_TRACE_OS,
2723 + ("yaffs_iget for %lu\n", ino));
2724
2725 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
2726 + inode = iget_locked(sb, ino);
2727 + if (!inode)
2728 + return ERR_PTR(-ENOMEM);
2729 + if (!(inode->i_state & I_NEW))
2730 + return inode;
2731 +
2732 + /* NB This is called as a side effect of other functions, but
2733 + * we had to release the lock to prevent deadlocks, so
2734 + * need to lock again.
2735 + */
2736
2737 - return 0; /* yaffs_do_sync_fs(sb);*/
2738 + yaffs_GrossLock(dev);
2739
2740 + obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
2741 +
2742 + yaffs_FillInodeFromObject(inode, obj);
2743 +
2744 + yaffs_GrossUnlock(dev);
2745 +
2746 + unlock_new_inode(inode);
2747 + return inode;
2748 }
2749
2750 +#else
2751
2752 static void yaffs_read_inode(struct inode *inode)
2753 {
2754 @@ -1438,7 +1682,7 @@ static void yaffs_read_inode(struct inod
2755 yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb);
2756
2757 T(YAFFS_TRACE_OS,
2758 - (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
2759 + ("yaffs_read_inode for %d\n", (int)inode->i_ino));
2760
2761 yaffs_GrossLock(dev);
2762
2763 @@ -1449,18 +1693,20 @@ static void yaffs_read_inode(struct inod
2764 yaffs_GrossUnlock(dev);
2765 }
2766
2767 -static LIST_HEAD(yaffs_dev_list);
2768 +#endif
2769 +
2770 +static YLIST_HEAD(yaffs_dev_list);
2771
2772 -#if 0 // not used
2773 +#if 0 /* not used */
2774 static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
2775 {
2776 yaffs_Device *dev = yaffs_SuperToDevice(sb);
2777
2778 - if( *flags & MS_RDONLY ) {
2779 + if (*flags & MS_RDONLY) {
2780 struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
2781
2782 T(YAFFS_TRACE_OS,
2783 - (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
2784 + ("yaffs_remount_fs: %s: RO\n", dev->name));
2785
2786 yaffs_GrossLock(dev);
2787
2788 @@ -1472,10 +1718,9 @@ static int yaffs_remount_fs(struct super
2789 mtd->sync(mtd);
2790
2791 yaffs_GrossUnlock(dev);
2792 - }
2793 - else {
2794 + } else {
2795 T(YAFFS_TRACE_OS,
2796 - (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
2797 + ("yaffs_remount_fs: %s: RW\n", dev->name));
2798 }
2799
2800 return 0;
2801 @@ -1486,7 +1731,7 @@ static void yaffs_put_super(struct super
2802 {
2803 yaffs_Device *dev = yaffs_SuperToDevice(sb);
2804
2805 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
2806 + T(YAFFS_TRACE_OS, ("yaffs_put_super\n"));
2807
2808 yaffs_GrossLock(dev);
2809
2810 @@ -1494,18 +1739,17 @@ static void yaffs_put_super(struct super
2811
2812 yaffs_CheckpointSave(dev);
2813
2814 - if (dev->putSuperFunc) {
2815 + if (dev->putSuperFunc)
2816 dev->putSuperFunc(sb);
2817 - }
2818
2819 yaffs_Deinitialise(dev);
2820
2821 yaffs_GrossUnlock(dev);
2822
2823 /* we assume this is protected by lock_kernel() in mount/umount */
2824 - list_del(&dev->devList);
2825 + ylist_del(&dev->devList);
2826
2827 - if(dev->spareBuffer){
2828 + if (dev->spareBuffer) {
2829 YFREE(dev->spareBuffer);
2830 dev->spareBuffer = NULL;
2831 }
2832 @@ -1516,12 +1760,10 @@ static void yaffs_put_super(struct super
2833
2834 static void yaffs_MTDPutSuper(struct super_block *sb)
2835 {
2836 -
2837 struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
2838
2839 - if (mtd->sync) {
2840 + if (mtd->sync)
2841 mtd->sync(mtd);
2842 - }
2843
2844 put_mtd_device(mtd);
2845 }
2846 @@ -1531,9 +1773,9 @@ static void yaffs_MarkSuperBlockDirty(vo
2847 {
2848 struct super_block *sb = (struct super_block *)vsb;
2849
2850 - T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
2851 -// if(sb)
2852 -// sb->s_dirt = 1;
2853 + T(YAFFS_TRACE_OS, ("yaffs_MarkSuperBlockDirty() sb = %p\n", sb));
2854 + if (sb)
2855 + sb->s_dirt = 1;
2856 }
2857
2858 typedef struct {
2859 @@ -1546,48 +1788,48 @@ typedef struct {
2860 #define MAX_OPT_LEN 20
2861 static int yaffs_parse_options(yaffs_options *options, const char *options_str)
2862 {
2863 - char cur_opt[MAX_OPT_LEN+1];
2864 + char cur_opt[MAX_OPT_LEN + 1];
2865 int p;
2866 int error = 0;
2867
2868 /* Parse through the options which is a comma seperated list */
2869
2870 - while(options_str && *options_str && !error){
2871 - memset(cur_opt,0,MAX_OPT_LEN+1);
2872 + while (options_str && *options_str && !error) {
2873 + memset(cur_opt, 0, MAX_OPT_LEN + 1);
2874 p = 0;
2875
2876 - while(*options_str && *options_str != ','){
2877 - if(p < MAX_OPT_LEN){
2878 + while (*options_str && *options_str != ',') {
2879 + if (p < MAX_OPT_LEN) {
2880 cur_opt[p] = *options_str;
2881 p++;
2882 }
2883 options_str++;
2884 }
2885
2886 - if(!strcmp(cur_opt,"inband-tags"))
2887 + if (!strcmp(cur_opt, "inband-tags"))
2888 options->inband_tags = 1;
2889 - else if(!strcmp(cur_opt,"no-cache"))
2890 + else if (!strcmp(cur_opt, "no-cache"))
2891 options->no_cache = 1;
2892 - else if(!strcmp(cur_opt,"no-checkpoint-read"))
2893 + else if (!strcmp(cur_opt, "no-checkpoint-read"))
2894 options->skip_checkpoint_read = 1;
2895 - else if(!strcmp(cur_opt,"no-checkpoint-write"))
2896 + else if (!strcmp(cur_opt, "no-checkpoint-write"))
2897 options->skip_checkpoint_write = 1;
2898 - else if(!strcmp(cur_opt,"no-checkpoint")){
2899 + else if (!strcmp(cur_opt, "no-checkpoint")) {
2900 options->skip_checkpoint_read = 1;
2901 options->skip_checkpoint_write = 1;
2902 } else {
2903 - printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
2904 + printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",
2905 + cur_opt);
2906 error = 1;
2907 }
2908 -
2909 }
2910
2911 return error;
2912 }
2913
2914 static struct super_block *yaffs_internal_read_super(int yaffsVersion,
2915 - struct super_block *sb,
2916 - void *data, int silent)
2917 + struct super_block *sb,
2918 + void *data, int silent)
2919 {
2920 int nBlocks;
2921 struct inode *inode = NULL;
2922 @@ -1602,6 +1844,7 @@ static struct super_block *yaffs_interna
2923
2924 sb->s_magic = YAFFS_MAGIC;
2925 sb->s_op = &yaffs_super_ops;
2926 + sb->s_flags |= MS_NOATIME;
2927
2928 if (!sb)
2929 printk(KERN_INFO "yaffs: sb is NULL\n");
2930 @@ -1614,14 +1857,14 @@ static struct super_block *yaffs_interna
2931 sb->s_dev,
2932 yaffs_devname(sb, devname_buf));
2933
2934 - if(!data_str)
2935 + if (!data_str)
2936 data_str = "";
2937
2938 - printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
2939 + printk(KERN_INFO "yaffs: passed flags \"%s\"\n", data_str);
2940
2941 - memset(&options,0,sizeof(options));
2942 + memset(&options, 0, sizeof(options));
2943
2944 - if(yaffs_parse_options(&options,data_str)){
2945 + if (yaffs_parse_options(&options, data_str)) {
2946 /* Option parsing failed */
2947 return NULL;
2948 }
2949 @@ -1645,9 +1888,9 @@ static struct super_block *yaffs_interna
2950 yaffs_devname(sb, devname_buf)));
2951
2952 /* Check it's an mtd device..... */
2953 - if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
2954 + if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
2955 return NULL; /* This isn't an mtd device */
2956 - }
2957 +
2958 /* Get the device */
2959 mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
2960 if (!mtd) {
2961 @@ -1673,29 +1916,23 @@ static struct super_block *yaffs_interna
2962 T(YAFFS_TRACE_OS, (" %s %d\n", WRITE_SIZE_STR, WRITE_SIZE(mtd)));
2963 T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
2964 T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
2965 - T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
2966 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
2967 + T(YAFFS_TRACE_OS, (" size %u\n", mtd->size));
2968 +#else
2969 + T(YAFFS_TRACE_OS, (" size %lld\n", mtd->size));
2970 +#endif
2971
2972 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
2973
2974 - if (yaffsVersion == 1 &&
2975 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2976 - mtd->writesize >= 2048) {
2977 -#else
2978 - mtd->oobblock >= 2048) {
2979 -#endif
2980 - T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
2981 - yaffsVersion = 2;
2982 + if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) {
2983 + T(YAFFS_TRACE_ALWAYS, ("yaffs: auto selecting yaffs2\n"));
2984 + yaffsVersion = 2;
2985 }
2986
2987 /* Added NCB 26/5/2006 for completeness */
2988 - if (yaffsVersion == 2 &&
2989 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2990 - mtd->writesize == 512) {
2991 -#else
2992 - mtd->oobblock == 512) {
2993 -#endif
2994 - T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
2995 - yaffsVersion = 1;
2996 + if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
2997 + T(YAFFS_TRACE_ALWAYS, ("yaffs: auto selecting yaffs1\n"));
2998 + yaffsVersion = 1;
2999 }
3000
3001 #endif
3002 @@ -1707,7 +1944,7 @@ static struct super_block *yaffs_interna
3003 !mtd->block_markbad ||
3004 !mtd->read ||
3005 !mtd->write ||
3006 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3007 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3008 !mtd->read_oob || !mtd->write_oob) {
3009 #else
3010 !mtd->write_ecc ||
3011 @@ -1719,12 +1956,9 @@ static struct super_block *yaffs_interna
3012 return NULL;
3013 }
3014
3015 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3016 - if (mtd->writesize < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
3017 -#else
3018 - if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
3019 -#endif
3020 - mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) {
3021 + if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
3022 + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
3023 + !options.inband_tags) {
3024 T(YAFFS_TRACE_ALWAYS,
3025 ("yaffs: MTD device does not have the "
3026 "right page sizes\n"));
3027 @@ -1735,7 +1969,7 @@ static struct super_block *yaffs_interna
3028 if (!mtd->erase ||
3029 !mtd->read ||
3030 !mtd->write ||
3031 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3032 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3033 !mtd->read_oob || !mtd->write_oob) {
3034 #else
3035 !mtd->write_ecc ||
3036 @@ -1761,7 +1995,7 @@ static struct super_block *yaffs_interna
3037 * Set the yaffs_Device up for mtd
3038 */
3039
3040 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
3041 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
3042 sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
3043 #else
3044 sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
3045 @@ -1780,13 +2014,15 @@ static struct super_block *yaffs_interna
3046
3047 /* Set up the memory size parameters.... */
3048
3049 - nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
3050 + nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK));
3051 +
3052 dev->startBlock = 0;
3053 dev->endBlock = nBlocks - 1;
3054 dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
3055 - dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
3056 + dev->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
3057 dev->nReservedBlocks = 5;
3058 dev->nShortOpCaches = (options.no_cache) ? 0 : 10;
3059 + dev->inbandTags = options.inband_tags;
3060
3061 /* ... and the functions. */
3062 if (yaffsVersion == 2) {
3063 @@ -1798,20 +2034,19 @@ static struct super_block *yaffs_interna
3064 dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
3065 dev->spareBuffer = YMALLOC(mtd->oobsize);
3066 dev->isYaffs2 = 1;
3067 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3068 - dev->nDataBytesPerChunk = mtd->writesize;
3069 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3070 + dev->totalBytesPerChunk = mtd->writesize;
3071 dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
3072 #else
3073 - dev->nDataBytesPerChunk = mtd->oobblock;
3074 + dev->totalBytesPerChunk = mtd->oobblock;
3075 dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
3076 #endif
3077 - nBlocks = mtd->size / mtd->erasesize;
3078 + nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize);
3079
3080 - dev->nCheckpointReservedBlocks = CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS;
3081 dev->startBlock = 0;
3082 dev->endBlock = nBlocks - 1;
3083 } else {
3084 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3085 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3086 /* use the MTD interface in yaffs_mtdif1.c */
3087 dev->writeChunkWithTagsToNAND =
3088 nandmtd1_WriteChunkWithTagsToNAND;
3089 @@ -1847,7 +2082,7 @@ static struct super_block *yaffs_interna
3090 dev->skipCheckpointWrite = options.skip_checkpoint_write;
3091
3092 /* we assume this is protected by lock_kernel() in mount/umount */
3093 - list_add_tail(&dev->devList, &yaffs_dev_list);
3094 + ylist_add_tail(&dev->devList, &yaffs_dev_list);
3095
3096 init_MUTEX(&dev->grossLock);
3097
3098 @@ -1884,20 +2119,23 @@ static struct super_block *yaffs_interna
3099 return NULL;
3100 }
3101 sb->s_root = root;
3102 + sb->s_dirt = !dev->isCheckpointed;
3103 + T(YAFFS_TRACE_ALWAYS,
3104 + ("yaffs_read_super: isCheckpointed %d\n", dev->isCheckpointed));
3105
3106 T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
3107 return sb;
3108 }
3109
3110
3111 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
3112 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
3113 static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
3114 int silent)
3115 {
3116 return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
3117 }
3118
3119 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3120 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3121 static int yaffs_read_super(struct file_system_type *fs,
3122 int flags, const char *dev_name,
3123 void *data, struct vfsmount *mnt)
3124 @@ -1938,14 +2176,14 @@ static DECLARE_FSTYPE(yaffs_fs_type, "ya
3125
3126 #ifdef CONFIG_YAFFS_YAFFS2
3127
3128 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
3129 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
3130 static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
3131 int silent)
3132 {
3133 return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
3134 }
3135
3136 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3137 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3138 static int yaffs2_read_super(struct file_system_type *fs,
3139 int flags, const char *dev_name, void *data,
3140 struct vfsmount *mnt)
3141 @@ -1990,12 +2228,12 @@ static char *yaffs_dump_dev(char *buf, y
3142 {
3143 buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
3144 buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
3145 + buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->totalBytesPerChunk);
3146 buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk);
3147 buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
3148 buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
3149 buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
3150 buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->nReservedBlocks);
3151 - buf += sprintf(buf, "nCheckptResBlocks.. %d\n", dev->nCheckpointReservedBlocks);
3152 buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint);
3153 buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
3154 buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
3155 @@ -2006,10 +2244,8 @@ static char *yaffs_dump_dev(char *buf, y
3156 buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
3157 buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
3158 buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
3159 - buf +=
3160 - sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
3161 - buf +=
3162 - sprintf(buf, "passiveGCs......... %d\n",
3163 + buf += sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
3164 + buf += sprintf(buf, "passiveGCs......... %d\n",
3165 dev->passiveGarbageCollections);
3166 buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
3167 buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->nShortOpCaches);
3168 @@ -2025,6 +2261,7 @@ static char *yaffs_dump_dev(char *buf, y
3169 sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
3170 buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
3171 buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
3172 + buf += sprintf(buf, "inbandTags......... %d\n", dev->inbandTags);
3173
3174 return buf;
3175 }
3176 @@ -2033,7 +2270,7 @@ static int yaffs_proc_read(char *page,
3177 char **start,
3178 off_t offset, int count, int *eof, void *data)
3179 {
3180 - struct list_head *item;
3181 + struct ylist_head *item;
3182 char *buf = page;
3183 int step = offset;
3184 int n = 0;
3185 @@ -2057,8 +2294,8 @@ static int yaffs_proc_read(char *page,
3186 lock_kernel();
3187
3188 /* Locate and print the Nth entry. Order N-squared but N is small. */
3189 - list_for_each(item, &yaffs_dev_list) {
3190 - yaffs_Device *dev = list_entry(item, yaffs_Device, devList);
3191 + ylist_for_each(item, &yaffs_dev_list) {
3192 + yaffs_Device *dev = ylist_entry(item, yaffs_Device, devList);
3193 if (n < step) {
3194 n++;
3195 continue;
3196 @@ -2119,7 +2356,7 @@ static int yaffs_proc_write(struct file
3197 char *end;
3198 char *mask_name;
3199 const char *x;
3200 - char substring[MAX_MASK_NAME_LENGTH+1];
3201 + char substring[MAX_MASK_NAME_LENGTH + 1];
3202 int i;
3203 int done = 0;
3204 int add, len = 0;
3205 @@ -2129,9 +2366,8 @@ static int yaffs_proc_write(struct file
3206
3207 while (!done && (pos < count)) {
3208 done = 1;
3209 - while ((pos < count) && isspace(buf[pos])) {
3210 + while ((pos < count) && isspace(buf[pos]))
3211 pos++;
3212 - }
3213
3214 switch (buf[pos]) {
3215 case '+':
3216 @@ -2148,20 +2384,21 @@ static int yaffs_proc_write(struct file
3217 mask_name = NULL;
3218
3219 mask_bitfield = simple_strtoul(buf + pos, &end, 0);
3220 +
3221 if (end > buf + pos) {
3222 mask_name = "numeral";
3223 len = end - (buf + pos);
3224 pos += len;
3225 done = 0;
3226 } else {
3227 - for(x = buf + pos, i = 0;
3228 - (*x == '_' || (*x >='a' && *x <= 'z')) &&
3229 - i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
3230 - substring[i] = *x;
3231 + for (x = buf + pos, i = 0;
3232 + (*x == '_' || (*x >= 'a' && *x <= 'z')) &&
3233 + i < MAX_MASK_NAME_LENGTH; x++, i++, pos++)
3234 + substring[i] = *x;
3235 substring[i] = '\0';
3236
3237 for (i = 0; mask_flags[i].mask_name != NULL; i++) {
3238 - if(strcmp(substring,mask_flags[i].mask_name) == 0){
3239 + if (strcmp(substring, mask_flags[i].mask_name) == 0) {
3240 mask_name = mask_flags[i].mask_name;
3241 mask_bitfield = mask_flags[i].mask_bitfield;
3242 done = 0;
3243 @@ -2172,7 +2409,7 @@ static int yaffs_proc_write(struct file
3244
3245 if (mask_name != NULL) {
3246 done = 0;
3247 - switch(add) {
3248 + switch (add) {
3249 case '-':
3250 rg &= ~mask_bitfield;
3251 break;
3252 @@ -2191,13 +2428,13 @@ static int yaffs_proc_write(struct file
3253
3254 yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS;
3255
3256 - printk("new trace = 0x%08X\n",yaffs_traceMask);
3257 + printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_traceMask);
3258
3259 if (rg & YAFFS_TRACE_ALWAYS) {
3260 for (i = 0; mask_flags[i].mask_name != NULL; i++) {
3261 char flag;
3262 flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-';
3263 - printk("%c%s\n", flag, mask_flags[i].mask_name);
3264 + printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name);
3265 }
3266 }
3267
3268 @@ -2211,12 +2448,8 @@ struct file_system_to_install {
3269 };
3270
3271 static struct file_system_to_install fs_to_install[] = {
3272 -//#ifdef CONFIG_YAFFS_YAFFS1
3273 {&yaffs_fs_type, 0},
3274 -//#endif
3275 -//#ifdef CONFIG_YAFFS_YAFFS2
3276 {&yaffs2_fs_type, 0},
3277 -//#endif
3278 {NULL, 0}
3279 };
3280
3281 @@ -2231,15 +2464,14 @@ static int __init init_yaffs_fs(void)
3282 /* Install the proc_fs entry */
3283 my_proc_entry = create_proc_entry("yaffs",
3284 S_IRUGO | S_IFREG,
3285 - &proc_root);
3286 + YPROC_ROOT);
3287
3288 if (my_proc_entry) {
3289 my_proc_entry->write_proc = yaffs_proc_write;
3290 my_proc_entry->read_proc = yaffs_proc_read;
3291 my_proc_entry->data = NULL;
3292 - } else {
3293 + } else
3294 return -ENOMEM;
3295 - }
3296
3297 /* Now add the file system entries */
3298
3299 @@ -2247,9 +2479,8 @@ static int __init init_yaffs_fs(void)
3300
3301 while (fsinst->fst && !error) {
3302 error = register_filesystem(fsinst->fst);
3303 - if (!error) {
3304 + if (!error)
3305 fsinst->installed = 1;
3306 - }
3307 fsinst++;
3308 }
3309
3310 @@ -2277,7 +2508,7 @@ static void __exit exit_yaffs_fs(void)
3311 T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
3312 " removing. \n"));
3313
3314 - remove_proc_entry("yaffs", &proc_root);
3315 + remove_proc_entry("yaffs", YPROC_ROOT);
3316
3317 fsinst = fs_to_install;
3318
3319 @@ -2288,7 +2519,6 @@ static void __exit exit_yaffs_fs(void)
3320 }
3321 fsinst++;
3322 }
3323 -
3324 }
3325
3326 module_init(init_yaffs_fs)
3327 --- /dev/null
3328 +++ b/fs/yaffs2/yaffs_getblockinfo.h
3329 @@ -0,0 +1,34 @@
3330 +/*
3331 + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
3332 + *
3333 + * Copyright (C) 2002-2007 Aleph One Ltd.
3334 + * for Toby Churchill Ltd and Brightstar Engineering
3335 + *
3336 + * Created by Charles Manning <charles@aleph1.co.uk>
3337 + *
3338 + * This program is free software; you can redistribute it and/or modify
3339 + * it under the terms of the GNU Lesser General Public License version 2.1 as
3340 + * published by the Free Software Foundation.
3341 + *
3342 + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
3343 + */
3344 +
3345 +#ifndef __YAFFS_GETBLOCKINFO_H__
3346 +#define __YAFFS_GETBLOCKINFO_H__
3347 +
3348 +#include "yaffs_guts.h"
3349 +
3350 +/* Function to manipulate block info */
3351 +static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
3352 +{
3353 + if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
3354 + T(YAFFS_TRACE_ERROR,
3355 + (TSTR
3356 + ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
3357 + blk));
3358 + YBUG();
3359 + }
3360 + return &dev->blockInfo[blk - dev->internalStartBlock];
3361 +}
3362 +
3363 +#endif
3364 --- a/fs/yaffs2/yaffs_guts.c
3365 +++ b/fs/yaffs2/yaffs_guts.c
3366 @@ -12,16 +12,17 @@
3367 */
3368
3369 const char *yaffs_guts_c_version =
3370 - "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
3371 + "$Id: yaffs_guts.c,v 1.82 2009-03-09 04:24:17 charles Exp $";
3372
3373 #include "yportenv.h"
3374
3375 #include "yaffsinterface.h"
3376 #include "yaffs_guts.h"
3377 #include "yaffs_tagsvalidity.h"
3378 +#include "yaffs_getblockinfo.h"
3379
3380 #include "yaffs_tagscompat.h"
3381 -#ifndef CONFIG_YAFFS_USE_OWN_SORT
3382 +#ifndef CONFIG_YAFFS_USE_OWN_SORT
3383 #include "yaffs_qsort.h"
3384 #endif
3385 #include "yaffs_nand.h"
3386 @@ -32,116 +33,116 @@ const char *yaffs_guts_c_version =
3387 #include "yaffs_packedtags2.h"
3388
3389
3390 -#ifdef CONFIG_YAFFS_WINCE
3391 -void yfsd_LockYAFFS(BOOL fsLockOnly);
3392 -void yfsd_UnlockYAFFS(BOOL fsLockOnly);
3393 -#endif
3394 -
3395 #define YAFFS_PASSIVE_GC_CHUNKS 2
3396
3397 #include "yaffs_ecc.h"
3398
3399
3400 /* Robustification (if it ever comes about...) */
3401 -static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND);
3402 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk);
3403 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
3404 - const __u8 * data,
3405 - const yaffs_ExtendedTags * tags);
3406 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
3407 - const yaffs_ExtendedTags * tags);
3408 +static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND);
3409 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND,
3410 + int erasedOk);
3411 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
3412 + const __u8 *data,
3413 + const yaffs_ExtendedTags *tags);
3414 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
3415 + const yaffs_ExtendedTags *tags);
3416
3417 /* Other local prototypes */
3418 -static int yaffs_UnlinkObject( yaffs_Object *obj);
3419 +static int yaffs_UnlinkObject(yaffs_Object *obj);
3420 static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj);
3421
3422 static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList);
3423
3424 -static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device * dev,
3425 - const __u8 * buffer,
3426 - yaffs_ExtendedTags * tags,
3427 - int useReserve);
3428 -static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
3429 - int chunkInNAND, int inScan);
3430 -
3431 -static yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
3432 - yaffs_ObjectType type);
3433 -static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
3434 - yaffs_Object * obj);
3435 -static int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name,
3436 - int force, int isShrink, int shadows);
3437 -static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj);
3438 +static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev,
3439 + const __u8 *buffer,
3440 + yaffs_ExtendedTags *tags,
3441 + int useReserve);
3442 +static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode,
3443 + int chunkInNAND, int inScan);
3444 +
3445 +static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
3446 + yaffs_ObjectType type);
3447 +static void yaffs_AddObjectToDirectory(yaffs_Object *directory,
3448 + yaffs_Object *obj);
3449 +static int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name,
3450 + int force, int isShrink, int shadows);
3451 +static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj);
3452 static int yaffs_CheckStructures(void);
3453 -static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
3454 - int chunkOffset, int *limit);
3455 -static int yaffs_DoGenericObjectDeletion(yaffs_Object * in);
3456 -
3457 -static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
3458 -
3459 -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
3460 -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
3461 - int lineNo);
3462 +static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
3463 + int chunkOffset, int *limit);
3464 +static int yaffs_DoGenericObjectDeletion(yaffs_Object *in);
3465 +
3466 +static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device *dev, int blockNo);
3467
3468 -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
3469 - int chunkInNAND);
3470
3471 -static int yaffs_UnlinkWorker(yaffs_Object * obj);
3472 -static void yaffs_DestroyObject(yaffs_Object * obj);
3473 +static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
3474 + int chunkInNAND);
3475
3476 -static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
3477 - int chunkInObject);
3478 +static int yaffs_UnlinkWorker(yaffs_Object *obj);
3479
3480 -loff_t yaffs_GetFileSize(yaffs_Object * obj);
3481 +static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId,
3482 + int chunkInObject);
3483
3484 -static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr);
3485 +static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve,
3486 + yaffs_BlockInfo **blockUsedPtr);
3487
3488 -static void yaffs_VerifyFreeChunks(yaffs_Device * dev);
3489 +static void yaffs_VerifyFreeChunks(yaffs_Device *dev);
3490
3491 static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in);
3492
3493 +static void yaffs_VerifyDirectory(yaffs_Object *directory);
3494 #ifdef YAFFS_PARANOID
3495 -static int yaffs_CheckFileSanity(yaffs_Object * in);
3496 +static int yaffs_CheckFileSanity(yaffs_Object *in);
3497 #else
3498 #define yaffs_CheckFileSanity(in)
3499 #endif
3500
3501 -static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in);
3502 -static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId);
3503 +static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in);
3504 +static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId);
3505
3506 static void yaffs_InvalidateCheckpoint(yaffs_Device *dev);
3507
3508 -static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
3509 - yaffs_ExtendedTags * tags);
3510 +static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode,
3511 + yaffs_ExtendedTags *tags);
3512
3513 -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos);
3514 -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
3515 - yaffs_FileStructure * fStruct,
3516 - __u32 chunkId);
3517 +static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn,
3518 + unsigned pos);
3519 +static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,
3520 + yaffs_FileStructure *fStruct,
3521 + __u32 chunkId);
3522
3523
3524 /* Function to calculate chunk and offset */
3525
3526 -static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
3527 +static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut,
3528 + __u32 *offsetOut)
3529 {
3530 - if(dev->chunkShift){
3531 - /* Easy-peasy power of 2 case */
3532 - *chunk = (__u32)(addr >> dev->chunkShift);
3533 - *offset = (__u32)(addr & dev->chunkMask);
3534 - }
3535 - else if(dev->crumbsPerChunk)
3536 - {
3537 - /* Case where we're using "crumbs" */
3538 - *offset = (__u32)(addr & dev->crumbMask);
3539 - addr >>= dev->crumbShift;
3540 - *chunk = ((__u32)addr)/dev->crumbsPerChunk;
3541 - *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
3542 + int chunk;
3543 + __u32 offset;
3544 +
3545 + chunk = (__u32)(addr >> dev->chunkShift);
3546 +
3547 + if (dev->chunkDiv == 1) {
3548 + /* easy power of 2 case */
3549 + offset = (__u32)(addr & dev->chunkMask);
3550 + } else {
3551 + /* Non power-of-2 case */
3552 +
3553 + loff_t chunkBase;
3554 +
3555 + chunk /= dev->chunkDiv;
3556 +
3557 + chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk;
3558 + offset = (__u32)(addr - chunkBase);
3559 }
3560 - else
3561 - YBUG();
3562 +
3563 + *chunkOut = chunk;
3564 + *offsetOut = offset;
3565 }
3566
3567 -/* Function to return the number of shifts for a power of 2 greater than or equal
3568 - * to the given number
3569 +/* Function to return the number of shifts for a power of 2 greater than or
3570 + * equal to the given number
3571 * Note we don't try to cater for all possible numbers and this does not have to
3572 * be hellishly efficient.
3573 */
3574 @@ -153,13 +154,14 @@ static __u32 ShiftsGE(__u32 x)
3575
3576 nShifts = extraBits = 0;
3577
3578 - while(x>1){
3579 - if(x & 1) extraBits++;
3580 - x>>=1;
3581 + while (x > 1) {
3582 + if (x & 1)
3583 + extraBits++;
3584 + x >>= 1;
3585 nShifts++;
3586 }
3587
3588 - if(extraBits)
3589 + if (extraBits)
3590 nShifts++;
3591
3592 return nShifts;
3593 @@ -168,16 +170,17 @@ static __u32 ShiftsGE(__u32 x)
3594 /* Function to return the number of shifts to get a 1 in bit 0
3595 */
3596
3597 -static __u32 ShiftDiv(__u32 x)
3598 +static __u32 Shifts(__u32 x)
3599 {
3600 int nShifts;
3601
3602 nShifts = 0;
3603
3604 - if(!x) return 0;
3605 + if (!x)
3606 + return 0;
3607
3608 - while( !(x&1)){
3609 - x>>=1;
3610 + while (!(x&1)) {
3611 + x >>= 1;
3612 nShifts++;
3613 }
3614
3615 @@ -195,21 +198,25 @@ static int yaffs_InitialiseTempBuffers(y
3616 int i;
3617 __u8 *buf = (__u8 *)1;
3618
3619 - memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
3620 + memset(dev->tempBuffer, 0, sizeof(dev->tempBuffer));
3621
3622 for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
3623 dev->tempBuffer[i].line = 0; /* not in use */
3624 dev->tempBuffer[i].buffer = buf =
3625 - YMALLOC_DMA(dev->nDataBytesPerChunk);
3626 + YMALLOC_DMA(dev->totalBytesPerChunk);
3627 }
3628
3629 return buf ? YAFFS_OK : YAFFS_FAIL;
3630 -
3631 }
3632
3633 -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
3634 +__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo)
3635 {
3636 int i, j;
3637 +
3638 + dev->tempInUse++;
3639 + if (dev->tempInUse > dev->maxTemp)
3640 + dev->maxTemp = dev->tempInUse;
3641 +
3642 for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3643 if (dev->tempBuffer[i].line == 0) {
3644 dev->tempBuffer[i].line = lineNo;
3645 @@ -227,9 +234,9 @@ static __u8 *yaffs_GetTempBuffer(yaffs_D
3646 T(YAFFS_TRACE_BUFFERS,
3647 (TSTR("Out of temp buffers at line %d, other held by lines:"),
3648 lineNo));
3649 - for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3650 + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
3651 T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line));
3652 - }
3653 +
3654 T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
3655
3656 /*
3657 @@ -242,10 +249,13 @@ static __u8 *yaffs_GetTempBuffer(yaffs_D
3658
3659 }
3660
3661 -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
3662 +void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer,
3663 int lineNo)
3664 {
3665 int i;
3666 +
3667 + dev->tempInUse--;
3668 +
3669 for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3670 if (dev->tempBuffer[i].buffer == buffer) {
3671 dev->tempBuffer[i].line = 0;
3672 @@ -267,27 +277,26 @@ static void yaffs_ReleaseTempBuffer(yaff
3673 /*
3674 * Determine if we have a managed buffer.
3675 */
3676 -int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer)
3677 +int yaffs_IsManagedTempBuffer(yaffs_Device *dev, const __u8 *buffer)
3678 {
3679 int i;
3680 +
3681 for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3682 if (dev->tempBuffer[i].buffer == buffer)
3683 return 1;
3684 + }
3685
3686 + for (i = 0; i < dev->nShortOpCaches; i++) {
3687 + if (dev->srCache[i].data == buffer)
3688 + return 1;
3689 }
3690
3691 - for (i = 0; i < dev->nShortOpCaches; i++) {
3692 - if( dev->srCache[i].data == buffer )
3693 - return 1;
3694 -
3695 - }
3696 -
3697 - if (buffer == dev->checkpointBuffer)
3698 - return 1;
3699 -
3700 - T(YAFFS_TRACE_ALWAYS,
3701 - (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
3702 - return 0;
3703 + if (buffer == dev->checkpointBuffer)
3704 + return 1;
3705 +
3706 + T(YAFFS_TRACE_ALWAYS,
3707 + (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
3708 + return 0;
3709 }
3710
3711
3712 @@ -296,62 +305,63 @@ int yaffs_IsManagedTempBuffer(yaffs_Devi
3713 * Chunk bitmap manipulations
3714 */
3715
3716 -static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device * dev, int blk)
3717 +static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device *dev, int blk)
3718 {
3719 if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
3720 T(YAFFS_TRACE_ERROR,
3721 - (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
3722 - blk));
3723 + (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
3724 + blk));
3725 YBUG();
3726 }
3727 return dev->chunkBits +
3728 - (dev->chunkBitmapStride * (blk - dev->internalStartBlock));
3729 + (dev->chunkBitmapStride * (blk - dev->internalStartBlock));
3730 }
3731
3732 static Y_INLINE void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk)
3733 {
3734 - if(blk < dev->internalStartBlock || blk > dev->internalEndBlock ||
3735 - chunk < 0 || chunk >= dev->nChunksPerBlock) {
3736 - T(YAFFS_TRACE_ERROR,
3737 - (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),blk,chunk));
3738 - YBUG();
3739 + if (blk < dev->internalStartBlock || blk > dev->internalEndBlock ||
3740 + chunk < 0 || chunk >= dev->nChunksPerBlock) {
3741 + T(YAFFS_TRACE_ERROR,
3742 + (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),
3743 + blk, chunk));
3744 + YBUG();
3745 }
3746 }
3747
3748 -static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device * dev, int blk)
3749 +static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device *dev, int blk)
3750 {
3751 __u8 *blkBits = yaffs_BlockBits(dev, blk);
3752
3753 memset(blkBits, 0, dev->chunkBitmapStride);
3754 }
3755
3756 -static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
3757 +static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk)
3758 {
3759 __u8 *blkBits = yaffs_BlockBits(dev, blk);
3760
3761 - yaffs_VerifyChunkBitId(dev,blk,chunk);
3762 + yaffs_VerifyChunkBitId(dev, blk, chunk);
3763
3764 blkBits[chunk / 8] &= ~(1 << (chunk & 7));
3765 }
3766
3767 -static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
3768 +static Y_INLINE void yaffs_SetChunkBit(yaffs_Device *dev, int blk, int chunk)
3769 {
3770 __u8 *blkBits = yaffs_BlockBits(dev, blk);
3771
3772 - yaffs_VerifyChunkBitId(dev,blk,chunk);
3773 + yaffs_VerifyChunkBitId(dev, blk, chunk);
3774
3775 blkBits[chunk / 8] |= (1 << (chunk & 7));
3776 }
3777
3778 -static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device * dev, int blk, int chunk)
3779 +static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk)
3780 {
3781 __u8 *blkBits = yaffs_BlockBits(dev, blk);
3782 - yaffs_VerifyChunkBitId(dev,blk,chunk);
3783 + yaffs_VerifyChunkBitId(dev, blk, chunk);
3784
3785 return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
3786 }
3787
3788 -static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device * dev, int blk)
3789 +static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk)
3790 {
3791 __u8 *blkBits = yaffs_BlockBits(dev, blk);
3792 int i;
3793 @@ -363,17 +373,17 @@ static Y_INLINE int yaffs_StillSomeChunk
3794 return 0;
3795 }
3796
3797 -static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
3798 +static int yaffs_CountChunkBits(yaffs_Device *dev, int blk)
3799 {
3800 __u8 *blkBits = yaffs_BlockBits(dev, blk);
3801 int i;
3802 int n = 0;
3803 for (i = 0; i < dev->chunkBitmapStride; i++) {
3804 __u8 x = *blkBits;
3805 - while(x){
3806 - if(x & 1)
3807 + while (x) {
3808 + if (x & 1)
3809 n++;
3810 - x >>=1;
3811 + x >>= 1;
3812 }
3813
3814 blkBits++;
3815 @@ -400,7 +410,7 @@ static int yaffs_SkipNANDVerification(ya
3816 return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
3817 }
3818
3819 -static const char * blockStateName[] = {
3820 +static const char *blockStateName[] = {
3821 "Unknown",
3822 "Needs scanning",
3823 "Scanning",
3824 @@ -413,64 +423,65 @@ static const char * blockStateName[] = {
3825 "Dead"
3826 };
3827
3828 -static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
3829 +static void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
3830 {
3831 int actuallyUsed;
3832 int inUse;
3833
3834 - if(yaffs_SkipVerification(dev))
3835 + if (yaffs_SkipVerification(dev))
3836 return;
3837
3838 /* Report illegal runtime states */
3839 - if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
3840 - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
3841 + if (bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
3842 + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->blockState));
3843
3844 - switch(bi->blockState){
3845 - case YAFFS_BLOCK_STATE_UNKNOWN:
3846 - case YAFFS_BLOCK_STATE_SCANNING:
3847 - case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
3848 - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
3849 - n,blockStateName[bi->blockState]));
3850 + switch (bi->blockState) {
3851 + case YAFFS_BLOCK_STATE_UNKNOWN:
3852 + case YAFFS_BLOCK_STATE_SCANNING:
3853 + case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
3854 + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR),
3855 + n, blockStateName[bi->blockState]));
3856 }
3857
3858 /* Check pages in use and soft deletions are legal */
3859
3860 actuallyUsed = bi->pagesInUse - bi->softDeletions;
3861
3862 - if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
3863 + if (bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
3864 bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
3865 actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
3866 - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
3867 - n,bi->pagesInUse,bi->softDeletions));
3868 + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
3869 + n, bi->pagesInUse, bi->softDeletions));
3870
3871
3872 /* Check chunk bitmap legal */
3873 - inUse = yaffs_CountChunkBits(dev,n);
3874 - if(inUse != bi->pagesInUse)
3875 - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
3876 - n,bi->pagesInUse,inUse));
3877 + inUse = yaffs_CountChunkBits(dev, n);
3878 + if (inUse != bi->pagesInUse)
3879 + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
3880 + n, bi->pagesInUse, inUse));
3881
3882 /* Check that the sequence number is valid.
3883 * Ten million is legal, but is very unlikely
3884 */
3885 - if(dev->isYaffs2 &&
3886 + if (dev->isYaffs2 &&
3887 (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
3888 - (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
3889 - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
3890 - n,bi->sequenceNumber));
3891 -
3892 + (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000))
3893 + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has suspect sequence number of %d"TENDSTR),
3894 + n, bi->sequenceNumber));
3895 }
3896
3897 -static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
3898 +static void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi,
3899 + int n)
3900 {
3901 - yaffs_VerifyBlock(dev,bi,n);
3902 + yaffs_VerifyBlock(dev, bi, n);
3903
3904 /* After collection the block should be in the erased state */
3905 - /* TODO: This will need to change if we do partial gc */
3906 + /* This will need to change if we do partial gc */
3907
3908 - if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
3909 - T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
3910 - n,bi->blockState));
3911 + if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING &&
3912 + bi->blockState != YAFFS_BLOCK_STATE_EMPTY) {
3913 + T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
3914 + n, bi->blockState));
3915 }
3916 }
3917
3918 @@ -480,52 +491,49 @@ static void yaffs_VerifyBlocks(yaffs_Dev
3919 int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
3920 int nIllegalBlockStates = 0;
3921
3922 -
3923 - if(yaffs_SkipVerification(dev))
3924 + if (yaffs_SkipVerification(dev))
3925 return;
3926
3927 - memset(nBlocksPerState,0,sizeof(nBlocksPerState));
3928 -
3929 + memset(nBlocksPerState, 0, sizeof(nBlocksPerState));
3930
3931 - for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
3932 - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
3933 - yaffs_VerifyBlock(dev,bi,i);
3934 + for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
3935 + yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
3936 + yaffs_VerifyBlock(dev, bi, i);
3937
3938 - if(bi->blockState >=0 && bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
3939 + if (bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
3940 nBlocksPerState[bi->blockState]++;
3941 else
3942 nIllegalBlockStates++;
3943 -
3944 }
3945
3946 - T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
3947 - T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
3948 + T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
3949 + T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR)));
3950
3951 - T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
3952 - if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
3953 - T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
3954 + T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), nIllegalBlockStates));
3955 + if (nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
3956 + T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR)));
3957
3958 - for(i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
3959 + for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
3960 T(YAFFS_TRACE_VERIFY,
3961 (TSTR("%s %d blocks"TENDSTR),
3962 - blockStateName[i],nBlocksPerState[i]));
3963 + blockStateName[i], nBlocksPerState[i]));
3964
3965 - if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
3966 + if (dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
3967 T(YAFFS_TRACE_VERIFY,
3968 (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
3969 dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
3970
3971 - if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
3972 + if (dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
3973 T(YAFFS_TRACE_VERIFY,
3974 (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
3975 dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
3976
3977 - if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
3978 + if (nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
3979 T(YAFFS_TRACE_VERIFY,
3980 (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
3981 nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING]));
3982
3983 - T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
3984 + T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
3985
3986 }
3987
3988 @@ -535,26 +543,26 @@ static void yaffs_VerifyBlocks(yaffs_Dev
3989 */
3990 static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)
3991 {
3992 - if(yaffs_SkipVerification(obj->myDev))
3993 + if (obj && yaffs_SkipVerification(obj->myDev))
3994 return;
3995
3996 - if(!(tags && obj && oh)){
3997 - T(YAFFS_TRACE_VERIFY,
3998 - (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
3999 - (__u32)tags,(__u32)obj,(__u32)oh));
4000 + if (!(tags && obj && oh)) {
4001 + T(YAFFS_TRACE_VERIFY,
4002 + (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
4003 + (__u32)tags, (__u32)obj, (__u32)oh));
4004 return;
4005 }
4006
4007 - if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
4008 - oh->type > YAFFS_OBJECT_TYPE_MAX)
4009 - T(YAFFS_TRACE_VERIFY,
4010 - (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
4011 - tags->objectId, oh->type));
4012 -
4013 - if(tags->objectId != obj->objectId)
4014 - T(YAFFS_TRACE_VERIFY,
4015 - (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
4016 - tags->objectId, obj->objectId));
4017 + if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
4018 + oh->type > YAFFS_OBJECT_TYPE_MAX)
4019 + T(YAFFS_TRACE_VERIFY,
4020 + (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
4021 + tags->objectId, oh->type));
4022 +
4023 + if (tags->objectId != obj->objectId)
4024 + T(YAFFS_TRACE_VERIFY,
4025 + (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
4026 + tags->objectId, obj->objectId));
4027
4028
4029 /*
4030 @@ -563,46 +571,43 @@ static void yaffs_VerifyObjectHeader(yaf
4031 * Tests do not apply to the root object.
4032 */
4033
4034 - if(parentCheck && tags->objectId > 1 && !obj->parent)
4035 - T(YAFFS_TRACE_VERIFY,
4036 - (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
4037 - tags->objectId, oh->parentObjectId));
4038 -
4039 -
4040 - if(parentCheck && obj->parent &&
4041 - oh->parentObjectId != obj->parent->objectId &&
4042 - (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
4043 - obj->parent->objectId != YAFFS_OBJECTID_DELETED))
4044 - T(YAFFS_TRACE_VERIFY,
4045 - (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
4046 - tags->objectId, oh->parentObjectId, obj->parent->objectId));
4047 + if (parentCheck && tags->objectId > 1 && !obj->parent)
4048 + T(YAFFS_TRACE_VERIFY,
4049 + (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
4050 + tags->objectId, oh->parentObjectId));
4051
4052 + if (parentCheck && obj->parent &&
4053 + oh->parentObjectId != obj->parent->objectId &&
4054 + (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
4055 + obj->parent->objectId != YAFFS_OBJECTID_DELETED))
4056 + T(YAFFS_TRACE_VERIFY,
4057 + (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
4058 + tags->objectId, oh->parentObjectId, obj->parent->objectId));
4059
4060 - if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
4061 + if (tags->objectId > 1 && oh->name[0] == 0) /* Null name */
4062 T(YAFFS_TRACE_VERIFY,
4063 - (TSTR("Obj %d header name is NULL"TENDSTR),
4064 - obj->objectId));
4065 + (TSTR("Obj %d header name is NULL"TENDSTR),
4066 + obj->objectId));
4067
4068 - if(tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
4069 + if (tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
4070 T(YAFFS_TRACE_VERIFY,
4071 - (TSTR("Obj %d header name is 0xFF"TENDSTR),
4072 - obj->objectId));
4073 + (TSTR("Obj %d header name is 0xFF"TENDSTR),
4074 + obj->objectId));
4075 }
4076
4077
4078
4079 -static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
4080 - __u32 level, int chunkOffset)
4081 +static int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
4082 + __u32 level, int chunkOffset)
4083 {
4084 int i;
4085 yaffs_Device *dev = obj->myDev;
4086 int ok = 1;
4087 - int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4088
4089 if (tn) {
4090 if (level > 0) {
4091
4092 - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
4093 + for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
4094 if (tn->internal[i]) {
4095 ok = yaffs_VerifyTnodeWorker(obj,
4096 tn->internal[i],
4097 @@ -611,20 +616,19 @@ static int yaffs_VerifyTnodeWorker(yaffs
4098 }
4099 }
4100 } else if (level == 0) {
4101 - int i;
4102 yaffs_ExtendedTags tags;
4103 __u32 objectId = obj->objectId;
4104
4105 chunkOffset <<= YAFFS_TNODES_LEVEL0_BITS;
4106
4107 - for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
4108 - __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
4109 + for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) {
4110 + __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
4111
4112 - if(theChunk > 0){
4113 + if (theChunk > 0) {
4114 /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
4115 - yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
4116 - if(tags.objectId != objectId || tags.chunkId != chunkOffset){
4117 - T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4118 + yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags);
4119 + if (tags.objectId != objectId || tags.chunkId != chunkOffset) {
4120 + T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4121 objectId, chunkOffset, theChunk,
4122 tags.objectId, tags.chunkId));
4123 }
4124 @@ -646,13 +650,15 @@ static void yaffs_VerifyFile(yaffs_Objec
4125 __u32 lastChunk;
4126 __u32 x;
4127 __u32 i;
4128 - int ok;
4129 yaffs_Device *dev;
4130 yaffs_ExtendedTags tags;
4131 yaffs_Tnode *tn;
4132 __u32 objectId;
4133
4134 - if(obj && yaffs_SkipVerification(obj->myDev))
4135 + if (!obj)
4136 + return;
4137 +
4138 + if (yaffs_SkipVerification(obj->myDev))
4139 return;
4140
4141 dev = obj->myDev;
4142 @@ -662,17 +668,17 @@ static void yaffs_VerifyFile(yaffs_Objec
4143 lastChunk = obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
4144 x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
4145 requiredTallness = 0;
4146 - while (x> 0) {
4147 + while (x > 0) {
4148 x >>= YAFFS_TNODES_INTERNAL_BITS;
4149 requiredTallness++;
4150 }
4151
4152 actualTallness = obj->variant.fileVariant.topLevel;
4153
4154 - if(requiredTallness > actualTallness )
4155 + if (requiredTallness > actualTallness)
4156 T(YAFFS_TRACE_VERIFY,
4157 (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
4158 - obj->objectId,actualTallness, requiredTallness));
4159 + obj->objectId, actualTallness, requiredTallness));
4160
4161
4162 /* Check that the chunks in the tnode tree are all correct.
4163 @@ -680,39 +686,31 @@ static void yaffs_VerifyFile(yaffs_Objec
4164 * checking the tags for every chunk match.
4165 */
4166
4167 - if(yaffs_SkipNANDVerification(dev))
4168 + if (yaffs_SkipNANDVerification(dev))
4169 return;
4170
4171 - for(i = 1; i <= lastChunk; i++){
4172 - tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
4173 + for (i = 1; i <= lastChunk; i++) {
4174 + tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant, i);
4175
4176 if (tn) {
4177 - __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
4178 - if(theChunk > 0){
4179 + __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
4180 + if (theChunk > 0) {
4181 /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */
4182 - yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
4183 - if(tags.objectId != objectId || tags.chunkId != i){
4184 - T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4185 + yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags);
4186 + if (tags.objectId != objectId || tags.chunkId != i) {
4187 + T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4188 objectId, i, theChunk,
4189 tags.objectId, tags.chunkId));
4190 }
4191 }
4192 }
4193 -
4194 }
4195 -
4196 }
4197
4198 -static void yaffs_VerifyDirectory(yaffs_Object *obj)
4199 -{
4200 - if(obj && yaffs_SkipVerification(obj->myDev))
4201 - return;
4202 -
4203 -}
4204
4205 static void yaffs_VerifyHardLink(yaffs_Object *obj)
4206 {
4207 - if(obj && yaffs_SkipVerification(obj->myDev))
4208 + if (obj && yaffs_SkipVerification(obj->myDev))
4209 return;
4210
4211 /* Verify sane equivalent object */
4212 @@ -720,7 +718,7 @@ static void yaffs_VerifyHardLink(yaffs_O
4213
4214 static void yaffs_VerifySymlink(yaffs_Object *obj)
4215 {
4216 - if(obj && yaffs_SkipVerification(obj->myDev))
4217 + if (obj && yaffs_SkipVerification(obj->myDev))
4218 return;
4219
4220 /* Verify symlink string */
4221 @@ -728,7 +726,7 @@ static void yaffs_VerifySymlink(yaffs_Ob
4222
4223 static void yaffs_VerifySpecial(yaffs_Object *obj)
4224 {
4225 - if(obj && yaffs_SkipVerification(obj->myDev))
4226 + if (obj && yaffs_SkipVerification(obj->myDev))
4227 return;
4228 }
4229
4230 @@ -740,14 +738,19 @@ static void yaffs_VerifyObject(yaffs_Obj
4231 __u32 chunkMax;
4232
4233 __u32 chunkIdOk;
4234 - __u32 chunkIsLive;
4235 + __u32 chunkInRange;
4236 + __u32 chunkShouldNotBeDeleted;
4237 + __u32 chunkValid;
4238 +
4239 + if (!obj)
4240 + return;
4241
4242 - if(!obj)
4243 + if (obj->beingCreated)
4244 return;
4245
4246 dev = obj->myDev;
4247
4248 - if(yaffs_SkipVerification(dev))
4249 + if (yaffs_SkipVerification(dev))
4250 return;
4251
4252 /* Check sane object header chunk */
4253 @@ -755,50 +758,54 @@ static void yaffs_VerifyObject(yaffs_Obj
4254 chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
4255 chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
4256
4257 - chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
4258 - chunkIsLive = chunkIdOk &&
4259 + chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax);
4260 + chunkIdOk = chunkInRange || obj->hdrChunk == 0;
4261 + chunkValid = chunkInRange &&
4262 yaffs_CheckChunkBit(dev,
4263 - obj->chunkId / dev->nChunksPerBlock,
4264 - obj->chunkId % dev->nChunksPerBlock);
4265 - if(!obj->fake &&
4266 - (!chunkIdOk || !chunkIsLive)) {
4267 - T(YAFFS_TRACE_VERIFY,
4268 - (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
4269 - obj->objectId,obj->chunkId,
4270 - chunkIdOk ? "" : ",out of range",
4271 - chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
4272 + obj->hdrChunk / dev->nChunksPerBlock,
4273 + obj->hdrChunk % dev->nChunksPerBlock);
4274 + chunkShouldNotBeDeleted = chunkInRange && !chunkValid;
4275 +
4276 + if (!obj->fake &&
4277 + (!chunkIdOk || chunkShouldNotBeDeleted)) {
4278 + T(YAFFS_TRACE_VERIFY,
4279 + (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
4280 + obj->objectId, obj->hdrChunk,
4281 + chunkIdOk ? "" : ",out of range",
4282 + chunkShouldNotBeDeleted ? ",marked as deleted" : ""));
4283 }
4284
4285 - if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
4286 + if (chunkValid && !yaffs_SkipNANDVerification(dev)) {
4287 yaffs_ExtendedTags tags;
4288 yaffs_ObjectHeader *oh;
4289 - __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
4290 + __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
4291
4292 oh = (yaffs_ObjectHeader *)buffer;
4293
4294 - yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
4295 + yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer,
4296 + &tags);
4297
4298 - yaffs_VerifyObjectHeader(obj,oh,&tags,1);
4299 + yaffs_VerifyObjectHeader(obj, oh, &tags, 1);
4300
4301 - yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
4302 + yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
4303 }
4304
4305 /* Verify it has a parent */
4306 - if(obj && !obj->fake &&
4307 - (!obj->parent || obj->parent->myDev != dev)){
4308 - T(YAFFS_TRACE_VERIFY,
4309 - (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
4310 - obj->objectId,obj->parent));
4311 + if (obj && !obj->fake &&
4312 + (!obj->parent || obj->parent->myDev != dev)) {
4313 + T(YAFFS_TRACE_VERIFY,
4314 + (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
4315 + obj->objectId, obj->parent));
4316 }
4317
4318 /* Verify parent is a directory */
4319 - if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
4320 - T(YAFFS_TRACE_VERIFY,
4321 - (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
4322 - obj->objectId,obj->parent->variantType));
4323 + if (obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
4324 + T(YAFFS_TRACE_VERIFY,
4325 + (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
4326 + obj->objectId, obj->parent->variantType));
4327 }
4328
4329 - switch(obj->variantType){
4330 + switch (obj->variantType) {
4331 case YAFFS_OBJECT_TYPE_FILE:
4332 yaffs_VerifyFile(obj);
4333 break;
4334 @@ -818,33 +825,30 @@ static void yaffs_VerifyObject(yaffs_Obj
4335 default:
4336 T(YAFFS_TRACE_VERIFY,
4337 (TSTR("Obj %d has illegaltype %d"TENDSTR),
4338 - obj->objectId,obj->variantType));
4339 + obj->objectId, obj->variantType));
4340 break;
4341 }
4342 -
4343 -
4344 }
4345
4346 static void yaffs_VerifyObjects(yaffs_Device *dev)
4347 {
4348 yaffs_Object *obj;
4349 int i;
4350 - struct list_head *lh;
4351 + struct ylist_head *lh;
4352
4353 - if(yaffs_SkipVerification(dev))
4354 + if (yaffs_SkipVerification(dev))
4355 return;
4356
4357 /* Iterate through the objects in each hash entry */
4358
4359 - for(i = 0; i < YAFFS_NOBJECT_BUCKETS; i++){
4360 - list_for_each(lh, &dev->objectBucket[i].list) {
4361 + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
4362 + ylist_for_each(lh, &dev->objectBucket[i].list) {
4363 if (lh) {
4364 - obj = list_entry(lh, yaffs_Object, hashLink);
4365 + obj = ylist_entry(lh, yaffs_Object, hashLink);
4366 yaffs_VerifyObject(obj);
4367 }
4368 }
4369 - }
4370 -
4371 + }
4372 }
4373
4374
4375 @@ -855,19 +859,20 @@ static void yaffs_VerifyObjects(yaffs_De
4376 static Y_INLINE int yaffs_HashFunction(int n)
4377 {
4378 n = abs(n);
4379 - return (n % YAFFS_NOBJECT_BUCKETS);
4380 + return n % YAFFS_NOBJECT_BUCKETS;
4381 }
4382
4383 /*
4384 - * Access functions to useful fake objects
4385 + * Access functions to useful fake objects.
4386 + * Note that root might have a presence in NAND if permissions are set.
4387 */
4388
4389 -yaffs_Object *yaffs_Root(yaffs_Device * dev)
4390 +yaffs_Object *yaffs_Root(yaffs_Device *dev)
4391 {
4392 return dev->rootDir;
4393 }
4394
4395 -yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
4396 +yaffs_Object *yaffs_LostNFound(yaffs_Device *dev)
4397 {
4398 return dev->lostNFoundDir;
4399 }
4400 @@ -877,7 +882,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Dev
4401 * Erased NAND checking functions
4402 */
4403
4404 -int yaffs_CheckFF(__u8 * buffer, int nBytes)
4405 +int yaffs_CheckFF(__u8 *buffer, int nBytes)
4406 {
4407 /* Horrible, slow implementation */
4408 while (nBytes--) {
4409 @@ -889,9 +894,8 @@ int yaffs_CheckFF(__u8 * buffer, int nBy
4410 }
4411
4412 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
4413 - int chunkInNAND)
4414 + int chunkInNAND)
4415 {
4416 -
4417 int retval = YAFFS_OK;
4418 __u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
4419 yaffs_ExtendedTags tags;
4420 @@ -899,10 +903,9 @@ static int yaffs_CheckChunkErased(struct
4421
4422 result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
4423
4424 - if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
4425 + if (tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
4426 retval = YAFFS_FAIL;
4427
4428 -
4429 if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
4430 T(YAFFS_TRACE_NANDACCESS,
4431 (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND));
4432 @@ -915,11 +918,10 @@ static int yaffs_CheckChunkErased(struct
4433
4434 }
4435
4436 -
4437 static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
4438 - const __u8 * data,
4439 - yaffs_ExtendedTags * tags,
4440 - int useReserve)
4441 + const __u8 *data,
4442 + yaffs_ExtendedTags *tags,
4443 + int useReserve)
4444 {
4445 int attempts = 0;
4446 int writeOk = 0;
4447 @@ -972,7 +974,7 @@ static int yaffs_WriteNewChunkWithTagsTo
4448 erasedOk = yaffs_CheckChunkErased(dev, chunk);
4449 if (erasedOk != YAFFS_OK) {
4450 T(YAFFS_TRACE_ERROR,
4451 - (TSTR ("**>> yaffs chunk %d was not erased"
4452 + (TSTR("**>> yaffs chunk %d was not erased"
4453 TENDSTR), chunk));
4454
4455 /* try another chunk */
4456 @@ -992,7 +994,11 @@ static int yaffs_WriteNewChunkWithTagsTo
4457 /* Copy the data into the robustification buffer */
4458 yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
4459
4460 - } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
4461 + } while (writeOk != YAFFS_OK &&
4462 + (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
4463 +
4464 + if (!writeOk)
4465 + chunk = -1;
4466
4467 if (attempts > 1) {
4468 T(YAFFS_TRACE_ERROR,
4469 @@ -1009,13 +1015,35 @@ static int yaffs_WriteNewChunkWithTagsTo
4470 * Block retiring for handling a broken block.
4471 */
4472
4473 -static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
4474 +static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND)
4475 {
4476 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
4477
4478 yaffs_InvalidateCheckpoint(dev);
4479
4480 - yaffs_MarkBlockBad(dev, blockInNAND);
4481 + if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) {
4482 + if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) {
4483 + T(YAFFS_TRACE_ALWAYS, (TSTR(
4484 + "yaffs: Failed to mark bad and erase block %d"
4485 + TENDSTR), blockInNAND));
4486 + } else {
4487 + yaffs_ExtendedTags tags;
4488 + int chunkId = blockInNAND * dev->nChunksPerBlock;
4489 +
4490 + __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
4491 +
4492 + memset(buffer, 0xff, dev->nDataBytesPerChunk);
4493 + yaffs_InitialiseTags(&tags);
4494 + tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK;
4495 + if (dev->writeChunkWithTagsToNAND(dev, chunkId -
4496 + dev->chunkOffset, buffer, &tags) != YAFFS_OK)
4497 + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to "
4498 + TCONT("write bad block marker to block %d")
4499 + TENDSTR), blockInNAND));
4500 +
4501 + yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
4502 + }
4503 + }
4504
4505 bi->blockState = YAFFS_BLOCK_STATE_DEAD;
4506 bi->gcPrioritise = 0;
4507 @@ -1029,49 +1057,45 @@ static void yaffs_RetireBlock(yaffs_Devi
4508 *
4509 */
4510
4511 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
4512 - const __u8 * data,
4513 - const yaffs_ExtendedTags * tags)
4514 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
4515 + const __u8 *data,
4516 + const yaffs_ExtendedTags *tags)
4517 {
4518 }
4519
4520 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
4521 - const yaffs_ExtendedTags * tags)
4522 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
4523 + const yaffs_ExtendedTags *tags)
4524 {
4525 }
4526
4527 void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
4528 {
4529 - if(!bi->gcPrioritise){
4530 + if (!bi->gcPrioritise) {
4531 bi->gcPrioritise = 1;
4532 dev->hasPendingPrioritisedGCs = 1;
4533 - bi->chunkErrorStrikes ++;
4534 + bi->chunkErrorStrikes++;
4535
4536 - if(bi->chunkErrorStrikes > 3){
4537 + if (bi->chunkErrorStrikes > 3) {
4538 bi->needsRetiring = 1; /* Too many stikes, so retire this */
4539 T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
4540
4541 }
4542 -
4543 }
4544 }
4545
4546 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk)
4547 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND,
4548 + int erasedOk)
4549 {
4550 -
4551 int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
4552 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
4553
4554 - yaffs_HandleChunkError(dev,bi);
4555 + yaffs_HandleChunkError(dev, bi);
4556
4557 -
4558 - if(erasedOk ) {
4559 + if (erasedOk) {
4560 /* Was an actual write failure, so mark the block for retirement */
4561 bi->needsRetiring = 1;
4562 T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
4563 (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
4564 -
4565 -
4566 }
4567
4568 /* Delete the chunk */
4569 @@ -1081,12 +1105,12 @@ static void yaffs_HandleWriteChunkError(
4570
4571 /*---------------- Name handling functions ------------*/
4572
4573 -static __u16 yaffs_CalcNameSum(const YCHAR * name)
4574 +static __u16 yaffs_CalcNameSum(const YCHAR *name)
4575 {
4576 __u16 sum = 0;
4577 __u16 i = 1;
4578
4579 - YUCHAR *bname = (YUCHAR *) name;
4580 + const YUCHAR *bname = (const YUCHAR *) name;
4581 if (bname) {
4582 while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) {
4583
4584 @@ -1102,14 +1126,14 @@ static __u16 yaffs_CalcNameSum(const YCH
4585 return sum;
4586 }
4587
4588 -static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
4589 +static void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name)
4590 {
4591 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
4592 - if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) {
4593 + memset(obj->shortName, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1));
4594 + if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH)
4595 yaffs_strcpy(obj->shortName, name);
4596 - } else {
4597 + else
4598 obj->shortName[0] = _Y('\0');
4599 - }
4600 #endif
4601 obj->sum = yaffs_CalcNameSum(name);
4602 }
4603 @@ -1126,7 +1150,7 @@ static void yaffs_SetObjectName(yaffs_Ob
4604 * Don't use this function directly
4605 */
4606
4607 -static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
4608 +static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes)
4609 {
4610 int i;
4611 int tnodeSize;
4612 @@ -1143,6 +1167,9 @@ static int yaffs_CreateTnodes(yaffs_Devi
4613 * Must be a multiple of 32-bits */
4614 tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4615
4616 + if (tnodeSize < sizeof(yaffs_Tnode))
4617 + tnodeSize = sizeof(yaffs_Tnode);
4618 +
4619 /* make these things */
4620
4621 newTnodes = YMALLOC(nTnodes * tnodeSize);
4622 @@ -1150,7 +1177,7 @@ static int yaffs_CreateTnodes(yaffs_Devi
4623
4624 if (!newTnodes) {
4625 T(YAFFS_TRACE_ERROR,
4626 - (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
4627 + (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
4628 return YAFFS_FAIL;
4629 }
4630
4631 @@ -1170,7 +1197,7 @@ static int yaffs_CreateTnodes(yaffs_Devi
4632 dev->freeTnodes = newTnodes;
4633 #else
4634 /* New hookup for wide tnodes */
4635 - for(i = 0; i < nTnodes -1; i++) {
4636 + for (i = 0; i < nTnodes - 1; i++) {
4637 curr = (yaffs_Tnode *) &mem[i * tnodeSize];
4638 next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
4639 curr->internal[0] = next;
4640 @@ -1197,7 +1224,6 @@ static int yaffs_CreateTnodes(yaffs_Devi
4641 (TSTR
4642 ("yaffs: Could not add tnodes to management list" TENDSTR)));
4643 return YAFFS_FAIL;
4644 -
4645 } else {
4646 tnl->tnodes = newTnodes;
4647 tnl->next = dev->allocatedTnodeList;
4648 @@ -1211,14 +1237,13 @@ static int yaffs_CreateTnodes(yaffs_Devi
4649
4650 /* GetTnode gets us a clean tnode. Tries to make allocate more if we run out */
4651
4652 -static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
4653 +static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device *dev)
4654 {
4655 yaffs_Tnode *tn = NULL;
4656
4657 /* If there are none left make more */
4658 - if (!dev->freeTnodes) {
4659 + if (!dev->freeTnodes)
4660 yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES);
4661 - }
4662
4663 if (dev->freeTnodes) {
4664 tn = dev->freeTnodes;
4665 @@ -1233,21 +1258,27 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(ya
4666 dev->nFreeTnodes--;
4667 }
4668
4669 + dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
4670 +
4671 return tn;
4672 }
4673
4674 -static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
4675 +static yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev)
4676 {
4677 yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
4678 + int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4679
4680 - if(tn)
4681 - memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4682 + if (tnodeSize < sizeof(yaffs_Tnode))
4683 + tnodeSize = sizeof(yaffs_Tnode);
4684 +
4685 + if (tn)
4686 + memset(tn, 0, tnodeSize);
4687
4688 return tn;
4689 }
4690
4691 /* FreeTnode frees up a tnode and puts it back on the free list */
4692 -static void yaffs_FreeTnode(yaffs_Device * dev, yaffs_Tnode * tn)
4693 +static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn)
4694 {
4695 if (tn) {
4696 #ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
4697 @@ -1262,9 +1293,10 @@ static void yaffs_FreeTnode(yaffs_Device
4698 dev->freeTnodes = tn;
4699 dev->nFreeTnodes++;
4700 }
4701 + dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
4702 }
4703
4704 -static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
4705 +static void yaffs_DeinitialiseTnodes(yaffs_Device *dev)
4706 {
4707 /* Free the list of allocated tnodes */
4708 yaffs_TnodeList *tmp;
4709 @@ -1282,71 +1314,72 @@ static void yaffs_DeinitialiseTnodes(yaf
4710 dev->nFreeTnodes = 0;
4711 }
4712
4713 -static void yaffs_InitialiseTnodes(yaffs_Device * dev)
4714 +static void yaffs_InitialiseTnodes(yaffs_Device *dev)
4715 {
4716 dev->allocatedTnodeList = NULL;
4717 dev->freeTnodes = NULL;
4718 dev->nFreeTnodes = 0;
4719 dev->nTnodesCreated = 0;
4720 -
4721 }
4722
4723
4724 -void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsigned val)
4725 +void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos,
4726 + unsigned val)
4727 {
4728 - __u32 *map = (__u32 *)tn;
4729 - __u32 bitInMap;
4730 - __u32 bitInWord;
4731 - __u32 wordInMap;
4732 - __u32 mask;
4733 + __u32 *map = (__u32 *)tn;
4734 + __u32 bitInMap;
4735 + __u32 bitInWord;
4736 + __u32 wordInMap;
4737 + __u32 mask;
4738
4739 - pos &= YAFFS_TNODES_LEVEL0_MASK;
4740 - val >>= dev->chunkGroupBits;
4741 + pos &= YAFFS_TNODES_LEVEL0_MASK;
4742 + val >>= dev->chunkGroupBits;
4743
4744 - bitInMap = pos * dev->tnodeWidth;
4745 - wordInMap = bitInMap /32;
4746 - bitInWord = bitInMap & (32 -1);
4747 + bitInMap = pos * dev->tnodeWidth;
4748 + wordInMap = bitInMap / 32;
4749 + bitInWord = bitInMap & (32 - 1);
4750
4751 - mask = dev->tnodeMask << bitInWord;
4752 + mask = dev->tnodeMask << bitInWord;
4753
4754 - map[wordInMap] &= ~mask;
4755 - map[wordInMap] |= (mask & (val << bitInWord));
4756 + map[wordInMap] &= ~mask;
4757 + map[wordInMap] |= (mask & (val << bitInWord));
4758
4759 - if(dev->tnodeWidth > (32-bitInWord)) {
4760 - bitInWord = (32 - bitInWord);
4761 - wordInMap++;;
4762 - mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord);
4763 - map[wordInMap] &= ~mask;
4764 - map[wordInMap] |= (mask & (val >> bitInWord));
4765 - }
4766 + if (dev->tnodeWidth > (32 - bitInWord)) {
4767 + bitInWord = (32 - bitInWord);
4768 + wordInMap++;;
4769 + mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord);
4770 + map[wordInMap] &= ~mask;
4771 + map[wordInMap] |= (mask & (val >> bitInWord));
4772 + }
4773 }
4774
4775 -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos)
4776 +static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn,
4777 + unsigned pos)
4778 {
4779 - __u32 *map = (__u32 *)tn;
4780 - __u32 bitInMap;
4781 - __u32 bitInWord;
4782 - __u32 wordInMap;
4783 - __u32 val;
4784 + __u32 *map = (__u32 *)tn;
4785 + __u32 bitInMap;
4786 + __u32 bitInWord;
4787 + __u32 wordInMap;
4788 + __u32 val;
4789
4790 - pos &= YAFFS_TNODES_LEVEL0_MASK;
4791 + pos &= YAFFS_TNODES_LEVEL0_MASK;
4792
4793 - bitInMap = pos * dev->tnodeWidth;
4794 - wordInMap = bitInMap /32;
4795 - bitInWord = bitInMap & (32 -1);
4796 + bitInMap = pos * dev->tnodeWidth;
4797 + wordInMap = bitInMap / 32;
4798 + bitInWord = bitInMap & (32 - 1);
4799
4800 - val = map[wordInMap] >> bitInWord;
4801 + val = map[wordInMap] >> bitInWord;
4802
4803 - if(dev->tnodeWidth > (32-bitInWord)) {
4804 - bitInWord = (32 - bitInWord);
4805 - wordInMap++;;
4806 - val |= (map[wordInMap] << bitInWord);
4807 - }
4808 + if (dev->tnodeWidth > (32 - bitInWord)) {
4809 + bitInWord = (32 - bitInWord);
4810 + wordInMap++;;
4811 + val |= (map[wordInMap] << bitInWord);
4812 + }
4813
4814 - val &= dev->tnodeMask;
4815 - val <<= dev->chunkGroupBits;
4816 + val &= dev->tnodeMask;
4817 + val <<= dev->chunkGroupBits;
4818
4819 - return val;
4820 + return val;
4821 }
4822
4823 /* ------------------- End of individual tnode manipulation -----------------*/
4824 @@ -1357,24 +1390,21 @@ static __u32 yaffs_GetChunkGroupBase(yaf
4825 */
4826
4827 /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
4828 -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
4829 - yaffs_FileStructure * fStruct,
4830 - __u32 chunkId)
4831 +static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,
4832 + yaffs_FileStructure *fStruct,
4833 + __u32 chunkId)
4834 {
4835 -
4836 yaffs_Tnode *tn = fStruct->top;
4837 __u32 i;
4838 int requiredTallness;
4839 int level = fStruct->topLevel;
4840
4841 /* Check sane level and chunk Id */
4842 - if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) {
4843 + if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL)
4844 return NULL;
4845 - }
4846
4847 - if (chunkId > YAFFS_MAX_CHUNK_ID) {
4848 + if (chunkId > YAFFS_MAX_CHUNK_ID)
4849 return NULL;
4850 - }
4851
4852 /* First check we're tall enough (ie enough topLevel) */
4853
4854 @@ -1385,22 +1415,17 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
4855 requiredTallness++;
4856 }
4857
4858 - if (requiredTallness > fStruct->topLevel) {
4859 - /* Not tall enough, so we can't find it, return NULL. */
4860 - return NULL;
4861 - }
4862 + if (requiredTallness > fStruct->topLevel)
4863 + return NULL; /* Not tall enough, so we can't find it */
4864
4865 /* Traverse down to level 0 */
4866 while (level > 0 && tn) {
4867 - tn = tn->
4868 - internal[(chunkId >>
4869 - ( YAFFS_TNODES_LEVEL0_BITS +
4870 - (level - 1) *
4871 - YAFFS_TNODES_INTERNAL_BITS)
4872 - ) &
4873 - YAFFS_TNODES_INTERNAL_MASK];
4874 + tn = tn->internal[(chunkId >>
4875 + (YAFFS_TNODES_LEVEL0_BITS +
4876 + (level - 1) *
4877 + YAFFS_TNODES_INTERNAL_BITS)) &
4878 + YAFFS_TNODES_INTERNAL_MASK];
4879 level--;
4880 -
4881 }
4882
4883 return tn;
4884 @@ -1417,12 +1442,11 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
4885 * be plugged into the ttree.
4886 */
4887
4888 -static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
4889 - yaffs_FileStructure * fStruct,
4890 - __u32 chunkId,
4891 - yaffs_Tnode *passedTn)
4892 +static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev,
4893 + yaffs_FileStructure *fStruct,
4894 + __u32 chunkId,
4895 + yaffs_Tnode *passedTn)
4896 {
4897 -
4898 int requiredTallness;
4899 int i;
4900 int l;
4901 @@ -1432,13 +1456,11 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4902
4903
4904 /* Check sane level and page Id */
4905 - if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) {
4906 + if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL)
4907 return NULL;
4908 - }
4909
4910 - if (chunkId > YAFFS_MAX_CHUNK_ID) {
4911 + if (chunkId > YAFFS_MAX_CHUNK_ID)
4912 return NULL;
4913 - }
4914
4915 /* First check we're tall enough (ie enough topLevel) */
4916
4917 @@ -1451,7 +1473,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4918
4919
4920 if (requiredTallness > fStruct->topLevel) {
4921 - /* Not tall enough,gotta make the tree taller */
4922 + /* Not tall enough, gotta make the tree taller */
4923 for (i = fStruct->topLevel; i < requiredTallness; i++) {
4924
4925 tn = yaffs_GetTnode(dev);
4926 @@ -1473,27 +1495,27 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4927 l = fStruct->topLevel;
4928 tn = fStruct->top;
4929
4930 - if(l > 0) {
4931 + if (l > 0) {
4932 while (l > 0 && tn) {
4933 x = (chunkId >>
4934 - ( YAFFS_TNODES_LEVEL0_BITS +
4935 + (YAFFS_TNODES_LEVEL0_BITS +
4936 (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) &
4937 YAFFS_TNODES_INTERNAL_MASK;
4938
4939
4940 - if((l>1) && !tn->internal[x]){
4941 + if ((l > 1) && !tn->internal[x]) {
4942 /* Add missing non-level-zero tnode */
4943 tn->internal[x] = yaffs_GetTnode(dev);
4944
4945 - } else if(l == 1) {
4946 + } else if (l == 1) {
4947 /* Looking from level 1 at level 0 */
4948 - if (passedTn) {
4949 + if (passedTn) {
4950 /* If we already have one, then release it.*/
4951 - if(tn->internal[x])
4952 - yaffs_FreeTnode(dev,tn->internal[x]);
4953 + if (tn->internal[x])
4954 + yaffs_FreeTnode(dev, tn->internal[x]);
4955 tn->internal[x] = passedTn;
4956
4957 - } else if(!tn->internal[x]) {
4958 + } else if (!tn->internal[x]) {
4959 /* Don't have one, none passed in */
4960 tn->internal[x] = yaffs_GetTnode(dev);
4961 }
4962 @@ -1504,31 +1526,29 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4963 }
4964 } else {
4965 /* top is level 0 */
4966 - if(passedTn) {
4967 - memcpy(tn,passedTn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4968 - yaffs_FreeTnode(dev,passedTn);
4969 + if (passedTn) {
4970 + memcpy(tn, passedTn, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4971 + yaffs_FreeTnode(dev, passedTn);
4972 }
4973 }
4974
4975 return tn;
4976 }
4977
4978 -static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
4979 - yaffs_ExtendedTags * tags, int objectId,
4980 - int chunkInInode)
4981 +static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk,
4982 + yaffs_ExtendedTags *tags, int objectId,
4983 + int chunkInInode)
4984 {
4985 int j;
4986
4987 for (j = 0; theChunk && j < dev->chunkGroupSize; j++) {
4988 - if (yaffs_CheckChunkBit
4989 - (dev, theChunk / dev->nChunksPerBlock,
4990 - theChunk % dev->nChunksPerBlock)) {
4991 + if (yaffs_CheckChunkBit(dev, theChunk / dev->nChunksPerBlock,
4992 + theChunk % dev->nChunksPerBlock)) {
4993 yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL,
4994 tags);
4995 if (yaffs_TagsMatch(tags, objectId, chunkInInode)) {
4996 /* found it; */
4997 return theChunk;
4998 -
4999 }
5000 }
5001 theChunk++;
5002 @@ -1543,7 +1563,7 @@ static int yaffs_FindChunkInGroup(yaffs_
5003 * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
5004 */
5005
5006 -static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
5007 +static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
5008 int chunkOffset, int *limit)
5009 {
5010 int i;
5011 @@ -1557,7 +1577,6 @@ static int yaffs_DeleteWorker(yaffs_Obje
5012
5013 if (tn) {
5014 if (level > 0) {
5015 -
5016 for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0;
5017 i--) {
5018 if (tn->internal[i]) {
5019 @@ -1565,17 +1584,17 @@ static int yaffs_DeleteWorker(yaffs_Obje
5020 allDone = 0;
5021 } else {
5022 allDone =
5023 - yaffs_DeleteWorker(in,
5024 - tn->
5025 - internal
5026 - [i],
5027 - level -
5028 - 1,
5029 - (chunkOffset
5030 + yaffs_DeleteWorker(in,
5031 + tn->
5032 + internal
5033 + [i],
5034 + level -
5035 + 1,
5036 + (chunkOffset
5037 <<
5038 YAFFS_TNODES_INTERNAL_BITS)
5039 - + i,
5040 - limit);
5041 + + i,
5042 + limit);
5043 }
5044 if (allDone) {
5045 yaffs_FreeTnode(dev,
5046 @@ -1584,27 +1603,25 @@ static int yaffs_DeleteWorker(yaffs_Obje
5047 tn->internal[i] = NULL;
5048 }
5049 }
5050 -
5051 }
5052 return (allDone) ? 1 : 0;
5053 } else if (level == 0) {
5054 int hitLimit = 0;
5055
5056 for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit;
5057 - i--) {
5058 - theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
5059 + i--) {
5060 + theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
5061 if (theChunk) {
5062
5063 - chunkInInode =
5064 - (chunkOffset <<
5065 - YAFFS_TNODES_LEVEL0_BITS) + i;
5066 + chunkInInode = (chunkOffset <<
5067 + YAFFS_TNODES_LEVEL0_BITS) + i;
5068
5069 foundChunk =
5070 - yaffs_FindChunkInGroup(dev,
5071 - theChunk,
5072 - &tags,
5073 - in->objectId,
5074 - chunkInInode);
5075 + yaffs_FindChunkInGroup(dev,
5076 + theChunk,
5077 + &tags,
5078 + in->objectId,
5079 + chunkInInode);
5080
5081 if (foundChunk > 0) {
5082 yaffs_DeleteChunk(dev,
5083 @@ -1613,14 +1630,13 @@ static int yaffs_DeleteWorker(yaffs_Obje
5084 in->nDataChunks--;
5085 if (limit) {
5086 *limit = *limit - 1;
5087 - if (*limit <= 0) {
5088 + if (*limit <= 0)
5089 hitLimit = 1;
5090 - }
5091 }
5092
5093 }
5094
5095 - yaffs_PutLevel0Tnode(dev,tn,i,0);
5096 + yaffs_PutLevel0Tnode(dev, tn, i, 0);
5097 }
5098
5099 }
5100 @@ -1634,9 +1650,8 @@ static int yaffs_DeleteWorker(yaffs_Obje
5101
5102 }
5103
5104 -static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
5105 +static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk)
5106 {
5107 -
5108 yaffs_BlockInfo *theBlock;
5109
5110 T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
5111 @@ -1654,7 +1669,7 @@ static void yaffs_SoftDeleteChunk(yaffs_
5112 * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
5113 */
5114
5115 -static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
5116 +static int yaffs_SoftDeleteWorker(yaffs_Object *in, yaffs_Tnode *tn,
5117 __u32 level, int chunkOffset)
5118 {
5119 int i;
5120 @@ -1691,14 +1706,14 @@ static int yaffs_SoftDeleteWorker(yaffs_
5121 } else if (level == 0) {
5122
5123 for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) {
5124 - theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
5125 + theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
5126 if (theChunk) {
5127 /* Note this does not find the real chunk, only the chunk group.
5128 * We make an assumption that a chunk group is not larger than
5129 * a block.
5130 */
5131 yaffs_SoftDeleteChunk(dev, theChunk);
5132 - yaffs_PutLevel0Tnode(dev,tn,i,0);
5133 + yaffs_PutLevel0Tnode(dev, tn, i, 0);
5134 }
5135
5136 }
5137 @@ -1712,7 +1727,7 @@ static int yaffs_SoftDeleteWorker(yaffs_
5138
5139 }
5140
5141 -static void yaffs_SoftDeleteFile(yaffs_Object * obj)
5142 +static void yaffs_SoftDeleteFile(yaffs_Object *obj)
5143 {
5144 if (obj->deleted &&
5145 obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) {
5146 @@ -1746,8 +1761,8 @@ static void yaffs_SoftDeleteFile(yaffs_O
5147 * by a special case.
5148 */
5149
5150 -static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device * dev, yaffs_Tnode * tn,
5151 - __u32 level, int del0)
5152 +static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn,
5153 + __u32 level, int del0)
5154 {
5155 int i;
5156 int hasData;
5157 @@ -1763,9 +1778,8 @@ static yaffs_Tnode *yaffs_PruneWorker(ya
5158 (i == 0) ? del0 : 1);
5159 }
5160
5161 - if (tn->internal[i]) {
5162 + if (tn->internal[i])
5163 hasData++;
5164 - }
5165 }
5166
5167 if (hasData == 0 && del0) {
5168 @@ -1781,8 +1795,8 @@ static yaffs_Tnode *yaffs_PruneWorker(ya
5169
5170 }
5171
5172 -static int yaffs_PruneFileStructure(yaffs_Device * dev,
5173 - yaffs_FileStructure * fStruct)
5174 +static int yaffs_PruneFileStructure(yaffs_Device *dev,
5175 + yaffs_FileStructure *fStruct)
5176 {
5177 int i;
5178 int hasData;
5179 @@ -1805,9 +1819,8 @@ static int yaffs_PruneFileStructure(yaff
5180
5181 hasData = 0;
5182 for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) {
5183 - if (tn->internal[i]) {
5184 + if (tn->internal[i])
5185 hasData++;
5186 - }
5187 }
5188
5189 if (!hasData) {
5190 @@ -1828,7 +1841,7 @@ static int yaffs_PruneFileStructure(yaff
5191 /* yaffs_CreateFreeObjects creates a bunch more objects and
5192 * adds them to the object free list.
5193 */
5194 -static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
5195 +static int yaffs_CreateFreeObjects(yaffs_Device *dev, int nObjects)
5196 {
5197 int i;
5198 yaffs_Object *newObjects;
5199 @@ -1842,9 +1855,9 @@ static int yaffs_CreateFreeObjects(yaffs
5200 list = YMALLOC(sizeof(yaffs_ObjectList));
5201
5202 if (!newObjects || !list) {
5203 - if(newObjects)
5204 + if (newObjects)
5205 YFREE(newObjects);
5206 - if(list)
5207 + if (list)
5208 YFREE(list);
5209 T(YAFFS_TRACE_ALLOCATE,
5210 (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
5211 @@ -1854,7 +1867,7 @@ static int yaffs_CreateFreeObjects(yaffs
5212 /* Hook them into the free list */
5213 for (i = 0; i < nObjects - 1; i++) {
5214 newObjects[i].siblings.next =
5215 - (struct list_head *)(&newObjects[i + 1]);
5216 + (struct ylist_head *)(&newObjects[i + 1]);
5217 }
5218
5219 newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
5220 @@ -1873,85 +1886,109 @@ static int yaffs_CreateFreeObjects(yaffs
5221
5222
5223 /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */
5224 -static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev)
5225 +static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev)
5226 {
5227 yaffs_Object *tn = NULL;
5228
5229 +#ifdef VALGRIND_TEST
5230 + tn = YMALLOC(sizeof(yaffs_Object));
5231 +#else
5232 /* If there are none left make more */
5233 - if (!dev->freeObjects) {
5234 + if (!dev->freeObjects)
5235 yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS);
5236 - }
5237
5238 if (dev->freeObjects) {
5239 tn = dev->freeObjects;
5240 dev->freeObjects =
5241 - (yaffs_Object *) (dev->freeObjects->siblings.next);
5242 + (yaffs_Object *) (dev->freeObjects->siblings.next);
5243 dev->nFreeObjects--;
5244 -
5245 + }
5246 +#endif
5247 + if (tn) {
5248 /* Now sweeten it up... */
5249
5250 memset(tn, 0, sizeof(yaffs_Object));
5251 + tn->beingCreated = 1;
5252 +
5253 tn->myDev = dev;
5254 - tn->chunkId = -1;
5255 + tn->hdrChunk = 0;
5256 tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
5257 - INIT_LIST_HEAD(&(tn->hardLinks));
5258 - INIT_LIST_HEAD(&(tn->hashLink));
5259 - INIT_LIST_HEAD(&tn->siblings);
5260 + YINIT_LIST_HEAD(&(tn->hardLinks));
5261 + YINIT_LIST_HEAD(&(tn->hashLink));
5262 + YINIT_LIST_HEAD(&tn->siblings);
5263 +
5264 +
5265 + /* Now make the directory sane */
5266 + if (dev->rootDir) {
5267 + tn->parent = dev->rootDir;
5268 + ylist_add(&(tn->siblings), &dev->rootDir->variant.directoryVariant.children);
5269 + }
5270
5271 /* Add it to the lost and found directory.
5272 * NB Can't put root or lostNFound in lostNFound so
5273 * check if lostNFound exists first
5274 */
5275 - if (dev->lostNFoundDir) {
5276 + if (dev->lostNFoundDir)
5277 yaffs_AddObjectToDirectory(dev->lostNFoundDir, tn);
5278 - }
5279 +
5280 + tn->beingCreated = 0;
5281 }
5282
5283 + dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
5284 +
5285 return tn;
5286 }
5287
5288 -static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device * dev, int number,
5289 +static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device *dev, int number,
5290 __u32 mode)
5291 {
5292
5293 yaffs_Object *obj =
5294 yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
5295 if (obj) {
5296 - obj->fake = 1; /* it is fake so it has no NAND presence... */
5297 + obj->fake = 1; /* it is fake so it might have no NAND presence... */
5298 obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */
5299 obj->unlinkAllowed = 0; /* ... or unlink it */
5300 obj->deleted = 0;
5301 obj->unlinked = 0;
5302 obj->yst_mode = mode;
5303 obj->myDev = dev;
5304 - obj->chunkId = 0; /* Not a valid chunk. */
5305 + obj->hdrChunk = 0; /* Not a valid chunk. */
5306 }
5307
5308 return obj;
5309
5310 }
5311
5312 -static void yaffs_UnhashObject(yaffs_Object * tn)
5313 +static void yaffs_UnhashObject(yaffs_Object *tn)
5314 {
5315 int bucket;
5316 yaffs_Device *dev = tn->myDev;
5317
5318 /* If it is still linked into the bucket list, free from the list */
5319 - if (!list_empty(&tn->hashLink)) {
5320 - list_del_init(&tn->hashLink);
5321 + if (!ylist_empty(&tn->hashLink)) {
5322 + ylist_del_init(&tn->hashLink);
5323 bucket = yaffs_HashFunction(tn->objectId);
5324 dev->objectBucket[bucket].count--;
5325 }
5326 -
5327 }
5328
5329 /* FreeObject frees up a Object and puts it back on the free list */
5330 -static void yaffs_FreeObject(yaffs_Object * tn)
5331 +static void yaffs_FreeObject(yaffs_Object *tn)
5332 {
5333 -
5334 yaffs_Device *dev = tn->myDev;
5335
5336 -#ifdef __KERNEL__
5337 +#ifdef __KERNEL__
5338 + T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), tn, tn->myInode));
5339 +#endif
5340 +
5341 + if (tn->parent)
5342 + YBUG();
5343 + if (!ylist_empty(&tn->siblings))
5344 + YBUG();
5345 +
5346 +
5347 +#ifdef __KERNEL__
5348 if (tn->myInode) {
5349 /* We're still hooked up to a cached inode.
5350 * Don't delete now, but mark for later deletion
5351 @@ -1963,24 +2000,28 @@ static void yaffs_FreeObject(yaffs_Objec
5352
5353 yaffs_UnhashObject(tn);
5354
5355 +#ifdef VALGRIND_TEST
5356 + YFREE(tn);
5357 +#else
5358 /* Link into the free list. */
5359 - tn->siblings.next = (struct list_head *)(dev->freeObjects);
5360 + tn->siblings.next = (struct ylist_head *)(dev->freeObjects);
5361 dev->freeObjects = tn;
5362 dev->nFreeObjects++;
5363 +#endif
5364 + dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
5365 }
5366
5367 #ifdef __KERNEL__
5368
5369 -void yaffs_HandleDeferedFree(yaffs_Object * obj)
5370 +void yaffs_HandleDeferedFree(yaffs_Object *obj)
5371 {
5372 - if (obj->deferedFree) {
5373 + if (obj->deferedFree)
5374 yaffs_FreeObject(obj);
5375 - }
5376 }
5377
5378 #endif
5379
5380 -static void yaffs_DeinitialiseObjects(yaffs_Device * dev)
5381 +static void yaffs_DeinitialiseObjects(yaffs_Device *dev)
5382 {
5383 /* Free the list of allocated Objects */
5384
5385 @@ -1998,7 +2039,7 @@ static void yaffs_DeinitialiseObjects(ya
5386 dev->nFreeObjects = 0;
5387 }
5388
5389 -static void yaffs_InitialiseObjects(yaffs_Device * dev)
5390 +static void yaffs_InitialiseObjects(yaffs_Device *dev)
5391 {
5392 int i;
5393
5394 @@ -2007,15 +2048,14 @@ static void yaffs_InitialiseObjects(yaff
5395 dev->nFreeObjects = 0;
5396
5397 for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
5398 - INIT_LIST_HEAD(&dev->objectBucket[i].list);
5399 + YINIT_LIST_HEAD(&dev->objectBucket[i].list);
5400 dev->objectBucket[i].count = 0;
5401 }
5402 -
5403 }
5404
5405 -static int yaffs_FindNiceObjectBucket(yaffs_Device * dev)
5406 +static int yaffs_FindNiceObjectBucket(yaffs_Device *dev)
5407 {
5408 - static int x = 0;
5409 + static int x;
5410 int i;
5411 int l = 999;
5412 int lowest = 999999;
5413 @@ -2049,7 +2089,7 @@ static int yaffs_FindNiceObjectBucket(ya
5414 return l;
5415 }
5416
5417 -static int yaffs_CreateNewObjectNumber(yaffs_Device * dev)
5418 +static int yaffs_CreateNewObjectNumber(yaffs_Device *dev)
5419 {
5420 int bucket = yaffs_FindNiceObjectBucket(dev);
5421
5422 @@ -2058,7 +2098,7 @@ static int yaffs_CreateNewObjectNumber(y
5423 */
5424
5425 int found = 0;
5426 - struct list_head *i;
5427 + struct ylist_head *i;
5428
5429 __u32 n = (__u32) bucket;
5430
5431 @@ -2068,41 +2108,38 @@ static int yaffs_CreateNewObjectNumber(y
5432 found = 1;
5433 n += YAFFS_NOBJECT_BUCKETS;
5434 if (1 || dev->objectBucket[bucket].count > 0) {
5435 - list_for_each(i, &dev->objectBucket[bucket].list) {
5436 + ylist_for_each(i, &dev->objectBucket[bucket].list) {
5437 /* If there is already one in the list */
5438 - if (i
5439 - && list_entry(i, yaffs_Object,
5440 - hashLink)->objectId == n) {
5441 + if (i && ylist_entry(i, yaffs_Object,
5442 + hashLink)->objectId == n) {
5443 found = 0;
5444 }
5445 }
5446 }
5447 }
5448
5449 -
5450 return n;
5451 }
5452
5453 -static void yaffs_HashObject(yaffs_Object * in)
5454 +static void yaffs_HashObject(yaffs_Object *in)
5455 {
5456 int bucket = yaffs_HashFunction(in->objectId);
5457 yaffs_Device *dev = in->myDev;
5458
5459 - list_add(&in->hashLink, &dev->objectBucket[bucket].list);
5460 + ylist_add(&in->hashLink, &dev->objectBucket[bucket].list);
5461 dev->objectBucket[bucket].count++;
5462 -
5463 }
5464
5465 -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
5466 +yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number)
5467 {
5468 int bucket = yaffs_HashFunction(number);
5469 - struct list_head *i;
5470 + struct ylist_head *i;
5471 yaffs_Object *in;
5472
5473 - list_for_each(i, &dev->objectBucket[bucket].list) {
5474 + ylist_for_each(i, &dev->objectBucket[bucket].list) {
5475 /* Look if it is in the list */
5476 if (i) {
5477 - in = list_entry(i, yaffs_Object, hashLink);
5478 + in = ylist_entry(i, yaffs_Object, hashLink);
5479 if (in->objectId == number) {
5480 #ifdef __KERNEL__
5481 /* Don't tell the VFS about this one if it is defered free */
5482 @@ -2118,31 +2155,27 @@ yaffs_Object *yaffs_FindObjectByNumber(y
5483 return NULL;
5484 }
5485
5486 -yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
5487 +yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
5488 yaffs_ObjectType type)
5489 {
5490 -
5491 yaffs_Object *theObject;
5492 - yaffs_Tnode *tn;
5493 + yaffs_Tnode *tn = NULL;
5494
5495 - if (number < 0) {
5496 + if (number < 0)
5497 number = yaffs_CreateNewObjectNumber(dev);
5498 - }
5499
5500 theObject = yaffs_AllocateEmptyObject(dev);
5501 - if(!theObject)
5502 + if (!theObject)
5503 return NULL;
5504
5505 - if(type == YAFFS_OBJECT_TYPE_FILE){
5506 + if (type == YAFFS_OBJECT_TYPE_FILE) {
5507 tn = yaffs_GetTnode(dev);
5508 - if(!tn){
5509 + if (!tn) {
5510 yaffs_FreeObject(theObject);
5511 return NULL;
5512 }
5513 }
5514
5515 -
5516 -
5517 if (theObject) {
5518 theObject->fake = 0;
5519 theObject->renameAllowed = 1;
5520 @@ -2171,8 +2204,8 @@ yaffs_Object *yaffs_CreateNewObject(yaff
5521 theObject->variant.fileVariant.top = tn;
5522 break;
5523 case YAFFS_OBJECT_TYPE_DIRECTORY:
5524 - INIT_LIST_HEAD(&theObject->variant.directoryVariant.
5525 - children);
5526 + YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
5527 + children);
5528 break;
5529 case YAFFS_OBJECT_TYPE_SYMLINK:
5530 case YAFFS_OBJECT_TYPE_HARDLINK:
5531 @@ -2188,32 +2221,30 @@ yaffs_Object *yaffs_CreateNewObject(yaff
5532 return theObject;
5533 }
5534
5535 -static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
5536 +static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev,
5537 int number,
5538 yaffs_ObjectType type)
5539 {
5540 yaffs_Object *theObject = NULL;
5541
5542 - if (number > 0) {
5543 + if (number > 0)
5544 theObject = yaffs_FindObjectByNumber(dev, number);
5545 - }
5546
5547 - if (!theObject) {
5548 + if (!theObject)
5549 theObject = yaffs_CreateNewObject(dev, number, type);
5550 - }
5551
5552 return theObject;
5553
5554 }
5555
5556
5557 -static YCHAR *yaffs_CloneString(const YCHAR * str)
5558 +static YCHAR *yaffs_CloneString(const YCHAR *str)
5559 {
5560 YCHAR *newStr = NULL;
5561
5562 if (str && *str) {
5563 newStr = YMALLOC((yaffs_strlen(str) + 1) * sizeof(YCHAR));
5564 - if(newStr)
5565 + if (newStr)
5566 yaffs_strcpy(newStr, str);
5567 }
5568
5569 @@ -2229,29 +2260,31 @@ static YCHAR *yaffs_CloneString(const YC
5570 */
5571
5572 static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
5573 - yaffs_Object * parent,
5574 - const YCHAR * name,
5575 + yaffs_Object *parent,
5576 + const YCHAR *name,
5577 __u32 mode,
5578 __u32 uid,
5579 __u32 gid,
5580 - yaffs_Object * equivalentObject,
5581 - const YCHAR * aliasString, __u32 rdev)
5582 + yaffs_Object *equivalentObject,
5583 + const YCHAR *aliasString, __u32 rdev)
5584 {
5585 yaffs_Object *in;
5586 - YCHAR *str;
5587 + YCHAR *str = NULL;
5588
5589 yaffs_Device *dev = parent->myDev;
5590
5591 /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/
5592 - if (yaffs_FindObjectByName(parent, name)) {
5593 + if (yaffs_FindObjectByName(parent, name))
5594 return NULL;
5595 - }
5596
5597 in = yaffs_CreateNewObject(dev, -1, type);
5598
5599 - if(type == YAFFS_OBJECT_TYPE_SYMLINK){
5600 + if (!in)
5601 + return YAFFS_FAIL;
5602 +
5603 + if (type == YAFFS_OBJECT_TYPE_SYMLINK) {
5604 str = yaffs_CloneString(aliasString);
5605 - if(!str){
5606 + if (!str) {
5607 yaffs_FreeObject(in);
5608 return NULL;
5609 }
5610 @@ -2260,7 +2293,7 @@ static yaffs_Object *yaffs_MknodObject(y
5611
5612
5613 if (in) {
5614 - in->chunkId = -1;
5615 + in->hdrChunk = 0;
5616 in->valid = 1;
5617 in->variantType = type;
5618
5619 @@ -2293,10 +2326,10 @@ static yaffs_Object *yaffs_MknodObject(y
5620 break;
5621 case YAFFS_OBJECT_TYPE_HARDLINK:
5622 in->variant.hardLinkVariant.equivalentObject =
5623 - equivalentObject;
5624 + equivalentObject;
5625 in->variant.hardLinkVariant.equivalentObjectId =
5626 - equivalentObject->objectId;
5627 - list_add(&in->hardLinks, &equivalentObject->hardLinks);
5628 + equivalentObject->objectId;
5629 + ylist_add(&in->hardLinks, &equivalentObject->hardLinks);
5630 break;
5631 case YAFFS_OBJECT_TYPE_FILE:
5632 case YAFFS_OBJECT_TYPE_DIRECTORY:
5633 @@ -2308,7 +2341,7 @@ static yaffs_Object *yaffs_MknodObject(y
5634
5635 if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
5636 /* Could not create the object header, fail the creation */
5637 - yaffs_DestroyObject(in);
5638 + yaffs_DeleteObject(in);
5639 in = NULL;
5640 }
5641
5642 @@ -2317,38 +2350,38 @@ static yaffs_Object *yaffs_MknodObject(y
5643 return in;
5644 }
5645
5646 -yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
5647 - __u32 mode, __u32 uid, __u32 gid)
5648 +yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name,
5649 + __u32 mode, __u32 uid, __u32 gid)
5650 {
5651 return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
5652 - uid, gid, NULL, NULL, 0);
5653 + uid, gid, NULL, NULL, 0);
5654 }
5655
5656 -yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
5657 - __u32 mode, __u32 uid, __u32 gid)
5658 +yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name,
5659 + __u32 mode, __u32 uid, __u32 gid)
5660 {
5661 return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
5662 mode, uid, gid, NULL, NULL, 0);
5663 }
5664
5665 -yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
5666 - __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
5667 +yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name,
5668 + __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
5669 {
5670 return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
5671 uid, gid, NULL, NULL, rdev);
5672 }
5673
5674 -yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
5675 - __u32 mode, __u32 uid, __u32 gid,
5676 - const YCHAR * alias)
5677 +yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name,
5678 + __u32 mode, __u32 uid, __u32 gid,
5679 + const YCHAR *alias)
5680 {
5681 return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode,
5682 - uid, gid, NULL, alias, 0);
5683 + uid, gid, NULL, alias, 0);
5684 }
5685
5686 /* yaffs_Link returns the object id of the equivalent object.*/
5687 -yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
5688 - yaffs_Object * equivalentObject)
5689 +yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name,
5690 + yaffs_Object *equivalentObject)
5691 {
5692 /* Get the real object in case we were fed a hard link as an equivalent object */
5693 equivalentObject = yaffs_GetEquivalentObject(equivalentObject);
5694 @@ -2363,33 +2396,31 @@ yaffs_Object *yaffs_Link(yaffs_Object *
5695
5696 }
5697
5698 -static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
5699 - const YCHAR * newName, int force, int shadows)
5700 +static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir,
5701 + const YCHAR *newName, int force, int shadows)
5702 {
5703 int unlinkOp;
5704 int deleteOp;
5705
5706 yaffs_Object *existingTarget;
5707
5708 - if (newDir == NULL) {
5709 + if (newDir == NULL)
5710 newDir = obj->parent; /* use the old directory */
5711 - }
5712
5713 if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
5714 T(YAFFS_TRACE_ALWAYS,
5715 (TSTR
5716 - ("tragendy: yaffs_ChangeObjectName: newDir is not a directory"
5717 + ("tragedy: yaffs_ChangeObjectName: newDir is not a directory"
5718 TENDSTR)));
5719 YBUG();
5720 }
5721
5722 /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
5723 - if (obj->myDev->isYaffs2) {
5724 + if (obj->myDev->isYaffs2)
5725 unlinkOp = (newDir == obj->myDev->unlinkedDir);
5726 - } else {
5727 + else
5728 unlinkOp = (newDir == obj->myDev->unlinkedDir
5729 && obj->variantType == YAFFS_OBJECT_TYPE_FILE);
5730 - }
5731
5732 deleteOp = (newDir == obj->myDev->deletedDir);
5733
5734 @@ -2415,40 +2446,40 @@ static int yaffs_ChangeObjectName(yaffs_
5735 obj->unlinked = 1;
5736
5737 /* If it is a deletion then we mark it as a shrink for gc purposes. */
5738 - if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows)>= 0)
5739 + if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows) >= 0)
5740 return YAFFS_OK;
5741 }
5742
5743 return YAFFS_FAIL;
5744 }
5745
5746 -int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
5747 - yaffs_Object * newDir, const YCHAR * newName)
5748 +int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName,
5749 + yaffs_Object *newDir, const YCHAR *newName)
5750 {
5751 - yaffs_Object *obj;
5752 - yaffs_Object *existingTarget;
5753 + yaffs_Object *obj = NULL;
5754 + yaffs_Object *existingTarget = NULL;
5755 int force = 0;
5756
5757 +
5758 + if (!oldDir || oldDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
5759 + YBUG();
5760 + if (!newDir || newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
5761 + YBUG();
5762 +
5763 #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
5764 /* Special case for case insemsitive systems (eg. WinCE).
5765 * While look-up is case insensitive, the name isn't.
5766 * Therefore we might want to change x.txt to X.txt
5767 */
5768 - if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) {
5769 + if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0)
5770 force = 1;
5771 - }
5772 #endif
5773
5774 + else if (yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
5775 + /* ENAMETOOLONG */
5776 + return YAFFS_FAIL;
5777 +
5778 obj = yaffs_FindObjectByName(oldDir, oldName);
5779 - /* Check new name to long. */
5780 - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK &&
5781 - yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH)
5782 - /* ENAMETOOLONG */
5783 - return YAFFS_FAIL;
5784 - else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK &&
5785 - yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
5786 - /* ENAMETOOLONG */
5787 - return YAFFS_FAIL;
5788
5789 if (obj && obj->renameAllowed) {
5790
5791 @@ -2456,8 +2487,8 @@ int yaffs_RenameObject(yaffs_Object * ol
5792
5793 existingTarget = yaffs_FindObjectByName(newDir, newName);
5794 if (existingTarget &&
5795 - existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
5796 - !list_empty(&existingTarget->variant.directoryVariant.children)) {
5797 + existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
5798 + !ylist_empty(&existingTarget->variant.directoryVariant.children)) {
5799 /* There is a target that is a non-empty directory, so we fail */
5800 return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */
5801 } else if (existingTarget && existingTarget != obj) {
5802 @@ -2465,7 +2496,7 @@ int yaffs_RenameObject(yaffs_Object * ol
5803 * but only if it isn't the same object
5804 */
5805 yaffs_ChangeObjectName(obj, newDir, newName, force,
5806 - existingTarget->objectId);
5807 + existingTarget->objectId);
5808 yaffs_UnlinkObject(existingTarget);
5809 }
5810
5811 @@ -2476,7 +2507,7 @@ int yaffs_RenameObject(yaffs_Object * ol
5812
5813 /*------------------------- Block Management and Page Allocation ----------------*/
5814
5815 -static int yaffs_InitialiseBlocks(yaffs_Device * dev)
5816 +static int yaffs_InitialiseBlocks(yaffs_Device *dev)
5817 {
5818 int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
5819
5820 @@ -2487,23 +2518,20 @@ static int yaffs_InitialiseBlocks(yaffs_
5821
5822 /* If the first allocation strategy fails, thry the alternate one */
5823 dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo));
5824 - if(!dev->blockInfo){
5825 + if (!dev->blockInfo) {
5826 dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo));
5827 dev->blockInfoAlt = 1;
5828 - }
5829 - else
5830 + } else
5831 dev->blockInfoAlt = 0;
5832
5833 - if(dev->blockInfo){
5834 -
5835 + if (dev->blockInfo) {
5836 /* Set up dynamic blockinfo stuff. */
5837 dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
5838 dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
5839 - if(!dev->chunkBits){
5840 + if (!dev->chunkBits) {
5841 dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks);
5842 dev->chunkBitsAlt = 1;
5843 - }
5844 - else
5845 + } else
5846 dev->chunkBitsAlt = 0;
5847 }
5848
5849 @@ -2514,30 +2542,29 @@ static int yaffs_InitialiseBlocks(yaffs_
5850 }
5851
5852 return YAFFS_FAIL;
5853 -
5854 }
5855
5856 -static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
5857 +static void yaffs_DeinitialiseBlocks(yaffs_Device *dev)
5858 {
5859 - if(dev->blockInfoAlt && dev->blockInfo)
5860 + if (dev->blockInfoAlt && dev->blockInfo)
5861 YFREE_ALT(dev->blockInfo);
5862 - else if(dev->blockInfo)
5863 + else if (dev->blockInfo)
5864 YFREE(dev->blockInfo);
5865
5866 dev->blockInfoAlt = 0;
5867
5868 dev->blockInfo = NULL;
5869
5870 - if(dev->chunkBitsAlt && dev->chunkBits)
5871 + if (dev->chunkBitsAlt && dev->chunkBits)
5872 YFREE_ALT(dev->chunkBits);
5873 - else if(dev->chunkBits)
5874 + else if (dev->chunkBits)
5875 YFREE(dev->chunkBits);
5876 dev->chunkBitsAlt = 0;
5877 dev->chunkBits = NULL;
5878 }
5879
5880 -static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device * dev,
5881 - yaffs_BlockInfo * bi)
5882 +static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
5883 + yaffs_BlockInfo *bi)
5884 {
5885 int i;
5886 __u32 seq;
5887 @@ -2556,7 +2583,7 @@ static int yaffs_BlockNotDisqualifiedFro
5888 seq = dev->sequenceNumber;
5889
5890 for (i = dev->internalStartBlock; i <= dev->internalEndBlock;
5891 - i++) {
5892 + i++) {
5893 b = yaffs_GetBlockInfo(dev, i);
5894 if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
5895 (b->pagesInUse - b->softDeletions) <
5896 @@ -2571,38 +2598,36 @@ static int yaffs_BlockNotDisqualifiedFro
5897 * discarded pages.
5898 */
5899 return (bi->sequenceNumber <= dev->oldestDirtySequence);
5900 -
5901 }
5902
5903 /* FindDiretiestBlock is used to select the dirtiest block (or close enough)
5904 * for garbage collection.
5905 */
5906
5907 -static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
5908 - int aggressive)
5909 +static int yaffs_FindBlockForGarbageCollection(yaffs_Device *dev,
5910 + int aggressive)
5911 {
5912 -
5913 int b = dev->currentDirtyChecker;
5914
5915 int i;
5916 int iterations;
5917 int dirtiest = -1;
5918 int pagesInUse = 0;
5919 - int prioritised=0;
5920 + int prioritised = 0;
5921 yaffs_BlockInfo *bi;
5922 int pendingPrioritisedExist = 0;
5923
5924 /* First let's see if we need to grab a prioritised block */
5925 - if(dev->hasPendingPrioritisedGCs){
5926 - for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
5927 + if (dev->hasPendingPrioritisedGCs) {
5928 + for (i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++) {
5929
5930 bi = yaffs_GetBlockInfo(dev, i);
5931 - //yaffs_VerifyBlock(dev,bi,i);
5932 + /* yaffs_VerifyBlock(dev,bi,i); */
5933
5934 - if(bi->gcPrioritise) {
5935 + if (bi->gcPrioritise) {
5936 pendingPrioritisedExist = 1;
5937 - if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
5938 - yaffs_BlockNotDisqualifiedFromGC(dev, bi)){
5939 + if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
5940 + yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
5941 pagesInUse = (bi->pagesInUse - bi->softDeletions);
5942 dirtiest = i;
5943 prioritised = 1;
5944 @@ -2611,7 +2636,7 @@ static int yaffs_FindBlockForGarbageColl
5945 }
5946 }
5947
5948 - if(!pendingPrioritisedExist) /* None found, so we can clear this */
5949 + if (!pendingPrioritisedExist) /* None found, so we can clear this */
5950 dev->hasPendingPrioritisedGCs = 0;
5951 }
5952
5953 @@ -2623,31 +2648,28 @@ static int yaffs_FindBlockForGarbageColl
5954
5955 dev->nonAggressiveSkip--;
5956
5957 - if (!aggressive && (dev->nonAggressiveSkip > 0)) {
5958 + if (!aggressive && (dev->nonAggressiveSkip > 0))
5959 return -1;
5960 - }
5961
5962 - if(!prioritised)
5963 + if (!prioritised)
5964 pagesInUse =
5965 - (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
5966 + (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
5967
5968 - if (aggressive) {
5969 + if (aggressive)
5970 iterations =
5971 dev->internalEndBlock - dev->internalStartBlock + 1;
5972 - } else {
5973 + else {
5974 iterations =
5975 dev->internalEndBlock - dev->internalStartBlock + 1;
5976 iterations = iterations / 16;
5977 - if (iterations > 200) {
5978 + if (iterations > 200)
5979 iterations = 200;
5980 - }
5981 }
5982
5983 for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
5984 b++;
5985 - if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
5986 + if (b < dev->internalStartBlock || b > dev->internalEndBlock)
5987 b = dev->internalStartBlock;
5988 - }
5989
5990 if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
5991 T(YAFFS_TRACE_ERROR,
5992 @@ -2657,17 +2679,9 @@ static int yaffs_FindBlockForGarbageColl
5993
5994 bi = yaffs_GetBlockInfo(dev, b);
5995
5996 -#if 0
5997 - if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
5998 - dirtiest = b;
5999 - pagesInUse = 0;
6000 - }
6001 - else
6002 -#endif
6003 -
6004 if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
6005 - (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
6006 - yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
6007 + (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
6008 + yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
6009 dirtiest = b;
6010 pagesInUse = (bi->pagesInUse - bi->softDeletions);
6011 }
6012 @@ -2678,19 +2692,18 @@ static int yaffs_FindBlockForGarbageColl
6013 if (dirtiest > 0) {
6014 T(YAFFS_TRACE_GC,
6015 (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest,
6016 - dev->nChunksPerBlock - pagesInUse,prioritised));
6017 + dev->nChunksPerBlock - pagesInUse, prioritised));
6018 }
6019
6020 dev->oldestDirtySequence = 0;
6021
6022 - if (dirtiest > 0) {
6023 + if (dirtiest > 0)
6024 dev->nonAggressiveSkip = 4;
6025 - }
6026
6027 return dirtiest;
6028 }
6029
6030 -static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
6031 +static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo)
6032 {
6033 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo);
6034
6035 @@ -2752,7 +2765,7 @@ static void yaffs_BlockBecameDirty(yaffs
6036 }
6037 }
6038
6039 -static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
6040 +static int yaffs_FindBlockForAllocation(yaffs_Device *dev)
6041 {
6042 int i;
6043
6044 @@ -2763,7 +2776,7 @@ static int yaffs_FindBlockForAllocation(
6045 * Can't get space to gc
6046 */
6047 T(YAFFS_TRACE_ERROR,
6048 - (TSTR("yaffs tragedy: no more eraased blocks" TENDSTR)));
6049 + (TSTR("yaffs tragedy: no more erased blocks" TENDSTR)));
6050
6051 return -1;
6052 }
6053 @@ -2794,31 +2807,74 @@ static int yaffs_FindBlockForAllocation(
6054
6055 T(YAFFS_TRACE_ALWAYS,
6056 (TSTR
6057 - ("yaffs tragedy: no more eraased blocks, but there should have been %d"
6058 + ("yaffs tragedy: no more erased blocks, but there should have been %d"
6059 TENDSTR), dev->nErasedBlocks));
6060
6061 return -1;
6062 }
6063
6064
6065 -// Check if there's space to allocate...
6066 -// Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
6067 -static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
6068 +
6069 +static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
6070 +{
6071 + if (!dev->nCheckpointBlocksRequired &&
6072 + dev->isYaffs2) {
6073 + /* Not a valid value so recalculate */
6074 + int nBytes = 0;
6075 + int nBlocks;
6076 + int devBlocks = (dev->endBlock - dev->startBlock + 1);
6077 + int tnodeSize;
6078 +
6079 + tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
6080 +
6081 + if (tnodeSize < sizeof(yaffs_Tnode))
6082 + tnodeSize = sizeof(yaffs_Tnode);
6083 +
6084 + nBytes += sizeof(yaffs_CheckpointValidity);
6085 + nBytes += sizeof(yaffs_CheckpointDevice);
6086 + nBytes += devBlocks * sizeof(yaffs_BlockInfo);
6087 + nBytes += devBlocks * dev->chunkBitmapStride;
6088 + nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjectsCreated - dev->nFreeObjects);
6089 + nBytes += (tnodeSize + sizeof(__u32)) * (dev->nTnodesCreated - dev->nFreeTnodes);
6090 + nBytes += sizeof(yaffs_CheckpointValidity);
6091 + nBytes += sizeof(__u32); /* checksum*/
6092 +
6093 + /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
6094 +
6095 + nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->nChunksPerBlock)) + 3;
6096 +
6097 + dev->nCheckpointBlocksRequired = nBlocks;
6098 + }
6099 +
6100 + return dev->nCheckpointBlocksRequired;
6101 +}
6102 +
6103 +/*
6104 + * Check if there's space to allocate...
6105 + * Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
6106 + */
6107 +static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev)
6108 {
6109 int reservedChunks;
6110 int reservedBlocks = dev->nReservedBlocks;
6111 int checkpointBlocks;
6112
6113 - checkpointBlocks = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
6114 - if(checkpointBlocks < 0)
6115 + if (dev->isYaffs2) {
6116 + checkpointBlocks = yaffs_CalcCheckpointBlocksRequired(dev) -
6117 + dev->blocksInCheckpoint;
6118 + if (checkpointBlocks < 0)
6119 + checkpointBlocks = 0;
6120 + } else {
6121 checkpointBlocks = 0;
6122 + }
6123
6124 reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
6125
6126 return (dev->nFreeChunks > reservedChunks);
6127 }
6128
6129 -static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr)
6130 +static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve,
6131 + yaffs_BlockInfo **blockUsedPtr)
6132 {
6133 int retVal;
6134 yaffs_BlockInfo *bi;
6135 @@ -2835,7 +2891,7 @@ static int yaffs_AllocateChunk(yaffs_Dev
6136 }
6137
6138 if (dev->nErasedBlocks < dev->nReservedBlocks
6139 - && dev->allocationPage == 0) {
6140 + && dev->allocationPage == 0) {
6141 T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
6142 }
6143
6144 @@ -2844,10 +2900,10 @@ static int yaffs_AllocateChunk(yaffs_Dev
6145 bi = yaffs_GetBlockInfo(dev, dev->allocationBlock);
6146
6147 retVal = (dev->allocationBlock * dev->nChunksPerBlock) +
6148 - dev->allocationPage;
6149 + dev->allocationPage;
6150 bi->pagesInUse++;
6151 yaffs_SetChunkBit(dev, dev->allocationBlock,
6152 - dev->allocationPage);
6153 + dev->allocationPage);
6154
6155 dev->allocationPage++;
6156
6157 @@ -2859,43 +2915,43 @@ static int yaffs_AllocateChunk(yaffs_Dev
6158 dev->allocationBlock = -1;
6159 }
6160
6161 - if(blockUsedPtr)
6162 + if (blockUsedPtr)
6163 *blockUsedPtr = bi;
6164
6165 return retVal;
6166 }
6167
6168 T(YAFFS_TRACE_ERROR,
6169 - (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
6170 + (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
6171
6172 return -1;
6173 }
6174
6175 -static int yaffs_GetErasedChunks(yaffs_Device * dev)
6176 +static int yaffs_GetErasedChunks(yaffs_Device *dev)
6177 {
6178 int n;
6179
6180 n = dev->nErasedBlocks * dev->nChunksPerBlock;
6181
6182 - if (dev->allocationBlock > 0) {
6183 + if (dev->allocationBlock > 0)
6184 n += (dev->nChunksPerBlock - dev->allocationPage);
6185 - }
6186
6187 return n;
6188
6189 }
6190
6191 -static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
6192 +static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
6193 + int wholeBlock)
6194 {
6195 int oldChunk;
6196 int newChunk;
6197 - int chunkInBlock;
6198 int markNAND;
6199 int retVal = YAFFS_OK;
6200 int cleanups = 0;
6201 int i;
6202 int isCheckpointBlock;
6203 int matchingChunk;
6204 + int maxCopies;
6205
6206 int chunksBefore = yaffs_GetErasedChunks(dev);
6207 int chunksAfter;
6208 @@ -2911,8 +2967,11 @@ static int yaffs_GarbageCollectBlock(yaf
6209 bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
6210
6211 T(YAFFS_TRACE_TRACING,
6212 - (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block,
6213 - bi->pagesInUse, bi->hasShrinkHeader));
6214 + (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR),
6215 + block,
6216 + bi->pagesInUse,
6217 + bi->hasShrinkHeader,
6218 + wholeBlock));
6219
6220 /*yaffs_VerifyFreeChunks(dev); */
6221
6222 @@ -2926,26 +2985,33 @@ static int yaffs_GarbageCollectBlock(yaf
6223 dev->isDoingGC = 1;
6224
6225 if (isCheckpointBlock ||
6226 - !yaffs_StillSomeChunkBits(dev, block)) {
6227 + !yaffs_StillSomeChunkBits(dev, block)) {
6228 T(YAFFS_TRACE_TRACING,
6229 - (TSTR
6230 - ("Collecting block %d that has no chunks in use" TENDSTR),
6231 - block));
6232 + (TSTR
6233 + ("Collecting block %d that has no chunks in use" TENDSTR),
6234 + block));
6235 yaffs_BlockBecameDirty(dev, block);
6236 } else {
6237
6238 __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
6239
6240 - yaffs_VerifyBlock(dev,bi,block);
6241 + yaffs_VerifyBlock(dev, bi, block);
6242
6243 - for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
6244 - chunkInBlock < dev->nChunksPerBlock
6245 - && yaffs_StillSomeChunkBits(dev, block);
6246 - chunkInBlock++, oldChunk++) {
6247 - if (yaffs_CheckChunkBit(dev, block, chunkInBlock)) {
6248 + maxCopies = (wholeBlock) ? dev->nChunksPerBlock : 10;
6249 + oldChunk = block * dev->nChunksPerBlock + dev->gcChunk;
6250 +
6251 + for (/* init already done */;
6252 + retVal == YAFFS_OK &&
6253 + dev->gcChunk < dev->nChunksPerBlock &&
6254 + (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) &&
6255 + maxCopies > 0;
6256 + dev->gcChunk++, oldChunk++) {
6257 + if (yaffs_CheckChunkBit(dev, block, dev->gcChunk)) {
6258
6259 /* This page is in use and might need to be copied off */
6260
6261 + maxCopies--;
6262 +
6263 markNAND = 1;
6264
6265 yaffs_InitialiseTags(&tags);
6266 @@ -2959,22 +3025,22 @@ static int yaffs_GarbageCollectBlock(yaf
6267
6268 T(YAFFS_TRACE_GC_DETAIL,
6269 (TSTR
6270 - ("Collecting page %d, %d %d %d " TENDSTR),
6271 - chunkInBlock, tags.objectId, tags.chunkId,
6272 + ("Collecting chunk in block %d, %d %d %d " TENDSTR),
6273 + dev->gcChunk, tags.objectId, tags.chunkId,
6274 tags.byteCount));
6275
6276 - if(object && !yaffs_SkipVerification(dev)){
6277 - if(tags.chunkId == 0)
6278 - matchingChunk = object->chunkId;
6279 - else if(object->softDeleted)
6280 + if (object && !yaffs_SkipVerification(dev)) {
6281 + if (tags.chunkId == 0)
6282 + matchingChunk = object->hdrChunk;
6283 + else if (object->softDeleted)
6284 matchingChunk = oldChunk; /* Defeat the test */
6285 else
6286 - matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
6287 + matchingChunk = yaffs_FindChunkInFile(object, tags.chunkId, NULL);
6288
6289 - if(oldChunk != matchingChunk)
6290 + if (oldChunk != matchingChunk)
6291 T(YAFFS_TRACE_ERROR,
6292 (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
6293 - oldChunk,matchingChunk,tags.objectId, tags.chunkId));
6294 + oldChunk, matchingChunk, tags.objectId, tags.chunkId));
6295
6296 }
6297
6298 @@ -2986,9 +3052,11 @@ static int yaffs_GarbageCollectBlock(yaf
6299 tags.objectId, tags.chunkId, tags.byteCount));
6300 }
6301
6302 - if (object && object->deleted
6303 - && tags.chunkId != 0) {
6304 - /* Data chunk in a deleted file, throw it away
6305 + if (object &&
6306 + object->deleted &&
6307 + object->softDeleted &&
6308 + tags.chunkId != 0) {
6309 + /* Data chunk in a soft deleted file, throw it away
6310 * It's a soft deleted data chunk,
6311 * No need to copy this, just forget about it and
6312 * fix up the object.
6313 @@ -3003,13 +3071,12 @@ static int yaffs_GarbageCollectBlock(yaf
6314 cleanups++;
6315 }
6316 markNAND = 0;
6317 - } else if (0
6318 - /* Todo object && object->deleted && object->nDataChunks == 0 */
6319 - ) {
6320 + } else if (0) {
6321 + /* Todo object && object->deleted && object->nDataChunks == 0 */
6322 /* Deleted object header with no data chunks.
6323 * Can be discarded and the file deleted.
6324 */
6325 - object->chunkId = 0;
6326 + object->hdrChunk = 0;
6327 yaffs_FreeTnode(object->myDev,
6328 object->variant.
6329 fileVariant.top);
6330 @@ -3031,17 +3098,14 @@ static int yaffs_GarbageCollectBlock(yaf
6331 * We need to nuke the shrinkheader flags first
6332 * We no longer want the shrinkHeader flag since its work is done
6333 * and if it is left in place it will mess up scanning.
6334 - * Also, clear out any shadowing stuff
6335 */
6336
6337 yaffs_ObjectHeader *oh;
6338 oh = (yaffs_ObjectHeader *)buffer;
6339 oh->isShrink = 0;
6340 - oh->shadowsObject = -1;
6341 - tags.extraShadows = 0;
6342 tags.extraIsShrinkHeader = 0;
6343
6344 - yaffs_VerifyObjectHeader(object,oh,&tags,1);
6345 + yaffs_VerifyObjectHeader(object, oh, &tags, 1);
6346 }
6347
6348 newChunk =
6349 @@ -3055,7 +3119,7 @@ static int yaffs_GarbageCollectBlock(yaf
6350
6351 if (tags.chunkId == 0) {
6352 /* It's a header */
6353 - object->chunkId = newChunk;
6354 + object->hdrChunk = newChunk;
6355 object->serial = tags.serialNumber;
6356 } else {
6357 /* It's a data chunk */
6358 @@ -3067,7 +3131,8 @@ static int yaffs_GarbageCollectBlock(yaf
6359 }
6360 }
6361
6362 - yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
6363 + if (retVal == YAFFS_OK)
6364 + yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
6365
6366 }
6367 }
6368 @@ -3098,18 +3163,25 @@ static int yaffs_GarbageCollectBlock(yaf
6369
6370 }
6371
6372 - yaffs_VerifyCollectedBlock(dev,bi,block);
6373 + yaffs_VerifyCollectedBlock(dev, bi, block);
6374
6375 - if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
6376 + chunksAfter = yaffs_GetErasedChunks(dev);
6377 + if (chunksBefore >= chunksAfter) {
6378 T(YAFFS_TRACE_GC,
6379 (TSTR
6380 ("gc did not increase free chunks before %d after %d"
6381 TENDSTR), chunksBefore, chunksAfter));
6382 }
6383
6384 + /* If the gc completed then clear the current gcBlock so that we find another. */
6385 + if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) {
6386 + dev->gcBlock = -1;
6387 + dev->gcChunk = 0;
6388 + }
6389 +
6390 dev->isDoingGC = 0;
6391
6392 - return YAFFS_OK;
6393 + return retVal;
6394 }
6395
6396 /* New garbage collector
6397 @@ -3121,7 +3193,7 @@ static int yaffs_GarbageCollectBlock(yaf
6398 * The idea is to help clear out space in a more spread-out manner.
6399 * Dunno if it really does anything useful.
6400 */
6401 -static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
6402 +static int yaffs_CheckGarbageCollection(yaffs_Device *dev)
6403 {
6404 int block;
6405 int aggressive;
6406 @@ -3142,8 +3214,8 @@ static int yaffs_CheckGarbageCollection(
6407 do {
6408 maxTries++;
6409
6410 - checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
6411 - if(checkpointBlockAdjust < 0)
6412 + checkpointBlockAdjust = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
6413 + if (checkpointBlockAdjust < 0)
6414 checkpointBlockAdjust = 0;
6415
6416 if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) {
6417 @@ -3154,20 +3226,24 @@ static int yaffs_CheckGarbageCollection(
6418 aggressive = 0;
6419 }
6420
6421 - block = yaffs_FindBlockForGarbageCollection(dev, aggressive);
6422 + if (dev->gcBlock <= 0) {
6423 + dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive);
6424 + dev->gcChunk = 0;
6425 + }
6426 +
6427 + block = dev->gcBlock;
6428
6429 if (block > 0) {
6430 dev->garbageCollections++;
6431 - if (!aggressive) {
6432 + if (!aggressive)
6433 dev->passiveGarbageCollections++;
6434 - }
6435
6436 T(YAFFS_TRACE_GC,
6437 (TSTR
6438 ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR),
6439 dev->nErasedBlocks, aggressive));
6440
6441 - gcOk = yaffs_GarbageCollectBlock(dev, block);
6442 + gcOk = yaffs_GarbageCollectBlock(dev, block, aggressive);
6443 }
6444
6445 if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) {
6446 @@ -3176,15 +3252,16 @@ static int yaffs_CheckGarbageCollection(
6447 ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d"
6448 TENDSTR), dev->nErasedBlocks, maxTries, block));
6449 }
6450 - } while ((dev->nErasedBlocks < dev->nReservedBlocks) && (block > 0)
6451 - && (maxTries < 2));
6452 + } while ((dev->nErasedBlocks < dev->nReservedBlocks) &&
6453 + (block > 0) &&
6454 + (maxTries < 2));
6455
6456 return aggressive ? gcOk : YAFFS_OK;
6457 }
6458
6459 /*------------------------- TAGS --------------------------------*/
6460
6461 -static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
6462 +static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId,
6463 int chunkInObject)
6464 {
6465 return (tags->chunkId == chunkInObject &&
6466 @@ -3195,8 +3272,8 @@ static int yaffs_TagsMatch(const yaffs_E
6467
6468 /*-------------------- Data file manipulation -----------------*/
6469
6470 -static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
6471 - yaffs_ExtendedTags * tags)
6472 +static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode,
6473 + yaffs_ExtendedTags *tags)
6474 {
6475 /*Get the Tnode, then get the level 0 offset chunk offset */
6476 yaffs_Tnode *tn;
6477 @@ -3214,7 +3291,7 @@ static int yaffs_FindChunkInFile(yaffs_O
6478 tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
6479
6480 if (tn) {
6481 - theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
6482 + theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
6483
6484 retVal =
6485 yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
6486 @@ -3223,8 +3300,8 @@ static int yaffs_FindChunkInFile(yaffs_O
6487 return retVal;
6488 }
6489
6490 -static int yaffs_FindAndDeleteChunkInFile(yaffs_Object * in, int chunkInInode,
6491 - yaffs_ExtendedTags * tags)
6492 +static int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in, int chunkInInode,
6493 + yaffs_ExtendedTags *tags)
6494 {
6495 /* Get the Tnode, then get the level 0 offset chunk offset */
6496 yaffs_Tnode *tn;
6497 @@ -3243,29 +3320,23 @@ static int yaffs_FindAndDeleteChunkInFil
6498
6499 if (tn) {
6500
6501 - theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
6502 + theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
6503
6504 retVal =
6505 yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
6506 chunkInInode);
6507
6508 /* Delete the entry in the filestructure (if found) */
6509 - if (retVal != -1) {
6510 - yaffs_PutLevel0Tnode(dev,tn,chunkInInode,0);
6511 - }
6512 - } else {
6513 - /*T(("No level 0 found for %d\n", chunkInInode)); */
6514 + if (retVal != -1)
6515 + yaffs_PutLevel0Tnode(dev, tn, chunkInInode, 0);
6516 }
6517
6518 - if (retVal == -1) {
6519 - /* T(("Could not find %d to delete\n",chunkInInode)); */
6520 - }
6521 return retVal;
6522 }
6523
6524 #ifdef YAFFS_PARANOID
6525
6526 -static int yaffs_CheckFileSanity(yaffs_Object * in)
6527 +static int yaffs_CheckFileSanity(yaffs_Object *in)
6528 {
6529 int chunk;
6530 int nChunks;
6531 @@ -3278,10 +3349,8 @@ static int yaffs_CheckFileSanity(yaffs_O
6532 int theChunk;
6533 int chunkDeleted;
6534
6535 - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
6536 - /* T(("Object not a file\n")); */
6537 + if (in->variantType != YAFFS_OBJECT_TYPE_FILE)
6538 return YAFFS_FAIL;
6539 - }
6540
6541 objId = in->objectId;
6542 fSize = in->variant.fileVariant.fileSize;
6543 @@ -3294,7 +3363,7 @@ static int yaffs_CheckFileSanity(yaffs_O
6544
6545 if (tn) {
6546
6547 - theChunk = yaffs_GetChunkGroupBase(dev,tn,chunk);
6548 + theChunk = yaffs_GetChunkGroupBase(dev, tn, chunk);
6549
6550 if (yaffs_CheckChunkBits
6551 (dev, theChunk / dev->nChunksPerBlock,
6552 @@ -3323,7 +3392,7 @@ static int yaffs_CheckFileSanity(yaffs_O
6553
6554 #endif
6555
6556 -static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
6557 +static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode,
6558 int chunkInNAND, int inScan)
6559 {
6560 /* NB inScan is zero unless scanning.
6561 @@ -3358,11 +3427,10 @@ static int yaffs_PutChunkIntoFile(yaffs_
6562 &in->variant.fileVariant,
6563 chunkInInode,
6564 NULL);
6565 - if (!tn) {
6566 + if (!tn)
6567 return YAFFS_FAIL;
6568 - }
6569
6570 - existingChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
6571 + existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
6572
6573 if (inScan != 0) {
6574 /* If we're scanning then we need to test for duplicates
6575 @@ -3374,7 +3442,7 @@ static int yaffs_PutChunkIntoFile(yaffs_
6576 * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
6577 */
6578
6579 - if (existingChunk != 0) {
6580 + if (existingChunk > 0) {
6581 /* NB Right now existing chunk will not be real chunkId if the device >= 32MB
6582 * thus we have to do a FindChunkInFile to get the real chunk id.
6583 *
6584 @@ -3411,8 +3479,10 @@ static int yaffs_PutChunkIntoFile(yaffs_
6585 * not be loaded during a scan
6586 */
6587
6588 - newSerial = newTags.serialNumber;
6589 - existingSerial = existingTags.serialNumber;
6590 + if (inScan > 0) {
6591 + newSerial = newTags.serialNumber;
6592 + existingSerial = existingTags.serialNumber;
6593 + }
6594
6595 if ((inScan > 0) &&
6596 (in->myDev->isYaffs2 ||
6597 @@ -3437,24 +3507,23 @@ static int yaffs_PutChunkIntoFile(yaffs_
6598
6599 }
6600
6601 - if (existingChunk == 0) {
6602 + if (existingChunk == 0)
6603 in->nDataChunks++;
6604 - }
6605
6606 - yaffs_PutLevel0Tnode(dev,tn,chunkInInode,chunkInNAND);
6607 + yaffs_PutLevel0Tnode(dev, tn, chunkInInode, chunkInNAND);
6608
6609 return YAFFS_OK;
6610 }
6611
6612 -static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
6613 - __u8 * buffer)
6614 +static int yaffs_ReadChunkDataFromObject(yaffs_Object *in, int chunkInInode,
6615 + __u8 *buffer)
6616 {
6617 int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL);
6618
6619 - if (chunkInNAND >= 0) {
6620 + if (chunkInNAND >= 0)
6621 return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND,
6622 - buffer,NULL);
6623 - } else {
6624 + buffer, NULL);
6625 + else {
6626 T(YAFFS_TRACE_NANDACCESS,
6627 (TSTR("Chunk %d not found zero instead" TENDSTR),
6628 chunkInNAND));
6629 @@ -3465,7 +3534,7 @@ static int yaffs_ReadChunkDataFromObject
6630
6631 }
6632
6633 -void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
6634 +void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn)
6635 {
6636 int block;
6637 int page;
6638 @@ -3475,16 +3544,15 @@ void yaffs_DeleteChunk(yaffs_Device * de
6639 if (chunkId <= 0)
6640 return;
6641
6642 -
6643 dev->nDeletions++;
6644 block = chunkId / dev->nChunksPerBlock;
6645 page = chunkId % dev->nChunksPerBlock;
6646
6647
6648 - if(!yaffs_CheckChunkBit(dev,block,page))
6649 + if (!yaffs_CheckChunkBit(dev, block, page))
6650 T(YAFFS_TRACE_VERIFY,
6651 - (TSTR("Deleting invalid chunk %d"TENDSTR),
6652 - chunkId));
6653 + (TSTR("Deleting invalid chunk %d"TENDSTR),
6654 + chunkId));
6655
6656 bi = yaffs_GetBlockInfo(dev, block);
6657
6658 @@ -3524,14 +3592,12 @@ void yaffs_DeleteChunk(yaffs_Device * de
6659 yaffs_BlockBecameDirty(dev, block);
6660 }
6661
6662 - } else {
6663 - /* T(("Bad news deleting chunk %d\n",chunkId)); */
6664 }
6665
6666 }
6667
6668 -static int yaffs_WriteChunkDataToObject(yaffs_Object * in, int chunkInInode,
6669 - const __u8 * buffer, int nBytes,
6670 +static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
6671 + const __u8 *buffer, int nBytes,
6672 int useReserve)
6673 {
6674 /* Find old chunk Need to do this to get serial number
6675 @@ -3561,6 +3627,12 @@ static int yaffs_WriteChunkDataToObject(
6676 (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1;
6677 newTags.byteCount = nBytes;
6678
6679 + if (nBytes < 1 || nBytes > dev->totalBytesPerChunk) {
6680 + T(YAFFS_TRACE_ERROR,
6681 + (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes));
6682 + YBUG();
6683 + }
6684 +
6685 newChunkId =
6686 yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
6687 useReserve);
6688 @@ -3568,11 +3640,9 @@ static int yaffs_WriteChunkDataToObject(
6689 if (newChunkId >= 0) {
6690 yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0);
6691
6692 - if (prevChunkId >= 0) {
6693 + if (prevChunkId >= 0)
6694 yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__);
6695
6696 - }
6697 -
6698 yaffs_CheckFileSanity(in);
6699 }
6700 return newChunkId;
6701 @@ -3582,7 +3652,7 @@ static int yaffs_WriteChunkDataToObject(
6702 /* UpdateObjectHeader updates the header on NAND for an object.
6703 * If name is not NULL, then that new name is used.
6704 */
6705 -int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
6706 +int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force,
6707 int isShrink, int shadows)
6708 {
6709
6710 @@ -3603,9 +3673,12 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6711
6712 yaffs_ObjectHeader *oh = NULL;
6713
6714 - yaffs_strcpy(oldName,"silly old name");
6715 + yaffs_strcpy(oldName, _Y("silly old name"));
6716
6717 - if (!in->fake || force) {
6718 +
6719 + if (!in->fake ||
6720 + in == dev->rootDir || /* The rootDir should also be saved */
6721 + force) {
6722
6723 yaffs_CheckGarbageCollection(dev);
6724 yaffs_CheckObjectDetailsLoaded(in);
6725 @@ -3613,13 +3686,13 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6726 buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
6727 oh = (yaffs_ObjectHeader *) buffer;
6728
6729 - prevChunkId = in->chunkId;
6730 + prevChunkId = in->hdrChunk;
6731
6732 - if (prevChunkId >= 0) {
6733 + if (prevChunkId > 0) {
6734 result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
6735 buffer, &oldTags);
6736
6737 - yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
6738 + yaffs_VerifyObjectHeader(in, oh, &oldTags, 0);
6739
6740 memcpy(oldName, oh->name, sizeof(oh->name));
6741 }
6742 @@ -3628,7 +3701,7 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6743
6744 oh->type = in->variantType;
6745 oh->yst_mode = in->yst_mode;
6746 - oh->shadowsObject = shadows;
6747 + oh->shadowsObject = oh->inbandShadowsObject = shadows;
6748
6749 #ifdef CONFIG_YAFFS_WINCE
6750 oh->win_atime[0] = in->win_atime[0];
6751 @@ -3645,20 +3718,18 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6752 oh->yst_ctime = in->yst_ctime;
6753 oh->yst_rdev = in->yst_rdev;
6754 #endif
6755 - if (in->parent) {
6756 + if (in->parent)
6757 oh->parentObjectId = in->parent->objectId;
6758 - } else {
6759 + else
6760 oh->parentObjectId = 0;
6761 - }
6762
6763 if (name && *name) {
6764 memset(oh->name, 0, sizeof(oh->name));
6765 yaffs_strncpy(oh->name, name, YAFFS_MAX_NAME_LENGTH);
6766 - } else if (prevChunkId>=0) {
6767 + } else if (prevChunkId >= 0)
6768 memcpy(oh->name, oldName, sizeof(oh->name));
6769 - } else {
6770 + else
6771 memset(oh->name, 0, sizeof(oh->name));
6772 - }
6773
6774 oh->isShrink = isShrink;
6775
6776 @@ -3708,7 +3779,7 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6777 newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0;
6778 newTags.extraObjectType = in->variantType;
6779
6780 - yaffs_VerifyObjectHeader(in,oh,&newTags,1);
6781 + yaffs_VerifyObjectHeader(in, oh, &newTags, 1);
6782
6783 /* Create new chunk in NAND */
6784 newChunkId =
6785 @@ -3717,20 +3788,20 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6786
6787 if (newChunkId >= 0) {
6788
6789 - in->chunkId = newChunkId;
6790 + in->hdrChunk = newChunkId;
6791
6792 if (prevChunkId >= 0) {
6793 yaffs_DeleteChunk(dev, prevChunkId, 1,
6794 __LINE__);
6795 }
6796
6797 - if(!yaffs_ObjectHasCachedWriteData(in))
6798 + if (!yaffs_ObjectHasCachedWriteData(in))
6799 in->dirty = 0;
6800
6801 /* If this was a shrink, then mark the block that the chunk lives on */
6802 if (isShrink) {
6803 bi = yaffs_GetBlockInfo(in->myDev,
6804 - newChunkId /in->myDev-> nChunksPerBlock);
6805 + newChunkId / in->myDev->nChunksPerBlock);
6806 bi->hasShrinkHeader = 1;
6807 }
6808
6809 @@ -3766,7 +3837,7 @@ static int yaffs_ObjectHasCachedWriteDat
6810 yaffs_ChunkCache *cache;
6811 int nCaches = obj->myDev->nShortOpCaches;
6812
6813 - for(i = 0; i < nCaches; i++){
6814 + for (i = 0; i < nCaches; i++) {
6815 cache = &dev->srCache[i];
6816 if (cache->object == obj &&
6817 cache->dirty)
6818 @@ -3777,7 +3848,7 @@ static int yaffs_ObjectHasCachedWriteDat
6819 }
6820
6821
6822 -static void yaffs_FlushFilesChunkCache(yaffs_Object * obj)
6823 +static void yaffs_FlushFilesChunkCache(yaffs_Object *obj)
6824 {
6825 yaffs_Device *dev = obj->myDev;
6826 int lowest = -99; /* Stop compiler whining. */
6827 @@ -3844,16 +3915,16 @@ void yaffs_FlushEntireDeviceCache(yaffs_
6828 */
6829 do {
6830 obj = NULL;
6831 - for( i = 0; i < nCaches && !obj; i++) {
6832 + for (i = 0; i < nCaches && !obj; i++) {
6833 if (dev->srCache[i].object &&
6834 dev->srCache[i].dirty)
6835 obj = dev->srCache[i].object;
6836
6837 }
6838 - if(obj)
6839 + if (obj)
6840 yaffs_FlushFilesChunkCache(obj);
6841
6842 - } while(obj);
6843 + } while (obj);
6844
6845 }
6846
6847 @@ -3863,41 +3934,21 @@ void yaffs_FlushEntireDeviceCache(yaffs_
6848 * Then look for the least recently used non-dirty one.
6849 * Then look for the least recently used dirty one...., flush and look again.
6850 */
6851 -static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
6852 +static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev)
6853 {
6854 int i;
6855 - int usage;
6856 - int theOne;
6857
6858 if (dev->nShortOpCaches > 0) {
6859 for (i = 0; i < dev->nShortOpCaches; i++) {
6860 if (!dev->srCache[i].object)
6861 return &dev->srCache[i];
6862 }
6863 + }
6864
6865 - return NULL;
6866 + return NULL;
6867 +}
6868
6869 - theOne = -1;
6870 - usage = 0; /* just to stop the compiler grizzling */
6871 -
6872 - for (i = 0; i < dev->nShortOpCaches; i++) {
6873 - if (!dev->srCache[i].dirty &&
6874 - ((dev->srCache[i].lastUse < usage && theOne >= 0) ||
6875 - theOne < 0)) {
6876 - usage = dev->srCache[i].lastUse;
6877 - theOne = i;
6878 - }
6879 - }
6880 -
6881 -
6882 - return theOne >= 0 ? &dev->srCache[theOne] : NULL;
6883 - } else {
6884 - return NULL;
6885 - }
6886 -
6887 -}
6888 -
6889 -static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device * dev)
6890 +static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev)
6891 {
6892 yaffs_ChunkCache *cache;
6893 yaffs_Object *theObj;
6894 @@ -3927,8 +3978,7 @@ static yaffs_ChunkCache *yaffs_GrabChunk
6895 for (i = 0; i < dev->nShortOpCaches; i++) {
6896 if (dev->srCache[i].object &&
6897 !dev->srCache[i].locked &&
6898 - (dev->srCache[i].lastUse < usage || !cache))
6899 - {
6900 + (dev->srCache[i].lastUse < usage || !cache)) {
6901 usage = dev->srCache[i].lastUse;
6902 theObj = dev->srCache[i].object;
6903 cache = &dev->srCache[i];
6904 @@ -3950,7 +4000,7 @@ static yaffs_ChunkCache *yaffs_GrabChunk
6905 }
6906
6907 /* Find a cached chunk */
6908 -static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object * obj,
6909 +static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj,
6910 int chunkId)
6911 {
6912 yaffs_Device *dev = obj->myDev;
6913 @@ -3969,7 +4019,7 @@ static yaffs_ChunkCache *yaffs_FindChunk
6914 }
6915
6916 /* Mark the chunk for the least recently used algorithym */
6917 -static void yaffs_UseChunkCache(yaffs_Device * dev, yaffs_ChunkCache * cache,
6918 +static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache,
6919 int isAWrite)
6920 {
6921
6922 @@ -3977,9 +4027,9 @@ static void yaffs_UseChunkCache(yaffs_De
6923 if (dev->srLastUse < 0 || dev->srLastUse > 100000000) {
6924 /* Reset the cache usages */
6925 int i;
6926 - for (i = 1; i < dev->nShortOpCaches; i++) {
6927 + for (i = 1; i < dev->nShortOpCaches; i++)
6928 dev->srCache[i].lastUse = 0;
6929 - }
6930 +
6931 dev->srLastUse = 0;
6932 }
6933
6934 @@ -3987,9 +4037,8 @@ static void yaffs_UseChunkCache(yaffs_De
6935
6936 cache->lastUse = dev->srLastUse;
6937
6938 - if (isAWrite) {
6939 + if (isAWrite)
6940 cache->dirty = 1;
6941 - }
6942 }
6943 }
6944
6945 @@ -3997,21 +4046,20 @@ static void yaffs_UseChunkCache(yaffs_De
6946 * Do this when a whole page gets written,
6947 * ie the short cache for this page is no longer valid.
6948 */
6949 -static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId)
6950 +static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId)
6951 {
6952 if (object->myDev->nShortOpCaches > 0) {
6953 yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId);
6954
6955 - if (cache) {
6956 + if (cache)
6957 cache->object = NULL;
6958 - }
6959 }
6960 }
6961
6962 /* Invalidate all the cache pages associated with this object
6963 * Do this whenever ther file is deleted or resized.
6964 */
6965 -static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
6966 +static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in)
6967 {
6968 int i;
6969 yaffs_Device *dev = in->myDev;
6970 @@ -4019,9 +4067,8 @@ static void yaffs_InvalidateWholeChunkCa
6971 if (dev->nShortOpCaches > 0) {
6972 /* Invalidate it. */
6973 for (i = 0; i < dev->nShortOpCaches; i++) {
6974 - if (dev->srCache[i].object == in) {
6975 + if (dev->srCache[i].object == in)
6976 dev->srCache[i].object = NULL;
6977 - }
6978 }
6979 }
6980 }
6981 @@ -4029,18 +4076,18 @@ static void yaffs_InvalidateWholeChunkCa
6982 /*--------------------- Checkpointing --------------------*/
6983
6984
6985 -static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
6986 +static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev, int head)
6987 {
6988 yaffs_CheckpointValidity cp;
6989
6990 - memset(&cp,0,sizeof(cp));
6991 + memset(&cp, 0, sizeof(cp));
6992
6993 cp.structType = sizeof(cp);
6994 cp.magic = YAFFS_MAGIC;
6995 cp.version = YAFFS_CHECKPOINT_VERSION;
6996 cp.head = (head) ? 1 : 0;
6997
6998 - return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
6999 + return (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)) ?
7000 1 : 0;
7001 }
7002
7003 @@ -4049,9 +4096,9 @@ static int yaffs_ReadCheckpointValidityM
7004 yaffs_CheckpointValidity cp;
7005 int ok;
7006
7007 - ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
7008 + ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
7009
7010 - if(ok)
7011 + if (ok)
7012 ok = (cp.structType == sizeof(cp)) &&
7013 (cp.magic == YAFFS_MAGIC) &&
7014 (cp.version == YAFFS_CHECKPOINT_VERSION) &&
7015 @@ -4100,21 +4147,21 @@ static int yaffs_WriteCheckpointDevice(y
7016 int ok;
7017
7018 /* Write device runtime values*/
7019 - yaffs_DeviceToCheckpointDevice(&cp,dev);
7020 + yaffs_DeviceToCheckpointDevice(&cp, dev);
7021 cp.structType = sizeof(cp);
7022
7023 - ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
7024 + ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
7025
7026 /* Write block info */
7027 - if(ok) {
7028 + if (ok) {
7029 nBytes = nBlocks * sizeof(yaffs_BlockInfo);
7030 - ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
7031 + ok = (yaffs_CheckpointWrite(dev, dev->blockInfo, nBytes) == nBytes);
7032 }
7033
7034 /* Write chunk bits */
7035 - if(ok) {
7036 + if (ok) {
7037 nBytes = nBlocks * dev->chunkBitmapStride;
7038 - ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
7039 + ok = (yaffs_CheckpointWrite(dev, dev->chunkBits, nBytes) == nBytes);
7040 }
7041 return ok ? 1 : 0;
7042
7043 @@ -4128,25 +4175,25 @@ static int yaffs_ReadCheckpointDevice(ya
7044
7045 int ok;
7046
7047 - ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
7048 - if(!ok)
7049 + ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
7050 + if (!ok)
7051 return 0;
7052
7053 - if(cp.structType != sizeof(cp))
7054 + if (cp.structType != sizeof(cp))
7055 return 0;
7056
7057
7058 - yaffs_CheckpointDeviceToDevice(dev,&cp);
7059 + yaffs_CheckpointDeviceToDevice(dev, &cp);
7060
7061 nBytes = nBlocks * sizeof(yaffs_BlockInfo);
7062
7063 - ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
7064 + ok = (yaffs_CheckpointRead(dev, dev->blockInfo, nBytes) == nBytes);
7065
7066 - if(!ok)
7067 + if (!ok)
7068 return 0;
7069 nBytes = nBlocks * dev->chunkBitmapStride;
7070
7071 - ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
7072 + ok = (yaffs_CheckpointRead(dev, dev->chunkBits, nBytes) == nBytes);
7073
7074 return ok ? 1 : 0;
7075 }
7076 @@ -4157,7 +4204,7 @@ static void yaffs_ObjectToCheckpointObje
7077
7078 cp->objectId = obj->objectId;
7079 cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
7080 - cp->chunkId = obj->chunkId;
7081 + cp->hdrChunk = obj->hdrChunk;
7082 cp->variantType = obj->variantType;
7083 cp->deleted = obj->deleted;
7084 cp->softDeleted = obj->softDeleted;
7085 @@ -4168,20 +4215,28 @@ static void yaffs_ObjectToCheckpointObje
7086 cp->serial = obj->serial;
7087 cp->nDataChunks = obj->nDataChunks;
7088
7089 - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7090 + if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7091 cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
7092 - else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7093 + else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7094 cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId;
7095 }
7096
7097 -static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp)
7098 +static int yaffs_CheckpointObjectToObject(yaffs_Object *obj, yaffs_CheckpointObject *cp)
7099 {
7100
7101 yaffs_Object *parent;
7102
7103 + if (obj->variantType != cp->variantType) {
7104 + T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "
7105 + TCONT("chunk %d does not match existing object type %d")
7106 + TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk,
7107 + obj->variantType));
7108 + return 0;
7109 + }
7110 +
7111 obj->objectId = cp->objectId;
7112
7113 - if(cp->parentId)
7114 + if (cp->parentId)
7115 parent = yaffs_FindOrCreateObjectByNumber(
7116 obj->myDev,
7117 cp->parentId,
7118 @@ -4189,10 +4244,19 @@ static void yaffs_CheckpointObjectToObje
7119 else
7120 parent = NULL;
7121
7122 - if(parent)
7123 + if (parent) {
7124 + if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
7125 + T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d"
7126 + TCONT(" chunk %d Parent type, %d, not directory")
7127 + TENDSTR),
7128 + cp->objectId, cp->parentId, cp->variantType,
7129 + cp->hdrChunk, parent->variantType));
7130 + return 0;
7131 + }
7132 yaffs_AddObjectToDirectory(parent, obj);
7133 + }
7134
7135 - obj->chunkId = cp->chunkId;
7136 + obj->hdrChunk = cp->hdrChunk;
7137 obj->variantType = cp->variantType;
7138 obj->deleted = cp->deleted;
7139 obj->softDeleted = cp->softDeleted;
7140 @@ -4203,29 +4267,34 @@ static void yaffs_CheckpointObjectToObje
7141 obj->serial = cp->serial;
7142 obj->nDataChunks = cp->nDataChunks;
7143
7144 - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7145 + if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7146 obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
7147 - else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7148 + else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7149 obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
7150
7151 - if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
7152 + if (obj->hdrChunk > 0)
7153 obj->lazyLoaded = 1;
7154 + return 1;
7155 }
7156
7157
7158
7159 -static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
7160 - __u32 level, int chunkOffset)
7161 +static int yaffs_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn,
7162 + __u32 level, int chunkOffset)
7163 {
7164 int i;
7165 yaffs_Device *dev = in->myDev;
7166 int ok = 1;
7167 - int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
7168 + int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
7169 +
7170 + if (tnodeSize < sizeof(yaffs_Tnode))
7171 + tnodeSize = sizeof(yaffs_Tnode);
7172 +
7173
7174 if (tn) {
7175 if (level > 0) {
7176
7177 - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
7178 + for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
7179 if (tn->internal[i]) {
7180 ok = yaffs_CheckpointTnodeWorker(in,
7181 tn->internal[i],
7182 @@ -4235,10 +4304,9 @@ static int yaffs_CheckpointTnodeWorker(y
7183 }
7184 } else if (level == 0) {
7185 __u32 baseOffset = chunkOffset << YAFFS_TNODES_LEVEL0_BITS;
7186 - /* printf("write tnode at %d\n",baseOffset); */
7187 - ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
7188 - if(ok)
7189 - ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
7190 + ok = (yaffs_CheckpointWrite(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset));
7191 + if (ok)
7192 + ok = (yaffs_CheckpointWrite(dev, tn, tnodeSize) == tnodeSize);
7193 }
7194 }
7195
7196 @@ -4251,13 +4319,13 @@ static int yaffs_WriteCheckpointTnodes(y
7197 __u32 endMarker = ~0;
7198 int ok = 1;
7199
7200 - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
7201 + if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
7202 ok = yaffs_CheckpointTnodeWorker(obj,
7203 obj->variant.fileVariant.top,
7204 obj->variant.fileVariant.topLevel,
7205 0);
7206 - if(ok)
7207 - ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
7208 + if (ok)
7209 + ok = (yaffs_CheckpointWrite(obj->myDev, &endMarker, sizeof(endMarker)) ==
7210 sizeof(endMarker));
7211 }
7212
7213 @@ -4272,38 +4340,38 @@ static int yaffs_ReadCheckpointTnodes(ya
7214 yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
7215 yaffs_Tnode *tn;
7216 int nread = 0;
7217 + int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
7218
7219 - ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
7220 + if (tnodeSize < sizeof(yaffs_Tnode))
7221 + tnodeSize = sizeof(yaffs_Tnode);
7222
7223 - while(ok && (~baseChunk)){
7224 + ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
7225 +
7226 + while (ok && (~baseChunk)) {
7227 nread++;
7228 /* Read level 0 tnode */
7229
7230
7231 - /* printf("read tnode at %d\n",baseChunk); */
7232 tn = yaffs_GetTnodeRaw(dev);
7233 - if(tn)
7234 - ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
7235 - (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
7236 + if (tn)
7237 + ok = (yaffs_CheckpointRead(dev, tn, tnodeSize) == tnodeSize);
7238 else
7239 ok = 0;
7240
7241 - if(tn && ok){
7242 + if (tn && ok)
7243 ok = yaffs_AddOrFindLevel0Tnode(dev,
7244 - fileStructPtr,
7245 - baseChunk,
7246 - tn) ? 1 : 0;
7247 + fileStructPtr,
7248 + baseChunk,
7249 + tn) ? 1 : 0;
7250
7251 - }
7252 -
7253 - if(ok)
7254 - ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
7255 + if (ok)
7256 + ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
7257
7258 }
7259
7260 - T(YAFFS_TRACE_CHECKPOINT,(
7261 + T(YAFFS_TRACE_CHECKPOINT, (
7262 TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
7263 - nread,baseChunk,ok));
7264 + nread, baseChunk, ok));
7265
7266 return ok ? 1 : 0;
7267 }
7268 @@ -4315,41 +4383,40 @@ static int yaffs_WriteCheckpointObjects(
7269 yaffs_CheckpointObject cp;
7270 int i;
7271 int ok = 1;
7272 - struct list_head *lh;
7273 + struct ylist_head *lh;
7274
7275
7276 /* Iterate through the objects in each hash entry,
7277 * dumping them to the checkpointing stream.
7278 */
7279
7280 - for(i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++){
7281 - list_for_each(lh, &dev->objectBucket[i].list) {
7282 + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) {
7283 + ylist_for_each(lh, &dev->objectBucket[i].list) {
7284 if (lh) {
7285 - obj = list_entry(lh, yaffs_Object, hashLink);
7286 + obj = ylist_entry(lh, yaffs_Object, hashLink);
7287 if (!obj->deferedFree) {
7288 - yaffs_ObjectToCheckpointObject(&cp,obj);
7289 + yaffs_ObjectToCheckpointObject(&cp, obj);
7290 cp.structType = sizeof(cp);
7291
7292 - T(YAFFS_TRACE_CHECKPOINT,(
7293 + T(YAFFS_TRACE_CHECKPOINT, (
7294 TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
7295 - cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
7296 + cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, (unsigned) obj));
7297
7298 - ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
7299 + ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
7300
7301 - if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
7302 + if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7303 ok = yaffs_WriteCheckpointTnodes(obj);
7304 - }
7305 }
7306 }
7307 }
7308 - }
7309 + }
7310
7311 - /* Dump end of list */
7312 - memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
7313 + /* Dump end of list */
7314 + memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject));
7315 cp.structType = sizeof(cp);
7316
7317 - if(ok)
7318 - ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
7319 + if (ok)
7320 + ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
7321
7322 return ok ? 1 : 0;
7323 }
7324 @@ -4362,38 +4429,39 @@ static int yaffs_ReadCheckpointObjects(y
7325 int done = 0;
7326 yaffs_Object *hardList = NULL;
7327
7328 - while(ok && !done) {
7329 - ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
7330 - if(cp.structType != sizeof(cp)) {
7331 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("struct size %d instead of %d ok %d"TENDSTR),
7332 - cp.structType,sizeof(cp),ok));
7333 + while (ok && !done) {
7334 + ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
7335 + if (cp.structType != sizeof(cp)) {
7336 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR),
7337 + cp.structType, sizeof(cp), ok));
7338 ok = 0;
7339 }
7340
7341 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
7342 - cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
7343 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
7344 + cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk));
7345
7346 - if(ok && cp.objectId == ~0)
7347 + if (ok && cp.objectId == ~0)
7348 done = 1;
7349 - else if(ok){
7350 - obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType);
7351 - if(obj) {
7352 - yaffs_CheckpointObjectToObject(obj,&cp);
7353 - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
7354 + else if (ok) {
7355 + obj = yaffs_FindOrCreateObjectByNumber(dev, cp.objectId, cp.variantType);
7356 + if (obj) {
7357 + ok = yaffs_CheckpointObjectToObject(obj, &cp);
7358 + if (!ok)
7359 + break;
7360 + if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
7361 ok = yaffs_ReadCheckpointTnodes(obj);
7362 - } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
7363 + } else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
7364 obj->hardLinks.next =
7365 - (struct list_head *)
7366 - hardList;
7367 + (struct ylist_head *) hardList;
7368 hardList = obj;
7369 }
7370 -
7371 - }
7372 + } else
7373 + ok = 0;
7374 }
7375 }
7376
7377 - if(ok)
7378 - yaffs_HardlinkFixup(dev,hardList);
7379 + if (ok)
7380 + yaffs_HardlinkFixup(dev, hardList);
7381
7382 return ok ? 1 : 0;
7383 }
7384 @@ -4403,11 +4471,11 @@ static int yaffs_WriteCheckpointSum(yaff
7385 __u32 checkpointSum;
7386 int ok;
7387
7388 - yaffs_GetCheckpointSum(dev,&checkpointSum);
7389 + yaffs_GetCheckpointSum(dev, &checkpointSum);
7390
7391 - ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
7392 + ok = (yaffs_CheckpointWrite(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum));
7393
7394 - if(!ok)
7395 + if (!ok)
7396 return 0;
7397
7398 return 1;
7399 @@ -4419,14 +4487,14 @@ static int yaffs_ReadCheckpointSum(yaffs
7400 __u32 checkpointSum1;
7401 int ok;
7402
7403 - yaffs_GetCheckpointSum(dev,&checkpointSum0);
7404 + yaffs_GetCheckpointSum(dev, &checkpointSum0);
7405
7406 - ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
7407 + ok = (yaffs_CheckpointRead(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1));
7408
7409 - if(!ok)
7410 + if (!ok)
7411 return 0;
7412
7413 - if(checkpointSum0 != checkpointSum1)
7414 + if (checkpointSum0 != checkpointSum1)
7415 return 0;
7416
7417 return 1;
7418 @@ -4435,46 +4503,43 @@ static int yaffs_ReadCheckpointSum(yaffs
7419
7420 static int yaffs_WriteCheckpointData(yaffs_Device *dev)
7421 {
7422 -
7423 int ok = 1;
7424
7425 - if(dev->skipCheckpointWrite || !dev->isYaffs2){
7426 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
7427 + if (dev->skipCheckpointWrite || !dev->isYaffs2) {
7428 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR)));
7429 ok = 0;
7430 }
7431
7432 - if(ok)
7433 - ok = yaffs_CheckpointOpen(dev,1);
7434 + if (ok)
7435 + ok = yaffs_CheckpointOpen(dev, 1);
7436
7437 - if(ok){
7438 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
7439 - ok = yaffs_WriteCheckpointValidityMarker(dev,1);
7440 + if (ok) {
7441 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
7442 + ok = yaffs_WriteCheckpointValidityMarker(dev, 1);
7443 }
7444 - if(ok){
7445 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint device" TENDSTR)));
7446 + if (ok) {
7447 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR)));
7448 ok = yaffs_WriteCheckpointDevice(dev);
7449 }
7450 - if(ok){
7451 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint objects" TENDSTR)));
7452 + if (ok) {
7453 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR)));
7454 ok = yaffs_WriteCheckpointObjects(dev);
7455 }
7456 - if(ok){
7457 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
7458 - ok = yaffs_WriteCheckpointValidityMarker(dev,0);
7459 + if (ok) {
7460 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
7461 + ok = yaffs_WriteCheckpointValidityMarker(dev, 0);
7462 }
7463
7464 - if(ok){
7465 + if (ok)
7466 ok = yaffs_WriteCheckpointSum(dev);
7467 - }
7468 -
7469
7470 - if(!yaffs_CheckpointClose(dev))
7471 - ok = 0;
7472 + if (!yaffs_CheckpointClose(dev))
7473 + ok = 0;
7474
7475 - if(ok)
7476 - dev->isCheckpointed = 1;
7477 - else
7478 - dev->isCheckpointed = 0;
7479 + if (ok)
7480 + dev->isCheckpointed = 1;
7481 + else
7482 + dev->isCheckpointed = 0;
7483
7484 return dev->isCheckpointed;
7485 }
7486 @@ -4483,43 +4548,43 @@ static int yaffs_ReadCheckpointData(yaff
7487 {
7488 int ok = 1;
7489
7490 - if(dev->skipCheckpointRead || !dev->isYaffs2){
7491 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
7492 + if (dev->skipCheckpointRead || !dev->isYaffs2) {
7493 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR)));
7494 ok = 0;
7495 }
7496
7497 - if(ok)
7498 - ok = yaffs_CheckpointOpen(dev,0); /* open for read */
7499 + if (ok)
7500 + ok = yaffs_CheckpointOpen(dev, 0); /* open for read */
7501
7502 - if(ok){
7503 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
7504 - ok = yaffs_ReadCheckpointValidityMarker(dev,1);
7505 + if (ok) {
7506 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
7507 + ok = yaffs_ReadCheckpointValidityMarker(dev, 1);
7508 }
7509 - if(ok){
7510 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint device" TENDSTR)));
7511 + if (ok) {
7512 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR)));
7513 ok = yaffs_ReadCheckpointDevice(dev);
7514 }
7515 - if(ok){
7516 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
7517 + if (ok) {
7518 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR)));
7519 ok = yaffs_ReadCheckpointObjects(dev);
7520 }
7521 - if(ok){
7522 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
7523 - ok = yaffs_ReadCheckpointValidityMarker(dev,0);
7524 + if (ok) {
7525 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
7526 + ok = yaffs_ReadCheckpointValidityMarker(dev, 0);
7527 }
7528
7529 - if(ok){
7530 + if (ok) {
7531 ok = yaffs_ReadCheckpointSum(dev);
7532 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
7533 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok));
7534 }
7535
7536 - if(!yaffs_CheckpointClose(dev))
7537 + if (!yaffs_CheckpointClose(dev))
7538 ok = 0;
7539
7540 - if(ok)
7541 - dev->isCheckpointed = 1;
7542 - else
7543 - dev->isCheckpointed = 0;
7544 + if (ok)
7545 + dev->isCheckpointed = 1;
7546 + else
7547 + dev->isCheckpointed = 0;
7548
7549 return ok ? 1 : 0;
7550
7551 @@ -4527,11 +4592,11 @@ static int yaffs_ReadCheckpointData(yaff
7552
7553 static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
7554 {
7555 - if(dev->isCheckpointed ||
7556 - dev->blocksInCheckpoint > 0){
7557 + if (dev->isCheckpointed ||
7558 + dev->blocksInCheckpoint > 0) {
7559 dev->isCheckpointed = 0;
7560 yaffs_CheckpointInvalidateStream(dev);
7561 - if(dev->superBlock && dev->markSuperBlockDirty)
7562 + if (dev->superBlock && dev->markSuperBlockDirty)
7563 dev->markSuperBlockDirty(dev->superBlock);
7564 }
7565 }
7566 @@ -4540,18 +4605,18 @@ static void yaffs_InvalidateCheckpoint(y
7567 int yaffs_CheckpointSave(yaffs_Device *dev)
7568 {
7569
7570 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("save entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7571 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7572
7573 yaffs_VerifyObjects(dev);
7574 yaffs_VerifyBlocks(dev);
7575 yaffs_VerifyFreeChunks(dev);
7576
7577 - if(!dev->isCheckpointed) {
7578 + if (!dev->isCheckpointed) {
7579 yaffs_InvalidateCheckpoint(dev);
7580 yaffs_WriteCheckpointData(dev);
7581 }
7582
7583 - T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7584 + T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7585
7586 return dev->isCheckpointed;
7587 }
7588 @@ -4559,17 +4624,17 @@ int yaffs_CheckpointSave(yaffs_Device *d
7589 int yaffs_CheckpointRestore(yaffs_Device *dev)
7590 {
7591 int retval;
7592 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7593 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7594
7595 retval = yaffs_ReadCheckpointData(dev);
7596
7597 - if(dev->isCheckpointed){
7598 + if (dev->isCheckpointed) {
7599 yaffs_VerifyObjects(dev);
7600 yaffs_VerifyBlocks(dev);
7601 yaffs_VerifyFreeChunks(dev);
7602 }
7603
7604 - T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7605 + T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7606
7607 return retval;
7608 }
7609 @@ -4584,12 +4649,12 @@ int yaffs_CheckpointRestore(yaffs_Device
7610 * Curve-balls: the first chunk might also be the last chunk.
7611 */
7612
7613 -int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
7614 - int nBytes)
7615 +int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset,
7616 + int nBytes)
7617 {
7618
7619 int chunk;
7620 - int start;
7621 + __u32 start;
7622 int nToCopy;
7623 int n = nBytes;
7624 int nDone = 0;
7625 @@ -4600,27 +4665,26 @@ int yaffs_ReadDataFromFile(yaffs_Object
7626 dev = in->myDev;
7627
7628 while (n > 0) {
7629 - //chunk = offset / dev->nDataBytesPerChunk + 1;
7630 - //start = offset % dev->nDataBytesPerChunk;
7631 - yaffs_AddrToChunk(dev,offset,&chunk,&start);
7632 + /* chunk = offset / dev->nDataBytesPerChunk + 1; */
7633 + /* start = offset % dev->nDataBytesPerChunk; */
7634 + yaffs_AddrToChunk(dev, offset, &chunk, &start);
7635 chunk++;
7636
7637 /* OK now check for the curveball where the start and end are in
7638 * the same chunk.
7639 */
7640 - if ((start + n) < dev->nDataBytesPerChunk) {
7641 + if ((start + n) < dev->nDataBytesPerChunk)
7642 nToCopy = n;
7643 - } else {
7644 + else
7645 nToCopy = dev->nDataBytesPerChunk - start;
7646 - }
7647
7648 cache = yaffs_FindChunkCache(in, chunk);
7649
7650 /* If the chunk is already in the cache or it is less than a whole chunk
7651 - * then use the cache (if there is caching)
7652 + * or we're using inband tags then use the cache (if there is caching)
7653 * else bypass the cache.
7654 */
7655 - if (cache || nToCopy != dev->nDataBytesPerChunk) {
7656 + if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
7657 if (dev->nShortOpCaches > 0) {
7658
7659 /* If we can't find the data in the cache, then load it up. */
7660 @@ -4641,14 +4705,9 @@ int yaffs_ReadDataFromFile(yaffs_Object
7661
7662 cache->locked = 1;
7663
7664 -#ifdef CONFIG_YAFFS_WINCE
7665 - yfsd_UnlockYAFFS(TRUE);
7666 -#endif
7667 +
7668 memcpy(buffer, &cache->data[start], nToCopy);
7669
7670 -#ifdef CONFIG_YAFFS_WINCE
7671 - yfsd_LockYAFFS(TRUE);
7672 -#endif
7673 cache->locked = 0;
7674 } else {
7675 /* Read into the local buffer then copy..*/
7676 @@ -4657,41 +4716,19 @@ int yaffs_ReadDataFromFile(yaffs_Object
7677 yaffs_GetTempBuffer(dev, __LINE__);
7678 yaffs_ReadChunkDataFromObject(in, chunk,
7679 localBuffer);
7680 -#ifdef CONFIG_YAFFS_WINCE
7681 - yfsd_UnlockYAFFS(TRUE);
7682 -#endif
7683 +
7684 memcpy(buffer, &localBuffer[start], nToCopy);
7685
7686 -#ifdef CONFIG_YAFFS_WINCE
7687 - yfsd_LockYAFFS(TRUE);
7688 -#endif
7689 +
7690 yaffs_ReleaseTempBuffer(dev, localBuffer,
7691 __LINE__);
7692 }
7693
7694 } else {
7695 -#ifdef CONFIG_YAFFS_WINCE
7696 - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
7697 -
7698 - /* Under WinCE can't do direct transfer. Need to use a local buffer.
7699 - * This is because we otherwise screw up WinCE's memory mapper
7700 - */
7701 - yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
7702 -
7703 -#ifdef CONFIG_YAFFS_WINCE
7704 - yfsd_UnlockYAFFS(TRUE);
7705 -#endif
7706 - memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
7707
7708 -#ifdef CONFIG_YAFFS_WINCE
7709 - yfsd_LockYAFFS(TRUE);
7710 - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
7711 -#endif
7712 -
7713 -#else
7714 /* A full chunk. Read directly into the supplied buffer. */
7715 yaffs_ReadChunkDataFromObject(in, chunk, buffer);
7716 -#endif
7717 +
7718 }
7719
7720 n -= nToCopy;
7721 @@ -4704,28 +4741,37 @@ int yaffs_ReadDataFromFile(yaffs_Object
7722 return nDone;
7723 }
7724
7725 -int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
7726 - int nBytes, int writeThrough)
7727 +int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
7728 + int nBytes, int writeThrough)
7729 {
7730
7731 int chunk;
7732 - int start;
7733 + __u32 start;
7734 int nToCopy;
7735 int n = nBytes;
7736 int nDone = 0;
7737 int nToWriteBack;
7738 int startOfWrite = offset;
7739 int chunkWritten = 0;
7740 - int nBytesRead;
7741 + __u32 nBytesRead;
7742 + __u32 chunkStart;
7743
7744 yaffs_Device *dev;
7745
7746 dev = in->myDev;
7747
7748 while (n > 0 && chunkWritten >= 0) {
7749 - //chunk = offset / dev->nDataBytesPerChunk + 1;
7750 - //start = offset % dev->nDataBytesPerChunk;
7751 - yaffs_AddrToChunk(dev,offset,&chunk,&start);
7752 + /* chunk = offset / dev->nDataBytesPerChunk + 1; */
7753 + /* start = offset % dev->nDataBytesPerChunk; */
7754 + yaffs_AddrToChunk(dev, offset, &chunk, &start);
7755 +
7756 + if (chunk * dev->nDataBytesPerChunk + start != offset ||
7757 + start >= dev->nDataBytesPerChunk) {
7758 + T(YAFFS_TRACE_ERROR, (
7759 + TSTR("AddrToChunk of offset %d gives chunk %d start %d"
7760 + TENDSTR),
7761 + (int)offset, chunk, start));
7762 + }
7763 chunk++;
7764
7765 /* OK now check for the curveball where the start and end are in
7766 @@ -4740,25 +4786,32 @@ int yaffs_WriteDataToFile(yaffs_Object *
7767 * we need to write back as much as was there before.
7768 */
7769
7770 - nBytesRead =
7771 - in->variant.fileVariant.fileSize -
7772 - ((chunk - 1) * dev->nDataBytesPerChunk);
7773 + chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk);
7774 +
7775 + if (chunkStart > in->variant.fileVariant.fileSize)
7776 + nBytesRead = 0; /* Past end of file */
7777 + else
7778 + nBytesRead = in->variant.fileVariant.fileSize - chunkStart;
7779
7780 - if (nBytesRead > dev->nDataBytesPerChunk) {
7781 + if (nBytesRead > dev->nDataBytesPerChunk)
7782 nBytesRead = dev->nDataBytesPerChunk;
7783 - }
7784
7785 nToWriteBack =
7786 (nBytesRead >
7787 (start + n)) ? nBytesRead : (start + n);
7788
7789 + if (nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk)
7790 + YBUG();
7791 +
7792 } else {
7793 nToCopy = dev->nDataBytesPerChunk - start;
7794 nToWriteBack = dev->nDataBytesPerChunk;
7795 }
7796
7797 - if (nToCopy != dev->nDataBytesPerChunk) {
7798 - /* An incomplete start or end chunk (or maybe both start and end chunk) */
7799 + if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
7800 + /* An incomplete start or end chunk (or maybe both start and end chunk),
7801 + * or we're using inband tags, so we want to use the cache buffers.
7802 + */
7803 if (dev->nShortOpCaches > 0) {
7804 yaffs_ChunkCache *cache;
7805 /* If we can't find the data in the cache, then load the cache */
7806 @@ -4775,10 +4828,9 @@ int yaffs_WriteDataToFile(yaffs_Object *
7807 yaffs_ReadChunkDataFromObject(in, chunk,
7808 cache->
7809 data);
7810 - }
7811 - else if(cache &&
7812 - !cache->dirty &&
7813 - !yaffs_CheckSpaceForAllocation(in->myDev)){
7814 + } else if (cache &&
7815 + !cache->dirty &&
7816 + !yaffs_CheckSpaceForAllocation(in->myDev)) {
7817 /* Drop the cache if it was a read cache item and
7818 * no space check has been made for it.
7819 */
7820 @@ -4788,16 +4840,12 @@ int yaffs_WriteDataToFile(yaffs_Object *
7821 if (cache) {
7822 yaffs_UseChunkCache(dev, cache, 1);
7823 cache->locked = 1;
7824 -#ifdef CONFIG_YAFFS_WINCE
7825 - yfsd_UnlockYAFFS(TRUE);
7826 -#endif
7827 +
7828
7829 memcpy(&cache->data[start], buffer,
7830 nToCopy);
7831
7832 -#ifdef CONFIG_YAFFS_WINCE
7833 - yfsd_LockYAFFS(TRUE);
7834 -#endif
7835 +
7836 cache->locked = 0;
7837 cache->nBytes = nToWriteBack;
7838
7839 @@ -4825,15 +4873,10 @@ int yaffs_WriteDataToFile(yaffs_Object *
7840 yaffs_ReadChunkDataFromObject(in, chunk,
7841 localBuffer);
7842
7843 -#ifdef CONFIG_YAFFS_WINCE
7844 - yfsd_UnlockYAFFS(TRUE);
7845 -#endif
7846 +
7847
7848 memcpy(&localBuffer[start], buffer, nToCopy);
7849
7850 -#ifdef CONFIG_YAFFS_WINCE
7851 - yfsd_LockYAFFS(TRUE);
7852 -#endif
7853 chunkWritten =
7854 yaffs_WriteChunkDataToObject(in, chunk,
7855 localBuffer,
7856 @@ -4846,31 +4889,15 @@ int yaffs_WriteDataToFile(yaffs_Object *
7857 }
7858
7859 } else {
7860 -
7861 -#ifdef CONFIG_YAFFS_WINCE
7862 - /* Under WinCE can't do direct transfer. Need to use a local buffer.
7863 - * This is because we otherwise screw up WinCE's memory mapper
7864 - */
7865 - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
7866 -#ifdef CONFIG_YAFFS_WINCE
7867 - yfsd_UnlockYAFFS(TRUE);
7868 -#endif
7869 - memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
7870 -#ifdef CONFIG_YAFFS_WINCE
7871 - yfsd_LockYAFFS(TRUE);
7872 -#endif
7873 - chunkWritten =
7874 - yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
7875 - dev->nDataBytesPerChunk,
7876 - 0);
7877 - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
7878 -#else
7879 /* A full chunk. Write directly from the supplied buffer. */
7880 +
7881 +
7882 +
7883 chunkWritten =
7884 yaffs_WriteChunkDataToObject(in, chunk, buffer,
7885 dev->nDataBytesPerChunk,
7886 0);
7887 -#endif
7888 +
7889 /* Since we've overwritten the cached data, we better invalidate it. */
7890 yaffs_InvalidateChunkCache(in, chunk);
7891 }
7892 @@ -4886,9 +4913,8 @@ int yaffs_WriteDataToFile(yaffs_Object *
7893
7894 /* Update file object */
7895
7896 - if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) {
7897 + if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize)
7898 in->variant.fileVariant.fileSize = (startOfWrite + nDone);
7899 - }
7900
7901 in->dirty = 1;
7902
7903 @@ -4898,7 +4924,7 @@ int yaffs_WriteDataToFile(yaffs_Object *
7904
7905 /* ---------------------- File resizing stuff ------------------ */
7906
7907 -static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
7908 +static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize)
7909 {
7910
7911 yaffs_Device *dev = in->myDev;
7912 @@ -4939,11 +4965,11 @@ static void yaffs_PruneResizedChunks(yaf
7913
7914 }
7915
7916 -int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
7917 +int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize)
7918 {
7919
7920 int oldFileSize = in->variant.fileVariant.fileSize;
7921 - int newSizeOfPartialChunk;
7922 + __u32 newSizeOfPartialChunk;
7923 int newFullChunks;
7924
7925 yaffs_Device *dev = in->myDev;
7926 @@ -4955,13 +4981,11 @@ int yaffs_ResizeFile(yaffs_Object * in,
7927
7928 yaffs_CheckGarbageCollection(dev);
7929
7930 - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
7931 - return yaffs_GetFileSize(in);
7932 - }
7933 + if (in->variantType != YAFFS_OBJECT_TYPE_FILE)
7934 + return YAFFS_FAIL;
7935
7936 - if (newSize == oldFileSize) {
7937 - return oldFileSize;
7938 - }
7939 + if (newSize == oldFileSize)
7940 + return YAFFS_OK;
7941
7942 if (newSize < oldFileSize) {
7943
7944 @@ -4994,21 +5018,20 @@ int yaffs_ResizeFile(yaffs_Object * in,
7945 }
7946
7947
7948 -
7949 /* Write a new object header.
7950 * show we've shrunk the file, if need be
7951 * Do this only if the file is not in the deleted directories.
7952 */
7953 - if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
7954 - in->parent->objectId != YAFFS_OBJECTID_DELETED) {
7955 + if (in->parent &&
7956 + in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
7957 + in->parent->objectId != YAFFS_OBJECTID_DELETED)
7958 yaffs_UpdateObjectHeader(in, NULL, 0,
7959 (newSize < oldFileSize) ? 1 : 0, 0);
7960 - }
7961
7962 - return newSize;
7963 + return YAFFS_OK;
7964 }
7965
7966 -loff_t yaffs_GetFileSize(yaffs_Object * obj)
7967 +loff_t yaffs_GetFileSize(yaffs_Object *obj)
7968 {
7969 obj = yaffs_GetEquivalentObject(obj);
7970
7971 @@ -5024,7 +5047,7 @@ loff_t yaffs_GetFileSize(yaffs_Object *
7972
7973
7974
7975 -int yaffs_FlushFile(yaffs_Object * in, int updateTime)
7976 +int yaffs_FlushFile(yaffs_Object *in, int updateTime)
7977 {
7978 int retVal;
7979 if (in->dirty) {
7980 @@ -5039,9 +5062,8 @@ int yaffs_FlushFile(yaffs_Object * in, i
7981 #endif
7982 }
7983
7984 - retVal =
7985 - (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
7986 - 0) ? YAFFS_OK : YAFFS_FAIL;
7987 + retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
7988 + 0) ? YAFFS_OK : YAFFS_FAIL;
7989 } else {
7990 retVal = YAFFS_OK;
7991 }
7992 @@ -5050,7 +5072,7 @@ int yaffs_FlushFile(yaffs_Object * in, i
7993
7994 }
7995
7996 -static int yaffs_DoGenericObjectDeletion(yaffs_Object * in)
7997 +static int yaffs_DoGenericObjectDeletion(yaffs_Object *in)
7998 {
7999
8000 /* First off, invalidate the file's data in the cache, without flushing. */
8001 @@ -5058,13 +5080,13 @@ static int yaffs_DoGenericObjectDeletion
8002
8003 if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
8004 /* Move to the unlinked directory so we have a record that it was deleted. */
8005 - yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
8006 + yaffs_ChangeObjectName(in, in->myDev->deletedDir, _Y("deleted"), 0, 0);
8007
8008 }
8009
8010 yaffs_RemoveObjectFromDirectory(in);
8011 - yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__);
8012 - in->chunkId = -1;
8013 + yaffs_DeleteChunk(in->myDev, in->hdrChunk, 1, __LINE__);
8014 + in->hdrChunk = 0;
8015
8016 yaffs_FreeObject(in);
8017 return YAFFS_OK;
8018 @@ -5075,62 +5097,63 @@ static int yaffs_DoGenericObjectDeletion
8019 * and the inode associated with the file.
8020 * It does not delete the links associated with the file.
8021 */
8022 -static int yaffs_UnlinkFile(yaffs_Object * in)
8023 +static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in)
8024 {
8025
8026 int retVal;
8027 int immediateDeletion = 0;
8028
8029 - if (1) {
8030 #ifdef __KERNEL__
8031 - if (!in->myInode) {
8032 - immediateDeletion = 1;
8033 -
8034 - }
8035 + if (!in->myInode)
8036 + immediateDeletion = 1;
8037 #else
8038 - if (in->inUse <= 0) {
8039 - immediateDeletion = 1;
8040 -
8041 - }
8042 + if (in->inUse <= 0)
8043 + immediateDeletion = 1;
8044 #endif
8045 - if (immediateDeletion) {
8046 - retVal =
8047 - yaffs_ChangeObjectName(in, in->myDev->deletedDir,
8048 - "deleted", 0, 0);
8049 - T(YAFFS_TRACE_TRACING,
8050 - (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
8051 - in->objectId));
8052 - in->deleted = 1;
8053 - in->myDev->nDeletedFiles++;
8054 - if (0 && in->myDev->isYaffs2) {
8055 - yaffs_ResizeFile(in, 0);
8056 - }
8057 - yaffs_SoftDeleteFile(in);
8058 - } else {
8059 - retVal =
8060 - yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
8061 - "unlinked", 0, 0);
8062 - }
8063
8064 + if (immediateDeletion) {
8065 + retVal =
8066 + yaffs_ChangeObjectName(in, in->myDev->deletedDir,
8067 + _Y("deleted"), 0, 0);
8068 + T(YAFFS_TRACE_TRACING,
8069 + (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
8070 + in->objectId));
8071 + in->deleted = 1;
8072 + in->myDev->nDeletedFiles++;
8073 + if (1 || in->myDev->isYaffs2)
8074 + yaffs_ResizeFile(in, 0);
8075 + yaffs_SoftDeleteFile(in);
8076 + } else {
8077 + retVal =
8078 + yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
8079 + _Y("unlinked"), 0, 0);
8080 }
8081 +
8082 +
8083 return retVal;
8084 }
8085
8086 -int yaffs_DeleteFile(yaffs_Object * in)
8087 +int yaffs_DeleteFile(yaffs_Object *in)
8088 {
8089 int retVal = YAFFS_OK;
8090 + int deleted = in->deleted;
8091 +
8092 + yaffs_ResizeFile(in, 0);
8093
8094 if (in->nDataChunks > 0) {
8095 - /* Use soft deletion if there is data in the file */
8096 - if (!in->unlinked) {
8097 - retVal = yaffs_UnlinkFile(in);
8098 - }
8099 + /* Use soft deletion if there is data in the file.
8100 + * That won't be the case if it has been resized to zero.
8101 + */
8102 + if (!in->unlinked)
8103 + retVal = yaffs_UnlinkFileIfNeeded(in);
8104 +
8105 if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
8106 in->deleted = 1;
8107 + deleted = 1;
8108 in->myDev->nDeletedFiles++;
8109 yaffs_SoftDeleteFile(in);
8110 }
8111 - return in->deleted ? YAFFS_OK : YAFFS_FAIL;
8112 + return deleted ? YAFFS_OK : YAFFS_FAIL;
8113 } else {
8114 /* The file has no data chunks so we toss it immediately */
8115 yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top);
8116 @@ -5141,62 +5164,75 @@ int yaffs_DeleteFile(yaffs_Object * in)
8117 }
8118 }
8119
8120 -static int yaffs_DeleteDirectory(yaffs_Object * in)
8121 +static int yaffs_DeleteDirectory(yaffs_Object *in)
8122 {
8123 /* First check that the directory is empty. */
8124 - if (list_empty(&in->variant.directoryVariant.children)) {
8125 + if (ylist_empty(&in->variant.directoryVariant.children))
8126 return yaffs_DoGenericObjectDeletion(in);
8127 - }
8128
8129 return YAFFS_FAIL;
8130
8131 }
8132
8133 -static int yaffs_DeleteSymLink(yaffs_Object * in)
8134 +static int yaffs_DeleteSymLink(yaffs_Object *in)
8135 {
8136 YFREE(in->variant.symLinkVariant.alias);
8137
8138 return yaffs_DoGenericObjectDeletion(in);
8139 }
8140
8141 -static int yaffs_DeleteHardLink(yaffs_Object * in)
8142 +static int yaffs_DeleteHardLink(yaffs_Object *in)
8143 {
8144 /* remove this hardlink from the list assocaited with the equivalent
8145 * object
8146 */
8147 - list_del(&in->hardLinks);
8148 + ylist_del_init(&in->hardLinks);
8149 return yaffs_DoGenericObjectDeletion(in);
8150 }
8151
8152 -static void yaffs_DestroyObject(yaffs_Object * obj)
8153 +int yaffs_DeleteObject(yaffs_Object *obj)
8154 {
8155 +int retVal = -1;
8156 switch (obj->variantType) {
8157 case YAFFS_OBJECT_TYPE_FILE:
8158 - yaffs_DeleteFile(obj);
8159 + retVal = yaffs_DeleteFile(obj);
8160 break;
8161 case YAFFS_OBJECT_TYPE_DIRECTORY:
8162 - yaffs_DeleteDirectory(obj);
8163 + return yaffs_DeleteDirectory(obj);
8164 break;
8165 case YAFFS_OBJECT_TYPE_SYMLINK:
8166 - yaffs_DeleteSymLink(obj);
8167 + retVal = yaffs_DeleteSymLink(obj);
8168 break;
8169 case YAFFS_OBJECT_TYPE_HARDLINK:
8170 - yaffs_DeleteHardLink(obj);
8171 + retVal = yaffs_DeleteHardLink(obj);
8172 break;
8173 case YAFFS_OBJECT_TYPE_SPECIAL:
8174 - yaffs_DoGenericObjectDeletion(obj);
8175 + retVal = yaffs_DoGenericObjectDeletion(obj);
8176 break;
8177 case YAFFS_OBJECT_TYPE_UNKNOWN:
8178 + retVal = 0;
8179 break; /* should not happen. */
8180 }
8181 +
8182 + return retVal;
8183 }
8184
8185 -static int yaffs_UnlinkWorker(yaffs_Object * obj)
8186 +static int yaffs_UnlinkWorker(yaffs_Object *obj)
8187 {
8188
8189 + int immediateDeletion = 0;
8190 +
8191 +#ifdef __KERNEL__
8192 + if (!obj->myInode)
8193 + immediateDeletion = 1;
8194 +#else
8195 + if (obj->inUse <= 0)
8196 + immediateDeletion = 1;
8197 +#endif
8198 +
8199 if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
8200 return yaffs_DeleteHardLink(obj);
8201 - } else if (!list_empty(&obj->hardLinks)) {
8202 + } else if (!ylist_empty(&obj->hardLinks)) {
8203 /* Curve ball: We're unlinking an object that has a hardlink.
8204 *
8205 * This problem arises because we are not strictly following
8206 @@ -5215,24 +5251,24 @@ static int yaffs_UnlinkWorker(yaffs_Obje
8207 int retVal;
8208 YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
8209
8210 - hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
8211 + hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
8212
8213 - list_del_init(&hl->hardLinks);
8214 - list_del_init(&hl->siblings);
8215 + ylist_del_init(&hl->hardLinks);
8216 + ylist_del_init(&hl->siblings);
8217
8218 yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
8219
8220 retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0);
8221
8222 - if (retVal == YAFFS_OK) {
8223 + if (retVal == YAFFS_OK)
8224 retVal = yaffs_DoGenericObjectDeletion(hl);
8225 - }
8226 +
8227 return retVal;
8228
8229 - } else {
8230 + } else if (immediateDeletion) {
8231 switch (obj->variantType) {
8232 case YAFFS_OBJECT_TYPE_FILE:
8233 - return yaffs_UnlinkFile(obj);
8234 + return yaffs_DeleteFile(obj);
8235 break;
8236 case YAFFS_OBJECT_TYPE_DIRECTORY:
8237 return yaffs_DeleteDirectory(obj);
8238 @@ -5248,21 +5284,22 @@ static int yaffs_UnlinkWorker(yaffs_Obje
8239 default:
8240 return YAFFS_FAIL;
8241 }
8242 - }
8243 + } else
8244 + return yaffs_ChangeObjectName(obj, obj->myDev->unlinkedDir,
8245 + _Y("unlinked"), 0, 0);
8246 }
8247
8248
8249 -static int yaffs_UnlinkObject( yaffs_Object *obj)
8250 +static int yaffs_UnlinkObject(yaffs_Object *obj)
8251 {
8252
8253 - if (obj && obj->unlinkAllowed) {
8254 + if (obj && obj->unlinkAllowed)
8255 return yaffs_UnlinkWorker(obj);
8256 - }
8257
8258 return YAFFS_FAIL;
8259
8260 }
8261 -int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name)
8262 +int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name)
8263 {
8264 yaffs_Object *obj;
8265
8266 @@ -5272,8 +5309,8 @@ int yaffs_Unlink(yaffs_Object * dir, con
8267
8268 /*----------------------- Initialisation Scanning ---------------------- */
8269
8270 -static void yaffs_HandleShadowedObject(yaffs_Device * dev, int objId,
8271 - int backwardScanning)
8272 +static void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId,
8273 + int backwardScanning)
8274 {
8275 yaffs_Object *obj;
8276
8277 @@ -5286,9 +5323,8 @@ static void yaffs_HandleShadowedObject(y
8278 /* Handle YAFFS2 case (backward scanning)
8279 * If the shadowed object exists then ignore.
8280 */
8281 - if (yaffs_FindObjectByNumber(dev, objId)) {
8282 + if (yaffs_FindObjectByNumber(dev, objId))
8283 return;
8284 - }
8285 }
8286
8287 /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc.
8288 @@ -5297,6 +5333,8 @@ static void yaffs_HandleShadowedObject(y
8289 obj =
8290 yaffs_FindOrCreateObjectByNumber(dev, objId,
8291 YAFFS_OBJECT_TYPE_FILE);
8292 + if (!obj)
8293 + return;
8294 yaffs_AddObjectToDirectory(dev->unlinkedDir, obj);
8295 obj->variant.fileVariant.shrinkSize = 0;
8296 obj->valid = 1; /* So that we don't read any other info for this file */
8297 @@ -5325,44 +5363,77 @@ static void yaffs_HardlinkFixup(yaffs_De
8298 if (in) {
8299 /* Add the hardlink pointers */
8300 hl->variant.hardLinkVariant.equivalentObject = in;
8301 - list_add(&hl->hardLinks, &in->hardLinks);
8302 + ylist_add(&hl->hardLinks, &in->hardLinks);
8303 } else {
8304 /* Todo Need to report/handle this better.
8305 * Got a problem... hardlink to a non-existant object
8306 */
8307 hl->variant.hardLinkVariant.equivalentObject = NULL;
8308 - INIT_LIST_HEAD(&hl->hardLinks);
8309 + YINIT_LIST_HEAD(&hl->hardLinks);
8310
8311 }
8312 -
8313 }
8314 +}
8315 +
8316 +
8317
8318 +
8319 +
8320 +static int ybicmp(const void *a, const void *b)
8321 +{
8322 + register int aseq = ((yaffs_BlockIndex *)a)->seq;
8323 + register int bseq = ((yaffs_BlockIndex *)b)->seq;
8324 + register int ablock = ((yaffs_BlockIndex *)a)->block;
8325 + register int bblock = ((yaffs_BlockIndex *)b)->block;
8326 + if (aseq == bseq)
8327 + return ablock - bblock;
8328 + else
8329 + return aseq - bseq;
8330 }
8331
8332
8333 +struct yaffs_ShadowFixerStruct {
8334 + int objectId;
8335 + int shadowedId;
8336 + struct yaffs_ShadowFixerStruct *next;
8337 +};
8338 +
8339
8340 +static void yaffs_StripDeletedObjects(yaffs_Device *dev)
8341 +{
8342 + /*
8343 + * Sort out state of unlinked and deleted objects after scanning.
8344 + */
8345 + struct ylist_head *i;
8346 + struct ylist_head *n;
8347 + yaffs_Object *l;
8348
8349 + /* Soft delete all the unlinked files */
8350 + ylist_for_each_safe(i, n,
8351 + &dev->unlinkedDir->variant.directoryVariant.children) {
8352 + if (i) {
8353 + l = ylist_entry(i, yaffs_Object, siblings);
8354 + yaffs_DeleteObject(l);
8355 + }
8356 + }
8357
8358 -static int ybicmp(const void *a, const void *b){
8359 - register int aseq = ((yaffs_BlockIndex *)a)->seq;
8360 - register int bseq = ((yaffs_BlockIndex *)b)->seq;
8361 - register int ablock = ((yaffs_BlockIndex *)a)->block;
8362 - register int bblock = ((yaffs_BlockIndex *)b)->block;
8363 - if( aseq == bseq )
8364 - return ablock - bblock;
8365 - else
8366 - return aseq - bseq;
8367 + ylist_for_each_safe(i, n,
8368 + &dev->deletedDir->variant.directoryVariant.children) {
8369 + if (i) {
8370 + l = ylist_entry(i, yaffs_Object, siblings);
8371 + yaffs_DeleteObject(l);
8372 + }
8373 + }
8374
8375 }
8376
8377 -static int yaffs_Scan(yaffs_Device * dev)
8378 +static int yaffs_Scan(yaffs_Device *dev)
8379 {
8380 yaffs_ExtendedTags tags;
8381 int blk;
8382 int blockIterator;
8383 int startIterator;
8384 int endIterator;
8385 - int nBlocksToScan = 0;
8386 int result;
8387
8388 int chunk;
8389 @@ -5371,26 +5442,19 @@ static int yaffs_Scan(yaffs_Device * dev
8390 yaffs_BlockState state;
8391 yaffs_Object *hardList = NULL;
8392 yaffs_BlockInfo *bi;
8393 - int sequenceNumber;
8394 + __u32 sequenceNumber;
8395 yaffs_ObjectHeader *oh;
8396 yaffs_Object *in;
8397 yaffs_Object *parent;
8398 - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
8399
8400 int alloc_failed = 0;
8401
8402 + struct yaffs_ShadowFixerStruct *shadowFixerList = NULL;
8403 +
8404
8405 __u8 *chunkData;
8406
8407 - yaffs_BlockIndex *blockIndex = NULL;
8408
8409 - if (dev->isYaffs2) {
8410 - T(YAFFS_TRACE_SCAN,
8411 - (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
8412 - return YAFFS_FAIL;
8413 - }
8414 -
8415 - //TODO Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
8416
8417 T(YAFFS_TRACE_SCAN,
8418 (TSTR("yaffs_Scan starts intstartblk %d intendblk %d..." TENDSTR),
8419 @@ -5400,12 +5464,6 @@ static int yaffs_Scan(yaffs_Device * dev
8420
8421 dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
8422
8423 - if (dev->isYaffs2) {
8424 - blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
8425 - if(!blockIndex)
8426 - return YAFFS_FAIL;
8427 - }
8428 -
8429 /* Scan all the blocks to determine their state */
8430 for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
8431 bi = yaffs_GetBlockInfo(dev, blk);
8432 @@ -5418,6 +5476,9 @@ static int yaffs_Scan(yaffs_Device * dev
8433 bi->blockState = state;
8434 bi->sequenceNumber = sequenceNumber;
8435
8436 + if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
8437 + bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
8438 +
8439 T(YAFFS_TRACE_SCAN_DEBUG,
8440 (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
8441 state, sequenceNumber));
8442 @@ -5430,70 +5491,21 @@ static int yaffs_Scan(yaffs_Device * dev
8443 (TSTR("Block empty " TENDSTR)));
8444 dev->nErasedBlocks++;
8445 dev->nFreeChunks += dev->nChunksPerBlock;
8446 - } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
8447 -
8448 - /* Determine the highest sequence number */
8449 - if (dev->isYaffs2 &&
8450 - sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
8451 - sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
8452 -
8453 - blockIndex[nBlocksToScan].seq = sequenceNumber;
8454 - blockIndex[nBlocksToScan].block = blk;
8455 -
8456 - nBlocksToScan++;
8457 -
8458 - if (sequenceNumber >= dev->sequenceNumber) {
8459 - dev->sequenceNumber = sequenceNumber;
8460 - }
8461 - } else if (dev->isYaffs2) {
8462 - /* TODO: Nasty sequence number! */
8463 - T(YAFFS_TRACE_SCAN,
8464 - (TSTR
8465 - ("Block scanning block %d has bad sequence number %d"
8466 - TENDSTR), blk, sequenceNumber));
8467 -
8468 - }
8469 }
8470 }
8471
8472 - /* Sort the blocks
8473 - * Dungy old bubble sort for now...
8474 - */
8475 - if (dev->isYaffs2) {
8476 - yaffs_BlockIndex temp;
8477 - int i;
8478 - int j;
8479 -
8480 - for (i = 0; i < nBlocksToScan; i++)
8481 - for (j = i + 1; j < nBlocksToScan; j++)
8482 - if (blockIndex[i].seq > blockIndex[j].seq) {
8483 - temp = blockIndex[j];
8484 - blockIndex[j] = blockIndex[i];
8485 - blockIndex[i] = temp;
8486 - }
8487 - }
8488 -
8489 - /* Now scan the blocks looking at the data. */
8490 - if (dev->isYaffs2) {
8491 - startIterator = 0;
8492 - endIterator = nBlocksToScan - 1;
8493 - T(YAFFS_TRACE_SCAN_DEBUG,
8494 - (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
8495 - } else {
8496 - startIterator = dev->internalStartBlock;
8497 - endIterator = dev->internalEndBlock;
8498 - }
8499 + startIterator = dev->internalStartBlock;
8500 + endIterator = dev->internalEndBlock;
8501
8502 /* For each block.... */
8503 for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
8504 blockIterator++) {
8505
8506 - if (dev->isYaffs2) {
8507 - /* get the block to scan in the correct order */
8508 - blk = blockIndex[blockIterator].block;
8509 - } else {
8510 - blk = blockIterator;
8511 - }
8512 + YYIELD();
8513 +
8514 + YYIELD();
8515 +
8516 + blk = blockIterator;
8517
8518 bi = yaffs_GetBlockInfo(dev, blk);
8519 state = bi->blockState;
8520 @@ -5511,7 +5523,7 @@ static int yaffs_Scan(yaffs_Device * dev
8521
8522 /* Let's have a good look at this chunk... */
8523
8524 - if (!dev->isYaffs2 && tags.chunkDeleted) {
8525 + if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) {
8526 /* YAFFS1 only...
8527 * A deleted chunk
8528 */
8529 @@ -5540,18 +5552,6 @@ static int yaffs_Scan(yaffs_Device * dev
8530 dev->allocationBlockFinder = blk;
8531 /* Set it to here to encourage the allocator to go forth from here. */
8532
8533 - /* Yaffs2 sanity check:
8534 - * This should be the one with the highest sequence number
8535 - */
8536 - if (dev->isYaffs2
8537 - && (dev->sequenceNumber !=
8538 - bi->sequenceNumber)) {
8539 - T(YAFFS_TRACE_ALWAYS,
8540 - (TSTR
8541 - ("yaffs: Allocation block %d was not highest sequence id:"
8542 - " block seq = %d, dev seq = %d"
8543 - TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
8544 - }
8545 }
8546
8547 dev->nFreeChunks += (dev->nChunksPerBlock - c);
8548 @@ -5570,11 +5570,11 @@ static int yaffs_Scan(yaffs_Device * dev
8549 * the same chunkId).
8550 */
8551
8552 - if(!in)
8553 + if (!in)
8554 alloc_failed = 1;
8555
8556 - if(in){
8557 - if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
8558 + if (in) {
8559 + if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, 1))
8560 alloc_failed = 1;
8561 }
8562
8563 @@ -5617,7 +5617,7 @@ static int yaffs_Scan(yaffs_Device * dev
8564 * deleted, and worse still it has changed type. Delete the old object.
8565 */
8566
8567 - yaffs_DestroyObject(in);
8568 + yaffs_DeleteObject(in);
8569
8570 in = 0;
8571 }
8572 @@ -5627,14 +5627,20 @@ static int yaffs_Scan(yaffs_Device * dev
8573 objectId,
8574 oh->type);
8575
8576 - if(!in)
8577 + if (!in)
8578 alloc_failed = 1;
8579
8580 if (in && oh->shadowsObject > 0) {
8581 - yaffs_HandleShadowedObject(dev,
8582 - oh->
8583 - shadowsObject,
8584 - 0);
8585 +
8586 + struct yaffs_ShadowFixerStruct *fixer;
8587 + fixer = YMALLOC(sizeof(struct yaffs_ShadowFixerStruct));
8588 + if (fixer) {
8589 + fixer->next = shadowFixerList;
8590 + shadowFixerList = fixer;
8591 + fixer->objectId = tags.objectId;
8592 + fixer->shadowedId = oh->shadowsObject;
8593 + }
8594 +
8595 }
8596
8597 if (in && in->valid) {
8598 @@ -5643,12 +5649,10 @@ static int yaffs_Scan(yaffs_Device * dev
8599 unsigned existingSerial = in->serial;
8600 unsigned newSerial = tags.serialNumber;
8601
8602 - if (dev->isYaffs2 ||
8603 - ((existingSerial + 1) & 3) ==
8604 - newSerial) {
8605 + if (((existingSerial + 1) & 3) == newSerial) {
8606 /* Use new one - destroy the exisiting one */
8607 yaffs_DeleteChunk(dev,
8608 - in->chunkId,
8609 + in->hdrChunk,
8610 1, __LINE__);
8611 in->valid = 0;
8612 } else {
8613 @@ -5681,7 +5685,8 @@ static int yaffs_Scan(yaffs_Device * dev
8614 in->yst_ctime = oh->yst_ctime;
8615 in->yst_rdev = oh->yst_rdev;
8616 #endif
8617 - in->chunkId = chunk;
8618 + in->hdrChunk = chunk;
8619 + in->serial = tags.serialNumber;
8620
8621 } else if (in && !in->valid) {
8622 /* we need to load this info */
8623 @@ -5705,7 +5710,8 @@ static int yaffs_Scan(yaffs_Device * dev
8624 in->yst_ctime = oh->yst_ctime;
8625 in->yst_rdev = oh->yst_rdev;
8626 #endif
8627 - in->chunkId = chunk;
8628 + in->hdrChunk = chunk;
8629 + in->serial = tags.serialNumber;
8630
8631 yaffs_SetObjectName(in, oh->name);
8632 in->dirty = 0;
8633 @@ -5718,25 +5724,25 @@ static int yaffs_Scan(yaffs_Device * dev
8634 yaffs_FindOrCreateObjectByNumber
8635 (dev, oh->parentObjectId,
8636 YAFFS_OBJECT_TYPE_DIRECTORY);
8637 - if (parent->variantType ==
8638 + if (!parent)
8639 + alloc_failed = 1;
8640 + if (parent && parent->variantType ==
8641 YAFFS_OBJECT_TYPE_UNKNOWN) {
8642 /* Set up as a directory */
8643 parent->variantType =
8644 - YAFFS_OBJECT_TYPE_DIRECTORY;
8645 - INIT_LIST_HEAD(&parent->variant.
8646 - directoryVariant.
8647 - children);
8648 - } else if (parent->variantType !=
8649 - YAFFS_OBJECT_TYPE_DIRECTORY)
8650 - {
8651 + YAFFS_OBJECT_TYPE_DIRECTORY;
8652 + YINIT_LIST_HEAD(&parent->variant.
8653 + directoryVariant.
8654 + children);
8655 + } else if (!parent || parent->variantType !=
8656 + YAFFS_OBJECT_TYPE_DIRECTORY) {
8657 /* Hoosterman, another problem....
8658 * We're trying to use a non-directory as a directory
8659 */
8660
8661 T(YAFFS_TRACE_ERROR,
8662 (TSTR
8663 - ("yaffs tragedy: attempting to use non-directory as"
8664 - " a directory in scan. Put in lost+found."
8665 + ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
8666 TENDSTR)));
8667 parent = dev->lostNFoundDir;
8668 }
8669 @@ -5760,15 +5766,6 @@ static int yaffs_Scan(yaffs_Device * dev
8670 /* Todo got a problem */
8671 break;
8672 case YAFFS_OBJECT_TYPE_FILE:
8673 - if (dev->isYaffs2
8674 - && oh->isShrink) {
8675 - /* Prune back the shrunken chunks */
8676 - yaffs_PruneResizedChunks
8677 - (in, oh->fileSize);
8678 - /* Mark the block as having a shrinkHeader */
8679 - bi->hasShrinkHeader = 1;
8680 - }
8681 -
8682 if (dev->useHeaderFileSize)
8683
8684 in->variant.fileVariant.
8685 @@ -5778,11 +5775,11 @@ static int yaffs_Scan(yaffs_Device * dev
8686 break;
8687 case YAFFS_OBJECT_TYPE_HARDLINK:
8688 in->variant.hardLinkVariant.
8689 - equivalentObjectId =
8690 - oh->equivalentObjectId;
8691 + equivalentObjectId =
8692 + oh->equivalentObjectId;
8693 in->hardLinks.next =
8694 - (struct list_head *)
8695 - hardList;
8696 + (struct ylist_head *)
8697 + hardList;
8698 hardList = in;
8699 break;
8700 case YAFFS_OBJECT_TYPE_DIRECTORY:
8701 @@ -5794,15 +5791,17 @@ static int yaffs_Scan(yaffs_Device * dev
8702 case YAFFS_OBJECT_TYPE_SYMLINK:
8703 in->variant.symLinkVariant.alias =
8704 yaffs_CloneString(oh->alias);
8705 - if(!in->variant.symLinkVariant.alias)
8706 + if (!in->variant.symLinkVariant.alias)
8707 alloc_failed = 1;
8708 break;
8709 }
8710
8711 +/*
8712 if (parent == dev->deletedDir) {
8713 yaffs_DestroyObject(in);
8714 bi->hasShrinkHeader = 1;
8715 }
8716 +*/
8717 }
8718 }
8719 }
8720 @@ -5823,10 +5822,6 @@ static int yaffs_Scan(yaffs_Device * dev
8721
8722 }
8723
8724 - if (blockIndex) {
8725 - YFREE(blockIndex);
8726 - }
8727 -
8728
8729 /* Ok, we've done all the scanning.
8730 * Fix up the hard link chains.
8731 @@ -5834,32 +5829,36 @@ static int yaffs_Scan(yaffs_Device * dev
8732 * hardlinks.
8733 */
8734
8735 - yaffs_HardlinkFixup(dev,hardList);
8736 + yaffs_HardlinkFixup(dev, hardList);
8737
8738 - /* Handle the unlinked files. Since they were left in an unlinked state we should
8739 - * just delete them.
8740 - */
8741 + /* Fix up any shadowed objects */
8742 {
8743 - struct list_head *i;
8744 - struct list_head *n;
8745 + struct yaffs_ShadowFixerStruct *fixer;
8746 + yaffs_Object *obj;
8747
8748 - yaffs_Object *l;
8749 - /* Soft delete all the unlinked files */
8750 - list_for_each_safe(i, n,
8751 - &dev->unlinkedDir->variant.directoryVariant.
8752 - children) {
8753 - if (i) {
8754 - l = list_entry(i, yaffs_Object, siblings);
8755 - yaffs_DestroyObject(l);
8756 - }
8757 + while (shadowFixerList) {
8758 + fixer = shadowFixerList;
8759 + shadowFixerList = fixer->next;
8760 + /* Complete the rename transaction by deleting the shadowed object
8761 + * then setting the object header to unshadowed.
8762 + */
8763 + obj = yaffs_FindObjectByNumber(dev, fixer->shadowedId);
8764 + if (obj)
8765 + yaffs_DeleteObject(obj);
8766 +
8767 + obj = yaffs_FindObjectByNumber(dev, fixer->objectId);
8768 +
8769 + if (obj)
8770 + yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0);
8771 +
8772 + YFREE(fixer);
8773 }
8774 }
8775
8776 yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
8777
8778 - if(alloc_failed){
8779 + if (alloc_failed)
8780 return YAFFS_FAIL;
8781 - }
8782
8783 T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
8784
8785 @@ -5871,25 +5870,27 @@ static void yaffs_CheckObjectDetailsLoad
8786 {
8787 __u8 *chunkData;
8788 yaffs_ObjectHeader *oh;
8789 - yaffs_Device *dev = in->myDev;
8790 + yaffs_Device *dev;
8791 yaffs_ExtendedTags tags;
8792 int result;
8793 int alloc_failed = 0;
8794
8795 - if(!in)
8796 + if (!in)
8797 return;
8798
8799 + dev = in->myDev;
8800 +
8801 #if 0
8802 - T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
8803 + T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR),
8804 in->objectId,
8805 in->lazyLoaded ? "not yet" : "already"));
8806 #endif
8807
8808 - if(in->lazyLoaded){
8809 + if (in->lazyLoaded && in->hdrChunk > 0) {
8810 in->lazyLoaded = 0;
8811 chunkData = yaffs_GetTempBuffer(dev, __LINE__);
8812
8813 - result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
8814 + result = yaffs_ReadChunkWithTagsFromNAND(dev, in->hdrChunk, chunkData, &tags);
8815 oh = (yaffs_ObjectHeader *) chunkData;
8816
8817 in->yst_mode = oh->yst_mode;
8818 @@ -5911,18 +5912,18 @@ static void yaffs_CheckObjectDetailsLoad
8819 #endif
8820 yaffs_SetObjectName(in, oh->name);
8821
8822 - if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
8823 - in->variant.symLinkVariant.alias =
8824 + if (in->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
8825 + in->variant.symLinkVariant.alias =
8826 yaffs_CloneString(oh->alias);
8827 - if(!in->variant.symLinkVariant.alias)
8828 + if (!in->variant.symLinkVariant.alias)
8829 alloc_failed = 1; /* Not returned to caller */
8830 }
8831
8832 - yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
8833 + yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
8834 }
8835 }
8836
8837 -static int yaffs_ScanBackwards(yaffs_Device * dev)
8838 +static int yaffs_ScanBackwards(yaffs_Device *dev)
8839 {
8840 yaffs_ExtendedTags tags;
8841 int blk;
8842 @@ -5938,7 +5939,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8843 yaffs_BlockState state;
8844 yaffs_Object *hardList = NULL;
8845 yaffs_BlockInfo *bi;
8846 - int sequenceNumber;
8847 + __u32 sequenceNumber;
8848 yaffs_ObjectHeader *oh;
8849 yaffs_Object *in;
8850 yaffs_Object *parent;
8851 @@ -5972,12 +5973,12 @@ static int yaffs_ScanBackwards(yaffs_Dev
8852
8853 blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
8854
8855 - if(!blockIndex) {
8856 + if (!blockIndex) {
8857 blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
8858 altBlockIndex = 1;
8859 }
8860
8861 - if(!blockIndex) {
8862 + if (!blockIndex) {
8863 T(YAFFS_TRACE_SCAN,
8864 (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
8865 return YAFFS_FAIL;
8866 @@ -5999,15 +6000,17 @@ static int yaffs_ScanBackwards(yaffs_Dev
8867 bi->blockState = state;
8868 bi->sequenceNumber = sequenceNumber;
8869
8870 - if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
8871 + if (bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
8872 bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
8873 + if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
8874 + bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
8875
8876 T(YAFFS_TRACE_SCAN_DEBUG,
8877 (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
8878 state, sequenceNumber));
8879
8880
8881 - if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
8882 + if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
8883 dev->blocksInCheckpoint++;
8884
8885 } else if (state == YAFFS_BLOCK_STATE_DEAD) {
8886 @@ -6021,8 +6024,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8887 } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
8888
8889 /* Determine the highest sequence number */
8890 - if (dev->isYaffs2 &&
8891 - sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
8892 + if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
8893 sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
8894
8895 blockIndex[nBlocksToScan].seq = sequenceNumber;
8896 @@ -6030,10 +6032,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
8897
8898 nBlocksToScan++;
8899
8900 - if (sequenceNumber >= dev->sequenceNumber) {
8901 + if (sequenceNumber >= dev->sequenceNumber)
8902 dev->sequenceNumber = sequenceNumber;
8903 - }
8904 - } else if (dev->isYaffs2) {
8905 + } else {
8906 /* TODO: Nasty sequence number! */
8907 T(YAFFS_TRACE_SCAN,
8908 (TSTR
8909 @@ -6053,11 +6054,13 @@ static int yaffs_ScanBackwards(yaffs_Dev
8910
8911 /* Sort the blocks */
8912 #ifndef CONFIG_YAFFS_USE_OWN_SORT
8913 - yaffs_qsort(blockIndex, nBlocksToScan,
8914 - sizeof(yaffs_BlockIndex), ybicmp);
8915 + {
8916 + /* Use qsort now. */
8917 + yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp);
8918 + }
8919 #else
8920 {
8921 - /* Dungy old bubble sort... */
8922 + /* Dungy old bubble sort... */
8923
8924 yaffs_BlockIndex temp;
8925 int i;
8926 @@ -6075,7 +6078,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8927
8928 YYIELD();
8929
8930 - T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
8931 + T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
8932
8933 /* Now scan the blocks looking at the data. */
8934 startIterator = 0;
8935 @@ -6085,10 +6088,10 @@ static int yaffs_ScanBackwards(yaffs_Dev
8936
8937 /* For each block.... backwards */
8938 for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator;
8939 - blockIterator--) {
8940 - /* Cooperative multitasking! This loop can run for so
8941 + blockIterator--) {
8942 + /* Cooperative multitasking! This loop can run for so
8943 long that watchdog timers expire. */
8944 - YYIELD();
8945 + YYIELD();
8946
8947 /* get the block to scan in the correct order */
8948 blk = blockIndex[blockIterator].block;
8949 @@ -6127,10 +6130,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
8950 * this is the one being allocated from
8951 */
8952
8953 - if(foundChunksInBlock)
8954 - {
8955 + if (foundChunksInBlock) {
8956 /* This is a chunk that was skipped due to failing the erased check */
8957 -
8958 } else if (c == 0) {
8959 /* We're looking at the first chunk in the block so the block is unused */
8960 state = YAFFS_BLOCK_STATE_EMPTY;
8961 @@ -6138,7 +6139,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8962 } else {
8963 if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
8964 state == YAFFS_BLOCK_STATE_ALLOCATING) {
8965 - if(dev->sequenceNumber == bi->sequenceNumber) {
8966 + if (dev->sequenceNumber == bi->sequenceNumber) {
8967 /* this is the block being allocated from */
8968
8969 T(YAFFS_TRACE_SCAN,
8970 @@ -6150,27 +6151,31 @@ static int yaffs_ScanBackwards(yaffs_Dev
8971 dev->allocationBlock = blk;
8972 dev->allocationPage = c;
8973 dev->allocationBlockFinder = blk;
8974 - }
8975 - else {
8976 + } else {
8977 /* This is a partially written block that is not
8978 * the current allocation block. This block must have
8979 * had a write failure, so set up for retirement.
8980 */
8981
8982 - bi->needsRetiring = 1;
8983 + /* bi->needsRetiring = 1; ??? TODO */
8984 bi->gcPrioritise = 1;
8985
8986 T(YAFFS_TRACE_ALWAYS,
8987 - (TSTR("Partially written block %d being set for retirement" TENDSTR),
8988 + (TSTR("Partially written block %d detected" TENDSTR),
8989 blk));
8990 }
8991 -
8992 }
8993 -
8994 }
8995
8996 dev->nFreeChunks++;
8997
8998 + } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) {
8999 + T(YAFFS_TRACE_SCAN,
9000 + (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR),
9001 + blk, c));
9002 +
9003 + dev->nFreeChunks++;
9004 +
9005 } else if (tags.chunkId > 0) {
9006 /* chunkId > 0 so it is a data chunk... */
9007 unsigned int endpos;
9008 @@ -6187,7 +6192,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9009 tags.
9010 objectId,
9011 YAFFS_OBJECT_TYPE_FILE);
9012 - if(!in){
9013 + if (!in) {
9014 /* Out of memory */
9015 alloc_failed = 1;
9016 }
9017 @@ -6197,8 +6202,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
9018 && chunkBase <
9019 in->variant.fileVariant.shrinkSize) {
9020 /* This has not been invalidated by a resize */
9021 - if(!yaffs_PutChunkIntoFile(in, tags.chunkId,
9022 - chunk, -1)){
9023 + if (!yaffs_PutChunkIntoFile(in, tags.chunkId,
9024 + chunk, -1)) {
9025 alloc_failed = 1;
9026 }
9027
9028 @@ -6221,7 +6226,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9029 scannedFileSize;
9030 }
9031
9032 - } else if(in) {
9033 + } else if (in) {
9034 /* This chunk has been invalidated by a resize, so delete */
9035 yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
9036
9037 @@ -6242,6 +6247,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
9038 in = yaffs_FindOrCreateObjectByNumber
9039 (dev, tags.objectId,
9040 tags.extraObjectType);
9041 + if (!in)
9042 + alloc_failed = 1;
9043 }
9044
9045 if (!in ||
9046 @@ -6251,8 +6258,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9047 tags.extraShadows ||
9048 (!in->valid &&
9049 (tags.objectId == YAFFS_OBJECTID_ROOT ||
9050 - tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))
9051 - ) {
9052 + tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))) {
9053
9054 /* If we don't have valid info then we need to read the chunk
9055 * TODO In future we can probably defer reading the chunk and
9056 @@ -6266,8 +6272,17 @@ static int yaffs_ScanBackwards(yaffs_Dev
9057
9058 oh = (yaffs_ObjectHeader *) chunkData;
9059
9060 - if (!in)
9061 + if (dev->inbandTags) {
9062 + /* Fix up the header if they got corrupted by inband tags */
9063 + oh->shadowsObject = oh->inbandShadowsObject;
9064 + oh->isShrink = oh->inbandIsShrink;
9065 + }
9066 +
9067 + if (!in) {
9068 in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
9069 + if (!in)
9070 + alloc_failed = 1;
9071 + }
9072
9073 }
9074
9075 @@ -6275,10 +6290,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
9076 /* TODO Hoosterman we have a problem! */
9077 T(YAFFS_TRACE_ERROR,
9078 (TSTR
9079 - ("yaffs tragedy: Could not make object for object %d "
9080 - "at chunk %d during scan"
9081 + ("yaffs tragedy: Could not make object for object %d at chunk %d during scan"
9082 TENDSTR), tags.objectId, chunk));
9083 -
9084 + continue;
9085 }
9086
9087 if (in->valid) {
9088 @@ -6289,10 +6303,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
9089
9090 if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
9091 ((oh &&
9092 - oh-> type == YAFFS_OBJECT_TYPE_FILE)||
9093 + oh->type == YAFFS_OBJECT_TYPE_FILE) ||
9094 (tags.extraHeaderInfoAvailable &&
9095 - tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
9096 - ) {
9097 + tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))) {
9098 __u32 thisSize =
9099 (oh) ? oh->fileSize : tags.
9100 extraFileLength;
9101 @@ -6300,7 +6313,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
9102 (oh) ? oh->
9103 parentObjectId : tags.
9104 extraParentObjectId;
9105 - unsigned isShrink =
9106 +
9107 +
9108 + isShrink =
9109 (oh) ? oh->isShrink : tags.
9110 extraIsShrinkHeader;
9111
9112 @@ -6323,9 +6338,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
9113 thisSize;
9114 }
9115
9116 - if (isShrink) {
9117 + if (isShrink)
9118 bi->hasShrinkHeader = 1;
9119 - }
9120
9121 }
9122 /* Use existing - destroy this one. */
9123 @@ -6333,6 +6347,17 @@ static int yaffs_ScanBackwards(yaffs_Dev
9124
9125 }
9126
9127 + if (!in->valid && in->variantType !=
9128 + (oh ? oh->type : tags.extraObjectType))
9129 + T(YAFFS_TRACE_ERROR, (
9130 + TSTR("yaffs tragedy: Bad object type, "
9131 + TCONT("%d != %d, for object %d at chunk ")
9132 + TCONT("%d during scan")
9133 + TENDSTR), oh ?
9134 + oh->type : tags.extraObjectType,
9135 + in->variantType, tags.objectId,
9136 + chunk));
9137 +
9138 if (!in->valid &&
9139 (tags.objectId == YAFFS_OBJECTID_ROOT ||
9140 tags.objectId ==
9141 @@ -6340,7 +6365,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9142 /* We only load some info, don't fiddle with directory structure */
9143 in->valid = 1;
9144
9145 - if(oh) {
9146 + if (oh) {
9147 in->variantType = oh->type;
9148
9149 in->yst_mode = oh->yst_mode;
9150 @@ -6365,15 +6390,15 @@ static int yaffs_ScanBackwards(yaffs_Dev
9151 in->lazyLoaded = 1;
9152 }
9153
9154 - in->chunkId = chunk;
9155 + in->hdrChunk = chunk;
9156
9157 } else if (!in->valid) {
9158 /* we need to load this info */
9159
9160 in->valid = 1;
9161 - in->chunkId = chunk;
9162 + in->hdrChunk = chunk;
9163
9164 - if(oh) {
9165 + if (oh) {
9166 in->variantType = oh->type;
9167
9168 in->yst_mode = oh->yst_mode;
9169 @@ -6403,20 +6428,19 @@ static int yaffs_ScanBackwards(yaffs_Dev
9170 yaffs_SetObjectName(in, oh->name);
9171 parent =
9172 yaffs_FindOrCreateObjectByNumber
9173 - (dev, oh->parentObjectId,
9174 - YAFFS_OBJECT_TYPE_DIRECTORY);
9175 + (dev, oh->parentObjectId,
9176 + YAFFS_OBJECT_TYPE_DIRECTORY);
9177
9178 fileSize = oh->fileSize;
9179 - isShrink = oh->isShrink;
9180 + isShrink = oh->isShrink;
9181 equivalentObjectId = oh->equivalentObjectId;
9182
9183 - }
9184 - else {
9185 + } else {
9186 in->variantType = tags.extraObjectType;
9187 parent =
9188 yaffs_FindOrCreateObjectByNumber
9189 - (dev, tags.extraParentObjectId,
9190 - YAFFS_OBJECT_TYPE_DIRECTORY);
9191 + (dev, tags.extraParentObjectId,
9192 + YAFFS_OBJECT_TYPE_DIRECTORY);
9193 fileSize = tags.extraFileLength;
9194 isShrink = tags.extraIsShrinkHeader;
9195 equivalentObjectId = tags.extraEquivalentObjectId;
9196 @@ -6425,29 +6449,30 @@ static int yaffs_ScanBackwards(yaffs_Dev
9197 }
9198 in->dirty = 0;
9199
9200 + if (!parent)
9201 + alloc_failed = 1;
9202 +
9203 /* directory stuff...
9204 * hook up to parent
9205 */
9206
9207 - if (parent->variantType ==
9208 + if (parent && parent->variantType ==
9209 YAFFS_OBJECT_TYPE_UNKNOWN) {
9210 /* Set up as a directory */
9211 parent->variantType =
9212 - YAFFS_OBJECT_TYPE_DIRECTORY;
9213 - INIT_LIST_HEAD(&parent->variant.
9214 - directoryVariant.
9215 - children);
9216 - } else if (parent->variantType !=
9217 - YAFFS_OBJECT_TYPE_DIRECTORY)
9218 - {
9219 + YAFFS_OBJECT_TYPE_DIRECTORY;
9220 + YINIT_LIST_HEAD(&parent->variant.
9221 + directoryVariant.
9222 + children);
9223 + } else if (!parent || parent->variantType !=
9224 + YAFFS_OBJECT_TYPE_DIRECTORY) {
9225 /* Hoosterman, another problem....
9226 * We're trying to use a non-directory as a directory
9227 */
9228
9229 T(YAFFS_TRACE_ERROR,
9230 (TSTR
9231 - ("yaffs tragedy: attempting to use non-directory as"
9232 - " a directory in scan. Put in lost+found."
9233 + ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
9234 TENDSTR)));
9235 parent = dev->lostNFoundDir;
9236 }
9237 @@ -6494,12 +6519,12 @@ static int yaffs_ScanBackwards(yaffs_Dev
9238
9239 break;
9240 case YAFFS_OBJECT_TYPE_HARDLINK:
9241 - if(!itsUnlinked) {
9242 - in->variant.hardLinkVariant.equivalentObjectId =
9243 - equivalentObjectId;
9244 - in->hardLinks.next =
9245 - (struct list_head *) hardList;
9246 - hardList = in;
9247 + if (!itsUnlinked) {
9248 + in->variant.hardLinkVariant.equivalentObjectId =
9249 + equivalentObjectId;
9250 + in->hardLinks.next =
9251 + (struct ylist_head *) hardList;
9252 + hardList = in;
9253 }
9254 break;
9255 case YAFFS_OBJECT_TYPE_DIRECTORY:
9256 @@ -6509,12 +6534,11 @@ static int yaffs_ScanBackwards(yaffs_Dev
9257 /* Do nothing */
9258 break;
9259 case YAFFS_OBJECT_TYPE_SYMLINK:
9260 - if(oh){
9261 - in->variant.symLinkVariant.alias =
9262 - yaffs_CloneString(oh->
9263 - alias);
9264 - if(!in->variant.symLinkVariant.alias)
9265 - alloc_failed = 1;
9266 + if (oh) {
9267 + in->variant.symLinkVariant.alias =
9268 + yaffs_CloneString(oh->alias);
9269 + if (!in->variant.symLinkVariant.alias)
9270 + alloc_failed = 1;
9271 }
9272 break;
9273 }
9274 @@ -6551,75 +6575,129 @@ static int yaffs_ScanBackwards(yaffs_Dev
9275 * We should now have scanned all the objects, now it's time to add these
9276 * hardlinks.
9277 */
9278 - yaffs_HardlinkFixup(dev,hardList);
9279 + yaffs_HardlinkFixup(dev, hardList);
9280
9281
9282 - /*
9283 - * Sort out state of unlinked and deleted objects.
9284 - */
9285 - {
9286 - struct list_head *i;
9287 - struct list_head *n;
9288 + yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
9289
9290 - yaffs_Object *l;
9291 + if (alloc_failed)
9292 + return YAFFS_FAIL;
9293
9294 - /* Soft delete all the unlinked files */
9295 - list_for_each_safe(i, n,
9296 - &dev->unlinkedDir->variant.directoryVariant.
9297 - children) {
9298 - if (i) {
9299 - l = list_entry(i, yaffs_Object, siblings);
9300 - yaffs_DestroyObject(l);
9301 - }
9302 - }
9303 + T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
9304
9305 - /* Soft delete all the deletedDir files */
9306 - list_for_each_safe(i, n,
9307 - &dev->deletedDir->variant.directoryVariant.
9308 - children) {
9309 - if (i) {
9310 - l = list_entry(i, yaffs_Object, siblings);
9311 - yaffs_DestroyObject(l);
9312 + return YAFFS_OK;
9313 +}
9314
9315 - }
9316 +/*------------------------------ Directory Functions ----------------------------- */
9317 +
9318 +static void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
9319 +{
9320 + struct ylist_head *lh;
9321 + yaffs_Object *listObj;
9322 +
9323 + int count = 0;
9324 +
9325 + if (!obj) {
9326 + T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
9327 + YBUG();
9328 + return;
9329 + }
9330 +
9331 + if (yaffs_SkipVerification(obj->myDev))
9332 + return;
9333 +
9334 + if (!obj->parent) {
9335 + T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR)));
9336 + YBUG();
9337 + return;
9338 + }
9339 +
9340 + if (obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9341 + T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR)));
9342 + YBUG();
9343 + }
9344 +
9345 + /* Iterate through the objects in each hash entry */
9346 +
9347 + ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) {
9348 + if (lh) {
9349 + listObj = ylist_entry(lh, yaffs_Object, siblings);
9350 + yaffs_VerifyObject(listObj);
9351 + if (obj == listObj)
9352 + count++;
9353 }
9354 + }
9355 +
9356 + if (count != 1) {
9357 + T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count));
9358 + YBUG();
9359 }
9360 +}
9361
9362 - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
9363 +static void yaffs_VerifyDirectory(yaffs_Object *directory)
9364 +{
9365 + struct ylist_head *lh;
9366 + yaffs_Object *listObj;
9367
9368 - if(alloc_failed){
9369 - return YAFFS_FAIL;
9370 + if (!directory) {
9371 + YBUG();
9372 + return;
9373 }
9374
9375 - T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
9376 + if (yaffs_SkipFullVerification(directory->myDev))
9377 + return;
9378
9379 - return YAFFS_OK;
9380 + if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9381 + T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variantType));
9382 + YBUG();
9383 + }
9384 +
9385 + /* Iterate through the objects in each hash entry */
9386 +
9387 + ylist_for_each(lh, &directory->variant.directoryVariant.children) {
9388 + if (lh) {
9389 + listObj = ylist_entry(lh, yaffs_Object, siblings);
9390 + if (listObj->parent != directory) {
9391 + T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent));
9392 + YBUG();
9393 + }
9394 + yaffs_VerifyObjectInDirectory(listObj);
9395 + }
9396 + }
9397 }
9398
9399 -/*------------------------------ Directory Functions ----------------------------- */
9400
9401 -static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
9402 +static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj)
9403 {
9404 yaffs_Device *dev = obj->myDev;
9405 + yaffs_Object *parent;
9406 +
9407 + yaffs_VerifyObjectInDirectory(obj);
9408 + parent = obj->parent;
9409 +
9410 + yaffs_VerifyDirectory(parent);
9411
9412 - if(dev && dev->removeObjectCallback)
9413 + if (dev && dev->removeObjectCallback)
9414 dev->removeObjectCallback(obj);
9415
9416 - list_del_init(&obj->siblings);
9417 +
9418 + ylist_del_init(&obj->siblings);
9419 obj->parent = NULL;
9420 +
9421 + yaffs_VerifyDirectory(parent);
9422 }
9423
9424
9425 -static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
9426 - yaffs_Object * obj)
9427 +static void yaffs_AddObjectToDirectory(yaffs_Object *directory,
9428 + yaffs_Object *obj)
9429 {
9430 -
9431 if (!directory) {
9432 T(YAFFS_TRACE_ALWAYS,
9433 (TSTR
9434 ("tragedy: Trying to add an object to a null pointer directory"
9435 TENDSTR)));
9436 YBUG();
9437 + return;
9438 }
9439 if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9440 T(YAFFS_TRACE_ALWAYS,
9441 @@ -6631,37 +6709,42 @@ static void yaffs_AddObjectToDirectory(y
9442
9443 if (obj->siblings.prev == NULL) {
9444 /* Not initialised */
9445 - INIT_LIST_HEAD(&obj->siblings);
9446 -
9447 - } else if (!list_empty(&obj->siblings)) {
9448 - /* If it is holed up somewhere else, un hook it */
9449 - yaffs_RemoveObjectFromDirectory(obj);
9450 + YBUG();
9451 }
9452 +
9453 +
9454 + yaffs_VerifyDirectory(directory);
9455 +
9456 + yaffs_RemoveObjectFromDirectory(obj);
9457 +
9458 +
9459 /* Now add it */
9460 - list_add(&obj->siblings, &directory->variant.directoryVariant.children);
9461 + ylist_add(&obj->siblings, &directory->variant.directoryVariant.children);
9462 obj->parent = directory;
9463
9464 if (directory == obj->myDev->unlinkedDir
9465 - || directory == obj->myDev->deletedDir) {
9466 + || directory == obj->myDev->deletedDir) {
9467 obj->unlinked = 1;
9468 obj->myDev->nUnlinkedFiles++;
9469 obj->renameAllowed = 0;
9470 }
9471 +
9472 + yaffs_VerifyDirectory(directory);
9473 + yaffs_VerifyObjectInDirectory(obj);
9474 }
9475
9476 -yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
9477 - const YCHAR * name)
9478 +yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory,
9479 + const YCHAR *name)
9480 {
9481 int sum;
9482
9483 - struct list_head *i;
9484 + struct ylist_head *i;
9485 YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
9486
9487 yaffs_Object *l;
9488
9489 - if (!name) {
9490 + if (!name)
9491 return NULL;
9492 - }
9493
9494 if (!directory) {
9495 T(YAFFS_TRACE_ALWAYS,
9496 @@ -6669,6 +6752,7 @@ yaffs_Object *yaffs_FindObjectByName(yaf
9497 ("tragedy: yaffs_FindObjectByName: null pointer directory"
9498 TENDSTR)));
9499 YBUG();
9500 + return NULL;
9501 }
9502 if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9503 T(YAFFS_TRACE_ALWAYS,
9504 @@ -6679,28 +6763,27 @@ yaffs_Object *yaffs_FindObjectByName(yaf
9505
9506 sum = yaffs_CalcNameSum(name);
9507
9508 - list_for_each(i, &directory->variant.directoryVariant.children) {
9509 + ylist_for_each(i, &directory->variant.directoryVariant.children) {
9510 if (i) {
9511 - l = list_entry(i, yaffs_Object, siblings);
9512 + l = ylist_entry(i, yaffs_Object, siblings);
9513 +
9514 + if (l->parent != directory)
9515 + YBUG();
9516
9517 yaffs_CheckObjectDetailsLoaded(l);
9518
9519 /* Special case for lost-n-found */
9520 if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
9521 - if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
9522 + if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0)
9523 return l;
9524 - }
9525 - } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
9526 - {
9527 - /* LostnFound cunk called Objxxx
9528 + } else if (yaffs_SumCompare(l->sum, sum) || l->hdrChunk <= 0) {
9529 + /* LostnFound chunk called Objxxx
9530 * Do a real check
9531 */
9532 yaffs_GetObjectName(l, buffer,
9533 YAFFS_MAX_NAME_LENGTH);
9534 - if (yaffs_strncmp(name, buffer,YAFFS_MAX_NAME_LENGTH) == 0) {
9535 + if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
9536 return l;
9537 - }
9538 -
9539 }
9540 }
9541 }
9542 @@ -6710,10 +6793,10 @@ yaffs_Object *yaffs_FindObjectByName(yaf
9543
9544
9545 #if 0
9546 -int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
9547 - int (*fn) (yaffs_Object *))
9548 +int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,
9549 + int (*fn) (yaffs_Object *))
9550 {
9551 - struct list_head *i;
9552 + struct ylist_head *i;
9553 yaffs_Object *l;
9554
9555 if (!theDir) {
9556 @@ -6722,20 +6805,21 @@ int yaffs_ApplyToDirectoryChildren(yaffs
9557 ("tragedy: yaffs_FindObjectByName: null pointer directory"
9558 TENDSTR)));
9559 YBUG();
9560 + return YAFFS_FAIL;
9561 }
9562 if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9563 T(YAFFS_TRACE_ALWAYS,
9564 (TSTR
9565 ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
9566 YBUG();
9567 + return YAFFS_FAIL;
9568 }
9569
9570 - list_for_each(i, &theDir->variant.directoryVariant.children) {
9571 + ylist_for_each(i, &theDir->variant.directoryVariant.children) {
9572 if (i) {
9573 - l = list_entry(i, yaffs_Object, siblings);
9574 - if (l && !fn(l)) {
9575 + l = ylist_entry(i, yaffs_Object, siblings);
9576 + if (l && !fn(l))
9577 return YAFFS_FAIL;
9578 - }
9579 }
9580 }
9581
9582 @@ -6748,7 +6832,7 @@ int yaffs_ApplyToDirectoryChildren(yaffs
9583 * actual object.
9584 */
9585
9586 -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
9587 +yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj)
9588 {
9589 if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
9590 /* We want the object id of the equivalent object, not this one */
9591 @@ -6756,10 +6840,9 @@ yaffs_Object *yaffs_GetEquivalentObject(
9592 yaffs_CheckObjectDetailsLoaded(obj);
9593 }
9594 return obj;
9595 -
9596 }
9597
9598 -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
9599 +int yaffs_GetObjectName(yaffs_Object *obj, YCHAR *name, int buffSize)
9600 {
9601 memset(name, 0, buffSize * sizeof(YCHAR));
9602
9603 @@ -6767,18 +6850,26 @@ int yaffs_GetObjectName(yaffs_Object * o
9604
9605 if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
9606 yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1);
9607 - } else if (obj->chunkId <= 0) {
9608 + } else if (obj->hdrChunk <= 0) {
9609 YCHAR locName[20];
9610 + YCHAR numString[20];
9611 + YCHAR *x = &numString[19];
9612 + unsigned v = obj->objectId;
9613 + numString[19] = 0;
9614 + while (v > 0) {
9615 + x--;
9616 + *x = '0' + (v % 10);
9617 + v /= 10;
9618 + }
9619 /* make up a name */
9620 - yaffs_sprintf(locName, _Y("%s%d"), YAFFS_LOSTNFOUND_PREFIX,
9621 - obj->objectId);
9622 + yaffs_strcpy(locName, YAFFS_LOSTNFOUND_PREFIX);
9623 + yaffs_strcat(locName, x);
9624 yaffs_strncpy(name, locName, buffSize - 1);
9625
9626 }
9627 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
9628 - else if (obj->shortName[0]) {
9629 + else if (obj->shortName[0])
9630 yaffs_strcpy(name, obj->shortName);
9631 - }
9632 #endif
9633 else {
9634 int result;
9635 @@ -6788,9 +6879,9 @@ int yaffs_GetObjectName(yaffs_Object * o
9636
9637 memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
9638
9639 - if (obj->chunkId >= 0) {
9640 + if (obj->hdrChunk > 0) {
9641 result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
9642 - obj->chunkId, buffer,
9643 + obj->hdrChunk, buffer,
9644 NULL);
9645 }
9646 yaffs_strncpy(name, oh->name, buffSize - 1);
9647 @@ -6801,46 +6892,43 @@ int yaffs_GetObjectName(yaffs_Object * o
9648 return yaffs_strlen(name);
9649 }
9650
9651 -int yaffs_GetObjectFileLength(yaffs_Object * obj)
9652 +int yaffs_GetObjectFileLength(yaffs_Object *obj)
9653 {
9654 -
9655 /* Dereference any hard linking */
9656 obj = yaffs_GetEquivalentObject(obj);
9657
9658 - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
9659 + if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
9660 return obj->variant.fileVariant.fileSize;
9661 - }
9662 - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
9663 + if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
9664 return yaffs_strlen(obj->variant.symLinkVariant.alias);
9665 - } else {
9666 + else {
9667 /* Only a directory should drop through to here */
9668 return obj->myDev->nDataBytesPerChunk;
9669 }
9670 }
9671
9672 -int yaffs_GetObjectLinkCount(yaffs_Object * obj)
9673 +int yaffs_GetObjectLinkCount(yaffs_Object *obj)
9674 {
9675 int count = 0;
9676 - struct list_head *i;
9677 + struct ylist_head *i;
9678
9679 - if (!obj->unlinked) {
9680 - count++; /* the object itself */
9681 - }
9682 - list_for_each(i, &obj->hardLinks) {
9683 - count++; /* add the hard links; */
9684 - }
9685 - return count;
9686 + if (!obj->unlinked)
9687 + count++; /* the object itself */
9688 +
9689 + ylist_for_each(i, &obj->hardLinks)
9690 + count++; /* add the hard links; */
9691
9692 + return count;
9693 }
9694
9695 -int yaffs_GetObjectInode(yaffs_Object * obj)
9696 +int yaffs_GetObjectInode(yaffs_Object *obj)
9697 {
9698 obj = yaffs_GetEquivalentObject(obj);
9699
9700 return obj->objectId;
9701 }
9702
9703 -unsigned yaffs_GetObjectType(yaffs_Object * obj)
9704 +unsigned yaffs_GetObjectType(yaffs_Object *obj)
9705 {
9706 obj = yaffs_GetEquivalentObject(obj);
9707
9708 @@ -6872,19 +6960,18 @@ unsigned yaffs_GetObjectType(yaffs_Objec
9709 }
9710 }
9711
9712 -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj)
9713 +YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj)
9714 {
9715 obj = yaffs_GetEquivalentObject(obj);
9716 - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
9717 + if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
9718 return yaffs_CloneString(obj->variant.symLinkVariant.alias);
9719 - } else {
9720 + else
9721 return yaffs_CloneString(_Y(""));
9722 - }
9723 }
9724
9725 #ifndef CONFIG_YAFFS_WINCE
9726
9727 -int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr)
9728 +int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr)
9729 {
9730 unsigned int valid = attr->ia_valid;
9731
9732 @@ -6910,7 +6997,7 @@ int yaffs_SetAttributes(yaffs_Object * o
9733 return YAFFS_OK;
9734
9735 }
9736 -int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr)
9737 +int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr)
9738 {
9739 unsigned int valid = 0;
9740
9741 @@ -6934,13 +7021,12 @@ int yaffs_GetAttributes(yaffs_Object * o
9742 attr->ia_valid = valid;
9743
9744 return YAFFS_OK;
9745 -
9746 }
9747
9748 #endif
9749
9750 #if 0
9751 -int yaffs_DumpObject(yaffs_Object * obj)
9752 +int yaffs_DumpObject(yaffs_Object *obj)
9753 {
9754 YCHAR name[257];
9755
9756 @@ -6951,7 +7037,7 @@ int yaffs_DumpObject(yaffs_Object * obj)
9757 ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d"
9758 " chunk %d type %d size %d\n"
9759 TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name,
9760 - obj->dirty, obj->valid, obj->serial, obj->sum, obj->chunkId,
9761 + obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdrChunk,
9762 yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj)));
9763
9764 return YAFFS_OK;
9765 @@ -6960,7 +7046,7 @@ int yaffs_DumpObject(yaffs_Object * obj)
9766
9767 /*---------------------------- Initialisation code -------------------------------------- */
9768
9769 -static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
9770 +static int yaffs_CheckDevFunctions(const yaffs_Device *dev)
9771 {
9772
9773 /* Common functions, gotta have */
9774 @@ -7011,7 +7097,7 @@ static int yaffs_CreateInitialDirectorie
9775 yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
9776 YAFFS_LOSTNFOUND_MODE | S_IFDIR);
9777
9778 - if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
9779 + if (dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir) {
9780 yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
9781 return YAFFS_OK;
9782 }
9783 @@ -7019,7 +7105,7 @@ static int yaffs_CreateInitialDirectorie
9784 return YAFFS_FAIL;
9785 }
9786
9787 -int yaffs_GutsInitialise(yaffs_Device * dev)
9788 +int yaffs_GutsInitialise(yaffs_Device *dev)
9789 {
9790 int init_failed = 0;
9791 unsigned x;
9792 @@ -7040,6 +7126,8 @@ int yaffs_GutsInitialise(yaffs_Device *
9793 dev->chunkOffset = 0;
9794 dev->nFreeChunks = 0;
9795
9796 + dev->gcBlock = -1;
9797 +
9798 if (dev->startBlock == 0) {
9799 dev->internalStartBlock = dev->startBlock + 1;
9800 dev->internalEndBlock = dev->endBlock + 1;
9801 @@ -7049,18 +7137,18 @@ int yaffs_GutsInitialise(yaffs_Device *
9802
9803 /* Check geometry parameters. */
9804
9805 - if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
9806 - (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
9807 + if ((!dev->inbandTags && dev->isYaffs2 && dev->totalBytesPerChunk < 1024) ||
9808 + (!dev->isYaffs2 && dev->totalBytesPerChunk < 512) ||
9809 + (dev->inbandTags && !dev->isYaffs2) ||
9810 dev->nChunksPerBlock < 2 ||
9811 dev->nReservedBlocks < 2 ||
9812 dev->internalStartBlock <= 0 ||
9813 dev->internalEndBlock <= 0 ||
9814 - dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2) // otherwise it is too small
9815 - ) {
9816 + dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)) { /* otherwise it is too small */
9817 T(YAFFS_TRACE_ALWAYS,
9818 (TSTR
9819 - ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
9820 - TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
9821 + ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d "
9822 + TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags));
9823 return YAFFS_FAIL;
9824 }
9825
9826 @@ -7070,6 +7158,12 @@ int yaffs_GutsInitialise(yaffs_Device *
9827 return YAFFS_FAIL;
9828 }
9829
9830 + /* Sort out space for inband tags, if required */
9831 + if (dev->inbandTags)
9832 + dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart);
9833 + else
9834 + dev->nDataBytesPerChunk = dev->totalBytesPerChunk;
9835 +
9836 /* Got the right mix of functions? */
9837 if (!yaffs_CheckDevFunctions(dev)) {
9838 /* Function missing */
9839 @@ -7097,31 +7191,18 @@ int yaffs_GutsInitialise(yaffs_Device *
9840
9841 dev->isMounted = 1;
9842
9843 -
9844 -
9845 /* OK now calculate a few things for the device */
9846
9847 /*
9848 * Calculate all the chunk size manipulation numbers:
9849 */
9850 - /* Start off assuming it is a power of 2 */
9851 - dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
9852 - dev->chunkMask = (1<<dev->chunkShift) - 1;
9853 -
9854 - if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
9855 - /* Yes it is a power of 2, disable crumbs */
9856 - dev->crumbMask = 0;
9857 - dev->crumbShift = 0;
9858 - dev->crumbsPerChunk = 0;
9859 - } else {
9860 - /* Not a power of 2, use crumbs instead */
9861 - dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
9862 - dev->crumbMask = (1<<dev->crumbShift)-1;
9863 - dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
9864 - dev->chunkShift = 0;
9865 - dev->chunkMask = 0;
9866 - }
9867 -
9868 + x = dev->nDataBytesPerChunk;
9869 + /* We always use dev->chunkShift and dev->chunkDiv */
9870 + dev->chunkShift = Shifts(x);
9871 + x >>= dev->chunkShift;
9872 + dev->chunkDiv = x;
9873 + /* We only use chunk mask if chunkDiv is 1 */
9874 + dev->chunkMask = (1<<dev->chunkShift) - 1;
9875
9876 /*
9877 * Calculate chunkGroupBits.
9878 @@ -7133,16 +7214,15 @@ int yaffs_GutsInitialise(yaffs_Device *
9879 bits = ShiftsGE(x);
9880
9881 /* Set up tnode width if wide tnodes are enabled. */
9882 - if(!dev->wideTnodesDisabled){
9883 + if (!dev->wideTnodesDisabled) {
9884 /* bits must be even so that we end up with 32-bit words */
9885 - if(bits & 1)
9886 + if (bits & 1)
9887 bits++;
9888 - if(bits < 16)
9889 + if (bits < 16)
9890 dev->tnodeWidth = 16;
9891 else
9892 dev->tnodeWidth = bits;
9893 - }
9894 - else
9895 + } else
9896 dev->tnodeWidth = 16;
9897
9898 dev->tnodeMask = (1<<dev->tnodeWidth)-1;
9899 @@ -7193,7 +7273,7 @@ int yaffs_GutsInitialise(yaffs_Device *
9900 dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
9901
9902 /* Initialise temporary buffers and caches. */
9903 - if(!yaffs_InitialiseTempBuffers(dev))
9904 + if (!yaffs_InitialiseTempBuffers(dev))
9905 init_failed = 1;
9906
9907 dev->srCache = NULL;
9908 @@ -7203,25 +7283,26 @@ int yaffs_GutsInitialise(yaffs_Device *
9909 if (!init_failed &&
9910 dev->nShortOpCaches > 0) {
9911 int i;
9912 - __u8 *buf;
9913 + void *buf;
9914 int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
9915
9916 - if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
9917 + if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES)
9918 dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES;
9919 - }
9920
9921 - buf = dev->srCache = YMALLOC(srCacheBytes);
9922 + dev->srCache = YMALLOC(srCacheBytes);
9923
9924 - if(dev->srCache)
9925 - memset(dev->srCache,0,srCacheBytes);
9926 + buf = (__u8 *) dev->srCache;
9927 +
9928 + if (dev->srCache)
9929 + memset(dev->srCache, 0, srCacheBytes);
9930
9931 for (i = 0; i < dev->nShortOpCaches && buf; i++) {
9932 dev->srCache[i].object = NULL;
9933 dev->srCache[i].lastUse = 0;
9934 dev->srCache[i].dirty = 0;
9935 - dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
9936 + dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk);
9937 }
9938 - if(!buf)
9939 + if (!buf)
9940 init_failed = 1;
9941
9942 dev->srLastUse = 0;
9943 @@ -7229,29 +7310,30 @@ int yaffs_GutsInitialise(yaffs_Device *
9944
9945 dev->cacheHits = 0;
9946
9947 - if(!init_failed){
9948 + if (!init_failed) {
9949 dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
9950 - if(!dev->gcCleanupList)
9951 + if (!dev->gcCleanupList)
9952 init_failed = 1;
9953 }
9954
9955 - if (dev->isYaffs2) {
9956 + if (dev->isYaffs2)
9957 dev->useHeaderFileSize = 1;
9958 - }
9959 - if(!init_failed && !yaffs_InitialiseBlocks(dev))
9960 +
9961 + if (!init_failed && !yaffs_InitialiseBlocks(dev))
9962 init_failed = 1;
9963
9964 yaffs_InitialiseTnodes(dev);
9965 yaffs_InitialiseObjects(dev);
9966
9967 - if(!init_failed && !yaffs_CreateInitialDirectories(dev))
9968 + if (!init_failed && !yaffs_CreateInitialDirectories(dev))
9969 init_failed = 1;
9970
9971
9972 - if(!init_failed){
9973 + if (!init_failed) {
9974 /* Now scan the flash. */
9975 if (dev->isYaffs2) {
9976 - if(yaffs_CheckpointRestore(dev)) {
9977 + if (yaffs_CheckpointRestore(dev)) {
9978 + yaffs_CheckObjectDetailsLoaded(dev->rootDir);
9979 T(YAFFS_TRACE_ALWAYS,
9980 (TSTR("yaffs: restored from checkpoint" TENDSTR)));
9981 } else {
9982 @@ -7273,24 +7355,25 @@ int yaffs_GutsInitialise(yaffs_Device *
9983 dev->nBackgroundDeletions = 0;
9984 dev->oldestDirtySequence = 0;
9985
9986 - if(!init_failed && !yaffs_InitialiseBlocks(dev))
9987 + if (!init_failed && !yaffs_InitialiseBlocks(dev))
9988 init_failed = 1;
9989
9990 yaffs_InitialiseTnodes(dev);
9991 yaffs_InitialiseObjects(dev);
9992
9993 - if(!init_failed && !yaffs_CreateInitialDirectories(dev))
9994 + if (!init_failed && !yaffs_CreateInitialDirectories(dev))
9995 init_failed = 1;
9996
9997 - if(!init_failed && !yaffs_ScanBackwards(dev))
9998 + if (!init_failed && !yaffs_ScanBackwards(dev))
9999 init_failed = 1;
10000 }
10001 - }else
10002 - if(!yaffs_Scan(dev))
10003 + } else if (!yaffs_Scan(dev))
10004 init_failed = 1;
10005 +
10006 + yaffs_StripDeletedObjects(dev);
10007 }
10008
10009 - if(init_failed){
10010 + if (init_failed) {
10011 /* Clean up the mess */
10012 T(YAFFS_TRACE_TRACING,
10013 (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR)));
10014 @@ -7318,7 +7401,7 @@ int yaffs_GutsInitialise(yaffs_Device *
10015
10016 }
10017
10018 -void yaffs_Deinitialise(yaffs_Device * dev)
10019 +void yaffs_Deinitialise(yaffs_Device *dev)
10020 {
10021 if (dev->isMounted) {
10022 int i;
10023 @@ -7330,7 +7413,7 @@ void yaffs_Deinitialise(yaffs_Device * d
10024 dev->srCache) {
10025
10026 for (i = 0; i < dev->nShortOpCaches; i++) {
10027 - if(dev->srCache[i].data)
10028 + if (dev->srCache[i].data)
10029 YFREE(dev->srCache[i].data);
10030 dev->srCache[i].data = NULL;
10031 }
10032 @@ -7341,16 +7424,17 @@ void yaffs_Deinitialise(yaffs_Device * d
10033
10034 YFREE(dev->gcCleanupList);
10035
10036 - for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
10037 + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
10038 YFREE(dev->tempBuffer[i].buffer);
10039 - }
10040
10041 dev->isMounted = 0;
10042 - }
10043
10044 + if (dev->deinitialiseNAND)
10045 + dev->deinitialiseNAND(dev);
10046 + }
10047 }
10048
10049 -static int yaffs_CountFreeChunks(yaffs_Device * dev)
10050 +static int yaffs_CountFreeChunks(yaffs_Device *dev)
10051 {
10052 int nFree;
10053 int b;
10054 @@ -7358,7 +7442,7 @@ static int yaffs_CountFreeChunks(yaffs_D
10055 yaffs_BlockInfo *blk;
10056
10057 for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock;
10058 - b++) {
10059 + b++) {
10060 blk = yaffs_GetBlockInfo(dev, b);
10061
10062 switch (blk->blockState) {
10063 @@ -7373,19 +7457,19 @@ static int yaffs_CountFreeChunks(yaffs_D
10064 default:
10065 break;
10066 }
10067 -
10068 }
10069
10070 return nFree;
10071 }
10072
10073 -int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
10074 +int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev)
10075 {
10076 /* This is what we report to the outside world */
10077
10078 int nFree;
10079 int nDirtyCacheChunks;
10080 int blocksForCheckpoint;
10081 + int i;
10082
10083 #if 1
10084 nFree = dev->nFreeChunks;
10085 @@ -7397,12 +7481,9 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
10086
10087 /* Now count the number of dirty chunks in the cache and subtract those */
10088
10089 - {
10090 - int i;
10091 - for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) {
10092 - if (dev->srCache[i].dirty)
10093 - nDirtyCacheChunks++;
10094 - }
10095 + for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) {
10096 + if (dev->srCache[i].dirty)
10097 + nDirtyCacheChunks++;
10098 }
10099
10100 nFree -= nDirtyCacheChunks;
10101 @@ -7410,8 +7491,8 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
10102 nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
10103
10104 /* Now we figure out how much to reserve for the checkpoint and report that... */
10105 - blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
10106 - if(blocksForCheckpoint < 0)
10107 + blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
10108 + if (blocksForCheckpoint < 0)
10109 blocksForCheckpoint = 0;
10110
10111 nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
10112 @@ -7425,12 +7506,12 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
10113
10114 static int yaffs_freeVerificationFailures;
10115
10116 -static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
10117 +static void yaffs_VerifyFreeChunks(yaffs_Device *dev)
10118 {
10119 int counted;
10120 int difference;
10121
10122 - if(yaffs_SkipVerification(dev))
10123 + if (yaffs_SkipVerification(dev))
10124 return;
10125
10126 counted = yaffs_CountFreeChunks(dev);
10127 @@ -7447,23 +7528,25 @@ static void yaffs_VerifyFreeChunks(yaffs
10128
10129 /*---------------------------------------- YAFFS test code ----------------------*/
10130
10131 -#define yaffs_CheckStruct(structure,syze, name) \
10132 - if(sizeof(structure) != syze) \
10133 - { \
10134 - T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
10135 - name,syze,sizeof(structure))); \
10136 - return YAFFS_FAIL; \
10137 - }
10138 +#define yaffs_CheckStruct(structure, syze, name) \
10139 + do { \
10140 + if (sizeof(structure) != syze) { \
10141 + T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\
10142 + name, syze, sizeof(structure))); \
10143 + return YAFFS_FAIL; \
10144 + } \
10145 + } while (0)
10146
10147 static int yaffs_CheckStructures(void)
10148 {
10149 -/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
10150 -/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
10151 -/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
10152 +/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */
10153 +/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
10154 +/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */
10155 #ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
10156 - yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
10157 + yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode");
10158 #endif
10159 - yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
10160 -
10161 - return YAFFS_OK;
10162 +#ifndef CONFIG_YAFFS_WINCE
10163 + yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
10164 +#endif
10165 + return YAFFS_OK;
10166 }
10167 --- a/fs/yaffs2/yaffs_guts.h
10168 +++ b/fs/yaffs2/yaffs_guts.h
10169 @@ -90,7 +90,7 @@
10170
10171 #define YAFFS_MAX_SHORT_OP_CACHES 20
10172
10173 -#define YAFFS_N_TEMP_BUFFERS 4
10174 +#define YAFFS_N_TEMP_BUFFERS 6
10175
10176 /* We limit the number attempts at sucessfully saving a chunk of data.
10177 * Small-page devices have 32 pages per block; large-page devices have 64.
10178 @@ -108,6 +108,9 @@
10179 #define YAFFS_LOWEST_SEQUENCE_NUMBER 0x00001000
10180 #define YAFFS_HIGHEST_SEQUENCE_NUMBER 0xEFFFFF00
10181
10182 +/* Special sequence number for bad block that failed to be marked bad */
10183 +#define YAFFS_SEQUENCE_BAD_BLOCK 0xFFFF0000
10184 +
10185 /* ChunkCache is used for short read/write operations.*/
10186 typedef struct {
10187 struct yaffs_ObjectStruct *object;
10188 @@ -134,11 +137,10 @@ typedef struct {
10189 typedef struct {
10190 unsigned chunkId:20;
10191 unsigned serialNumber:2;
10192 - unsigned byteCount:10;
10193 + unsigned byteCountLSB:10;
10194 unsigned objectId:18;
10195 unsigned ecc:12;
10196 - unsigned unusedStuff:2;
10197 -
10198 + unsigned byteCountMSB:2;
10199 } yaffs_Tags;
10200
10201 typedef union {
10202 @@ -277,13 +279,13 @@ typedef struct {
10203
10204 int softDeletions:10; /* number of soft deleted pages */
10205 int pagesInUse:10; /* number of pages in use */
10206 - yaffs_BlockState blockState:4; /* One of the above block states */
10207 + unsigned blockState:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */
10208 __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */
10209 - /* and retire the block. */
10210 - __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
10211 - __u32 gcPrioritise: 1; /* An ECC check or blank check has failed on this block.
10212 + /* and retire the block. */
10213 + __u32 skipErasedCheck:1; /* If this is set we can skip the erased check on this block */
10214 + __u32 gcPrioritise:1; /* An ECC check or blank check has failed on this block.
10215 It should be prioritised for GC */
10216 - __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
10217 + __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
10218
10219 #ifdef CONFIG_YAFFS_YAFFS2
10220 __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */
10221 @@ -300,11 +302,11 @@ typedef struct {
10222
10223 /* Apply to everything */
10224 int parentObjectId;
10225 - __u16 sum__NoLongerUsed; /* checksum of name. No longer used */
10226 + __u16 sum__NoLongerUsed; /* checksum of name. No longer used */
10227 YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
10228
10229 - /* Thes following apply to directories, files, symlinks - not hard links */
10230 - __u32 yst_mode; /* protection */
10231 + /* The following apply to directories, files, symlinks - not hard links */
10232 + __u32 yst_mode; /* protection */
10233
10234 #ifdef CONFIG_YAFFS_WINCE
10235 __u32 notForWinCE[5];
10236 @@ -331,11 +333,14 @@ typedef struct {
10237 __u32 win_ctime[2];
10238 __u32 win_atime[2];
10239 __u32 win_mtime[2];
10240 - __u32 roomToGrow[4];
10241 #else
10242 - __u32 roomToGrow[10];
10243 + __u32 roomToGrow[6];
10244 +
10245 #endif
10246 + __u32 inbandShadowsObject;
10247 + __u32 inbandIsShrink;
10248
10249 + __u32 reservedSpace[2];
10250 int shadowsObject; /* This object header shadows the specified object if > 0 */
10251
10252 /* isShrink applies to object headers written when we shrink the file (ie resize) */
10253 @@ -381,7 +386,7 @@ typedef struct {
10254 } yaffs_FileStructure;
10255
10256 typedef struct {
10257 - struct list_head children; /* list of child links */
10258 + struct ylist_head children; /* list of child links */
10259 } yaffs_DirectoryStructure;
10260
10261 typedef struct {
10262 @@ -418,23 +423,24 @@ struct yaffs_ObjectStruct {
10263 * still in the inode cache. Free of object is defered.
10264 * until the inode is released.
10265 */
10266 + __u8 beingCreated:1; /* This object is still being created so skip some checks. */
10267
10268 __u8 serial; /* serial number of chunk in NAND. Cached here */
10269 __u16 sum; /* sum of the name to speed searching */
10270
10271 - struct yaffs_DeviceStruct *myDev; /* The device I'm on */
10272 + struct yaffs_DeviceStruct *myDev; /* The device I'm on */
10273
10274 - struct list_head hashLink; /* list of objects in this hash bucket */
10275 + struct ylist_head hashLink; /* list of objects in this hash bucket */
10276
10277 - struct list_head hardLinks; /* all the equivalent hard linked objects */
10278 + struct ylist_head hardLinks; /* all the equivalent hard linked objects */
10279
10280 /* directory structure stuff */
10281 /* also used for linking up the free list */
10282 struct yaffs_ObjectStruct *parent;
10283 - struct list_head siblings;
10284 + struct ylist_head siblings;
10285
10286 /* Where's my object header in NAND? */
10287 - int chunkId;
10288 + int hdrChunk;
10289
10290 int nDataChunks; /* Number of data chunks attached to the file. */
10291
10292 @@ -485,7 +491,7 @@ struct yaffs_ObjectList_struct {
10293 typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
10294
10295 typedef struct {
10296 - struct list_head list;
10297 + struct ylist_head list;
10298 int count;
10299 } yaffs_ObjectBucket;
10300
10301 @@ -495,11 +501,10 @@ typedef struct {
10302 */
10303
10304 typedef struct {
10305 - int structType;
10306 + int structType;
10307 __u32 objectId;
10308 __u32 parentId;
10309 - int chunkId;
10310 -
10311 + int hdrChunk;
10312 yaffs_ObjectType variantType:3;
10313 __u8 deleted:1;
10314 __u8 softDeleted:1;
10315 @@ -511,8 +516,7 @@ typedef struct {
10316
10317 int nDataChunks;
10318 __u32 fileSizeOrEquivalentObjectId;
10319 -
10320 -}yaffs_CheckpointObject;
10321 +} yaffs_CheckpointObject;
10322
10323 /*--------------------- Temporary buffers ----------------
10324 *
10325 @@ -528,13 +532,13 @@ typedef struct {
10326 /*----------------- Device ---------------------------------*/
10327
10328 struct yaffs_DeviceStruct {
10329 - struct list_head devList;
10330 + struct ylist_head devList;
10331 const char *name;
10332
10333 /* Entry parameters set up way early. Yaffs sets up the rest.*/
10334 int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */
10335 int nChunksPerBlock; /* does not need to be a power of 2 */
10336 - int nBytesPerSpare; /* spare area size */
10337 + int spareBytesPerChunk; /* spare area size */
10338 int startBlock; /* Start block we're allowed to use */
10339 int endBlock; /* End block we're allowed to use */
10340 int nReservedBlocks; /* We want this tuneable so that we can reduce */
10341 @@ -544,9 +548,7 @@ struct yaffs_DeviceStruct {
10342 /* Stuff used by the shared space checkpointing mechanism */
10343 /* If this value is zero, then this mechanism is disabled */
10344
10345 - int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
10346 -
10347 -
10348 +/* int nCheckpointReservedBlocks; */ /* Blocks to reserve for checkpoint data */
10349
10350
10351 int nShortOpCaches; /* If <= 0, then short op caching is disabled, else
10352 @@ -560,30 +562,31 @@ struct yaffs_DeviceStruct {
10353 void *genericDevice; /* Pointer to device context
10354 * On an mtd this holds the mtd pointer.
10355 */
10356 - void *superBlock;
10357 + void *superBlock;
10358
10359 /* NAND access functions (Must be set before calling YAFFS)*/
10360
10361 - int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
10362 - int chunkInNAND, const __u8 * data,
10363 - const yaffs_Spare * spare);
10364 - int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev,
10365 - int chunkInNAND, __u8 * data,
10366 - yaffs_Spare * spare);
10367 - int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev,
10368 - int blockInNAND);
10369 - int (*initialiseNAND) (struct yaffs_DeviceStruct * dev);
10370 + int (*writeChunkToNAND) (struct yaffs_DeviceStruct *dev,
10371 + int chunkInNAND, const __u8 *data,
10372 + const yaffs_Spare *spare);
10373 + int (*readChunkFromNAND) (struct yaffs_DeviceStruct *dev,
10374 + int chunkInNAND, __u8 *data,
10375 + yaffs_Spare *spare);
10376 + int (*eraseBlockInNAND) (struct yaffs_DeviceStruct *dev,
10377 + int blockInNAND);
10378 + int (*initialiseNAND) (struct yaffs_DeviceStruct *dev);
10379 + int (*deinitialiseNAND) (struct yaffs_DeviceStruct *dev);
10380
10381 #ifdef CONFIG_YAFFS_YAFFS2
10382 - int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev,
10383 - int chunkInNAND, const __u8 * data,
10384 - const yaffs_ExtendedTags * tags);
10385 - int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev,
10386 - int chunkInNAND, __u8 * data,
10387 - yaffs_ExtendedTags * tags);
10388 - int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo);
10389 - int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo,
10390 - yaffs_BlockState * state, int *sequenceNumber);
10391 + int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct *dev,
10392 + int chunkInNAND, const __u8 *data,
10393 + const yaffs_ExtendedTags *tags);
10394 + int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct *dev,
10395 + int chunkInNAND, __u8 *data,
10396 + yaffs_ExtendedTags *tags);
10397 + int (*markNANDBlockBad) (struct yaffs_DeviceStruct *dev, int blockNo);
10398 + int (*queryNANDBlock) (struct yaffs_DeviceStruct *dev, int blockNo,
10399 + yaffs_BlockState *state, __u32 *sequenceNumber);
10400 #endif
10401
10402 int isYaffs2;
10403 @@ -595,10 +598,12 @@ struct yaffs_DeviceStruct {
10404 void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
10405
10406 /* Callback to mark the superblock dirsty */
10407 - void (*markSuperBlockDirty)(void * superblock);
10408 + void (*markSuperBlockDirty)(void *superblock);
10409
10410 int wideTnodesDisabled; /* Set to disable wide tnodes */
10411
10412 + YCHAR *pathDividers; /* String of legal path dividers */
10413 +
10414
10415 /* End of stuff that must be set before initialisation. */
10416
10417 @@ -615,16 +620,14 @@ struct yaffs_DeviceStruct {
10418 __u32 tnodeWidth;
10419 __u32 tnodeMask;
10420
10421 - /* Stuff to support various file offses to chunk/offset translations */
10422 - /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
10423 - __u32 crumbMask;
10424 - __u32 crumbShift;
10425 - __u32 crumbsPerChunk;
10426 -
10427 - /* Straight shifting for nDataBytesPerChunk being a power of 2 */
10428 - __u32 chunkShift;
10429 - __u32 chunkMask;
10430 -
10431 + /* Stuff for figuring out file offset to chunk conversions */
10432 + __u32 chunkShift; /* Shift value */
10433 + __u32 chunkDiv; /* Divisor after shifting: 1 for power-of-2 sizes */
10434 + __u32 chunkMask; /* Mask to use for power-of-2 case */
10435 +
10436 + /* Stuff to handle inband tags */
10437 + int inbandTags;
10438 + __u32 totalBytesPerChunk;
10439
10440 #ifdef __KERNEL__
10441
10442 @@ -633,7 +636,7 @@ struct yaffs_DeviceStruct {
10443 __u8 *spareBuffer; /* For mtdif2 use. Don't know the size of the buffer
10444 * at compile time so we have to allocate it.
10445 */
10446 - void (*putSuperFunc) (struct super_block * sb);
10447 + void (*putSuperFunc) (struct super_block *sb);
10448 #endif
10449
10450 int isMounted;
10451 @@ -663,6 +666,8 @@ struct yaffs_DeviceStruct {
10452 __u32 checkpointSum;
10453 __u32 checkpointXor;
10454
10455 + int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */
10456 +
10457 /* Block Info */
10458 yaffs_BlockInfo *blockInfo;
10459 __u8 *chunkBits; /* bitmap of chunks in use */
10460 @@ -684,11 +689,15 @@ struct yaffs_DeviceStruct {
10461 yaffs_TnodeList *allocatedTnodeList;
10462
10463 int isDoingGC;
10464 + int gcBlock;
10465 + int gcChunk;
10466
10467 int nObjectsCreated;
10468 yaffs_Object *freeObjects;
10469 int nFreeObjects;
10470
10471 + int nHardLinks;
10472 +
10473 yaffs_ObjectList *allocatedObjectList;
10474
10475 yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS];
10476 @@ -745,8 +754,10 @@ struct yaffs_DeviceStruct {
10477 int nBackgroundDeletions; /* Count of background deletions. */
10478
10479
10480 + /* Temporary buffer management */
10481 yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
10482 int maxTemp;
10483 + int tempInUse;
10484 int unmanagedTempAllocations;
10485 int unmanagedTempDeallocations;
10486
10487 @@ -758,9 +769,9 @@ struct yaffs_DeviceStruct {
10488
10489 typedef struct yaffs_DeviceStruct yaffs_Device;
10490
10491 -/* The static layout of bllock usage etc is stored in the super block header */
10492 +/* The static layout of block usage etc is stored in the super block header */
10493 typedef struct {
10494 - int StructType;
10495 + int StructType;
10496 int version;
10497 int checkpointStartBlock;
10498 int checkpointEndBlock;
10499 @@ -773,7 +784,7 @@ typedef struct {
10500 * must be preserved over unmount/mount cycles.
10501 */
10502 typedef struct {
10503 - int structType;
10504 + int structType;
10505 int nErasedBlocks;
10506 int allocationBlock; /* Current block being allocated off */
10507 __u32 allocationPage;
10508 @@ -791,57 +802,45 @@ typedef struct {
10509
10510
10511 typedef struct {
10512 - int structType;
10513 - __u32 magic;
10514 - __u32 version;
10515 - __u32 head;
10516 + int structType;
10517 + __u32 magic;
10518 + __u32 version;
10519 + __u32 head;
10520 } yaffs_CheckpointValidity;
10521
10522 -/* Function to manipulate block info */
10523 -static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
10524 -{
10525 - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
10526 - T(YAFFS_TRACE_ERROR,
10527 - (TSTR
10528 - ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
10529 - blk));
10530 - YBUG();
10531 - }
10532 - return &dev->blockInfo[blk - dev->internalStartBlock];
10533 -}
10534
10535 /*----------------------- YAFFS Functions -----------------------*/
10536
10537 -int yaffs_GutsInitialise(yaffs_Device * dev);
10538 -void yaffs_Deinitialise(yaffs_Device * dev);
10539 +int yaffs_GutsInitialise(yaffs_Device *dev);
10540 +void yaffs_Deinitialise(yaffs_Device *dev);
10541
10542 -int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev);
10543 +int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev);
10544
10545 -int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
10546 - yaffs_Object * newDir, const YCHAR * newName);
10547 +int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName,
10548 + yaffs_Object *newDir, const YCHAR *newName);
10549
10550 -int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name);
10551 -int yaffs_DeleteFile(yaffs_Object * obj);
10552 +int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name);
10553 +int yaffs_DeleteObject(yaffs_Object *obj);
10554
10555 -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize);
10556 -int yaffs_GetObjectFileLength(yaffs_Object * obj);
10557 -int yaffs_GetObjectInode(yaffs_Object * obj);
10558 -unsigned yaffs_GetObjectType(yaffs_Object * obj);
10559 -int yaffs_GetObjectLinkCount(yaffs_Object * obj);
10560 +int yaffs_GetObjectName(yaffs_Object *obj, YCHAR *name, int buffSize);
10561 +int yaffs_GetObjectFileLength(yaffs_Object *obj);
10562 +int yaffs_GetObjectInode(yaffs_Object *obj);
10563 +unsigned yaffs_GetObjectType(yaffs_Object *obj);
10564 +int yaffs_GetObjectLinkCount(yaffs_Object *obj);
10565
10566 -int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr);
10567 -int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr);
10568 +int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr);
10569 +int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr);
10570
10571 /* File operations */
10572 -int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset,
10573 - int nBytes);
10574 -int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset,
10575 - int nBytes, int writeThrough);
10576 -int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize);
10577 -
10578 -yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
10579 - __u32 mode, __u32 uid, __u32 gid);
10580 -int yaffs_FlushFile(yaffs_Object * obj, int updateTime);
10581 +int yaffs_ReadDataFromFile(yaffs_Object *obj, __u8 *buffer, loff_t offset,
10582 + int nBytes);
10583 +int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, loff_t offset,
10584 + int nBytes, int writeThrough);
10585 +int yaffs_ResizeFile(yaffs_Object *obj, loff_t newSize);
10586 +
10587 +yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name,
10588 + __u32 mode, __u32 uid, __u32 gid);
10589 +int yaffs_FlushFile(yaffs_Object *obj, int updateTime);
10590
10591 /* Flushing and checkpointing */
10592 void yaffs_FlushEntireDeviceCache(yaffs_Device *dev);
10593 @@ -850,33 +849,33 @@ int yaffs_CheckpointSave(yaffs_Device *d
10594 int yaffs_CheckpointRestore(yaffs_Device *dev);
10595
10596 /* Directory operations */
10597 -yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
10598 - __u32 mode, __u32 uid, __u32 gid);
10599 -yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name);
10600 -int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
10601 +yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name,
10602 + __u32 mode, __u32 uid, __u32 gid);
10603 +yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir, const YCHAR *name);
10604 +int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,
10605 int (*fn) (yaffs_Object *));
10606
10607 -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number);
10608 +yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number);
10609
10610 /* Link operations */
10611 -yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
10612 - yaffs_Object * equivalentObject);
10613 +yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name,
10614 + yaffs_Object *equivalentObject);
10615
10616 -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj);
10617 +yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj);
10618
10619 /* Symlink operations */
10620 -yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
10621 +yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name,
10622 __u32 mode, __u32 uid, __u32 gid,
10623 - const YCHAR * alias);
10624 -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj);
10625 + const YCHAR *alias);
10626 +YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj);
10627
10628 /* Special inodes (fifos, sockets and devices) */
10629 -yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
10630 +yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name,
10631 __u32 mode, __u32 uid, __u32 gid, __u32 rdev);
10632
10633 /* Special directories */
10634 -yaffs_Object *yaffs_Root(yaffs_Device * dev);
10635 -yaffs_Object *yaffs_LostNFound(yaffs_Device * dev);
10636 +yaffs_Object *yaffs_Root(yaffs_Device *dev);
10637 +yaffs_Object *yaffs_LostNFound(yaffs_Device *dev);
10638
10639 #ifdef CONFIG_YAFFS_WINCE
10640 /* CONFIG_YAFFS_WINCE special stuff */
10641 @@ -885,18 +884,21 @@ void yfsd_WinFileTimeNow(__u32 target[2]
10642
10643 #ifdef __KERNEL__
10644
10645 -void yaffs_HandleDeferedFree(yaffs_Object * obj);
10646 +void yaffs_HandleDeferedFree(yaffs_Object *obj);
10647 #endif
10648
10649 /* Debug dump */
10650 -int yaffs_DumpObject(yaffs_Object * obj);
10651 +int yaffs_DumpObject(yaffs_Object *obj);
10652
10653 -void yaffs_GutsTest(yaffs_Device * dev);
10654 +void yaffs_GutsTest(yaffs_Device *dev);
10655
10656 /* A few useful functions */
10657 -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
10658 -void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn);
10659 -int yaffs_CheckFF(__u8 * buffer, int nBytes);
10660 +void yaffs_InitialiseTags(yaffs_ExtendedTags *tags);
10661 +void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn);
10662 +int yaffs_CheckFF(__u8 *buffer, int nBytes);
10663 void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi);
10664
10665 +__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo);
10666 +void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, int lineNo);
10667 +
10668 #endif
10669 --- a/fs/yaffs2/yaffs_mtdif1.c
10670 +++ b/fs/yaffs2/yaffs_mtdif1.c
10671 @@ -26,7 +26,7 @@
10672 #include "yportenv.h"
10673 #include "yaffs_guts.h"
10674 #include "yaffs_packedtags1.h"
10675 -#include "yaffs_tagscompat.h" // for yaffs_CalcTagsECC
10676 +#include "yaffs_tagscompat.h" /* for yaffs_CalcTagsECC */
10677
10678 #include "linux/kernel.h"
10679 #include "linux/version.h"
10680 @@ -34,9 +34,9 @@
10681 #include "linux/mtd/mtd.h"
10682
10683 /* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
10684 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10685 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
10686
10687 -const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.3 2007/05/15 20:16:11 ian Exp $";
10688 +const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.10 2009-03-09 07:41:10 charles Exp $";
10689
10690 #ifndef CONFIG_YAFFS_9BYTE_TAGS
10691 # define YTAG1_SIZE 8
10692 @@ -89,9 +89,9 @@ static struct nand_ecclayout nand_oob_16
10693 * Returns YAFFS_OK or YAFFS_FAIL.
10694 */
10695 int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev,
10696 - int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags)
10697 + int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *etags)
10698 {
10699 - struct mtd_info * mtd = dev->genericDevice;
10700 + struct mtd_info *mtd = dev->genericDevice;
10701 int chunkBytes = dev->nDataBytesPerChunk;
10702 loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
10703 struct mtd_oob_ops ops;
10704 @@ -146,7 +146,7 @@ int nandmtd1_WriteChunkWithTagsToNAND(ya
10705
10706 /* Return with empty ExtendedTags but add eccResult.
10707 */
10708 -static int rettags(yaffs_ExtendedTags * etags, int eccResult, int retval)
10709 +static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval)
10710 {
10711 if (etags) {
10712 memset(etags, 0, sizeof(*etags));
10713 @@ -169,9 +169,9 @@ static int rettags(yaffs_ExtendedTags *
10714 * Returns YAFFS_OK or YAFFS_FAIL.
10715 */
10716 int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev,
10717 - int chunkInNAND, __u8 * data, yaffs_ExtendedTags * etags)
10718 + int chunkInNAND, __u8 *data, yaffs_ExtendedTags *etags)
10719 {
10720 - struct mtd_info * mtd = dev->genericDevice;
10721 + struct mtd_info *mtd = dev->genericDevice;
10722 int chunkBytes = dev->nDataBytesPerChunk;
10723 loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
10724 int eccres = YAFFS_ECC_RESULT_NO_ERROR;
10725 @@ -189,7 +189,7 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y
10726 ops.datbuf = data;
10727 ops.oobbuf = (__u8 *)&pt1;
10728
10729 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
10730 +#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20))
10731 /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
10732 * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
10733 */
10734 @@ -284,11 +284,11 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y
10735 */
10736 int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
10737 {
10738 - struct mtd_info * mtd = dev->genericDevice;
10739 + struct mtd_info *mtd = dev->genericDevice;
10740 int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
10741 int retval;
10742
10743 - yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
10744 + yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad\n", blockNo);
10745
10746 retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
10747 return (retval) ? YAFFS_FAIL : YAFFS_OK;
10748 @@ -298,7 +298,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaf
10749 *
10750 * Returns YAFFS_OK or YAFFS_FAIL.
10751 */
10752 -static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
10753 +static int nandmtd1_TestPrerequists(struct mtd_info *mtd)
10754 {
10755 /* 2.6.18 has mtd->ecclayout->oobavail */
10756 /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
10757 @@ -323,10 +323,11 @@ static int nandmtd1_TestPrerequists(stru
10758 * Always returns YAFFS_OK.
10759 */
10760 int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
10761 - yaffs_BlockState * pState, int *pSequenceNumber)
10762 + yaffs_BlockState *pState, __u32 *pSequenceNumber)
10763 {
10764 - struct mtd_info * mtd = dev->genericDevice;
10765 + struct mtd_info *mtd = dev->genericDevice;
10766 int chunkNo = blockNo * dev->nChunksPerBlock;
10767 + loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk;
10768 yaffs_ExtendedTags etags;
10769 int state = YAFFS_BLOCK_STATE_DEAD;
10770 int seqnum = 0;
10771 @@ -335,21 +336,22 @@ int nandmtd1_QueryNANDBlock(struct yaffs
10772 /* We don't yet have a good place to test for MTD config prerequists.
10773 * Do it here as we are called during the initial scan.
10774 */
10775 - if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) {
10776 + if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK)
10777 return YAFFS_FAIL;
10778 - }
10779
10780 retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
10781 + etags.blockBad = (mtd->block_isbad)(mtd, addr);
10782 if (etags.blockBad) {
10783 yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
10784 - "block %d is marked bad", blockNo);
10785 + "block %d is marked bad\n", blockNo);
10786 state = YAFFS_BLOCK_STATE_DEAD;
10787 - }
10788 - else if (etags.chunkUsed) {
10789 + } else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) {
10790 + /* bad tags, need to look more closely */
10791 + state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
10792 + } else if (etags.chunkUsed) {
10793 state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
10794 seqnum = etags.sequenceNumber;
10795 - }
10796 - else {
10797 + } else {
10798 state = YAFFS_BLOCK_STATE_EMPTY;
10799 }
10800
10801 @@ -360,4 +362,4 @@ int nandmtd1_QueryNANDBlock(struct yaffs
10802 return YAFFS_OK;
10803 }
10804
10805 -#endif /*KERNEL_VERSION*/
10806 +#endif /*MTD_VERSION*/
10807 --- a/fs/yaffs2/yaffs_mtdif1.h
10808 +++ b/fs/yaffs2/yaffs_mtdif1.h
10809 @@ -14,15 +14,15 @@
10810 #ifndef __YAFFS_MTDIF1_H__
10811 #define __YAFFS_MTDIF1_H__
10812
10813 -int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
10814 - const __u8 * data, const yaffs_ExtendedTags * tags);
10815 +int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND,
10816 + const __u8 *data, const yaffs_ExtendedTags *tags);
10817
10818 -int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
10819 - __u8 * data, yaffs_ExtendedTags * tags);
10820 +int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
10821 + __u8 *data, yaffs_ExtendedTags *tags);
10822
10823 int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
10824
10825 int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
10826 - yaffs_BlockState * state, int *sequenceNumber);
10827 + yaffs_BlockState *state, __u32 *sequenceNumber);
10828
10829 #endif
10830 --- a/fs/yaffs2/yaffs_mtdif2.c
10831 +++ b/fs/yaffs2/yaffs_mtdif2.c
10832 @@ -14,7 +14,7 @@
10833 /* mtd interface for YAFFS2 */
10834
10835 const char *yaffs_mtdif2_c_version =
10836 - "$Id: yaffs_mtdif2.c,v 1.17 2007-02-14 01:09:06 wookey Exp $";
10837 + "$Id: yaffs_mtdif2.c,v 1.23 2009-03-06 17:20:53 wookey Exp $";
10838
10839 #include "yportenv.h"
10840
10841 @@ -27,19 +27,23 @@ const char *yaffs_mtdif2_c_version =
10842
10843 #include "yaffs_packedtags2.h"
10844
10845 -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
10846 - const __u8 * data,
10847 - const yaffs_ExtendedTags * tags)
10848 +/* NB For use with inband tags....
10849 + * We assume that the data buffer is of size totalBytersPerChunk so that we can also
10850 + * use it to load the tags.
10851 + */
10852 +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND,
10853 + const __u8 *data,
10854 + const yaffs_ExtendedTags *tags)
10855 {
10856 struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
10857 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10858 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
10859 struct mtd_oob_ops ops;
10860 #else
10861 size_t dummy;
10862 #endif
10863 int retval = 0;
10864
10865 - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
10866 + loff_t addr;
10867
10868 yaffs_PackedTags2 pt;
10869
10870 @@ -48,46 +52,40 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya
10871 ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
10872 TENDSTR), chunkInNAND, data, tags));
10873
10874 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10875 - if (tags)
10876 - yaffs_PackTags2(&pt, tags);
10877 - else
10878 - BUG(); /* both tags and data should always be present */
10879
10880 - if (data) {
10881 - ops.mode = MTD_OOB_AUTO;
10882 - ops.ooblen = sizeof(pt);
10883 - ops.len = dev->nDataBytesPerChunk;
10884 - ops.ooboffs = 0;
10885 - ops.datbuf = (__u8 *)data;
10886 - ops.oobbuf = (void *)&pt;
10887 - retval = mtd->write_oob(mtd, addr, &ops);
10888 + addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
10889 +
10890 + /* For yaffs2 writing there must be both data and tags.
10891 + * If we're using inband tags, then the tags are stuffed into
10892 + * the end of the data buffer.
10893 + */
10894 + if (!data || !tags)
10895 + BUG();
10896 + else if (dev->inbandTags) {
10897 + yaffs_PackedTags2TagsPart *pt2tp;
10898 + pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk);
10899 + yaffs_PackTags2TagsPart(pt2tp, tags);
10900 } else
10901 - BUG(); /* both tags and data should always be present */
10902 -#else
10903 - if (tags) {
10904 yaffs_PackTags2(&pt, tags);
10905 - }
10906
10907 - if (data && tags) {
10908 - if (dev->useNANDECC)
10909 - retval =
10910 - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
10911 - &dummy, data, (__u8 *) & pt, NULL);
10912 - else
10913 - retval =
10914 - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
10915 - &dummy, data, (__u8 *) & pt, NULL);
10916 - } else {
10917 - if (data)
10918 - retval =
10919 - mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
10920 - data);
10921 - if (tags)
10922 - retval =
10923 - mtd->write_oob(mtd, addr, mtd->oobsize, &dummy,
10924 - (__u8 *) & pt);
10925 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
10926 + ops.mode = MTD_OOB_AUTO;
10927 + ops.ooblen = (dev->inbandTags) ? 0 : sizeof(pt);
10928 + ops.len = dev->totalBytesPerChunk;
10929 + ops.ooboffs = 0;
10930 + ops.datbuf = (__u8 *)data;
10931 + ops.oobbuf = (dev->inbandTags) ? NULL : (void *)&pt;
10932 + retval = mtd->write_oob(mtd, addr, &ops);
10933
10934 +#else
10935 + if (!dev->inbandTags) {
10936 + retval =
10937 + mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
10938 + &dummy, data, (__u8 *) &pt, NULL);
10939 + } else {
10940 + retval =
10941 + mtd->write(mtd, addr, dev->totalBytesPerChunk, &dummy,
10942 + data);
10943 }
10944 #endif
10945
10946 @@ -97,17 +95,18 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya
10947 return YAFFS_FAIL;
10948 }
10949
10950 -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
10951 - __u8 * data, yaffs_ExtendedTags * tags)
10952 +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
10953 + __u8 *data, yaffs_ExtendedTags *tags)
10954 {
10955 struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
10956 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10957 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
10958 struct mtd_oob_ops ops;
10959 #endif
10960 size_t dummy;
10961 int retval = 0;
10962 + int localData = 0;
10963
10964 - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
10965 + loff_t addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
10966
10967 yaffs_PackedTags2 pt;
10968
10969 @@ -116,9 +115,20 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
10970 ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
10971 TENDSTR), chunkInNAND, data, tags));
10972
10973 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10974 - if (data && !tags)
10975 - retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
10976 + if (dev->inbandTags) {
10977 +
10978 + if (!data) {
10979 + localData = 1;
10980 + data = yaffs_GetTempBuffer(dev, __LINE__);
10981 + }
10982 +
10983 +
10984 + }
10985 +
10986 +
10987 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
10988 + if (dev->inbandTags || (data && !tags))
10989 + retval = mtd->read(mtd, addr, dev->totalBytesPerChunk,
10990 &dummy, data);
10991 else if (tags) {
10992 ops.mode = MTD_OOB_AUTO;
10993 @@ -130,38 +140,42 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
10994 retval = mtd->read_oob(mtd, addr, &ops);
10995 }
10996 #else
10997 - if (data && tags) {
10998 - if (dev->useNANDECC) {
10999 - retval =
11000 - mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
11001 - &dummy, data, dev->spareBuffer,
11002 - NULL);
11003 - } else {
11004 - retval =
11005 - mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
11006 + if (!dev->inbandTags && data && tags) {
11007 +
11008 + retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
11009 &dummy, data, dev->spareBuffer,
11010 NULL);
11011 - }
11012 } else {
11013 if (data)
11014 retval =
11015 mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
11016 data);
11017 - if (tags)
11018 + if (!dev->inbandTags && tags)
11019 retval =
11020 mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
11021 dev->spareBuffer);
11022 }
11023 #endif
11024
11025 - memcpy(&pt, dev->spareBuffer, sizeof(pt));
11026
11027 - if (tags)
11028 - yaffs_UnpackTags2(tags, &pt);
11029 + if (dev->inbandTags) {
11030 + if (tags) {
11031 + yaffs_PackedTags2TagsPart *pt2tp;
11032 + pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
11033 + yaffs_UnpackTags2TagsPart(tags, pt2tp);
11034 + }
11035 + } else {
11036 + if (tags) {
11037 + memcpy(&pt, dev->spareBuffer, sizeof(pt));
11038 + yaffs_UnpackTags2(tags, &pt);
11039 + }
11040 + }
11041
11042 - if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
11043 - tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
11044 + if (localData)
11045 + yaffs_ReleaseTempBuffer(dev, data, __LINE__);
11046
11047 + if (tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
11048 + tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
11049 if (retval == 0)
11050 return YAFFS_OK;
11051 else
11052 @@ -178,7 +192,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaf
11053 retval =
11054 mtd->block_markbad(mtd,
11055 blockNo * dev->nChunksPerBlock *
11056 - dev->nDataBytesPerChunk);
11057 + dev->totalBytesPerChunk);
11058
11059 if (retval == 0)
11060 return YAFFS_OK;
11061 @@ -188,7 +202,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaf
11062 }
11063
11064 int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
11065 - yaffs_BlockState * state, int *sequenceNumber)
11066 + yaffs_BlockState *state, __u32 *sequenceNumber)
11067 {
11068 struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11069 int retval;
11070 @@ -198,7 +212,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs
11071 retval =
11072 mtd->block_isbad(mtd,
11073 blockNo * dev->nChunksPerBlock *
11074 - dev->nDataBytesPerChunk);
11075 + dev->totalBytesPerChunk);
11076
11077 if (retval) {
11078 T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
11079 --- a/fs/yaffs2/yaffs_mtdif2.h
11080 +++ b/fs/yaffs2/yaffs_mtdif2.h
11081 @@ -17,13 +17,13 @@
11082 #define __YAFFS_MTDIF2_H__
11083
11084 #include "yaffs_guts.h"
11085 -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
11086 - const __u8 * data,
11087 - const yaffs_ExtendedTags * tags);
11088 -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
11089 - __u8 * data, yaffs_ExtendedTags * tags);
11090 +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND,
11091 + const __u8 *data,
11092 + const yaffs_ExtendedTags *tags);
11093 +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
11094 + __u8 *data, yaffs_ExtendedTags *tags);
11095 int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
11096 int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
11097 - yaffs_BlockState * state, int *sequenceNumber);
11098 + yaffs_BlockState *state, __u32 *sequenceNumber);
11099
11100 #endif
11101 --- a/fs/yaffs2/yaffs_mtdif.c
11102 +++ b/fs/yaffs2/yaffs_mtdif.c
11103 @@ -12,7 +12,7 @@
11104 */
11105
11106 const char *yaffs_mtdif_c_version =
11107 - "$Id: yaffs_mtdif.c,v 1.19 2007-02-14 01:09:06 wookey Exp $";
11108 + "$Id: yaffs_mtdif.c,v 1.22 2009-03-06 17:20:51 wookey Exp $";
11109
11110 #include "yportenv.h"
11111
11112 @@ -24,7 +24,7 @@ const char *yaffs_mtdif_c_version =
11113 #include "linux/time.h"
11114 #include "linux/mtd/nand.h"
11115
11116 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
11117 +#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 18))
11118 static struct nand_oobinfo yaffs_oobinfo = {
11119 .useecc = 1,
11120 .eccbytes = 6,
11121 @@ -36,7 +36,7 @@ static struct nand_oobinfo yaffs_noeccin
11122 };
11123 #endif
11124
11125 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11126 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11127 static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob)
11128 {
11129 oob[0] = spare->tagByte0;
11130 @@ -45,8 +45,8 @@ static inline void translate_spare2oob(c
11131 oob[3] = spare->tagByte3;
11132 oob[4] = spare->tagByte4;
11133 oob[5] = spare->tagByte5 & 0x3f;
11134 - oob[5] |= spare->blockStatus == 'Y' ? 0: 0x80;
11135 - oob[5] |= spare->pageStatus == 0 ? 0: 0x40;
11136 + oob[5] |= spare->blockStatus == 'Y' ? 0 : 0x80;
11137 + oob[5] |= spare->pageStatus == 0 ? 0 : 0x40;
11138 oob[6] = spare->tagByte6;
11139 oob[7] = spare->tagByte7;
11140 }
11141 @@ -71,18 +71,18 @@ static inline void translate_oob2spare(y
11142 }
11143 #endif
11144
11145 -int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
11146 - const __u8 * data, const yaffs_Spare * spare)
11147 +int nandmtd_WriteChunkToNAND(yaffs_Device *dev, int chunkInNAND,
11148 + const __u8 *data, const yaffs_Spare *spare)
11149 {
11150 struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11151 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11152 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11153 struct mtd_oob_ops ops;
11154 #endif
11155 size_t dummy;
11156 int retval = 0;
11157
11158 loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
11159 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11160 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11161 __u8 spareAsBytes[8]; /* OOB */
11162
11163 if (data && !spare)
11164 @@ -135,18 +135,18 @@ int nandmtd_WriteChunkToNAND(yaffs_Devic
11165 return YAFFS_FAIL;
11166 }
11167
11168 -int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
11169 - yaffs_Spare * spare)
11170 +int nandmtd_ReadChunkFromNAND(yaffs_Device *dev, int chunkInNAND, __u8 *data,
11171 + yaffs_Spare *spare)
11172 {
11173 struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11174 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11175 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11176 struct mtd_oob_ops ops;
11177 #endif
11178 size_t dummy;
11179 int retval = 0;
11180
11181 loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
11182 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11183 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11184 __u8 spareAsBytes[8]; /* OOB */
11185
11186 if (data && !spare)
11187 @@ -205,7 +205,7 @@ int nandmtd_ReadChunkFromNAND(yaffs_Devi
11188 return YAFFS_FAIL;
11189 }
11190
11191 -int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber)
11192 +int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
11193 {
11194 struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11195 __u32 addr =
11196 @@ -234,7 +234,7 @@ int nandmtd_EraseBlockInNAND(yaffs_Devic
11197 return YAFFS_FAIL;
11198 }
11199
11200 -int nandmtd_InitialiseNAND(yaffs_Device * dev)
11201 +int nandmtd_InitialiseNAND(yaffs_Device *dev)
11202 {
11203 return YAFFS_OK;
11204 }
11205 --- a/fs/yaffs2/yaffs_mtdif.h
11206 +++ b/fs/yaffs2/yaffs_mtdif.h
11207 @@ -18,10 +18,15 @@
11208
11209 #include "yaffs_guts.h"
11210
11211 -int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
11212 - const __u8 * data, const yaffs_Spare * spare);
11213 -int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
11214 - yaffs_Spare * spare);
11215 -int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber);
11216 -int nandmtd_InitialiseNAND(yaffs_Device * dev);
11217 +#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 18))
11218 +extern struct nand_oobinfo yaffs_oobinfo;
11219 +extern struct nand_oobinfo yaffs_noeccinfo;
11220 +#endif
11221 +
11222 +int nandmtd_WriteChunkToNAND(yaffs_Device *dev, int chunkInNAND,
11223 + const __u8 *data, const yaffs_Spare *spare);
11224 +int nandmtd_ReadChunkFromNAND(yaffs_Device *dev, int chunkInNAND, __u8 *data,
11225 + yaffs_Spare *spare);
11226 +int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
11227 +int nandmtd_InitialiseNAND(yaffs_Device *dev);
11228 #endif
11229 --- a/fs/yaffs2/yaffs_nand.c
11230 +++ b/fs/yaffs2/yaffs_nand.c
11231 @@ -12,16 +12,17 @@
11232 */
11233
11234 const char *yaffs_nand_c_version =
11235 - "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
11236 + "$Id: yaffs_nand.c,v 1.10 2009-03-06 17:20:54 wookey Exp $";
11237
11238 #include "yaffs_nand.h"
11239 #include "yaffs_tagscompat.h"
11240 #include "yaffs_tagsvalidity.h"
11241
11242 +#include "yaffs_getblockinfo.h"
11243
11244 -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
11245 - __u8 * buffer,
11246 - yaffs_ExtendedTags * tags)
11247 +int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
11248 + __u8 *buffer,
11249 + yaffs_ExtendedTags *tags)
11250 {
11251 int result;
11252 yaffs_ExtendedTags localTags;
11253 @@ -29,7 +30,7 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff
11254 int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
11255
11256 /* If there are no tags provided, use local tags to get prioritised gc working */
11257 - if(!tags)
11258 + if (!tags)
11259 tags = &localTags;
11260
11261 if (dev->readChunkWithTagsFromNAND)
11262 @@ -40,20 +41,20 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff
11263 realignedChunkInNAND,
11264 buffer,
11265 tags);
11266 - if(tags &&
11267 - tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
11268 + if (tags &&
11269 + tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) {
11270
11271 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
11272 - yaffs_HandleChunkError(dev,bi);
11273 + yaffs_HandleChunkError(dev, bi);
11274 }
11275
11276 return result;
11277 }
11278
11279 -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
11280 +int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev,
11281 int chunkInNAND,
11282 - const __u8 * buffer,
11283 - yaffs_ExtendedTags * tags)
11284 + const __u8 *buffer,
11285 + yaffs_ExtendedTags *tags)
11286 {
11287 chunkInNAND -= dev->chunkOffset;
11288
11289 @@ -84,7 +85,7 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs
11290 tags);
11291 }
11292
11293 -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo)
11294 +int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo)
11295 {
11296 blockNo -= dev->blockOffset;
11297
11298 @@ -95,10 +96,10 @@ int yaffs_MarkBlockBad(yaffs_Device * de
11299 return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo);
11300 }
11301
11302 -int yaffs_QueryInitialBlockState(yaffs_Device * dev,
11303 +int yaffs_QueryInitialBlockState(yaffs_Device *dev,
11304 int blockNo,
11305 - yaffs_BlockState * state,
11306 - unsigned *sequenceNumber)
11307 + yaffs_BlockState *state,
11308 + __u32 *sequenceNumber)
11309 {
11310 blockNo -= dev->blockOffset;
11311
11312 --- a/fs/yaffs2/yaffs_nandemul2k.h
11313 +++ b/fs/yaffs2/yaffs_nandemul2k.h
11314 @@ -21,14 +21,14 @@
11315 #include "yaffs_guts.h"
11316
11317 int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
11318 - int chunkInNAND, const __u8 * data,
11319 - yaffs_ExtendedTags * tags);
11320 + int chunkInNAND, const __u8 *data,
11321 + const yaffs_ExtendedTags *tags);
11322 int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev,
11323 - int chunkInNAND, __u8 * data,
11324 - yaffs_ExtendedTags * tags);
11325 + int chunkInNAND, __u8 *data,
11326 + yaffs_ExtendedTags *tags);
11327 int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
11328 int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
11329 - yaffs_BlockState * state, int *sequenceNumber);
11330 + yaffs_BlockState *state, __u32 *sequenceNumber);
11331 int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
11332 int blockInNAND);
11333 int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev);
11334 --- a/fs/yaffs2/yaffs_nand.h
11335 +++ b/fs/yaffs2/yaffs_nand.h
11336 @@ -19,21 +19,21 @@
11337
11338
11339
11340 -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
11341 - __u8 * buffer,
11342 - yaffs_ExtendedTags * tags);
11343 -
11344 -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
11345 - int chunkInNAND,
11346 - const __u8 * buffer,
11347 - yaffs_ExtendedTags * tags);
11348 -
11349 -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo);
11350 -
11351 -int yaffs_QueryInitialBlockState(yaffs_Device * dev,
11352 - int blockNo,
11353 - yaffs_BlockState * state,
11354 - unsigned *sequenceNumber);
11355 +int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
11356 + __u8 *buffer,
11357 + yaffs_ExtendedTags *tags);
11358 +
11359 +int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev,
11360 + int chunkInNAND,
11361 + const __u8 *buffer,
11362 + yaffs_ExtendedTags *tags);
11363 +
11364 +int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo);
11365 +
11366 +int yaffs_QueryInitialBlockState(yaffs_Device *dev,
11367 + int blockNo,
11368 + yaffs_BlockState *state,
11369 + unsigned *sequenceNumber);
11370
11371 int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
11372 int blockInNAND);
11373 --- a/fs/yaffs2/yaffs_packedtags1.c
11374 +++ b/fs/yaffs2/yaffs_packedtags1.c
11375 @@ -14,7 +14,7 @@
11376 #include "yaffs_packedtags1.h"
11377 #include "yportenv.h"
11378
11379 -void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t)
11380 +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t)
11381 {
11382 pt->chunkId = t->chunkId;
11383 pt->serialNumber = t->serialNumber;
11384 @@ -27,7 +27,7 @@ void yaffs_PackTags1(yaffs_PackedTags1 *
11385
11386 }
11387
11388 -void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt)
11389 +void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt)
11390 {
11391 static const __u8 allFF[] =
11392 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
11393 @@ -35,9 +35,8 @@ void yaffs_UnpackTags1(yaffs_ExtendedTag
11394
11395 if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) {
11396 t->blockBad = 0;
11397 - if (pt->shouldBeFF != 0xFFFFFFFF) {
11398 + if (pt->shouldBeFF != 0xFFFFFFFF)
11399 t->blockBad = 1;
11400 - }
11401 t->chunkUsed = 1;
11402 t->objectId = pt->objectId;
11403 t->chunkId = pt->chunkId;
11404 @@ -47,6 +46,5 @@ void yaffs_UnpackTags1(yaffs_ExtendedTag
11405 t->serialNumber = pt->serialNumber;
11406 } else {
11407 memset(t, 0, sizeof(yaffs_ExtendedTags));
11408 -
11409 }
11410 }
11411 --- a/fs/yaffs2/yaffs_packedtags1.h
11412 +++ b/fs/yaffs2/yaffs_packedtags1.h
11413 @@ -32,6 +32,6 @@ typedef struct {
11414
11415 } yaffs_PackedTags1;
11416
11417 -void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t);
11418 -void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt);
11419 +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t);
11420 +void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt);
11421 #endif
11422 --- a/fs/yaffs2/yaffs_packedtags2.c
11423 +++ b/fs/yaffs2/yaffs_packedtags2.c
11424 @@ -37,60 +37,68 @@
11425 #define EXTRA_OBJECT_TYPE_SHIFT (28)
11426 #define EXTRA_OBJECT_TYPE_MASK ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
11427
11428 -static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
11429 +
11430 +static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart *ptt)
11431 {
11432 T(YAFFS_TRACE_MTD,
11433 (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
11434 - pt->t.objectId, pt->t.chunkId, pt->t.byteCount,
11435 - pt->t.sequenceNumber));
11436 + ptt->objectId, ptt->chunkId, ptt->byteCount,
11437 + ptt->sequenceNumber));
11438 +}
11439 +static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt)
11440 +{
11441 + yaffs_DumpPackedTags2TagsPart(&pt->t);
11442 }
11443
11444 -static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
11445 +static void yaffs_DumpTags2(const yaffs_ExtendedTags *t)
11446 {
11447 T(YAFFS_TRACE_MTD,
11448 (TSTR
11449 - ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte "
11450 - "%d del %d ser %d seq %d"
11451 + ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d"
11452 TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId,
11453 t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber,
11454 t->sequenceNumber));
11455
11456 }
11457
11458 -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
11459 +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt,
11460 + const yaffs_ExtendedTags *t)
11461 {
11462 - pt->t.chunkId = t->chunkId;
11463 - pt->t.sequenceNumber = t->sequenceNumber;
11464 - pt->t.byteCount = t->byteCount;
11465 - pt->t.objectId = t->objectId;
11466 + ptt->chunkId = t->chunkId;
11467 + ptt->sequenceNumber = t->sequenceNumber;
11468 + ptt->byteCount = t->byteCount;
11469 + ptt->objectId = t->objectId;
11470
11471 if (t->chunkId == 0 && t->extraHeaderInfoAvailable) {
11472 /* Store the extra header info instead */
11473 /* We save the parent object in the chunkId */
11474 - pt->t.chunkId = EXTRA_HEADER_INFO_FLAG
11475 + ptt->chunkId = EXTRA_HEADER_INFO_FLAG
11476 | t->extraParentObjectId;
11477 - if (t->extraIsShrinkHeader) {
11478 - pt->t.chunkId |= EXTRA_SHRINK_FLAG;
11479 - }
11480 - if (t->extraShadows) {
11481 - pt->t.chunkId |= EXTRA_SHADOWS_FLAG;
11482 - }
11483 + if (t->extraIsShrinkHeader)
11484 + ptt->chunkId |= EXTRA_SHRINK_FLAG;
11485 + if (t->extraShadows)
11486 + ptt->chunkId |= EXTRA_SHADOWS_FLAG;
11487
11488 - pt->t.objectId &= ~EXTRA_OBJECT_TYPE_MASK;
11489 - pt->t.objectId |=
11490 + ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
11491 + ptt->objectId |=
11492 (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT);
11493
11494 - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
11495 - pt->t.byteCount = t->extraEquivalentObjectId;
11496 - } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) {
11497 - pt->t.byteCount = t->extraFileLength;
11498 - } else {
11499 - pt->t.byteCount = 0;
11500 - }
11501 + if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK)
11502 + ptt->byteCount = t->extraEquivalentObjectId;
11503 + else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE)
11504 + ptt->byteCount = t->extraFileLength;
11505 + else
11506 + ptt->byteCount = 0;
11507 }
11508
11509 - yaffs_DumpPackedTags2(pt);
11510 + yaffs_DumpPackedTags2TagsPart(ptt);
11511 yaffs_DumpTags2(t);
11512 +}
11513 +
11514 +
11515 +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t)
11516 +{
11517 + yaffs_PackTags2TagsPart(&pt->t, t);
11518
11519 #ifndef YAFFS_IGNORE_TAGS_ECC
11520 {
11521 @@ -101,82 +109,98 @@ void yaffs_PackTags2(yaffs_PackedTags2 *
11522 #endif
11523 }
11524
11525 -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
11526 +
11527 +void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t,
11528 + yaffs_PackedTags2TagsPart *ptt)
11529 {
11530
11531 memset(t, 0, sizeof(yaffs_ExtendedTags));
11532
11533 yaffs_InitialiseTags(t);
11534
11535 - if (pt->t.sequenceNumber != 0xFFFFFFFF) {
11536 - /* Page is in use */
11537 -#ifdef YAFFS_IGNORE_TAGS_ECC
11538 - {
11539 - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11540 - }
11541 -#else
11542 - {
11543 - yaffs_ECCOther ecc;
11544 - int result;
11545 - yaffs_ECCCalculateOther((unsigned char *)&pt->t,
11546 - sizeof
11547 - (yaffs_PackedTags2TagsPart),
11548 - &ecc);
11549 - result =
11550 - yaffs_ECCCorrectOther((unsigned char *)&pt->t,
11551 - sizeof
11552 - (yaffs_PackedTags2TagsPart),
11553 - &pt->ecc, &ecc);
11554 - switch(result){
11555 - case 0:
11556 - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11557 - break;
11558 - case 1:
11559 - t->eccResult = YAFFS_ECC_RESULT_FIXED;
11560 - break;
11561 - case -1:
11562 - t->eccResult = YAFFS_ECC_RESULT_UNFIXED;
11563 - break;
11564 - default:
11565 - t->eccResult = YAFFS_ECC_RESULT_UNKNOWN;
11566 - }
11567 - }
11568 -#endif
11569 + if (ptt->sequenceNumber != 0xFFFFFFFF) {
11570 t->blockBad = 0;
11571 t->chunkUsed = 1;
11572 - t->objectId = pt->t.objectId;
11573 - t->chunkId = pt->t.chunkId;
11574 - t->byteCount = pt->t.byteCount;
11575 + t->objectId = ptt->objectId;
11576 + t->chunkId = ptt->chunkId;
11577 + t->byteCount = ptt->byteCount;
11578 t->chunkDeleted = 0;
11579 t->serialNumber = 0;
11580 - t->sequenceNumber = pt->t.sequenceNumber;
11581 + t->sequenceNumber = ptt->sequenceNumber;
11582
11583 /* Do extra header info stuff */
11584
11585 - if (pt->t.chunkId & EXTRA_HEADER_INFO_FLAG) {
11586 + if (ptt->chunkId & EXTRA_HEADER_INFO_FLAG) {
11587 t->chunkId = 0;
11588 t->byteCount = 0;
11589
11590 t->extraHeaderInfoAvailable = 1;
11591 t->extraParentObjectId =
11592 - pt->t.chunkId & (~(ALL_EXTRA_FLAGS));
11593 + ptt->chunkId & (~(ALL_EXTRA_FLAGS));
11594 t->extraIsShrinkHeader =
11595 - (pt->t.chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
11596 + (ptt->chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
11597 t->extraShadows =
11598 - (pt->t.chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
11599 + (ptt->chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
11600 t->extraObjectType =
11601 - pt->t.objectId >> EXTRA_OBJECT_TYPE_SHIFT;
11602 + ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT;
11603 t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
11604
11605 - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
11606 - t->extraEquivalentObjectId = pt->t.byteCount;
11607 - } else {
11608 - t->extraFileLength = pt->t.byteCount;
11609 + if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK)
11610 + t->extraEquivalentObjectId = ptt->byteCount;
11611 + else
11612 + t->extraFileLength = ptt->byteCount;
11613 + }
11614 + }
11615 +
11616 + yaffs_DumpPackedTags2TagsPart(ptt);
11617 + yaffs_DumpTags2(t);
11618 +
11619 +}
11620 +
11621 +
11622 +void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt)
11623 +{
11624 +
11625 + yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11626 +
11627 + if (pt->t.sequenceNumber != 0xFFFFFFFF) {
11628 + /* Page is in use */
11629 +#ifndef YAFFS_IGNORE_TAGS_ECC
11630 + {
11631 + yaffs_ECCOther ecc;
11632 + int result;
11633 + yaffs_ECCCalculateOther((unsigned char *)&pt->t,
11634 + sizeof
11635 + (yaffs_PackedTags2TagsPart),
11636 + &ecc);
11637 + result =
11638 + yaffs_ECCCorrectOther((unsigned char *)&pt->t,
11639 + sizeof
11640 + (yaffs_PackedTags2TagsPart),
11641 + &pt->ecc, &ecc);
11642 + switch (result) {
11643 + case 0:
11644 + eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11645 + break;
11646 + case 1:
11647 + eccResult = YAFFS_ECC_RESULT_FIXED;
11648 + break;
11649 + case -1:
11650 + eccResult = YAFFS_ECC_RESULT_UNFIXED;
11651 + break;
11652 + default:
11653 + eccResult = YAFFS_ECC_RESULT_UNKNOWN;
11654 }
11655 }
11656 +#endif
11657 }
11658
11659 + yaffs_UnpackTags2TagsPart(t, &pt->t);
11660 +
11661 + t->eccResult = eccResult;
11662 +
11663 yaffs_DumpPackedTags2(pt);
11664 yaffs_DumpTags2(t);
11665
11666 }
11667 +
11668 --- a/fs/yaffs2/yaffs_packedtags2.h
11669 +++ b/fs/yaffs2/yaffs_packedtags2.h
11670 @@ -33,6 +33,11 @@ typedef struct {
11671 yaffs_ECCOther ecc;
11672 } yaffs_PackedTags2;
11673
11674 -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t);
11675 -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt);
11676 +/* Full packed tags with ECC, used for oob tags */
11677 +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t);
11678 +void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt);
11679 +
11680 +/* Only the tags part (no ECC for use with inband tags */
11681 +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ExtendedTags *t);
11682 +void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t, yaffs_PackedTags2TagsPart *pt);
11683 #endif
11684 --- a/fs/yaffs2/yaffs_qsort.c
11685 +++ b/fs/yaffs2/yaffs_qsort.c
11686 @@ -28,12 +28,12 @@
11687 */
11688
11689 #include "yportenv.h"
11690 -//#include <linux/string.h>
11691 +/* #include <linux/string.h> */
11692
11693 /*
11694 * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
11695 */
11696 -#define swapcode(TYPE, parmi, parmj, n) { \
11697 +#define swapcode(TYPE, parmi, parmj, n) do { \
11698 long i = (n) / sizeof (TYPE); \
11699 register TYPE *pi = (TYPE *) (parmi); \
11700 register TYPE *pj = (TYPE *) (parmj); \
11701 @@ -41,28 +41,29 @@
11702 register TYPE t = *pi; \
11703 *pi++ = *pj; \
11704 *pj++ = t; \
11705 - } while (--i > 0); \
11706 -}
11707 + } while (--i > 0); \
11708 +} while (0)
11709
11710 #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
11711 - es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
11712 + es % sizeof(long) ? 2 : es == sizeof(long) ? 0 : 1;
11713
11714 static __inline void
11715 swapfunc(char *a, char *b, int n, int swaptype)
11716 {
11717 if (swaptype <= 1)
11718 - swapcode(long, a, b, n)
11719 + swapcode(long, a, b, n);
11720 else
11721 - swapcode(char, a, b, n)
11722 + swapcode(char, a, b, n);
11723 }
11724
11725 -#define swap(a, b) \
11726 +#define yswap(a, b) do { \
11727 if (swaptype == 0) { \
11728 long t = *(long *)(a); \
11729 *(long *)(a) = *(long *)(b); \
11730 *(long *)(b) = t; \
11731 } else \
11732 - swapfunc(a, b, es, swaptype)
11733 + swapfunc(a, b, es, swaptype); \
11734 +} while (0)
11735
11736 #define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype)
11737
11738 @@ -70,12 +71,12 @@ static __inline char *
11739 med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
11740 {
11741 return cmp(a, b) < 0 ?
11742 - (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
11743 - :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
11744 + (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a))
11745 + : (cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c));
11746 }
11747
11748 #ifndef min
11749 -#define min(a,b) (((a) < (b)) ? (a) : (b))
11750 +#define min(a, b) (((a) < (b)) ? (a) : (b))
11751 #endif
11752
11753 void
11754 @@ -92,7 +93,7 @@ loop: SWAPINIT(a, es);
11755 for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es)
11756 for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
11757 pl -= es)
11758 - swap(pl, pl - es);
11759 + yswap(pl, pl - es);
11760 return;
11761 }
11762 pm = (char *)a + (n / 2) * es;
11763 @@ -107,7 +108,7 @@ loop: SWAPINIT(a, es);
11764 }
11765 pm = med3(pl, pm, pn, cmp);
11766 }
11767 - swap(a, pm);
11768 + yswap(a, pm);
11769 pa = pb = (char *)a + es;
11770
11771 pc = pd = (char *)a + (n - 1) * es;
11772 @@ -115,7 +116,7 @@ loop: SWAPINIT(a, es);
11773 while (pb <= pc && (r = cmp(pb, a)) <= 0) {
11774 if (r == 0) {
11775 swap_cnt = 1;
11776 - swap(pa, pb);
11777 + yswap(pa, pb);
11778 pa += es;
11779 }
11780 pb += es;
11781 @@ -123,14 +124,14 @@ loop: SWAPINIT(a, es);
11782 while (pb <= pc && (r = cmp(pc, a)) >= 0) {
11783 if (r == 0) {
11784 swap_cnt = 1;
11785 - swap(pc, pd);
11786 + yswap(pc, pd);
11787 pd -= es;
11788 }
11789 pc -= es;
11790 }
11791 if (pb > pc)
11792 break;
11793 - swap(pb, pc);
11794 + yswap(pb, pc);
11795 swap_cnt = 1;
11796 pb += es;
11797 pc -= es;
11798 @@ -139,7 +140,7 @@ loop: SWAPINIT(a, es);
11799 for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
11800 for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
11801 pl -= es)
11802 - swap(pl, pl - es);
11803 + yswap(pl, pl - es);
11804 return;
11805 }
11806
11807 @@ -148,9 +149,11 @@ loop: SWAPINIT(a, es);
11808 vecswap(a, pb - r, r);
11809 r = min((long)(pd - pc), (long)(pn - pd - es));
11810 vecswap(pb, pn - r, r);
11811 - if ((r = pb - pa) > es)
11812 + r = pb - pa;
11813 + if (r > es)
11814 yaffs_qsort(a, r / es, es, cmp);
11815 - if ((r = pd - pc) > es) {
11816 + r = pd - pc;
11817 + if (r > es) {
11818 /* Iterate rather than recurse to save stack space */
11819 a = pn - r;
11820 n = r / es;
11821 --- a/fs/yaffs2/yaffs_qsort.h
11822 +++ b/fs/yaffs2/yaffs_qsort.h
11823 @@ -17,7 +17,7 @@
11824 #ifndef __YAFFS_QSORT_H__
11825 #define __YAFFS_QSORT_H__
11826
11827 -extern void yaffs_qsort (void *const base, size_t total_elems, size_t size,
11828 - int (*cmp)(const void *, const void *));
11829 +extern void yaffs_qsort(void *const base, size_t total_elems, size_t size,
11830 + int (*cmp)(const void *, const void *));
11831
11832 #endif
11833 --- a/fs/yaffs2/yaffs_tagscompat.c
11834 +++ b/fs/yaffs2/yaffs_tagscompat.c
11835 @@ -14,16 +14,17 @@
11836 #include "yaffs_guts.h"
11837 #include "yaffs_tagscompat.h"
11838 #include "yaffs_ecc.h"
11839 +#include "yaffs_getblockinfo.h"
11840
11841 -static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
11842 +static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND);
11843 #ifdef NOTYET
11844 -static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
11845 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
11846 - const __u8 * data,
11847 - const yaffs_Spare * spare);
11848 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
11849 - const yaffs_Spare * spare);
11850 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
11851 +static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND);
11852 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
11853 + const __u8 *data,
11854 + const yaffs_Spare *spare);
11855 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
11856 + const yaffs_Spare *spare);
11857 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND);
11858 #endif
11859
11860 static const char yaffs_countBitsTable[256] = {
11861 @@ -54,13 +55,13 @@ int yaffs_CountBits(__u8 x)
11862
11863 /********** Tags ECC calculations *********/
11864
11865 -void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
11866 +void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare)
11867 {
11868 yaffs_ECCCalculate(data, spare->ecc1);
11869 yaffs_ECCCalculate(&data[256], spare->ecc2);
11870 }
11871
11872 -void yaffs_CalcTagsECC(yaffs_Tags * tags)
11873 +void yaffs_CalcTagsECC(yaffs_Tags *tags)
11874 {
11875 /* Calculate an ecc */
11876
11877 @@ -74,9 +75,8 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags
11878 for (i = 0; i < 8; i++) {
11879 for (j = 1; j & 0xff; j <<= 1) {
11880 bit++;
11881 - if (b[i] & j) {
11882 + if (b[i] & j)
11883 ecc ^= bit;
11884 - }
11885 }
11886 }
11887
11888 @@ -84,7 +84,7 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags
11889
11890 }
11891
11892 -int yaffs_CheckECCOnTags(yaffs_Tags * tags)
11893 +int yaffs_CheckECCOnTags(yaffs_Tags *tags)
11894 {
11895 unsigned ecc = tags->ecc;
11896
11897 @@ -115,8 +115,8 @@ int yaffs_CheckECCOnTags(yaffs_Tags * ta
11898
11899 /********** Tags **********/
11900
11901 -static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
11902 - yaffs_Tags * tagsPtr)
11903 +static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr,
11904 + yaffs_Tags *tagsPtr)
11905 {
11906 yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
11907
11908 @@ -132,8 +132,8 @@ static void yaffs_LoadTagsIntoSpare(yaff
11909 sparePtr->tagByte7 = tu->asBytes[7];
11910 }
11911
11912 -static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
11913 - yaffs_Tags * tagsPtr)
11914 +static void yaffs_GetTagsFromSpare(yaffs_Device *dev, yaffs_Spare *sparePtr,
11915 + yaffs_Tags *tagsPtr)
11916 {
11917 yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
11918 int result;
11919 @@ -148,21 +148,20 @@ static void yaffs_GetTagsFromSpare(yaffs
11920 tu->asBytes[7] = sparePtr->tagByte7;
11921
11922 result = yaffs_CheckECCOnTags(tagsPtr);
11923 - if (result > 0) {
11924 + if (result > 0)
11925 dev->tagsEccFixed++;
11926 - } else if (result < 0) {
11927 + else if (result < 0)
11928 dev->tagsEccUnfixed++;
11929 - }
11930 }
11931
11932 -static void yaffs_SpareInitialise(yaffs_Spare * spare)
11933 +static void yaffs_SpareInitialise(yaffs_Spare *spare)
11934 {
11935 memset(spare, 0xFF, sizeof(yaffs_Spare));
11936 }
11937
11938 static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
11939 - int chunkInNAND, const __u8 * data,
11940 - yaffs_Spare * spare)
11941 + int chunkInNAND, const __u8 *data,
11942 + yaffs_Spare *spare)
11943 {
11944 if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) {
11945 T(YAFFS_TRACE_ERROR,
11946 @@ -177,9 +176,9 @@ static int yaffs_WriteChunkToNAND(struct
11947
11948 static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
11949 int chunkInNAND,
11950 - __u8 * data,
11951 - yaffs_Spare * spare,
11952 - yaffs_ECCResult * eccResult,
11953 + __u8 *data,
11954 + yaffs_Spare *spare,
11955 + yaffs_ECCResult *eccResult,
11956 int doErrorCorrection)
11957 {
11958 int retVal;
11959 @@ -252,9 +251,11 @@ static int yaffs_ReadChunkFromNAND(struc
11960 /* Must allocate enough memory for spare+2*sizeof(int) */
11961 /* for ecc results from device. */
11962 struct yaffs_NANDSpare nspare;
11963 - retVal =
11964 - dev->readChunkFromNAND(dev, chunkInNAND, data,
11965 - (yaffs_Spare *) & nspare);
11966 +
11967 + memset(&nspare, 0, sizeof(nspare));
11968 +
11969 + retVal = dev->readChunkFromNAND(dev, chunkInNAND, data,
11970 + (yaffs_Spare *) &nspare);
11971 memcpy(spare, &nspare, sizeof(yaffs_Spare));
11972 if (data && doErrorCorrection) {
11973 if (nspare.eccres1 > 0) {
11974 @@ -302,8 +303,7 @@ static int yaffs_ReadChunkFromNAND(struc
11975 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
11976 int chunkInNAND)
11977 {
11978 -
11979 - static int init = 0;
11980 + static int init;
11981 static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
11982 static __u8 data[YAFFS_BYTES_PER_CHUNK];
11983 /* Might as well always allocate the larger size for */
11984 @@ -331,12 +331,12 @@ static int yaffs_CheckChunkErased(struct
11985 * Functions for robustisizing
11986 */
11987
11988 -static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
11989 +static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND)
11990 {
11991 int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
11992
11993 /* Mark the block for retirement */
11994 - yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
11995 + yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1;
11996 T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
11997 (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
11998
11999 @@ -348,22 +348,22 @@ static void yaffs_HandleReadDataError(ya
12000 }
12001
12002 #ifdef NOTYET
12003 -static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND)
12004 +static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND)
12005 {
12006 }
12007
12008 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
12009 - const __u8 * data,
12010 - const yaffs_Spare * spare)
12011 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
12012 + const __u8 *data,
12013 + const yaffs_Spare *spare)
12014 {
12015 }
12016
12017 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
12018 - const yaffs_Spare * spare)
12019 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
12020 + const yaffs_Spare *spare)
12021 {
12022 }
12023
12024 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
12025 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND)
12026 {
12027 int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
12028
12029 @@ -373,8 +373,8 @@ static void yaffs_HandleWriteChunkError(
12030 yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
12031 }
12032
12033 -static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
12034 - const yaffs_Spare * s0, const yaffs_Spare * s1)
12035 +static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1,
12036 + const yaffs_Spare *s0, const yaffs_Spare *s1)
12037 {
12038
12039 if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
12040 @@ -398,28 +398,35 @@ static int yaffs_VerifyCompare(const __u
12041 }
12042 #endif /* NOTYET */
12043
12044 -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
12045 - int chunkInNAND,
12046 - const __u8 * data,
12047 - const yaffs_ExtendedTags *
12048 - eTags)
12049 +int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev,
12050 + int chunkInNAND,
12051 + const __u8 *data,
12052 + const yaffs_ExtendedTags *eTags)
12053 {
12054 yaffs_Spare spare;
12055 yaffs_Tags tags;
12056
12057 yaffs_SpareInitialise(&spare);
12058
12059 - if (eTags->chunkDeleted) {
12060 + if (eTags->chunkDeleted)
12061 spare.pageStatus = 0;
12062 - } else {
12063 + else {
12064 tags.objectId = eTags->objectId;
12065 tags.chunkId = eTags->chunkId;
12066 - tags.byteCount = eTags->byteCount;
12067 +
12068 + tags.byteCountLSB = eTags->byteCount & 0x3ff;
12069 +
12070 + if (dev->nDataBytesPerChunk >= 1024)
12071 + tags.byteCountMSB = (eTags->byteCount >> 10) & 3;
12072 + else
12073 + tags.byteCountMSB = 3;
12074 +
12075 +
12076 tags.serialNumber = eTags->serialNumber;
12077
12078 - if (!dev->useNANDECC && data) {
12079 + if (!dev->useNANDECC && data)
12080 yaffs_CalcECC(data, &spare);
12081 - }
12082 +
12083 yaffs_LoadTagsIntoSpare(&spare, &tags);
12084
12085 }
12086 @@ -427,15 +434,15 @@ int yaffs_TagsCompatabilityWriteChunkWit
12087 return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare);
12088 }
12089
12090 -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
12091 +int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev,
12092 int chunkInNAND,
12093 - __u8 * data,
12094 - yaffs_ExtendedTags * eTags)
12095 + __u8 *data,
12096 + yaffs_ExtendedTags *eTags)
12097 {
12098
12099 yaffs_Spare spare;
12100 yaffs_Tags tags;
12101 - yaffs_ECCResult eccResult;
12102 + yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN;
12103
12104 static yaffs_Spare spareFF;
12105 static int init;
12106 @@ -466,7 +473,11 @@ int yaffs_TagsCompatabilityReadChunkWith
12107
12108 eTags->objectId = tags.objectId;
12109 eTags->chunkId = tags.chunkId;
12110 - eTags->byteCount = tags.byteCount;
12111 + eTags->byteCount = tags.byteCountLSB;
12112 +
12113 + if (dev->nDataBytesPerChunk >= 1024)
12114 + eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10);
12115 +
12116 eTags->serialNumber = tags.serialNumber;
12117 }
12118 }
12119 @@ -497,9 +508,9 @@ int yaffs_TagsCompatabilityMarkNANDBlock
12120 }
12121
12122 int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
12123 - int blockNo, yaffs_BlockState *
12124 - state,
12125 - int *sequenceNumber)
12126 + int blockNo,
12127 + yaffs_BlockState *state,
12128 + __u32 *sequenceNumber)
12129 {
12130
12131 yaffs_Spare spare0, spare1;
12132 --- a/fs/yaffs2/yaffs_tagscompat.h
12133 +++ b/fs/yaffs2/yaffs_tagscompat.h
12134 @@ -17,24 +17,23 @@
12135 #define __YAFFS_TAGSCOMPAT_H__
12136
12137 #include "yaffs_guts.h"
12138 -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
12139 - int chunkInNAND,
12140 - const __u8 * data,
12141 - const yaffs_ExtendedTags *
12142 - tags);
12143 -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
12144 - int chunkInNAND,
12145 - __u8 * data,
12146 - yaffs_ExtendedTags *
12147 - tags);
12148 +int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev,
12149 + int chunkInNAND,
12150 + const __u8 *data,
12151 + const yaffs_ExtendedTags *tags);
12152 +int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev,
12153 + int chunkInNAND,
12154 + __u8 *data,
12155 + yaffs_ExtendedTags *tags);
12156 int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
12157 int blockNo);
12158 int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
12159 - int blockNo, yaffs_BlockState *
12160 - state, int *sequenceNumber);
12161 + int blockNo,
12162 + yaffs_BlockState *state,
12163 + __u32 *sequenceNumber);
12164
12165 -void yaffs_CalcTagsECC(yaffs_Tags * tags);
12166 -int yaffs_CheckECCOnTags(yaffs_Tags * tags);
12167 +void yaffs_CalcTagsECC(yaffs_Tags *tags);
12168 +int yaffs_CheckECCOnTags(yaffs_Tags *tags);
12169 int yaffs_CountBits(__u8 byte);
12170
12171 #endif
12172 --- a/fs/yaffs2/yaffs_tagsvalidity.c
12173 +++ b/fs/yaffs2/yaffs_tagsvalidity.c
12174 @@ -13,14 +13,14 @@
12175
12176 #include "yaffs_tagsvalidity.h"
12177
12178 -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags)
12179 +void yaffs_InitialiseTags(yaffs_ExtendedTags *tags)
12180 {
12181 memset(tags, 0, sizeof(yaffs_ExtendedTags));
12182 tags->validMarker0 = 0xAAAAAAAA;
12183 tags->validMarker1 = 0x55555555;
12184 }
12185
12186 -int yaffs_ValidateTags(yaffs_ExtendedTags * tags)
12187 +int yaffs_ValidateTags(yaffs_ExtendedTags *tags)
12188 {
12189 return (tags->validMarker0 == 0xAAAAAAAA &&
12190 tags->validMarker1 == 0x55555555);
12191 --- a/fs/yaffs2/yaffs_tagsvalidity.h
12192 +++ b/fs/yaffs2/yaffs_tagsvalidity.h
12193 @@ -19,6 +19,6 @@
12194
12195 #include "yaffs_guts.h"
12196
12197 -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
12198 -int yaffs_ValidateTags(yaffs_ExtendedTags * tags);
12199 +void yaffs_InitialiseTags(yaffs_ExtendedTags *tags);
12200 +int yaffs_ValidateTags(yaffs_ExtendedTags *tags);
12201 #endif
12202 --- a/fs/yaffs2/yportenv.h
12203 +++ b/fs/yaffs2/yportenv.h
12204 @@ -17,17 +17,28 @@
12205 #ifndef __YPORTENV_H__
12206 #define __YPORTENV_H__
12207
12208 +/*
12209 + * Define the MTD version in terms of Linux Kernel versions
12210 + * This allows yaffs to be used independantly of the kernel
12211 + * as well as with it.
12212 + */
12213 +
12214 +#define MTD_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
12215 +
12216 #if defined CONFIG_YAFFS_WINCE
12217
12218 #include "ywinceenv.h"
12219
12220 -#elif defined __KERNEL__
12221 +#elif defined __KERNEL__
12222
12223 #include "moduleconfig.h"
12224
12225 /* Linux kernel */
12226 +
12227 #include <linux/version.h>
12228 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
12229 +#define MTD_VERSION_CODE LINUX_VERSION_CODE
12230 +
12231 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
12232 #include <linux/config.h>
12233 #endif
12234 #include <linux/kernel.h>
12235 @@ -40,12 +51,13 @@
12236 #define YCHAR char
12237 #define YUCHAR unsigned char
12238 #define _Y(x) x
12239 -#define yaffs_strcpy(a,b) strcpy(a,b)
12240 -#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
12241 -#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
12242 -#define yaffs_strlen(s) strlen(s)
12243 -#define yaffs_sprintf sprintf
12244 -#define yaffs_toupper(a) toupper(a)
12245 +#define yaffs_strcat(a, b) strcat(a, b)
12246 +#define yaffs_strcpy(a, b) strcpy(a, b)
12247 +#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
12248 +#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
12249 +#define yaffs_strlen(s) strlen(s)
12250 +#define yaffs_sprintf sprintf
12251 +#define yaffs_toupper(a) toupper(a)
12252
12253 #define Y_INLINE inline
12254
12255 @@ -53,19 +65,19 @@
12256 #define YAFFS_LOSTNFOUND_PREFIX "obj"
12257
12258 /* #define YPRINTF(x) printk x */
12259 -#define YMALLOC(x) kmalloc(x,GFP_KERNEL)
12260 +#define YMALLOC(x) kmalloc(x, GFP_NOFS)
12261 #define YFREE(x) kfree(x)
12262 #define YMALLOC_ALT(x) vmalloc(x)
12263 #define YFREE_ALT(x) vfree(x)
12264 #define YMALLOC_DMA(x) YMALLOC(x)
12265
12266 -// KR - added for use in scan so processes aren't blocked indefinitely.
12267 +/* KR - added for use in scan so processes aren't blocked indefinitely. */
12268 #define YYIELD() schedule()
12269
12270 #define YAFFS_ROOT_MODE 0666
12271 #define YAFFS_LOSTNFOUND_MODE 0666
12272
12273 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
12274 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
12275 #define Y_CURRENT_TIME CURRENT_TIME.tv_sec
12276 #define Y_TIME_CONVERT(x) (x).tv_sec
12277 #else
12278 @@ -73,11 +85,12 @@
12279 #define Y_TIME_CONVERT(x) (x)
12280 #endif
12281
12282 -#define yaffs_SumCompare(x,y) ((x) == (y))
12283 -#define yaffs_strcmp(a,b) strcmp(a,b)
12284 +#define yaffs_SumCompare(x, y) ((x) == (y))
12285 +#define yaffs_strcmp(a, b) strcmp(a, b)
12286
12287 #define TENDSTR "\n"
12288 #define TSTR(x) KERN_WARNING x
12289 +#define TCONT(x) x
12290 #define TOUT(p) printk p
12291
12292 #define yaffs_trace(mask, fmt, args...) \
12293 @@ -90,6 +103,8 @@
12294
12295 #elif defined CONFIG_YAFFS_DIRECT
12296
12297 +#define MTD_VERSION_CODE MTD_VERSION(2, 6, 22)
12298 +
12299 /* Direct interface */
12300 #include "ydirectenv.h"
12301
12302 @@ -111,11 +126,12 @@
12303 #define YCHAR char
12304 #define YUCHAR unsigned char
12305 #define _Y(x) x
12306 -#define yaffs_strcpy(a,b) strcpy(a,b)
12307 -#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
12308 -#define yaffs_strlen(s) strlen(s)
12309 -#define yaffs_sprintf sprintf
12310 -#define yaffs_toupper(a) toupper(a)
12311 +#define yaffs_strcat(a, b) strcat(a, b)
12312 +#define yaffs_strcpy(a, b) strcpy(a, b)
12313 +#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
12314 +#define yaffs_strlen(s) strlen(s)
12315 +#define yaffs_sprintf sprintf
12316 +#define yaffs_toupper(a) toupper(a)
12317
12318 #define Y_INLINE inline
12319
12320 @@ -133,8 +149,8 @@
12321 #define YAFFS_ROOT_MODE 0666
12322 #define YAFFS_LOSTNFOUND_MODE 0666
12323
12324 -#define yaffs_SumCompare(x,y) ((x) == (y))
12325 -#define yaffs_strcmp(a,b) strcmp(a,b)
12326 +#define yaffs_SumCompare(x, y) ((x) == (y))
12327 +#define yaffs_strcmp(a, b) strcmp(a, b)
12328
12329 #else
12330 /* Should have specified a configuration type */
12331 @@ -178,10 +194,10 @@ extern unsigned int yaffs_wr_attempts;
12332 #define YAFFS_TRACE_ALWAYS 0xF0000000
12333
12334
12335 -#define T(mask,p) do{ if((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p);} while(0)
12336 +#define T(mask, p) do { if ((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0)
12337
12338 -#ifndef CONFIG_YAFFS_WINCE
12339 -#define YBUG() T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__))
12340 +#ifndef YBUG
12341 +#define YBUG() do {T(YAFFS_TRACE_BUG, (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR), __LINE__)); } while (0)
12342 #endif
12343
12344 #endif
Personal OpenWRT clone
This page took 0.623749 seconds and 3 git commands to generate.