yaffs: Redo Lindent
authorCharles Manning <cdhmanning@gmail.com>
Wed, 3 Nov 2010 02:02:10 +0000 (15:02 +1300)
committerCharles Manning <cdhmanning@gmail.com>
Wed, 3 Nov 2010 02:02:43 +0000 (15:02 +1300)
Only applies to Linux files.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>
42 files changed:
moduleconfig.h
yaffs_allocator.c
yaffs_attribs.c
yaffs_attribs.h
yaffs_bitmap.c
yaffs_checkptrw.c
yaffs_checkptrw.h
yaffs_ecc.c
yaffs_ecc.h
yaffs_getblockinfo.h
yaffs_guts.c
yaffs_guts.h
yaffs_linux.h
yaffs_mtdif.c
yaffs_mtdif1.h
yaffs_mtdif1_multi.c
yaffs_mtdif1_single.c
yaffs_mtdif2.h
yaffs_mtdif2_multi.c
yaffs_mtdif2_single.c
yaffs_nameval.c
yaffs_nameval.h
yaffs_nand.c
yaffs_nand.h
yaffs_packedtags1.c
yaffs_packedtags1.h
yaffs_packedtags2.c
yaffs_packedtags2.h
yaffs_tagscompat.c
yaffs_tagscompat.h
yaffs_tagsvalidity.c
yaffs_tagsvalidity.h
yaffs_trace.h
yaffs_verify.c
yaffs_verify.h
yaffs_vfs_multi.c
yaffs_vfs_single.c
yaffs_yaffs1.c
yaffs_yaffs2.c
yaffs_yaffs2.h
yportenv_multi.h
yportenv_single.h

index 4b4d642..20a0882 100644 (file)
@@ -62,7 +62,6 @@
 /* Meaning: Select to disable background processing */
 /* #define CONFIG_DISABLE_BACKGROUND */
 
-
 /* Default: Selected */
 /* Meaning: Enable XATTR support */
 #define CONFIG_YAFFS_XATTR
index 35d8869..03ede86 100644 (file)
@@ -11,8 +11,6 @@
  * published by the Free Software Foundation.
  */
 
-
-
 #include "yaffs_allocator.h"
 #include "yaffs_guts.h"
 #include "yaffs_trace.h"
@@ -54,10 +52,9 @@ void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 {
        dev = dev;
-       return (struct yaffs_obj *) YMALLOC(sizeof(struct yaffs_obj));
+       return (struct yaffs_obj *)YMALLOC(sizeof(struct yaffs_obj));
 }
 
-
 void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
 
@@ -72,13 +69,11 @@ struct yaffs_tnode_list {
        struct yaffs_tnode *tnodes;
 };
 
-
 struct yaffs_obj_list {
        struct yaffs_obj_list *next;
        struct yaffs_obj *objects;
 };
 
-
 struct yaffs_allocator {
        int n_tnodes_created;
        struct yaffs_tnode *free_tnodes;
@@ -92,15 +87,15 @@ struct yaffs_allocator {
        struct yaffs_obj_list *allocated_obj_list;
 };
 
-
 static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
 {
 
-       struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
+       struct yaffs_allocator *allocator =
+           (struct yaffs_allocator *)dev->allocator;
 
        struct yaffs_tnode_list *tmp;
 
-       if(!allocator){
+       if (!allocator) {
                YBUG();
                return;
        }
@@ -123,7 +118,7 @@ static void yaffs_init_raw_tnodes(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
-       if(allocator){
+       if (allocator) {
                allocator->alloc_tnode_list = NULL;
                allocator->free_tnodes = NULL;
                allocator->n_free_tnodes = 0;
@@ -134,7 +129,8 @@ static void yaffs_init_raw_tnodes(struct yaffs_dev *dev)
 
 static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 {
-       struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
+       struct yaffs_allocator *allocator =
+           (struct yaffs_allocator *)dev->allocator;
        int i;
        struct yaffs_tnode *new_tnodes;
        u8 *mem;
@@ -142,7 +138,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
        struct yaffs_tnode *next;
        struct yaffs_tnode_list *tnl;
 
-       if(!allocator){
+       if (!allocator) {
                YBUG();
                return YAFFS_FAIL;
        }
@@ -150,26 +146,25 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
        if (n_tnodes < 1)
                return YAFFS_OK;
 
-
        /* make these things */
 
        new_tnodes = YMALLOC(n_tnodes * dev->tnode_size);
-       mem = (u8 *)new_tnodes;
+       mem = (u8 *) new_tnodes;
 
        if (!new_tnodes) {
                T(YAFFS_TRACE_ERROR,
-                       (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
+                 (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
                return YAFFS_FAIL;
        }
 
        /* New hookup for wide tnodes */
        for (i = 0; i < n_tnodes - 1; i++) {
-               curr = (struct yaffs_tnode *) &mem[i * dev->tnode_size];
-               next = (struct yaffs_tnode *) &mem[(i+1) * dev->tnode_size];
+               curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size];
+               next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size];
                curr->internal[0] = next;
        }
 
-       curr = (struct yaffs_tnode *) &mem[(n_tnodes - 1) * dev->tnode_size];
+       curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size];
        curr->internal[0] = allocator->free_tnodes;
        allocator->free_tnodes = (struct yaffs_tnode *)mem;
 
@@ -186,7 +181,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
                T(YAFFS_TRACE_ERROR,
                  (TSTR
                   ("yaffs: Could not add tnodes to management list" TENDSTR)));
-                  return YAFFS_FAIL;
+               return YAFFS_FAIL;
        } else {
                tnl->tnodes = new_tnodes;
                tnl->next = allocator->alloc_tnode_list;
@@ -198,13 +193,13 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
        return YAFFS_OK;
 }
 
-
 struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
-       struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
+       struct yaffs_allocator *allocator =
+           (struct yaffs_allocator *)dev->allocator;
        struct yaffs_tnode *tn = NULL;
 
-       if(!allocator){
+       if (!allocator) {
                YBUG();
                return NULL;
        }
@@ -227,7 +222,7 @@ void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
-       if(!allocator){
+       if (!allocator) {
                YBUG();
                return;
        }
@@ -237,16 +232,14 @@ void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
                allocator->free_tnodes = tn;
                allocator->n_free_tnodes++;
        }
-       dev->checkpoint_blocks_required = 0; /* force recalculation*/
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */
 }
 
-
-
 static void yaffs_init_raw_objs(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
-       if(allocator) {
+       if (allocator) {
                allocator->allocated_obj_list = NULL;
                allocator->free_objs = NULL;
                allocator->n_free_objects = 0;
@@ -259,7 +252,7 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
        struct yaffs_allocator *allocator = dev->allocator;
        struct yaffs_obj_list *tmp;
 
-       if(!allocator){
+       if (!allocator) {
                YBUG();
                return;
        }
@@ -277,7 +270,6 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
        allocator->n_obj_created = 0;
 }
 
-
 static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
 {
        struct yaffs_allocator *allocator = dev->allocator;
@@ -286,7 +278,7 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
        struct yaffs_obj *new_objs;
        struct yaffs_obj_list *list;
 
-       if(!allocator){
+       if (!allocator) {
                YBUG();
                return YAFFS_FAIL;
        }
@@ -299,11 +291,11 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
        list = YMALLOC(sizeof(struct yaffs_obj_list));
 
        if (!new_objs || !list) {
-               if (new_objs){
+               if (new_objs) {
                        YFREE(new_objs);
                        new_objs = NULL;
                }
-               if (list){
+               if (list) {
                        YFREE(list);
                        list = NULL;
                }
@@ -315,7 +307,7 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
        /* Hook them into the free list */
        for (i = 0; i < n_obj - 1; i++) {
                new_objs[i].siblings.next =
-                               (struct list_head *)(&new_objs[i + 1]);
+                   (struct list_head *)(&new_objs[i + 1]);
        }
 
        new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs;
@@ -337,7 +329,7 @@ struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
        struct yaffs_obj *obj = NULL;
        struct yaffs_allocator *allocator = dev->allocator;
 
-       if(!allocator) {
+       if (!allocator) {
                YBUG();
                return obj;
        }
@@ -349,20 +341,19 @@ struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
        if (allocator->free_objs) {
                obj = allocator->free_objs;
                allocator->free_objs =
-                       (struct yaffs_obj *) (allocator->free_objs->siblings.next);
+                   (struct yaffs_obj *)(allocator->free_objs->siblings.next);
                allocator->n_free_objects--;
        }
 
        return obj;
 }
 
-
 void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
 
        struct yaffs_allocator *allocator = dev->allocator;
 
-       if(!allocator)
+       if (!allocator)
                YBUG();
        else {
                /* Link into the free list. */
@@ -374,12 +365,12 @@ void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 
 void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
-       if(dev->allocator){
+       if (dev->allocator) {
                yaffs_deinit_raw_tnodes(dev);
                yaffs_deinit_raw_objs(dev);
 
                YFREE(dev->allocator);
-               dev->allocator=NULL;
+               dev->allocator = NULL;
        } else
                YBUG();
 }
@@ -388,9 +379,9 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator;
 
-       if(!dev->allocator){
+       if (!dev->allocator) {
                allocator = YMALLOC(sizeof(struct yaffs_allocator));
-               if(allocator){
+               if (allocator) {
                        dev->allocator = allocator;
                        yaffs_init_raw_tnodes(dev);
                        yaffs_init_raw_objs(dev);
@@ -399,5 +390,4 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
                YBUG();
 }
 
-
 #endif
index 651a473..aaf4685 100644 (file)
@@ -11,7 +11,6 @@
  * published by the Free Software Foundation.
  */
 
-
 #include "yaffs_guts.h"
 #include "yaffs_attribs.h"
 
@@ -27,7 +26,7 @@ void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh)
 
 void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj)
 {
-        oh->yst_uid = obj->yst_uid;
+       oh->yst_uid = obj->yst_uid;
        oh->yst_gid = obj->yst_gid;
        oh->yst_atime = obj->yst_atime;
        oh->yst_mtime = obj->yst_mtime;
@@ -38,22 +37,21 @@ void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj)
 
 void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c)
 {
-        obj->yst_mtime = Y_CURRENT_TIME;
-        if(do_a)
-                obj->yst_atime = obj->yst_atime;
-        if(do_c)
-                obj->yst_ctime = obj->yst_atime;
+       obj->yst_mtime = Y_CURRENT_TIME;
+       if (do_a)
+               obj->yst_atime = obj->yst_atime;
+       if (do_c)
+               obj->yst_ctime = obj->yst_atime;
 }
 
 void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev)
 {
-       yaffs_load_current_time(obj,1,1);
+       yaffs_load_current_time(obj, 1, 1);
        obj->yst_rdev = rdev;
        obj->yst_uid = uid;
        obj->yst_gid = gid;
 }
 
-
 loff_t yaffs_get_file_size(struct yaffs_obj *obj)
 {
        YCHAR *alias = NULL;
@@ -64,9 +62,9 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj)
                return obj->variant.file_variant.file_size;
        case YAFFS_OBJECT_TYPE_SYMLINK:
                alias = obj->variant.symlink_variant.alias;
-               if(!alias)
+               if (!alias)
                        return 0;
-               return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
+               return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
        default:
                return 0;
        }
@@ -124,5 +122,3 @@ int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr)
 
        return YAFFS_OK;
 }
-
-
index c9a0867..33d541d 100644 (file)
 #ifndef __YAFFS_ATTRIBS_H__
 #define __YAFFS_ATTRIBS_H__
 
-
 #include "yaffs_guts.h"
 
-
 void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh);
 void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj);
 void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev);
@@ -27,6 +25,4 @@ void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c);
 int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr);
 int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr);
 
-
 #endif
-
index d54a27a..5d1cfb2 100644 (file)
@@ -21,21 +21,21 @@ static Y_INLINE u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
                T(YAFFS_TRACE_ERROR,
-                       (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
-                       blk));
+                 (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
+                  blk));
                YBUG();
        }
        return dev->chunk_bits +
-               (dev->chunk_bit_stride * (blk - dev->internal_start_block));
+           (dev->chunk_bit_stride * (blk - dev->internal_start_block));
 }
 
 void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block ||
-                       chunk < 0 || chunk >= dev->param.chunks_per_block) {
+           chunk < 0 || chunk >= dev->param.chunks_per_block) {
                T(YAFFS_TRACE_ERROR,
-               (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),
-                       blk, chunk));
+                 (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid" TENDSTR),
+                  blk, chunk));
                YBUG();
        }
 }
@@ -102,4 +102,3 @@ int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk)
        }
        return n;
 }
-
index 2991305..2cb144c 100644 (file)
@@ -19,33 +19,36 @@ static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev)
        int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
 
        T(YAFFS_TRACE_CHECKPOINT,
-               (TSTR("checkpt blocks available = %d" TENDSTR),
-               blocks_avail));
+         (TSTR("checkpt blocks available = %d" TENDSTR), blocks_avail));
 
        return (blocks_avail <= 0) ? 0 : 1;
 }
 
-
 static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 {
        int i;
 
        if (!dev->param.erase_fn)
                return 0;
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR),
-               dev->internal_start_block, dev->internal_end_block));
+       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d" TENDSTR),
+                                  dev->internal_start_block,
+                                  dev->internal_end_block));
 
        for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
                struct yaffs_block_info *bi = yaffs_get_block_info(dev, i);
                if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) {
-                       T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i));
+                       T(YAFFS_TRACE_CHECKPOINT,
+                         (TSTR("erasing checkpt block %d" TENDSTR), i));
 
                        dev->n_erasures++;
 
-                       if (dev->param.erase_fn(dev, i - dev->block_offset /* realign */)) {
+                       if (dev->param.
+                           erase_fn(dev,
+                                    i - dev->block_offset /* realign */ )) {
                                bi->block_state = YAFFS_BLOCK_STATE_EMPTY;
                                dev->n_erased_blocks++;
-                               dev->n_free_chunks += dev->param.chunks_per_block;
+                               dev->n_free_chunks +=
+                                   dev->param.chunks_per_block;
                        } else {
                                dev->param.bad_block_fn(dev, i);
                                bi->block_state = YAFFS_BLOCK_STATE_DEAD;
@@ -58,30 +61,35 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev)
        return 1;
 }
 
-
 static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 {
-       int  i;
+       int i;
        int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
        T(YAFFS_TRACE_CHECKPOINT,
-               (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
-               dev->n_erased_blocks, dev->param.n_reserved_blocks, blocks_avail, dev->checkpt_next_block));
+         (TSTR
+          ("allocating checkpt block: erased %d reserved %d avail %d next %d "
+           TENDSTR), dev->n_erased_blocks, dev->param.n_reserved_blocks,
+          blocks_avail, dev->checkpt_next_block));
 
        if (dev->checkpt_next_block >= 0 &&
-                       dev->checkpt_next_block <= dev->internal_end_block &&
-                       blocks_avail > 0) {
+           dev->checkpt_next_block <= dev->internal_end_block &&
+           blocks_avail > 0) {
 
-               for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
-                       struct yaffs_block_info *bi = yaffs_get_block_info(dev, i);
+               for (i = dev->checkpt_next_block; i <= dev->internal_end_block;
+                    i++) {
+                       struct yaffs_block_info *bi =
+                           yaffs_get_block_info(dev, i);
                        if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
                                dev->checkpt_next_block = i + 1;
                                dev->checkpt_cur_block = i;
-                               T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i));
+                               T(YAFFS_TRACE_CHECKPOINT,
+                                 (TSTR("allocating checkpt block %d" TENDSTR),
+                                  i));
                                return;
                        }
                }
        }
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR)));
+       T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks" TENDSTR)));
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
@@ -89,62 +97,67 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 
 static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 {
-       int  i;
+       int i;
        struct yaffs_ext_tags tags;
 
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
-               dev->blocks_in_checkpt, dev->checkpt_next_block));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
+          dev->blocks_in_checkpt, dev->checkpt_next_block));
 
        if (dev->blocks_in_checkpt < dev->checkpt_max_blocks)
-               for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
+               for (i = dev->checkpt_next_block; i <= dev->internal_end_block;
+                    i++) {
                        int chunk = i * dev->param.chunks_per_block;
                        int realigned_chunk = chunk - dev->chunk_offset;
 
                        dev->param.read_chunk_tags_fn(dev, realigned_chunk,
-                                       NULL, &tags);
-                       T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
-                               i, tags.obj_id, tags.seq_number, tags.ecc_result));
+                                                     NULL, &tags);
+                       T(YAFFS_TRACE_CHECKPOINT,
+                         (TSTR
+                          ("find next checkpt block: search: block %d oid %d seq %d eccr %d"
+                           TENDSTR), i, tags.obj_id, tags.seq_number,
+                          tags.ecc_result));
 
                        if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) {
                                /* Right kind of block */
                                dev->checkpt_next_block = tags.obj_id;
                                dev->checkpt_cur_block = i;
-                               dev->checkpt_block_list[dev->blocks_in_checkpt] = i;
+                               dev->checkpt_block_list[dev->
+                                                       blocks_in_checkpt] = i;
                                dev->blocks_in_checkpt++;
-                               T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i));
+                               T(YAFFS_TRACE_CHECKPOINT,
+                                 (TSTR("found checkpt block %d" TENDSTR), i));
                                return;
                        }
                }
 
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR)));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("found no more checkpt blocks" TENDSTR)));
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
 }
 
-
 int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 {
 
-
        dev->checkpt_open_write = writing;
 
        /* Got the functions we need? */
        if (!dev->param.write_chunk_tags_fn ||
-               !dev->param.read_chunk_tags_fn ||
-               !dev->param.erase_fn ||
-               !dev->param.bad_block_fn)
+           !dev->param.read_chunk_tags_fn ||
+           !dev->param.erase_fn || !dev->param.bad_block_fn)
                return 0;
 
        if (writing && !yaffs2_checkpt_space_ok(dev))
                return 0;
 
        if (!dev->checkpt_buffer)
-               dev->checkpt_buffer = YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+               dev->checkpt_buffer =
+                   YMALLOC_DMA(dev->param.total_bytes_per_chunk);
        if (!dev->checkpt_buffer)
                return 0;
 
-
        dev->checkpt_page_seq = 0;
        dev->checkpt_byte_count = 0;
        dev->checkpt_sum = 0;
@@ -165,9 +178,12 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
                /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
                 * going to be way more than we need */
                dev->blocks_in_checkpt = 0;
-               dev->checkpt_max_blocks = (dev->internal_end_block - dev->internal_start_block)/16 + 2;
-               dev->checkpt_block_list = YMALLOC(sizeof(int) * dev->checkpt_max_blocks);
-               if(!dev->checkpt_block_list)
+               dev->checkpt_max_blocks =
+                   (dev->internal_end_block - dev->internal_start_block) / 16 +
+                   2;
+               dev->checkpt_block_list =
+                   YMALLOC(sizeof(int) * dev->checkpt_max_blocks);
+               if (!dev->checkpt_block_list)
                        return 0;
 
                for (i = 0; i < dev->checkpt_max_blocks; i++)
@@ -177,10 +193,10 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
        return 1;
 }
 
-int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 *sum)
+int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum)
 {
        u32 composite_sum;
-       composite_sum =  (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
+       composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
        *sum = composite_sum;
        return 1;
 }
@@ -201,30 +217,35 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
                return 0;
 
        tags.is_deleted = 0;
-       tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */
+       tags.obj_id = dev->checkpt_next_block;  /* Hint to next place to look */
        tags.chunk_id = dev->checkpt_page_seq + 1;
-       tags.seq_number =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
+       tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA;
        tags.n_bytes = dev->data_bytes_per_chunk;
        if (dev->checkpt_cur_chunk == 0) {
                /* First chunk we write for the block? Set block state to
                   checkpoint */
-               struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block);
+               struct yaffs_block_info *bi =
+                   yaffs_get_block_info(dev, dev->checkpt_cur_block);
                bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
                dev->blocks_in_checkpt++;
        }
 
-       chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk;
-
+       chunk =
+           dev->checkpt_cur_block * dev->param.chunks_per_block +
+           dev->checkpt_cur_chunk;
 
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
-               chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR
+          ("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
+          chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id,
+          tags.chunk_id));
 
        realigned_chunk = chunk - dev->chunk_offset;
 
        dev->n_page_writes++;
 
        dev->param.write_chunk_tags_fn(dev, realigned_chunk,
-                       dev->checkpt_buffer, &tags);
+                                      dev->checkpt_buffer, &tags);
        dev->checkpt_byte_offs = 0;
        dev->checkpt_page_seq++;
        dev->checkpt_cur_chunk++;
@@ -237,16 +258,12 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
        return 1;
 }
 
-
 int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
 {
        int i = 0;
        int ok = 1;
 
-
-       u8 * data_bytes = (u8 *)data;
-
-
+       u8 *data_bytes = (u8 *) data;
 
        if (!dev->checkpt_buffer)
                return 0;
@@ -264,9 +281,8 @@ int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
                data_bytes++;
                dev->checkpt_byte_count++;
 
-
                if (dev->checkpt_byte_offs < 0 ||
-                  dev->checkpt_byte_offs >= dev->data_bytes_per_chunk)
+                   dev->checkpt_byte_offs >= dev->data_bytes_per_chunk)
                        ok = yaffs2_checkpt_flush_buffer(dev);
        }
 
@@ -279,11 +295,10 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
        int ok = 1;
        struct yaffs_ext_tags tags;
 
-
        int chunk;
        int realigned_chunk;
 
-       u8 *data_bytes = (u8 *)data;
+       u8 *data_bytes = (u8 *) data;
 
        if (!dev->checkpt_buffer)
                return 0;
@@ -293,9 +308,8 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 
        while (i < n_bytes && ok) {
 
-
                if (dev->checkpt_byte_offs < 0 ||
-                       dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) {
+                   dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) {
 
                        if (dev->checkpt_cur_block < 0) {
                                yaffs2_checkpt_find_block(dev);
@@ -306,35 +320,39 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
                                ok = 0;
                        else {
                                chunk = dev->checkpt_cur_block *
-                                       dev->param.chunks_per_block +
-                                       dev->checkpt_cur_chunk;
+                                   dev->param.chunks_per_block +
+                                   dev->checkpt_cur_chunk;
 
                                realigned_chunk = chunk - dev->chunk_offset;
-                               
+
                                dev->n_page_reads++;
 
                                /* read in the next chunk */
                                dev->param.read_chunk_tags_fn(dev,
-                                               realigned_chunk,
-                                               dev->checkpt_buffer,
-                                               &tags);
-
-                               if (tags.chunk_id != (dev->checkpt_page_seq + 1) ||
-                                       tags.ecc_result > YAFFS_ECC_RESULT_FIXED ||
-                                       tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA)
+                                                             realigned_chunk,
+                                                             dev->
+                                                             checkpt_buffer,
+                                                             &tags);
+
+                               if (tags.chunk_id != (dev->checkpt_page_seq + 1)
+                                   || tags.ecc_result > YAFFS_ECC_RESULT_FIXED
+                                   || tags.seq_number !=
+                                   YAFFS_SEQUENCE_CHECKPOINT_DATA)
                                        ok = 0;
 
                                dev->checkpt_byte_offs = 0;
                                dev->checkpt_page_seq++;
                                dev->checkpt_cur_chunk++;
 
-                               if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block)
+                               if (dev->checkpt_cur_chunk >=
+                                   dev->param.chunks_per_block)
                                        dev->checkpt_cur_block = -1;
                        }
                }
 
                if (ok) {
-                       *data_bytes = dev->checkpt_buffer[dev->checkpt_byte_offs];
+                       *data_bytes =
+                           dev->checkpt_buffer[dev->checkpt_byte_offs];
                        dev->checkpt_sum += *data_bytes;
                        dev->checkpt_xor ^= *data_bytes;
                        dev->checkpt_byte_offs++;
@@ -344,7 +362,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
                }
        }
 
-       return  i;
+       return i;
 }
 
 int yaffs_checkpt_close(struct yaffs_dev *dev)
@@ -353,12 +371,15 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
        if (dev->checkpt_open_write) {
                if (dev->checkpt_byte_offs != 0)
                        yaffs2_checkpt_flush_buffer(dev);
-       } else if(dev->checkpt_block_list){
+       } else if (dev->checkpt_block_list) {
                int i;
-               for (i = 0; i < dev->blocks_in_checkpt && dev->checkpt_block_list[i] >= 0; i++) {
+               for (i = 0;
+                    i < dev->blocks_in_checkpt
+                    && dev->checkpt_block_list[i] >= 0; i++) {
                        int blk = dev->checkpt_block_list[i];
                        struct yaffs_block_info *bi = NULL;
-                       if( dev->internal_start_block <= blk && blk <= dev->internal_end_block)
+                       if (dev->internal_start_block <= blk
+                           && blk <= dev->internal_end_block)
                                bi = yaffs_get_block_info(dev, blk);
                        if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY)
                                bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
@@ -370,12 +391,12 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
                dev->checkpt_block_list = NULL;
        }
 
-       dev->n_free_chunks -= dev->blocks_in_checkpt * dev->param.chunks_per_block;
+       dev->n_free_chunks -=
+           dev->blocks_in_checkpt * dev->param.chunks_per_block;
        dev->n_erased_blocks -= dev->blocks_in_checkpt;
 
-
        T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR),
-                       dev->checkpt_byte_count));
+                                  dev->checkpt_byte_count));
 
        if (dev->checkpt_buffer) {
                /* free the buffer */
@@ -390,11 +411,9 @@ int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
 {
        /* Erase the checkpoint data */
 
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR),
-               dev->blocks_in_checkpt));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("checkpoint invalidate of %d blocks" TENDSTR),
+          dev->blocks_in_checkpt));
 
        return yaffs_checkpt_erase(dev);
 }
-
-
-
index 07ceb36..361c606 100644 (file)
@@ -24,11 +24,10 @@ int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes);
 
 int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes);
 
-int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 *sum);
+int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum);
 
 int yaffs_checkpt_close(struct yaffs_dev *dev);
 
 int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev);
 
-
 #endif
index 290f8d3..0ea0305 100644 (file)
@@ -106,7 +106,7 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc)
                b = column_parity_table[*data++];
                col_parity ^= b;
 
-               if (b & 0x01) {         /* odd number of bits in the byte */
+               if (b & 0x01) { /* odd number of bits in the byte */
                        line_parity ^= i;
                        line_parity_prime ^= ~i;
                }
@@ -160,11 +160,10 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc)
 #endif
 }
 
-
 /* Correct the ECC on a 256 byte block of data */
 
 int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc,
-                    const unsigned char *test_ecc)
+                     const unsigned char *test_ecc)
 {
        unsigned char d0, d1, d2;       /* deltas */
 
@@ -173,7 +172,7 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc,
        d2 = read_ecc[2] ^ test_ecc[2];
 
        if ((d0 | d1 | d2) == 0)
-               return 0; /* no error */
+               return 0;       /* no error */
 
        if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 &&
            ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 &&
@@ -220,19 +219,18 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc,
 
                data[byte] ^= (1 << bit);
 
-               return 1; /* Corrected the error */
+               return 1;       /* Corrected the error */
        }
 
        if ((yaffs_count_bits(d0) +
-            yaffs_count_bits(d1) +
-            yaffs_count_bits(d2)) ==  1) {
+            yaffs_count_bits(d1) + yaffs_count_bits(d2)) == 1) {
                /* Reccoverable error in ecc */
 
                read_ecc[0] = test_ecc[0];
                read_ecc[1] = test_ecc[1];
                read_ecc[2] = test_ecc[2];
 
-               return 1; /* Corrected the error */
+               return 1;       /* Corrected the error */
        }
 
        /* Unrecoverable error */
@@ -241,12 +239,11 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc,
 
 }
 
-
 /*
  * ECCxxxOther does ECC calcs on arbitrary n bytes of data
  */
 void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes,
-                               struct yaffs_ecc_other *ecc_other)
+                         struct yaffs_ecc_other *ecc_other)
 {
        unsigned int i;
 
@@ -259,7 +256,7 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes,
                b = column_parity_table[*data++];
                col_parity ^= b;
 
-               if (b & 0x01)    {
+               if (b & 0x01) {
                        /* odd number of bits in the byte */
                        line_parity ^= i;
                        line_parity_prime ^= ~i;
@@ -273,8 +270,8 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes,
 }
 
 int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes,
-                       struct yaffs_ecc_other *read_ecc,
-                       const struct yaffs_ecc_other *test_ecc)
+                           struct yaffs_ecc_other *read_ecc,
+                           const struct yaffs_ecc_other *test_ecc)
 {
        unsigned char delta_col;        /* column parity delta */
        unsigned delta_line;    /* line parity delta */
@@ -283,10 +280,11 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes,
 
        delta_col = read_ecc->col_parity ^ test_ecc->col_parity;
        delta_line = read_ecc->line_parity ^ test_ecc->line_parity;
-       delta_line_prime = read_ecc->line_parity_prime ^ test_ecc->line_parity_prime;
+       delta_line_prime =
+           read_ecc->line_parity_prime ^ test_ecc->line_parity_prime;
 
        if ((delta_col | delta_line | delta_line_prime) == 0)
-               return 0; /* no error */
+               return 0;       /* no error */
 
        if (delta_line == ~delta_line_prime &&
            (((delta_col ^ (delta_col >> 1)) & 0x15) == 0x15)) {
@@ -306,15 +304,16 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes,
 
                data[delta_line] ^= (1 << bit);
 
-               return 1; /* corrected */
+               return 1;       /* corrected */
        }
 
-       if ((yaffs_count_bits32(delta_line) + yaffs_count_bits32(delta_line_prime) +
-                       yaffs_count_bits(delta_col)) == 1) {
+       if ((yaffs_count_bits32(delta_line) +
+            yaffs_count_bits32(delta_line_prime) +
+            yaffs_count_bits(delta_col)) == 1) {
                /* Reccoverable error in ecc */
 
                *read_ecc = *test_ecc;
-               return 1; /* corrected */
+               return 1;       /* corrected */
        }
 
        /* Unrecoverable error */
index c2d0013..b0c461d 100644 (file)
@@ -30,15 +30,15 @@ struct yaffs_ecc_other {
        unsigned char col_parity;
        unsigned line_parity;
        unsigned line_parity_prime;
-} ;
+};
 
 void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc);
 int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc,
-               const unsigned char *test_ecc);
+                     const unsigned char *test_ecc);
 
 void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes,
-                       struct yaffs_ecc_other *ecc);
+                         struct yaffs_ecc_other *ecc);
 int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes,
-                       struct yaffs_ecc_other *read_ecc,
-                       const struct yaffs_ecc_other *test_ecc);
+                           struct yaffs_ecc_other *read_ecc,
+                           const struct yaffs_ecc_other *test_ecc);
 #endif
index 28bcd54..108c361 100644 (file)
@@ -20,7 +20,8 @@
 #include "yaffs_trace.h"
 
 /* Function to manipulate block info */
-static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev * dev, int blk)
+static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev
+                                                             *dev, int blk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
                T(YAFFS_TRACE_ERROR,
index ce7ed7e..a9fc46c 100644 (file)
 
 #include "yaffs_ecc.h"
 
-
-
 /* Robustification (if it ever comes about...) */
 static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block);
 static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
-               int erased_ok);
+                                       int erased_ok);
 static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
-                               const u8 *data,
-                               const struct yaffs_ext_tags *tags);
+                                    const u8 * data,
+                                    const struct yaffs_ext_tags *tags);
 static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
-                               const struct yaffs_ext_tags *tags);
+                                     const struct yaffs_ext_tags *tags);
 
 /* Other local prototypes */
 static void yaffs_update_parent(struct yaffs_obj *obj);
@@ -59,62 +57,60 @@ static int yaffs_unlink_obj(struct yaffs_obj *obj);
 static int yaffs_obj_cache_dirty(struct yaffs_obj *obj);
 
 static int yaffs_write_new_chunk(struct yaffs_dev *dev,
-                                       const u8 *buffer,
-                                       struct yaffs_ext_tags *tags,
-                                       int use_reserver);
-
+                                const u8 * buffer,
+                                struct yaffs_ext_tags *tags, int use_reserver);
 
 static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
-                                       enum yaffs_obj_type type);
+                                      enum yaffs_obj_type type);
 
-
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod);
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer,
+                                  struct yaffs_xattr_mod *xmod);
 
 static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj);
 static int yaffs_generic_obj_del(struct yaffs_obj *in);
 
-static int yaffs_check_chunk_erased(struct yaffs_dev *dev,
-                               int nand_chunk);
+static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk);
 
 static int yaffs_unlink_worker(struct yaffs_obj *obj);
 
 static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
-                       int chunk_obj);
+                           int chunk_obj);
 
 static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-                               struct yaffs_block_info **block_ptr);
+                            struct yaffs_block_info **block_ptr);
 
 static void yaffs_check_obj_details_loaded(struct yaffs_obj *in);
 
 static void yaffs_invalidate_whole_cache(struct yaffs_obj *in);
-static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id);
+static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object,
+                                        int chunk_id);
 
 static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                               struct yaffs_ext_tags *tags);
+                                   struct yaffs_ext_tags *tags);
 
 static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
-                                       int nand_chunk,
-                                       const u8 *data,
-                                       struct yaffs_ext_tags *tags);
-
-
-static void yaffs_load_name_from_oh(struct yaffs_dev *dev,YCHAR *name, const YCHAR *oh_name, int buff_size);
-static void yaffs_load_oh_from_name(struct yaffs_dev *dev,YCHAR *oh_name, const YCHAR *name);
+                                     int nand_chunk,
+                                     const u8 * data,
+                                     struct yaffs_ext_tags *tags);
 
+static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
+                                   const YCHAR * oh_name, int buff_size);
+static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name,
+                                   const YCHAR * name);
 
 /* Function to calculate chunk and offset */
 
-static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, int *chunk_out,
-               u32 *offset_out)
+static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr,
+                               int *chunk_out, u32 * offset_out)
 {
        int chunk;
        u32 offset;
 
-       chunk  = (u32)(addr >> dev->chunk_shift);
+       chunk = (u32) (addr >> dev->chunk_shift);
 
        if (dev->chunk_div == 1) {
                /* easy power of 2 case */
-               offset = (u32)(addr & dev->chunk_mask);
+               offset = (u32) (addr & dev->chunk_mask);
        } else {
                /* Non power-of-2 case */
 
@@ -122,8 +118,8 @@ static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, int *chunk_o
 
                chunk /= dev->chunk_div;
 
-               chunk_base = ((loff_t)chunk) * dev->data_bytes_per_chunk;
-               offset = (u32)(addr - chunk_base);
+               chunk_base = ((loff_t) chunk) * dev->data_bytes_per_chunk;
+               offset = (u32) (addr - chunk_base);
        }
 
        *chunk_out = chunk;
@@ -163,12 +159,12 @@ static u32 calc_shifts(u32 x)
 {
        u32 shifts;
 
-       shifts =  0;
+       shifts = 0;
 
        if (!x)
                return 0;
 
-       while (!(x&1)) {
+       while (!(x & 1)) {
                x >>= 1;
                shifts++;
        }
@@ -176,8 +172,6 @@ static u32 calc_shifts(u32 x)
        return shifts;
 }
 
-
-
 /*
  * Temporary buffer manipulations.
  */
@@ -185,7 +179,7 @@ static u32 calc_shifts(u32 x)
 static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
 {
        int i;
-       u8 *buf = (u8 *)1;
+       u8 *buf = (u8 *) 1;
 
        memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer));
 
@@ -198,7 +192,7 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
        return buf ? YAFFS_OK : YAFFS_FAIL;
 }
 
-u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no)
+u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
 {
        int i, j;
 
@@ -224,7 +218,8 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no)
          (TSTR("Out of temp buffers at line %d, other held by lines:"),
           line_no));
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-               T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->temp_buffer[i].line));
+               T(YAFFS_TRACE_BUFFERS,
+                 (TSTR(" %d "), dev->temp_buffer[i].line));
 
        T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
 
@@ -238,8 +233,7 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no)
 
 }
 
-void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer,
-                                   int line_no)
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no)
 {
        int i;
 
@@ -266,7 +260,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer,
 /*
  * Determine if we have a managed buffer.
  */
-int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer)
+int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer)
 {
        int i;
 
@@ -284,7 +278,7 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer)
                return 1;
 
        T(YAFFS_TRACE_ALWAYS,
-               (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
+         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
        return 0;
 }
 
@@ -292,9 +286,6 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer)
  * Verification code
  */
 
-
-
-
 /*
  *  Simple hash function. Needs to have a reasonable spread
  */
@@ -320,12 +311,11 @@ struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev)
        return dev->lost_n_found;
 }
 
-
 /*
  *  Erased NAND checking functions
  */
 
-int yaffs_check_ff(u8 *buffer, int n_bytes)
+int yaffs_check_ff(u8 * buffer, int n_bytes)
 {
        /* Horrible, slow implementation */
        while (n_bytes--) {
@@ -336,8 +326,7 @@ int yaffs_check_ff(u8 *buffer, int n_bytes)
        return 1;
 }
 
-static int yaffs_check_chunk_erased(struct yaffs_dev *dev,
-                               int nand_chunk)
+static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
 {
        int retval = YAFFS_OK;
        u8 *data = yaffs_get_temp_buffer(dev, __LINE__);
@@ -361,22 +350,21 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev,
 
 }
 
-
 static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
-                                       int nand_chunk,
-                                       const u8 *data,
-                                       struct yaffs_ext_tags *tags)
+                                     int nand_chunk,
+                                     const u8 * data,
+                                     struct yaffs_ext_tags *tags)
 {
        int retval = YAFFS_OK;
        struct yaffs_ext_tags temp_tags;
-       u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__);
+       u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
        int result;
-       
-       result = yaffs_rd_chunk_tags_nand(dev,nand_chunk,buffer,&temp_tags);
-       if(memcmp(buffer,data,dev->data_bytes_per_chunk) ||
-               temp_tags.obj_id != tags->obj_id ||
-               temp_tags.chunk_id  != tags->chunk_id ||
-               temp_tags.n_bytes != tags->n_bytes)
+
+       result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags);
+       if (memcmp(buffer, data, dev->data_bytes_per_chunk) ||
+           temp_tags.obj_id != tags->obj_id ||
+           temp_tags.chunk_id != tags->chunk_id ||
+           temp_tags.n_bytes != tags->n_bytes)
                retval = YAFFS_FAIL;
 
        yaffs_release_temp_buffer(dev, buffer, __LINE__);
@@ -385,9 +373,8 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
 }
 
 static int yaffs_write_new_chunk(struct yaffs_dev *dev,
-                                       const u8 *data,
-                                       struct yaffs_ext_tags *tags,
-                                       int use_reserver)
+                                const u8 * data,
+                                struct yaffs_ext_tags *tags, int use_reserver)
 {
        int attempts = 0;
        int write_ok = 0;
@@ -411,7 +398,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                 *
                 * Check the first page we try to write in a block.
                 * If the check passes then we don't need to check any
-                * more.        If the check fails, we check again...
+                * more.        If the check fails, we check again...
                 * If the block has been erased, we don't need to check.
                 *
                 * However, if the block has been prioritised for gc,
@@ -432,30 +419,30 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                /* let's give it a try */
                attempts++;
 
-               if(dev->param.always_check_erased)
+               if (dev->param.always_check_erased)
                        bi->skip_erased_check = 0;
 
                if (!bi->skip_erased_check) {
                        erased_ok = yaffs_check_chunk_erased(dev, chunk);
                        if (erased_ok != YAFFS_OK) {
                                T(YAFFS_TRACE_ERROR,
-                               (TSTR("**>> yaffs chunk %d was not erased"
-                               TENDSTR), chunk));
+                                 (TSTR("**>> yaffs chunk %d was not erased"
+                                       TENDSTR), chunk));
 
                                /* If not erased, delete this one,
                                 * skip rest of block and
                                 * try another chunk */
-                                yaffs_chunk_del(dev,chunk,1,__LINE__);
-                                yaffs_skip_rest_of_block(dev);
+                               yaffs_chunk_del(dev, chunk, 1, __LINE__);
+                               yaffs_skip_rest_of_block(dev);
                                continue;
                        }
                }
 
-               write_ok = yaffs_wr_chunk_tags_nand(dev, chunk,
-                               data, tags);
+               write_ok = yaffs_wr_chunk_tags_nand(dev, chunk, data, tags);
 
-               if(!bi->skip_erased_check)
-                       write_ok = yaffs_verify_chunk_written(dev, chunk, data, tags);
+               if (!bi->skip_erased_check)
+                       write_ok =
+                           yaffs_verify_chunk_written(dev, chunk, data, tags);
 
                if (write_ok != YAFFS_OK) {
                        /* Clean up aborted write, skip to next block and
@@ -470,15 +457,15 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                yaffs_handle_chunk_wr_ok(dev, chunk, data, tags);
 
        } while (write_ok != YAFFS_OK &&
-               (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
+                (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
 
        if (!write_ok)
                chunk = -1;
 
        if (attempts > 1) {
                T(YAFFS_TRACE_ERROR,
-                       (TSTR("**>> yaffs write required %d attempts" TENDSTR),
-                       attempts));
+                 (TSTR("**>> yaffs write required %d attempts" TENDSTR),
+                  attempts));
 
                dev->n_retired_writes += (attempts - 1);
        }
@@ -486,8 +473,6 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
        return chunk;
 }
 
-
 /*
  * Block retiring for handling a broken block.
  */
@@ -497,17 +482,19 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
        struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
 
        yaffs2_checkpt_invalidate(dev);
-       
-       yaffs2_clear_oldest_dirty_seq(dev,bi);
+
+       yaffs2_clear_oldest_dirty_seq(dev, bi);
 
        if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) {
                if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) {
-                       T(YAFFS_TRACE_ALWAYS, (TSTR(
-                               "yaffs: Failed to mark bad and erase block %d"
-                               TENDSTR), flash_block));
+                       T(YAFFS_TRACE_ALWAYS,
+                         (TSTR
+                          ("yaffs: Failed to mark bad and erase block %d"
+                           TENDSTR), flash_block));
                } else {
                        struct yaffs_ext_tags tags;
-                       int chunk_id = flash_block * dev->param.chunks_per_block;
+                       int chunk_id =
+                           flash_block * dev->param.chunks_per_block;
 
                        u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
@@ -515,10 +502,14 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
                        yaffs_init_tags(&tags);
                        tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK;
                        if (dev->param.write_chunk_tags_fn(dev, chunk_id -
-                               dev->chunk_offset, buffer, &tags) != YAFFS_OK)
-                               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to "
-                                       TCONT("write bad block marker to block %d")
-                                       TENDSTR), flash_block));
+                                                          dev->chunk_offset,
+                                                          buffer,
+                                                          &tags) != YAFFS_OK)
+                               T(YAFFS_TRACE_ALWAYS,
+                                 (TSTR
+                                  ("yaffs: Failed to "
+                                   TCONT("write bad block marker to block %d")
+                                   TENDSTR), flash_block));
 
                        yaffs_release_temp_buffer(dev, buffer, __LINE__);
                }
@@ -537,24 +528,25 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
  */
 
 static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
-                               const u8 *data,
-                               const struct yaffs_ext_tags *tags)
+                                    const u8 * data,
+                                    const struct yaffs_ext_tags *tags)
 {
-       dev=dev;
-       nand_chunk=nand_chunk;
-       data=data;
-       tags=tags;
+       dev = dev;
+       nand_chunk = nand_chunk;
+       data = data;
+       tags = tags;
 }
 
 static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
-                               const struct yaffs_ext_tags *tags)
+                                     const struct yaffs_ext_tags *tags)
 {
-       dev=dev;
-       nand_chunk=nand_chunk;
-       tags=tags;
+       dev = dev;
+       nand_chunk = nand_chunk;
+       tags = tags;
 }
 
-void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi)
+void yaffs_handle_chunk_error(struct yaffs_dev *dev,
+                             struct yaffs_block_info *bi)
 {
        if (!bi->gc_prioritise) {
                bi->gc_prioritise = 1;
@@ -562,15 +554,16 @@ void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi
                bi->chunk_error_strikes++;
 
                if (bi->chunk_error_strikes > 3) {
-                       bi->needs_retiring = 1; /* Too many stikes, so retire this */
-                       T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
+                       bi->needs_retiring = 1; /* Too many stikes, so retire this */
+                       T(YAFFS_TRACE_ALWAYS,
+                         (TSTR("yaffs: Block struck out" TENDSTR)));
 
                }
        }
 }
 
 static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
-               int erased_ok)
+                                       int erased_ok)
 {
        int flash_block = nand_chunk / dev->param.chunks_per_block;
        struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
@@ -589,17 +582,16 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
        yaffs_skip_rest_of_block(dev);
 }
 
-
 /*---------------- Name handling functions ------------*/
 
-static u16 yaffs_calc_name_sum(const YCHAR *name)
+static u16 yaffs_calc_name_sum(const YCHAR * name)
 {
        u16 sum = 0;
        u16 i = 1;
 
-       const YUCHAR *bname = (const YUCHAR *) name;
+       const YUCHAR *bname = (const YUCHAR *)name;
        if (bname) {
-               while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) {
+               while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH / 2))) {
 
                        /* 0x1f mask is case insensitive */
                        sum += ((*bname) & 0x1f) * i;
@@ -610,11 +602,15 @@ static u16 yaffs_calc_name_sum(const YCHAR *name)
        return sum;
 }
 
-void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name)
+void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
 {
 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
-       memset(obj->short_name, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1));
-       if (name && yaffs_strnlen(name,YAFFS_SHORT_NAME_LENGTH+1) <= YAFFS_SHORT_NAME_LENGTH)
+       memset(obj->short_name, 0,
+              sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH + 1));
+       if (name
+           && yaffs_strnlen(name,
+                            YAFFS_SHORT_NAME_LENGTH + 1) <=
+           YAFFS_SHORT_NAME_LENGTH)
                yaffs_strcpy(obj->short_name, name);
        else
                obj->short_name[0] = _Y('\0');
@@ -622,15 +618,17 @@ void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name)
        obj->sum = yaffs_calc_name_sum(name);
 }
 
-void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hdr *oh)
+void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
+                               const struct yaffs_obj_hdr *oh)
 {
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
-       YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH+1];
-       memset(tmp_name,0,sizeof(tmp_name));
-       yaffs_load_name_from_oh(obj->my_dev,tmp_name,oh->name,YAFFS_MAX_NAME_LENGTH+1);
-       yaffs_set_obj_name(obj,tmp_name);
+       YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH + 1];
+       memset(tmp_name, 0, sizeof(tmp_name));
+       yaffs_load_name_from_oh(obj->my_dev, tmp_name, oh->name,
+                               YAFFS_MAX_NAME_LENGTH + 1);
+       yaffs_set_obj_name(obj, tmp_name);
 #else
-       yaffs_set_obj_name(obj,oh->name);
+       yaffs_set_obj_name(obj, oh->name);
 #endif
 }
 
@@ -641,16 +639,15 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hd
  * in the tnode.
  */
 
-
 struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev)
 {
        struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev);
-       if (tn){
+       if (tn) {
                memset(tn, 0, dev->tnode_size);
                dev->n_tnodes++;
        }
 
-       dev->checkpoint_blocks_required = 0; /* force recalculation*/
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */
 
        return tn;
 }
@@ -658,9 +655,9 @@ struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev)
 /* FreeTnode frees up a tnode and puts it back on the free list */
 static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
 {
-       yaffs_free_raw_tnode(dev,tn);
+       yaffs_free_raw_tnode(dev, tn);
        dev->n_tnodes--;
-       dev->checkpoint_blocks_required = 0; /* force recalculation*/
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */
 }
 
 static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev)
@@ -670,11 +667,10 @@ static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev)
        dev->n_tnodes = 0;
 }
 
-
-void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos,
-               unsigned val)
+void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn,
+                       unsigned pos, unsigned val)
 {
-       u32 *map = (u32 *)tn;
+       u32 *map = (u32 *) tn;
        u32 bit_in_map;
        u32 bit_in_word;
        u32 word_in_map;
@@ -695,16 +691,17 @@ void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned
        if (dev->tnode_width > (32 - bit_in_word)) {
                bit_in_word = (32 - bit_in_word);
                word_in_map++;;
-               mask = dev->tnode_mask >> (/*dev->tnode_width -*/ bit_in_word);
+               mask =
+                   dev->tnode_mask >> ( /*dev->tnode_width - */ bit_in_word);
                map[word_in_map] &= ~mask;
                map[word_in_map] |= (mask & (val >> bit_in_word));
        }
 }
 
 u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
-               unsigned pos)
+                        unsigned pos)
 {
-       u32 *map = (u32 *)tn;
+       u32 *map = (u32 *) tn;
        u32 bit_in_map;
        u32 bit_in_word;
        u32 word_in_map;
@@ -718,7 +715,7 @@ u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
 
        val = map[word_in_map] >> bit_in_word;
 
-       if      (dev->tnode_width > (32 - bit_in_word)) {
+       if (dev->tnode_width > (32 - bit_in_word)) {
                bit_in_word = (32 - bit_in_word);
                word_in_map++;;
                val |= (map[word_in_map] << bit_in_word);
@@ -739,15 +736,15 @@ u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
 
 /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
 struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
-                                       struct yaffs_file_var *file_struct,
-                                       u32 chunk_id)
+                                      struct yaffs_file_var *file_struct,
+                                      u32 chunk_id)
 {
        struct yaffs_tnode *tn = file_struct->top;
        u32 i;
        int required_depth;
        int level = file_struct->top_level;
 
-       dev=dev;
+       dev = dev;
 
        /* Check sane level and chunk Id */
        if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL)
@@ -766,15 +763,15 @@ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
        }
 
        if (required_depth > file_struct->top_level)
-               return NULL; /* Not tall enough, so we can't find it */
+               return NULL;    /* Not tall enough, so we can't find it */
 
        /* Traverse down to level 0 */
        while (level > 0 && tn) {
                tn = tn->internal[(chunk_id >>
-                       (YAFFS_TNODES_LEVEL0_BITS +
-                               (level - 1) *
-                               YAFFS_TNODES_INTERNAL_BITS)) &
-                       YAFFS_TNODES_INTERNAL_MASK];
+                                  (YAFFS_TNODES_LEVEL0_BITS +
+                                   (level - 1) *
+                                   YAFFS_TNODES_INTERNAL_BITS)) &
+                                 YAFFS_TNODES_INTERNAL_MASK];
                level--;
        }
 
@@ -793,9 +790,9 @@ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
  */
 
 struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
-                                       struct yaffs_file_var *file_struct,
-                                       u32 chunk_id,
-                                       struct yaffs_tnode *passed_tn)
+                                          struct yaffs_file_var *file_struct,
+                                          u32 chunk_id,
+                                          struct yaffs_tnode *passed_tn)
 {
        int required_depth;
        int i;
@@ -804,9 +801,9 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
 
        u32 x;
 
-
        /* Check sane level and page Id */
-       if (file_struct->top_level < 0 || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL)
+       if (file_struct->top_level < 0
+           || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL)
                return NULL;
 
        if (chunk_id > YAFFS_MAX_CHUNK_ID)
@@ -821,7 +818,6 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                required_depth++;
        }
 
-
        if (required_depth > file_struct->top_level) {
                /* Not tall enough, gotta make the tree taller */
                for (i = file_struct->top_level; i < required_depth; i++) {
@@ -834,7 +830,7 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                                file_struct->top_level++;
                        } else {
                                T(YAFFS_TRACE_ERROR,
-                                       (TSTR("yaffs: no more tnodes" TENDSTR)));
+                                 (TSTR("yaffs: no more tnodes" TENDSTR)));
                                return NULL;
                        }
                }
@@ -852,24 +848,25 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                              (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) &
                            YAFFS_TNODES_INTERNAL_MASK;
 
-
                        if ((l > 1) && !tn->internal[x]) {
                                /* Add missing non-level-zero tnode */
                                tn->internal[x] = yaffs_get_tnode(dev);
-                               if(!tn->internal[x])
+                               if (!tn->internal[x])
                                        return NULL;
                        } else if (l == 1) {
                                /* Looking from level 1 at level 0 */
                                if (passed_tn) {
-                                       /* If we already have one, then release it.*/
+                                       /* If we already have one, then release it. */
                                        if (tn->internal[x])
-                                               yaffs_free_tnode(dev, tn->internal[x]);
+                                               yaffs_free_tnode(dev,
+                                                                tn->
+                                                                internal[x]);
                                        tn->internal[x] = passed_tn;
 
                                } else if (!tn->internal[x]) {
                                        /* Don't have one, none passed in */
                                        tn->internal[x] = yaffs_get_tnode(dev);
-                                       if(!tn->internal[x])
+                                       if (!tn->internal[x])
                                                return NULL;
                                }
                        }
@@ -880,7 +877,8 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
        } else {
                /* top is level 0 */
                if (passed_tn) {
-                       memcpy(tn, passed_tn, (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8);
+                       memcpy(tn, passed_tn,
+                              (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8);
                        yaffs_free_tnode(dev, passed_tn);
                }
        }
@@ -889,20 +887,21 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
 }
 
 static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
-                               struct yaffs_ext_tags *tags, int obj_id,
-                               int inode_chunk)
+                                    struct yaffs_ext_tags *tags, int obj_id,
+                                    int inode_chunk)
 {
        int j;
 
        for (j = 0; the_chunk && j < dev->chunk_grp_size; j++) {
-               if (yaffs_check_chunk_bit(dev, the_chunk / dev->param.chunks_per_block,
-                               the_chunk % dev->param.chunks_per_block)) {
-                       
-                       if(dev->chunk_grp_size == 1)
+               if (yaffs_check_chunk_bit
+                   (dev, the_chunk / dev->param.chunks_per_block,
+                    the_chunk % dev->param.chunks_per_block)) {
+
+                       if (dev->chunk_grp_size == 1)
                                return the_chunk;
                        else {
                                yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL,
-                                                               tags);
+                                                        tags);
                                if (yaffs_tags_match(tags, obj_id, inode_chunk)) {
                                        /* found it; */
                                        return the_chunk;
@@ -914,7 +913,6 @@ static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
        return -1;
 }
 
-
 static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 {
        struct yaffs_block_info *the_block;
@@ -922,7 +920,7 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 
        T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
 
-       block_no =  chunk / dev->param.chunks_per_block;
+       block_no = chunk / dev->param.chunks_per_block;
        the_block = yaffs_get_block_info(dev, block_no);
        if (the_block) {
                the_block->soft_del_pages++;
@@ -938,7 +936,7 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
  */
 
 static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
-                                 u32 level, int chunk_offset)
+                                u32 level, int chunk_offset)
 {
        int i;
        int the_chunk;
@@ -953,17 +951,17 @@ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
                                if (tn->internal[i]) {
                                        all_done =
                                            yaffs_soft_del_worker(in,
-                                                                  tn->
-                                                                  internal[i],
-                                                                  level - 1,
-                                                                  (chunk_offset
-                                                                   <<
-                                                                   YAFFS_TNODES_INTERNAL_BITS)
-                                                                  + i);
+                                                                 tn->internal
+                                                                 [i],
+                                                                 level - 1,
+                                                                 (chunk_offset
+                                                                  <<
+                                                                  YAFFS_TNODES_INTERNAL_BITS)
+                                                                 + i);
                                        if (all_done) {
                                                yaffs_free_tnode(dev,
-                                                               tn->
-                                                               internal[i]);
+                                                                tn->internal
+                                                                [i]);
                                                tn->internal[i] = NULL;
                                        } else {
                                                /* Hoosterman... how could this happen? */
@@ -1002,7 +1000,7 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj)
                if (obj->n_data_chunks <= 0) {
                        /* Empty file with no duplicate object headers, just delete it immediately */
                        yaffs_free_tnode(obj->my_dev,
-                                       obj->variant.file_variant.top);
+                                        obj->variant.file_variant.top);
                        obj->variant.file_variant.top = NULL;
                        T(YAFFS_TRACE_TRACING,
                          (TSTR("yaffs: Deleting empty file %d" TENDSTR),
@@ -1010,9 +1008,9 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj)
                        yaffs_generic_obj_del(obj);
                } else {
                        yaffs_soft_del_worker(obj,
-                                              obj->variant.file_variant.top,
-                                              obj->variant.file_variant.
-                                              top_level, 0);
+                                             obj->variant.file_variant.top,
+                                             obj->variant.
+                                             file_variant.top_level, 0);
                        obj->soft_del = 1;
                }
        }
@@ -1033,8 +1031,9 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj)
  * If there is no data in a subtree then it is pruned.
  */
 
-static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaffs_tnode *tn,
-                               u32 level, int del0)
+static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev,
+                                             struct yaffs_tnode *tn, u32 level,
+                                             int del0)
 {
        int i;
        int has_data;
@@ -1042,27 +1041,29 @@ static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaff
        if (tn) {
                has_data = 0;
 
-               if(level > 0){
+               if (level > 0) {
                        for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) {
                                if (tn->internal[i]) {
                                        tn->internal[i] =
-                                               yaffs_prune_worker(dev, tn->internal[i],
-                                                       level - 1,
-                                                       (i == 0) ? del0 : 1);
+                                           yaffs_prune_worker(dev,
+                                                              tn->internal[i],
+                                                              level - 1,
+                                                              (i ==
+                                                               0) ? del0 : 1);
                                }
 
                                if (tn->internal[i])
                                        has_data++;
                        }
                } else {
-                       int tnode_size_u32 = dev->tnode_size/sizeof(u32);
-                       u32 *map = (u32 *)tn;
+                       int tnode_size_u32 = dev->tnode_size / sizeof(u32);
+                       u32 *map = (u32 *) tn;
 
-                        for(i = 0; !has_data && i < tnode_size_u32; i++){
-                                if(map[i])
-                                        has_data++;
-                        }
-                }
+                       for (i = 0; !has_data && i < tnode_size_u32; i++) {
+                               if (map[i])
+                                       has_data++;
+                       }
+               }
 
                if (has_data == 0 && del0) {
                        /* Free and return NULL */
@@ -1078,7 +1079,7 @@ static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaff
 }
 
 static int yaffs_prune_tree(struct yaffs_dev *dev,
-                               struct yaffs_file_var *file_struct)
+                           struct yaffs_file_var *file_struct)
 {
        int i;
        int has_data;
@@ -1087,7 +1088,8 @@ static int yaffs_prune_tree(struct yaffs_dev *dev,
 
        if (file_struct->top_level > 0) {
                file_struct->top =
-                   yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0);
+                   yaffs_prune_worker(dev, file_struct->top,
+                                      file_struct->top_level, 0);
 
                /* Now we have a tree with all the non-zero branches NULL but the height
                 * is the same as it was.
@@ -1120,7 +1122,6 @@ static int yaffs_prune_tree(struct yaffs_dev *dev,
 
 /*-------------------- End of File Structure functions.-------------------*/
 
-
 /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */
 static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
 {
@@ -1141,11 +1142,11 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
                INIT_LIST_HEAD(&(obj->hash_link));
                INIT_LIST_HEAD(&obj->siblings);
 
-
                /* Now make the directory sane */
                if (dev->root_dir) {
                        obj->parent = dev->root_dir;
-                       list_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children);
+                       list_add(&(obj->siblings),
+                                &dev->root_dir->variant.dir_variant.children);
                }
 
                /* Add it to the lost and found directory.
@@ -1158,19 +1159,19 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
                obj->being_created = 0;
        }
 
-       dev->checkpoint_blocks_required = 0; /* force recalculation*/
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */
 
        return obj;
 }
 
-static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, int number,
-                                              u32 mode)
+static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev,
+                                              int number, u32 mode)
 {
 
        struct yaffs_obj *obj =
            yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
        if (obj) {
-               obj->fake = 1;          /* it is fake so it might have no NAND presence... */
+               obj->fake = 1;  /* it is fake so it might have no NAND presence... */
                obj->rename_allowed = 0;        /* ... and we're not allowed to rename it... */
                obj->unlink_allowed = 0;        /* ... or unlink it */
                obj->deleted = 0;
@@ -1202,7 +1203,8 @@ static void yaffs_free_obj(struct yaffs_obj *obj)
 {
        struct yaffs_dev *dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->my_inode));
+       T(YAFFS_TRACE_OS,
+         (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode));
 
        if (!obj)
                YBUG();
@@ -1211,7 +1213,6 @@ static void yaffs_free_obj(struct yaffs_obj *obj)
        if (!list_empty(&obj->siblings))
                YBUG();
 
-
        if (obj->my_inode) {
                /* We're still hooked up to a cached inode.
                 * Don't delete now, but mark for later deletion
@@ -1222,12 +1223,11 @@ static void yaffs_free_obj(struct yaffs_obj *obj)
 
        yaffs_unhash_obj(obj);
 
-       yaffs_free_raw_obj(dev,obj);
+       yaffs_free_raw_obj(dev, obj);
        dev->n_obj--;
-       dev->checkpoint_blocks_required = 0; /* force recalculation*/
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */
 }
 
-
 void yaffs_handle_defered_free(struct yaffs_obj *obj)
 {
        if (obj->defered_free)
@@ -1255,7 +1255,6 @@ static int yaffs_find_nice_bucket(struct yaffs_dev *dev)
        int l = 999;
        int lowest = 999999;
 
-
        /* Search for the shortest list or one that
         * isn't too long.
         */
@@ -1295,7 +1294,7 @@ static int yaffs_new_obj_id(struct yaffs_dev *dev)
                        list_for_each(i, &dev->obj_bucket[bucket].list) {
                                /* If there is already one in the list */
                                if (i && list_entry(i, struct yaffs_obj,
-                                               hash_link)->obj_id == n) {
+                                                   hash_link)->obj_id == n) {
                                        found = 0;
                                }
                        }
@@ -1339,9 +1338,9 @@ struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number)
 }
 
 struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
-                                   enum yaffs_obj_type type)
+                               enum yaffs_obj_type type)
 {
-       struct yaffs_obj *the_obj=NULL;
+       struct yaffs_obj *the_obj = NULL;
        struct yaffs_tnode *tn = NULL;
 
        if (number < 0)
@@ -1354,13 +1353,12 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
        }
 
        the_obj = yaffs_alloc_empty_obj(dev);
-       if (!the_obj){
-               if(tn)
-                       yaffs_free_tnode(dev,tn);
+       if (!the_obj) {
+               if (tn)
+                       yaffs_free_tnode(dev, tn);
                return NULL;
        }
 
-
        if (the_obj) {
                the_obj->fake = 0;
                the_obj->rename_allowed = 1;
@@ -1368,21 +1366,19 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
                the_obj->obj_id = number;
                yaffs_hash_obj(the_obj);
                the_obj->variant_type = type;
-               yaffs_load_current_time(the_obj,1,1);
+               yaffs_load_current_time(the_obj, 1, 1);
 
                switch (type) {
                case YAFFS_OBJECT_TYPE_FILE:
                        the_obj->variant.file_variant.file_size = 0;
                        the_obj->variant.file_variant.scanned_size = 0;
-                       the_obj->variant.file_variant.shrink_size = ~0;/* max */
+                       the_obj->variant.file_variant.shrink_size = ~0; /* max */
                        the_obj->variant.file_variant.top_level = 0;
                        the_obj->variant.file_variant.top = tn;
                        break;
                case YAFFS_OBJECT_TYPE_DIRECTORY:
-                       INIT_LIST_HEAD(&the_obj->variant.dir_variant.
-                                       children);
-                       INIT_LIST_HEAD(&the_obj->variant.dir_variant.
-                                       dirty);
+                       INIT_LIST_HEAD(&the_obj->variant.dir_variant.children);
+                       INIT_LIST_HEAD(&the_obj->variant.dir_variant.dirty);
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK:
                case YAFFS_OBJECT_TYPE_HARDLINK:
@@ -1399,8 +1395,8 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
 }
 
 struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
-                                               int number,
-                                               enum yaffs_obj_type type)
+                                                int number,
+                                                enum yaffs_obj_type type)
 {
        struct yaffs_obj *the_obj = NULL;
 
@@ -1414,8 +1410,7 @@ struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
 
 }
 
-
-YCHAR *yaffs_clone_str(const YCHAR *str)
+YCHAR *yaffs_clone_str(const YCHAR * str)
 {
        YCHAR *new_str = NULL;
        int len;
@@ -1423,10 +1418,10 @@ YCHAR *yaffs_clone_str(const YCHAR *str)
        if (!str)
                str = _Y("");
 
-       len = yaffs_strnlen(str,YAFFS_MAX_ALIAS_LENGTH);
+       len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
        new_str = YMALLOC((len + 1) * sizeof(YCHAR));
-       if (new_str){
-               yaffs_strncpy(new_str, str,len);
+       if (new_str) {
+               yaffs_strncpy(new_str, str, len);
                new_str[len] = 0;
        }
        return new_str;
@@ -1441,20 +1436,20 @@ YCHAR *yaffs_clone_str(const YCHAR *str)
  */
 
 static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
-                                      struct yaffs_obj *parent,
-                                      const YCHAR *name,
-                                      u32 mode,
-                                      u32 uid,
-                                      u32 gid,
-                                      struct yaffs_obj *equiv_obj,
-                                      const YCHAR *alias_str, u32 rdev)
+                                         struct yaffs_obj *parent,
+                                         const YCHAR * name,
+                                         u32 mode,
+                                         u32 uid,
+                                         u32 gid,
+                                         struct yaffs_obj *equiv_obj,
+                                         const YCHAR * alias_str, u32 rdev)
 {
        struct yaffs_obj *in;
        YCHAR *str = NULL;
 
        struct yaffs_dev *dev = parent->my_dev;
 
-       /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/
+       /* Check if the entry exists. If it does then fail the call since we don't want a dup. */
        if (yaffs_find_by_name(parent, name))
                return NULL;
 
@@ -1466,16 +1461,12 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
 
        in = yaffs_new_obj(dev, -1, type);
 
-       if (!in){
-               if(str)
+       if (!in) {
+               if (str)
                        YFREE(str);
                return NULL;
        }
 
-
-
-
-
        if (in) {
                in->hdr_chunk = 0;
                in->valid = 1;
@@ -1499,10 +1490,9 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
                        in->variant.symlink_variant.alias = str;
                        break;
                case YAFFS_OBJECT_TYPE_HARDLINK:
-                       in->variant.hardlink_variant.equiv_obj =
-                               equiv_obj;
+                       in->variant.hardlink_variant.equiv_obj = equiv_obj;
                        in->variant.hardlink_variant.equiv_id =
-                               equiv_obj->obj_id;
+                           equiv_obj->obj_id;
                        list_add(&in->hard_links, &equiv_obj->hard_links);
                        break;
                case YAFFS_OBJECT_TYPE_FILE:
@@ -1525,38 +1515,40 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
        return in;
 }
 
-struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, const YCHAR *name,
-                       u32 mode, u32 uid, u32 gid)
+struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent,
+                                   const YCHAR * name, u32 mode, u32 uid,
+                                   u32 gid)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
                                uid, gid, NULL, NULL, 0);
 }
 
-struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name,
-                               u32 mode, u32 uid, u32 gid)
+struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name,
+                                  u32 mode, u32 uid, u32 gid)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
-                                mode, uid, gid, NULL, NULL, 0);
+                               mode, uid, gid, NULL, NULL, 0);
 }
 
-struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, const YCHAR *name,
-                               u32 mode, u32 uid, u32 gid, u32 rdev)
+struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent,
+                                      const YCHAR * name, u32 mode, u32 uid,
+                                      u32 gid, u32 rdev)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
-                                uid, gid, NULL, NULL, rdev);
+                               uid, gid, NULL, NULL, rdev);
 }
 
-struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, const YCHAR *name,
-                               u32 mode, u32 uid, u32 gid,
-                               const YCHAR *alias)
+struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent,
+                                      const YCHAR * name, u32 mode, u32 uid,
+                                      u32 gid, const YCHAR * alias)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode,
                                uid, gid, NULL, alias, 0);
 }
 
 /* yaffs_link_obj returns the object id of the equivalent object.*/
-struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name,
-                       struct yaffs_obj *equiv_obj)
+struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name,
+                                struct yaffs_obj *equiv_obj)
 {
        /* Get the real object in case we were fed a hard link as an equivalent object */
        equiv_obj = yaffs_get_equivalent_obj(equiv_obj);
@@ -1571,8 +1563,9 @@ struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name,
 
 }
 
-static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_dir,
-                               const YCHAR *new_name, int force, int shadows)
+static int yaffs_change_obj_name(struct yaffs_obj *obj,
+                                struct yaffs_obj *new_dir,
+                                const YCHAR * new_name, int force, int shadows)
 {
        int unlink_op;
        int del_op;
@@ -1595,7 +1588,7 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_di
                unlink_op = (new_dir == obj->my_dev->unlinked_dir);
        else
                unlink_op = (new_dir == obj->my_dev->unlinked_dir
-                           && obj->variant_type == YAFFS_OBJECT_TYPE_FILE);
+                            && obj->variant_type == YAFFS_OBJECT_TYPE_FILE);
 
        del_op = (new_dir == obj->my_dev->del_dir);
 
@@ -1621,15 +1614,16 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_di
                        obj->unlinked = 1;
 
                /* If it is a deletion then we mark it as a shrink for gc purposes. */
-               if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= 0)
+               if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >=
+                   0)
                        return YAFFS_OK;
        }
 
        return YAFFS_FAIL;
 }
 
-int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
-               struct yaffs_obj *new_dir, const YCHAR *new_name)
+int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
+                    struct yaffs_obj *new_dir, const YCHAR * new_name)
 {
        struct yaffs_obj *obj = NULL;
        struct yaffs_obj *existing_target = NULL;
@@ -1637,7 +1631,6 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
        int result;
        struct yaffs_dev *dev;
 
-
        if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                YBUG();
        if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
@@ -1649,12 +1642,13 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
        /* Special case for case insemsitive systems.
         * While look-up is case insensitive, the name isn't.
         * Therefore we might want to change x.txt to X.txt
-       */
+        */
        if (old_dir == new_dir && yaffs_strcmp(old_name, new_name) == 0)
                force = 1;
 #endif
 
-       if(yaffs_strnlen(new_name,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH)
+       if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
+           YAFFS_MAX_NAME_LENGTH)
                /* ENAMETOOLONG */
                return YAFFS_FAIL;
 
@@ -1666,8 +1660,9 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
 
                existing_target = yaffs_find_by_name(new_dir, new_name);
                if (existing_target &&
-                       existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
-                       !list_empty(&existing_target->variant.dir_variant.children)) {
+                   existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY
+                   && !list_empty(&existing_target->variant.dir_variant.
+                                  children)) {
                        /* There is a target that is a non-empty directory, so we fail */
                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
                } else if (existing_target && existing_target != obj) {
@@ -1677,20 +1672,20 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
                         * Note we must disable gc otherwise it can mess up the shadowing.
                         *
                         */
-                       dev->gc_disable=1;
+                       dev->gc_disable = 1;
                        yaffs_change_obj_name(obj, new_dir, new_name, force,
-                                               existing_target->obj_id);
+                                             existing_target->obj_id);
                        existing_target->is_shadowed = 1;
                        yaffs_unlink_obj(existing_target);
-                       dev->gc_disable=0;
+                       dev->gc_disable = 0;
                }
 
                result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0);
 
                yaffs_update_parent(old_dir);
-               if(new_dir != old_dir)
+               if (new_dir != old_dir)
                        yaffs_update_parent(new_dir);
-               
+
                return result;
        }
        return YAFFS_FAIL;
@@ -1710,24 +1705,27 @@ static int yaffs_init_blocks(struct yaffs_dev *dev)
        /* If the first allocation strategy fails, thry the alternate one */
        dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info));
        if (!dev->block_info) {
-               dev->block_info = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info));
+               dev->block_info =
+                   YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info));
                dev->block_info_alt = 1;
        } else
                dev->block_info_alt = 0;
 
        if (dev->block_info) {
                /* Set up dynamic blockinfo stuff. */
-               dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */
+               dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8;  /* round up bytes */
                dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * n_blocks);
                if (!dev->chunk_bits) {
-                       dev->chunk_bits = YMALLOC_ALT(dev->chunk_bit_stride * n_blocks);
+                       dev->chunk_bits =
+                           YMALLOC_ALT(dev->chunk_bit_stride * n_blocks);
                        dev->chunk_bits_alt = 1;
                } else
                        dev->chunk_bits_alt = 0;
        }
 
        if (dev->block_info && dev->chunk_bits) {
-               memset(dev->block_info, 0, n_blocks * sizeof(struct yaffs_block_info));
+               memset(dev->block_info, 0,
+                      n_blocks * sizeof(struct yaffs_block_info));
                memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks);
                return YAFFS_OK;
        }
@@ -1765,19 +1763,20 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
         */
 
        T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
-               (TSTR("yaffs_block_became_dirty block %d state %d %s"TENDSTR),
-               block_no, bi->block_state, (bi->needs_retiring) ? "needs retiring" : ""));
+         (TSTR("yaffs_block_became_dirty block %d state %d %s" TENDSTR),
+          block_no, bi->block_state,
+          (bi->needs_retiring) ? "needs retiring" : ""));
 
-       yaffs2_clear_oldest_dirty_seq(dev,bi);
+       yaffs2_clear_oldest_dirty_seq(dev, bi);
 
        bi->block_state = YAFFS_BLOCK_STATE_DIRTY;
 
        /* If this is the block being garbage collected then stop gc'ing this block */
-       if(block_no == dev->gc_block)
+       if (block_no == dev->gc_block)
                dev->gc_block = 0;
 
        /* If this block is currently the best candidate for gc then drop as a candidate */
-       if(block_no == dev->gc_dirtiest){
+       if (block_no == dev->gc_dirtiest) {
                dev->gc_dirtiest = 0;
                dev->gc_pages_in_use = 0;
        }
@@ -1793,7 +1792,8 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
        }
 
        if (erased_ok &&
-           ((yaffs_trace_mask & YAFFS_TRACE_ERASE) || !yaffs_skip_verification(dev))) {
+           ((yaffs_trace_mask & YAFFS_TRACE_ERASE)
+            || !yaffs_skip_verification(dev))) {
                int i;
                for (i = 0; i < dev->param.chunks_per_block; i++) {
                        if (!yaffs_check_chunk_erased
@@ -1814,7 +1814,7 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
                bi->pages_in_use = 0;
                bi->soft_del_pages = 0;
                bi->has_shrink_hdr = 0;
-               bi->skip_erased_check = 1;  /* This is clean, so no need to check */
+               bi->skip_erased_check = 1;      /* This is clean, so no need to check */
                bi->gc_prioritise = 0;
                yaffs_clear_chunk_bits(dev, block_no);
 
@@ -1877,7 +1877,6 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev)
        return -1;
 }
 
-
 /*
  * Check if there's space to allocate...
  * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()?
@@ -1890,13 +1889,14 @@ int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
 
        checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev);
 
-       reserved_chunks = ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block);
+       reserved_chunks =
+           ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block);
 
        return (dev->n_free_chunks > (reserved_chunks + n_chunks));
 }
 
 static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-               struct yaffs_block_info **block_ptr)
+                            struct yaffs_block_info **block_ptr)
 {
        int ret_val;
        struct yaffs_block_info *bi;
@@ -1913,7 +1913,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
        }
 
        if (dev->n_erased_blocks < dev->param.n_reserved_blocks
-                       && dev->alloc_page == 0) {
+           && dev->alloc_page == 0) {
                T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
        }
 
@@ -1922,10 +1922,9 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
                bi = yaffs_get_block_info(dev, dev->alloc_block);
 
                ret_val = (dev->alloc_block * dev->param.chunks_per_block) +
-                       dev->alloc_page;
+                   dev->alloc_page;
                bi->pages_in_use++;
-               yaffs_set_chunk_bit(dev, dev->alloc_block,
-                               dev->alloc_page);
+               yaffs_set_chunk_bit(dev, dev->alloc_block, dev->alloc_page);
 
                dev->alloc_page++;
 
@@ -1944,7 +1943,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
        }
 
        T(YAFFS_TRACE_ERROR,
-                       (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
 
        return -1;
 }
@@ -1968,18 +1967,17 @@ static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
  */
 void yaffs_skip_rest_of_block(struct yaffs_dev *dev)
 {
-       if(dev->alloc_block > 0){
-               struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->alloc_block);
-               if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){
+       if (dev->alloc_block > 0) {
+               struct yaffs_block_info *bi =
+                   yaffs_get_block_info(dev, dev->alloc_block);
+               if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) {
                        bi->block_state = YAFFS_BLOCK_STATE_FULL;
                        dev->alloc_block = -1;
                }
        }
 }
 
-
-static int yaffs_gc_block(struct yaffs_dev *dev, int block,
-               int whole_block)
+static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 {
        int old_chunk;
        int new_chunk;
@@ -2001,29 +1999,26 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
 
        is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT);
 
-
        T(YAFFS_TRACE_TRACING,
-                       (TSTR("Collecting block %d, in use %d, shrink %d, whole_block %d" TENDSTR),
-                        block,
-                        bi->pages_in_use,
-                        bi->has_shrink_hdr,
-                        whole_block));
+         (TSTR
+          ("Collecting block %d, in use %d, shrink %d, whole_block %d"
+           TENDSTR), block, bi->pages_in_use, bi->has_shrink_hdr,
+          whole_block));
 
        /*yaffs_verify_free_chunks(dev); */
 
-       if(bi->block_state == YAFFS_BLOCK_STATE_FULL)
+       if (bi->block_state == YAFFS_BLOCK_STATE_FULL)
                bi->block_state = YAFFS_BLOCK_STATE_COLLECTING;
-       
+
        bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */
 
        dev->gc_disable = 1;
 
-       if (is_checkpt_block ||
-                       !yaffs_still_some_chunks(dev, block)) {
+       if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) {
                T(YAFFS_TRACE_TRACING,
-                               (TSTR
-                                ("Collecting block %d that has no chunks in use" TENDSTR),
-                                block));
+                 (TSTR
+                  ("Collecting block %d that has no chunks in use" TENDSTR),
+                  block));
                yaffs_block_became_dirty(dev, block);
        } else {
 
@@ -2034,12 +2029,11 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                max_copies = (whole_block) ? dev->param.chunks_per_block : 5;
                old_chunk = block * dev->param.chunks_per_block + dev->gc_chunk;
 
-               for (/* init already done */;
+               for ( /* init already done */ ;
                     ret_val == YAFFS_OK &&
                     dev->gc_chunk < dev->param.chunks_per_block &&
                     (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) &&
-                    max_copies > 0;
-                    dev->gc_chunk++, old_chunk++) {
+                    max_copies > 0; dev->gc_chunk++, old_chunk++) {
                        if (yaffs_check_chunk_bit(dev, block, dev->gc_chunk)) {
 
                                /* This page is in use and might need to be copied off */
@@ -2051,30 +2045,35 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                                yaffs_init_tags(&tags);
 
                                yaffs_rd_chunk_tags_nand(dev, old_chunk,
-                                                               buffer, &tags);
+                                                        buffer, &tags);
 
-                               object =
-                                   yaffs_find_by_number(dev,
-                                                            tags.obj_id);
+                               object = yaffs_find_by_number(dev, tags.obj_id);
 
                                T(YAFFS_TRACE_GC_DETAIL,
                                  (TSTR
-                                  ("Collecting chunk in block %d, %d %d %d " TENDSTR),
-                                  dev->gc_chunk, tags.obj_id, tags.chunk_id,
-                                  tags.n_bytes));
+                                  ("Collecting chunk in block %d, %d %d %d "
+                                   TENDSTR), dev->gc_chunk, tags.obj_id,
+                                  tags.chunk_id, tags.n_bytes));
 
                                if (object && !yaffs_skip_verification(dev)) {
                                        if (tags.chunk_id == 0)
-                                               matching_chunk = object->hdr_chunk;
+                                               matching_chunk =
+                                                   object->hdr_chunk;
                                        else if (object->soft_del)
-                                               matching_chunk = old_chunk; /* Defeat the test */
+                                               matching_chunk = old_chunk;     /* Defeat the test */
                                        else
-                                               matching_chunk = yaffs_find_chunk_in_file(object, tags.chunk_id, NULL);
+                                               matching_chunk =
+                                                   yaffs_find_chunk_in_file
+                                                   (object, tags.chunk_id,
+                                                    NULL);
 
                                        if (old_chunk != matching_chunk)
                                                T(YAFFS_TRACE_ERROR,
-                                                 (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
-                                                 old_chunk, matching_chunk, tags.obj_id, tags.chunk_id));
+                                                 (TSTR
+                                                  ("gc: page in gc mismatch: %d %d %d %d"
+                                                   TENDSTR), old_chunk,
+                                                  matching_chunk, tags.obj_id,
+                                                  tags.chunk_id));
 
                                }
 
@@ -2083,19 +2082,19 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                                          (TSTR
                                           ("page %d in gc has no object: %d %d %d "
                                            TENDSTR), old_chunk,
-                                           tags.obj_id, tags.chunk_id, tags.n_bytes));
+                                          tags.obj_id, tags.chunk_id,
+                                          tags.n_bytes));
                                }
 
                                if (object &&
                                    object->deleted &&
-                                   object->soft_del &&
-                                   tags.chunk_id != 0) {
+                                   object->soft_del && tags.chunk_id != 0) {
                                        /* Data chunk in a soft deleted file, throw it away
                                         * It's a soft deleted data chunk,
                                         * No need to copy this, just forget about it and
                                         * fix up the object.
                                         */
-                                        
+
                                        /* Free chunks already includes softdeleted chunks.
                                         * How ever this chunk is going to soon be really deleted
                                         * which will increment free chunks.
@@ -2108,8 +2107,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
 
                                        if (object->n_data_chunks <= 0) {
                                                /* remeber to clean up the object */
-                                               dev->gc_cleanup_list[dev->n_clean_ups] =
-                                                   tags.obj_id;
+                                               dev->gc_cleanup_list[dev->
+                                                                    n_clean_ups]
+                                                   = tags.obj_id;
                                                dev->n_clean_ups++;
                                        }
                                        mark_flash = 0;
@@ -2120,8 +2120,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                                         */
                                        object->hdr_chunk = 0;
                                        yaffs_free_tnode(object->my_dev,
-                                                       object->variant.
-                                                       file_variant.top);
+                                                        object->
+                                                        variant.file_variant.
+                                                        top);
                                        object->variant.file_variant.top = NULL;
                                        yaffs_generic_obj_del(object);
 
@@ -2144,7 +2145,8 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                                                 */
 
                                                struct yaffs_obj_hdr *oh;
-                                               oh = (struct yaffs_obj_hdr *)buffer;
+                                               oh = (struct yaffs_obj_hdr *)
+                                                   buffer;
 
                                                oh->is_shrink = 0;
                                                tags.extra_is_shrink = 0;
@@ -2154,17 +2156,30 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                                                tags.extra_shadows = 0;
 
                                                /* Update file size */
-                                               if(object->variant_type == YAFFS_OBJECT_TYPE_FILE){
-                                                       oh->file_size = object->variant.file_variant.file_size;
-                                                       tags.extra_length = oh->file_size;
+                                               if (object->variant_type ==
+                                                   YAFFS_OBJECT_TYPE_FILE) {
+                                                       oh->file_size =
+                                                           object->variant.
+                                                           file_variant.
+                                                           file_size;
+                                                       tags.extra_length =
+                                                           oh->file_size;
                                                }
 
-                                               yaffs_verify_oh(object, oh, &tags, 1);
+                                               yaffs_verify_oh(object, oh,
+                                                               &tags, 1);
                                                new_chunk =
-                                                   yaffs_write_new_chunk(dev,(u8 *) oh, &tags, 1);
+                                                   yaffs_write_new_chunk(dev,
+                                                                         (u8 *)
+                                                                         oh,
+                                                                         &tags,
+                                                                         1);
                                        } else
                                                new_chunk =
-                                                   yaffs_write_new_chunk(dev, buffer, &tags, 1);
+                                                   yaffs_write_new_chunk(dev,
+                                                                         buffer,
+                                                                         &tags,
+                                                                         1);
 
                                        if (new_chunk < 0) {
                                                ret_val = YAFFS_FAIL;
@@ -2174,35 +2189,31 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
 
                                                if (tags.chunk_id == 0) {
                                                        /* It's a header */
-                                                       object->hdr_chunk =  new_chunk;
-                                                       object->serial =   tags.serial_number;
+                                                       object->hdr_chunk =
+                                                           new_chunk;
+                                                       object->serial =
+                                                           tags.serial_number;
                                                } else {
                                                        /* It's a data chunk */
                                                        int ok;
-                                                       ok = yaffs_put_chunk_in_file
-                                                           (object,
-                                                            tags.chunk_id,
-                                                            new_chunk, 0);
+                                                       ok = yaffs_put_chunk_in_file(object, tags.chunk_id, new_chunk, 0);
                                                }
                                        }
                                }
 
                                if (ret_val == YAFFS_OK)
-                                       yaffs_chunk_del(dev, old_chunk, mark_flash, __LINE__);
+                                       yaffs_chunk_del(dev, old_chunk,
+                                                       mark_flash, __LINE__);
 
                        }
                }
 
                yaffs_release_temp_buffer(dev, buffer, __LINE__);
 
-
-
        }
 
        yaffs_verify_collected_blk(dev, bi, block);
 
-
-
        if (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) {
                /*
                 * The gc did not complete. Set block state back to FULL
@@ -2215,12 +2226,11 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                for (i = 0; i < dev->n_clean_ups; i++) {
                        /* Time to delete the file too */
                        object =
-                           yaffs_find_by_number(dev,
-                                                    dev->gc_cleanup_list[i]);
+                           yaffs_find_by_number(dev, dev->gc_cleanup_list[i]);
                        if (object) {
                                yaffs_free_tnode(dev,
-                                               object->variant.file_variant.
-                                               top);
+                                                object->variant.
+                                                file_variant.top);
                                object->variant.file_variant.top = NULL;
                                T(YAFFS_TRACE_GC,
                                  (TSTR
@@ -2232,7 +2242,6 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
 
                }
 
-
                chunks_after = yaffs_get_erased_chunks(dev);
                if (chunks_before >= chunks_after) {
                        T(YAFFS_TRACE_GC,
@@ -2256,8 +2265,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block,
  */
 
 static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
-                                       int aggressive,
-                                       int background)
+                                   int aggressive, int background)
 {
        int i;
        int iterations;
@@ -2272,13 +2280,12 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
                dev->gc_dirtiest = 0;
                bi = dev->block_info;
                for (i = dev->internal_start_block;
-                       i <= dev->internal_end_block && !selected;
-                       i++) {
+                    i <= dev->internal_end_block && !selected; i++) {
 
                        if (bi->gc_prioritise) {
                                prioritised_exist = 1;
                                if (bi->block_state == YAFFS_BLOCK_STATE_FULL &&
-                                  yaffs_block_ok_for_gc(dev, bi)) {
+                                   yaffs_block_ok_for_gc(dev, bi)) {
                                        selected = i;
                                        prioritised = 1;
                                }
@@ -2292,12 +2299,11 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
                 * up the works. Let's gc the oldest dirty block.
                 */
 
-               if(prioritised_exist &&
-                       !selected &&
-                       dev->oldest_dirty_block > 0)
+               if (prioritised_exist &&
+                   !selected && dev->oldest_dirty_block > 0)
                        selected = dev->oldest_dirty_block;
 
-               if (!prioritised_exist) /* None found, so we can clear this */
+               if (!prioritised_exist) /* None found, so we can clear this */
                        dev->has_pending_prioritised_gc = 0;
        }
 
@@ -2307,28 +2313,28 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
         * block has only a few pages in use.
         */
 
-       if (!selected){
+       if (!selected) {
                int pages_used;
-               int n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
-               if (aggressive){
+               int n_blocks =
+                   dev->internal_end_block - dev->internal_start_block + 1;
+               if (aggressive) {
                        threshold = dev->param.chunks_per_block;
                        iterations = n_blocks;
                } else {
                        int max_threshold;
 
-                       if(background)
-                               max_threshold = dev->param.chunks_per_block/2;
+                       if (background)
+                               max_threshold = dev->param.chunks_per_block / 2;
                        else
-                               max_threshold = dev->param.chunks_per_block/8;
+                               max_threshold = dev->param.chunks_per_block / 8;
 
-                       if(max_threshold <  YAFFS_GC_PASSIVE_THRESHOLD)
+                       if (max_threshold < YAFFS_GC_PASSIVE_THRESHOLD)
                                max_threshold = YAFFS_GC_PASSIVE_THRESHOLD;
 
-                       threshold = background ?
-                               (dev->gc_not_done + 2) * 2 : 0;
-                       if(threshold <YAFFS_GC_PASSIVE_THRESHOLD)
+                       threshold = background ? (dev->gc_not_done + 2) * 2 : 0;
+                       if (threshold < YAFFS_GC_PASSIVE_THRESHOLD)
                                threshold = YAFFS_GC_PASSIVE_THRESHOLD;
-                       if(threshold > max_threshold)
+                       if (threshold > max_threshold)
                                threshold = max_threshold;
 
                        iterations = n_blocks / 16 + 1;
@@ -2337,29 +2343,30 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
                }
 
                for (i = 0;
-                       i < iterations &&
-                       (dev->gc_dirtiest < 1 ||
-                               dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH);
-                       i++) {
+                    i < iterations &&
+                    (dev->gc_dirtiest < 1 ||
+                     dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); i++) {
                        dev->gc_block_finder++;
                        if (dev->gc_block_finder < dev->internal_start_block ||
-                               dev->gc_block_finder > dev->internal_end_block)
-                               dev->gc_block_finder = dev->internal_start_block;
+                           dev->gc_block_finder > dev->internal_end_block)
+                               dev->gc_block_finder =
+                                   dev->internal_start_block;
 
                        bi = yaffs_get_block_info(dev, dev->gc_block_finder);
 
                        pages_used = bi->pages_in_use - bi->soft_del_pages;
 
                        if (bi->block_state == YAFFS_BLOCK_STATE_FULL &&
-                               pages_used < dev->param.chunks_per_block &&
-                               (dev->gc_dirtiest < 1 || pages_used < dev->gc_pages_in_use) &&
-                               yaffs_block_ok_for_gc(dev, bi)) {
+                           pages_used < dev->param.chunks_per_block &&
+                           (dev->gc_dirtiest < 1
+                            || pages_used < dev->gc_pages_in_use)
+                           && yaffs_block_ok_for_gc(dev, bi)) {
                                dev->gc_dirtiest = dev->gc_block_finder;
                                dev->gc_pages_in_use = pages_used;
                        }
                }
 
-               if(dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold)
+               if (dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold)
                        selected = dev->gc_dirtiest;
        }
 
@@ -2368,44 +2375,45 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
         * because that's gumming up the works.
         */
 
-       if(!selected && dev->param.is_yaffs2 &&
-               dev->gc_not_done >= ( background ? 10 : 20)){
+       if (!selected && dev->param.is_yaffs2 &&
+           dev->gc_not_done >= (background ? 10 : 20)) {
                yaffs2_find_oldest_dirty_seq(dev);
-               if(dev->oldest_dirty_block > 0) {
+               if (dev->oldest_dirty_block > 0) {
                        selected = dev->oldest_dirty_block;
                        dev->gc_dirtiest = selected;
                        dev->oldest_dirty_gc_count++;
                        bi = yaffs_get_block_info(dev, selected);
-                       dev->gc_pages_in_use =  bi->pages_in_use - bi->soft_del_pages;
+                       dev->gc_pages_in_use =
+                           bi->pages_in_use - bi->soft_del_pages;
                } else
                        dev->gc_not_done = 0;
        }
 
-       if(selected){
+       if (selected) {
                T(YAFFS_TRACE_GC,
-                 (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR),
-                 selected,
-                 dev->param.chunks_per_block - dev->gc_pages_in_use,
-                 prioritised));
+                 (TSTR
+                  ("GC Selected block %d with %d free, prioritised:%d"
+                   TENDSTR), selected,
+                  dev->param.chunks_per_block - dev->gc_pages_in_use,
+                  prioritised));
 
                dev->n_gc_blocks++;
-               if(background)
+               if (background)
                        dev->bg_gcs++;
 
                dev->gc_dirtiest = 0;
                dev->gc_pages_in_use = 0;
                dev->gc_not_done = 0;
-               if(dev->refresh_skip > 0)
+               if (dev->refresh_skip > 0)
                        dev->refresh_skip--;
-       } else{
+       } else {
                dev->gc_not_done++;
                T(YAFFS_TRACE_GC,
-                 (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR),
-                 dev->gc_block_finder, dev->gc_not_done,
-                 threshold,
-                 dev->gc_dirtiest, dev->gc_pages_in_use,
-                 dev->oldest_dirty_block,
-                 background ? " bg" : ""));
+                 (TSTR
+                  ("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s"
+                   TENDSTR), dev->gc_block_finder, dev->gc_not_done, threshold,
+                  dev->gc_dirtiest, dev->gc_pages_in_use,
+                  dev->oldest_dirty_block, background ? " bg" : ""));
        }
 
        return selected;
@@ -2429,8 +2437,7 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
        int erased_chunks;
        int checkpt_block_adjust;
 
-       if(dev->param.gc_control &&
-               (dev->param.gc_control(dev) & 1) == 0)
+       if (dev->param.gc_control && (dev->param.gc_control(dev) & 1) == 0)
                return YAFFS_OK;
 
        if (dev->gc_disable) {
@@ -2447,21 +2454,23 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
 
                checkpt_block_adjust = yaffs_calc_checkpt_blocks_required(dev);
 
-               min_erased  = dev->param.n_reserved_blocks + checkpt_block_adjust + 1;
-               erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
+               min_erased =
+                   dev->param.n_reserved_blocks + checkpt_block_adjust + 1;
+               erased_chunks =
+                   dev->n_erased_blocks * dev->param.chunks_per_block;
 
-               /* If we need a block soon then do aggressive gc.*/
+               /* If we need a block soon then do aggressive gc. */
                if (dev->n_erased_blocks < min_erased)
                        aggressive = 1;
                else {
-                       if(!background && erased_chunks > (dev->n_free_chunks / 4))
+                       if (!background
+                           && erased_chunks > (dev->n_free_chunks / 4))
                                break;
 
-                       if(dev->gc_skip > 20)
+                       if (dev->gc_skip > 20)
                                dev->gc_skip = 20;
-                       if(erased_chunks < dev->n_free_chunks/2 ||
-                               dev->gc_skip < 1 ||
-                               background)
+                       if (erased_chunks < dev->n_free_chunks / 2 ||
+                           dev->gc_skip < 1 || background)
                                aggressive = 0;
                        else {
                                dev->gc_skip--;
@@ -2471,17 +2480,18 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
 
                dev->gc_skip = 5;
 
-                /* If we don't already have a block being gc'd then see if we should start another */
+               /* If we don't already have a block being gc'd then see if we should start another */
 
                if (dev->gc_block < 1 && !aggressive) {
                        dev->gc_block = yaffs2_find_refresh_block(dev);
                        dev->gc_chunk = 0;
-                       dev->n_clean_ups=0;
+                       dev->n_clean_ups = 0;
                }
                if (dev->gc_block < 1) {
-                       dev->gc_block = yaffs_find_gc_block(dev, aggressive, background);
+                       dev->gc_block =
+                           yaffs_find_gc_block(dev, aggressive, background);
                        dev->gc_chunk = 0;
-                       dev->n_clean_ups=0;
+                       dev->n_clean_ups = 0;
                }
 
                if (dev->gc_block > 0) {
@@ -2491,21 +2501,22 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
 
                        T(YAFFS_TRACE_GC,
                          (TSTR
-                          ("yaffs: GC n_erased_blocks %d aggressive %d" TENDSTR),
-                          dev->n_erased_blocks, aggressive));
+                          ("yaffs: GC n_erased_blocks %d aggressive %d"
+                           TENDSTR), dev->n_erased_blocks, aggressive));
 
                        gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive);
                }
 
-               if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && dev->gc_block > 0) {
+               if (dev->n_erased_blocks < (dev->param.n_reserved_blocks)
+                   && dev->gc_block > 0) {
                        T(YAFFS_TRACE_GC,
                          (TSTR
                           ("yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d"
-                           TENDSTR), dev->n_erased_blocks, max_tries, dev->gc_block));
+                           TENDSTR), dev->n_erased_blocks, max_tries,
+                          dev->gc_block));
                }
        } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) &&
-                (dev->gc_block > 0) &&
-                (max_tries < 2));
+                (dev->gc_block > 0) && (max_tries < 2));
 
        return aggressive ? gc_ok : YAFFS_OK;
 }
@@ -2519,27 +2530,26 @@ int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency)
 {
        int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
 
-       T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency));
+       T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR), urgency));
 
        yaffs_check_gc(dev, 1);
-       return erased_chunks > dev->n_free_chunks/2;
+       return erased_chunks > dev->n_free_chunks / 2;
 }
 
 /*-------------------------  TAGS --------------------------------*/
 
 static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
-                          int chunk_obj)
+                           int chunk_obj)
 {
        return (tags->chunk_id == chunk_obj &&
                tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0;
 
 }
 
-
 /*-------------------- Data file manipulation -----------------*/
 
 static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                                struct yaffs_ext_tags *tags)
+                                   struct yaffs_ext_tags *tags)
 {
        /*Get the Tnode, then get the level 0 offset chunk offset */
        struct yaffs_tnode *tn;
@@ -2561,13 +2571,13 @@ static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
 
                ret_val =
                    yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
-                                          inode_chunk);
+                                             inode_chunk);
        }
        return ret_val;
 }
 
 static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk,
-                                         struct yaffs_ext_tags *tags)
+                                    struct yaffs_ext_tags *tags)
 {
        /* Get the Tnode, then get the level 0 offset chunk offset */
        struct yaffs_tnode *tn;
@@ -2590,7 +2600,7 @@ static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk,
 
                ret_val =
                    yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
-                                          inode_chunk);
+                                             inode_chunk);
 
                /* Delete the entry in the filestructure (if found) */
                if (ret_val != -1)
@@ -2600,9 +2610,8 @@ static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk,
        return ret_val;
 }
 
-
 int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                               int nand_chunk, int in_scan)
+                           int nand_chunk, int in_scan)
 {
        /* NB in_scan is zero unless scanning.
         * For forward scanning, in_scan is > 0;
@@ -2635,13 +2644,12 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
        }
 
        tn = yaffs_add_find_tnode_0(dev,
-                                       &in->variant.file_variant,
-                                       inode_chunk,
-                                       NULL);
+                                   &in->variant.file_variant,
+                                   inode_chunk, NULL);
        if (!tn)
                return YAFFS_FAIL;
-       
-       if(!nand_chunk)
+
+       if (!nand_chunk)
                /* Dummy insert, bail now */
                return YAFFS_OK;
 
@@ -2671,13 +2679,13 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
                        if (in_scan > 0) {
                                /* Only do this for forward scanning */
                                yaffs_rd_chunk_tags_nand(dev,
-                                                               nand_chunk,
-                                                               NULL, &new_tags);
+                                                        nand_chunk,
+                                                        NULL, &new_tags);
 
                                /* Do a proper find */
                                existing_cunk =
                                    yaffs_find_chunk_in_file(in, inode_chunk,
-                                                         &existing_tags);
+                                                            &existing_tags);
                        }
 
                        if (existing_cunk <= 0) {
@@ -2707,14 +2715,13 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
                                 * Delete the old one and drop through to update the tnode
                                 */
                                yaffs_chunk_del(dev, existing_cunk, 1,
-                                                 __LINE__);
+                                               __LINE__);
                        } else {
                                /* Backward scanning or we want to use the existing one
                                 * Use existing.
                                 * Delete the new one and return early so that the tnode isn't changed
                                 */
-                               yaffs_chunk_del(dev, nand_chunk, 1,
-                                                 __LINE__);
+                               yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
                                return YAFFS_OK;
                        }
                }
@@ -2729,8 +2736,7 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
        return YAFFS_OK;
 }
 
-static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk,
-                                       u8 *buffer)
+static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer)
 {
        int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL);
 
@@ -2748,7 +2754,8 @@ static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk,
 
 }
 
-void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int lyn)
+void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
+                    int lyn)
 {
        int block;
        int page;
@@ -2762,14 +2769,12 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int ly
        block = chunk_id / dev->param.chunks_per_block;
        page = chunk_id % dev->param.chunks_per_block;
 
-
        if (!yaffs_check_chunk_bit(dev, block, page))
                T(YAFFS_TRACE_VERIFY,
-                       (TSTR("Deleting invalid chunk %d"TENDSTR),
-                        chunk_id));
+                 (TSTR("Deleting invalid chunk %d" TENDSTR), chunk_id));
 
        bi = yaffs_get_block_info(dev, block);
-       
+
        yaffs2_update_oldest_dirty_seq(dev, block, bi);
 
        T(YAFFS_TRACE_DELETION,
@@ -2813,8 +2818,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int ly
 }
 
 static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
-                                       const u8 *buffer, int n_bytes,
-                                       int use_reserve)
+                            const u8 * buffer, int n_bytes, int use_reserve)
 {
        /* Find old chunk Need to do this to get serial number
         * Write new one and patch into tree.
@@ -2829,15 +2833,15 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 
        struct yaffs_dev *dev = in->my_dev;
 
-       yaffs_check_gc(dev,0);
+       yaffs_check_gc(dev, 0);
 
        /* Get the previous chunk at this location in the file if it exists.
         * If it does not exist then put a zero into the tree. This creates
         * the tnode now, rather than later when it is harder to clean up.
         */
        prev_chunk_id = yaffs_find_chunk_in_file(in, inode_chunk, &prev_tags);
-       if(prev_chunk_id < 1 &&
-               !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0))
+       if (prev_chunk_id < 1 &&
+           !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0))
                return 0;
 
        /* Set up new tags */
@@ -2851,14 +2855,13 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 
        if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) {
                T(YAFFS_TRACE_ERROR,
-               (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), n_bytes));
+                 (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR),
+                  n_bytes));
                YBUG();
        }
-       
-               
+
        new_chunk_id =
-           yaffs_write_new_chunk(dev, buffer, &new_tags,
-                                             use_reserve);
+           yaffs_write_new_chunk(dev, buffer, &new_tags, use_reserve);
 
        if (new_chunk_id > 0) {
                yaffs_put_chunk_in_file(in, inode_chunk, new_chunk_id, 0);
@@ -2875,8 +2878,8 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 /* UpdateObjectHeader updates the header on NAND for an object.
  * If name is not NULL, then that new name is used.
  */
-int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
-                            int is_shrink, int shadows, struct yaffs_xattr_mod *xmod)
+int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
+                   int is_shrink, int shadows, struct yaffs_xattr_mod *xmod)
 {
 
        struct yaffs_block_info *bi;
@@ -2899,22 +2902,20 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 
        yaffs_strcpy(old_name, _Y("silly old name"));
 
+       if (!in->fake || in == dev->root_dir || /* The root_dir should also be saved */
+           force || xmod) {
 
-       if (!in->fake ||
-               in == dev->root_dir || /* The root_dir should also be saved */
-               force  || xmod) {
-
-               yaffs_check_gc(dev,0);
+               yaffs_check_gc(dev, 0);
                yaffs_check_obj_details_loaded(in);
 
                buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__);
-               oh = (struct yaffs_obj_hdr *) buffer;
+               oh = (struct yaffs_obj_hdr *)buffer;
 
                prev_chunk_id = in->hdr_chunk;
 
                if (prev_chunk_id > 0) {
                        result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id,
-                                                       buffer, &old_tags);
+                                                         buffer, &old_tags);
 
                        yaffs_verify_oh(in, oh, &old_tags, 0);
 
@@ -2927,7 +2928,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                oh->yst_mode = in->yst_mode;
                oh->shadows_obj = oh->inband_shadowed_obj_id = shadows;
 
-               yaffs_load_attribs_oh(oh,in);
+               yaffs_load_attribs_oh(oh, in);
 
                if (in->parent)
                        oh->parent_obj_id = in->parent->obj_id;
@@ -2936,7 +2937,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 
                if (name && *name) {
                        memset(oh->name, 0, sizeof(oh->name));
-                       yaffs_load_oh_from_name(dev,oh->name,name);
+                       yaffs_load_oh_from_name(dev, oh->name, name);
                } else if (prev_chunk_id > 0)
                        memcpy(oh->name, old_name, sizeof(oh->name));
                else
@@ -2952,12 +2953,11 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                        oh->file_size =
                            (oh->parent_obj_id == YAFFS_OBJECTID_DELETED
                             || oh->parent_obj_id ==
-                            YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant.
-                           file_variant.file_size;
+                            YAFFS_OBJECTID_UNLINKED) ? 0 : in->
+                           variant.file_variant.file_size;
                        break;
                case YAFFS_OBJECT_TYPE_HARDLINK:
-                       oh->equiv_id =
-                           in->variant.hardlink_variant.equiv_id;
+                       oh->equiv_id = in->variant.hardlink_variant.equiv_id;
                        break;
                case YAFFS_OBJECT_TYPE_SPECIAL:
                        /* Do nothing */
@@ -2967,20 +2967,17 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK:
                        alias = in->variant.symlink_variant.alias;
-                       if(!alias)
+                       if (!alias)
                                alias = _Y("no alias");
-                       yaffs_strncpy(oh->alias,
-                                       alias,
-                                     YAFFS_MAX_ALIAS_LENGTH);
+                       yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
                        oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
                        break;
                }
 
                /* process any xattrib modifications */
-               if(xmod)
+               if (xmod)
                        yaffs_apply_xattrib_mod(in, (char *)buffer, xmod);
 
-
                /* Tags */
                yaffs_init_tags(&new_tags);
                in->serial++;
@@ -3003,7 +3000,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                /* Create new chunk in NAND */
                new_chunk_id =
                    yaffs_write_new_chunk(dev, buffer, &new_tags,
-                                                     (prev_chunk_id > 0) ? 1 : 0);
+                                         (prev_chunk_id > 0) ? 1 : 0);
 
                if (new_chunk_id >= 0) {
 
@@ -3011,7 +3008,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 
                        if (prev_chunk_id > 0) {
                                yaffs_chunk_del(dev, prev_chunk_id, 1,
-                                                 __LINE__);
+                                               __LINE__);
                        }
 
                        if (!yaffs_obj_cache_dirty(in))
@@ -3020,7 +3017,9 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                        /* If this was a shrink, then mark the block that the chunk lives on */
                        if (is_shrink) {
                                bi = yaffs_get_block_info(in->my_dev,
-                                       new_chunk_id / in->my_dev->param.chunks_per_block);
+                                                         new_chunk_id /
+                                                         in->my_dev->param.
+                                                         chunks_per_block);
                                bi->has_shrink_hdr = 1;
                        }
 
@@ -3058,15 +3057,13 @@ static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
 
        for (i = 0; i < n_caches; i++) {
                cache = &dev->cache[i];
-               if (cache->object == obj &&
-                   cache->dirty)
+               if (cache->object == obj && cache->dirty)
                        return 1;
        }
 
        return 0;
 }
 
-
 static void yaffs_flush_file_cache(struct yaffs_obj *obj)
 {
        struct yaffs_dev *dev = obj->my_dev;
@@ -3098,10 +3095,9 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj)
 
                                chunk_written =
                                    yaffs_wr_data_obj(cache->object,
-                                                                cache->chunk_id,
-                                                                cache->data,
-                                                                cache->n_bytes,
-                                                                1);
+                                                     cache->chunk_id,
+                                                     cache->data,
+                                                     cache->n_bytes, 1);
                                cache->dirty = 0;
                                cache->object = NULL;
                        }
@@ -3111,7 +3107,9 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj)
                if (cache) {
                        /* Hoosterman, disk full while writing cache out. */
                        T(YAFFS_TRACE_ERROR,
-                         (TSTR("yaffs tragedy: no space during cache write" TENDSTR)));
+                         (TSTR
+                          ("yaffs tragedy: no space during cache write"
+                           TENDSTR)));
 
                }
        }
@@ -3135,8 +3133,7 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev)
        do {
                obj = NULL;
                for (i = 0; i < n_caches && !obj; i++) {
-                       if (dev->cache[i].object &&
-                           dev->cache[i].dirty)
+                       if (dev->cache[i].object && dev->cache[i].dirty)
                                obj = dev->cache[i].object;
 
                }
@@ -3147,7 +3144,6 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev)
 
 }
 
-
 /* Grab us a cache chunk for use.
  * First look for an empty one.
  * Then look for the least recently used non-dirty one.
@@ -3197,7 +3193,8 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
                        for (i = 0; i < dev->param.n_caches; i++) {
                                if (dev->cache[i].object &&
                                    !dev->cache[i].locked &&
-                                   (dev->cache[i].last_use < usage || !cache)) {
+                                   (dev->cache[i].last_use < usage
+                                    || !cache)) {
                                        usage = dev->cache[i].last_use;
                                        the_obj = dev->cache[i].object;
                                        cache = &dev->cache[i];
@@ -3220,7 +3217,7 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
 
 /* Find a cached chunk */
 static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
-                                             int chunk_id)
+                                                 int chunk_id)
 {
        struct yaffs_dev *dev = obj->my_dev;
        int i;
@@ -3239,7 +3236,7 @@ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
 
 /* Mark the chunk for the least recently used algorithym */
 static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
-                               int is_write)
+                           int is_write)
 {
 
        if (dev->param.n_caches > 0) {
@@ -3268,7 +3265,8 @@ static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
 static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
 {
        if (object->my_dev->param.n_caches > 0) {
-               struct yaffs_cache *cache = yaffs_find_chunk_cache(object, chunk_id);
+               struct yaffs_cache *cache =
+                   yaffs_find_chunk_cache(object, chunk_id);
 
                if (cache)
                        cache->object = NULL;
@@ -3292,7 +3290,6 @@ static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
        }
 }
 
-
 /*--------------------- File read/write ------------------------
  * Read and write have very similar structures.
  * In general the read/write has three parts to it
@@ -3303,8 +3300,7 @@ static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
  * Curve-balls: the first chunk might also be the last chunk.
  */
 
-int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
-                       int n_bytes)
+int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes)
 {
 
        int chunk;
@@ -3338,20 +3334,21 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
                 * or we're using inband tags then use the cache (if there is caching)
                 * else bypass the cache.
                 */
-               if (cache || n_copy != dev->data_bytes_per_chunk || dev->param.inband_tags) {
+               if (cache || n_copy != dev->data_bytes_per_chunk
+                   || dev->param.inband_tags) {
                        if (dev->param.n_caches > 0) {
 
                                /* If we can't find the data in the cache, then load it up. */
 
                                if (!cache) {
-                                       cache = yaffs_grab_chunk_cache(in->my_dev);
+                                       cache =
+                                           yaffs_grab_chunk_cache(in->my_dev);
                                        cache->object = in;
                                        cache->chunk_id = chunk;
                                        cache->dirty = 0;
                                        cache->locked = 0;
                                        yaffs_rd_data_obj(in, chunk,
-                                                                     cache->
-                                                                     data);
+                                                         cache->data);
                                        cache->n_bytes = 0;
                                }
 
@@ -3359,23 +3356,20 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
 
                                cache->locked = 1;
 
-
                                memcpy(buffer, &cache->data[start], n_copy);
 
                                cache->locked = 0;
                        } else {
-                               /* Read into the local buffer then copy..*/
+                               /* Read into the local buffer then copy.. */
 
                                u8 *local_buffer =
                                    yaffs_get_temp_buffer(dev, __LINE__);
-                               yaffs_rd_data_obj(in, chunk,
-                                                             local_buffer);
+                               yaffs_rd_data_obj(in, chunk, local_buffer);
 
                                memcpy(buffer, &local_buffer[start], n_copy);
 
-
                                yaffs_release_temp_buffer(dev, local_buffer,
-                                                       __LINE__);
+                                                         __LINE__);
                        }
 
                } else {
@@ -3395,8 +3389,8 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
        return n_done;
 }
 
-int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
-                       int n_bytes, int write_trhrough)
+int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset,
+                    int n_bytes, int write_trhrough)
 {
 
        int chunk;
@@ -3418,13 +3412,13 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                yaffs_addr_to_chunk(dev, offset, &chunk, &start);
 
                if (chunk * dev->data_bytes_per_chunk + start != offset ||
-                               start >= dev->data_bytes_per_chunk) {
-                       T(YAFFS_TRACE_ERROR, (
-                          TSTR("AddrToChunk of offset %d gives chunk %d start %d"
-                          TENDSTR),
-                          (int)offset, chunk, start));
+                   start >= dev->data_bytes_per_chunk) {
+                       T(YAFFS_TRACE_ERROR,
+                         (TSTR
+                          ("AddrToChunk of offset %d gives chunk %d start %d"
+                           TENDSTR), (int)offset, chunk, start));
                }
-               chunk++; /* File pos to chunk in file offset */
+               chunk++;        /* File pos to chunk in file offset */
 
                /* OK now check for the curveball where the start and end are in
                 * the same chunk.
@@ -3441,9 +3435,11 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                        chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk);
 
                        if (chunk_start > in->variant.file_variant.file_size)
-                               n_bytes_read = 0; /* Past end of file */
+                               n_bytes_read = 0;       /* Past end of file */
                        else
-                               n_bytes_read = in->variant.file_variant.file_size - chunk_start;
+                               n_bytes_read =
+                                   in->variant.file_variant.file_size -
+                                   chunk_start;
 
                        if (n_bytes_read > dev->data_bytes_per_chunk)
                                n_bytes_read = dev->data_bytes_per_chunk;
@@ -3452,7 +3448,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                            (n_bytes_read >
                             (start + n)) ? n_bytes_read : (start + n);
 
-                       if (n_writeback < 0 || n_writeback > dev->data_bytes_per_chunk)
+                       if (n_writeback < 0
+                           || n_writeback > dev->data_bytes_per_chunk)
                                YBUG();
 
                } else {
@@ -3460,7 +3457,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                        n_writeback = dev->data_bytes_per_chunk;
                }
 
-               if (n_copy != dev->data_bytes_per_chunk || dev->param.inband_tags) {
+               if (n_copy != dev->data_bytes_per_chunk
+                   || dev->param.inband_tags) {
                        /* An incomplete start or end chunk (or maybe both start and end chunk),
                         * or we're using inband tags, so we want to use the cache buffers.
                         */
@@ -3477,25 +3475,24 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                                        cache->dirty = 0;
                                        cache->locked = 0;
                                        yaffs_rd_data_obj(in, chunk,
-                                                                     cache->data);
+                                                         cache->data);
                                } else if (cache &&
-                                       !cache->dirty &&
-                                       !yaffs_check_alloc_available(dev, 1)) {
+                                          !cache->dirty &&
+                                          !yaffs_check_alloc_available(dev,
+                                                                       1)) {
                                        /* Drop the cache if it was a read cache item and
                                         * no space check has been made for it.
                                         */
-                                        cache = NULL;
+                                       cache = NULL;
                                }
 
                                if (cache) {
                                        yaffs_use_cache(dev, cache, 1);
                                        cache->locked = 1;
 
-
                                        memcpy(&cache->data[start], buffer,
                                               n_copy);
 
-
                                        cache->locked = 0;
                                        cache->n_bytes = n_writeback;
 
@@ -3504,8 +3501,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                                                    yaffs_wr_data_obj
                                                    (cache->object,
                                                     cache->chunk_id,
-                                                    cache->data, cache->n_bytes,
-                                                    1);
+                                                    cache->data,
+                                                    cache->n_bytes, 1);
                                                cache->dirty = 0;
                                        }
 
@@ -3520,33 +3517,26 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                                u8 *local_buffer =
                                    yaffs_get_temp_buffer(dev, __LINE__);
 
-                               yaffs_rd_data_obj(in, chunk,
-                                                             local_buffer);
-
-
+                               yaffs_rd_data_obj(in, chunk, local_buffer);
 
                                memcpy(&local_buffer[start], buffer, n_copy);
 
                                chunk_written =
                                    yaffs_wr_data_obj(in, chunk,
-                                                                local_buffer,
-                                                                n_writeback,
-                                                                0);
+                                                     local_buffer,
+                                                     n_writeback, 0);
 
                                yaffs_release_temp_buffer(dev, local_buffer,
-                                                       __LINE__);
+                                                         __LINE__);
 
                        }
 
                } else {
                        /* A full chunk. Write directly from the supplied buffer. */
 
-
-
                        chunk_written =
                            yaffs_wr_data_obj(in, chunk, buffer,
-                                                        dev->data_bytes_per_chunk,
-                                                        0);
+                                             dev->data_bytes_per_chunk, 0);
 
                        /* Since we've overwritten the cached data, we better invalidate it. */
                        yaffs_invalidate_chunk_cache(in, chunk);
@@ -3571,15 +3561,13 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
        return n_done;
 }
 
-int yaffs_wr_file(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
-                       int n_bytes, int write_trhrough)
+int yaffs_wr_file(struct yaffs_obj *in, const u8 * buffer, loff_t offset,
+                 int n_bytes, int write_trhrough)
 {
-       yaffs2_handle_hole(in,offset);
-       return yaffs_do_file_wr(in,buffer,offset,n_bytes,write_trhrough);
+       yaffs2_handle_hole(in, offset);
+       return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_trhrough);
 }
 
-
-
 /* ---------------------- File resizing stuff ------------------ */
 
 static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
@@ -3607,12 +3595,14 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
                chunk_id = yaffs_find_del_file_chunk(in, i, NULL);
                if (chunk_id > 0) {
                        if (chunk_id <
-                           (dev->internal_start_block * dev->param.chunks_per_block)
+                           (dev->internal_start_block *
+                            dev->param.chunks_per_block)
                            || chunk_id >=
                            ((dev->internal_end_block +
                              1) * dev->param.chunks_per_block)) {
                                T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR("Found daft chunk_id %d for %d" TENDSTR),
+                                 (TSTR
+                                  ("Found daft chunk_id %d for %d" TENDSTR),
                                   chunk_id, i));
                        } else {
                                in->n_data_chunks--;
@@ -3623,8 +3613,7 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
 
 }
 
-
-void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size)
+void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
 {
        int new_full;
        u32 new_partial;
@@ -3641,10 +3630,10 @@ void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size)
                /* Got to read and rewrite the last chunk with its new size and zero pad */
                yaffs_rd_data_obj(obj, last_chunk, local_buffer);
                memset(local_buffer + new_partial, 0,
-                       dev->data_bytes_per_chunk - new_partial);
+                      dev->data_bytes_per_chunk - new_partial);
 
                yaffs_wr_data_obj(obj, last_chunk, local_buffer,
-                                            new_partial, 1);
+                                 new_partial, 1);
 
                yaffs_release_temp_buffer(dev, local_buffer, __LINE__);
        }
@@ -3654,7 +3643,6 @@ void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size)
        yaffs_prune_tree(dev, &obj->variant.file_variant);
 }
 
-
 int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
 {
        struct yaffs_dev *dev = in->my_dev;
@@ -3663,21 +3651,21 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
        yaffs_flush_file_cache(in);
        yaffs_invalidate_whole_cache(in);
 
-       yaffs_check_gc(dev,0);
+       yaffs_check_gc(dev, 0);
 
        if (in->variant_type != YAFFS_OBJECT_TYPE_FILE)
                return YAFFS_FAIL;
 
        if (new_size == old_size)
                return YAFFS_OK;
-               
-       if(new_size > old_size){
-               yaffs2_handle_hole(in,new_size);
+
+       if (new_size > old_size) {
+               yaffs2_handle_hole(in, new_size);
                in->variant.file_variant.file_size = new_size;
        } else {
-               /* new_size < old_size */ 
+               /* new_size < old_size */
                yaffs_resize_file_down(in, new_size);
-       } 
+       }
 
        /* Write a new object header to reflect the resize.
         * show we've shrunk the file, if need be
@@ -3690,24 +3678,22 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
            in->parent->obj_id != YAFFS_OBJECTID_DELETED)
                yaffs_update_oh(in, NULL, 0, 0, 0, NULL);
 
-
        return YAFFS_OK;
 }
 
-
 int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
 {
        int ret_val;
        if (in->dirty) {
                yaffs_flush_file_cache(in);
-               if(data_sync) /* Only sync data */
-                       ret_val=YAFFS_OK;
+               if (data_sync)  /* Only sync data */
+                       ret_val = YAFFS_OK;
                else {
                        if (update_time)
-                               yaffs_load_current_time(in,0,0);
+                               yaffs_load_current_time(in, 0, 0);
 
                        ret_val = (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >=
-                               0) ? YAFFS_OK : YAFFS_FAIL;
+                                  0) ? YAFFS_OK : YAFFS_FAIL;
                }
        } else {
                ret_val = YAFFS_OK;
@@ -3725,7 +3711,8 @@ static int yaffs_generic_obj_del(struct yaffs_obj *in)
 
        if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) {
                /* Move to the unlinked directory so we have a record that it was deleted. */
-               yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0);
+               yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0,
+                                     0);
 
        }
 
@@ -3755,7 +3742,7 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in)
        if (del_now) {
                ret_val =
                    yaffs_change_obj_name(in, in->my_dev->del_dir,
-                                          _Y("deleted"), 0, 0);
+                                         _Y("deleted"), 0, 0);
                T(YAFFS_TRACE_TRACING,
                  (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
                   in->obj_id));
@@ -3767,17 +3754,16 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in)
        } else {
                ret_val =
                    yaffs_change_obj_name(in, in->my_dev->unlinked_dir,
-                                          _Y("unlinked"), 0, 0);
+                                         _Y("unlinked"), 0, 0);
        }
 
-
        return ret_val;
 }
 
 int yaffs_del_file(struct yaffs_obj *in)
 {
        int ret_val = YAFFS_OK;
-       int deleted; /* Need to cache value on stack if in is freed */
+       int deleted;            /* Need to cache value on stack if in is freed */
        struct yaffs_dev *dev = in->my_dev;
 
        if (dev->param.disable_soft_del || dev->param.is_yaffs2)
@@ -3812,7 +3798,7 @@ int yaffs_del_file(struct yaffs_obj *in)
 static int yaffs_is_non_empty_dir(struct yaffs_obj *obj)
 {
        return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) &&
-               !(list_empty(&obj->variant.dir_variant.children));
+           !(list_empty(&obj->variant.dir_variant.children));
 }
 
 static int yaffs_del_dir(struct yaffs_obj *obj)
@@ -3826,9 +3812,9 @@ static int yaffs_del_dir(struct yaffs_obj *obj)
 
 static int yaffs_del_symlink(struct yaffs_obj *in)
 {
-       if(in->variant.symlink_variant.alias)
+       if (in->variant.symlink_variant.alias)
                YFREE(in->variant.symlink_variant.alias);
-       in->variant.symlink_variant.alias=NULL;
+       in->variant.symlink_variant.alias = NULL;
 
        return yaffs_generic_obj_del(in);
 }
@@ -3844,14 +3830,17 @@ static int yaffs_del_link(struct yaffs_obj *in)
 
 int yaffs_del_obj(struct yaffs_obj *obj)
 {
-int ret_val = -1;
+       int ret_val = -1;
        switch (obj->variant_type) {
        case YAFFS_OBJECT_TYPE_FILE:
                ret_val = yaffs_del_file(obj);
                break;
        case YAFFS_OBJECT_TYPE_DIRECTORY:
-               if(!list_empty(&obj->variant.dir_variant.dirty)){
-                       T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->obj_id));
+               if (!list_empty(&obj->variant.dir_variant.dirty)) {
+                       T(YAFFS_TRACE_BACKGROUND,
+                         (TSTR
+                          ("Remove object %d from dirty directories" TENDSTR),
+                          obj->obj_id));
                        list_del_init(&obj->variant.dir_variant.dirty);
                }
                return yaffs_del_dir(obj);
@@ -3881,7 +3870,7 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
        if (!obj->my_inode)
                del_now = 1;
 
-       if(obj)
+       if (obj)
                yaffs_update_parent(obj->parent);
 
        if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) {
@@ -3906,16 +3895,17 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
                int ret_val;
                YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
-               hl = list_entry(obj->hard_links.next, struct yaffs_obj, hard_links);
+               hl = list_entry(obj->hard_links.next, struct yaffs_obj,
+                               hard_links);
 
                yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
                parent = hl->parent;
 
                list_del_init(&hl->hard_links);
 
-               yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl);
+               yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl);
 
-               ret_val = yaffs_change_obj_name(obj,parent, name, 0, 0);
+               ret_val = yaffs_change_obj_name(obj, parent, name, 0, 0);
 
                if (ret_val == YAFFS_OK)
                        ret_val = yaffs_generic_obj_del(hl);
@@ -3942,14 +3932,13 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj)
                default:
                        return YAFFS_FAIL;
                }
-       } else if(yaffs_is_non_empty_dir(obj))
+       } else if (yaffs_is_non_empty_dir(obj))
                return YAFFS_FAIL;
        else
                return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir,
-                                          _Y("unlinked"), 0, 0);
+                                            _Y("unlinked"), 0, 0);
 }
 
-
 static int yaffs_unlink_obj(struct yaffs_obj *obj)
 {
 
@@ -3959,7 +3948,8 @@ static int yaffs_unlink_obj(struct yaffs_obj *obj)
        return YAFFS_FAIL;
 
 }
-int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name)
+
+int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name)
 {
        struct yaffs_obj *obj;
 
@@ -3970,7 +3960,7 @@ int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name)
 /*----------------------- Initialisation Scanning ---------------------- */
 
 void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
-                               int backward_scanning)
+                              int backward_scanning)
 {
        struct yaffs_obj *obj;
 
@@ -3984,7 +3974,7 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
                 * If the shadowed object exists then ignore.
                 */
                obj = yaffs_find_by_number(dev, obj_id);
-               if(obj)
+               if (obj)
                        return;
        }
 
@@ -3992,8 +3982,7 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
         * We put it in unlinked dir to be cleaned up after the scanning
         */
        obj =
-           yaffs_find_or_create_by_number(dev, obj_id,
-                                            YAFFS_OBJECT_TYPE_FILE);
+           yaffs_find_or_create_by_number(dev, obj_id, YAFFS_OBJECT_TYPE_FILE);
        if (!obj)
                return;
        obj->is_shadowed = 1;
@@ -4003,7 +3992,6 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
 
 }
 
-
 void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list)
 {
        struct yaffs_obj *hl;
@@ -4011,11 +3999,11 @@ void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list)
 
        while (hard_list) {
                hl = hard_list;
-               hard_list = (struct yaffs_obj *) (hard_list->hard_links.next);
+               hard_list = (struct yaffs_obj *)(hard_list->hard_links.next);
 
                in = yaffs_find_by_number(dev,
-                                             hl->variant.hardlink_variant.
-                                             equiv_id);
+                                         hl->variant.
+                                         hardlink_variant.equiv_id);
 
                if (in) {
                        /* Add the hardlink pointers */
@@ -4032,12 +4020,11 @@ void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list)
        }
 }
 
-
 static void yaffs_strip_deleted_objs(struct yaffs_dev *dev)
 {
        /*
-       *  Sort out state of unlinked and deleted objects after scanning.
-       */
+        *  Sort out state of unlinked and deleted objects after scanning.
+        */
        struct list_head *i;
        struct list_head *n;
        struct yaffs_obj *l;
@@ -4047,15 +4034,14 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev)
 
        /* Soft delete all the unlinked files */
        list_for_each_safe(i, n,
-               &dev->unlinked_dir->variant.dir_variant.children) {
+                          &dev->unlinked_dir->variant.dir_variant.children) {
                if (i) {
                        l = list_entry(i, struct yaffs_obj, siblings);
                        yaffs_del_obj(l);
                }
        }
 
-       list_for_each_safe(i, n,
-               &dev->del_dir->variant.dir_variant.children) {
+       list_for_each_safe(i, n, &dev->del_dir->variant.dir_variant.children) {
                if (i) {
                        l = list_entry(i, struct yaffs_obj, siblings);
                        yaffs_del_obj(l);
@@ -4080,12 +4066,11 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev)
  * This fixes the problem where directories might have inadvertently been deleted
  * leaving the object "hanging" without being rooted in the directory tree.
  */
+
 static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
        return (obj == dev->del_dir ||
-               obj == dev->unlinked_dir||
-               obj == dev->root_dir);
+               obj == dev->unlinked_dir || obj == dev->root_dir);
 }
 
 static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
@@ -4106,49 +4091,53 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
         * Make sure it is rooted.
         */
 
-       for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
+       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
                list_for_each_safe(lh, n, &dev->obj_bucket[i].list) {
                        if (lh) {
-                               obj = list_entry(lh, struct yaffs_obj, hash_link);
-                               parent= obj->parent;
-                               
-                               if(yaffs_has_null_parent(dev,obj)){
+                               obj =
+                                   list_entry(lh, struct yaffs_obj, hash_link);
+                               parent = obj->parent;
+
+                               if (yaffs_has_null_parent(dev, obj)) {
                                        /* These directories are not hanging */
                                        hanging = 0;
-                               }
-                               else if(!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+                               } else if (!parent
+                                          || parent->variant_type !=
+                                          YAFFS_OBJECT_TYPE_DIRECTORY)
                                        hanging = 1;
-                               else if(yaffs_has_null_parent(dev,parent))
+                               else if (yaffs_has_null_parent(dev, parent))
                                        hanging = 0;
                                else {
                                        /*
                                         * Need to follow the parent chain to see if it is hanging.
                                         */
                                        hanging = 0;
-                                       depth_limit=100;
+                                       depth_limit = 100;
 
-                                       while(parent != dev->root_dir &&
-                                               parent->parent &&
-                                               parent->parent->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
-                                               depth_limit > 0){
+                                       while (parent != dev->root_dir &&
+                                              parent->parent &&
+                                              parent->parent->variant_type ==
+                                              YAFFS_OBJECT_TYPE_DIRECTORY
+                                              && depth_limit > 0) {
                                                parent = parent->parent;
                                                depth_limit--;
                                        }
-                                       if(parent != dev->root_dir)
+                                       if (parent != dev->root_dir)
                                                hanging = 1;
                                }
-                               if(hanging){
+                               if (hanging) {
                                        T(YAFFS_TRACE_SCAN,
-                                         (TSTR("Hanging object %d moved to lost and found" TENDSTR),
-                                               obj->obj_id));
-                                       yaffs_add_obj_to_dir(dev->lost_n_found,obj);
+                                         (TSTR
+                                          ("Hanging object %d moved to lost and found"
+                                           TENDSTR), obj->obj_id));
+                                       yaffs_add_obj_to_dir(dev->lost_n_found,
+                                                            obj);
                                }
                        }
                }
        }
 }
 
-
 /*
  * Delete directory contents for cleaning up lost and found.
  */
@@ -4158,26 +4147,26 @@ static void yaffs_del_dir_contents(struct yaffs_obj *dir)
        struct list_head *lh;
        struct list_head *n;
 
-       if(dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+       if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                YBUG();
-       
+
        list_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
                if (lh) {
                        obj = list_entry(lh, struct yaffs_obj, siblings);
-                       if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
+                       if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                                yaffs_del_dir_contents(obj);
 
                        T(YAFFS_TRACE_SCAN,
-                               (TSTR("Deleting lost_found object %d" TENDSTR),
-                               obj->obj_id));
+                         (TSTR("Deleting lost_found object %d" TENDSTR),
+                          obj->obj_id));
 
                        /* Need to use UnlinkObject since Delete would not handle
                         * hardlinked objects correctly.
                         */
-                       yaffs_unlink_obj(obj); 
+                       yaffs_unlink_obj(obj);
                }
        }
-                       
+
 }
 
 static void yaffs_empty_l_n_f(struct yaffs_dev *dev)
@@ -4203,8 +4192,10 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
                in->lazy_loaded = 0;
                chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
 
-               result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, &tags);
-               oh = (struct yaffs_obj_hdr *) chunk_data;
+               result =
+                   yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data,
+                                            &tags);
+               oh = (struct yaffs_obj_hdr *)chunk_data;
 
                in->yst_mode = oh->yst_mode;
                yaffs_load_attribs(in, oh);
@@ -4212,9 +4203,9 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 
                if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
                        in->variant.symlink_variant.alias =
-                                                   yaffs_clone_str(oh->alias);
+                           yaffs_clone_str(oh->alias);
                        if (!in->variant.symlink_variant.alias)
-                               alloc_failed = 1; /* Not returned to caller */
+                               alloc_failed = 1;       /* Not returned to caller */
                }
 
                yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
@@ -4238,23 +4229,23 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
  * If the directory updating is defered then yaffs_update_dirty_dirs must be
  * called periodically.
  */
+
 static void yaffs_update_parent(struct yaffs_obj *obj)
 {
        struct yaffs_dev *dev;
-       if(!obj)
+       if (!obj)
                return;
        dev = obj->my_dev;
        obj->dirty = 1;
-       yaffs_load_current_time(obj,0,1);
-       if(dev->param.defered_dir_update){
-               struct list_head *link = &obj->variant.dir_variant.dirty; 
-       
-               if(list_empty(link)){
-                       list_add(link,&dev->dirty_dirs);
-                       T(YAFFS_TRACE_BACKGROUND, 
-                       (TSTR("Added object %d to dirty directories" TENDSTR),
-                       obj->obj_id));
+       yaffs_load_current_time(obj, 0, 1);
+       if (dev->param.defered_dir_update) {
+               struct list_head *link = &obj->variant.dir_variant.dirty;
+
+               if (list_empty(link)) {
+                       list_add(link, &dev->dirty_dirs);
+                       T(YAFFS_TRACE_BACKGROUND,
+                         (TSTR("Added object %d to dirty directories" TENDSTR),
+                          obj->obj_id));
                }
 
        } else
@@ -4270,17 +4261,18 @@ void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
 
        T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
 
-       while(!list_empty(&dev->dirty_dirs)){
+       while (!list_empty(&dev->dirty_dirs)) {
                link = dev->dirty_dirs.next;
                list_del_init(link);
-               
-               d_s=list_entry(link,struct yaffs_dir_var,dirty);
-               o_v = list_entry(d_s,union yaffs_obj_var,dir_variant);
-               obj = list_entry(o_v,struct yaffs_obj,variant);
 
-               T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id));
+               d_s = list_entry(link, struct yaffs_dir_var, dirty);
+               o_v = list_entry(d_s, union yaffs_obj_var, dir_variant);
+               obj = list_entry(o_v, struct yaffs_obj, variant);
+
+               T(YAFFS_TRACE_BACKGROUND,
+                 (TSTR("Update directory %d" TENDSTR), obj->obj_id));
 
-               if(obj->dirty)
+               if (obj->dirty)
                        yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
        }
 }
@@ -4298,15 +4290,13 @@ static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
        if (dev && dev->param.remove_obj_fn)
                dev->param.remove_obj_fn(obj);
 
-
        list_del_init(&obj->siblings);
        obj->parent = NULL;
-       
+
        yaffs_verify_dir(parent);
 }
 
-void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
-                                       struct yaffs_obj *obj)
+void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj)
 {
        if (!directory) {
                T(YAFFS_TRACE_ALWAYS,
@@ -4329,18 +4319,16 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
                YBUG();
        }
 
-
        yaffs_verify_dir(directory);
 
        yaffs_remove_obj_from_dir(obj);
 
-
        /* Now add it */
        list_add(&obj->siblings, &directory->variant.dir_variant.children);
        obj->parent = directory;
 
        if (directory == obj->my_dev->unlinked_dir
-                       || directory == obj->my_dev->del_dir) {
+           || directory == obj->my_dev->del_dir) {
                obj->unlinked = 1;
                obj->my_dev->n_unlinked_files++;
                obj->rename_allowed = 0;
@@ -4351,7 +4339,7 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
 }
 
 struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
-                                    const YCHAR *name)
+                                    const YCHAR * name)
 {
        int sum;
 
@@ -4373,8 +4361,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
        }
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
                T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_find_by_name: non-directory" TENDSTR)));
+                 (TSTR("tragedy: yaffs_find_by_name: non-directory" TENDSTR)));
                YBUG();
        }
 
@@ -4391,15 +4378,18 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 
                        /* Special case for lost-n-found */
                        if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
-                               if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0)
+                               if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) ==
+                                   0)
                                        return l;
-                       } else if (yaffs_sum_cmp(l->sum, sum) || l->hdr_chunk <= 0) {
+                       } else if (yaffs_sum_cmp(l->sum, sum)
+                                  || l->hdr_chunk <= 0) {
                                /* LostnFound chunk called Objxxx
                                 * Do a real check
                                 */
                                yaffs_get_obj_name(l, buffer,
-                                                   YAFFS_MAX_NAME_LENGTH + 1);
-                               if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
+                                                  YAFFS_MAX_NAME_LENGTH + 1);
+                               if (yaffs_strncmp
+                                   (name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
                                        return l;
                        }
                }
@@ -4408,7 +4398,6 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
        return NULL;
 }
 
-
 /* GetEquivalentObject dereferences any hard links to get to the
  * actual object.
  */
@@ -4442,128 +4431,130 @@ struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj)
  *    starting at oh->name[1].
 
  */
-static void yaffs_fix_null_name(struct yaffs_obj * obj,YCHAR * name, int buffer_size)
+static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name,
+                               int buffer_size)
 {
        /* Create an object name if we could not find one. */
-       if(yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH) == 0){
+       if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) {
                YCHAR local_name[20];
                YCHAR num_string[20];
                YCHAR *x = &num_string[19];
                unsigned v = obj->obj_id;
                num_string[19] = 0;
-               while(v>0){
+               while (v > 0) {
                        x--;
                        *x = '0' + (v % 10);
                        v /= 10;
                }
                /* make up a name */
                yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
-               yaffs_strcat(local_name,x);
+               yaffs_strcat(local_name, x);
                yaffs_strncpy(name, local_name, buffer_size - 1);
        }
 }
 
-static void yaffs_load_name_from_oh(struct yaffs_dev *dev,YCHAR *name, const YCHAR *oh_name, int buff_size)
+static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
+                                   const YCHAR * oh_name, int buff_size)
 {
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
-       if(dev->param.auto_unicode){
-               if(*oh_name){
+       if (dev->param.auto_unicode) {
+               if (*oh_name) {
                        /* It is an ASCII name, so do an ASCII to unicode conversion */
                        const char *ascii_oh_name = (const char *)oh_name;
                        int n = buff_size - 1;
-                       while(n > 0 && *ascii_oh_name){
+                       while (n > 0 && *ascii_oh_name) {
                                *name = *ascii_oh_name;
                                name++;
                                ascii_oh_name++;
                                n--;
                        }
-               } else 
-                       yaffs_strncpy(name,oh_name+1, buff_size -1);
+               } else
+                       yaffs_strncpy(name, oh_name + 1, buff_size - 1);
        } else
 #endif
                yaffs_strncpy(name, oh_name, buff_size - 1);
 }
 
-
-static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name, const YCHAR *name)
+static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name,
+                                   const YCHAR * name)
 {
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
 
        int is_ascii;
        YCHAR *w;
 
-       if(dev->param.auto_unicode){
+       if (dev->param.auto_unicode) {
 
                is_ascii = 1;
                w = name;
-       
+
                /* Figure out if the name will fit in ascii character set */
-               while(is_ascii && *w){
-                       if((*w) & 0xff00)
+               while (is_ascii && *w) {
+                       if ((*w) & 0xff00)
                                is_ascii = 0;
                        w++;
                }
 
-               if(is_ascii){
+               if (is_ascii) {
                        /* It is an ASCII name, so do a unicode to ascii conversion */
                        char *ascii_oh_name = (char *)oh_name;
-                       int n = YAFFS_MAX_NAME_LENGTH  - 1;
-                       while(n > 0 && *name){
-                               *ascii_oh_name= *name;
+                       int n = YAFFS_MAX_NAME_LENGTH - 1;
+                       while (n > 0 && *name) {
+                               *ascii_oh_name = *name;
                                name++;
                                ascii_oh_name++;
                                n--;
                        }
-               } else{
+               } else {
                        /* It is a unicode name, so save starting at the second YCHAR */
                        *oh_name = 0;
-                       yaffs_strncpy(oh_name+1,name, YAFFS_MAX_NAME_LENGTH -2);
+                       yaffs_strncpy(oh_name + 1, name,
+                                     YAFFS_MAX_NAME_LENGTH - 2);
                }
-       }
-       else 
+       } else
 #endif
-               yaffs_strncpy(oh_name,name, YAFFS_MAX_NAME_LENGTH - 1);
+               yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
 
 }
 
-int yaffs_get_obj_name(struct yaffs_obj * obj, YCHAR * name, int buffer_size)
+int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
 {
        memset(name, 0, buffer_size * sizeof(YCHAR));
-       
+
        yaffs_check_obj_details_loaded(obj);
 
        if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
                yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
-       } 
+       }
 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
        else if (obj->short_name[0]) {
                yaffs_strcpy(name, obj->short_name);
        }
 #endif
-       else if(obj->hdr_chunk > 0) {
+       else if (obj->hdr_chunk > 0) {
                int result;
                u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__);
 
-               struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *) buffer;
+               struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer;
 
                memset(buffer, 0, obj->my_dev->data_bytes_per_chunk);
 
                if (obj->hdr_chunk > 0) {
                        result = yaffs_rd_chunk_tags_nand(obj->my_dev,
-                                                       obj->hdr_chunk, buffer,
-                                                       NULL);
+                                                         obj->hdr_chunk,
+                                                         buffer, NULL);
                }
-               yaffs_load_name_from_oh(obj->my_dev,name,oh->name,buffer_size);
+               yaffs_load_name_from_oh(obj->my_dev, name, oh->name,
+                                       buffer_size);
 
                yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__);
        }
 
-       yaffs_fix_null_name(obj,name,buffer_size);
+       yaffs_fix_null_name(obj, name, buffer_size);
 
-       return yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH);
+       return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH);
 }
 
-
 int yaffs_get_obj_length(struct yaffs_obj *obj)
 {
        /* Dereference any hard linking */
@@ -4571,10 +4562,11 @@ int yaffs_get_obj_length(struct yaffs_obj *obj)
 
        if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
                return obj->variant.file_variant.file_size;
-       if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){
-               if(!obj->variant.symlink_variant.alias)
+       if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
+               if (!obj->variant.symlink_variant.alias)
                        return 0;
-               return yaffs_strnlen(obj->variant.symlink_variant.alias,YAFFS_MAX_ALIAS_LENGTH);
+               return yaffs_strnlen(obj->variant.symlink_variant.alias,
+                                    YAFFS_MAX_ALIAS_LENGTH);
        } else {
                /* Only a directory should drop through to here */
                return obj->my_dev->data_bytes_per_chunk;
@@ -4587,10 +4579,10 @@ int yaffs_get_obj_link_count(struct yaffs_obj *obj)
        struct list_head *i;
 
        if (!obj->unlinked)
-               count++;                /* the object itself */
+               count++;        /* the object itself */
 
        list_for_each(i, &obj->hard_links)
-               count++;                /* add the hard links; */
+           count++;            /* add the hard links; */
 
        return count;
 }
@@ -4643,7 +4635,9 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
                return yaffs_clone_str(_Y(""));
 }
 
-static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *name, const void *value, int size, int flags)
+static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set,
+                               const YCHAR * name, const void *value, int size,
+                               int flags)
 {
        struct yaffs_xattr_mod xmod;
 
@@ -4652,29 +4646,32 @@ static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *nam
        xmod.set = set;
        xmod.name = name;
        xmod.data = value;
-       xmod.size =  size;
+       xmod.size = size;
        xmod.flags = flags;
        xmod.result = -ENOSPC;
 
        result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod);
 
-       if(result > 0)
+       if (result > 0)
                return xmod.result;
        else
                return -ENOSPC;
 }
 
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod)
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer,
+                                  struct yaffs_xattr_mod *xmod)
 {
        int retval = 0;
        int x_offs = sizeof(struct yaffs_obj_hdr);
        struct yaffs_dev *dev = obj->my_dev;
        int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
 
-       char * x_buffer = buffer + x_offs;
+       char *x_buffer = buffer + x_offs;
 
-       if(xmod->set)
-               retval = nval_set(x_buffer, x_size, xmod->name, xmod->data, xmod->size, xmod->flags);
+       if (xmod->set)
+               retval =
+                   nval_set(x_buffer, x_size, xmod->name, xmod->data,
+                            xmod->size, xmod->flags);
        else
                retval = nval_del(x_buffer, x_size, xmod->name);
 
@@ -4686,7 +4683,8 @@ static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct y
        return retval;
 }
 
-static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, void *value, int size)
+static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name,
+                                 void *value, int size)
 {
        char *buffer = NULL;
        int result;
@@ -4695,66 +4693,69 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, void
        int x_offs = sizeof(struct yaffs_obj_hdr);
        int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
 
-       char * x_buffer;
+       char *x_buffer;
 
        int retval = 0;
 
-       if(obj->hdr_chunk < 1)
+       if (obj->hdr_chunk < 1)
                return -ENODATA;
 
        /* If we know that the object has no xattribs then don't do all the
         * reading and parsing.
         */
-       if(obj->xattr_known && !obj->has_xattr){
-               if(name)
+       if (obj->xattr_known && !obj->has_xattr) {
+               if (name)
                        return -ENODATA;
                else
                        return 0;
        }
 
-       buffer = (char *) yaffs_get_temp_buffer(dev, __LINE__);
-       if(!buffer)
+       buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
+       if (!buffer)
                return -ENOMEM;
 
-       result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (u8 *)buffer, &tags);
+       result =
+           yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags);
 
-       if(result != YAFFS_OK)
+       if (result != YAFFS_OK)
                retval = -ENOENT;
-       else{
-               x_buffer =  buffer + x_offs;
+       else {
+               x_buffer = buffer + x_offs;
 
-               if (!obj->xattr_known){
+               if (!obj->xattr_known) {
                        obj->has_xattr = nval_hasvalues(x_buffer, x_size);
                        obj->xattr_known = 1;
                }
 
-               if(name)
+               if (name)
                        retval = nval_get(x_buffer, x_size, name, value, size);
                else
-                       retval = nval_list(x_buffer, x_size, value,size);
+                       retval = nval_list(x_buffer, x_size, value, size);
        }
-       yaffs_release_temp_buffer(dev,(u8 *)buffer,__LINE__);
+       yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
        return retval;
 }
 
-int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, const void * value, int size, int flags)
+int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
+                     const void *value, int size, int flags)
 {
        return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags);
 }
 
-int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name)
+int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name)
 {
        return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0);
 }
 
-int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, int size)
+int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
+                     int size)
 {
        return yaffs_do_xattrib_fetch(obj, name, value, size);
 }
 
 int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size)
 {
-       return yaffs_do_xattrib_fetch(obj, NULL, buffer,size);
+       return yaffs_do_xattrib_fetch(obj, NULL, buffer, size);
 }
 
 /*---------------------------- Initialisation code -------------------------------------- */
@@ -4773,8 +4774,7 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
            dev->param.read_chunk_tags_fn &&
            !dev->param.write_chunk_fn &&
            !dev->param.read_chunk_fn &&
-           dev->param.bad_block_fn &&
-           dev->param.query_block_fn)
+           dev->param.bad_block_fn && dev->param.query_block_fn)
                return 1;
 #endif
 
@@ -4784,19 +4784,17 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
            !dev->param.read_chunk_tags_fn &&
            dev->param.write_chunk_fn &&
            dev->param.read_chunk_fn &&
-           !dev->param.bad_block_fn &&
-           !dev->param.query_block_fn)
+           !dev->param.bad_block_fn && !dev->param.query_block_fn)
                return 1;
 
-       return 0;       /* bad */
+       return 0;               /* bad */
 }
 
-
 static int yaffs_create_initial_dir(struct yaffs_dev *dev)
 {
        /* Initialise the unlinked, deleted, root and lost and found directories */
 
-       dev->lost_n_found = dev->root_dir =  NULL;
+       dev->lost_n_found = dev->root_dir = NULL;
        dev->unlinked_dir = dev->del_dir = NULL;
 
        dev->unlinked_dir =
@@ -4807,12 +4805,13 @@ static int yaffs_create_initial_dir(struct yaffs_dev *dev)
 
        dev->root_dir =
            yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT,
-                                     YAFFS_ROOT_MODE | S_IFDIR);
+                                 YAFFS_ROOT_MODE | S_IFDIR);
        dev->lost_n_found =
            yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND,
-                                     YAFFS_LOSTNFOUND_MODE | S_IFDIR);
+                                 YAFFS_LOSTNFOUND_MODE | S_IFDIR);
 
-       if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir && dev->del_dir) {
+       if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir
+           && dev->del_dir) {
                yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found);
                return YAFFS_OK;
        }
@@ -4826,7 +4825,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        unsigned x;
        int bits;
 
-       T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR)));
+       T(YAFFS_TRACE_TRACING,
+         (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR)));
 
        /* Check stuff that must be set */
 
@@ -4852,18 +4852,12 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        /* Check geometry parameters. */
 
-       if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) ||
-           (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) ||
-           (dev->param.inband_tags && !dev->param.is_yaffs2) ||
-            dev->param.chunks_per_block < 2 ||
-            dev->param.n_reserved_blocks < 2 ||
-            dev->internal_start_block <= 0 ||
-            dev->internal_end_block <= 0 ||
-            dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) {       /* otherwise it is too small */
+       if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || (dev->param.inband_tags && !dev->param.is_yaffs2) || dev->param.chunks_per_block < 2 || dev->param.n_reserved_blocks < 2 || dev->internal_start_block <= 0 || dev->internal_end_block <= 0 || dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) {     /* otherwise it is too small */
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR
                   ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d "
-                   TENDSTR), dev->param.total_bytes_per_chunk, dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags));
+                   TENDSTR), dev->param.total_bytes_per_chunk,
+                  dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags));
                return YAFFS_FAIL;
        }
 
@@ -4875,7 +4869,9 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        /* Sort out space for inband tags, if required */
        if (dev->param.inband_tags)
-               dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(struct yaffs_packed_tags2_tags_only);
+               dev->data_bytes_per_chunk =
+                   dev->param.total_bytes_per_chunk -
+                   sizeof(struct yaffs_packed_tags2_tags_only);
        else
                dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk;
 
@@ -4910,7 +4906,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        x >>= dev->chunk_shift;
        dev->chunk_div = x;
        /* We only use chunk mask if chunk_div is 1 */
-       dev->chunk_mask = (1<<dev->chunk_shift) - 1;
+       dev->chunk_mask = (1 << dev->chunk_shift) - 1;
 
        /*
         * Calculate chunk_grp_bits.
@@ -4933,7 +4929,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        } else
                dev->tnode_width = 16;
 
-       dev->tnode_mask = (1<<dev->tnode_width)-1;
+       dev->tnode_mask = (1 << dev->tnode_width) - 1;
 
        /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
         * so if the bitwidth of the
@@ -4946,8 +4942,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        else
                dev->chunk_grp_bits = bits - dev->tnode_width;
 
-       dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8;
-       if(dev->tnode_size < sizeof(struct yaffs_tnode))
+       dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8;
+       if (dev->tnode_size < sizeof(struct yaffs_tnode))
                dev->tnode_size = sizeof(struct yaffs_tnode);
 
        dev->chunk_grp_size = 1 << dev->chunk_grp_bits;
@@ -4982,8 +4978,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        dev->n_tags_ecc_unfixed = 0;
        dev->n_erase_failures = 0;
        dev->n_erased_blocks = 0;
-       dev->gc_disable= 0;
-       dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */
+       dev->gc_disable = 0;
+       dev->has_pending_prioritised_gc = 1;    /* Assume the worst for now, will get fixed on first GC */
        INIT_LIST_HEAD(&dev->dirty_dirs);
        dev->oldest_dirty_seq = 0;
        dev->oldest_dirty_block = 0;
@@ -4995,17 +4991,16 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        dev->cache = NULL;
        dev->gc_cleanup_list = NULL;
 
-
-       if (!init_failed &&
-           dev->param.n_caches > 0) {
+       if (!init_failed && dev->param.n_caches > 0) {
                int i;
                void *buf;
-               int cache_bytes = dev->param.n_caches * sizeof(struct yaffs_cache);
+               int cache_bytes =
+                   dev->param.n_caches * sizeof(struct yaffs_cache);
 
                if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
                        dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
 
-               dev->cache =  YMALLOC(cache_bytes);
+               dev->cache = YMALLOC(cache_bytes);
 
                buf = (u8 *) dev->cache;
 
@@ -5016,7 +5011,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                        dev->cache[i].object = NULL;
                        dev->cache[i].last_use = 0;
                        dev->cache[i].dirty = 0;
-                       dev->cache[i].data = buf = YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+                       dev->cache[i].data = buf =
+                           YMALLOC_DMA(dev->param.total_bytes_per_chunk);
                }
                if (!buf)
                        init_failed = 1;
@@ -5027,7 +5023,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        dev->cache_hits = 0;
 
        if (!init_failed) {
-               dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(u32));
+               dev->gc_cleanup_list =
+                   YMALLOC(dev->param.chunks_per_block * sizeof(u32));
                if (!dev->gc_cleanup_list)
                        init_failed = 1;
        }
@@ -5043,14 +5040,15 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        if (!init_failed && !yaffs_create_initial_dir(dev))
                init_failed = 1;
 
-
        if (!init_failed) {
                /* Now scan the flash. */
                if (dev->param.is_yaffs2) {
                        if (yaffs2_checkpt_restore(dev)) {
                                yaffs_check_obj_details_loaded(dev->root_dir);
                                T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR("yaffs: restored from checkpoint" TENDSTR)));
+                                 (TSTR
+                                  ("yaffs: restored from checkpoint"
+                                   TENDSTR)));
                        } else {
 
                                /* Clean up the mess caused by an aborted checkpoint load
@@ -5073,18 +5071,19 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
                                yaffs_init_tnodes_and_objs(dev);
 
-                               if (!init_failed && !yaffs_create_initial_dir(dev))
+                               if (!init_failed
+                                   && !yaffs_create_initial_dir(dev))
                                        init_failed = 1;
 
                                if (!init_failed && !yaffs2_scan_backwards(dev))
                                        init_failed = 1;
                        }
                } else if (!yaffs1_scan(dev))
-                               init_failed = 1;
+                       init_failed = 1;
 
                yaffs_strip_deleted_objs(dev);
                yaffs_fix_hanging_objs(dev);
-               if(dev->param.empty_lost_n_found)
+               if (dev->param.empty_lost_n_found)
                        yaffs_empty_l_n_f(dev);
        }
 
@@ -5110,7 +5109,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        yaffs_verify_blocks(dev);
 
        /* Clean up any aborted checkpoint data */
-       if(!dev->is_checkpointed && dev->blocks_in_checkpt > 0)
+       if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0)
                yaffs2_checkpt_invalidate(dev);
 
        T(YAFFS_TRACE_TRACING,
@@ -5126,8 +5125,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
                yaffs_deinit_blocks(dev);
                yaffs_deinit_tnodes_and_objs(dev);
-               if (dev->param.n_caches > 0 &&
-                   dev->cache) {
+               if (dev->param.n_caches > 0 && dev->cache) {
 
                        for (i = 0; i < dev->param.n_caches; i++) {
                                if (dev->cache[i].data)
@@ -5153,7 +5151,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
 int yaffs_count_free_chunks(struct yaffs_dev *dev)
 {
-       int n_free=0;
+       int n_free = 0;
        int b;
 
        struct yaffs_block_info *blk;
@@ -5199,7 +5197,8 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 
        n_free -= n_dirty_caches;
 
-       n_free -= ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block);
+       n_free -=
+           ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block);
 
        /* Now we figure out how much to reserve for the checkpoint and report that... */
        blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev);
index fe6e934..60770ca 100644 (file)
 
 #define YAFFS_MAX_CHUNK_ID             0x000FFFFF
 
-
 #define YAFFS_ALLOCATION_NOBJECTS      100
 #define YAFFS_ALLOCATION_NTNODES       100
 #define YAFFS_ALLOCATION_NLINKS                100
 
 #define YAFFS_NOBJECT_BUCKETS          256
 
-
 #define YAFFS_OBJECT_SPACE             0x40000
 #define YAFFS_MAX_OBJECT_ID            (YAFFS_OBJECT_SPACE -1)
 
@@ -85,7 +83,6 @@
 #define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20
 #define YAFFS_SEQUENCE_CHECKPOINT_DATA  0x21
 
-
 #define YAFFS_MAX_SHORT_OP_CACHES      20
 
 #define YAFFS_N_TEMP_BUFFERS           6
@@ -118,9 +115,7 @@ struct yaffs_cache {
        int n_bytes;            /* Only valid if the cache is dirty */
        int locked;             /* Can't push out or flush while locked. */
        u8 *data;
-} ;
-
-
+};
 
 /* Tags structures in RAM
  * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise
@@ -137,10 +132,10 @@ struct yaffs_tags {
        unsigned n_bytes_msb:2;
 };
 
-union yaffs_tags_union{
+union yaffs_tags_union {
        struct yaffs_tags as_tags;
        u8 as_bytes[8];
-} ;
+};
 
 #endif
 
@@ -151,7 +146,7 @@ enum yaffs_ecc_result {
        YAFFS_ECC_RESULT_NO_ERROR,
        YAFFS_ECC_RESULT_FIXED,
        YAFFS_ECC_RESULT_UNFIXED
-} ;
+};
 
 enum yaffs_obj_type {
        YAFFS_OBJECT_TYPE_UNKNOWN,
@@ -160,11 +155,11 @@ enum yaffs_obj_type {
        YAFFS_OBJECT_TYPE_DIRECTORY,
        YAFFS_OBJECT_TYPE_HARDLINK,
        YAFFS_OBJECT_TYPE_SPECIAL
-} ;
+};
 
 #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL
 
-struct yaffs_ext_tags{
+struct yaffs_ext_tags {
 
        unsigned validity0;
        unsigned chunk_used;    /*  Status of the chunk: used or unused */
@@ -188,11 +183,11 @@ struct yaffs_ext_tags{
        unsigned extra_available;       /* There is extra info available if this is not zero */
        unsigned extra_parent_id;       /* The parent object */
        unsigned extra_is_shrink;       /* Is it a shrink header? */
-       unsigned extra_shadows;         /* Does this shadow another object? */
+       unsigned extra_shadows; /* Does this shadow another object? */
 
        enum yaffs_obj_type extra_obj_type;     /* What object type? */
 
-       unsigned extra_length;          /* Length if it is a file */
+       unsigned extra_length;  /* Length if it is a file */
        unsigned extra_equiv_id;        /* Equivalent object Id if it is a hard link */
 
        unsigned validity1;
@@ -200,12 +195,12 @@ struct yaffs_ext_tags{
 };
 
 /* Spare structure for YAFFS1 */
-struct yaffs_spare{
+struct yaffs_spare {
        u8 tb0;
        u8 tb1;
        u8 tb2;
        u8 tb3;
-       u8 page_status; /* set to 0 to delete the chunk */
+       u8 page_status;         /* set to 0 to delete the chunk */
        u8 block_status;
        u8 tb4;
        u8 tb5;
@@ -213,7 +208,7 @@ struct yaffs_spare{
        u8 tb6;
        u8 tb7;
        u8 ecc2[3];
-} ;
+};
 
 /*Special structure for passing through to mtd */
 struct yaffs_nand_spare {
@@ -224,11 +219,11 @@ struct yaffs_nand_spare {
 
 /* Block data in RAM */
 
-enum yaffs_block_state{
+enum yaffs_block_state {
        YAFFS_BLOCK_STATE_UNKNOWN = 0,
 
        YAFFS_BLOCK_STATE_SCANNING,
-        /* Being scanned */
+       /* Being scanned */
 
        YAFFS_BLOCK_STATE_NEEDS_SCANNING,
        /* The block might have something on it (ie it is allocating or full, perhaps empty)
@@ -246,13 +241,13 @@ enum yaffs_block_state{
         * At least one page holds valid data.
         * This is the one currently being used for page
         * allocation. Should never be more than one of these.
-         * If a block is only partially allocated at mount it is treated as full.
+        * If a block is only partially allocated at mount it is treated as full.
         */
 
        YAFFS_BLOCK_STATE_FULL,
        /* All the pages in this block have been allocated.
-         * If a block was only partially allocated when mounted we treat
-         * it as fully allocated.
+        * If a block was only partially allocated when mounted we treat
+        * it as fully allocated.
         */
 
        YAFFS_BLOCK_STATE_DIRTY,
@@ -267,30 +262,29 @@ enum yaffs_block_state{
        /* This block is being garbage collected */
 
        YAFFS_BLOCK_STATE_DEAD
-       /* This block has failed and is not in use */
+           /* This block has failed and is not in use */
 };
 
 #define        YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1)
 
-
-struct yaffs_block_info{
+struct yaffs_block_info {
 
        int soft_del_pages:10;  /* number of soft deleted pages */
        int pages_in_use:10;    /* number of pages in use */
        unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */
        u32 needs_retiring:1;   /* Data has failed on this block, need to get valid data off */
-                               /* and retire the block. */
-       u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */
-       u32 gc_prioritise:1;    /* An ECC check or blank check has failed on this block.
+       /* and retire the block. */
+       u32 skip_erased_check:1;        /* If this is set we can skip the erased check on this block */
+       u32 gc_prioritise:1;    /* An ECC check or blank check has failed on this block.
                                   It should be prioritised for GC */
-       u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
+       u32 chunk_error_strikes:3;      /* How many times we've had ecc etc failures on this block and tried to reuse it */
 
 #ifdef CONFIG_YAFFS_YAFFS2
-       u32 has_shrink_hdr:1; /* This block has at least one shrink object header */
-       u32 seq_number;  /* block sequence number for yaffs2 */
+       u32 has_shrink_hdr:1;   /* This block has at least one shrink object header */
+       u32 seq_number;         /* block sequence number for yaffs2 */
 #endif
 
-} ;
+};
 
 /* -------------------------- Object structure -------------------------------*/
 /* This is the object structure as stored on NAND */
@@ -300,11 +294,11 @@ struct yaffs_obj_hdr {
 
        /* Apply to everything  */
        int parent_obj_id;
-       u16 sum_no_longer_used;        /* checksum of name. No longer used */
+       u16 sum_no_longer_used; /* checksum of name. No longer used */
        YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
        /* The following apply to directories, files, symlinks - not hard links */
-       u32 yst_mode;         /* protection */
+       u32 yst_mode;           /* protection */
 
        u32 yst_uid;
        u32 yst_gid;
@@ -344,8 +338,6 @@ struct yaffs_tnode {
        struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL];
 };
 
-
-
 /*------------------------  Object -----------------------------*/
 /* An object can be one of:
  * - a directory (no data, has children links
@@ -360,35 +352,33 @@ struct yaffs_file_var {
        u32 shrink_size;
        int top_level;
        struct yaffs_tnode *top;
-} ;
+};
 
-struct yaffs_dir_var{
-       struct list_head children;     /* list of child links */
+struct yaffs_dir_var {
+       struct list_head children;      /* list of child links */
        struct list_head dirty; /* Entry for list of dirty directories */
 };
 
-struct yaffs_symlink_var{
+struct yaffs_symlink_var {
        YCHAR *alias;
 };
 
-struct yaffs_hardlink_var{
+struct yaffs_hardlink_var {
        struct yaffs_obj *equiv_obj;
        u32 equiv_id;
 };
 
-union yaffs_obj_var{
+union yaffs_obj_var {
        struct yaffs_file_var file_variant;
        struct yaffs_dir_var dir_variant;
        struct yaffs_symlink_var symlink_variant;
        struct yaffs_hardlink_var hardlink_variant;
 };
 
-
-
 struct yaffs_obj {
        u8 deleted:1;           /* This should only apply to unlinked files. */
-       u8 soft_del:1;  /* it has also been soft deleted */
-       u8 unlinked:1;  /* An unlinked file. The file should be in the unlinked directory.*/
+       u8 soft_del:1;          /* it has also been soft deleted */
+       u8 unlinked:1;          /* An unlinked file. The file should be in the unlinked directory. */
        u8 fake:1;              /* A fake object has no presence on NAND. */
        u8 rename_allowed:1;    /* Some objects are not allowed to be renamed. */
        u8 unlink_allowed:1;
@@ -407,16 +397,16 @@ struct yaffs_obj {
        u8 is_shadowed:1;       /* This object is shadowed on the way to being renamed. */
 
        u8 xattr_known:1;       /* We know if this has object has xattribs or not. */
-       u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */
+       u8 has_xattr:1;         /* This object has xattribs. Valid if xattr_known. */
 
        u8 serial;              /* serial number of chunk in NAND. Cached here */
        u16 sum;                /* sum of the name to speed searching */
 
-       struct yaffs_dev *my_dev;       /* The device I'm on */
+       struct yaffs_dev *my_dev;       /* The device I'm on */
 
-       struct list_head hash_link;     /* list of objects in this hash bucket */
+       struct list_head hash_link;     /* list of objects in this hash bucket */
 
-       struct list_head hard_links;    /* all the equivalent hard linked objects */
+       struct list_head hard_links;    /* all the equivalent hard linked objects */
 
        /* directory structure stuff */
        /* also used for linking up the free list */
@@ -461,14 +451,13 @@ struct yaffs_obj {
 struct yaffs_obj_bucket {
        struct list_head list;
        int count;
-} ;
-
+};
 
 /* yaffs_checkpt_obj holds the definition of an object as dumped
  * by checkpointing.
  */
 
-struct yaffs_checkpt_obj{
+struct yaffs_checkpt_obj {
        int struct_type;
        u32 obj_id;
        u32 parent_id;
@@ -492,42 +481,40 @@ struct yaffs_checkpt_obj{
 
 struct yaffs_buffer {
        u8 *buffer;
-       int line;       /* track from whence this buffer was allocated */
+       int line;               /* track from whence this buffer was allocated */
        int max_line;
-} ;
+};
 
 /*----------------- Device ---------------------------------*/
 
-
 struct yaffs_param {
        const YCHAR *name;
 
        /*
-         * Entry parameters set up way early. Yaffs sets up the rest.
-         * The structure should be zeroed out before use so that unused
-         * and defualt values are zero.
-         */
+        * Entry parameters set up way early. Yaffs sets up the rest.
+        * The structure should be zeroed out before use so that unused
+        * and defualt values are zero.
+        */
 
-       int inband_tags;          /* Use unband tags */
-       u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */
+       int inband_tags;        /* Use unband tags */
+       u32 total_bytes_per_chunk;      /* Should be >= 512, does not need to be a power of 2 */
        int chunks_per_block;   /* does not need to be a power of 2 */
        int spare_bytes_per_chunk;      /* spare area size */
-       int start_block;                /* Start block we're allowed to use */
+       int start_block;        /* Start block we're allowed to use */
        int end_block;          /* End block we're allowed to use */
        int n_reserved_blocks;  /* We want this tuneable so that we can reduce */
-                               /* reserved blocks on NOR and RAM. */
+       /* reserved blocks on NOR and RAM. */
 
-
-       int n_caches;   /* If <= 0, then short op caching is disabled, else
+       int n_caches;           /* If <= 0, then short op caching is disabled, else
                                 * the number of short op caches (don't use too many).
-                                 * 10 to 20 is a good bet.
+                                * 10 to 20 is a good bet.
                                 */
-       int use_nand_ecc;               /* Flag to decide whether or not to use NANDECC on data (yaffs1) */
-       int no_tags_ecc;                /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ 
+       int use_nand_ecc;       /* Flag to decide whether or not to use NANDECC on data (yaffs1) */
+       int no_tags_ecc;        /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */
 
-       int is_yaffs2;           /* Use yaffs2 mode on this device */
+       int is_yaffs2;          /* Use yaffs2 mode on this device */
 
-       int empty_lost_n_found;  /* Auto-empty lost+found directory on mount */
+       int empty_lost_n_found; /* Auto-empty lost+found directory on mount */
 
        int refresh_period;     /* How often we should check to do a block refresh */
 
@@ -537,63 +524,62 @@ struct yaffs_param {
 
        int enable_xattr;       /* Enable xattribs */
 
-       /* NAND access functions (Must be set before calling YAFFS)*/
+       /* NAND access functions (Must be set before calling YAFFS) */
 
-       int (*write_chunk_fn) (struct yaffs_dev *dev,
-                                       int nand_chunk, const u8 *data,
-                                       const struct yaffs_spare *spare);
-       int (*read_chunk_fn) (struct yaffs_dev *dev,
-                                       int nand_chunk, u8 *data,
-                                       struct yaffs_spare *spare);
-       int (*erase_fn) (struct yaffs_dev *dev,
-                                       int flash_block);
-       int (*initialise_flash_fn) (struct yaffs_dev *dev);
-       int (*deinitialise_flash_fn) (struct yaffs_dev *dev);
+       int (*write_chunk_fn) (struct yaffs_dev * dev,
+                              int nand_chunk, const u8 * data,
+                              const struct yaffs_spare * spare);
+       int (*read_chunk_fn) (struct yaffs_dev * dev,
+                             int nand_chunk, u8 * data,
+                             struct yaffs_spare * spare);
+       int (*erase_fn) (struct yaffs_dev * dev, int flash_block);
+       int (*initialise_flash_fn) (struct yaffs_dev * dev);
+       int (*deinitialise_flash_fn) (struct yaffs_dev * dev);
 
 #ifdef CONFIG_YAFFS_YAFFS2
-       int (*write_chunk_tags_fn) (struct yaffs_dev *dev,
-                                        int nand_chunk, const u8 *data,
-                                        const struct yaffs_ext_tags *tags);
-       int (*read_chunk_tags_fn) (struct yaffs_dev *dev,
-                                         int nand_chunk, u8 *data,
-                                         struct yaffs_ext_tags *tags);
-       int (*bad_block_fn) (struct yaffs_dev *dev, int block_no);
-       int (*query_block_fn) (struct yaffs_dev *dev, int block_no,
-                              enum yaffs_block_state *state, u32 *seq_number);
+       int (*write_chunk_tags_fn) (struct yaffs_dev * dev,
+                                   int nand_chunk, const u8 * data,
+                                   const struct yaffs_ext_tags * tags);
+       int (*read_chunk_tags_fn) (struct yaffs_dev * dev,
+                                  int nand_chunk, u8 * data,
+                                  struct yaffs_ext_tags * tags);
+       int (*bad_block_fn) (struct yaffs_dev * dev, int block_no);
+       int (*query_block_fn) (struct yaffs_dev * dev, int block_no,
+                              enum yaffs_block_state * state,
+                              u32 * seq_number);
 #endif
 
        /* The remove_obj_fn function must be supplied by OS flavours that
         * need it.
-         * yaffs direct uses it to implement the faster readdir.
-         * Linux uses it to protect the directory during unlocking.
+        * yaffs direct uses it to implement the faster readdir.
+        * Linux uses it to protect the directory during unlocking.
         */
-       void (*remove_obj_fn)(struct yaffs_obj *obj);
+       void (*remove_obj_fn) (struct yaffs_obj * obj);
 
        /* Callback to mark the superblock dirty */
-       void (*sb_dirty_fn)(struct yaffs_dev *dev);
-       
+       void (*sb_dirty_fn) (struct yaffs_dev * dev);
+
        /*  Callback to control garbage collection. */
-       unsigned (*gc_control)(struct yaffs_dev *dev);
+       unsigned (*gc_control) (struct yaffs_dev * dev);
 
-        /* Debug control flags. Don't use unless you know what you're doing */
+       /* Debug control flags. Don't use unless you know what you're doing */
        int use_header_file_size;       /* Flag to determine if we should use file sizes from the header */
        int disable_lazy_load;  /* Disable lazy loading on this device */
-       int wide_tnodes_disabled; /* Set to disable wide tnodes */
-       int disable_soft_del;  /* yaffs 1 only: Set to disable the use of softdeletion. */
-       
-       int defered_dir_update; /* Set to defer directory updates */
+       int wide_tnodes_disabled;       /* Set to disable wide tnodes */
+       int disable_soft_del;   /* yaffs 1 only: Set to disable the use of softdeletion. */
+
+       int defered_dir_update; /* Set to defer directory updates */
 
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
        int auto_unicode;
 #endif
-       int always_check_erased; /* Force chunk erased check always on */
+       int always_check_erased;        /* Force chunk erased check always on */
 };
 
-
 struct yaffs_dev {
        struct yaffs_param param;
 
-        /* Context storage. Holds extra OS specific data for this device */
+       /* Context storage. Holds extra OS specific data for this device */
 
        void *os_context;
        void *driver_context;
@@ -601,12 +587,12 @@ struct yaffs_dev {
        struct list_head dev_list;
 
        /* Runtime parameters. Set up by YAFFS. */
-       int data_bytes_per_chunk;       
+       int data_bytes_per_chunk;
 
-        /* Non-wide tnode stuff */
+       /* Non-wide tnode stuff */
        u16 chunk_grp_bits;     /* Number of bits that need to be resolved if
-                                 * the tnodes are not wide enough.
-                                 */
+                                * the tnodes are not wide enough.
+                                */
        u16 chunk_grp_size;     /* == 2^^chunk_grp_bits */
 
        /* Stuff to support wide tnodes */
@@ -615,26 +601,22 @@ struct yaffs_dev {
        u32 tnode_size;
 
        /* Stuff for figuring out file offset to chunk conversions */
-       u32 chunk_shift; /* Shift value */
-       u32 chunk_div;   /* Divisor after shifting: 1 for power-of-2 sizes */
-       u32 chunk_mask;  /* Mask to use for power-of-2 case */
-
-
+       u32 chunk_shift;        /* Shift value */
+       u32 chunk_div;          /* Divisor after shifting: 1 for power-of-2 sizes */
+       u32 chunk_mask;         /* Mask to use for power-of-2 case */
 
        int is_mounted;
        int read_only;
        int is_checkpointed;
 
-
        /* Stuff to support block offsetting to support start block zero */
        int internal_start_block;
        int internal_end_block;
        int block_offset;
        int chunk_offset;
 
-
        /* Runtime checkpointing stuff */
-       int checkpt_page_seq;   /* running sequence number of checkpoint pages */
+       int checkpt_page_seq;   /* running sequence number of checkpoint pages */
        int checkpt_byte_count;
        int checkpt_byte_offs;
        u8 *checkpt_buffer;
@@ -648,11 +630,11 @@ struct yaffs_dev {
        u32 checkpt_sum;
        u32 checkpt_xor;
 
-       int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */
+       int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */
 
        /* Block Info */
        struct yaffs_block_info *block_info;
-       u8 *chunk_bits; /* bitmap of chunks in use */
+       u8 *chunk_bits;         /* bitmap of chunks in use */
        unsigned block_info_alt:1;      /* was allocated using alternative strategy */
        unsigned chunk_bits_alt:1;      /* was allocated using alternative strategy */
        int chunk_bit_stride;   /* Number of bytes of chunk_bits per block.
@@ -680,7 +662,7 @@ struct yaffs_dev {
        u32 *gc_cleanup_list;   /* objects to delete at the end of a GC. */
        u32 n_clean_ups;
 
-       unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */
+       unsigned has_pending_prioritised_gc;    /* We think this device might have pending prioritised gcs */
        unsigned gc_disable;
        unsigned gc_block_finder;
        unsigned gc_dirtiest;
@@ -705,12 +687,12 @@ struct yaffs_dev {
        struct yaffs_cache *cache;
        int cache_last_use;
 
-       /* Stuff for background deletion and unlinked files.*/
+       /* Stuff for background deletion and unlinked files. */
        struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted files live. */
        struct yaffs_obj *del_dir;      /* Directory where deleted objects are sent to disappear. */
-       struct yaffs_obj *unlinked_deletion;    /* Current file being background deleted.*/
-       int n_deleted_files;            /* Count of files awaiting deletion;*/
-       int n_unlinked_files;           /* Count of unlinked files. */
+       struct yaffs_obj *unlinked_deletion;    /* Current file being background deleted. */
+       int n_deleted_files;    /* Count of files awaiting deletion; */
+       int n_unlinked_files;   /* Count of unlinked files. */
        int n_bg_deletions;     /* Count of background deletions. */
 
        /* Temporary buffer management */
@@ -729,8 +711,7 @@ struct yaffs_dev {
        int refresh_skip;       /* A skip down counter. Refresh happens when this gets to zero. */
 
        /* Dirty directory handling */
-       struct list_head dirty_dirs; /* List of dirty directories */
-
+       struct list_head dirty_dirs;    /* List of dirty directories */
 
        /* Statistcs */
        u32 n_page_writes;
@@ -756,19 +737,18 @@ struct yaffs_dev {
 
 };
 
-
 /* The CheckpointDevice structure holds the device information that changes at runtime and
  * must be preserved over unmount/mount cycles.
  */
-struct yaffs_checkpt_dev{
+struct yaffs_checkpt_dev {
        int struct_type;
        int n_erased_blocks;
        int alloc_block;        /* Current block being allocated off */
        u32 alloc_page;
        int n_free_chunks;
 
-       int n_deleted_files;            /* Count of files awaiting deletion;*/
-       int n_unlinked_files;           /* Count of unlinked files. */
+       int n_deleted_files;    /* Count of files awaiting deletion; */
+       int n_unlinked_files;   /* Count of unlinked files. */
        int n_bg_deletions;     /* Count of background deletions. */
 
        /* yaffs2 runtime stuff */
@@ -776,15 +756,13 @@ struct yaffs_checkpt_dev{
 
 };
 
-
-struct yaffs_checkpt_validity{
+struct yaffs_checkpt_validity {
        int struct_type;
        u32 magic;
        u32 version;
        u32 head;
 };
 
-
 struct yaffs_shadow_fixer {
        int obj_id;
        int shadowed_id;
@@ -792,8 +770,8 @@ struct yaffs_shadow_fixer {
 };
 
 /* Structure for doing xattr modifications */
-struct yaffs_xattr_mod{
-       int set; /* If 0 then this is a deletion */
+struct yaffs_xattr_mod {
+       int set;                /* If 0 then this is a deletion */
        const YCHAR *name;
        const void *data;
        int size;
@@ -801,7 +779,6 @@ struct yaffs_xattr_mod{
        int result;
 };
 
-
 /*----------------------- YAFFS Functions -----------------------*/
 
 int yaffs_guts_initialise(struct yaffs_dev *dev);
@@ -809,27 +786,28 @@ void yaffs_deinitialise(struct yaffs_dev *dev);
 
 int yaffs_get_n_free_chunks(struct yaffs_dev *dev);
 
-int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
-                      struct yaffs_obj *new_dir, const YCHAR *new_name);
+int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
+                    struct yaffs_obj *new_dir, const YCHAR * new_name);
 
-int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name);
+int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name);
 int yaffs_del_obj(struct yaffs_obj *obj);
 
-int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size);
+int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size);
 int yaffs_get_obj_length(struct yaffs_obj *obj);
 int yaffs_get_obj_inode(struct yaffs_obj *obj);
 unsigned yaffs_get_obj_type(struct yaffs_obj *obj);
 int yaffs_get_obj_link_count(struct yaffs_obj *obj);
 
 /* File operations */
-int yaffs_file_rd(struct yaffs_obj *obj, u8 *buffer, loff_t offset,
-                               int n_bytes);
-int yaffs_wr_file(struct yaffs_obj *obj, const u8 *buffer, loff_t offset,
-                               int n_bytes, int write_trhrough);
+int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset,
+                 int n_bytes);
+int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset,
+                 int n_bytes, int write_trhrough);
 int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size);
 
-struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, const YCHAR *name,
-                               u32 mode, u32 uid, u32 gid);
+struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent,
+                                   const YCHAR * name, u32 mode, u32 uid,
+                                   u32 gid);
 
 int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync);
 
@@ -840,32 +818,35 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev);
 int yaffs_checkpoint_restore(struct yaffs_dev *dev);
 
 /* Directory operations */
-struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name,
-                               u32 mode, u32 uid, u32 gid);
-struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, const YCHAR *name);
+struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name,
+                                  u32 mode, u32 uid, u32 gid);
+struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir,
+                                    const YCHAR * name);
 struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number);
 
 /* Link operations */
-struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name,
-                        struct yaffs_obj *equiv_obj);
+struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name,
+                                struct yaffs_obj *equiv_obj);
 
 struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj);
 
 /* Symlink operations */
-struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, const YCHAR *name,
-                                u32 mode, u32 uid, u32 gid,
-                                const YCHAR *alias);
+struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent,
+                                      const YCHAR * name, u32 mode, u32 uid,
+                                      u32 gid, const YCHAR * alias);
 YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj);
 
 /* Special inodes (fifos, sockets and devices) */
-struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, const YCHAR *name,
-                                u32 mode, u32 uid, u32 gid, u32 rdev);
-
-
-int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, const void * value, int size, int flags);
-int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, int size);
+struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent,
+                                      const YCHAR * name, u32 mode, u32 uid,
+                                      u32 gid, u32 rdev);
+
+int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
+                     const void *value, int size, int flags);
+int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
+                     int size);
 int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size);
-int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name);
+int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name);
 
 /* Special directories */
 struct yaffs_obj *yaffs_root(struct yaffs_dev *dev);
@@ -883,49 +864,51 @@ int yaffs_dump_obj(struct yaffs_obj *obj);
 void yaffs_guts_test(struct yaffs_dev *dev);
 
 /* A few useful functions to be used within the core files*/
-void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int lyn);
-int yaffs_check_ff(u8 *buffer, int n_bytes);
-void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi);
+void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
+                    int lyn);
+int yaffs_check_ff(u8 * buffer, int n_bytes);
+void yaffs_handle_chunk_error(struct yaffs_dev *dev,
+                             struct yaffs_block_info *bi);
 
 u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no);
-void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no);
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no);
 
 struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
-                                               int number,
-                                               enum yaffs_obj_type type);
+                                                int number,
+                                                enum yaffs_obj_type type);
 int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                               int nand_chunk, int in_scan);
-void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name);
+                           int nand_chunk, int in_scan);
+void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name);
 void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
-                                const struct yaffs_obj_hdr *oh);
-void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
-                                       struct yaffs_obj *obj);
-YCHAR *yaffs_clone_str(const YCHAR *str);
+                               const struct yaffs_obj_hdr *oh);
+void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj);
+YCHAR *yaffs_clone_str(const YCHAR * str);
 void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list);
 void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no);
-int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name,
-                               int force, int is_shrink, int shadows,
-                                struct yaffs_xattr_mod *xop);
+int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name,
+                   int force, int is_shrink, int shadows,
+                   struct yaffs_xattr_mod *xop);
 void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
-                               int backward_scanning);
+                              int backward_scanning);
 int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks);
 struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev);
 struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
-                                       struct yaffs_file_var *file_struct,
-                                       u32 chunk_id,
-                                       struct yaffs_tnode *passed_tn);
+                                          struct yaffs_file_var *file_struct,
+                                          u32 chunk_id,
+                                          struct yaffs_tnode *passed_tn);
 
-int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
-                       int n_bytes, int write_trhrough);
-void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size);
+int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset,
+                    int n_bytes, int write_trhrough);
+void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size);
 void yaffs_skip_rest_of_block(struct yaffs_dev *dev);
 
 int yaffs_count_free_chunks(struct yaffs_dev *dev);
 
 struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
-                               struct yaffs_file_var *file_struct,
-                               u32 chunk_id);
+                                      struct yaffs_file_var *file_struct,
+                                      u32 chunk_id);
 
-u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos);
+u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
+                        unsigned pos);
 
 #endif
index 9c463a9..84d1ce8 100644 (file)
 #include "yportenv.h"
 
 struct yaffs_linux_context {
-       struct list_head        context_list; /* List of these we have mounted */
+       struct list_head context_list;  /* List of these we have mounted */
        struct yaffs_dev *dev;
-       struct super_block * super;
-       struct task_struct *bg_thread; /* Background thread for this device */
+       struct super_block *super;
+       struct task_struct *bg_thread;  /* Background thread for this device */
        int bg_running;
-        struct semaphore gross_lock;     /* Gross locking semaphore */
-       u8 *spare_buffer;      /* For mtdif2 use. Don't know the size of the buffer
+       struct semaphore gross_lock;    /* Gross locking semaphore */
+       u8 *spare_buffer;       /* For mtdif2 use. Don't know the size of the buffer
                                 * at compile time so we have to allocate it.
                                 */
        struct list_head search_contexts;
-       void (*put_super_fn)(struct super_block *sb);
+       void (*put_super_fn) (struct super_block * sb);
 
        struct task_struct *readdir_process;
        unsigned mount_id;
@@ -39,4 +39,3 @@ struct yaffs_linux_context {
 #define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context))
 
 #endif
-
index cdbe428..7cf53b3 100644 (file)
@@ -13,7 +13,6 @@
 
 #include "yportenv.h"
 
-
 #include "yaffs_mtdif.h"
 
 #include "linux/mtd/mtd.h"
@@ -28,9 +27,9 @@ int nandmtd_erase_block(struct yaffs_dev *dev, int block_no)
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        u32 addr =
            ((loff_t) block_no) * dev->param.total_bytes_per_chunk
-               * dev->param.chunks_per_block;
+           * dev->param.chunks_per_block;
        struct erase_info ei;
-       
+
        int retval = 0;
 
        ei.mtd = mtd;
@@ -53,4 +52,3 @@ int nandmtd_initialise(struct yaffs_dev *dev)
 {
        return YAFFS_OK;
 }
-
index 4f0da74..07ce452 100644 (file)
 #define __YAFFS_MTDIF1_H__
 
 int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
-       const u8 *data, const struct yaffs_ext_tags *tags);
+                             const u8 * data,
+                             const struct yaffs_ext_tags *tags);
 
 int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
-       u8 *data, struct yaffs_ext_tags *tags);
+                            u8 * data, struct yaffs_ext_tags *tags);
 
 int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no);
 
 int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
-       enum yaffs_block_state *state, u32 *seq_number);
+                        enum yaffs_block_state *state, u32 * seq_number);
 
 #endif