yaffs: Redo Lindent

Only applies to Linux files.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>

diff --git a/moduleconfig.h b/moduleconfig.h
index 4b4d6424cdb43138aa648329fcae43a926a59da8..20a08821985788cb66add99fc73f0af1c7174a1c 100644 (file)
--- a/moduleconfig.h
+++ b/moduleconfig.h
@@ -62,7 +62,6 @@
 /* Meaning: Select to disable background processing */
 /* #define CONFIG_DISABLE_BACKGROUND */
 
 /* Meaning: Select to disable background processing */
 /* #define CONFIG_DISABLE_BACKGROUND */
 

-

 /* Default: Selected */
 /* Meaning: Enable XATTR support */
 #define CONFIG_YAFFS_XATTR
 /* Default: Selected */
 /* Meaning: Enable XATTR support */
 #define CONFIG_YAFFS_XATTR

diff --git a/yaffs_allocator.c b/yaffs_allocator.c
index 35d8869c88fb2e19b7a9d0b959af21fb78c0eaf9..03ede863744809989918ac984065a29abb7fb699 100644 (file)
--- a/yaffs_allocator.c
+++ b/yaffs_allocator.c
@@ -11,8 +11,6 @@
  * published by the Free Software Foundation.
  */
 
  * published by the Free Software Foundation.
  */
 

-
-

 #include "yaffs_allocator.h"
 #include "yaffs_guts.h"
 #include "yaffs_trace.h"
 #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;
 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)
 {
 
 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_tnode *tnodes;
 };
 

-

 struct yaffs_obj_list {
        struct yaffs_obj_list *next;
        struct yaffs_obj *objects;
 };
 
 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;
 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;
 };
 
        struct yaffs_obj_list *allocated_obj_list;
 };
 

-

 static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
 {
 
 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;
 
 
        struct yaffs_tnode_list *tmp;
 

-       if(!allocator){
+       if (!allocator) {

                YBUG();
                return;
        }
                YBUG();
                return;
        }


@@ -123,7 +118,7 @@ static void yaffs_init_raw_tnodes(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
 {
        struct yaffs_allocator *allocator = dev->allocator;
 

-       if(allocator){
+       if (allocator) {

                allocator->alloc_tnode_list = NULL;
                allocator->free_tnodes = NULL;
                allocator->n_free_tnodes = 0;
                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)
 {
 
 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;
        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;
 
        struct yaffs_tnode *next;
        struct yaffs_tnode_list *tnl;
 

-       if(!allocator){
+       if (!allocator) {

                YBUG();
                return YAFFS_FAIL;
        }
                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;
 
        if (n_tnodes < 1)
                return YAFFS_OK;
 

-

        /* make these things */
 
        new_tnodes = YMALLOC(n_tnodes * dev->tnode_size);
        /* 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,
 
        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++) {
                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->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;
 
        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)));
                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;
        } 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;
 }
 
        return YAFFS_OK;
 }
 

-

 struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
 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;
 
        struct yaffs_tnode *tn = NULL;
 

-       if(!allocator){
+       if (!allocator) {

                YBUG();
                return NULL;
        }
                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;
 
 {
        struct yaffs_allocator *allocator = dev->allocator;
 

-       if(!allocator){
+       if (!allocator) {

                YBUG();
                return;
        }
                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++;
        }
                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;
 
 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;
                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;
 
        struct yaffs_allocator *allocator = dev->allocator;
        struct yaffs_obj_list *tmp;
 

-       if(!allocator){
+       if (!allocator) {

                YBUG();
                return;
        }
                YBUG();
                return;
        }


@@ -277,7 +270,6 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
        allocator->n_obj_created = 0;
 }
 
        allocator->n_obj_created = 0;
 }
 

-

 static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 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;
 
        struct yaffs_obj *new_objs;
        struct yaffs_obj_list *list;
 

-       if(!allocator){
+       if (!allocator) {

                YBUG();
                return YAFFS_FAIL;
        }
                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) {
        list = YMALLOC(sizeof(struct yaffs_obj_list));
 
        if (!new_objs || !list) {

-               if (new_objs){
+               if (new_objs) {

                        YFREE(new_objs);
                        new_objs = NULL;
                }
                        YFREE(new_objs);
                        new_objs = NULL;
                }

-               if (list){
+               if (list) {

                        YFREE(list);
                        list = NULL;
                }
                        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 =
        /* 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;
        }
 
        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;
 
        struct yaffs_obj *obj = NULL;
        struct yaffs_allocator *allocator = dev->allocator;
 

-       if(!allocator) {
+       if (!allocator) {

                YBUG();
                return obj;
        }
                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 =
        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;
 }
 
                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;
 
 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. */
                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)
 {
 
 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);
                yaffs_deinit_raw_tnodes(dev);
                yaffs_deinit_raw_objs(dev);
 
                YFREE(dev->allocator);

-               dev->allocator=NULL;
+               dev->allocator = NULL;

        } else
                YBUG();
 }
        } else
                YBUG();
 }


@@ -388,9 +379,9 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator;
 
 {
        struct yaffs_allocator *allocator;
 

-       if(!dev->allocator){
+       if (!dev->allocator) {

                allocator = YMALLOC(sizeof(struct yaffs_allocator));
                allocator = YMALLOC(sizeof(struct yaffs_allocator));

-               if(allocator){
+               if (allocator) {

                        dev->allocator = allocator;
                        yaffs_init_raw_tnodes(dev);
                        yaffs_init_raw_objs(dev);
                        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();
 }
 
                YBUG();
 }
 

-

 #endif
 #endif

diff --git a/yaffs_attribs.c b/yaffs_attribs.c
index 651a473f7f53b50972a3eb9f56dfe9d307f9abe6..aaf46850c655252159ef32901a40884387508102 100644 (file)
--- a/yaffs_attribs.c
+++ b/yaffs_attribs.c
@@ -11,7 +11,6 @@
  * published by the Free Software Foundation.
  */
 
  * published by the Free Software Foundation.
  */
 

-

 #include "yaffs_guts.h"
 #include "yaffs_attribs.h"
 
 #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)
 {
 
 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;
        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)
 {
 
 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)
 {
 }
 
 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;
 }
 
        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;
 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;
                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 0;

-               return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
+               return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);

        default:
                return 0;
        }
        default:
                return 0;
        }


@@ -124,5 +122,3 @@ int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr)
 
        return YAFFS_OK;
 }
 
        return YAFFS_OK;
 }

-
-

diff --git a/yaffs_attribs.h b/yaffs_attribs.h
index c9a08677d5f93392e0ca2c4d30b2b05f157ab100..33d541d69441b430a8629f6a62b5e78559f4b520 100644 (file)
--- a/yaffs_attribs.h
+++ b/yaffs_attribs.h
@@ -16,10 +16,8 @@
 #ifndef __YAFFS_ATTRIBS_H__
 #define __YAFFS_ATTRIBS_H__
 
 #ifndef __YAFFS_ATTRIBS_H__
 #define __YAFFS_ATTRIBS_H__
 

-

 #include "yaffs_guts.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);
 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);
 
 int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr);
 int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr);
 

-

 #endif
 #endif

-

diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c
index d54a27a9067ee1d67496238a0b6b266429bf2563..5d1cfb2965197ba853011551571e2301ec5e9a6d 100644 (file)
--- a/yaffs_bitmap.c
+++ b/yaffs_bitmap.c
@@ -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,
 {
        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 +
                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 ||
 }
 
 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,
                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();
        }
 }
                YBUG();
        }
 }


@@ -102,4 +102,3 @@ int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk)
        }
        return n;
 }
        }
        return n;
 }

-

diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 299130539b2b6fd15b20adbde67d99955260e57d..2cb144c2f4831e4770cf54ce19c65c5d9bac6571 100644 (file)
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -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,
        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;
 }
 
 
        return (blocks_avail <= 0) ? 0 : 1;
 }
 

-

 static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 {
        int i;
 
        if (!dev->param.erase_fn)
                return 0;
 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) {
 
        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++;
 
 
                        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++;
                                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;
                        } 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;
 }
 
        return 1;
 }
 

-

 static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 {
 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,
        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 &&
 
        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;
                        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;
                        }
                }
        }
                                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;
 
        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)
 {
 
 static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 {

-       int  i;
+       int i;

        struct yaffs_ext_tags tags;
 
        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)
 
        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,
                        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;
 
                        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++;
                                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;
                        }
                }
 
                                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;
 }
 
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
 }
 

-

 int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 {
 
 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->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)
                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;
 
        if (!dev->checkpt_buffer)
                return 0;
 

-

        dev->checkpt_page_seq = 0;
        dev->checkpt_byte_count = 0;
        dev->checkpt_sum = 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;
                /* 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++)
                        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;
 }
 
        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;
 {
        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;
 }
        *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;
                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.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 */
        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++;
        }
 
                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,
 
        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++;
        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;
 }
 
        return 1;
 }
 

-

 int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
 {
        int i = 0;
        int ok = 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;
 
        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++;
 
                data_bytes++;
                dev->checkpt_byte_count++;
 

-

                if (dev->checkpt_byte_offs < 0 ||
                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);
        }
 
                        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 ok = 1;
        struct yaffs_ext_tags tags;
 

-

        int chunk;
        int realigned_chunk;
 
        int chunk;
        int realigned_chunk;
 

-       u8 *data_bytes = (u8 *)data;
+       u8 *data_bytes = (u8 *) data;

 
        if (!dev->checkpt_buffer)
                return 0;
 
        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) {
 
 
        while (i < n_bytes && ok) {
 

-

                if (dev->checkpt_byte_offs < 0 ||
                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);
 
                        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 *
                                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;
 
                                realigned_chunk = chunk - dev->chunk_offset;

-                               
+

                                dev->n_page_reads++;
 
                                /* read in the next chunk */
                                dev->param.read_chunk_tags_fn(dev,
                                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++;
 
                                        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) {
                                        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++;
                        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)
 }
 
 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);
        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;
                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;
                        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;
                                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->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;
 
        dev->n_erased_blocks -= dev->blocks_in_checkpt;
 

-

        T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR),
        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 */
 
        if (dev->checkpt_buffer) {
                /* free the buffer */


@@ -390,11 +411,9 @@ int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
 {
        /* Erase the checkpoint data */
 
 {
        /* 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);
 }
 
        return yaffs_checkpt_erase(dev);
 }

-
-
-

diff --git a/yaffs_checkptrw.h b/yaffs_checkptrw.h
index 07ceb3632fcfcfae83de224b7565ff8a1ad12ca7..361c6067717eebb504784b4ba6586cb5a23035f0 100644 (file)
--- a/yaffs_checkptrw.h
+++ b/yaffs_checkptrw.h
@@ -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_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);
 
 
 int yaffs_checkpt_close(struct yaffs_dev *dev);
 
 int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev);
 

-

 #endif
 #endif

diff --git a/yaffs_ecc.c b/yaffs_ecc.c
index 290f8d34644242f53a66d997b57f9e93167633ca..0ea0305e5ceb10025f9e4016c439930631ac9a79 100644 (file)
--- a/yaffs_ecc.c
+++ b/yaffs_ecc.c
@@ -106,7 +106,7 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc)
                b = column_parity_table[*data++];
                col_parity ^= b;
 
                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;
                }
                        line_parity ^= i;
                        line_parity_prime ^= ~i;
                }


@@ -160,11 +160,10 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc)
 #endif
 }
 
 #endif
 }
 

-

 /* Correct the ECC on a 256 byte block of data */
 
 int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc,
 /* 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 */
 
 {
        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)
        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 &&
 
        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);
 
 
                data[byte] ^= (1 << bit);
 

-               return 1; /* Corrected the error */
+               return 1;       /* Corrected the error */

        }
 
        if ((yaffs_count_bits(d0) +
        }
 
        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];
 
                /* 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 */
        }
 
        /* 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,
 /*
  * 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;
 
 {
        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;
 
                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;
                        /* 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,
 }
 
 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 */
 {
        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_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)
 
        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)) {
 
        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);
 
 
                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;
                /* Reccoverable error in ecc */
 
                *read_ecc = *test_ecc;

-               return 1; /* corrected */
+               return 1;       /* corrected */

        }
 
        /* Unrecoverable error */
        }
 
        /* Unrecoverable error */

diff --git a/yaffs_ecc.h b/yaffs_ecc.h
index c2d001368cb62e89b884e567f7a8c25acb10d9d8..b0c461d699e674159363119b4ef999c8c6fddadb 100644 (file)
--- a/yaffs_ecc.h
+++ b/yaffs_ecc.h
@@ -30,15 +30,15 @@ struct yaffs_ecc_other {
        unsigned char col_parity;
        unsigned line_parity;
        unsigned line_parity_prime;
        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,
 
 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,
 
 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,
 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
 #endif

diff --git a/yaffs_getblockinfo.h b/yaffs_getblockinfo.h
index 28bcd54ba33440d661430f792ad985b40983ea49..108c361261049ac2bb6ddf0df8af3f388fcdc1f0 100644 (file)
--- a/yaffs_getblockinfo.h
+++ b/yaffs_getblockinfo.h
@@ -20,7 +20,8 @@
 #include "yaffs_trace.h"
 
 /* Function to manipulate block info */
 #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,
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
                T(YAFFS_TRACE_ERROR,

diff --git a/yaffs_guts.c b/yaffs_guts.c
index ce7ed7ebb870ff3a548781f5d817c782e6d2a69e..a9fc46c0a4814a2a03697c985a074cf2e1d393d0 100644 (file)
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -41,17 +41,15 @@
 
 #include "yaffs_ecc.h"
 
 
 #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,
 /* 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,
 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,
 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);
 
 /* 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,
 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,
 
 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 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,
 
 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,
 
 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_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,
 
 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,
 
 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 */
 
 
 /* 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;
 
 {
        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 */
 
        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 */
 
        } 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 /= 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;
        }
 
        *chunk_out = chunk;


@@ -163,12 +159,12 @@ static u32 calc_shifts(u32 x)
 {
        u32 shifts;
 
 {
        u32 shifts;
 

-       shifts =  0;
+       shifts = 0;

 
        if (!x)
                return 0;
 
 
        if (!x)
                return 0;
 

-       while (!(x&1)) {
+       while (!(x & 1)) {

                x >>= 1;
                shifts++;
        }
                x >>= 1;
                shifts++;
        }


@@ -176,8 +172,6 @@ static u32 calc_shifts(u32 x)
        return shifts;
 }
 
        return shifts;
 }
 

-
-

 /*
  * Temporary buffer manipulations.
  */
 /*
  * 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;
 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));
 
 
        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;
 }
 
        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;
 
 {
        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++)
          (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)));
 
 
        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;
 
 {
        int i;
 


@@ -266,7 +260,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer,
 /*
  * Determine if we have a managed 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;
 
 {
        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,
                return 1;
 
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
+         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));

        return 0;
 }
 
        return 0;
 }
 


@@ -292,9 +286,6 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer)
  * Verification code
  */
 
  * Verification code
  */
 

-
-
-

 /*
  *  Simple hash function. Needs to have a reasonable spread
  */
 /*
  *  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;
 }
 
        return dev->lost_n_found;
 }
 

-

 /*
  *  Erased NAND checking functions
  */
 
 /*
  *  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--) {
 {
        /* Horrible, slow implementation */
        while (n_bytes--) {


@@ -336,8 +326,7 @@ int yaffs_check_ff(u8 *buffer, int n_bytes)
        return 1;
 }
 
        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__);
 {
        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,
 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;
 {
        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;
        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__);
                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,
 }
 
 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;
 {
        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
                 *
                 * 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,
                 * 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++;
 
                /* 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,
                        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 */
 
                                /* 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;
                        }
                }
 
                                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
 
                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_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,
 
        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);
        }
 
                dev->n_retired_writes += (attempts - 1);
        }


@@ -486,8 +473,6 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
        return chunk;
 }
 
        return chunk;
 }
 

-
- 

 /*
  * Block retiring for handling a broken block.
  */
 /*
  * 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);
        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) {
 
        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;
                } 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__);
 
 
                        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 -
                        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__);
                }
 
                        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,
  */
 
 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,
 }
 
 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;
 {
        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->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,
 
                }
        }
 }
 
 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);
 {
        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);
 }
 
        yaffs_skip_rest_of_block(dev);
 }
 

-

 /*---------------- Name handling functions ------------*/
 
 /*---------------- 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;
 
 {
        u16 sum = 0;
        u16 i = 1;
 

-       const YUCHAR *bname = (const YUCHAR *) name;
+       const YUCHAR *bname = (const YUCHAR *)name;

        if (bname) {
        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;
 
                        /* 0x1f mask is case insensitive */
                        sum += ((*bname) & 0x1f) * i;


@@ -610,11 +602,15 @@ static u16 yaffs_calc_name_sum(const YCHAR *name)
        return sum;
 }
 
        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
 {
 #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');
                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);
 }
 
        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
 {
 #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
 #else

-       yaffs_set_obj_name(obj,oh->name);
+       yaffs_set_obj_name(obj, oh->name);

 #endif
 }
 
 #endif
 }
 


@@ -641,16 +639,15 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hd
  * in the tnode.
  */
 
  * in the tnode.
  */
 

-

 struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev)
 {
        struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev);
 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++;
        }
 
                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;
 }
 
        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)
 {
 /* 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->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)
 }
 
 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;
 }
 
        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;
        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++;;
        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,
                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;
        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;
 
 
        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);
                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,
 
 /* 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;
 
 {
        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)
 
        /* 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)
        }
 
        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 >>
 
        /* 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--;
        }
 
                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_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;
 {
        int required_depth;
        int i;


@@ -804,9 +801,9 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
 
        u32 x;
 
 
        u32 x;
 

-

        /* Check sane level and page Id */
        /* 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)
                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++;
        }
 
                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++) {
        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,
                                file_struct->top_level++;
                        } else {
                                T(YAFFS_TRACE_ERROR,

-                                       (TSTR("yaffs: no more tnodes" TENDSTR)));
+                                 (TSTR("yaffs: no more tnodes" TENDSTR)));

                                return NULL;
                        }
                }
                                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;
 
                              (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 ((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) {
                                        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])
                                        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);
                                        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;
                                }
                        }
                                                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) {
        } 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);
                }
        }
                        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,
 }
 
 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++) {
 {
        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,
                                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;
                                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;
 }
 
        return -1;
 }
 

-

 static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 {
        struct yaffs_block_info *the_block;
 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));
 
 
        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++;
        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,
  */
 
 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;
 {
        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,
                                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,
                                        if (all_done) {
                                                yaffs_free_tnode(dev,

-                                                               tn->
-                                                               internal[i]);
+                                                                tn->internal
+                                                                [i]);

                                                tn->internal[i] = NULL;
                                        } else {
                                                /* Hoosterman... how could this happen? */
                                                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,
                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),
                        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,
                        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;
                }
        }
                        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.
  */
 
  * 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;
 {
        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 (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] =
                        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 {
                                }
 
                                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 */
 
                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,
 }
 
 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;
 {
        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 =
 
        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.
 
                /* 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.-------------------*/
 
 
 /*-------------------- 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)
 {
 /* 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);
 
                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;
                /* 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.
                }
 
                /* 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;
        }
 
                obj->being_created = 0;
        }
 

-       dev->checkpoint_blocks_required = 0; /* force recalculation*/
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */

 
        return obj;
 }
 
 
        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) {
 {
 
        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;
                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;
 
 {
        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();
 
        if (!obj)
                YBUG();


@@ -1211,7 +1213,6 @@ static void yaffs_free_obj(struct yaffs_obj *obj)
        if (!list_empty(&obj->siblings))
                YBUG();
 
        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
        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_unhash_obj(obj);
 

-       yaffs_free_raw_obj(dev,obj);
+       yaffs_free_raw_obj(dev, obj);

        dev->n_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)
 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;
 
        int l = 999;
        int lowest = 999999;
 

-

        /* Search for the shortest list or one that
         * isn't too long.
         */
        /* 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,
                        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;
                                }
                        }
                                        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,
 }
 
 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)
        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);
        }
 
        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;
        }
 
                return NULL;
        }
 

-

        if (the_obj) {
                the_obj->fake = 0;
                the_obj->rename_allowed = 1;
        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;
                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;
 
                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:
                        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:
                        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,
 }
 
 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;
 
 {
        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;
 {
        YCHAR *new_str = NULL;
        int len;


@@ -1423,10 +1418,10 @@ YCHAR *yaffs_clone_str(const YCHAR *str)
        if (!str)
                str = _Y("");
 
        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));
        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;
                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,
  */
 
 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;
 
 {
        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;
 
        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);
 
 
        in = yaffs_new_obj(dev, -1, type);
 

-       if (!in){
-               if(str)
+       if (!in) {
+               if (str)

                        YFREE(str);
                return NULL;
        }
 
                        YFREE(str);
                return NULL;
        }
 

-
-
-
-

        if (in) {
                in->hdr_chunk = 0;
                in->valid = 1;
        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.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 =
                        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:
                        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;
 }
 
        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);
 }
 
 {
        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,
 {
        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,
 {
        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.*/
 {
        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);
 {
        /* 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;
 {
        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
                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);
 
 
        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. */
                        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;
 }
 
                        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;
 {
        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;
 
        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)
        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
        /* 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 (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;
 
                /* 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 = 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) {
                        /* 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.
                         *
                         */
                         * 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,
                        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);
                        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);
                }
 
                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);
                        yaffs_update_parent(new_dir);

-               
+

                return result;
        }
        return YAFFS_FAIL;
                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) {
        /* 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->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(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) {
                        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;
        }
                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,
         */
 
        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 */
 
        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 */
                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;
        }
                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 &&
        }
 
        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
                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->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);
 
                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;
 }
 
        return -1;
 }
 

-

 /*
  * Check if there's space to allocate...
  * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()?
 /*
  * 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);
 
 
        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,
 
        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;
 {
        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
        }
 
        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)));
        }
 
                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) +
                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++;
                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++;
 
 
                dev->alloc_page++;
 


@@ -1944,7 +1943,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
        }
 
        T(YAFFS_TRACE_ERROR,
        }
 
        T(YAFFS_TRACE_ERROR,

-                       (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));

 
        return -1;
 }
 
        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)
 {
  */
 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;
                }
        }
 }
 
                        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;
 {
        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);
 
 
        is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT);
 

-

        T(YAFFS_TRACE_TRACING,
        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); */
 
 
        /*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->block_state = YAFFS_BLOCK_STATE_COLLECTING;

-       
+

        bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */
 
        dev->gc_disable = 1;
 
        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,
                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 {
 
                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;
 
                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) &&
                     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 */
                        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,
                                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
 
                                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)
 
                                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)
                                        else if (object->soft_del)

-                                               matching_chunk = old_chunk; /* Defeat the test */
+                                               matching_chunk = old_chunk;     /* Defeat the test */

                                        else
                                        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,
 
                                        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,
                                          (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 &&
                                }
 
                                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.
                                         */
                                        /* 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.
                                        /* 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 */
 
                                        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;
                                                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->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);
 
                                        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;
                                                 */
 
                                                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;
 
                                                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 */
                                                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 =
                                                new_chunk =

-                                                   yaffs_write_new_chunk(dev,(u8 *) oh, &tags, 1);
+                                                   yaffs_write_new_chunk(dev,
+                                                                         (u8 *)
+                                                                         oh,
+                                                                         &tags,
+                                                                         1);

                                        } else
                                                new_chunk =
                                        } 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;
 
                                        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 */
 
                                                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;
                                                } 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)
                                                }
                                        }
                                }
 
                                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_release_temp_buffer(dev, buffer, __LINE__);
 

-
-

        }
 
        yaffs_verify_collected_blk(dev, bi, block);
 
        }
 
        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
        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 =
                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,
                        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
                                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,
                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,
  */
 
 static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,

-                                       int aggressive,
-                                       int background)
+                                   int aggressive, int background)

 {
        int i;
        int iterations;
 {
        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;
                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 &&
 
                        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;
                                }
                                        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.
                 */
 
                 * 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;
 
                        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;
        }
 
                        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.
         */
 
         * block has only a few pages in use.
         */
 

-       if (!selected){
+       if (!selected) {

                int pages_used;
                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;
 
                        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
                        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;
 
                                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;
                                threshold = YAFFS_GC_PASSIVE_THRESHOLD;

-                       if(threshold > max_threshold)
+                       if (threshold > max_threshold)

                                threshold = max_threshold;
 
                        iterations = n_blocks / 16 + 1;
                                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;
                }
 
                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++;
                        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 &&
 
                        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;
                        }
                }
 
                                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;
        }
 
                        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.
         */
 
         * 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);
                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);
                        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;
        }
 
                } else
                        dev->gc_not_done = 0;
        }
 

-       if(selected){
+       if (selected) {

                T(YAFFS_TRACE_GC,
                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++;
 
                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;
                        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--;
                        dev->refresh_skip--;

-       } else{
+       } else {

                dev->gc_not_done++;
                T(YAFFS_TRACE_GC,
                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;
        }
 
        return selected;


@@ -2429,8 +2437,7 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
        int erased_chunks;
        int checkpt_block_adjust;
 
        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) {
                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);
 
 
                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 (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;
 
                                break;
 

-                       if(dev->gc_skip > 20)
+                       if (dev->gc_skip > 20)

                                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--;
                                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;
 
 
                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;
 
                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) {
                }
                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->gc_chunk = 0;

-                       dev->n_clean_ups=0;
+                       dev->n_clean_ups = 0;

                }
 
                if (dev->gc_block > 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
 
                        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);
                }
 
 
                        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"
                        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) &&
                }
        } 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;
 }
 
        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;
 
 {
        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);
 
        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,
 }
 
 /*-------------------------  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;
 
 }
 
 {
        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,
 /*-------------------- 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;
 {
        /*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,
 
                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,
        }
        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;
 {
        /* 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,
 
                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)
 
                /* 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;
 }
 
        return ret_val;
 }
 

-

 int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
 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;
 {
        /* 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,
        }
 
        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 (!tn)
                return YAFFS_FAIL;

-       
-       if(!nand_chunk)
+
+       if (!nand_chunk)

                /* Dummy insert, bail now */
                return YAFFS_OK;
 
                /* 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,
                        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,
 
                                /* Do a proper find */
                                existing_cunk =
                                    yaffs_find_chunk_in_file(in, inode_chunk,

-                                                         &existing_tags);
+                                                            &existing_tags);

                        }
 
                        if (existing_cunk <= 0) {
                        }
 
                        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,
                                 * 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
                                 */
                        } 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;
                        }
                }
                                return YAFFS_OK;
                        }
                }


@@ -2729,8 +2736,7 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
        return YAFFS_OK;
 }
 
        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);
 
 {
        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;
 {
        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;
 
        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,
        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);
 
        bi = yaffs_get_block_info(dev, block);

-       
+

        yaffs2_update_oldest_dirty_seq(dev, block, bi);
 
        T(YAFFS_TRACE_DELETION,
        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,
 }
 
 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.
 {
        /* 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;
 
 
        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);
 
        /* 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 */
                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,
 
        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();
        }
                YBUG();
        }

-       
-               
+

        new_chunk_id =
        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);
 
        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.
  */
 /* 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;
 {
 
        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"));
 
 
        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__);
                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,
 
                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);
 
 
                        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;
 
                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;
 
                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));
 
                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
                } 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 ==
                        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:
                        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 */
                        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;
                        break;
                case YAFFS_OBJECT_TYPE_SYMLINK:
                        alias = in->variant.symlink_variant.alias;

-                       if(!alias)
+                       if (!alias)

                                alias = _Y("no 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 */
                        oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
                        break;
                }
 
                /* process any xattrib modifications */

-               if(xmod)
+               if (xmod)

                        yaffs_apply_xattrib_mod(in, (char *)buffer, xmod);
 
                        yaffs_apply_xattrib_mod(in, (char *)buffer, xmod);
 

-

                /* Tags */
                yaffs_init_tags(&new_tags);
                in->serial++;
                /* 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,
                /* 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) {
 
 
                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,
 
                        if (prev_chunk_id > 0) {
                                yaffs_chunk_del(dev, prev_chunk_id, 1,

-                                                 __LINE__);
+                                               __LINE__);

                        }
 
                        if (!yaffs_obj_cache_dirty(in))
                        }
 
                        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,
                        /* 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;
                        }
 
                                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];
 
        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;
 }
 
                        return 1;
        }
 
        return 0;
 }
 

-

 static void yaffs_flush_file_cache(struct yaffs_obj *obj)
 {
        struct yaffs_dev *dev = obj->my_dev;
 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,
 
                                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;
                        }
                                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,
                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++) {
        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;
 
                }
                                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.
 /* 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 &&
                        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];
                                        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,
 
 /* 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;
 {
        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,
 
 /* 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) {
 {
 
        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) {
 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;
 
                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
 /*--------------------- 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.
  */
 
  * 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;
 {
 
        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.
                 */
                 * 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) {
                        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->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;
                                }
 
                                        cache->n_bytes = 0;
                                }
 


@@ -3359,23 +3356,20 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
 
                                cache->locked = 1;
 
 
                                cache->locked = 1;
 

-

                                memcpy(buffer, &cache->data[start], n_copy);
 
                                cache->locked = 0;
                        } else {
                                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__);
 
                                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);
 
 
                                memcpy(buffer, &local_buffer[start], n_copy);
 

-

                                yaffs_release_temp_buffer(dev, local_buffer,
                                yaffs_release_temp_buffer(dev, local_buffer,

-                                                       __LINE__);
+                                                         __LINE__);

                        }
 
                } else {
                        }
 
                } else {


@@ -3395,8 +3389,8 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
        return n_done;
 }
 
        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;
 {
 
        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 ||
                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.
 
                /* 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)
                        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
                        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;
 
                        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);
 
                            (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 {
                                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;
                }
 
                        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.
                         */
                        /* 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->dirty = 0;
                                        cache->locked = 0;
                                        yaffs_rd_data_obj(in, chunk,

-                                                                     cache->data);
+                                                         cache->data);

                                } else if (cache &&
                                } 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.
                                         */
                                        /* 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;
 
                                }
 
                                if (cache) {
                                        yaffs_use_cache(dev, cache, 1);
                                        cache->locked = 1;
 

-

                                        memcpy(&cache->data[start], buffer,
                                               n_copy);
 
                                        memcpy(&cache->data[start], buffer,
                                               n_copy);
 

-

                                        cache->locked = 0;
                                        cache->n_bytes = n_writeback;
 
                                        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,
                                                    yaffs_wr_data_obj
                                                    (cache->object,
                                                     cache->chunk_id,

-                                                    cache->data, cache->n_bytes,
-                                                    1);
+                                                    cache->data,
+                                                    cache->n_bytes, 1);

                                                cache->dirty = 0;
                                        }
 
                                                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__);
 
                                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,
 
                                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,
 
                                yaffs_release_temp_buffer(dev, local_buffer,

-                                                       __LINE__);
+                                                         __LINE__);

 
                        }
 
                } else {
                        /* A full chunk. Write directly from the supplied buffer. */
 
 
                        }
 
                } else {
                        /* A full chunk. Write directly from the supplied buffer. */
 

-
-

                        chunk_written =
                            yaffs_wr_data_obj(in, chunk, 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);
 
                        /* 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;
 }
 
        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)
 /* ---------------------- 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 <
                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,
                            || 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--;
                                   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;
 {
        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,
                /* 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,
 
                yaffs_wr_data_obj(obj, last_chunk, local_buffer,

-                                            new_partial, 1);
+                                 new_partial, 1);

 
                yaffs_release_temp_buffer(dev, local_buffer, __LINE__);
        }
 
                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);
 }
 
        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;
 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_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 (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 {
                in->variant.file_variant.file_size = new_size;
        } else {

-               /* new_size < old_size */ 
+               /* new_size < old_size */

                yaffs_resize_file_down(in, new_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
 
        /* 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);
 
            in->parent->obj_id != YAFFS_OBJECTID_DELETED)
                yaffs_update_oh(in, NULL, 0, 0, 0, NULL);
 

-

        return YAFFS_OK;
 }
 
        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);
 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)
                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) >=
 
                        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;
                }
        } 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. */
 
        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,
        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));
                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,
        } 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;
        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)
        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) &&
 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)
 }
 
 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)
 {
 
 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);
                YFREE(in->variant.symlink_variant.alias);

-       in->variant.symlink_variant.alias=NULL;
+       in->variant.symlink_variant.alias = NULL;

 
        return yaffs_generic_obj_del(in);
 }
 
        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 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:
        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);
                        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->my_inode)
                del_now = 1;
 

-       if(obj)
+       if (obj)

                yaffs_update_parent(obj->parent);
 
        if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) {
                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];
 
                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_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);
 
                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;
                }
                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,
                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)
 {
 
 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;
 
 }
        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;
 
 {
        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,
 /*----------------------- Initialisation Scanning ---------------------- */
 
 void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,

-                               int backward_scanning)
+                              int backward_scanning)

 {
        struct yaffs_obj *obj;
 
 {
        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 the shadowed object exists then ignore.
                 */
                obj = yaffs_find_by_number(dev, obj_id);

-               if(obj)
+               if (obj)

                        return;
        }
 
                        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 =
         * 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;
        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;
 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;
 
        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,
 
                in = yaffs_find_by_number(dev,

-                                             hl->variant.hardlink_variant.
-                                             equiv_id);
+                                         hl->variant.
+                                         hardlink_variant.equiv_id);

 
                if (in) {
                        /* Add the hardlink pointers */
 
                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)
 {
        /*
 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;
        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,
 
        /* 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);
                }
        }
 
                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);
                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.
  */
  * 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 ||
 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)
 }
 
 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.
         */
 
         * 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) {
                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;
                                        /* 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;
                                        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;
                                        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--;
                                        }
                                                parent = parent->parent;
                                                depth_limit--;
                                        }

-                                       if(parent != dev->root_dir)
+                                       if (parent != dev->root_dir)

                                                hanging = 1;
                                }
                                                hanging = 1;
                                }

-                               if(hanging){
+                               if (hanging) {

                                        T(YAFFS_TRACE_SCAN,
                                        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.
  */
 /*
  * 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;
 
        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();
                YBUG();

-       
+

        list_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
                if (lh) {
                        obj = list_entry(lh, struct yaffs_obj, siblings);
        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,
                                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.
                         */
 
                        /* 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)
 }
 
 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__);
 
                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);
 
                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 =
 
                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)
                        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__);
                }
 
                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.
  */
  * 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;
 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;
                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
                }
 
        } else


@@ -4270,17 +4261,18 @@ void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
 
        T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
 
 
        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);
                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);
        }
 }
                        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);
 
        if (dev && dev->param.remove_obj_fn)
                dev->param.remove_obj_fn(obj);
 

-

        list_del_init(&obj->siblings);
        obj->parent = NULL;
        list_del_init(&obj->siblings);
        obj->parent = NULL;

-       
+

        yaffs_verify_dir(parent);
 }
 
        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,
 {
        if (!directory) {
                T(YAFFS_TRACE_ALWAYS,


@@ -4329,18 +4319,16 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
                YBUG();
        }
 
                YBUG();
        }
 

-

        yaffs_verify_dir(directory);
 
        yaffs_remove_obj_from_dir(obj);
 
        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
        /* 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;
                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,
 }
 
 struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,

-                                    const YCHAR *name)
+                                    const YCHAR * name)

 {
        int sum;
 
 {
        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,
        }
        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();
        }
 
                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) {
 
                        /* 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;
                                        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,
                                /* 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;
                        }
                }
                                        return l;
                        }
                }


@@ -4408,7 +4398,6 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
        return NULL;
 }
 
        return NULL;
 }
 

-

 /* GetEquivalentObject dereferences any hard links to get to the
  * actual object.
  */
 /* 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].
 
  */
  *    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. */
 {
        /* 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;
                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);
                        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);
        }
 }
 
                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
 {
 #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;
                        /* 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--;
                        }
                                *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);
 }
 
        } 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;
 
 {
 #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;
 
                is_ascii = 1;
                w = name;

-       
+

                /* Figure out if the name will fit in ascii character set */
                /* 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++;
                }
 
                                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;
                        /* 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--;
                        }
                                name++;
                                ascii_oh_name++;
                                n--;
                        }

-               } else{
+               } else {

                        /* It is a unicode name, so save starting at the second YCHAR */
                        *oh_name = 0;
                        /* 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
 #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));
 {
        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);
        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
 #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__);
 
                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,
 
                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_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 */
 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_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 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;
        } 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)
        struct list_head *i;
 
        if (!obj->unlinked)

-               count++;                /* the object itself */
+               count++;        /* the object itself */

 
        list_for_each(i, &obj->hard_links)
 
        list_for_each(i, &obj->hard_links)

-               count++;                /* add the hard links; */
+           count++;            /* add the hard links; */

 
        return count;
 }
 
        return count;
 }


@@ -4643,7 +4635,9 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
                return yaffs_clone_str(_Y(""));
 }
 
                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;
 
 {
        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.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);
 
        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;
 }
 
                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);
 
 {
        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);
 
        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;
 }
 
        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;
 {
        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);
 
        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;
 
 
        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.
         */
                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;
        }
 
                        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;
 
                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;
                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;
                }
 
                        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_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;
 }
 
        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);
 }
 
 {
        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);
 }
 
 {
        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, 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 -------------------------------------- */
 }
 
 /*---------------------------- 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.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
 
                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.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 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 */
 
 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 =
        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,
 
        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,
        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;
        }
                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;
 
        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 */
 
 
        /* Check stuff that must be set */
 


@@ -4852,18 +4852,12 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        /* Check geometry parameters. */
 
 
        /* 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 "
                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;
        }
 
                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)
 
        /* 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;
 
        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 */
        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.
 
        /*
         * Calculate chunk_grp_bits.


@@ -4933,7 +4929,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        } else
                dev->tnode_width = 16;
 
        } 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
 
        /* 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;
 
        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;
                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->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;
        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;
 
        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 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;
 
 
                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;
 
 
                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].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;
                }
                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->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;
        }
                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 && !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,
        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
                        } 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);
 
 
                                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;
 
                                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);
 
                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);
        }
 
                        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 */
        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,
                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);
 
                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)
 
                        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 yaffs_count_free_chunks(struct yaffs_dev *dev)
 {

-       int n_free=0;
+       int n_free = 0;

        int b;
 
        struct yaffs_block_info *blk;
        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 -= 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);
 
        /* Now we figure out how much to reserve for the checkpoint and report that... */
        blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev);

diff --git a/yaffs_guts.h b/yaffs_guts.h
index fe6e934497caf7bd710aba715d40586ee1565ff3..60770ca7e10040e0f7da693ad833726586454433 100644 (file)
--- a/yaffs_guts.h
+++ b/yaffs_guts.h
@@ -51,14 +51,12 @@
 
 #define YAFFS_MAX_CHUNK_ID             0x000FFFFF
 
 
 #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_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)
 
 #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_OBJECTID_CHECKPOINT_DATA 0x20
 #define YAFFS_SEQUENCE_CHECKPOINT_DATA  0x21
 

-

 #define YAFFS_MAX_SHORT_OP_CACHES      20
 
 #define YAFFS_N_TEMP_BUFFERS           6
 #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;
        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
 
 /* 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;
 };
 
        unsigned n_bytes_msb:2;
 };
 

-union yaffs_tags_union{
+union yaffs_tags_union {

        struct yaffs_tags as_tags;
        u8 as_bytes[8];
        struct yaffs_tags as_tags;
        u8 as_bytes[8];

-} ;
+};

 
 #endif
 
 
 #endif
 


@@ -151,7 +146,7 @@ enum yaffs_ecc_result {
        YAFFS_ECC_RESULT_NO_ERROR,
        YAFFS_ECC_RESULT_FIXED,
        YAFFS_ECC_RESULT_UNFIXED
        YAFFS_ECC_RESULT_NO_ERROR,
        YAFFS_ECC_RESULT_FIXED,
        YAFFS_ECC_RESULT_UNFIXED

-} ;
+};

 
 enum yaffs_obj_type {
        YAFFS_OBJECT_TYPE_UNKNOWN,
 
 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
        YAFFS_OBJECT_TYPE_DIRECTORY,
        YAFFS_OBJECT_TYPE_HARDLINK,
        YAFFS_OBJECT_TYPE_SPECIAL

-} ;
+};

 
 #define YAFFS_OBJECT_TYPE_MAX 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 */
 
        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_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? */
 
 
        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;
        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 */
 };
 
 /* Spare structure for YAFFS1 */

-struct yaffs_spare{
+struct yaffs_spare {

        u8 tb0;
        u8 tb1;
        u8 tb2;
        u8 tb3;
        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;
        u8 block_status;
        u8 tb4;
        u8 tb5;


@@ -213,7 +208,7 @@ struct yaffs_spare{
        u8 tb6;
        u8 tb7;
        u8 ecc2[3];
        u8 tb6;
        u8 tb7;
        u8 ecc2[3];

-} ;
+};

 
 /*Special structure for passing through to mtd */
 struct yaffs_nand_spare {
 
 /*Special structure for passing through to mtd */
 struct yaffs_nand_spare {


@@ -224,11 +219,11 @@ struct yaffs_nand_spare {
 
 /* Block data in RAM */
 
 
 /* Block data in RAM */
 

-enum yaffs_block_state{
+enum yaffs_block_state {

        YAFFS_BLOCK_STATE_UNKNOWN = 0,
 
        YAFFS_BLOCK_STATE_SCANNING,
        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)
 
        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.
         * 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.
         */
 
        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,
         */
 
        YAFFS_BLOCK_STATE_DIRTY,


@@ -267,30 +262,29 @@ enum yaffs_block_state{
        /* This block is being garbage collected */
 
        YAFFS_BLOCK_STATE_DEAD
        /* 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)
 
 };
 
 #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 */
 
        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 */
                                   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
 
 #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
 
 #endif
 

-} ;
+};

 
 /* -------------------------- Object structure -------------------------------*/
 /* This is the object structure as stored on NAND */
 
 /* -------------------------- 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;
 
        /* 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 */
        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;
 
        u32 yst_uid;
        u32 yst_gid;


@@ -344,8 +338,6 @@ struct yaffs_tnode {
        struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL];
 };
 
        struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL];
 };
 

-
-

 /*------------------------  Object -----------------------------*/
 /* An object can be one of:
  * - a directory (no data, has children links
 /*------------------------  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;
        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 list_head dirty; /* Entry for list of dirty directories */
 };
 

-struct yaffs_symlink_var{
+struct yaffs_symlink_var {

        YCHAR *alias;
 };
 
        YCHAR *alias;
 };
 

-struct yaffs_hardlink_var{
+struct yaffs_hardlink_var {

        struct yaffs_obj *equiv_obj;
        u32 equiv_id;
 };
 
        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_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. */
 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;
        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 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 */
 
 
        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 */
 
        /* 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;
 struct yaffs_obj_bucket {
        struct list_head list;
        int count;

-} ;
-
+};

 
 /* yaffs_checkpt_obj holds the definition of an object as dumped
  * by checkpointing.
  */
 
 
 /* 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;
        int struct_type;
        u32 obj_id;
        u32 parent_id;


@@ -492,42 +481,40 @@ struct yaffs_checkpt_obj{
 
 struct yaffs_buffer {
        u8 *buffer;
 
 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;
        int max_line;

-} ;
+};

 
 /*----------------- Device ---------------------------------*/
 
 
 /*----------------- Device ---------------------------------*/
 

-

 struct yaffs_param {
        const YCHAR *name;
 
        /*
 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 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 */
        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).
                                 * 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 */
 
 
        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 */
 
 
        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
 
 #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.
 #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 */
 
        /* 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. */
        /*  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 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
 
 #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;
 
 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;
 
        void *os_context;
        void *driver_context;


@@ -601,12 +587,12 @@ struct yaffs_dev {
        struct list_head dev_list;
 
        /* Runtime parameters. Set up by YAFFS. */
        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
        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 */
        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 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;
 
 
        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;
 
        /* 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 */
        /* 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;
        int checkpt_byte_count;
        int checkpt_byte_offs;
        u8 *checkpt_buffer;


@@ -648,11 +630,11 @@ struct yaffs_dev {
        u32 checkpt_sum;
        u32 checkpt_xor;
 
        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;
 
        /* 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.
        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;
 
        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;
        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;
 
        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_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 */
        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 */
        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;
 
        /* 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.
  */
 /* 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 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 */
        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;
 };
 
        int struct_type;
        u32 magic;
        u32 version;
        u32 head;
 };
 

-

 struct yaffs_shadow_fixer {
        int obj_id;
        int shadowed_id;
 struct yaffs_shadow_fixer {
        int obj_id;
        int shadowed_id;


@@ -792,8 +770,8 @@ struct yaffs_shadow_fixer {
 };
 
 /* Structure for doing xattr modifications */
 };
 
 /* 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;
        const YCHAR *name;
        const void *data;
        int size;


@@ -801,7 +779,6 @@ struct yaffs_xattr_mod{
        int result;
 };
 
        int result;
 };
 

-

 /*----------------------- YAFFS Functions -----------------------*/
 
 int yaffs_guts_initialise(struct yaffs_dev *dev);
 /*----------------------- 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_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_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_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);
 
 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);
 
 
 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 */
 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_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_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) */
 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_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);
 
 /* 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_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);
 
 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,
 
 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 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,
 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);
 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,
 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,
 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,
 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
 
 #endif

diff --git a/yaffs_linux.h b/yaffs_linux.h
index 9c463a92c375fac07b6d7578255152cf7e1f2c4b..84d1ce8f4d6d8559f75c643c4288f19e54852103 100644 (file)
--- a/yaffs_linux.h
+++ b/yaffs_linux.h
@@ -19,17 +19,17 @@
 #include "yportenv.h"
 
 struct yaffs_linux_context {
 #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 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;
        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;
                                 * 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;
 
        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
 #define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context))
 
 #endif

-

diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c
index cdbe42866ebb4fe4227d8533120eb316bb56015f..7cf53b3d91be5057a0ff9d2dfb6d3994d48b12ac 100644 (file)
--- a/yaffs_mtdif.c
+++ b/yaffs_mtdif.c
@@ -13,7 +13,6 @@
 
 #include "yportenv.h"
 
 
 #include "yportenv.h"
 

-

 #include "yaffs_mtdif.h"
 
 #include "linux/mtd/mtd.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
        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;
        struct erase_info ei;

-       
+

        int retval = 0;
 
        ei.mtd = mtd;
        int retval = 0;
 
        ei.mtd = mtd;


@@ -53,4 +52,3 @@ int nandmtd_initialise(struct yaffs_dev *dev)
 {
        return YAFFS_OK;
 }
 {
        return YAFFS_OK;
 }

-

diff --git a/yaffs_mtdif1.h b/yaffs_mtdif1.h
index 4f0da7473f226f2f6be00f933aa7c07cdd49d471..07ce4524f0f6a38d8dc2df95c830fd4dec9d2d46 100644 (file)
--- a/yaffs_mtdif1.h
+++ b/yaffs_mtdif1.h
@@ -15,14 +15,15 @@
 #define __YAFFS_MTDIF1_H__
 
 int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 #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,
 
 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,
 
 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
 
 #endif

diff --git a/yaffs_mtdif1_multi.c b/yaffs_mtdif1_multi.c
index ac0f00c1dde80558152c5978b9adf7f5a0db2e04..c3ea8c9b90bdef21f7dff4c50bd05382e57527d5 100644 (file)
--- a/yaffs_mtdif1_multi.c
+++ b/yaffs_mtdif1_multi.c
@@ -62,9 +62,9 @@
  */
 static struct nand_ecclayout nand_oob_16 = {
        .eccbytes = 6,
  */
 static struct nand_ecclayout nand_oob_16 = {
        .eccbytes = 6,

-       .eccpos = { 8, 9, 10, 13, 14, 15 },
+       .eccpos = {8, 9, 10, 13, 14, 15},

        .oobavail = 9,
        .oobavail = 9,

-       .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } }
+       .oobfree = {{0, 4}, {6, 2}, {11, 2}, {4, 1}}

 };
 #endif
 
 };
 #endif
 


@@ -90,11 +90,12 @@ static struct nand_ecclayout nand_oob_16 = {
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,

-       int nand_chunk, const u8 *data, const struct yaffs_ext_tags *etags)
+                             int nand_chunk, const u8 * data,
+                             const struct yaffs_ext_tags *etags)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;

-       loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
+       loff_t addr = ((loff_t) nand_chunk) * chunk_bytes;

        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;
        int retval;
        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;
        int retval;


@@ -119,11 +120,11 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
                pt1.deleted = 0;
        }
 #else
                pt1.deleted = 0;
        }
 #else

-       ((u8 *)&pt1)[8] = 0xff;
+       ((u8 *) & pt1)[8] = 0xff;

        if (etags->is_deleted) {
                memset(&pt1, 0xff, 8);
                /* zero page_status byte to indicate deleted */
        if (etags->is_deleted) {
                memset(&pt1, 0xff, 8);
                /* zero page_status byte to indicate deleted */

-               ((u8 *)&pt1)[8] = 0;
+               ((u8 *) & pt1)[8] = 0;

        }
 #endif
 
        }
 #endif
 


@@ -131,14 +132,14 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
        ops.mode = MTD_OOB_AUTO;
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;
        ops.mode = MTD_OOB_AUTO;
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;

-       ops.datbuf = (u8 *)data;
-       ops.oobbuf = (u8 *)&pt1;
+       ops.datbuf = (u8 *) data;
+       ops.oobbuf = (u8 *) & pt1;

 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,
 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,

-                       (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR),
-                       nand_chunk, retval));
+                 (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR),
+                  nand_chunk, retval));

        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }
        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }


@@ -168,11 +169,12 @@ static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval)
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,

-       int nand_chunk, u8 *data, struct yaffs_ext_tags *etags)
+                            int nand_chunk, u8 * data,
+                            struct yaffs_ext_tags *etags)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;

-       loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
+       loff_t addr = ((loff_t) nand_chunk) * chunk_bytes;

        int eccres = YAFFS_ECC_RESULT_NO_ERROR;
        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;
        int eccres = YAFFS_ECC_RESULT_NO_ERROR;
        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;


@@ -184,7 +186,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;
        ops.datbuf = data;
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;
        ops.datbuf = data;

-       ops.oobbuf = (u8 *)&pt1;
+       ops.oobbuf = (u8 *) & pt1;

 
 #if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20))
        /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
 
 #if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20))
        /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;


@@ -198,8 +200,8 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
        retval = mtd->read_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,
        retval = mtd->read_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,

-                       (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR),
-                       nand_chunk, retval));
+                 (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR),
+                  nand_chunk, retval));

        }
 
        switch (retval) {
        }
 
        switch (retval) {


@@ -219,17 +221,16 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
                /* fall into... */
        default:
                rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);
                /* fall into... */
        default:
                rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);

-               etags->block_bad = (mtd->block_isbad)(mtd, addr);
+               etags->block_bad = (mtd->block_isbad) (mtd, addr);

                return YAFFS_FAIL;
        }
 
        /* Check for a blank/erased chunk.
         */
                return YAFFS_FAIL;
        }
 
        /* Check for a blank/erased chunk.
         */

-       if (yaffs_check_ff((u8 *)&pt1, 8)) {
+       if (yaffs_check_ff((u8 *) & pt1, 8)) {

                /* when blank, upper layers want ecc_result to be <= NO_ERROR */
                return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
        }
                /* when blank, upper layers want ecc_result to be <= NO_ERROR */
                return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
        }

-

 #ifndef CONFIG_YAFFS_9BYTE_TAGS
        /* Read deleted status (bit) then return it to it's non-deleted
         * state before performing tags mini-ECC check. pt1.deleted is
 #ifndef CONFIG_YAFFS_9BYTE_TAGS
        /* Read deleted status (bit) then return it to it's non-deleted
         * state before performing tags mini-ECC check. pt1.deleted is


@@ -238,7 +239,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
        deleted = !pt1.deleted;
        pt1.deleted = 1;
 #else
        deleted = !pt1.deleted;
        pt1.deleted = 1;
 #else

-       deleted = (yaffs_count_bits(((u8 *)&pt1)[8]) < 7);
+       deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7);

 #endif
 
        /* Check the packed tags mini-ECC and correct if necessary/possible.
 #endif
 
        /* Check the packed tags mini-ECC and correct if necessary/possible.


@@ -285,9 +286,10 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 

-       T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no));
+       T(YAFFS_TRACE_BAD_BLOCKS,
+         (TSTR("marking block %d bad" TENDSTR), block_no));

 
 

-       retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no);
+       retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no);

        return (retval) ? YAFFS_FAIL : YAFFS_OK;
 }
 
        return (retval) ? YAFFS_FAIL : YAFFS_OK;
 }
 


@@ -303,8 +305,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
 
        if (oobavail < YTAG1_SIZE) {
                T(YAFFS_TRACE_ERROR,
 
        if (oobavail < YTAG1_SIZE) {
                T(YAFFS_TRACE_ERROR,

-                       (TSTR("mtd device has only %d bytes for tags, need %d"TENDSTR),
-                       oobavail, YTAG1_SIZE));
+                 (TSTR
+                  ("mtd device has only %d bytes for tags, need %d" TENDSTR),
+                  oobavail, YTAG1_SIZE));

                return YAFFS_FAIL;
        }
        return YAFFS_OK;
                return YAFFS_FAIL;
        }
        return YAFFS_OK;


@@ -320,11 +323,11 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
  * Always returns YAFFS_OK.
  */
 int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
  * Always returns YAFFS_OK.
  */
 int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,

-       enum yaffs_block_state *state_ptr, u32 *seq_ptr)
+                        enum yaffs_block_state *state_ptr, u32 * seq_ptr)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_num = block_no * dev->param.chunks_per_block;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_num = block_no * dev->param.chunks_per_block;

-       loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk;
+       loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk;

        struct yaffs_ext_tags etags;
        int state = YAFFS_BLOCK_STATE_DEAD;
        int seqnum = 0;
        struct yaffs_ext_tags etags;
        int state = YAFFS_BLOCK_STATE_DEAD;
        int seqnum = 0;


@@ -337,10 +340,10 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
                return YAFFS_FAIL;
 
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);
                return YAFFS_FAIL;
 
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);

-       etags.block_bad = (mtd->block_isbad)(mtd, addr);
+       etags.block_bad = (mtd->block_isbad) (mtd, addr);

        if (etags.block_bad) {
                T(YAFFS_TRACE_BAD_BLOCKS,
        if (etags.block_bad) {
                T(YAFFS_TRACE_BAD_BLOCKS,

-                       (TSTR("block %d is marked bad"TENDSTR), block_no));
+                 (TSTR("block %d is marked bad" TENDSTR), block_no));

                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */
                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */


@@ -359,4 +362,4 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        return YAFFS_OK;
 }
 
        return YAFFS_OK;
 }
 

-#endif /*MTD_VERSION*/
+#endif /*MTD_VERSION */

diff --git a/yaffs_mtdif1_single.c b/yaffs_mtdif1_single.c
index 02281fdb3d568fe71e18fdf11ca52e401b1d50a8..a0bc04f8600757ad8868bcfd76f0a02c1a71d999 100644 (file)
--- a/yaffs_mtdif1_single.c
+++ b/yaffs_mtdif1_single.c
@@ -42,7 +42,6 @@
 # define YTAG1_SIZE 9
 #endif
 
 # define YTAG1_SIZE 9
 #endif
 

-

 /* Write a chunk (page) of data to NAND.
  *
  * Caller always provides ExtendedTags data which are converted to a more
 /* Write a chunk (page) of data to NAND.
  *
  * Caller always provides ExtendedTags data which are converted to a more


@@ -65,11 +64,12 @@
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,

-       int nand_chunk, const u8 *data, const struct yaffs_ext_tags *etags)
+                             int nand_chunk, const u8 * data,
+                             const struct yaffs_ext_tags *etags)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;

-       loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
+       loff_t addr = ((loff_t) nand_chunk) * chunk_bytes;

        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;
        int retval;
        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;
        int retval;


@@ -94,11 +94,11 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
                pt1.deleted = 0;
        }
 #else
                pt1.deleted = 0;
        }
 #else

-       ((u8 *)&pt1)[8] = 0xff;
+       ((u8 *) & pt1)[8] = 0xff;

        if (etags->is_deleted) {
                memset(&pt1, 0xff, 8);
                /* zero page_status byte to indicate deleted */
        if (etags->is_deleted) {
                memset(&pt1, 0xff, 8);
                /* zero page_status byte to indicate deleted */

-               ((u8 *)&pt1)[8] = 0;
+               ((u8 *) & pt1)[8] = 0;

        }
 #endif
 
        }
 #endif
 


@@ -106,14 +106,14 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
        ops.mode = MTD_OOB_AUTO;
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;
        ops.mode = MTD_OOB_AUTO;
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;

-       ops.datbuf = (u8 *)data;
-       ops.oobbuf = (u8 *)&pt1;
+       ops.datbuf = (u8 *) data;
+       ops.oobbuf = (u8 *) & pt1;

 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,
 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,

-                       (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR),
-                       nand_chunk, retval));
+                 (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR),
+                  nand_chunk, retval));

        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }
        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }


@@ -143,11 +143,12 @@ static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval)
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,

-       int nand_chunk, u8 *data, struct yaffs_ext_tags *etags)
+                            int nand_chunk, u8 * data,
+                            struct yaffs_ext_tags *etags)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;

-       loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
+       loff_t addr = ((loff_t) nand_chunk) * chunk_bytes;

        int eccres = YAFFS_ECC_RESULT_NO_ERROR;
        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;
        int eccres = YAFFS_ECC_RESULT_NO_ERROR;
        struct mtd_oob_ops ops;
        struct yaffs_packed_tags1 pt1;


@@ -159,7 +160,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;
        ops.datbuf = data;
        ops.len = (data) ? chunk_bytes : 0;
        ops.ooblen = YTAG1_SIZE;
        ops.datbuf = data;

-       ops.oobbuf = (u8 *)&pt1;
+       ops.oobbuf = (u8 *) & pt1;

 
        /* Read page and oob using MTD.
         * Check status and determine ECC result.
 
        /* Read page and oob using MTD.
         * Check status and determine ECC result.


@@ -167,8 +168,8 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
        retval = mtd->read_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,
        retval = mtd->read_oob(mtd, addr, &ops);
        if (retval) {
                T(YAFFS_TRACE_MTD,

-                       (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR),
-                       nand_chunk, retval));
+                 (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR),
+                  nand_chunk, retval));

        }
 
        switch (retval) {
        }
 
        switch (retval) {


@@ -188,17 +189,16 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
                /* fall into... */
        default:
                rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);
                /* fall into... */
        default:
                rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);

-               etags->block_bad = (mtd->block_isbad)(mtd, addr);
+               etags->block_bad = (mtd->block_isbad) (mtd, addr);

                return YAFFS_FAIL;
        }
 
        /* Check for a blank/erased chunk.
         */
                return YAFFS_FAIL;
        }
 
        /* Check for a blank/erased chunk.
         */

-       if (yaffs_check_ff((u8 *)&pt1, 8)) {
+       if (yaffs_check_ff((u8 *) & pt1, 8)) {

                /* when blank, upper layers want ecc_result to be <= NO_ERROR */
                return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
        }
                /* when blank, upper layers want ecc_result to be <= NO_ERROR */
                return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
        }

-

 #ifndef CONFIG_YAFFS_9BYTE_TAGS
        /* Read deleted status (bit) then return it to it's non-deleted
         * state before performing tags mini-ECC check. pt1.deleted is
 #ifndef CONFIG_YAFFS_9BYTE_TAGS
        /* Read deleted status (bit) then return it to it's non-deleted
         * state before performing tags mini-ECC check. pt1.deleted is


@@ -207,7 +207,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
        deleted = !pt1.deleted;
        pt1.deleted = 1;
 #else
        deleted = !pt1.deleted;
        pt1.deleted = 1;
 #else

-       deleted = (yaffs_count_bits(((u8 *)&pt1)[8]) < 7);
+       deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7);

 #endif
 
        /* Check the packed tags mini-ECC and correct if necessary/possible.
 #endif
 
        /* Check the packed tags mini-ECC and correct if necessary/possible.


@@ -254,9 +254,10 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 

-       T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no));
+       T(YAFFS_TRACE_BAD_BLOCKS,
+         (TSTR("marking block %d bad" TENDSTR), block_no));

 
 

-       retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no);
+       retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no);

        return (retval) ? YAFFS_FAIL : YAFFS_OK;
 }
 
        return (retval) ? YAFFS_FAIL : YAFFS_OK;
 }
 


@@ -272,8 +273,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
 
        if (oobavail < YTAG1_SIZE) {
                T(YAFFS_TRACE_ERROR,
 
        if (oobavail < YTAG1_SIZE) {
                T(YAFFS_TRACE_ERROR,

-                       (TSTR("mtd device has only %d bytes for tags, need %d"TENDSTR),
-                       oobavail, YTAG1_SIZE));
+                 (TSTR
+                  ("mtd device has only %d bytes for tags, need %d" TENDSTR),
+                  oobavail, YTAG1_SIZE));

                return YAFFS_FAIL;
        }
        return YAFFS_OK;
                return YAFFS_FAIL;
        }
        return YAFFS_OK;


@@ -289,11 +291,11 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
  * Always returns YAFFS_OK.
  */
 int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
  * Always returns YAFFS_OK.
  */
 int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,

-       enum yaffs_block_state *state_ptr, u32 *seq_ptr)
+                        enum yaffs_block_state *state_ptr, u32 * seq_ptr)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_num = block_no * dev->param.chunks_per_block;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int chunk_num = block_no * dev->param.chunks_per_block;

-       loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk;
+       loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk;

        struct yaffs_ext_tags etags;
        int state = YAFFS_BLOCK_STATE_DEAD;
        int seqnum = 0;
        struct yaffs_ext_tags etags;
        int state = YAFFS_BLOCK_STATE_DEAD;
        int seqnum = 0;


@@ -306,10 +308,10 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
                return YAFFS_FAIL;
 
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);
                return YAFFS_FAIL;
 
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);

-       etags.block_bad = (mtd->block_isbad)(mtd, addr);
+       etags.block_bad = (mtd->block_isbad) (mtd, addr);

        if (etags.block_bad) {
                T(YAFFS_TRACE_BAD_BLOCKS,
        if (etags.block_bad) {
                T(YAFFS_TRACE_BAD_BLOCKS,

-                       (TSTR("block %d is marked bad"TENDSTR), block_no));
+                 (TSTR("block %d is marked bad" TENDSTR), block_no));

                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */
                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */

diff --git a/yaffs_mtdif2.h b/yaffs_mtdif2.h
index e9759ff85f5ac6ca110652209b49dbc113af3801..d82112610d04306b1e6e4b84f6064cbe841db027 100644 (file)
--- a/yaffs_mtdif2.h
+++ b/yaffs_mtdif2.h
@@ -18,12 +18,12 @@
 
 #include "yaffs_guts.h"
 int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 
 #include "yaffs_guts.h"
 int nandmtd2_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 nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 int nandmtd2_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 nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no);
 int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
 int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no);
 int nandmtd2_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
 
 #endif

diff --git a/yaffs_mtdif2_multi.c b/yaffs_mtdif2_multi.c
index 04fb39da25965aac9ff0c97e3b4047b42352546b..555f937cebf58d91b86d47de33010dd9fe6c9d38 100644 (file)
--- a/yaffs_mtdif2_multi.c
+++ b/yaffs_mtdif2_multi.c
@@ -31,8 +31,8 @@
  * use it to load the tags.
  */
 int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
  * use it to load the tags.
  */
 int nandmtd2_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)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))


@@ -46,16 +46,17 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 
        struct yaffs_packed_tags2 pt;
 
 
        struct yaffs_packed_tags2 pt;
 

-       int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
-       void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt;
+       int packed_tags_size =
+           dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
+       void *packed_tags_ptr =
+           dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;

 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
            TENDSTR), nand_chunk, data, tags));
 
 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
            TENDSTR), nand_chunk, data, tags));
 

-
-       addr  = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
+       addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;

 
        /* For yaffs2 writing there must be both data and tags.
         * If we're using inband tags, then the tags are stuffed into
 
        /* For yaffs2 writing there must be both data and tags.
         * If we're using inband tags, then the tags are stuffed into


@@ -65,7 +66,10 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                BUG();
        else if (dev->param.inband_tags) {
                struct yaffs_packed_tags2_tags_only *pt2tp;
                BUG();
        else if (dev->param.inband_tags) {
                struct yaffs_packed_tags2_tags_only *pt2tp;

-               pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk);
+               pt2tp =
+                   (struct yaffs_packed_tags2_tags_only *)(data +
+                                                           dev->
+                                                           data_bytes_per_chunk);

                yaffs_pack_tags2_tags_only(pt2tp, tags);
        } else
                yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);
                yaffs_pack_tags2_tags_only(pt2tp, tags);
        } else
                yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);


@@ -75,7 +79,7 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;
        ops.len = dev->param.total_bytes_per_chunk;
        ops.ooboffs = 0;
        ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;
        ops.len = dev->param.total_bytes_per_chunk;
        ops.ooboffs = 0;

-       ops.datbuf = (u8 *)data;
+       ops.datbuf = (u8 *) data;

        ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr;
        retval = mtd->write_oob(mtd, addr, &ops);
 
        ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr;
        retval = mtd->write_oob(mtd, addr, &ops);
 


@@ -86,8 +90,8 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                                   &dummy, data, (u8 *) packed_tags_ptr, NULL);
        } else {
                retval =
                                   &dummy, data, (u8 *) packed_tags_ptr, NULL);
        } else {
                retval =

-                   mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, &dummy,
-                              data);
+                   mtd->write(mtd, addr, dev->param.total_bytes_per_chunk,
+                              &dummy, data);

        }
 #endif
 
        }
 #endif
 


@@ -98,7 +102,7 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 }
 
 int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 }
 
 int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,

-                                      u8 *data, struct yaffs_ext_tags *tags)
+                            u8 * data, struct yaffs_ext_tags *tags)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))


@@ -112,8 +116,10 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 
        struct yaffs_packed_tags2 pt;
 
 
        struct yaffs_packed_tags2 pt;
 

-       int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
-       void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt;
+       int packed_tags_size =
+           dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
+       void *packed_tags_ptr =
+           dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;

 
        T(YAFFS_TRACE_MTD,
          (TSTR
 
        T(YAFFS_TRACE_MTD,
          (TSTR


@@ -127,14 +133,12 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                        data = yaffs_get_temp_buffer(dev, __LINE__);
                }
 
                        data = yaffs_get_temp_buffer(dev, __LINE__);
                }
 

-

        }
 
        }
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        if (dev->param.inband_tags || (data && !tags))
                retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk,
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        if (dev->param.inband_tags || (data && !tags))
                retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk,

-                               &dummy, data);
+                                  &dummy, data);

        else if (tags) {
                ops.mode = MTD_OOB_AUTO;
                ops.ooblen = packed_tags_size;
        else if (tags) {
                ops.mode = MTD_OOB_AUTO;
                ops.ooblen = packed_tags_size;


@@ -148,13 +152,12 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        if (!dev->param.inband_tags && data && tags) {
 
                retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk,
        if (!dev->param.inband_tags && data && tags) {
 
                retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk,

-                                         &dummy, data, dev->spare_buffer,
-                                         NULL);
+                                      &dummy, data, dev->spare_buffer, NULL);

        } else {
                if (data)
                        retval =
        } else {
                if (data)
                        retval =

-                           mtd->read(mtd, addr, dev->data_bytes_per_chunk, &dummy,
-                                     data);
+                           mtd->read(mtd, addr, dev->data_bytes_per_chunk,
+                                     &dummy, data);

                if (!dev->param.inband_tags && tags)
                        retval =
                            mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
                if (!dev->param.inband_tags && tags)
                        retval =
                            mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,


@@ -162,16 +165,19 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        }
 #endif
 
        }
 #endif
 

-

        if (dev->param.inband_tags) {
                if (tags) {
                        struct yaffs_packed_tags2_tags_only *pt2tp;
        if (dev->param.inband_tags) {
                if (tags) {
                        struct yaffs_packed_tags2_tags_only *pt2tp;

-                       pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk];
+                       pt2tp =
+                           (struct yaffs_packed_tags2_tags_only *)&data[dev->
+                                                                        data_bytes_per_chunk];

                        yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
                if (tags) {
                        yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
                if (tags) {

-                       memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size);
+                       memcpy(packed_tags_ptr,
+                              yaffs_dev_to_lc(dev)->spare_buffer,
+                              packed_tags_size);

                        yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
                }
        }
                        yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
                }
        }


@@ -179,11 +185,13 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        if (local_data)
                yaffs_release_temp_buffer(dev, data, __LINE__);
 
        if (local_data)
                yaffs_release_temp_buffer(dev, data, __LINE__);
 

-       if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {
+       if (tags && retval == -EBADMSG
+           && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {

                tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED;
                dev->n_ecc_unfixed++;
        }
                tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED;
                dev->n_ecc_unfixed++;
        }

-       if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {
+       if (tags && retval == -EUCLEAN
+           && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {

                tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
                dev->n_ecc_fixed++;
        }
                tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
                dev->n_ecc_fixed++;
        }


@@ -213,13 +221,12 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 }
 
 int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
 }
 
 int nandmtd2_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)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 

-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
+       T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));

        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *


@@ -233,8 +240,7 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
        } else {
                struct yaffs_ext_tags t;
                nandmtd2_read_chunk_tags(dev, block_no *
        } else {
                struct yaffs_ext_tags t;
                nandmtd2_read_chunk_tags(dev, block_no *

-                                                  dev->param.chunks_per_block, NULL,
-                                                  &t);
+                                        dev->param.chunks_per_block, NULL, &t);

 
                if (t.chunk_used) {
                        *seq_number = t.seq_number;
 
                if (t.chunk_used) {
                        *seq_number = t.seq_number;


@@ -245,12 +251,10 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                }
        }
        T(YAFFS_TRACE_MTD,
                }
        }
        T(YAFFS_TRACE_MTD,

-         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number,
-          *state));
+         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state));

 
        if (retval == 0)
                return YAFFS_OK;
        else
                return YAFFS_FAIL;
 }
 
        if (retval == 0)
                return YAFFS_OK;
        else
                return YAFFS_FAIL;
 }

-

diff --git a/yaffs_mtdif2_single.c b/yaffs_mtdif2_single.c
index f5a5c10d4b15f1657ea5d17270605cae5e3948a3..00040cd9017eb81092fdd705451abea8f4fcb57b 100644 (file)
--- a/yaffs_mtdif2_single.c
+++ b/yaffs_mtdif2_single.c
@@ -31,8 +31,8 @@
  * use it to load the tags.
  */
 int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
  * use it to load the tags.
  */
 int nandmtd2_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)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        struct mtd_oob_ops ops;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        struct mtd_oob_ops ops;


@@ -42,16 +42,17 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 
        struct yaffs_packed_tags2 pt;
 
 
        struct yaffs_packed_tags2 pt;
 

-       int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
-       void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt;
+       int packed_tags_size =
+           dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
+       void *packed_tags_ptr =
+           dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;

 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
            TENDSTR), nand_chunk, data, tags));
 
 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
            TENDSTR), nand_chunk, data, tags));
 

-
-       addr  = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
+       addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;

 
        /* For yaffs2 writing there must be both data and tags.
         * If we're using inband tags, then the tags are stuffed into
 
        /* For yaffs2 writing there must be both data and tags.
         * If we're using inband tags, then the tags are stuffed into


@@ -61,7 +62,10 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                BUG();
        else if (dev->param.inband_tags) {
                struct yaffs_packed_tags2_tags_only *pt2tp;
                BUG();
        else if (dev->param.inband_tags) {
                struct yaffs_packed_tags2_tags_only *pt2tp;

-               pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk);
+               pt2tp =
+                   (struct yaffs_packed_tags2_tags_only *)(data +
+                                                           dev->
+                                                           data_bytes_per_chunk);

                yaffs_pack_tags2_tags_only(pt2tp, tags);
        } else
                yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);
                yaffs_pack_tags2_tags_only(pt2tp, tags);
        } else
                yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);


@@ -70,11 +74,10 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;
        ops.len = dev->param.total_bytes_per_chunk;
        ops.ooboffs = 0;
        ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;
        ops.len = dev->param.total_bytes_per_chunk;
        ops.ooboffs = 0;

-       ops.datbuf = (u8 *)data;
+       ops.datbuf = (u8 *) data;

        ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr;
        retval = mtd->write_oob(mtd, addr, &ops);
 
        ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr;
        retval = mtd->write_oob(mtd, addr, &ops);
 

-

        if (retval == 0)
                return YAFFS_OK;
        else
        if (retval == 0)
                return YAFFS_OK;
        else


@@ -82,7 +85,7 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 }
 
 int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 }
 
 int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,

-                                      u8 *data, struct yaffs_ext_tags *tags)
+                            u8 * data, struct yaffs_ext_tags *tags)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        struct mtd_oob_ops ops;
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        struct mtd_oob_ops ops;


@@ -95,8 +98,10 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
 
        struct yaffs_packed_tags2 pt;
 
 
        struct yaffs_packed_tags2 pt;
 

-       int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
-       void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt;
+       int packed_tags_size =
+           dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
+       void *packed_tags_ptr =
+           dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;

 
        T(YAFFS_TRACE_MTD,
          (TSTR
 
        T(YAFFS_TRACE_MTD,
          (TSTR


@@ -110,13 +115,11 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                        data = yaffs_get_temp_buffer(dev, __LINE__);
                }
 
                        data = yaffs_get_temp_buffer(dev, __LINE__);
                }
 

-

        }
 
        }
 

-

        if (dev->param.inband_tags || (data && !tags))
                retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk,
        if (dev->param.inband_tags || (data && !tags))
                retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk,

-                               &dummy, data);
+                                  &dummy, data);

        else if (tags) {
                ops.mode = MTD_OOB_AUTO;
                ops.ooblen = packed_tags_size;
        else if (tags) {
                ops.mode = MTD_OOB_AUTO;
                ops.ooblen = packed_tags_size;


@@ -130,12 +133,16 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        if (dev->param.inband_tags) {
                if (tags) {
                        struct yaffs_packed_tags2_tags_only *pt2tp;
        if (dev->param.inband_tags) {
                if (tags) {
                        struct yaffs_packed_tags2_tags_only *pt2tp;

-                       pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk];
+                       pt2tp =
+                           (struct yaffs_packed_tags2_tags_only *)&data[dev->
+                                                                        data_bytes_per_chunk];

                        yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
                if (tags) {
                        yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
                if (tags) {

-                       memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size);
+                       memcpy(packed_tags_ptr,
+                              yaffs_dev_to_lc(dev)->spare_buffer,
+                              packed_tags_size);

                        yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
                }
        }
                        yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
                }
        }


@@ -143,11 +150,13 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        if (local_data)
                yaffs_release_temp_buffer(dev, data, __LINE__);
 
        if (local_data)
                yaffs_release_temp_buffer(dev, data, __LINE__);
 

-       if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {
+       if (tags && retval == -EBADMSG
+           && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {

                tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED;
                dev->n_ecc_unfixed++;
        }
                tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED;
                dev->n_ecc_unfixed++;
        }

-       if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {
+       if (tags && retval == -EUCLEAN
+           && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {

                tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
                dev->n_ecc_fixed++;
        }
                tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
                dev->n_ecc_fixed++;
        }


@@ -177,13 +186,12 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 }
 
 int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
 }
 
 int nandmtd2_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)

 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 

-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
+       T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));

        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *


@@ -197,8 +205,7 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
        } else {
                struct yaffs_ext_tags t;
                nandmtd2_read_chunk_tags(dev, block_no *
        } else {
                struct yaffs_ext_tags t;
                nandmtd2_read_chunk_tags(dev, block_no *

-                                                  dev->param.chunks_per_block, NULL,
-                                                  &t);
+                                        dev->param.chunks_per_block, NULL, &t);

 
                if (t.chunk_used) {
                        *seq_number = t.seq_number;
 
                if (t.chunk_used) {
                        *seq_number = t.seq_number;


@@ -209,8 +216,7 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                }
        }
        T(YAFFS_TRACE_MTD,
                }
        }
        T(YAFFS_TRACE_MTD,

-         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number,
-          *state));
+         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state));

 
        if (retval == 0)
                return YAFFS_OK;
 
        if (retval == 0)
                return YAFFS_OK;

diff --git a/yaffs_nameval.c b/yaffs_nameval.c
index a4ed2973526ba259375199b480f01d7c49298dcd..d7cb72aa00a6bf94ea9d275f688e6b879e14ea93 100644 (file)
--- a/yaffs_nameval.c
+++ b/yaffs_nameval.c
@@ -25,118 +25,120 @@
  * This code has not been tested with unicode yet.
  */
 
  * This code has not been tested with unicode yet.
  */
 

-

 #include "yaffs_nameval.h"
 
 #include "yportenv.h"
 #include "yaffs_nameval.h"
 
 #include "yportenv.h"

- 
-static int nval_find(const char *xb, int xb_size, const YCHAR *name,
-               int *exist_size)
+
+static int nval_find(const char *xb, int xb_size, const YCHAR * name,
+                    int *exist_size)

 {
 {

-       int pos=0;
+       int pos = 0;

        int size;
 
        int size;
 

-       memcpy(&size,xb,sizeof(int));
-       while(size > 0 && (size < xb_size) && (pos + size < xb_size)){
-               if(yaffs_strncmp((YCHAR *)(xb+pos+sizeof(int)),name,size) == 0){
-                       if(exist_size)
+       memcpy(&size, xb, sizeof(int));
+       while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
+               if (yaffs_strncmp
+                   ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) {
+                       if (exist_size)

                                *exist_size = size;
                        return pos;
                }
                pos += size;
                                *exist_size = size;
                        return pos;
                }
                pos += size;

-               if(pos < xb_size -sizeof(int))
-                       memcpy(&size,xb + pos,sizeof(int));
+               if (pos < xb_size - sizeof(int))
+                       memcpy(&size, xb + pos, sizeof(int));

                else
                        size = 0;
        }
                else
                        size = 0;
        }

-       if(exist_size)
+       if (exist_size)

                *exist_size = 0;
        return -1;
 }
 
 static int nval_used(const char *xb, int xb_size)
 {
                *exist_size = 0;
        return -1;
 }
 
 static int nval_used(const char *xb, int xb_size)
 {

-       int pos=0;
+       int pos = 0;

        int size;
 
        int size;
 

-       memcpy(&size,xb + pos,sizeof(int));
-       while(size > 0 && (size < xb_size) && (pos + size < xb_size)){
+       memcpy(&size, xb + pos, sizeof(int));
+       while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {

                pos += size;
                pos += size;

-               if(pos < xb_size -sizeof(int))
-                       memcpy(&size,xb + pos,sizeof(int));
+               if (pos < xb_size - sizeof(int))
+                       memcpy(&size, xb + pos, sizeof(int));

                else
                        size = 0;
        }
        return pos;
 }
 
                else
                        size = 0;
        }
        return pos;
 }
 

-int nval_del(char *xb, int xb_size, const YCHAR *name)
+int nval_del(char *xb, int xb_size, const YCHAR * name)

 {
 {

-       int pos  = nval_find(xb, xb_size, name, NULL);
+       int pos = nval_find(xb, xb_size, name, NULL);

        int size;
        int size;

-       
-       if(pos >= 0 && pos < xb_size){
+
+       if (pos >= 0 && pos < xb_size) {

                /* Find size, shift rest over this record, then zero out the rest of buffer */
                /* Find size, shift rest over this record, then zero out the rest of buffer */

-               memcpy(&size,xb+pos,sizeof(int));
+               memcpy(&size, xb + pos, sizeof(int));

                memcpy(xb + pos, xb + pos + size, xb_size - (pos + size));
                memcpy(xb + pos, xb + pos + size, xb_size - (pos + size));

-               memset(xb + (xb_size - size),0,size);
+               memset(xb + (xb_size - size), 0, size);

                return 0;
        } else
                return -ENODATA;
 }
 
                return 0;
        } else
                return -ENODATA;
 }
 

-int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags)
+int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
+            int bsize, int flags)

 {
        int pos;
 {
        int pos;

-       int namelen = yaffs_strnlen(name,xb_size);
+       int namelen = yaffs_strnlen(name, xb_size);

        int reclen;
        int size_exist = 0;
        int space;
        int start;
 
        int reclen;
        int size_exist = 0;
        int space;
        int start;
 

-       pos = nval_find(xb,xb_size,name, &size_exist);
+       pos = nval_find(xb, xb_size, name, &size_exist);

 
 

-       if(flags & XATTR_CREATE && pos >= 0)
+       if (flags & XATTR_CREATE && pos >= 0)

                return -EEXIST;
                return -EEXIST;

-       if(flags & XATTR_REPLACE && pos < 0)
+       if (flags & XATTR_REPLACE && pos < 0)

                return -ENODATA;
 
                return -ENODATA;
 

-       start = nval_used(xb,xb_size);
+       start = nval_used(xb, xb_size);

        space = xb_size - start + size_exist;
 
        reclen = (sizeof(int) + namelen + 1 + bsize);
 
        space = xb_size - start + size_exist;
 
        reclen = (sizeof(int) + namelen + 1 + bsize);
 

-       if(reclen > space)
+       if (reclen > space)

                return -ENOSPC;
 
                return -ENOSPC;
 

-       if(pos >= 0){
-               nval_del(xb,xb_size,name);
+       if (pos >= 0) {
+               nval_del(xb, xb_size, name);

                start = nval_used(xb, xb_size);
        }
 
        pos = start;
 
                start = nval_used(xb, xb_size);
        }
 
        pos = start;
 

-       memcpy(xb + pos,&reclen,sizeof(int));
-       pos +=sizeof(int);
-       yaffs_strncpy((YCHAR *)(xb + pos), name, reclen);
-       pos+= (namelen+1);
-       memcpy(xb + pos,buf,bsize);
+       memcpy(xb + pos, &reclen, sizeof(int));
+       pos += sizeof(int);
+       yaffs_strncpy((YCHAR *) (xb + pos), name, reclen);
+       pos += (namelen + 1);
+       memcpy(xb + pos, buf, bsize);

        return 0;
 }
 
        return 0;
 }
 

-int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize)
+int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf,
+            int bsize)

 {
 {

-       int pos = nval_find(xb,xb_size,name,NULL);
+       int pos = nval_find(xb, xb_size, name, NULL);

        int size;
        int size;

-       
-       if(pos >= 0 && pos< xb_size){
-               
-               memcpy(&size,xb +pos,sizeof(int));
-               pos+=sizeof(int); /* advance past record length */
+
+       if (pos >= 0 && pos < xb_size) {
+
+               memcpy(&size, xb + pos, sizeof(int));
+               pos += sizeof(int);     /* advance past record length */

                size -= sizeof(int);
 
                /* Advance over name string */
                size -= sizeof(int);
 
                /* Advance over name string */

-               while(xb[pos] && size > 0 && pos < xb_size){
+               while (xb[pos] && size > 0 && pos < xb_size) {

                        pos++;
                        size--;
                }
                        pos++;
                        size--;
                }


@@ -144,13 +146,13 @@ int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsiz
                pos++;
                size--;
 
                pos++;
                size--;
 

-               if(size <= bsize){
-                       memcpy(buf,xb + pos,size);
+               if (size <= bsize) {
+                       memcpy(buf, xb + pos, size);

                        return size;
                }
                        return size;
                }

-               
+

        }
        }

-       if(pos >= 0)
+       if (pos >= 0)

                return -ERANGE;
        else
                return -ENODATA;
                return -ERANGE;
        else
                return -ENODATA;


@@ -164,33 +166,33 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize)
        int ncopied = 0;
        int filled = 0;
 
        int ncopied = 0;
        int filled = 0;
 

-       memcpy(&size,xb + pos,sizeof(int));
-       while(size > sizeof(int) && size <= xb_size && (pos + size) < xb_size && !filled){
-               pos+= sizeof(int);
-               size-=sizeof(int);
-               name_len = yaffs_strnlen((YCHAR *)(xb + pos), size);
-               if(ncopied + name_len + 1 < bsize){
-                       memcpy(buf,xb+pos,name_len * sizeof(YCHAR));
-                       buf+= name_len;
+       memcpy(&size, xb + pos, sizeof(int));
+       while (size > sizeof(int) && size <= xb_size && (pos + size) < xb_size
+              && !filled) {
+               pos += sizeof(int);
+               size -= sizeof(int);
+               name_len = yaffs_strnlen((YCHAR *) (xb + pos), size);
+               if (ncopied + name_len + 1 < bsize) {
+                       memcpy(buf, xb + pos, name_len * sizeof(YCHAR));
+                       buf += name_len;

                        *buf = '\0';
                        buf++;
                        *buf = '\0';
                        buf++;

-                       if(sizeof(YCHAR) > 1){
+                       if (sizeof(YCHAR) > 1) {

                                *buf = '\0';
                                buf++;
                        }
                                *buf = '\0';
                                buf++;
                        }

-                       ncopied += (name_len+1);
+                       ncopied += (name_len + 1);

                } else
                        filled = 1;
                } else
                        filled = 1;

-               pos+=size;
-               if(pos < xb_size -sizeof(int))
-                       memcpy(&size,xb + pos,sizeof(int));
+               pos += size;
+               if (pos < xb_size - sizeof(int))
+                       memcpy(&size, xb + pos, sizeof(int));

                else
                        size = 0;
        }
        return ncopied;
 }
 
                else
                        size = 0;
        }
        return ncopied;
 }
 

-

 int nval_hasvalues(const char *xb, int xb_size)
 {
        return nval_used(xb, xb_size) > 0;
 int nval_hasvalues(const char *xb, int xb_size)
 {
        return nval_used(xb, xb_size) > 0;

diff --git a/yaffs_nameval.h b/yaffs_nameval.h
index bd8085937eb36f477fa9ed004bd6b8436c35fad4..2bb02b62762835cd14355316d1b515f48e3fc447 100644 (file)
--- a/yaffs_nameval.h
+++ b/yaffs_nameval.h
@@ -18,9 +18,11 @@
 
 #include "yportenv.h"
 
 
 #include "yportenv.h"
 

-int nval_del(char *xb, int xb_size, const YCHAR *name);
-int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags);
-int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize);
+int nval_del(char *xb, int xb_size, const YCHAR * name);
+int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
+            int bsize, int flags);
+int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf,
+            int bsize);

 int nval_list(const char *xb, int xb_size, char *buf, int bsize);
 int nval_hasvalues(const char *xb, int xb_size);
 #endif
 int nval_list(const char *xb, int xb_size, char *buf, int bsize);
 int nval_hasvalues(const char *xb, int xb_size);
 #endif

diff --git a/yaffs_nand.c b/yaffs_nand.c
index d45259e462d5bdf7b377a6783ff39398225ac23e..84ab0f020edbddfaf031bbd140a92b75520bf8ef 100644 (file)
--- a/yaffs_nand.c
+++ b/yaffs_nand.c
@@ -18,8 +18,7 @@
 #include "yaffs_getblockinfo.h"
 
 int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
 #include "yaffs_getblockinfo.h"
 
 int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,

-                                          u8 *buffer,
-                                          struct yaffs_ext_tags *tags)
+                            u8 * buffer, struct yaffs_ext_tags *tags)

 {
        int result;
        struct yaffs_ext_tags local_tags;
 {
        int result;
        struct yaffs_ext_tags local_tags;


@@ -33,18 +32,18 @@ int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
                tags = &local_tags;
 
        if (dev->param.read_chunk_tags_fn)
                tags = &local_tags;
 
        if (dev->param.read_chunk_tags_fn)

-               result = dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer,
-                                                     tags);
+               result =
+                   dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer,
+                                                 tags);

        else
                result = yaffs_tags_compat_rd(dev,
        else
                result = yaffs_tags_compat_rd(dev,

-                                                                       realigned_chunk,
-                                                                       buffer,
-                                                                       tags);
-       if (tags &&
-          tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) {
+                                             realigned_chunk, buffer, tags);
+       if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) {

 
                struct yaffs_block_info *bi;
 
                struct yaffs_block_info *bi;

-               bi = yaffs_get_block_info(dev, nand_chunk/dev->param.chunks_per_block);
+               bi = yaffs_get_block_info(dev,
+                                         nand_chunk /
+                                         dev->param.chunks_per_block);

                yaffs_handle_chunk_error(dev, bi);
        }
 
                yaffs_handle_chunk_error(dev, bi);
        }
 


@@ -52,16 +51,14 @@ int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
 }
 
 int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
 }
 
 int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,

-                                                  int nand_chunk,
-                                                  const u8 *buffer,
-                                                  struct yaffs_ext_tags *tags)
+                            int nand_chunk,
+                            const u8 * buffer, struct yaffs_ext_tags *tags)

 {
 
        dev->n_page_writes++;
 
        nand_chunk -= dev->chunk_offset;
 
 {
 
        dev->n_page_writes++;
 
        nand_chunk -= dev->chunk_offset;
 

-

        if (tags) {
                tags->seq_number = dev->seq_number;
                tags->chunk_used = 1;
        if (tags) {
                tags->seq_number = dev->seq_number;
                tags->chunk_used = 1;


@@ -80,19 +77,15 @@ int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
 
        if (dev->param.write_chunk_tags_fn)
                return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer,
 
        if (dev->param.write_chunk_tags_fn)
                return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer,

-                                                    tags);
+                                                     tags);

        else
        else

-               return yaffs_tags_compat_wr(dev,
-                                                                      nand_chunk,
-                                                                      buffer,
-                                                                      tags);
+               return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags);

 }
 
 int yaffs_mark_bad(struct yaffs_dev *dev, int block_no)
 {
        block_no -= dev->block_offset;
 
 }
 
 int yaffs_mark_bad(struct yaffs_dev *dev, int block_no)
 {
        block_no -= dev->block_offset;
 

-

        if (dev->param.bad_block_fn)
                return dev->param.bad_block_fn(dev, block_no);
        else
        if (dev->param.bad_block_fn)
                return dev->param.bad_block_fn(dev, block_no);
        else


@@ -100,23 +93,21 @@ int yaffs_mark_bad(struct yaffs_dev *dev, int block_no)
 }
 
 int yaffs_query_init_block_state(struct yaffs_dev *dev,
 }
 
 int yaffs_query_init_block_state(struct yaffs_dev *dev,

-                                                int block_no,
-                                                enum yaffs_block_state *state,
-                                                u32 *seq_number)
+                                int block_no,
+                                enum yaffs_block_state *state,
+                                u32 * seq_number)

 {
        block_no -= dev->block_offset;
 
        if (dev->param.query_block_fn)
 {
        block_no -= dev->block_offset;
 
        if (dev->param.query_block_fn)

-               return dev->param.query_block_fn(dev, block_no, state, seq_number);
+               return dev->param.query_block_fn(dev, block_no, state,
+                                                seq_number);

        else
                return yaffs_tags_compat_query_block(dev, block_no,
        else
                return yaffs_tags_compat_query_block(dev, block_no,

-                                                            state,
-                                                            seq_number);
+                                                    state, seq_number);

 }
 
 }
 

-
-int yaffs_erase_block(struct yaffs_dev *dev,
-                                 int flash_block)
+int yaffs_erase_block(struct yaffs_dev *dev, int flash_block)

 {
        int result;
 
 {
        int result;
 


@@ -131,10 +122,7 @@ int yaffs_erase_block(struct yaffs_dev *dev,
 
 int yaffs_init_nand(struct yaffs_dev *dev)
 {
 
 int yaffs_init_nand(struct yaffs_dev *dev)
 {

-       if(dev->param.initialise_flash_fn)
+       if (dev->param.initialise_flash_fn)

                return dev->param.initialise_flash_fn(dev);
        return YAFFS_OK;
 }
                return dev->param.initialise_flash_fn(dev);
        return YAFFS_OK;
 }

-
-
-

diff --git a/yaffs_nand.h b/yaffs_nand.h
index 773badb3cf3e16d0392dfc7595b7bbdc12ac160c..543f1987124e6a9d9ea0682a4d51278f92191286 100644 (file)
--- a/yaffs_nand.h
+++ b/yaffs_nand.h
@@ -17,28 +17,22 @@
 #define __YAFFS_NAND_H__
 #include "yaffs_guts.h"
 
 #define __YAFFS_NAND_H__
 #include "yaffs_guts.h"
 

-
-

 int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
 int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,

-                                       u8 *buffer,
-                                       struct yaffs_ext_tags *tags);
+                            u8 * buffer, struct yaffs_ext_tags *tags);

 
 int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
 
 int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,

-                                               int nand_chunk,
-                                               const u8 *buffer,
-                                               struct yaffs_ext_tags *tags);
+                            int nand_chunk,
+                            const u8 * buffer, struct yaffs_ext_tags *tags);

 
 int yaffs_mark_bad(struct yaffs_dev *dev, int block_no);
 
 int yaffs_query_init_block_state(struct yaffs_dev *dev,
 
 int yaffs_mark_bad(struct yaffs_dev *dev, int block_no);
 
 int yaffs_query_init_block_state(struct yaffs_dev *dev,

-                                               int block_no,
-                                               enum yaffs_block_state *state,
-                                               unsigned *seq_number);
+                                int block_no,
+                                enum yaffs_block_state *state,
+                                unsigned *seq_number);

 
 

-int yaffs_erase_block(struct yaffs_dev *dev,
-                                 int flash_block);
+int yaffs_erase_block(struct yaffs_dev *dev, int flash_block);

 
 int yaffs_init_nand(struct yaffs_dev *dev);
 
 #endif
 
 int yaffs_init_nand(struct yaffs_dev *dev);
 
 #endif

-

diff --git a/yaffs_packedtags1.c b/yaffs_packedtags1.c
index 905551208bbd3ec120a421f29ba15bf13efee975..a77f0954fc135a3440c70918a616925551c098a5 100644 (file)
--- a/yaffs_packedtags1.c
+++ b/yaffs_packedtags1.c
@@ -14,7 +14,8 @@
 #include "yaffs_packedtags1.h"
 #include "yportenv.h"
 
 #include "yaffs_packedtags1.h"
 #include "yportenv.h"
 

-void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, const struct yaffs_ext_tags *t)
+void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt,
+                     const struct yaffs_ext_tags *t)

 {
        pt->chunk_id = t->chunk_id;
        pt->serial_number = t->serial_number;
 {
        pt->chunk_id = t->chunk_id;
        pt->serial_number = t->serial_number;


@@ -27,11 +28,13 @@ void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, const struct yaffs_ext_tags
 
 }
 
 
 }
 

-void yaffs_unpack_tags1(struct yaffs_ext_tags *t, const struct yaffs_packed_tags1 *pt)
+void yaffs_unpack_tags1(struct yaffs_ext_tags *t,
+                       const struct yaffs_packed_tags1 *pt)

 {
        static const u8 all_ff[] =
            { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 {
        static const u8 all_ff[] =
            { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

-0xff };
+               0xff
+       };

 
        if (memcmp(all_ff, pt, sizeof(struct yaffs_packed_tags1))) {
                t->block_bad = 0;
 
        if (memcmp(all_ff, pt, sizeof(struct yaffs_packed_tags1))) {
                t->block_bad = 0;

diff --git a/yaffs_packedtags1.h b/yaffs_packedtags1.h
index 9174837d4b2aa5300710a684f40702ae65b37183..d6861ff505e45701e7edce4a354d66b25220b6a3 100644 (file)
--- a/yaffs_packedtags1.h
+++ b/yaffs_packedtags1.h
@@ -30,8 +30,10 @@ struct yaffs_packed_tags1 {
        unsigned unused_stuff:1;
        unsigned should_be_ff;
 
        unsigned unused_stuff:1;
        unsigned should_be_ff;
 

-} ;
+};

 
 

-void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, const struct yaffs_ext_tags *t);
-void yaffs_unpack_tags1(struct yaffs_ext_tags *t, const struct yaffs_packed_tags1 *pt);
+void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt,
+                     const struct yaffs_ext_tags *t);
+void yaffs_unpack_tags1(struct yaffs_ext_tags *t,
+                       const struct yaffs_packed_tags1 *pt);

 #endif
 #endif

diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c
index 6a22939495073415a98ba579e2872d3b5c1204f8..6c12aed2b9ddabfe3ae7ffe8641553c7520eb10e 100644 (file)
--- a/yaffs_packedtags2.c
+++ b/yaffs_packedtags2.c
@@ -38,14 +38,14 @@
 #define EXTRA_OBJECT_TYPE_SHIFT (28)
 #define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
 
 #define EXTRA_OBJECT_TYPE_SHIFT (28)
 #define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
 

-
-static void yaffs_dump_packed_tags2_tags_only(const struct yaffs_packed_tags2_tags_only *ptt)
+static void yaffs_dump_packed_tags2_tags_only(const struct
+                                             yaffs_packed_tags2_tags_only *ptt)

 {
        T(YAFFS_TRACE_MTD,
          (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
 {
        T(YAFFS_TRACE_MTD,
          (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),

-          ptt->obj_id, ptt->chunk_id, ptt->n_bytes,
-          ptt->seq_number));
+          ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number));

 }
 }

+

 static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt)
 {
        yaffs_dump_packed_tags2_tags_only(&pt->t);
 static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt)
 {
        yaffs_dump_packed_tags2_tags_only(&pt->t);


@@ -63,7 +63,7 @@ static void yaffs_dump_tags2(const struct yaffs_ext_tags *t)
 }
 
 void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt,
 }
 
 void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt,

-               const struct yaffs_ext_tags *t)
+                               const struct yaffs_ext_tags *t)

 {
        ptt->chunk_id = t->chunk_id;
        ptt->seq_number = t->seq_number;
 {
        ptt->chunk_id = t->chunk_id;
        ptt->seq_number = t->seq_number;


@@ -73,16 +73,14 @@ void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt,
        if (t->chunk_id == 0 && t->extra_available) {
                /* Store the extra header info instead */
                /* We save the parent object in the chunk_id */
        if (t->chunk_id == 0 && t->extra_available) {
                /* Store the extra header info instead */
                /* We save the parent object in the chunk_id */

-               ptt->chunk_id = EXTRA_HEADER_INFO_FLAG
-                       | t->extra_parent_id;
+               ptt->chunk_id = EXTRA_HEADER_INFO_FLAG | t->extra_parent_id;

                if (t->extra_is_shrink)
                        ptt->chunk_id |= EXTRA_SHRINK_FLAG;
                if (t->extra_shadows)
                        ptt->chunk_id |= EXTRA_SHADOWS_FLAG;
 
                ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK;
                if (t->extra_is_shrink)
                        ptt->chunk_id |= EXTRA_SHRINK_FLAG;
                if (t->extra_shadows)
                        ptt->chunk_id |= EXTRA_SHADOWS_FLAG;
 
                ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK;

-               ptt->obj_id |=
-                   (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT);
+               ptt->obj_id |= (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT);

 
                if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK)
                        ptt->n_bytes = t->extra_equiv_id;
 
                if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK)
                        ptt->n_bytes = t->extra_equiv_id;


@@ -96,20 +94,20 @@ void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt,
        yaffs_dump_tags2(t);
 }
 
        yaffs_dump_tags2(t);
 }
 

-
-void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, const struct yaffs_ext_tags *t, int tags_ecc)
+void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt,
+                     const struct yaffs_ext_tags *t, int tags_ecc)

 {
        yaffs_pack_tags2_tags_only(&pt->t, t);
 
 {
        yaffs_pack_tags2_tags_only(&pt->t, t);
 

-       if(tags_ecc)
+       if (tags_ecc)

                yaffs_ecc_calc_other((unsigned char *)&pt->t,
                yaffs_ecc_calc_other((unsigned char *)&pt->t,

-                                       sizeof(struct yaffs_packed_tags2_tags_only),
-                                       &pt->ecc);
+                                    sizeof(struct
+                                           yaffs_packed_tags2_tags_only),
+                                    &pt->ecc);

 }
 
 }
 

-

 void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t,
 void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t,

-               struct yaffs_packed_tags2_tags_only *ptt)
+                                 struct yaffs_packed_tags2_tags_only *ptt)

 {
 
        memset(t, 0, sizeof(struct yaffs_ext_tags));
 {
 
        memset(t, 0, sizeof(struct yaffs_ext_tags));


@@ -155,36 +153,38 @@ void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t,
 
 }
 
 
 }
 

-
-void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, int tags_ecc)
+void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt,
+                       int tags_ecc)

 {
 
        enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
 
 {
 
        enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
 

-       if (pt->t.seq_number != 0xFFFFFFFF &&
-           tags_ecc){
+       if (pt->t.seq_number != 0xFFFFFFFF && tags_ecc) {

                /* Chunk is in use and we need to do ECC */
                /* Chunk is in use and we need to do ECC */

-               
+

                struct yaffs_ecc_other ecc;
                int result;
                yaffs_ecc_calc_other((unsigned char *)&pt->t,
                struct yaffs_ecc_other ecc;
                int result;
                yaffs_ecc_calc_other((unsigned char *)&pt->t,

-                                       sizeof(struct yaffs_packed_tags2_tags_only),
-                                       &ecc);
-               result = yaffs_ecc_correct_other((unsigned char *)&pt->t,
-                                               sizeof(struct yaffs_packed_tags2_tags_only),
-                                               &pt->ecc, &ecc);
+                                    sizeof(struct
+                                           yaffs_packed_tags2_tags_only),
+                                    &ecc);
+               result =
+                   yaffs_ecc_correct_other((unsigned char *)&pt->t,
+                                           sizeof(struct
+                                                  yaffs_packed_tags2_tags_only),
+                                           &pt->ecc, &ecc);

                switch (result) {
                switch (result) {

-                       case 0:
-                               ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
-                               break;
-                       case 1:
-                               ecc_result = YAFFS_ECC_RESULT_FIXED;
-                               break;
-                       case -1:
-                               ecc_result = YAFFS_ECC_RESULT_UNFIXED;
-                               break;
-                       default:
-                               ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
+               case 0:
+                       ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
+                       break;
+               case 1:
+                       ecc_result = YAFFS_ECC_RESULT_FIXED;
+                       break;
+               case -1:
+                       ecc_result = YAFFS_ECC_RESULT_UNFIXED;
+                       break;
+               default:
+                       ecc_result = YAFFS_ECC_RESULT_UNKNOWN;

                }
        }
 
                }
        }
 


@@ -195,4 +195,3 @@ void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt,
        yaffs_dump_packed_tags2(pt);
        yaffs_dump_tags2(t);
 }
        yaffs_dump_packed_tags2(pt);
        yaffs_dump_tags2(t);
 }

-

diff --git a/yaffs_packedtags2.h b/yaffs_packedtags2.h
index f147c0931c4d8a279eb683da985980147a11ac79..f3296697bc0c51712f2e6f0ee19474a2282ede15 100644 (file)
--- a/yaffs_packedtags2.h
+++ b/yaffs_packedtags2.h
@@ -26,18 +26,22 @@ struct yaffs_packed_tags2_tags_only {
        unsigned obj_id;
        unsigned chunk_id;
        unsigned n_bytes;
        unsigned obj_id;
        unsigned chunk_id;
        unsigned n_bytes;

-} ;
+};

 
 struct yaffs_packed_tags2 {
        struct yaffs_packed_tags2_tags_only t;
        struct yaffs_ecc_other ecc;
 
 struct yaffs_packed_tags2 {
        struct yaffs_packed_tags2_tags_only t;
        struct yaffs_ecc_other ecc;

-} ;
+};

 
 /* Full packed tags with ECC, used for oob tags */
 
 /* Full packed tags with ECC, used for oob tags */

-void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, const struct yaffs_ext_tags *t, int tags_ecc);
-void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, int tags_ecc);
+void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt,
+                     const struct yaffs_ext_tags *t, int tags_ecc);
+void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt,
+                       int tags_ecc);

 
 /* Only the tags part (no ECC for use with inband tags */
 
 /* Only the tags part (no ECC for use with inband tags */

-void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt, const struct yaffs_ext_tags *t);
-void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, struct yaffs_packed_tags2_tags_only *pt);
+void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt,
+                               const struct yaffs_ext_tags *t);
+void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t,
+                                 struct yaffs_packed_tags2_tags_only *pt);

 #endif
 #endif

diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c
index 57b1e54798f6eda1fe5cd09e1ae27b34f13d7ae6..3a9a157e7e2470c44252cb338363347db7b04569 100644 (file)
--- a/yaffs_tagscompat.c
+++ b/yaffs_tagscompat.c
@@ -19,7 +19,6 @@
 
 static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk);
 
 
 static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk);
 

-

 static const char yaffs_count_bits_table[256] = {
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 static const char yaffs_count_bits_table[256] = {
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,


@@ -48,7 +47,7 @@ int yaffs_count_bits(u8 x)
 
 /********** Tags ECC calculations  *********/
 
 
 /********** Tags ECC calculations  *********/
 

-void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
+void yaffs_calc_ecc(const u8 * data, struct yaffs_spare *spare)

 {
        yaffs_ecc_cacl(data, spare->ecc1);
        yaffs_ecc_cacl(&data[256], spare->ecc2);
 {
        yaffs_ecc_cacl(data, spare->ecc1);
        yaffs_ecc_cacl(&data[256], spare->ecc2);


@@ -58,7 +57,7 @@ void yaffs_calc_tags_ecc(struct yaffs_tags *tags)
 {
        /* Calculate an ecc */
 
 {
        /* Calculate an ecc */
 

-       unsigned char *b = ((union yaffs_tags_union *) tags)->as_bytes;
+       unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes;

        unsigned i, j;
        unsigned ecc = 0;
        unsigned bit = 0;
        unsigned i, j;
        unsigned ecc = 0;
        unsigned bit = 0;


@@ -87,7 +86,7 @@ int yaffs_check_tags_ecc(struct yaffs_tags *tags)
 
        if (ecc && ecc <= 64) {
                /* TODO: Handle the failure better. Retire? */
 
        if (ecc && ecc <= 64) {
                /* TODO: Handle the failure better. Retire? */

-               unsigned char *b = ((union yaffs_tags_union *) tags)->as_bytes;
+               unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes;

 
                ecc--;
 
 
                ecc--;
 


@@ -109,9 +108,9 @@ int yaffs_check_tags_ecc(struct yaffs_tags *tags)
 /********** Tags **********/
 
 static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr,
 /********** Tags **********/
 
 static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr,

-                               struct yaffs_tags *tags_ptr)
+                                    struct yaffs_tags *tags_ptr)

 {
 {

-       union yaffs_tags_union *tu = (union yaffs_tags_union *) tags_ptr;
+       union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr;

 
        yaffs_calc_tags_ecc(tags_ptr);
 
 
        yaffs_calc_tags_ecc(tags_ptr);
 


@@ -125,10 +124,11 @@ static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr,
        spare_ptr->tb7 = tu->as_bytes[7];
 }
 
        spare_ptr->tb7 = tu->as_bytes[7];
 }
 

-static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, struct yaffs_spare *spare_ptr,
-                               struct yaffs_tags *tags_ptr)
+static void yaffs_get_tags_from_spare(struct yaffs_dev *dev,
+                                     struct yaffs_spare *spare_ptr,
+                                     struct yaffs_tags *tags_ptr)

 {
 {

-       union yaffs_tags_union *tu = (union yaffs_tags_union *) tags_ptr;
+       union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr;

        int result;
 
        tu->as_bytes[0] = spare_ptr->tb0;
        int result;
 
        tu->as_bytes[0] = spare_ptr->tb0;


@@ -153,8 +153,8 @@ static void yaffs_spare_init(struct yaffs_spare *spare)
 }
 
 static int yaffs_wr_nand(struct yaffs_dev *dev,
 }
 
 static int yaffs_wr_nand(struct yaffs_dev *dev,

-                               int nand_chunk, const u8 *data,
-                               struct yaffs_spare *spare)
+                        int nand_chunk, const u8 * data,
+                        struct yaffs_spare *spare)

 {
        if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
                T(YAFFS_TRACE_ERROR,
 {
        if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
                T(YAFFS_TRACE_ERROR,


@@ -167,11 +167,11 @@ static int yaffs_wr_nand(struct yaffs_dev *dev,
 }
 
 static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
 }
 
 static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,

-                                  int nand_chunk,
-                                  u8 *data,
-                                  struct yaffs_spare *spare,
-                                  enum yaffs_ecc_result *ecc_result,
-                                  int correct_errors)
+                              int nand_chunk,
+                              u8 * data,
+                              struct yaffs_spare *spare,
+                              enum yaffs_ecc_result *ecc_result,
+                              int correct_errors)

 {
        int ret_val;
        struct yaffs_spare local_spare;
 {
        int ret_val;
        struct yaffs_spare local_spare;


@@ -183,7 +183,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
        }
 
        if (!dev->param.use_nand_ecc) {
        }
 
        if (!dev->param.use_nand_ecc) {

-               ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, spare);
+               ret_val =
+                   dev->param.read_chunk_fn(dev, nand_chunk, data, spare);

                if (data && correct_errors) {
                        /* Do ECC correction */
                        /* Todo handle any errors */
                if (data && correct_errors) {
                        /* Do ECC correction */
                        /* Todo handle any errors */


@@ -195,7 +196,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                            yaffs_ecc_correct(data, spare->ecc1, calc_ecc);
                        yaffs_ecc_cacl(&data[256], calc_ecc);
                        ecc_result2 =
                            yaffs_ecc_correct(data, spare->ecc1, calc_ecc);
                        yaffs_ecc_cacl(&data[256], calc_ecc);
                        ecc_result2 =

-                           yaffs_ecc_correct(&data[256], spare->ecc2, calc_ecc);
+                           yaffs_ecc_correct(&data[256], spare->ecc2,
+                                             calc_ecc);

 
                        if (ecc_result1 > 0) {
                                T(YAFFS_TRACE_ERROR,
 
                        if (ecc_result1 > 0) {
                                T(YAFFS_TRACE_ERROR,


@@ -245,7 +247,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                memset(&nspare, 0, sizeof(nspare));
 
                ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data,
                memset(&nspare, 0, sizeof(nspare));
 
                ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data,

-                                       (struct yaffs_spare *) &nspare);
+                                                  (struct yaffs_spare *)
+                                                  &nspare);

                memcpy(spare, &nspare, sizeof(struct yaffs_spare));
                if (data && correct_errors) {
                        if (nspare.eccres1 > 0) {
                memcpy(spare, &nspare, sizeof(struct yaffs_spare));
                if (data && correct_errors) {
                        if (nspare.eccres1 > 0) {


@@ -289,7 +292,6 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
        return ret_val;
 }
 
        return ret_val;
 }
 

-

 /*
  * Functions for robustisizing
  */
 /*
  * Functions for robustisizing
  */


@@ -299,7 +301,9 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk)
        int flash_block = nand_chunk / dev->param.chunks_per_block;
 
        /* Mark the block for retirement */
        int flash_block = nand_chunk / dev->param.chunks_per_block;
 
        /* Mark the block for retirement */

-       yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1;
+       yaffs_get_block_info(dev,
+                            flash_block + dev->block_offset)->needs_retiring =
+           1;

        T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
          (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block));
 
        T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
          (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block));
 


@@ -310,11 +314,9 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk)
         */
 }
 
         */
 }
 

-

 int yaffs_tags_compat_wr(struct yaffs_dev *dev,
 int yaffs_tags_compat_wr(struct yaffs_dev *dev,

-                                               int nand_chunk,
-                                               const u8 *data,
-                                               const struct yaffs_ext_tags *ext_tags)
+                        int nand_chunk,
+                        const u8 * data, const struct yaffs_ext_tags *ext_tags)

 {
        struct yaffs_spare spare;
        struct yaffs_tags tags;
 {
        struct yaffs_spare spare;
        struct yaffs_tags tags;


@@ -334,7 +336,6 @@ int yaffs_tags_compat_wr(struct yaffs_dev *dev,
                else
                        tags.n_bytes_msb = 3;
 
                else
                        tags.n_bytes_msb = 3;
 

-

                tags.serial_number = ext_tags->serial_number;
 
                if (!dev->param.use_nand_ecc && data)
                tags.serial_number = ext_tags->serial_number;
 
                if (!dev->param.use_nand_ecc && data)


@@ -348,9 +349,8 @@ int yaffs_tags_compat_wr(struct yaffs_dev *dev,
 }
 
 int yaffs_tags_compat_rd(struct yaffs_dev *dev,
 }
 
 int yaffs_tags_compat_rd(struct yaffs_dev *dev,

-                                                    int nand_chunk,
-                                                    u8 *data,
-                                                    struct yaffs_ext_tags *ext_tags)
+                        int nand_chunk,
+                        u8 * data, struct yaffs_ext_tags *ext_tags)

 {
 
        struct yaffs_spare spare;
 {
 
        struct yaffs_spare spare;


@@ -365,8 +365,7 @@ int yaffs_tags_compat_rd(struct yaffs_dev *dev,
                init = 1;
        }
 
                init = 1;
        }
 

-       if (yaffs_rd_chunk_nand
-           (dev, nand_chunk, data, &spare, &ecc_result, 1)) {
+       if (yaffs_rd_chunk_nand(dev, nand_chunk, data, &spare, &ecc_result, 1)) {

                /* ext_tags may be NULL */
                if (ext_tags) {
 
                /* ext_tags may be NULL */
                if (ext_tags) {
 


@@ -389,7 +388,9 @@ int yaffs_tags_compat_rd(struct yaffs_dev *dev,
                                ext_tags->n_bytes = tags.n_bytes_lsb;
 
                                if (dev->data_bytes_per_chunk >= 1024)
                                ext_tags->n_bytes = tags.n_bytes_lsb;
 
                                if (dev->data_bytes_per_chunk >= 1024)

-                                       ext_tags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10);
+                                       ext_tags->n_bytes |=
+                                           (((unsigned)tags.
+                                             n_bytes_msb) << 10);

 
                                ext_tags->serial_number = tags.serial_number;
                        }
 
                                ext_tags->serial_number = tags.serial_number;
                        }


@@ -401,8 +402,7 @@ int yaffs_tags_compat_rd(struct yaffs_dev *dev,
        }
 }
 
        }
 }
 

-int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev,
-                                           int flash_block)
+int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block)

 {
 
        struct yaffs_spare spare;
 {
 
        struct yaffs_spare spare;


@@ -412,18 +412,18 @@ int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev,
        spare.block_status = 'Y';
 
        yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL,
        spare.block_status = 'Y';
 
        yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL,

-                              &spare);
+                     &spare);

        yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1,
        yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1,

-                              NULL, &spare);
+                     NULL, &spare);

 
        return YAFFS_OK;
 
 }
 
 int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
 
        return YAFFS_OK;
 
 }
 
 int yaffs_tags_compat_query_block(struct yaffs_dev *dev,

-                                         int block_no,
-                                         enum yaffs_block_state *state,
-                                         u32 *seq_number)
+                                 int block_no,
+                                 enum yaffs_block_state *state,
+                                 u32 * seq_number)

 {
 
        struct yaffs_spare spare0, spare1;
 {
 
        struct yaffs_spare spare0, spare1;


@@ -439,9 +439,9 @@ int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
        *seq_number = 0;
 
        yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL,
        *seq_number = 0;
 
        yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL,

-                               &spare0, &dummy, 1);
-       yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL,
-                               &spare1, &dummy, 1);
+                           &spare0, &dummy, 1);
+       yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1,
+                           NULL, &spare1, &dummy, 1);

 
        if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7)
                *state = YAFFS_BLOCK_STATE_DEAD;
 
        if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7)
                *state = YAFFS_BLOCK_STATE_DEAD;

diff --git a/yaffs_tagscompat.h b/yaffs_tagscompat.h
index cf3402dde0ee18e351fccfeb995644fc845bb6b5..8cd35dcd3cab375e43d6094d80bf3d1f2e611531 100644 (file)
--- a/yaffs_tagscompat.h
+++ b/yaffs_tagscompat.h
@@ -18,19 +18,16 @@
 
 #include "yaffs_guts.h"
 int yaffs_tags_compat_wr(struct yaffs_dev *dev,
 
 #include "yaffs_guts.h"
 int yaffs_tags_compat_wr(struct yaffs_dev *dev,

-                                               int nand_chunk,
-                                               const u8 *data,
-                                               const struct yaffs_ext_tags *tags);
+                        int nand_chunk,
+                        const u8 * data, const struct yaffs_ext_tags *tags);

 int yaffs_tags_compat_rd(struct yaffs_dev *dev,
 int yaffs_tags_compat_rd(struct yaffs_dev *dev,

-                                               int nand_chunk,
-                                               u8 *data,
-                                               struct yaffs_ext_tags *tags);
-int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev,
-                                           int block_no);
+                        int nand_chunk,
+                        u8 * data, struct yaffs_ext_tags *tags);
+int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no);

 int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
 int yaffs_tags_compat_query_block(struct yaffs_dev *dev,

-                                         int block_no,
-                                         enum yaffs_block_state *state,
-                                         u32 *seq_number);
+                                 int block_no,
+                                 enum yaffs_block_state *state,
+                                 u32 * seq_number);

 
 void yaffs_calc_tags_ecc(struct yaffs_tags *tags);
 int yaffs_check_tags_ecc(struct yaffs_tags *tags);
 
 void yaffs_calc_tags_ecc(struct yaffs_tags *tags);
 int yaffs_check_tags_ecc(struct yaffs_tags *tags);

diff --git a/yaffs_tagsvalidity.c b/yaffs_tagsvalidity.c
index f86882a291915283b2912cde21ae66244424421e..4358d79d4bece97dca0b73863b2f609716204972 100644 (file)
--- a/yaffs_tagsvalidity.c
+++ b/yaffs_tagsvalidity.c
@@ -22,7 +22,6 @@ void yaffs_init_tags(struct yaffs_ext_tags *tags)
 
 int yaffs_validate_tags(struct yaffs_ext_tags *tags)
 {
 
 int yaffs_validate_tags(struct yaffs_ext_tags *tags)
 {

-       return (tags->validity0 == 0xAAAAAAAA &&
-               tags->validity1 == 0x55555555);
+       return (tags->validity0 == 0xAAAAAAAA && tags->validity1 == 0x55555555);

 
 }
 
 }

diff --git a/yaffs_tagsvalidity.h b/yaffs_tagsvalidity.h
index ae3116feacb84280fc775f4a42f29122b259c541..36a021fc8fa8bf07bcd4fa8f8f003901056a4121 100644 (file)
--- a/yaffs_tagsvalidity.h
+++ b/yaffs_tagsvalidity.h
@@ -13,7 +13,6 @@
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 

-

 #ifndef __YAFFS_TAGS_VALIDITY_H__
 #define __YAFFS_TAGS_VALIDITY_H__
 
 #ifndef __YAFFS_TAGS_VALIDITY_H__
 #define __YAFFS_TAGS_VALIDITY_H__
 

diff --git a/yaffs_trace.h b/yaffs_trace.h
index 9fe7214a210bdb9928c430ba344421c4323be1d6..90dbefc97751b7786fac1af4051e49d553707133 100644 (file)
--- a/yaffs_trace.h
+++ b/yaffs_trace.h
@@ -13,7 +13,6 @@
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 

-

 #ifndef __YTRACE_H__
 #define __YTRACE_H__
 
 #ifndef __YTRACE_H__
 #define __YTRACE_H__
 


@@ -54,7 +53,6 @@ extern unsigned int yaffs_wr_attempts;
 #define YAFFS_TRACE_BUG                        0x80000000
 #define YAFFS_TRACE_ALWAYS             0xF0000000
 
 #define YAFFS_TRACE_BUG                        0x80000000
 #define YAFFS_TRACE_ALWAYS             0xF0000000
 

-

 #define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0)
 
 #endif
 #define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0)
 
 #endif

diff --git a/yaffs_verify.c b/yaffs_verify.c
index e15bb321fc6d7cb762c8fdf00e5cbb86e14ee6ae..fee3a1e462f7c358022aa96e025f161ce1b2218b 100644 (file)
--- a/yaffs_verify.c
+++ b/yaffs_verify.c
@@ -11,7 +11,6 @@
  * published by the Free Software Foundation.
  */
 
  * published by the Free Software Foundation.
  */
 

-

 #include "yaffs_verify.h"
 #include "yaffs_trace.h"
 #include "yaffs_bitmap.h"
 #include "yaffs_verify.h"
 #include "yaffs_trace.h"
 #include "yaffs_bitmap.h"


@@ -20,37 +19,36 @@
 
 int yaffs_skip_verification(struct yaffs_dev *dev)
 {
 
 int yaffs_skip_verification(struct yaffs_dev *dev)
 {

-       dev=dev;
-       return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
+       dev = dev;
+       return !(yaffs_trace_mask &
+                (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));

 }
 
 static int yaffs_skip_full_verification(struct yaffs_dev *dev)
 {
 }
 
 static int yaffs_skip_full_verification(struct yaffs_dev *dev)
 {

-       dev=dev;
+       dev = dev;

        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL));
 }
 
 static int yaffs_skip_nand_verification(struct yaffs_dev *dev)
 {
        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL));
 }
 
 static int yaffs_skip_nand_verification(struct yaffs_dev *dev)
 {

-       dev=dev;
+       dev = dev;

        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));
 }
 
        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));
 }
 

-

 static const char *block_state_name[] = {
 static const char *block_state_name[] = {

-"Unknown",
-"Needs scanning",
-"Scanning",
-"Empty",
-"Allocating",
-"Full",
-"Dirty",
-"Checkpoint",
-"Collecting",
-"Dead"
+       "Unknown",
+       "Needs scanning",
+       "Scanning",
+       "Empty",
+       "Allocating",
+       "Full",
+       "Dirty",
+       "Checkpoint",
+       "Collecting",
+       "Dead"

 };
 
 };
 

-

 void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
 {
        int actually_used;
 void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
 {
        int actually_used;


@@ -61,47 +59,56 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
 
        /* Report illegal runtime states */
        if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES)
 
        /* Report illegal runtime states */
        if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES)

-               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->block_state));
+               T(YAFFS_TRACE_VERIFY,
+                 (TSTR("Block %d has undefined state %d" TENDSTR), n,
+                  bi->block_state));

 
        switch (bi->block_state) {
        case YAFFS_BLOCK_STATE_UNKNOWN:
        case YAFFS_BLOCK_STATE_SCANNING:
        case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
 
        switch (bi->block_state) {
        case YAFFS_BLOCK_STATE_UNKNOWN:
        case YAFFS_BLOCK_STATE_SCANNING:
        case YAFFS_BLOCK_STATE_NEEDS_SCANNING:

-               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR),
-               n, block_state_name[bi->block_state]));
+               T(YAFFS_TRACE_VERIFY,
+                 (TSTR("Block %d has bad run-state %s" TENDSTR), n,
+                  block_state_name[bi->block_state]));

        }
 
        /* Check pages in use and soft deletions are legal */
 
        actually_used = bi->pages_in_use - bi->soft_del_pages;
 
        }
 
        /* Check pages in use and soft deletions are legal */
 
        actually_used = bi->pages_in_use - bi->soft_del_pages;
 

-       if (bi->pages_in_use < 0 || bi->pages_in_use > dev->param.chunks_per_block ||
-          bi->soft_del_pages < 0 || bi->soft_del_pages > dev->param.chunks_per_block ||
-          actually_used < 0 || actually_used > dev->param.chunks_per_block)
-               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pages_in_used %d soft_del_pages %d"TENDSTR),
-               n, bi->pages_in_use, bi->soft_del_pages));
-
+       if (bi->pages_in_use < 0
+           || bi->pages_in_use > dev->param.chunks_per_block
+           || bi->soft_del_pages < 0
+           || bi->soft_del_pages > dev->param.chunks_per_block
+           || actually_used < 0 || actually_used > dev->param.chunks_per_block)
+               T(YAFFS_TRACE_VERIFY,
+                 (TSTR
+                  ("Block %d has illegal values pages_in_used %d soft_del_pages %d"
+                   TENDSTR), n, bi->pages_in_use, bi->soft_del_pages));

 
        /* Check chunk bitmap legal */
        in_use = yaffs_count_chunk_bits(dev, n);
        if (in_use != bi->pages_in_use)
 
        /* Check chunk bitmap legal */
        in_use = yaffs_count_chunk_bits(dev, n);
        if (in_use != bi->pages_in_use)

-               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"TENDSTR),
-                       n, bi->pages_in_use, in_use));
+               T(YAFFS_TRACE_VERIFY,
+                 (TSTR
+                  ("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"
+                   TENDSTR), n, bi->pages_in_use, in_use));

 
 }
 
 
 }
 

-
-
-void yaffs_verify_collected_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
+void yaffs_verify_collected_blk(struct yaffs_dev *dev,
+                               struct yaffs_block_info *bi, int n)

 {
        yaffs_verify_blk(dev, bi, n);
 
        /* After collection the block should be in the erased state */
 
        if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING &&
 {
        yaffs_verify_blk(dev, bi, n);
 
        /* After collection the block should be in the erased state */
 
        if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING &&

-                       bi->block_state != YAFFS_BLOCK_STATE_EMPTY) {
-               T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
-                       n, bi->block_state));
+           bi->block_state != YAFFS_BLOCK_STATE_EMPTY) {
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR
+                  ("Block %d is in state %d after gc, should be erased"
+                   TENDSTR), n, bi->block_state));

        }
 }
 
        }
 }
 


@@ -126,34 +133,37 @@ void yaffs_verify_blocks(struct yaffs_dev *dev)
                        illegal_states++;
        }
 
                        illegal_states++;
        }
 

-       T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
-       T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR)));
+       T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR)));
+       T(YAFFS_TRACE_VERIFY, (TSTR("Block summary" TENDSTR)));

 
 

-       T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), illegal_states));
+       T(YAFFS_TRACE_VERIFY,
+         (TSTR("%d blocks have illegal states" TENDSTR), illegal_states));

        if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
        if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1)

-               T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR)));
+               T(YAFFS_TRACE_VERIFY,
+                 (TSTR("Too many allocating blocks" TENDSTR)));

 
        for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
                T(YAFFS_TRACE_VERIFY,
 
        for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
                T(YAFFS_TRACE_VERIFY,

-                 (TSTR("%s %d blocks"TENDSTR),
-                 block_state_name[i], state_count[i]));
+                 (TSTR("%s %d blocks" TENDSTR),
+                  block_state_name[i], state_count[i]));

 
        if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT])
                T(YAFFS_TRACE_VERIFY,
 
        if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT])
                T(YAFFS_TRACE_VERIFY,

-                (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
-                dev->blocks_in_checkpt, state_count[YAFFS_BLOCK_STATE_CHECKPOINT]));
+                 (TSTR("Checkpoint block count wrong dev %d count %d" TENDSTR),
+                  dev->blocks_in_checkpt,
+                  state_count[YAFFS_BLOCK_STATE_CHECKPOINT]));

 
        if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY])
                T(YAFFS_TRACE_VERIFY,
 
        if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY])
                T(YAFFS_TRACE_VERIFY,

-                (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
-                dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY]));
+                 (TSTR("Erased block count wrong dev %d count %d" TENDSTR),
+                  dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY]));

 
        if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1)
                T(YAFFS_TRACE_VERIFY,
 
        if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1)
                T(YAFFS_TRACE_VERIFY,

-                (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
-                state_count[YAFFS_BLOCK_STATE_COLLECTING]));
+                 (TSTR("Too many collecting blocks %d (max is 1)" TENDSTR),
+                  state_count[YAFFS_BLOCK_STATE_COLLECTING]));

 
 

-       T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
+       T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR)));

 
 }
 
 
 }
 


@@ -161,29 +171,29 @@ void yaffs_verify_blocks(struct yaffs_dev *dev)
  * Verify the object header. oh must be valid, but obj and tags may be NULL in which
  * case those tests will not be performed.
  */
  * Verify the object header. oh must be valid, but obj and tags may be NULL in which
  * case those tests will not be performed.
  */

-void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check)
+void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
+                    struct yaffs_ext_tags *tags, int parent_check)

 {
        if (obj && yaffs_skip_verification(obj->my_dev))
                return;
 
        if (!(tags && obj && oh)) {
                T(YAFFS_TRACE_VERIFY,
 {
        if (obj && yaffs_skip_verification(obj->my_dev))
                return;
 
        if (!(tags && obj && oh)) {
                T(YAFFS_TRACE_VERIFY,

-                               (TSTR("Verifying object header tags %p obj %p oh %p"TENDSTR),
-                               tags, obj, oh));
+                 (TSTR("Verifying object header tags %p obj %p oh %p" TENDSTR),
+                  tags, obj, oh));

                return;
        }
 
        if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
                return;
        }
 
        if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||

-                       oh->type > YAFFS_OBJECT_TYPE_MAX)
+           oh->type > YAFFS_OBJECT_TYPE_MAX)

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
-                       tags->obj_id, oh->type));
+                 (TSTR("Obj %d header type is illegal value 0x%x" TENDSTR),
+                  tags->obj_id, oh->type));

 
        if (tags->obj_id != obj->obj_id)
                T(YAFFS_TRACE_VERIFY,
 
        if (tags->obj_id != obj->obj_id)
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d header mismatch obj_id %d"TENDSTR),
-                       tags->obj_id, obj->obj_id));
-
+                 (TSTR("Obj %d header mismatch obj_id %d" TENDSTR),
+                  tags->obj_id, obj->obj_id));

 
        /*
         * Check that the object's parent ids match if parent_check requested.
 
        /*
         * Check that the object's parent ids match if parent_check requested.


@@ -193,30 +203,29 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaf
 
        if (parent_check && tags->obj_id > 1 && !obj->parent)
                T(YAFFS_TRACE_VERIFY,
 
        if (parent_check && tags->obj_id > 1 && !obj->parent)
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d header mismatch parent_id %d obj->parent is NULL"TENDSTR),
-                       tags->obj_id, oh->parent_obj_id));
+                 (TSTR
+                  ("Obj %d header mismatch parent_id %d obj->parent is NULL"
+                   TENDSTR), tags->obj_id, oh->parent_obj_id));

 
        if (parent_check && obj->parent &&
 
        if (parent_check && obj->parent &&

-                       oh->parent_obj_id != obj->parent->obj_id &&
-                       (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED ||
-                       obj->parent->obj_id != YAFFS_OBJECTID_DELETED))
+           oh->parent_obj_id != obj->parent->obj_id &&
+           (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED ||
+            obj->parent->obj_id != YAFFS_OBJECTID_DELETED))

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d header mismatch parent_id %d parent_obj_id %d"TENDSTR),
-                       tags->obj_id, oh->parent_obj_id, obj->parent->obj_id));
+                 (TSTR
+                  ("Obj %d header mismatch parent_id %d parent_obj_id %d"
+                   TENDSTR), tags->obj_id, oh->parent_obj_id,
+                  obj->parent->obj_id));

 
 

-       if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */
+       if (tags->obj_id > 1 && oh->name[0] == 0)       /* Null name */

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d header name is NULL"TENDSTR),
-                       obj->obj_id));
+                 (TSTR("Obj %d header name is NULL" TENDSTR), obj->obj_id));

 
 

-       if (tags->obj_id > 1 && ((u8)(oh->name[0])) == 0xff) /* Trashed name */
+       if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff)   /* Trashed name */

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d header name is 0xFF"TENDSTR),
-                       obj->obj_id));
+                 (TSTR("Obj %d header name is 0xFF" TENDSTR), obj->obj_id));

 }
 
 }
 

-
-

 void yaffs_verify_file(struct yaffs_obj *obj)
 {
        int required_depth;
 void yaffs_verify_file(struct yaffs_obj *obj)
 {
        int required_depth;


@@ -239,7 +248,8 @@ void yaffs_verify_file(struct yaffs_obj *obj)
        obj_id = obj->obj_id;
 
        /* Check file size is consistent with tnode depth */
        obj_id = obj->obj_id;
 
        /* Check file size is consistent with tnode depth */

-       last_chunk =  obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1;
+       last_chunk =
+           obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1;

        x = last_chunk >> YAFFS_TNODES_LEVEL0_BITS;
        required_depth = 0;
        while (x > 0) {
        x = last_chunk >> YAFFS_TNODES_LEVEL0_BITS;
        required_depth = 0;
        while (x > 0) {


@@ -264,18 +274,20 @@ void yaffs_verify_file(struct yaffs_obj *obj)
                        u32 the_chunk = yaffs_get_group_base(dev, tn, i);
                        if (the_chunk > 0) {
                                /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */
                        u32 the_chunk = yaffs_get_group_base(dev, tn, i);
                        if (the_chunk > 0) {
                                /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */

-                               yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags);
+                               yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL,
+                                                        &tags);

                                if (tags.obj_id != obj_id || tags.chunk_id != i) {
                                if (tags.obj_id != obj_id || tags.chunk_id != i) {

-                                       T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
-                                               obj_id, i, the_chunk,
-                                               tags.obj_id, tags.chunk_id));
+                                       T(~0,
+                                         (TSTR
+                                          ("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"
+                                           TENDSTR), obj_id, i, the_chunk,
+                                          tags.obj_id, tags.chunk_id));

                                }
                        }
                }
        }
 }
 
                                }
                        }
                }
        }
 }
 

-

 void yaffs_verify_link(struct yaffs_obj *obj)
 {
        if (obj && yaffs_skip_verification(obj->my_dev))
 void yaffs_verify_link(struct yaffs_obj *obj)
 {
        if (obj && yaffs_skip_verification(obj->my_dev))


@@ -324,24 +336,24 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
        /* Check sane object header chunk */
 
        chunk_min = dev->internal_start_block * dev->param.chunks_per_block;
        /* Check sane object header chunk */
 
        chunk_min = dev->internal_start_block * dev->param.chunks_per_block;

-       chunk_max = (dev->internal_end_block+1) * dev->param.chunks_per_block - 1;
+       chunk_max =
+           (dev->internal_end_block + 1) * dev->param.chunks_per_block - 1;

 
 

-       chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min && 
-                       ((unsigned)(obj->hdr_chunk)) <= chunk_max);
+       chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min &&
+                         ((unsigned)(obj->hdr_chunk)) <= chunk_max);

        chunk_id_ok = chunk_in_range || (obj->hdr_chunk == 0);
        chunk_valid = chunk_in_range &&
        chunk_id_ok = chunk_in_range || (obj->hdr_chunk == 0);
        chunk_valid = chunk_in_range &&

-                       yaffs_check_chunk_bit(dev,
-                                       obj->hdr_chunk / dev->param.chunks_per_block,
-                                       obj->hdr_chunk % dev->param.chunks_per_block);
+           yaffs_check_chunk_bit(dev,
+                                 obj->hdr_chunk / dev->param.chunks_per_block,
+                                 obj->hdr_chunk % dev->param.chunks_per_block);

        chunk_wrongly_deleted = chunk_in_range && !chunk_valid;
 
        chunk_wrongly_deleted = chunk_in_range && !chunk_valid;
 

-       if (!obj->fake &&
-                       (!chunk_id_ok || chunk_wrongly_deleted)) {
+       if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted)) {

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d has chunk_id %d %s %s"TENDSTR),
-                       obj->obj_id, obj->hdr_chunk,
-                       chunk_id_ok ? "" : ",out of range",
-                       chunk_wrongly_deleted ? ",marked as deleted" : ""));
+                 (TSTR("Obj %d has chunk_id %d %s %s" TENDSTR),
+                  obj->obj_id, obj->hdr_chunk,
+                  chunk_id_ok ? "" : ",out of range",
+                  chunk_wrongly_deleted ? ",marked as deleted" : ""));

        }
 
        if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
        }
 
        if (chunk_valid && !yaffs_skip_nand_verification(dev)) {


@@ -351,8 +363,7 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
 
                oh = (struct yaffs_obj_hdr *)buffer;
 
 
                oh = (struct yaffs_obj_hdr *)buffer;
 

-               yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer,
-                               &tags);
+               yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, &tags);

 
                yaffs_verify_oh(obj, oh, &tags, 1);
 
 
                yaffs_verify_oh(obj, oh, &tags, 1);
 


@@ -360,18 +371,19 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
        }
 
        /* Verify it has a parent */
        }
 
        /* Verify it has a parent */

-       if (obj && !obj->fake &&
-                       (!obj->parent || obj->parent->my_dev != dev)) {
+       if (obj && !obj->fake && (!obj->parent || obj->parent->my_dev != dev)) {

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
-                       obj->obj_id, obj->parent));
+                 (TSTR
+                  ("Obj %d has parent pointer %p which does not look like an object"
+                   TENDSTR), obj->obj_id, obj->parent));

        }
 
        /* Verify parent is a directory */
        }
 
        /* Verify parent is a directory */

-       if (obj->parent && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+       if (obj->parent
+           && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {

                T(YAFFS_TRACE_VERIFY,
                T(YAFFS_TRACE_VERIFY,

-                       (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
-                       obj->obj_id, obj->parent->variant_type));
+                 (TSTR("Obj %d's parent is not a directory (type %d)" TENDSTR),
+                  obj->obj_id, obj->parent->variant_type));

        }
 
        switch (obj->variant_type) {
        }
 
        switch (obj->variant_type) {


@@ -393,8 +405,8 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
        case YAFFS_OBJECT_TYPE_UNKNOWN:
        default:
                T(YAFFS_TRACE_VERIFY,
        case YAFFS_OBJECT_TYPE_UNKNOWN:
        default:
                T(YAFFS_TRACE_VERIFY,

-               (TSTR("Obj %d has illegaltype %d"TENDSTR),
-               obj->obj_id, obj->variant_type));
+                 (TSTR("Obj %d has illegaltype %d" TENDSTR),
+                  obj->obj_id, obj->variant_type));

                break;
        }
 }
                break;
        }
 }


@@ -410,17 +422,17 @@ void yaffs_verify_objects(struct yaffs_dev *dev)
 
        /* Iterate through the objects in each hash entry */
 
 
        /* Iterate through the objects in each hash entry */
 

-       for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
+       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {

                list_for_each(lh, &dev->obj_bucket[i].list) {
                        if (lh) {
                list_for_each(lh, &dev->obj_bucket[i].list) {
                        if (lh) {

-                               obj = list_entry(lh, struct yaffs_obj, hash_link);
+                               obj =
+                                   list_entry(lh, struct yaffs_obj, hash_link);

                                yaffs_verify_obj(obj);
                        }
                }
        }
 }
 
                                yaffs_verify_obj(obj);
                        }
                }
        }
 }
 

-

 void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
 {
        struct list_head *lh;
 void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
 {
        struct list_head *lh;


@@ -438,13 +450,15 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
                return;
 
        if (!obj->parent) {
                return;
 
        if (!obj->parent) {

-               T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR)));
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("Object does not have parent" TENDSTR)));

                YBUG();
                return;
        }
 
        if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
                YBUG();
                return;
        }
 
        if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {

-               T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR)));
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("Parent is not directory" TENDSTR)));

                YBUG();
        }
 
                YBUG();
        }
 


@@ -457,10 +471,11 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
                        if (obj == list_obj)
                                count++;
                }
                        if (obj == list_obj)
                                count++;
                }

-        }
+       }

 
        if (count != 1) {
 
        if (count != 1) {

-               T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count));
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("Object in directory %d times" TENDSTR), count));

                YBUG();
        }
 }
                YBUG();
        }
 }


@@ -480,8 +495,8 @@ void yaffs_verify_dir(struct yaffs_obj *directory)
 
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
                T(YAFFS_TRACE_ALWAYS,
 
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
                T(YAFFS_TRACE_ALWAYS,

-               (TSTR("Directory has wrong type: %d" TENDSTR),
-               directory->variant_type));
+                 (TSTR("Directory has wrong type: %d" TENDSTR),
+                  directory->variant_type));

                YBUG();
        }
 
                YBUG();
        }
 


@@ -491,9 +506,10 @@ void yaffs_verify_dir(struct yaffs_obj *directory)
                if (lh) {
                        list_obj = list_entry(lh, struct yaffs_obj, siblings);
                        if (list_obj->parent != directory) {
                if (lh) {
                        list_obj = list_entry(lh, struct yaffs_obj, siblings);
                        if (list_obj->parent != directory) {

-                               T(YAFFS_TRACE_ALWAYS, (
-                               TSTR("Object in directory list has wrong parent %p" TENDSTR),
-                               list_obj->parent));
+                               T(YAFFS_TRACE_ALWAYS,
+                                 (TSTR
+                                  ("Object in directory list has wrong parent %p"
+                                   TENDSTR), list_obj->parent));

                                YBUG();
                        }
                        yaffs_verify_obj_in_dir(list_obj);
                                YBUG();
                        }
                        yaffs_verify_obj_in_dir(list_obj);


@@ -525,6 +541,6 @@ void yaffs_verify_free_chunks(struct yaffs_dev *dev)
 
 int yaffs_verify_file_sane(struct yaffs_obj *in)
 {
 
 int yaffs_verify_file_sane(struct yaffs_obj *in)
 {

-       in=in;
+       in = in;

        return YAFFS_OK;
 }
        return YAFFS_OK;
 }

diff --git a/yaffs_verify.h b/yaffs_verify.h
index 88924efc984d5f71484ad22ab0230b98a3e830fe..cc6f88999305dce2075eaac48f44de9ff44752f9 100644 (file)
--- a/yaffs_verify.h
+++ b/yaffs_verify.h
@@ -18,11 +18,14 @@
 
 #include "yaffs_guts.h"
 
 
 #include "yaffs_guts.h"
 

-void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n);
-void yaffs_verify_collected_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n);
+void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi,
+                     int n);
+void yaffs_verify_collected_blk(struct yaffs_dev *dev,
+                               struct yaffs_block_info *bi, int n);

 void yaffs_verify_blocks(struct yaffs_dev *dev);
 
 void yaffs_verify_blocks(struct yaffs_dev *dev);
 

-void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check);
+void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
+                    struct yaffs_ext_tags *tags, int parent_check);

 void yaffs_verify_file(struct yaffs_obj *obj);
 void yaffs_verify_link(struct yaffs_obj *obj);
 void yaffs_verify_symlink(struct yaffs_obj *obj);
 void yaffs_verify_file(struct yaffs_obj *obj);
 void yaffs_verify_link(struct yaffs_obj *obj);
 void yaffs_verify_symlink(struct yaffs_obj *obj);


@@ -38,4 +41,3 @@ int yaffs_verify_file_sane(struct yaffs_obj *obj);
 int yaffs_skip_verification(struct yaffs_dev *dev);
 
 #endif
 int yaffs_skip_verification(struct yaffs_dev *dev);
 
 #endif

-

diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c
index 6e2f8f8a963d89c018d82a41e77cb98fcc5f47cb..c4e3b978920d1edbe96111f8cc624cef4db3b322 100644 (file)
--- a/yaffs_vfs_multi.c
+++ b/yaffs_vfs_multi.c
@@ -151,7 +151,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
 {
        uint64_t result = partition_size;
        do_div(result, block_size);
 {
        uint64_t result = partition_size;
        do_div(result, block_size);

-       return (uint32_t)result;
+       return (uint32_t) result;

 }
 #else
 #define YCALCBLOCKS(s, b) ((s)/(b))
 }
 #else
 #define YCALCBLOCKS(s, b) ((s)/(b))


@@ -219,15 +219,14 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 #define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->u.generic_sbp)
 #endif
 
 #define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->u.generic_sbp)
 #endif
 

-

 #define update_dir_time(dir) do {\
                        (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
                } while(0)
 #define update_dir_time(dir) do {\
                        (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
                } while(0)

-               
+

 static void yaffs_put_super(struct super_block *sb);
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 static void yaffs_put_super(struct super_block *sb);
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,

-                               loff_t *pos);
+                               loff_t * pos);

 static ssize_t yaffs_hold_space(struct file *f);
 static void yaffs_release_space(struct file *f);
 
 static ssize_t yaffs_hold_space(struct file *f);
 static void yaffs_release_space(struct file *f);
 


@@ -241,7 +240,7 @@ static int yaffs_file_flush(struct file *file);
 static int yaffs_sync_object(struct file *file, int datasync);
 #else
 static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 static int yaffs_sync_object(struct file *file, int datasync);
 #else
 static int yaffs_sync_object(struct file *file, struct dentry *dentry,

-                               int datasync);
+                            int datasync);

 #endif
 
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
 #endif
 
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);


@@ -250,24 +249,24 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n);
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n);
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,

-                                       struct nameidata *n);
+                                  struct nameidata *n);

 #else
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
 #endif
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 #else
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
 #endif
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,

-                       struct dentry *dentry);
+                     struct dentry *dentry);

 static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,

-                       const char *symname);
+                        const char *symname);

 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,

-                       dev_t dev);
+                      dev_t dev);

 #else
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 #else
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,

-                       int dev);
+                      int dev);

 #endif
 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry);
 #endif
 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry);


@@ -309,31 +308,30 @@ static int yaffs_writepage(struct page *page);
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,

-                       const void *value, size_t size, int flags);
+                  const void *value, size_t size, int flags);

 ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
 ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,

-                       size_t size);
+                      size_t size);

 int yaffs_removexattr(struct dentry *dentry, const char *name);
 ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size);
 #endif
 
 int yaffs_removexattr(struct dentry *dentry, const char *name);
 ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size);
 #endif
 

-

 #if (YAFFS_USE_WRITE_BEGIN_END != 0)
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 #if (YAFFS_USE_WRITE_BEGIN_END != 0)
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned flags,
-                               struct page **pagep, void **fsdata);
+                            loff_t pos, unsigned len, unsigned flags,
+                            struct page **pagep, void **fsdata);

 static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 static int yaffs_write_end(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned copied,
-                               struct page *pg, void *fsdadata);
+                          loff_t pos, unsigned len, unsigned copied,
+                          struct page *pg, void *fsdadata);

 #else
 static int yaffs_prepare_write(struct file *f, struct page *pg,
 #else
 static int yaffs_prepare_write(struct file *f, struct page *pg,

-                               unsigned offset, unsigned to);
+                              unsigned offset, unsigned to);

 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,

-                               unsigned to);
+                             unsigned to);

 
 #endif
 
 
 #endif
 

-static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
-                               int buflen);
+static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
+                         int buflen);

 #if (YAFFS_NEW_FOLLOW_LINK == 1)
 void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias);
 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 #if (YAFFS_NEW_FOLLOW_LINK == 1)
 void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias);
 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);


@@ -347,7 +345,6 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin);
 
 static int yaffs_vfs_setattr(struct inode *, struct iattr *);
 
 
 static int yaffs_vfs_setattr(struct inode *, struct iattr *);
 

-

 static struct address_space_operations yaffs_file_address_operations = {
        .readpage = yaffs_readpage,
        .writepage = yaffs_writepage,
 static struct address_space_operations yaffs_file_address_operations = {
        .readpage = yaffs_readpage,
        .writepage = yaffs_writepage,


@@ -360,7 +357,6 @@ static struct address_space_operations yaffs_file_address_operations = {
 #endif
 };
 
 #endif
 };
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
 static const struct file_operations yaffs_file_operations = {
        .read = do_sync_read,
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
 static const struct file_operations yaffs_file_operations = {
        .read = do_sync_read,


@@ -405,14 +401,13 @@ static const struct file_operations yaffs_file_operations = {
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25))
 static void zero_user_segment(struct page *page, unsigned start, unsigned end)
 {
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25))
 static void zero_user_segment(struct page *page, unsigned start, unsigned end)
 {

-       void * kaddr = kmap_atomic(page, KM_USER0);
+       void *kaddr = kmap_atomic(page, KM_USER0);

        memset(kaddr + start, 0, end - start);
        kunmap_atomic(kaddr, KM_USER0);
        flush_dcache_page(page);
 }
 #endif
 
        memset(kaddr + start, 0, end - start);
        kunmap_atomic(kaddr, KM_USER0);
        flush_dcache_page(page);
 }
 #endif
 

-

 static const struct inode_operations yaffs_file_inode_operations = {
        .setattr = yaffs_setattr,
 #ifdef CONFIG_YAFFS_XATTR
 static const struct inode_operations yaffs_file_inode_operations = {
        .setattr = yaffs_setattr,
 #ifdef CONFIG_YAFFS_XATTR


@@ -484,11 +479,10 @@ static const struct super_operations yaffs_super_ops = {
        .write_super = yaffs_write_super,
 };
 
        .write_super = yaffs_write_super,
 };
 

-
-static  int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)
+static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)

 {
 #ifdef  YAFFS_USE_SETATTR_COPY
 {
 #ifdef  YAFFS_USE_SETATTR_COPY

-       setattr_copy(inode,attr);
+       setattr_copy(inode, attr);

        return 0;
 #else
        return inode_setattr(inode, attr);
        return 0;
 #else
        return inode_setattr(inode, attr);


@@ -496,13 +490,13 @@ static  int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)
 
 }
 
 
 }
 

-static  int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)
+static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)

 {
 #ifdef  YAFFS_USE_TRUNCATE_SETSIZE
 {
 #ifdef  YAFFS_USE_TRUNCATE_SETSIZE

-       truncate_setsize(inode,newsize);
+       truncate_setsize(inode, newsize);

        return 0;
 #else
        return 0;
 #else

-       truncate_inode_pages(&inode->i_data,newsize);
+       truncate_inode_pages(&inode->i_data, newsize);

        return 0;
 #endif
 
        return 0;
 #endif
 


@@ -512,7 +506,7 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 {
        return yaffs_gc_control;
 }
 {
        return yaffs_gc_control;
 }

-                                                                                                                       
+

 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));


@@ -528,22 +522,26 @@ static void yaffs_gross_unlock(struct yaffs_dev *dev)
 
 #ifdef YAFFS_COMPILE_EXPORTFS
 
 
 #ifdef YAFFS_COMPILE_EXPORTFS
 

-static struct inode *
-yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation)
+static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
+                                         uint32_t generation)

 {
        return Y_IGET(sb, ino);
 }
 
 {
        return Y_IGET(sb, ino);
 }
 

-static struct dentry *
-yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type)
+static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb,
+                                         struct fid *fid, int fh_len,
+                                         int fh_type)

 {
 {

-       return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ;
+       return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
+                                   yaffs2_nfs_get_inode);

 }
 
 }
 

-static struct dentry *
- yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type)
+static struct dentry *yaffs2_fh_to_parent(struct super_block *sb,
+                                         struct fid *fid, int fh_len,
+                                         int fh_type)

 {
 {

-       return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode);
+       return generic_fh_to_parent(sb, fid, fh_len, fh_type,
+                                   yaffs2_nfs_get_inode);

 }
 
 struct dentry *yaffs2_get_parent(struct dentry *dentry)
 }
 
 struct dentry *yaffs2_get_parent(struct dentry *dentry)


@@ -583,12 +581,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry)
  * using the default functions of exportfs.
  */
 
  * using the default functions of exportfs.
  */
 

-static struct export_operations yaffs_export_ops =
-{
+static struct export_operations yaffs_export_ops = {

        .fh_to_dentry = yaffs2_fh_to_dentry,
        .fh_to_parent = yaffs2_fh_to_parent,
        .get_parent = yaffs2_get_parent,
        .fh_to_dentry = yaffs2_fh_to_dentry,
        .fh_to_parent = yaffs2_fh_to_parent,
        .get_parent = yaffs2_get_parent,

-} ;
+};

 
 #endif
 
 
 #endif
 


@@ -624,21 +621,22 @@ struct yaffs_search_context {
  *
  * Called at start of readdir.
  */
  *
  * Called at start of readdir.
  */

-static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir)
+static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir)

 {
        struct yaffs_dev *dev = dir->my_dev;
 {
        struct yaffs_dev *dev = dir->my_dev;

-       struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context));
-       if(sc){
+       struct yaffs_search_context *sc =
+           YMALLOC(sizeof(struct yaffs_search_context));
+       if (sc) {

                sc->dir_obj = dir;
                sc->dev = dev;
                sc->dir_obj = dir;
                sc->dev = dev;

-               if( list_empty(&sc->dir_obj->variant.dir_variant.children))
+               if (list_empty(&sc->dir_obj->variant.dir_variant.children))

                        sc->next_return = NULL;
                else
                        sc->next_return = NULL;
                else

-                       sc->next_return = list_entry(
-                                dir->variant.dir_variant.children.next,
-                               struct yaffs_obj,siblings);
+                       sc->next_return =
+                           list_entry(dir->variant.dir_variant.children.next,
+                                      struct yaffs_obj, siblings);

                INIT_LIST_HEAD(&sc->others);
                INIT_LIST_HEAD(&sc->others);

-               list_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts));
+               list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts));

        }
        return sc;
 }
        }
        return sc;
 }


@@ -646,9 +644,9 @@ static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir)
 /*
  * yaffs_search_end() disposes of a search context and cleans up.
  */
 /*
  * yaffs_search_end() disposes of a search context and cleans up.
  */

-static void yaffs_search_end(struct yaffs_search_context * sc)
+static void yaffs_search_end(struct yaffs_search_context *sc)

 {
 {

-       if(sc){
+       if (sc) {

                list_del(&sc->others);
                YFREE(sc);
        }
                list_del(&sc->others);
                YFREE(sc);
        }


@@ -661,20 +659,21 @@ static void yaffs_search_end(struct yaffs_search_context * sc)
  */
 static void yaffs_search_advance(struct yaffs_search_context *sc)
 {
  */
 static void yaffs_search_advance(struct yaffs_search_context *sc)
 {

-        if(!sc)
-                return;
+       if (!sc)
+               return;

 
 

-        if( sc->next_return == NULL ||
-                list_empty(&sc->dir_obj->variant.dir_variant.children))
-                sc->next_return = NULL;
-        else {
-                struct list_head *next = sc->next_return->siblings.next;
+       if (sc->next_return == NULL ||
+           list_empty(&sc->dir_obj->variant.dir_variant.children))
+               sc->next_return = NULL;
+       else {
+               struct list_head *next = sc->next_return->siblings.next;

 
 

-                if( next == &sc->dir_obj->variant.dir_variant.children)
-                        sc->next_return = NULL; /* end of list */
-                else
-                        sc->next_return = list_entry(next,struct yaffs_obj,siblings);
-        }
+               if (next == &sc->dir_obj->variant.dir_variant.children)
+                       sc->next_return = NULL; /* end of list */
+               else
+                       sc->next_return =
+                           list_entry(next, struct yaffs_obj, siblings);
+       }

 }
 
 /*
 }
 
 /*


@@ -685,30 +684,29 @@ static void yaffs_search_advance(struct yaffs_search_context *sc)
 static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 {
 
 static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 {
 

-        struct list_head *i;
-        struct yaffs_search_context *sc;
-        struct list_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);
-
+       struct list_head *i;
+       struct yaffs_search_context *sc;
+       struct list_head *search_contexts =
+           &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);

 
 

-        /* Iterate through the directory search contexts.
-         * If any are currently on the object being removed, then advance
-         * the search context to the next object to prevent a hanging pointer.
-         */
-         list_for_each(i, search_contexts) {
-                if (i) {
-                        sc = list_entry(i, struct yaffs_search_context,others);
-                        if(sc->next_return == obj)
-                                yaffs_search_advance(sc);
-                }
+       /* Iterate through the directory search contexts.
+        * If any are currently on the object being removed, then advance
+        * the search context to the next object to prevent a hanging pointer.
+        */
+       list_for_each(i, search_contexts) {
+               if (i) {
+                       sc = list_entry(i, struct yaffs_search_context, others);
+                       if (sc->next_return == obj)
+                               yaffs_search_advance(sc);
+               }

        }
 
 }
 
        }
 
 }
 

-

 /*-----------------------------------------------------------------*/
 
 /*-----------------------------------------------------------------*/
 

-static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
-                       int buflen)
+static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
+                         int buflen)

 {
        unsigned char *alias;
        int ret;
 {
        unsigned char *alias;
        int ret;


@@ -751,32 +749,32 @@ static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
                ret_int = -ENOMEM;
                goto out;
        }
                ret_int = -ENOMEM;
                goto out;
        }

-

 #if (YAFFS_NEW_FOLLOW_LINK == 1)
        nd_set_link(nd, alias);
        ret = alias;
 out:
 #if (YAFFS_NEW_FOLLOW_LINK == 1)
        nd_set_link(nd, alias);
        ret = alias;
 out:

-       if(ret_int)
+       if (ret_int)

                ret = ERR_PTR(ret_int);
        return ret;
 #else
        ret = vfs_follow_link(nd, alias);
        kfree(alias);
 out:
                ret = ERR_PTR(ret_int);
        return ret;
 #else
        ret = vfs_follow_link(nd, alias);
        kfree(alias);
 out:

-       if(ret_int)
+       if (ret_int)

                ret = ret_int;
        return ret;
 #endif
 }
 
 #if (YAFFS_NEW_FOLLOW_LINK == 1)
                ret = ret_int;
        return ret;
 #endif
 }
 
 #if (YAFFS_NEW_FOLLOW_LINK == 1)

-void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) {
+void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias)
+{

        kfree(alias);
 }
 #endif
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        kfree(alias);
 }
 #endif
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,

-                               struct yaffs_obj *obj);
+                             struct yaffs_obj *obj);

 
 /*
  * Lookup is used to find objects in the fs
 
 /*
  * Lookup is used to find objects in the fs


@@ -784,7 +782,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,

-                               struct nameidata *n)
+                                  struct nameidata *n)

 #else
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
 #endif
 #else
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
 #endif


@@ -794,31 +792,29 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
 
        struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
 
 
        struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
 

-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if (current != yaffs_dev_to_lc(dev)->readdir_process)

                yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,
                yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_lookup for %d:%s\n"),
-               yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
+         (TSTR("yaffs_lookup for %d:%s\n"),
+          yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));

 
 

-       obj = yaffs_find_by_name(yaffs_inode_to_obj(dir),
-                                       dentry->d_name.name);
+       obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);

 
        obj = yaffs_get_equivalent_obj(obj);    /* in case it was a hardlink */
 
        /* Can't hold gross lock when calling yaffs_get_inode() */
 
        obj = yaffs_get_equivalent_obj(obj);    /* in case it was a hardlink */
 
        /* Can't hold gross lock when calling yaffs_get_inode() */

-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if (current != yaffs_dev_to_lc(dev)->readdir_process)

                yaffs_gross_unlock(dev);
 
        if (obj) {
                T(YAFFS_TRACE_OS,
                yaffs_gross_unlock(dev);
 
        if (obj) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
+                 (TSTR("yaffs_lookup found %d\n"), obj->obj_id));

 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
 
                if (inode) {
 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
 
                if (inode) {

-                       T(YAFFS_TRACE_OS,
-                               (TSTR("yaffs_loookup dentry \n")));
+                       T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));

 /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
  * d_add even if NULL inode */
 #if 0
 /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
  * d_add even if NULL inode */
 #if 0


@@ -831,7 +827,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
                }
 
        } else {
                }
 
        } else {

-               T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n")));
+               T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));

 
        }
 
 
        }
 


@@ -842,7 +838,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
        return NULL;
 }
 
        return NULL;
 }
 

-

 #ifdef YAFFS_HAS_PUT_INODE
 
 /* For now put inode is just for debugging
 #ifdef YAFFS_HAS_PUT_INODE
 
 /* For now put inode is just for debugging


@@ -851,13 +846,12 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
 static void yaffs_put_inode(struct inode *inode)
 {
        T(YAFFS_TRACE_OS,
 static void yaffs_put_inode(struct inode *inode)
 {
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
-               atomic_read(&inode->i_count)));
+         (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
+          atomic_read(&inode->i_count)));

 
 }
 #endif
 
 
 }
 #endif
 

-

 static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        /* Clear the association between the inode and
 static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        /* Clear the association between the inode and


@@ -878,7 +872,7 @@ static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
  * yaffs_clear_inode() and yaffs_delete_inode()
  *
  */
  * yaffs_clear_inode() and yaffs_delete_inode()
  *
  */

-static void yaffs_evict_inode( struct inode *inode)
+static void yaffs_evict_inode(struct inode *inode)

 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;


@@ -887,16 +881,16 @@ static void yaffs_evict_inode( struct inode *inode)
        obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-               atomic_read(&inode->i_count),
-               obj ? "object exists" : "null object"));
+         (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
+          atomic_read(&inode->i_count),
+          obj ? "object exists" : "null object"));

 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;
 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;

-       truncate_inode_pages(&inode->i_data,0);
+       truncate_inode_pages(&inode->i_data, 0);

        end_writeback(inode);
 
        end_writeback(inode);
 

-       if(deleteme && obj){
+       if (deleteme && obj) {

                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                yaffs_del_obj(obj);
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                yaffs_del_obj(obj);


@@ -905,11 +899,10 @@ static void yaffs_evict_inode( struct inode *inode)
        if (obj) {
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
        if (obj) {
                dev = obj->my_dev;
                yaffs_gross_lock(dev);

-               yaffs_unstitch_obj(inode,obj);
+               yaffs_unstitch_obj(inode, obj);

                yaffs_gross_unlock(dev);
        }
 
                yaffs_gross_unlock(dev);
        }
 

-

 }
 #else
 
 }
 #else
 


@@ -928,14 +921,14 @@ static void yaffs_clear_inode(struct inode *inode)
        obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-               atomic_read(&inode->i_count),
-               obj ? "object exists" : "null object"));
+         (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
+          atomic_read(&inode->i_count),
+          obj ? "object exists" : "null object"));

 
        if (obj) {
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
 
        if (obj) {
                dev = obj->my_dev;
                yaffs_gross_lock(dev);

-               yaffs_unstitch_obj(inode,obj);
+               yaffs_unstitch_obj(inode, obj);

                yaffs_gross_unlock(dev);
        }
 
                yaffs_gross_unlock(dev);
        }
 


@@ -952,9 +945,9 @@ static void yaffs_delete_inode(struct inode *inode)
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-               atomic_read(&inode->i_count),
-               obj ? "object exists" : "null object"));
+         (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
+          atomic_read(&inode->i_count),
+          obj ? "object exists" : "null object"));

 
        if (obj) {
                dev = obj->my_dev;
 
        if (obj) {
                dev = obj->my_dev;


@@ -969,7 +962,6 @@ static void yaffs_delete_inode(struct inode *inode)
 }
 #endif
 
 }
 #endif
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_file_flush(struct file *file, fl_owner_t id)
 #else
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_file_flush(struct file *file, fl_owner_t id)
 #else


@@ -981,8 +973,8 @@ static int yaffs_file_flush(struct file *file)
        struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
-               obj->dirty ? "dirty" : "clean"));
+         (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
+          obj->dirty ? "dirty" : "clean"));

 
        yaffs_gross_lock(dev);
 
 
        yaffs_gross_lock(dev);
 


@@ -1004,9 +996,9 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
-               (unsigned)(pg->index << PAGE_CACHE_SHIFT),
-               (unsigned)PAGE_CACHE_SIZE));
+         (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
+          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
+          (unsigned)PAGE_CACHE_SIZE));

 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 


@@ -1025,8 +1017,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        yaffs_gross_lock(dev);
 
        ret = yaffs_file_rd(obj, pg_buf,
        yaffs_gross_lock(dev);
 
        ret = yaffs_file_rd(obj, pg_buf,

-                               pg->index << PAGE_CACHE_SHIFT,
-                               PAGE_CACHE_SIZE);
+                           pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE);

 
        yaffs_gross_unlock(dev);
 
 
        yaffs_gross_unlock(dev);
 


@@ -1060,7 +1051,7 @@ static int yaffs_readpage(struct file *f, struct page *pg)
        int ret;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));
        int ret;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));

-       ret=yaffs_readpage_unlock(f, pg);
+       ret = yaffs_readpage_unlock(f, pg);

        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
        return ret;
 }
        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
        return ret;
 }


@@ -1092,20 +1083,21 @@ static int yaffs_writepage(struct page *page)
 
        end_index = i_size >> PAGE_CACHE_SHIFT;
 
 
        end_index = i_size >> PAGE_CACHE_SHIFT;
 

-       if(page->index < end_index)
+       if (page->index < end_index)

                n_bytes = PAGE_CACHE_SIZE;
        else {
                n_bytes = PAGE_CACHE_SIZE;
        else {

-               n_bytes = i_size & (PAGE_CACHE_SIZE -1);
+               n_bytes = i_size & (PAGE_CACHE_SIZE - 1);

 
                if (page->index > end_index || !n_bytes) {
                        T(YAFFS_TRACE_OS,
 
                if (page->index > end_index || !n_bytes) {
                        T(YAFFS_TRACE_OS,

-                               (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"),
-                               (unsigned)(page->index << PAGE_CACHE_SHIFT),
-                               (unsigned)inode->i_size));
+                         (TSTR
+                          ("yaffs_writepage at %08x, inode size = %08x!!!\n"),
+                          (unsigned)(page->index << PAGE_CACHE_SHIFT),
+                          (unsigned)inode->i_size));

                        T(YAFFS_TRACE_OS,
                        T(YAFFS_TRACE_OS,

-                               (TSTR("                -> don't care!!\n")));
+                         (TSTR("                -> don't care!!\n")));

 
 

-                       zero_user_segment(page,0,PAGE_CACHE_SIZE);
+                       zero_user_segment(page, 0, PAGE_CACHE_SIZE);

                        set_page_writeback(page);
                        unlock_page(page);
                        end_page_writeback(page);
                        set_page_writeback(page);
                        unlock_page(page);
                        end_page_writeback(page);


@@ -1113,8 +1105,8 @@ static int yaffs_writepage(struct page *page)
                }
        }
 
                }
        }
 

-       if(n_bytes != PAGE_CACHE_SIZE)
-               zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE);
+       if (n_bytes != PAGE_CACHE_SIZE)
+               zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE);

 
        get_page(page);
 
 
        get_page(page);
 


@@ -1125,20 +1117,20 @@ static int yaffs_writepage(struct page *page)
        yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,
        yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_writepage at %08x, size %08x\n"),
-               (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes));
+         (TSTR("yaffs_writepage at %08x, size %08x\n"),
+          (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes));

        T(YAFFS_TRACE_OS,
        T(YAFFS_TRACE_OS,

-               (TSTR("writepag0: obj = %05x, ino = %05x\n"),
-               (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+         (TSTR("writepag0: obj = %05x, ino = %05x\n"),
+          (int)obj->variant.file_variant.file_size, (int)inode->i_size));

 
        n_written = yaffs_wr_file(obj, buffer,
 
        n_written = yaffs_wr_file(obj, buffer,

-                       page->index << PAGE_CACHE_SHIFT, n_bytes, 0);
+                                 page->index << PAGE_CACHE_SHIFT, n_bytes, 0);

 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,
 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("writepag1: obj = %05x, ino = %05x\n"),
-               (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+         (TSTR("writepag1: obj = %05x, ino = %05x\n"),
+          (int)obj->variant.file_variant.file_size, (int)inode->i_size));

 
        yaffs_gross_unlock(dev);
 
 
        yaffs_gross_unlock(dev);
 


@@ -1151,11 +1143,10 @@ static int yaffs_writepage(struct page *page)
        return (n_written == n_bytes) ? 0 : -ENOSPC;
 }
 
        return (n_written == n_bytes) ? 0 : -ENOSPC;
 }
 

-

 #if (YAFFS_USE_WRITE_BEGIN_END > 0)
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 #if (YAFFS_USE_WRITE_BEGIN_END > 0)
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned flags,
-                               struct page **pagep, void **fsdata)
+                            loff_t pos, unsigned len, unsigned flags,
+                            struct page **pagep, void **fsdata)

 {
        struct page *pg = NULL;
        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 {
        struct page *pg = NULL;
        pgoff_t index = pos >> PAGE_CACHE_SHIFT;


@@ -1172,12 +1163,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 
        *pagep = pg;
        if (!pg) {
 
        *pagep = pg;
        if (!pg) {

-               ret =  -ENOMEM;
+               ret = -ENOMEM;

                goto out;
        }
        T(YAFFS_TRACE_OS,
                goto out;
        }
        T(YAFFS_TRACE_OS,

-               (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
-               (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0));
+         (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
+          (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0));

 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);
 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);


@@ -1202,7 +1193,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 
 out:
        T(YAFFS_TRACE_OS,
 
 out:
        T(YAFFS_TRACE_OS,

-               (TSTR("end yaffs_write_begin fail returning %d\n"), ret));
+         (TSTR("end yaffs_write_begin fail returning %d\n"), ret));

        if (space_held)
                yaffs_release_space(filp);
        if (pg) {
        if (space_held)
                yaffs_release_space(filp);
        if (pg) {


@@ -1215,7 +1206,7 @@ out:
 #else
 
 static int yaffs_prepare_write(struct file *f, struct page *pg,
 #else
 
 static int yaffs_prepare_write(struct file *f, struct page *pg,

-                               unsigned offset, unsigned to)
+                              unsigned offset, unsigned to)

 {
        T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n")));
 
 {
        T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n")));
 


@@ -1227,8 +1218,8 @@ static int yaffs_prepare_write(struct file *f, struct page *pg,
 
 #if (YAFFS_USE_WRITE_BEGIN_END > 0)
 static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 
 #if (YAFFS_USE_WRITE_BEGIN_END > 0)
 static int yaffs_write_end(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned copied,
-                               struct page *pg, void *fsdadata)
+                          loff_t pos, unsigned len, unsigned copied,
+                          struct page *pg, void *fsdadata)

 {
        int ret = 0;
        void *addr, *kva;
 {
        int ret = 0;
        void *addr, *kva;


@@ -1238,15 +1229,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
        addr = kva + offset_into_page;
 
        T(YAFFS_TRACE_OS,
        addr = kva + offset_into_page;
 
        T(YAFFS_TRACE_OS,

-               ("yaffs_write_end addr %p pos %x n_bytes %d\n",
-               addr,(unsigned)pos, copied));
+         ("yaffs_write_end addr %p pos %x n_bytes %d\n",
+          addr, (unsigned)pos, copied));

 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
                T(YAFFS_TRACE_OS,
 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
-                       ret, copied));
+                 (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
+                  ret, copied));

                SetPageError(pg);
        } else {
                /* Nothing */
                SetPageError(pg);
        } else {
                /* Nothing */


@@ -1262,7 +1253,7 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 #else
 
 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 #else
 
 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,

-                               unsigned to)
+                             unsigned to)

 {
        void *addr, *kva;
 
 {
        void *addr, *kva;
 


@@ -1276,18 +1267,19 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
        kva = kmap(pg);
        addr = kva + offset;
 
        kva = kmap(pg);
        addr = kva + offset;
 

-       saddr = (unsigned) addr;
+       saddr = (unsigned)addr;

 
        T(YAFFS_TRACE_OS,
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"),
-               saddr, spos, n_bytes));
+         (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"),
+          saddr, spos, n_bytes));

 
        n_written = yaffs_file_write(f, addr, n_bytes, &pos);
 
        if (n_written != n_bytes) {
                T(YAFFS_TRACE_OS,
 
        n_written = yaffs_file_write(f, addr, n_bytes, &pos);
 
        if (n_written != n_bytes) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_commit_write not same size n_written %d  n_bytes %d\n"),
-                       n_written, n_bytes));
+                 (TSTR
+                  ("yaffs_commit_write not same size n_written %d  n_bytes %d\n"),
+                  n_written, n_bytes));

                SetPageError(pg);
        } else {
                /* Nothing */
                SetPageError(pg);
        } else {
                /* Nothing */


@@ -1296,19 +1288,18 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
        kunmap(pg);
 
        T(YAFFS_TRACE_OS,
        kunmap(pg);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_commit_write returning %d\n"),
-               n_written == n_bytes ? 0 : n_written));
+         (TSTR("yaffs_commit_write returning %d\n"),
+          n_written == n_bytes ? 0 : n_written));

 
        return n_written == n_bytes ? 0 : n_written;
 }
 #endif
 
 
        return n_written == n_bytes ? 0 : n_written;
 }
 #endif
 

-
-static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj)
+static void yaffs_fill_inode_from_obj(struct inode *inode,
+                                     struct yaffs_obj *obj)

 {
        if (inode && obj) {
 
 {
        if (inode && obj) {
 

-

                /* Check mode against the variant type and attempt to repair if broken. */
                u32 mode = obj->yst_mode;
                switch (obj->variant_type) {
                /* Check mode against the variant type and attempt to repair if broken. */
                u32 mode = obj->yst_mode;
                switch (obj->variant_type) {


@@ -1371,25 +1362,26 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
                T(YAFFS_TRACE_OS,
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
-                       inode->i_mode, inode->i_uid, inode->i_gid,
-                       (int)inode->i_size, atomic_read(&inode->i_count)));
+                 (TSTR
+                  ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
+                  inode->i_mode, inode->i_uid, inode->i_gid,
+                  (int)inode->i_size, atomic_read(&inode->i_count)));

 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
                        init_special_inode(inode, obj->yst_mode,
 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
                        init_special_inode(inode, obj->yst_mode,

-                                       old_decode_dev(obj->yst_rdev));
+                                          old_decode_dev(obj->yst_rdev));

 #else
                        init_special_inode(inode, obj->yst_mode,
 #else
                        init_special_inode(inode, obj->yst_mode,

-                                       (dev_t) (obj->yst_rdev));
+                                          (dev_t) (obj->yst_rdev));

 #endif
                        break;
                case S_IFREG:   /* file */
                        inode->i_op = &yaffs_file_inode_operations;
                        inode->i_fop = &yaffs_file_operations;
                        inode->i_mapping->a_ops =
 #endif
                        break;
                case S_IFREG:   /* file */
                        inode->i_op = &yaffs_file_inode_operations;
                        inode->i_fop = &yaffs_file_operations;
                        inode->i_mapping->a_ops =

-                               &yaffs_file_address_operations;
+                           &yaffs_file_address_operations;

                        break;
                case S_IFDIR:   /* directory */
                        inode->i_op = &yaffs_dir_inode_operations;
                        break;
                case S_IFDIR:   /* directory */
                        inode->i_op = &yaffs_dir_inode_operations;


@@ -1406,32 +1398,32 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj
 
        } else {
                T(YAFFS_TRACE_OS,
 
        } else {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_fill_inode invalid parameters\n")));
+                 (TSTR("yaffs_fill_inode invalid parameters\n")));

        }
 
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        }
 
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,

-                               struct yaffs_obj *obj)
+                             struct yaffs_obj *obj)

 {
        struct inode *inode;
 
        if (!sb) {
                T(YAFFS_TRACE_OS,
 {
        struct inode *inode;
 
        if (!sb) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_get_inode for NULL super_block!!\n")));
+                 (TSTR("yaffs_get_inode for NULL super_block!!\n")));

                return NULL;
 
        }
 
        if (!obj) {
                T(YAFFS_TRACE_OS,
                return NULL;
 
        }
 
        if (!obj) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_get_inode for NULL object!!\n")));
+                 (TSTR("yaffs_get_inode for NULL object!!\n")));

                return NULL;
 
        }
 
        T(YAFFS_TRACE_OS,
                return NULL;
 
        }
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
+         (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));

 
        inode = Y_IGET(sb, obj->obj_id);
        if (IS_ERR(inode))
 
        inode = Y_IGET(sb, obj->obj_id);
        if (IS_ERR(inode))


@@ -1445,7 +1437,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 }
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 }
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,

-                               loff_t *pos)
+                               loff_t * pos)

 {
        struct yaffs_obj *obj;
        int n_written, ipos;
 {
        struct yaffs_obj *obj;
        int n_written, ipos;


@@ -1467,20 +1459,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 
        if (!obj)
                T(YAFFS_TRACE_OS,
 
        if (!obj)
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_file_write: hey obj is null!\n")));
+                 (TSTR("yaffs_file_write: hey obj is null!\n")));

        else
                T(YAFFS_TRACE_OS,
        else
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_file_write about to write writing %u(%x) bytes"
+                 (TSTR("yaffs_file_write about to write writing %u(%x) bytes"

                        "to object %d at %d(%x)\n"),
                        "to object %d at %d(%x)\n"),

-                       (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos));
+                  (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos));

 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,
 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_file_write: %d(%x) bytes written\n"),
-               (unsigned )n,(unsigned)n));
+         (TSTR("yaffs_file_write: %d(%x) bytes written\n"),
+          (unsigned)n, (unsigned)n));

 
        if (n_written > 0) {
                ipos += n_written;
 
        if (n_written > 0) {
                ipos += n_written;


@@ -1490,9 +1482,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                        inode->i_blocks = (ipos + 511) >> 9;
 
                        T(YAFFS_TRACE_OS,
                        inode->i_blocks = (ipos + 511) >> 9;
 
                        T(YAFFS_TRACE_OS,

-                               (TSTR("yaffs_file_write size updated to %d bytes, "
-                               "%d blocks\n"),
-                               ipos, (int)(inode->i_blocks)));
+                         (TSTR("yaffs_file_write size updated to %d bytes, "
+                               "%d blocks\n"), ipos, (int)(inode->i_blocks)));

                }
 
        }
                }
 
        }


@@ -1511,7 +1502,6 @@ static ssize_t yaffs_hold_space(struct file *f)
 
        int n_free_chunks;
 
 
        int n_free_chunks;
 

-

        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;


@@ -1530,25 +1520,22 @@ static void yaffs_release_space(struct file *f)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 

-

        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;
 
        yaffs_gross_lock(dev);
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;
 
        yaffs_gross_lock(dev);
 

-

        yaffs_gross_unlock(dev);
 }
 
        yaffs_gross_unlock(dev);
 }
 

-

 static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
 {
        long long retval;
 
        lock_kernel();
 
 static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
 {
        long long retval;
 
        lock_kernel();
 

-       switch (origin){
+       switch (origin) {

        case 2:
                offset += i_size_read(file->f_path.dentry->d_inode);
                break;
        case 2:
                offset += i_size_read(file->f_path.dentry->d_inode);
                break;


@@ -1557,7 +1544,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
        }
        retval = -EINVAL;
 
        }
        retval = -EINVAL;
 

-       if (offset >= 0){
+       if (offset >= 0) {

                if (offset != file->f_pos)
                        file->f_pos = offset;
 
                if (offset != file->f_pos)
                        file->f_pos = offset;
 


@@ -1567,16 +1554,15 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
        return retval;
 }
 
        return retval;
 }
 

-

 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;

-        struct yaffs_search_context *sc;
+       struct yaffs_search_context *sc;

        struct inode *inode = f->f_dentry->d_inode;
        unsigned long offset, curoffs;
        struct yaffs_obj *l;
        struct inode *inode = f->f_dentry->d_inode;
        unsigned long offset, curoffs;
        struct yaffs_obj *l;

-        int ret_val = 0;
+       int ret_val = 0;

 
        char name[YAFFS_MAX_NAME_LENGTH + 1];
 
 
        char name[YAFFS_MAX_NAME_LENGTH + 1];
 


@@ -1589,20 +1575,21 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 
        offset = f->f_pos;
 
 
        offset = f->f_pos;
 

-        sc = yaffs_new_search(obj);
-        if(!sc){
-                ret_val = -ENOMEM;
-                goto out;
-        }
+       sc = yaffs_new_search(obj);
+       if (!sc) {
+               ret_val = -ENOMEM;
+               goto out;
+       }

 
 

-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));
+       T(YAFFS_TRACE_OS,
+         (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));

 
        if (offset == 0) {
                T(YAFFS_TRACE_OS,
 
        if (offset == 0) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_readdir: entry . ino %d \n"),
-                       (int)inode->i_ino));
+                 (TSTR("yaffs_readdir: entry . ino %d \n"),
+                  (int)inode->i_ino));

                yaffs_gross_unlock(dev);
                yaffs_gross_unlock(dev);

-               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){
+               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) {

                        yaffs_gross_lock(dev);
                        goto out;
                }
                        yaffs_gross_lock(dev);
                        goto out;
                }


@@ -1612,11 +1599,12 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
        }
        if (offset == 1) {
                T(YAFFS_TRACE_OS,
        }
        if (offset == 1) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_readdir: entry .. ino %d \n"),
-                       (int)f->f_dentry->d_parent->d_inode->i_ino));
+                 (TSTR("yaffs_readdir: entry .. ino %d \n"),
+                  (int)f->f_dentry->d_parent->d_inode->i_ino));

                yaffs_gross_unlock(dev);
                if (filldir(dirent, "..", 2, offset,
                yaffs_gross_unlock(dev);
                if (filldir(dirent, "..", 2, offset,

-                       f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){
+                           f->f_dentry->d_parent->d_inode->i_ino,
+                           DT_DIR) < 0) {

                        yaffs_gross_lock(dev);
                        goto out;
                }
                        yaffs_gross_lock(dev);
                        goto out;
                }


@@ -1635,37 +1623,34 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                f->f_version = inode->i_version;
        }
 
                f->f_version = inode->i_version;
        }
 

-       while(sc->next_return){
+       while (sc->next_return) {

                curoffs++;
                curoffs++;

-                l = sc->next_return;
+               l = sc->next_return;

                if (curoffs >= offset) {
                if (curoffs >= offset) {

-                        int this_inode = yaffs_get_obj_inode(l);
-                        int this_type = yaffs_get_obj_type(l);
+                       int this_inode = yaffs_get_obj_inode(l);
+                       int this_type = yaffs_get_obj_type(l);

 
 

-                       yaffs_get_obj_name(l, name,
-                                           YAFFS_MAX_NAME_LENGTH + 1);
+                       yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);

                        T(YAFFS_TRACE_OS,
                          (TSTR("yaffs_readdir: %s inode %d\n"),
                        T(YAFFS_TRACE_OS,
                          (TSTR("yaffs_readdir: %s inode %d\n"),

-                         name, yaffs_get_obj_inode(l)));
+                          name, yaffs_get_obj_inode(l)));

 
 

-                        yaffs_gross_unlock(dev);
+                       yaffs_gross_unlock(dev);

 
                        if (filldir(dirent,
 
                        if (filldir(dirent,

-                                       name,
-                                       strlen(name),
-                                       offset,
-                                       this_inode,
-                                       this_type) < 0){
+                                   name,
+                                   strlen(name),
+                                   offset, this_inode, this_type) < 0) {

                                yaffs_gross_lock(dev);
                                goto out;
                        }
 
                                yaffs_gross_lock(dev);
                                goto out;
                        }
 

-                        yaffs_gross_lock(dev);
+                       yaffs_gross_lock(dev);

 
                        offset++;
                        f->f_pos++;
                }
 
                        offset++;
                        f->f_pos++;
                }

-                yaffs_search_advance(sc);
+               yaffs_search_advance(sc);

        }
 
 out:
        }
 
 out:


@@ -1676,8 +1661,6 @@ out:
        return ret_val;
 }
 
        return ret_val;
 }
 

-
-

 /*
  * File creation. Allocate an inode, and we're done..
  */
 /*
  * File creation. Allocate an inode, and we're done..
  */


@@ -1690,10 +1673,10 @@ out:
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,

-                       dev_t rdev)
+                      dev_t rdev)

 #else
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 #else
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,

-                       int rdev)
+                      int rdev)

 #endif
 {
        struct inode *inode;
 #endif
 {
        struct inode *inode;


@@ -1705,24 +1688,25 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
        int error = -ENOSPC;
        uid_t uid = YCRED(current)->fsuid;
 
        int error = -ENOSPC;
        uid_t uid = YCRED(current)->fsuid;

-       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
+       gid_t gid =
+           (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;

 
        if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
                mode |= S_ISGID;
 
        if (parent) {
                T(YAFFS_TRACE_OS,
 
        if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
                mode |= S_ISGID;
 
        if (parent) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_mknod: parent object %d type %d\n"),
-                       parent->obj_id, parent->variant_type));
+                 (TSTR("yaffs_mknod: parent object %d type %d\n"),
+                  parent->obj_id, parent->variant_type));

        } else {
                T(YAFFS_TRACE_OS,
        } else {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_mknod: could not get parent object\n")));
+                 (TSTR("yaffs_mknod: could not get parent object\n")));

                return -EPERM;
        }
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "
                return -EPERM;
        }
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "

-                       "mode %x dev %x\n"),
-                       dentry->d_name.name, mode, rdev));
+                               "mode %x dev %x\n"),
+                          dentry->d_name.name, mode, rdev));

 
        dev = parent->my_dev;
 
 
        dev = parent->my_dev;
 


@@ -1733,23 +1717,24 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                /* Special (socket, fifo, device...) */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
                /* Special (socket, fifo, device...) */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))

-               obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid,
-                               gid, old_encode_dev(rdev));
+               obj =
+                   yaffs_create_special(parent, dentry->d_name.name, mode, uid,
+                                        gid, old_encode_dev(rdev));

 #else
 #else

-               obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid,
-                               gid, rdev);
+               obj =
+                   yaffs_create_special(parent, dentry->d_name.name, mode, uid,
+                                        gid, rdev);

 #endif
                break;
        case S_IFREG:           /* file          */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
                obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,
 #endif
                break;
        case S_IFREG:           /* file          */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
                obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,

-                               gid);
+                                       gid);

                break;
        case S_IFDIR:           /* directory */
                break;
        case S_IFDIR:           /* directory */

-               T(YAFFS_TRACE_OS,
-                       (TSTR("yaffs_mknod: making directory\n")));
+               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n")));

                obj = yaffs_create_dir(parent, dentry->d_name.name, mode,
                obj = yaffs_create_dir(parent, dentry->d_name.name, mode,

-                                       uid, gid);
+                                      uid, gid);

                break;
        case S_IFLNK:           /* symlink */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));
                break;
        case S_IFLNK:           /* symlink */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));


@@ -1765,13 +1750,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                d_instantiate(dentry, inode);
                update_dir_time(dir);
                T(YAFFS_TRACE_OS,
                d_instantiate(dentry, inode);
                update_dir_time(dir);
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_mknod created object %d count = %d\n"),
-                       obj->obj_id, atomic_read(&inode->i_count)));
+                 (TSTR("yaffs_mknod created object %d count = %d\n"),
+                  obj->obj_id, atomic_read(&inode->i_count)));

                error = 0;
                error = 0;

-               yaffs_fill_inode_from_obj(dir,parent);
+               yaffs_fill_inode_from_obj(dir, parent);

        } else {
        } else {

-               T(YAFFS_TRACE_OS,
-                       (TSTR("yaffs_mknod failed making object\n")));
+               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n")));

                error = -ENOMEM;
        }
 
                error = -ENOMEM;
        }
 


@@ -1793,7 +1777,7 @@ static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
 #endif
 {
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
 #endif
 {

-       T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n")));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n")));

        return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 
        return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 


@@ -1805,9 +1789,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
        struct yaffs_obj *obj;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_unlink %d:%s\n"),
-               (int)(dir->i_ino),
-               dentry->d_name.name));
+         (TSTR("yaffs_unlink %d:%s\n"),
+          (int)(dir->i_ino), dentry->d_name.name));

        obj = yaffs_inode_to_obj(dir);
        dev = obj->my_dev;
 
        obj = yaffs_inode_to_obj(dir);
        dev = obj->my_dev;
 


@@ -1831,7 +1814,7 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
  * Create a link...
  */
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
  * Create a link...
  */
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,

-                       struct dentry *dentry)
+                     struct dentry *dentry)

 {
        struct inode *inode = old_dentry->d_inode;
        struct yaffs_obj *obj = NULL;
 {
        struct inode *inode = old_dentry->d_inode;
        struct yaffs_obj *obj = NULL;


@@ -1845,23 +1828,24 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 
        yaffs_gross_lock(dev);
 
 
        yaffs_gross_lock(dev);
 

-       if (!S_ISDIR(inode->i_mode))            /* Don't link directories */
-               link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
-                       obj);
+       if (!S_ISDIR(inode->i_mode))    /* Don't link directories */
+               link =
+                   yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
+                                  obj);

 
        if (link) {
                old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
                d_instantiate(dentry, old_dentry->d_inode);
                atomic_inc(&old_dentry->d_inode->i_count);
                T(YAFFS_TRACE_OS,
 
        if (link) {
                old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
                d_instantiate(dentry, old_dentry->d_inode);
                atomic_inc(&old_dentry->d_inode->i_count);
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_link link count %d i_count %d\n"),
-                       old_dentry->d_inode->i_nlink,
-                       atomic_read(&old_dentry->d_inode->i_count)));
+                 (TSTR("yaffs_link link count %d i_count %d\n"),
+                  old_dentry->d_inode->i_nlink,
+                  atomic_read(&old_dentry->d_inode->i_count)));

        }
 
        yaffs_gross_unlock(dev);
 
        }
 
        yaffs_gross_unlock(dev);
 

-       if (link){
+       if (link) {

                update_dir_time(dir);
                return 0;
        }
                update_dir_time(dir);
                return 0;
        }


@@ -1870,19 +1854,20 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 }
 
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 }
 
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,

-                               const char *symname)
+                        const char *symname)

 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
        uid_t uid = YCRED(current)->fsuid;
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
        uid_t uid = YCRED(current)->fsuid;

-       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
+       gid_t gid =
+           (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;

 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
 
        dev = yaffs_inode_to_obj(dir)->my_dev;
        yaffs_gross_lock(dev);
        obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
 
        dev = yaffs_inode_to_obj(dir)->my_dev;
        yaffs_gross_lock(dev);
        obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,

-                               S_IFLNK | S_IRWXUGO, uid, gid, symname);
+                                  S_IFLNK | S_IRWXUGO, uid, gid, symname);

        yaffs_gross_unlock(dev);
 
        if (obj) {
        yaffs_gross_unlock(dev);
 
        if (obj) {


@@ -1904,7 +1889,7 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 static int yaffs_sync_object(struct file *file, int datasync)
 #else
 static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 static int yaffs_sync_object(struct file *file, int datasync)
 #else
 static int yaffs_sync_object(struct file *file, struct dentry *dentry,

-                               int datasync)
+                            int datasync)

 #endif
 {
 
 #endif
 {
 


@@ -1918,8 +1903,7 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 
        dev = obj->my_dev;
 
 
        dev = obj->my_dev;
 

-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
-               (TSTR("yaffs_sync_object\n")));
+       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n")));

        yaffs_gross_lock(dev);
        yaffs_flush_file(obj, 1, datasync);
        yaffs_gross_unlock(dev);
        yaffs_gross_lock(dev);
        yaffs_flush_file(obj, 1, datasync);
        yaffs_gross_unlock(dev);


@@ -1945,12 +1929,10 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
        /* Check if the target is an existing directory that is not empty. */
        target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),
 
        /* Check if the target is an existing directory that is not empty. */
        target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),

-                               new_dentry->d_name.name);
-
-
+                                   new_dentry->d_name.name);

 
        if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
 
        if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&

-               !list_empty(&target->variant.dir_variant.children)) {
+           !list_empty(&target->variant.dir_variant.children)) {

 
                T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
 
 
                T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
 


@@ -1960,9 +1942,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
 
                ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
                T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
 
                ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),

-                               old_dentry->d_name.name,
-                               yaffs_inode_to_obj(new_dir),
-                               new_dentry->d_name.name);
+                                          old_dentry->d_name.name,
+                                          yaffs_inode_to_obj(new_dir),
+                                          new_dentry->d_name.name);

        }
        yaffs_gross_unlock(dev);
 
        }
        yaffs_gross_unlock(dev);
 


@@ -1971,9 +1953,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        new_dentry->d_inode->i_nlink--;
                        mark_inode_dirty(new_dentry->d_inode);
                }
                        new_dentry->d_inode->i_nlink--;
                        mark_inode_dirty(new_dentry->d_inode);
                }

-               
+

                update_dir_time(old_dir);
                update_dir_time(old_dir);

-               if(old_dir != new_dir)
+               if (old_dir != new_dir)

                        update_dir_time(new_dir);
                return 0;
        } else {
                        update_dir_time(new_dir);
                return 0;
        } else {


@@ -1988,34 +1970,34 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_setattr of object %d\n"),
-               yaffs_inode_to_obj(inode)->obj_id));
+         (TSTR("yaffs_setattr of object %d\n"),
+          yaffs_inode_to_obj(inode)->obj_id));

 
 

-       /* Fail if a requested resize >= 2GB */         
-       if (attr->ia_valid & ATTR_SIZE &&
-               (attr->ia_size >> 31))
+       /* Fail if a requested resize >= 2GB */
+       if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31))

                error = -EINVAL;
 
        if (error == 0)
                error = inode_change_ok(inode, attr);
        if (error == 0) {
                int result;
                error = -EINVAL;
 
        if (error == 0)
                error = inode_change_ok(inode, attr);
        if (error == 0) {
                int result;

-               if (!error){
+               if (!error) {

                        error = yaffs_vfs_setattr(inode, attr);
                        error = yaffs_vfs_setattr(inode, attr);

-                       T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n")));
-                       if (attr->ia_valid & ATTR_SIZE){
-                               yaffs_vfs_setsize(inode,attr->ia_size);
-                               inode->i_blocks = (inode->i_size + 511) >> 9;
+                       T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n")));
+                       if (attr->ia_valid & ATTR_SIZE) {
+                               yaffs_vfs_setsize(inode, attr->ia_size);
+                               inode->i_blocks = (inode->i_size + 511) >> 9;

                        }
                }
                dev = yaffs_inode_to_obj(inode)->my_dev;
                        }
                }
                dev = yaffs_inode_to_obj(inode)->my_dev;

-               if (attr->ia_valid & ATTR_SIZE){
-                       T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"),
-                               (int)(attr->ia_size),(int)(attr->ia_size)));
+               if (attr->ia_valid & ATTR_SIZE) {
+                       T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"),
+                                          (int)(attr->ia_size),
+                                          (int)(attr->ia_size)));

                }
                yaffs_gross_lock(dev);
                result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
                }
                yaffs_gross_lock(dev);
                result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);

-               if(result == YAFFS_OK) {
+               if (result == YAFFS_OK) {

                        error = 0;
                } else {
                        error = -EPERM;
                        error = 0;
                } else {
                        error = -EPERM;


@@ -2024,47 +2006,41 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 
        }
 
 
        }
 

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_setattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error));

 
        return error;
 }
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,
 
        return error;
 }
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,

-                       const void *value, size_t size, int flags)
+                  const void *value, size_t size, int flags)

 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_setxattr of object %d\n"),
-               obj->obj_id));
-
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id));

 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_set_xattrib(obj, name, value, size, flags);
 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_set_xattrib(obj, name, value, size, flags);

-               if(result == YAFFS_OK)
+               if (result == YAFFS_OK)

                        error = 0;
                        error = 0;

-               else if(result < 0)
+               else if (result < 0)

                        error = result;
                yaffs_gross_unlock(dev);
 
        }
                        error = result;
                yaffs_gross_unlock(dev);
 
        }

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_setxattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error));

 
        return error;
 }
 
 
        return error;
 }
 

-
-ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
-                       size_t size)
+ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff,
+                      size_t size)

 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;


@@ -2072,8 +2048,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_getxattr \"%s\" from object %d\n"),
-               name, obj->obj_id));
+         (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id));

 
        if (error == 0) {
                dev = obj->my_dev;
 
        if (error == 0) {
                dev = obj->my_dev;


@@ -2082,8 +2057,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
                yaffs_gross_unlock(dev);
 
        }
                yaffs_gross_unlock(dev);
 
        }

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_getxattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error));

 
        return error;
 }
 
        return error;
 }


@@ -2096,29 +2070,27 @@ int yaffs_removexattr(struct dentry *dentry, const char *name)
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_removexattr of object %d\n"),
-               obj->obj_id));
-
+         (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id));

 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_remove_xattrib(obj, name);
 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_remove_xattrib(obj, name);

-               if(result == YAFFS_OK)
+               if (result == YAFFS_OK)

                        error = 0;
                        error = 0;

-               else if(result < 0)
+               else if (result < 0)

                        error = result;
                yaffs_gross_unlock(dev);
 
        }
        T(YAFFS_TRACE_OS,
                        error = result;
                yaffs_gross_unlock(dev);
 
        }
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_removexattr done returning %d\n"),error));
+         (TSTR("yaffs_removexattr done returning %d\n"), error));

 
        return error;
 }
 
 
        return error;
 }
 

-ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
+ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)

 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;


@@ -2126,9 +2098,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_listxattr of object %d\n"),
-               obj->obj_id));
-
+         (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id));

 
        if (error == 0) {
                dev = obj->my_dev;
 
        if (error == 0) {
                dev = obj->my_dev;


@@ -2137,15 +2107,13 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
                yaffs_gross_unlock(dev);
 
        }
                yaffs_gross_unlock(dev);
 
        }

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_listxattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error));

 
        return error;
 }
 
 #endif
 
 
        return error;
 }
 
 #endif
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {


@@ -2175,14 +2143,17 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
                uint64_t bytes_in_dev;
                uint64_t bytes_free;
 
                uint64_t bytes_in_dev;
                uint64_t bytes_free;
 

-               bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) *
-                       ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk));
+               bytes_in_dev =
+                   ((uint64_t)
+                    ((dev->param.end_block - dev->param.start_block +
+                      1))) * ((uint64_t) (dev->param.chunks_per_block *
+                                          dev->data_bytes_per_chunk));

 
 

-               do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */
+               do_div(bytes_in_dev, sb->s_blocksize);  /* bytes_in_dev becomes the number of blocks */

                buf->f_blocks = bytes_in_dev;
 
                buf->f_blocks = bytes_in_dev;
 

-               bytes_free  = ((uint64_t)(yaffs_get_n_free_chunks(dev))) *
-                       ((uint64_t)(dev->data_bytes_per_chunk));
+               bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) *
+                   ((uint64_t) (dev->data_bytes_per_chunk));

 
                do_div(bytes_free, sb->s_blocksize);
 
 
                do_div(bytes_free, sb->s_blocksize);
 


@@ -2191,21 +2162,21 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
        } else if (sb->s_blocksize > dev->data_bytes_per_chunk) {
 
                buf->f_blocks =
        } else if (sb->s_blocksize > dev->data_bytes_per_chunk) {
 
                buf->f_blocks =

-                       (dev->param.end_block - dev->param.start_block + 1) *
-                       dev->param.chunks_per_block /
-                       (sb->s_blocksize / dev->data_bytes_per_chunk);
+                   (dev->param.end_block - dev->param.start_block + 1) *
+                   dev->param.chunks_per_block /
+                   (sb->s_blocksize / dev->data_bytes_per_chunk);

                buf->f_bfree =
                buf->f_bfree =

-                       yaffs_get_n_free_chunks(dev) /
-                       (sb->s_blocksize / dev->data_bytes_per_chunk);
+                   yaffs_get_n_free_chunks(dev) /
+                   (sb->s_blocksize / dev->data_bytes_per_chunk);

        } else {
                buf->f_blocks =
        } else {
                buf->f_blocks =

-                       (dev->param.end_block - dev->param.start_block + 1) *
-                       dev->param.chunks_per_block *
-                       (dev->data_bytes_per_chunk / sb->s_blocksize);
+                   (dev->param.end_block - dev->param.start_block + 1) *
+                   dev->param.chunks_per_block *
+                   (dev->data_bytes_per_chunk / sb->s_blocksize);

 
                buf->f_bfree =
 
                buf->f_bfree =

-                       yaffs_get_n_free_chunks(dev) *
-                       (dev->data_bytes_per_chunk / sb->s_blocksize);
+                   yaffs_get_n_free_chunks(dev) *
+                   (dev->data_bytes_per_chunk / sb->s_blocksize);

        }
 
        buf->f_files = 0;
        }
 
        buf->f_files = 0;


@@ -2216,61 +2187,57 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
        return 0;
 }
 
        return 0;
 }
 

-
-

 static void yaffs_flush_inodes(struct super_block *sb)
 {
        struct inode *iptr;
        struct yaffs_obj *obj;
 static void yaffs_flush_inodes(struct super_block *sb)
 {
        struct inode *iptr;
        struct yaffs_obj *obj;

-       
-       list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){
+
+       list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) {

                obj = yaffs_inode_to_obj(iptr);
                obj = yaffs_inode_to_obj(iptr);

-               if(obj){
+               if (obj) {

                        T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),
                        T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),

-                               obj->obj_id));
-                       yaffs_flush_file(obj,1,0);
+                                          obj->obj_id));
+                       yaffs_flush_file(obj, 1, 0);

                }
        }
 }
 
                }
        }
 }
 

-

 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {
 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {

-       struct yaffs_dev *dev = yaffs_super_to_dev(sb); 
-       if(!dev)
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
+       if (!dev)

                return;
                return;

-       
+

        yaffs_flush_inodes(sb);
        yaffs_update_dirty_dirs(dev);
        yaffs_flush_whole_cache(dev);
        yaffs_flush_inodes(sb);
        yaffs_update_dirty_dirs(dev);
        yaffs_flush_whole_cache(dev);

-       if(do_checkpoint)
+       if (do_checkpoint)

                yaffs_checkpoint_save(dev);
 }
 
                yaffs_checkpoint_save(dev);
 }
 

-

 static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev)
 {
 static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev)
 {

-       unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
+       unsigned erased_chunks =
+           dev->n_erased_blocks * dev->param.chunks_per_block;

        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);

-       unsigned scattered = 0; /* Free chunks not in an erased block */
+       unsigned scattered = 0; /* Free chunks not in an erased block */

 
 

-       if(erased_chunks < dev->n_free_chunks)
+       if (erased_chunks < dev->n_free_chunks)

                scattered = (dev->n_free_chunks - erased_chunks);
 
                scattered = (dev->n_free_chunks - erased_chunks);
 

-       if(!context->bg_running)
+       if (!context->bg_running)

                return 0;
                return 0;

-       else if(scattered < (dev->param.chunks_per_block * 2))
+       else if (scattered < (dev->param.chunks_per_block * 2))

                return 0;
                return 0;

-       else if(erased_chunks > dev->n_free_chunks/2)
+       else if (erased_chunks > dev->n_free_chunks / 2)

                return 0;
                return 0;

-       else if(erased_chunks > dev->n_free_chunks/4)
+       else if (erased_chunks > dev->n_free_chunks / 4)

                return 1;
        else
                return 2;
 }
 
                return 1;
        else
                return 2;
 }
 

-static int yaffs_do_sync_fs(struct super_block *sb,
-                               int request_checkpoint)
+static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint)

 {
 
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 {
 
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);


@@ -2279,21 +2246,20 @@ static int yaffs_do_sync_fs(struct super_block *sb,
        int do_checkpoint;
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
        int do_checkpoint;
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"),
-               gc_urgent,
-               sb->s_dirt ? "dirty" : "clean",
-               request_checkpoint ? "checkpoint requested" : "no checkpoint",
-               oneshot_checkpoint ? " one-shot" : "" ));
+         (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"),
+          gc_urgent,
+          sb->s_dirt ? "dirty" : "clean",
+          request_checkpoint ? "checkpoint requested" : "no checkpoint",
+          oneshot_checkpoint ? " one-shot" : ""));

 
        yaffs_gross_lock(dev);
        do_checkpoint = ((request_checkpoint && !gc_urgent) ||
 
        yaffs_gross_lock(dev);
        do_checkpoint = ((request_checkpoint && !gc_urgent) ||

-                       oneshot_checkpoint) &&
-                       !dev->is_checkpointed;
+                        oneshot_checkpoint) && !dev->is_checkpointed;

 
        if (sb->s_dirt || do_checkpoint) {
                yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint);
                sb->s_dirt = 0;
 
        if (sb->s_dirt || do_checkpoint) {
                yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint);
                sb->s_dirt = 0;

-               if(oneshot_checkpoint)
+               if (oneshot_checkpoint)

                        yaffs_auto_checkpoint &= ~4;
        }
        yaffs_gross_unlock(dev);
                        yaffs_auto_checkpoint &= ~4;
        }
        yaffs_gross_unlock(dev);


@@ -2334,62 +2300,60 @@ static int yaffs_bg_thread_fn(void *data)
        struct timer_list timer;
 
        T(YAFFS_TRACE_BACKGROUND,
        struct timer_list timer;
 
        T(YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs_background starting for dev %p\n"),
-               (void *)dev));
+         (TSTR("yaffs_background starting for dev %p\n"), (void *)dev));

 
 #ifdef YAFFS_COMPILE_FREEZER
        set_freezable();
 #endif
 
 #ifdef YAFFS_COMPILE_FREEZER
        set_freezable();
 #endif

-       while(context->bg_running){
-               T(YAFFS_TRACE_BACKGROUND,
-                       (TSTR("yaffs_background\n")));
+       while (context->bg_running) {
+               T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n")));

 
 

-               if(kthread_should_stop())
+               if (kthread_should_stop())

                        break;
 
 #ifdef YAFFS_COMPILE_FREEZER
                        break;
 
 #ifdef YAFFS_COMPILE_FREEZER

-               if(try_to_freeze())
+               if (try_to_freeze())

                        continue;
 #endif
                yaffs_gross_lock(dev);
 
                now = jiffies;
 
                        continue;
 #endif
                yaffs_gross_lock(dev);
 
                now = jiffies;
 

-               if(time_after(now, next_dir_update) && yaffs_bg_enable){
+               if (time_after(now, next_dir_update) && yaffs_bg_enable) {

                        yaffs_update_dirty_dirs(dev);
                        next_dir_update = now + HZ;
                }
 
                        yaffs_update_dirty_dirs(dev);
                        next_dir_update = now + HZ;
                }
 

-               if(time_after(now,next_gc) && yaffs_bg_enable){
-                       if(!dev->is_checkpointed){
+               if (time_after(now, next_gc) && yaffs_bg_enable) {
+                       if (!dev->is_checkpointed) {

                                urgency = yaffs_bg_gc_urgency(dev);
                                gc_result = yaffs_bg_gc(dev, urgency);
                                urgency = yaffs_bg_gc_urgency(dev);
                                gc_result = yaffs_bg_gc(dev, urgency);

-                               if(urgency > 1)
-                                       next_gc = now + HZ/20+1;
-                               else if(urgency > 0)
-                                       next_gc = now + HZ/10+1;
+                               if (urgency > 1)
+                                       next_gc = now + HZ / 20 + 1;
+                               else if (urgency > 0)
+                                       next_gc = now + HZ / 10 + 1;

                                else
                                        next_gc = now + HZ * 2;
                                else
                                        next_gc = now + HZ * 2;

-                       } else /*
-                               * gc not running so set to next_dir_update
-                               * to cut down on wake ups
-                               */
+                       } else  /*
+                                * gc not running so set to next_dir_update
+                                * to cut down on wake ups
+                                */

                                next_gc = next_dir_update;
                }
                yaffs_gross_unlock(dev);
 #if 1
                expires = next_dir_update;
                                next_gc = next_dir_update;
                }
                yaffs_gross_unlock(dev);
 #if 1
                expires = next_dir_update;

-               if (time_before(next_gc,expires))
+               if (time_before(next_gc, expires))

                        expires = next_gc;
                        expires = next_gc;

-               if(time_before(expires,now))
+               if (time_before(expires, now))

                        expires = now + HZ;
 
                Y_INIT_TIMER(&timer);
                        expires = now + HZ;
 
                Y_INIT_TIMER(&timer);

-               timer.expires = expires+1;
-               timer.data = (unsigned long) current;
+               timer.expires = expires + 1;
+               timer.data = (unsigned long)current;

                timer.function = yaffs_background_waker;
 
                timer.function = yaffs_background_waker;
 

-                set_current_state(TASK_INTERRUPTIBLE);
+               set_current_state(TASK_INTERRUPTIBLE);

                add_timer(&timer);
                schedule();
                del_timer_sync(&timer);
                add_timer(&timer);
                schedule();
                del_timer_sync(&timer);


@@ -2406,15 +2370,16 @@ static int yaffs_bg_start(struct yaffs_dev *dev)
        int retval = 0;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
 
        int retval = 0;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
 

-       if(dev->read_only)
+       if (dev->read_only)

                return -1;
 
        context->bg_running = 1;
 
        context->bg_thread = kthread_run(yaffs_bg_thread_fn,
                return -1;
 
        context->bg_running = 1;
 
        context->bg_thread = kthread_run(yaffs_bg_thread_fn,

-                               (void *)dev,"yaffs-bg-%d",context->mount_id);
+                                        (void *)dev, "yaffs-bg-%d",
+                                        context->mount_id);

 
 

-       if(IS_ERR(context->bg_thread)){
+       if (IS_ERR(context->bg_thread)) {

                retval = PTR_ERR(context->bg_thread);
                context->bg_thread = NULL;
                context->bg_running = 0;
                retval = PTR_ERR(context->bg_thread);
                context->bg_thread = NULL;
                context->bg_running = 0;


@@ -2428,7 +2393,7 @@ static void yaffs_bg_stop(struct yaffs_dev *dev)
 
        ctxt->bg_running = 0;
 
 
        ctxt->bg_running = 0;
 

-       if( ctxt->bg_thread){
+       if (ctxt->bg_thread) {

                kthread_stop(ctxt->bg_thread);
                ctxt->bg_thread = NULL;
        }
                kthread_stop(ctxt->bg_thread);
                ctxt->bg_thread = NULL;
        }


@@ -2449,7 +2414,6 @@ static void yaffs_bg_stop(struct yaffs_dev *dev)
 }
 #endif
 
 }
 #endif
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static void yaffs_write_super(struct super_block *sb)
 #else
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static void yaffs_write_super(struct super_block *sb)
 #else


@@ -2459,8 +2423,8 @@ static int yaffs_write_super(struct super_block *sb)
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs_write_super%s\n"),
-               request_checkpoint ? " checkpt" : ""));
+         (TSTR("yaffs_write_super%s\n"),
+          request_checkpoint ? " checkpt" : ""));

 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 


@@ -2469,7 +2433,6 @@ static int yaffs_write_super(struct super_block *sb)
 #endif
 }
 
 #endif
 }
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_sync_fs(struct super_block *sb, int wait)
 #else
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_sync_fs(struct super_block *sb, int wait)
 #else


@@ -2479,8 +2442,7 @@ static int yaffs_sync_fs(struct super_block *sb)
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,

-               (TSTR("yaffs_sync_fs%s\n"),
-               request_checkpoint ? " checkpt" : ""));
+         (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : ""));

 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 


@@ -2495,8 +2457,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_iget for %lu\n"), ino));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino));

 
        inode = iget_locked(sb, ino);
        if (!inode)
 
        inode = iget_locked(sb, ino);
        if (!inode)


@@ -2534,16 +2495,16 @@ static void yaffs_read_inode(struct inode *inode)
        struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino));
+         (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino));

 
 

-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if (current != yaffs_dev_to_lc(dev)->readdir_process)

                yaffs_gross_lock(dev);
 
        obj = yaffs_find_by_number(dev, inode->i_ino);
 
        yaffs_fill_inode_from_obj(inode, obj);
 
                yaffs_gross_lock(dev);
 
        obj = yaffs_find_by_number(dev, inode->i_ino);
 
        yaffs_fill_inode_from_obj(inode, obj);
 

-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if (current != yaffs_dev_to_lc(dev)->readdir_process)

                yaffs_gross_unlock(dev);
 }
 
                yaffs_gross_unlock(dev);
 }
 


@@ -2559,19 +2520,18 @@ static void yaffs_put_super(struct super_block *sb)
        T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
        T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,

-               (TSTR("Shutting down yaffs background thread\n")));
+         (TSTR("Shutting down yaffs background thread\n")));

        yaffs_bg_stop(dev);
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
        yaffs_bg_stop(dev);
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs background thread shut down\n")));
+         (TSTR("yaffs background thread shut down\n")));

 
        yaffs_gross_lock(dev);
 
 
        yaffs_gross_lock(dev);
 

-       yaffs_flush_super(sb,1);
+       yaffs_flush_super(sb, 1);

 
        if (yaffs_dev_to_lc(dev)->put_super_fn)
                yaffs_dev_to_lc(dev)->put_super_fn(sb);
 
 
        if (yaffs_dev_to_lc(dev)->put_super_fn)
                yaffs_dev_to_lc(dev)->put_super_fn(sb);
 

-

        yaffs_deinitialise(dev);
 
        yaffs_gross_unlock(dev);
        yaffs_deinitialise(dev);
 
        yaffs_gross_unlock(dev);


@@ -2588,7 +2548,6 @@ static void yaffs_put_super(struct super_block *sb)
        kfree(dev);
 }
 
        kfree(dev);
 }
 

-

 static void yaffs_mtd_put_super(struct super_block *sb)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
 static void yaffs_mtd_put_super(struct super_block *sb)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));


@@ -2599,7 +2558,6 @@ static void yaffs_mtd_put_super(struct super_block *sb)
        put_mtd_device(mtd);
 }
 
        put_mtd_device(mtd);
 }
 

-

 static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;


@@ -2620,10 +2578,11 @@ struct yaffs_options {
        int lazy_loading_overridden;
        int empty_lost_and_found;
        int empty_lost_and_found_overridden;
        int lazy_loading_overridden;
        int empty_lost_and_found;
        int empty_lost_and_found_overridden;

-} ;
+};

 
 #define MAX_OPT_LEN 30
 
 #define MAX_OPT_LEN 30

-static int yaffs_parse_options(struct yaffs_options *options, const char *options_str)
+static int yaffs_parse_options(struct yaffs_options *options,
+                              const char *options_str)

 {
        char cur_opt[MAX_OPT_LEN + 1];
        int p;
 {
        char cur_opt[MAX_OPT_LEN + 1];
        int p;


@@ -2635,7 +2594,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
                memset(cur_opt, 0, MAX_OPT_LEN + 1);
                p = 0;
 
                memset(cur_opt, 0, MAX_OPT_LEN + 1);
                p = 0;
 

-               while(*options_str == ',')
+               while (*options_str == ',')

                        options_str++;
 
                while (*options_str && *options_str != ',') {
                        options_str++;
 
                while (*options_str && *options_str != ',') {


@@ -2648,24 +2607,24 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
 
                if (!strcmp(cur_opt, "inband-tags"))
                        options->inband_tags = 1;
 
                if (!strcmp(cur_opt, "inband-tags"))
                        options->inband_tags = 1;

-               else if (!strcmp(cur_opt, "tags-ecc-off")){
+               else if (!strcmp(cur_opt, "tags-ecc-off")) {

                        options->tags_ecc_on = 0;
                        options->tags_ecc_on = 0;

-                       options->tags_ecc_overridden=1;
-               } else if (!strcmp(cur_opt, "tags-ecc-on")){
+                       options->tags_ecc_overridden = 1;
+               } else if (!strcmp(cur_opt, "tags-ecc-on")) {

                        options->tags_ecc_on = 1;
                        options->tags_ecc_overridden = 1;
                        options->tags_ecc_on = 1;
                        options->tags_ecc_overridden = 1;

-               } else if (!strcmp(cur_opt, "lazy-loading-off")){
+               } else if (!strcmp(cur_opt, "lazy-loading-off")) {

                        options->lazy_loading_enabled = 0;
                        options->lazy_loading_enabled = 0;

-                       options->lazy_loading_overridden=1;
-               } else if (!strcmp(cur_opt, "lazy-loading-on")){
+                       options->lazy_loading_overridden = 1;
+               } else if (!strcmp(cur_opt, "lazy-loading-on")) {

                        options->lazy_loading_enabled = 1;
                        options->lazy_loading_overridden = 1;
                        options->lazy_loading_enabled = 1;
                        options->lazy_loading_overridden = 1;

-               } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){
+               } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) {

                        options->empty_lost_and_found = 0;
                        options->empty_lost_and_found = 0;

-                       options->empty_lost_and_found_overridden=1;
-               } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){
+                       options->empty_lost_and_found_overridden = 1;
+               } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) {

                        options->empty_lost_and_found = 1;
                        options->empty_lost_and_found = 1;

-                       options->empty_lost_and_found_overridden=1;
+                       options->empty_lost_and_found_overridden = 1;

                } else if (!strcmp(cur_opt, "no-cache"))
                        options->no_cache = 1;
                else if (!strcmp(cur_opt, "no-checkpoint-read"))
                } else if (!strcmp(cur_opt, "no-cache"))
                        options->no_cache = 1;
                else if (!strcmp(cur_opt, "no-checkpoint-read"))


@@ -2677,7 +2636,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
                        options->skip_checkpoint_write = 1;
                } else {
                        printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",
                        options->skip_checkpoint_write = 1;
                } else {
                        printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",

-                                       cur_opt);
+                              cur_opt);

                        error = 1;
                }
        }
                        error = 1;
                }
        }


@@ -2686,8 +2645,8 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
 }
 
 static struct super_block *yaffs_internal_read_super(int yaffs_version,
 }
 
 static struct super_block *yaffs_internal_read_super(int yaffs_version,

-                                               struct super_block *sb,
-                                               void *data, int silent)
+                                                    struct super_block *sb,
+                                                    void *data, int silent)

 {
        int n_blocks;
        struct inode *inode = NULL;
 {
        int n_blocks;
        struct inode *inode = NULL;


@@ -2713,8 +2672,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        sb->s_op = &yaffs_super_ops;
        sb->s_flags |= MS_NOATIME;
 
        sb->s_op = &yaffs_super_ops;
        sb->s_flags |= MS_NOATIME;
 

-       read_only =((sb->s_flags & MS_RDONLY) != 0);
-
+       read_only = ((sb->s_flags & MS_RDONLY) != 0);

 
 #ifdef YAFFS_COMPILE_EXPORTFS
        sb->s_export_op = &yaffs_export_ops;
 
 #ifdef YAFFS_COMPILE_EXPORTFS
        sb->s_export_op = &yaffs_export_ops;


@@ -2729,8 +2687,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        else
                printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n",
                       sb->s_dev,
        else
                printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n",
                       sb->s_dev,

-                      yaffs_devname(sb, devname_buf),
-                      read_only ? "ro" : "rw");
+                      yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw");

 
        if (!data_str)
                data_str = "";
 
        if (!data_str)
                data_str = "";


@@ -2744,20 +2701,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                return NULL;
        }
 
                return NULL;
        }
 

-

        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
        T(YAFFS_TRACE_OS,
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
+         (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));

        T(YAFFS_TRACE_OS,
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_read_super: block size %d\n"),
-               (int)(sb->s_blocksize)));
+         (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize)));

 
        T(YAFFS_TRACE_ALWAYS,
 
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"),
-              MAJOR(sb->s_dev), MINOR(sb->s_dev),
-              yaffs_devname(sb, devname_buf)));
+         (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"),
+          MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf)));

 
        /* Check it's an mtd device..... */
        if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
 
        /* Check it's an mtd device..... */
        if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)


@@ -2767,15 +2721,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
        if (!mtd) {
                T(YAFFS_TRACE_ALWAYS,
        mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
        if (!mtd) {
                T(YAFFS_TRACE_ALWAYS,

-                       (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"),
-                       MINOR(sb->s_dev)));
+                 (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"),
+                  MINOR(sb->s_dev)));

                return NULL;
        }
        /* Check it's NAND */
        if (mtd->type != MTD_NANDFLASH) {
                T(YAFFS_TRACE_ALWAYS,
                return NULL;
        }
        /* Check it's NAND */
        if (mtd->type != MTD_NANDFLASH) {
                T(YAFFS_TRACE_ALWAYS,

-                       (TSTR("yaffs: MTD device is not NAND it's type %d\n"),
-                       mtd->type));
+                 (TSTR("yaffs: MTD device is not NAND it's type %d\n"),
+                  mtd->type));

                return NULL;
        }
 
                return NULL;
        }
 


@@ -2798,27 +2752,23 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
        if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
        if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {

-               T(YAFFS_TRACE_ALWAYS,
-                       (TSTR("yaffs: auto selecting yaffs2\n")));
+               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n")));

                yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */
                yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */

-       if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
-               T(YAFFS_TRACE_ALWAYS,
-                       (TSTR("yaffs: auto selecting yaffs1\n")));
+       if (yaffs_version == 2 && !options.inband_tags
+           && WRITE_SIZE(mtd) == 512) {
+               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n")));

                yaffs_version = 1;
        }
                yaffs_version = 1;
        }

-

 #endif
 
        if (yaffs_version == 2) {
                /* Check for version 2 style functions */
                if (!mtd->erase ||
                    !mtd->block_isbad ||
 #endif
 
        if (yaffs_version == 2) {
                /* Check for version 2 style functions */
                if (!mtd->erase ||
                    !mtd->block_isbad ||

-                   !mtd->block_markbad ||
-                   !mtd->read ||
-                   !mtd->write ||
+                   !mtd->block_markbad || !mtd->read || !mtd->write ||

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
                    !mtd->read_oob || !mtd->write_oob) {
 #else
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
                    !mtd->read_oob || !mtd->write_oob) {
 #else


@@ -2827,23 +2777,21 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #endif
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "
 #endif
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "

-                          "functions\n")));
+                               "functions\n")));

                        return NULL;
                }
 
                if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
                        return NULL;
                }
 
                if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||

-                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
+                    mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&

                    !options.inband_tags) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not have the "
                    !options.inband_tags) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not have the "

-                          "right page sizes\n")));
+                               "right page sizes\n")));

                        return NULL;
                }
        } else {
                /* Check for V1 style functions */
                        return NULL;
                }
        } else {
                /* Check for V1 style functions */

-               if (!mtd->erase ||
-                   !mtd->read ||
-                   !mtd->write ||
+               if (!mtd->erase || !mtd->read || !mtd->write ||

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
                    !mtd->read_oob || !mtd->write_oob) {
 #else
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
                    !mtd->read_oob || !mtd->write_oob) {
 #else


@@ -2852,7 +2800,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #endif
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "
 #endif
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "

-                          "functions\n")));
+                               "functions\n")));

                        return NULL;
                }
 
                        return NULL;
                }
 


@@ -2860,7 +2808,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support have the "
                    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support have the "

-                          "right page sizes\n")));
+                               "right page sizes\n")));

                        return NULL;
                }
        }
                        return NULL;
                }
        }


@@ -2870,19 +2818,20 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
         * Set the struct yaffs_dev up for mtd
         */
 
         * Set the struct yaffs_dev up for mtd
         */
 

-       if (!read_only && !(mtd->flags & MTD_WRITEABLE)){
+       if (!read_only && !(mtd->flags & MTD_WRITEABLE)) {

                read_only = 1;
                read_only = 1;

-               printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only");
+               printk(KERN_INFO
+                      "yaffs: mtd is read only, setting superblock read only");

                sb->s_flags |= MS_RDONLY;
        }
 
        dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL);
                sb->s_flags |= MS_RDONLY;
        }
 
        dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL);

-       context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL);
-       
-       if(!dev || !context ){
-               if(dev)
+       context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL);
+
+       if (!dev || !context) {
+               if (dev)

                        kfree(dev);
                        kfree(dev);

-               if(context)
+               if (context)

                        kfree(context);
                dev = NULL;
                context = NULL;
                        kfree(context);
                dev = NULL;
                context = NULL;


@@ -2892,13 +2841,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                /* Deep shit could not allocate device structure */
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("yaffs_read_super: Failed trying to allocate "
                /* Deep shit could not allocate device structure */
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("yaffs_read_super: Failed trying to allocate "

-                  "struct yaffs_dev. \n")));
+                       "struct yaffs_dev. \n")));

                return NULL;
        }
        memset(dev, 0, sizeof(struct yaffs_dev));
        param = &(dev->param);
 
                return NULL;
        }
        memset(dev, 0, sizeof(struct yaffs_dev));
        param = &(dev->param);
 

-       memset(context,0,sizeof(struct yaffs_linux_context));
+       memset(context, 0, sizeof(struct yaffs_linux_context));

        dev->os_context = context;
        INIT_LIST_HEAD(&(context->context_list));
        context->dev = dev;
        dev->os_context = context;
        INIT_LIST_HEAD(&(context->context_list));
        context->dev = dev;


@@ -2911,13 +2860,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #else
        sb->u.generic_sbp = dev;
 #endif
 #else
        sb->u.generic_sbp = dev;
 #endif

-       
+

        dev->driver_context = mtd;
        param->name = mtd->name;
 
        /* Set up the memory size parameters.... */
 
        dev->driver_context = mtd;
        param->name = mtd->name;
 
        /* Set up the memory size parameters.... */
 

-       n_blocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK));
+       n_blocks =
+           YCALCBLOCKS(mtd->size,
+                       (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK));

 
        param->start_block = 0;
        param->end_block = n_blocks - 1;
 
        param->start_block = 0;
        param->end_block = n_blocks - 1;


@@ -2933,7 +2884,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #ifdef CONFIG_YAFFS_XATTR
        param->enable_xattr = 1;
 #endif
 #ifdef CONFIG_YAFFS_XATTR
        param->enable_xattr = 1;
 #endif

-       if(options.lazy_loading_overridden)
+       if (options.lazy_loading_overridden)

                param->disable_lazy_load = !options.lazy_loading_enabled;
 
 #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC
                param->disable_lazy_load = !options.lazy_loading_enabled;
 
 #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC


@@ -2945,7 +2896,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        param->defered_dir_update = 1;
 #endif
 
        param->defered_dir_update = 1;
 #endif
 

-       if(options.tags_ecc_overridden)
+       if (options.tags_ecc_overridden)

                param->no_tags_ecc = !options.tags_ecc_on;
 
 #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND
                param->no_tags_ecc = !options.tags_ecc_on;
 
 #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND


@@ -2962,15 +2913,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        param->always_check_erased = 1;
 #endif
 
        param->always_check_erased = 1;
 #endif
 

-       if(options.empty_lost_and_found_overridden)
+       if (options.empty_lost_and_found_overridden)

                param->empty_lost_n_found = options.empty_lost_and_found;
 
        /* ... and the functions. */
        if (yaffs_version == 2) {
                param->empty_lost_n_found = options.empty_lost_and_found;
 
        /* ... and the functions. */
        if (yaffs_version == 2) {

-               param->write_chunk_tags_fn =
-                   nandmtd2_write_chunk_tags;
-               param->read_chunk_tags_fn =
-                   nandmtd2_read_chunk_tags;
+               param->write_chunk_tags_fn = nandmtd2_write_chunk_tags;
+               param->read_chunk_tags_fn = nandmtd2_read_chunk_tags;

                param->bad_block_fn = nandmtd2_mark_block_bad;
                param->query_block_fn = nandmtd2_query_block;
                yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
                param->bad_block_fn = nandmtd2_mark_block_bad;
                param->query_block_fn = nandmtd2_query_block;
                yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);


@@ -2989,10 +2938,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        } else {
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
                /* use the MTD interface in yaffs_mtdif1.c */
        } else {
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
                /* use the MTD interface in yaffs_mtdif1.c */

-               param->write_chunk_tags_fn =
-                       nandmtd1_write_chunk_tags;
-               param->read_chunk_tags_fn =
-                       nandmtd1_read_chunk_tags;
+               param->write_chunk_tags_fn = nandmtd1_write_chunk_tags;
+               param->read_chunk_tags_fn = nandmtd1_read_chunk_tags;

                param->bad_block_fn = nandmtd1_mark_block_bad;
                param->query_block_fn = nandmtd1_query_block;
 #else
                param->bad_block_fn = nandmtd1_mark_block_bad;
                param->query_block_fn = nandmtd1_query_block;
 #else


@@ -3010,8 +2957,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        param->sb_dirty_fn = yaffs_touch_super;
        param->gc_control = yaffs_gc_control_callback;
 
        param->sb_dirty_fn = yaffs_touch_super;
        param->gc_control = yaffs_gc_control_callback;
 

-       yaffs_dev_to_lc(dev)->super= sb;
-       
+       yaffs_dev_to_lc(dev)->super = sb;

 
 #ifndef CONFIG_YAFFS_DOES_ECC
        param->use_nand_ecc = 1;
 
 #ifndef CONFIG_YAFFS_DOES_ECC
        param->use_nand_ecc = 1;


@@ -3027,22 +2973,25 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        down(&yaffs_context_lock);
        /* Get a mount id */
        found = 0;
        down(&yaffs_context_lock);
        /* Get a mount id */
        found = 0;

-       for(mount_id=0; ! found; mount_id++){
+       for (mount_id = 0; !found; mount_id++) {

                found = 1;
                found = 1;

-               list_for_each(l,&yaffs_context_list){
-                       context_iterator = list_entry(l,struct yaffs_linux_context,context_list);
-                       if(context_iterator->mount_id == mount_id)
+               list_for_each(l, &yaffs_context_list) {
+                       context_iterator =
+                           list_entry(l, struct yaffs_linux_context,
+                                      context_list);
+                       if (context_iterator->mount_id == mount_id)

                                found = 0;
                }
        }
        context->mount_id = mount_id;
 
                                found = 0;
                }
        }
        context->mount_id = mount_id;
 

-       list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list);
+       list_add_tail(&(yaffs_dev_to_lc(dev)->context_list),
+                     &yaffs_context_list);

        up(&yaffs_context_lock);
 
        up(&yaffs_context_lock);
 

-        /* Directory search handling...*/
-        INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
-        param->remove_obj_fn = yaffs_remove_obj_callback;
+       /* Directory search handling... */
+       INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
+       param->remove_obj_fn = yaffs_remove_obj_callback;

 
        init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
 
 
        init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
 


@@ -3053,21 +3002,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        T(YAFFS_TRACE_OS,
          (TSTR("yaffs_read_super: guts initialised %s\n"),
           (err == YAFFS_OK) ? "OK" : "FAILED"));
        T(YAFFS_TRACE_OS,
          (TSTR("yaffs_read_super: guts initialised %s\n"),
           (err == YAFFS_OK) ? "OK" : "FAILED"));

-          
-       if(err == YAFFS_OK)
+
+       if (err == YAFFS_OK)

                yaffs_bg_start(dev);
                yaffs_bg_start(dev);

-               
-       if(!context->bg_thread)
-               param->defered_dir_update = 0;

 
 

+       if (!context->bg_thread)
+               param->defered_dir_update = 0;

 
        /* Release lock before yaffs_get_inode() */
        yaffs_gross_unlock(dev);
 
        /* Create root inode */
        if (err == YAFFS_OK)
 
        /* Release lock before yaffs_get_inode() */
        yaffs_gross_unlock(dev);
 
        /* Create root inode */
        if (err == YAFFS_OK)

-               inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,
-                                       yaffs_root(dev));
+               inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev));

 
        if (!inode)
                return NULL;
 
        if (!inode)
                return NULL;


@@ -3088,14 +3035,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        sb->s_root = root;
        sb->s_dirt = !dev->is_checkpointed;
        T(YAFFS_TRACE_ALWAYS,
        sb->s_root = root;
        sb->s_dirt = !dev->is_checkpointed;
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs_read_super: is_checkpointed %d\n"),
-               dev->is_checkpointed));
+         (TSTR("yaffs_read_super: is_checkpointed %d\n"),
+          dev->is_checkpointed));

 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n")));
        return sb;
 }
 
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n")));
        return sb;
 }
 

-

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
                                         int silent)
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
                                         int silent)


@@ -3141,7 +3087,6 @@ static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super,
                      FS_REQUIRES_DEV);
 #endif
 
                      FS_REQUIRES_DEV);
 #endif
 

-

 #ifdef CONFIG_YAFFS_YAFFS2
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 #ifdef CONFIG_YAFFS_YAFFS2
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))


@@ -3153,11 +3098,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs2_read_super(struct file_system_type *fs,
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs2_read_super(struct file_system_type *fs,

-                       int flags, const char *dev_name, void *data,
-                       struct vfsmount *mnt)
+                            int flags, const char *dev_name, void *data,
+                            struct vfsmount *mnt)

 {
        return get_sb_bdev(fs, flags, dev_name, data,
 {
        return get_sb_bdev(fs, flags, dev_name, data,

-                       yaffs2_internal_read_super_mtd, mnt);
+                          yaffs2_internal_read_super_mtd, mnt);

 }
 #else
 static struct super_block *yaffs2_read_super(struct file_system_type *fs,
 }
 #else
 static struct super_block *yaffs2_read_super(struct file_system_type *fs,


@@ -3188,40 +3133,58 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super,
                      FS_REQUIRES_DEV);
 #endif
 
                      FS_REQUIRES_DEV);
 #endif
 

-#endif                         /* CONFIG_YAFFS_YAFFS2 */
+#endif /* CONFIG_YAFFS_YAFFS2 */

 
 static struct proc_dir_entry *my_proc_entry;
 static struct proc_dir_entry *debug_proc_entry;
 
 
 static struct proc_dir_entry *my_proc_entry;
 static struct proc_dir_entry *debug_proc_entry;
 

-static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev * dev)
+static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)

 {
 {

-       buf += sprintf(buf, "start_block.......... %d\n", dev->param.start_block);
+       buf +=
+           sprintf(buf, "start_block.......... %d\n", dev->param.start_block);

        buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block);
        buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block);

-       buf += sprintf(buf, "total_bytes_per_chunk %d\n", dev->param.total_bytes_per_chunk);
-       buf += sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc);
-       buf += sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc);
+       buf +=
+           sprintf(buf, "total_bytes_per_chunk %d\n",
+                   dev->param.total_bytes_per_chunk);
+       buf +=
+           sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc);
+       buf +=
+           sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc);

        buf += sprintf(buf, "is_yaffs2............ %d\n", dev->param.is_yaffs2);
        buf += sprintf(buf, "is_yaffs2............ %d\n", dev->param.is_yaffs2);

-       buf += sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags);
-       buf += sprintf(buf, "empty_lost_n_found... %d\n", dev->param.empty_lost_n_found);
-       buf += sprintf(buf, "disable_lazy_load.... %d\n", dev->param.disable_lazy_load);
-       buf += sprintf(buf, "refresh_period....... %d\n", dev->param.refresh_period);
+       buf +=
+           sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags);
+       buf +=
+           sprintf(buf, "empty_lost_n_found... %d\n",
+                   dev->param.empty_lost_n_found);
+       buf +=
+           sprintf(buf, "disable_lazy_load.... %d\n",
+                   dev->param.disable_lazy_load);
+       buf +=
+           sprintf(buf, "refresh_period....... %d\n",
+                   dev->param.refresh_period);

        buf += sprintf(buf, "n_caches............. %d\n", dev->param.n_caches);
        buf += sprintf(buf, "n_caches............. %d\n", dev->param.n_caches);

-       buf += sprintf(buf, "n_reserved_blocks.... %d\n", dev->param.n_reserved_blocks);
-       buf += sprintf(buf, "always_check_erased.. %d\n", dev->param.always_check_erased);
+       buf +=
+           sprintf(buf, "n_reserved_blocks.... %d\n",
+                   dev->param.n_reserved_blocks);
+       buf +=
+           sprintf(buf, "always_check_erased.. %d\n",
+                   dev->param.always_check_erased);

 
        buf += sprintf(buf, "\n");
 
        return buf;
 }
 
 
        buf += sprintf(buf, "\n");
 
        return buf;
 }
 

-
-static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev)
+static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev)

 {
 {

-       buf += sprintf(buf, "data_bytes_per_chunk. %d\n", dev->data_bytes_per_chunk);
+       buf +=
+           sprintf(buf, "data_bytes_per_chunk. %d\n",
+                   dev->data_bytes_per_chunk);

        buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits);
        buf += sprintf(buf, "chunk_grp_size....... %d\n", dev->chunk_grp_size);
        buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks);
        buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits);
        buf += sprintf(buf, "chunk_grp_size....... %d\n", dev->chunk_grp_size);
        buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks);

-       buf += sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt);
+       buf +=
+           sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt);

        buf += sprintf(buf, "\n");
        buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes);
        buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj);
        buf += sprintf(buf, "\n");
        buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes);
        buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj);


@@ -3232,19 +3195,27 @@ static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev)
        buf += sprintf(buf, "n_erasures........... %u\n", dev->n_erasures);
        buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies);
        buf += sprintf(buf, "all_gcs.............. %u\n", dev->all_gcs);
        buf += sprintf(buf, "n_erasures........... %u\n", dev->n_erasures);
        buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies);
        buf += sprintf(buf, "all_gcs.............. %u\n", dev->all_gcs);

-       buf += sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count);
-       buf += sprintf(buf, "oldest_dirty_gc_count %u\n", dev->oldest_dirty_gc_count);
+       buf +=
+           sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count);
+       buf +=
+           sprintf(buf, "oldest_dirty_gc_count %u\n",
+                   dev->oldest_dirty_gc_count);

        buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks);
        buf += sprintf(buf, "bg_gcs............... %u\n", dev->bg_gcs);
        buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks);
        buf += sprintf(buf, "bg_gcs............... %u\n", dev->bg_gcs);

-       buf += sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes);
-       buf += sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks);
+       buf +=
+           sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes);
+       buf +=
+           sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks);

        buf += sprintf(buf, "n_ecc_fixed.......... %u\n", dev->n_ecc_fixed);
        buf += sprintf(buf, "n_ecc_unfixed........ %u\n", dev->n_ecc_unfixed);
        buf += sprintf(buf, "n_ecc_fixed.......... %u\n", dev->n_ecc_fixed);
        buf += sprintf(buf, "n_ecc_unfixed........ %u\n", dev->n_ecc_unfixed);

-       buf += sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed);
-       buf += sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed);
+       buf +=
+           sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed);
+       buf +=
+           sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed);

        buf += sprintf(buf, "cache_hits........... %u\n", dev->cache_hits);
        buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files);
        buf += sprintf(buf, "cache_hits........... %u\n", dev->cache_hits);
        buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files);

-       buf += sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files);
+       buf +=
+           sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files);

        buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count);
        buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions);
 
        buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count);
        buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions);
 


@@ -3270,29 +3241,36 @@ static int yaffs_proc_read(char *page,
 
        /* Print header first */
        if (step == 0)
 
        /* Print header first */
        if (step == 0)

-               buf += sprintf(buf, "Multi-version YAFFS built:" __DATE__ " " __TIME__"\n");
+               buf +=
+                   sprintf(buf,
+                           "Multi-version YAFFS built:" __DATE__ " " __TIME__
+                           "\n");

        else if (step == 1)
        else if (step == 1)

-               buf += sprintf(buf,"\n");
+               buf += sprintf(buf, "\n");

        else {
        else {

-               step-=2;
-               
+               step -= 2;
+

                down(&yaffs_context_lock);
 
                /* Locate and print the Nth entry.  Order N-squared but N is small. */
                list_for_each(item, &yaffs_context_list) {
                down(&yaffs_context_lock);
 
                /* Locate and print the Nth entry.  Order N-squared but N is small. */
                list_for_each(item, &yaffs_context_list) {

-                       struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list);
+                       struct yaffs_linux_context *dc =
+                           list_entry(item, struct yaffs_linux_context,
+                                      context_list);

                        struct yaffs_dev *dev = dc->dev;
 
                        if (n < (step & ~1)) {
                        struct yaffs_dev *dev = dc->dev;
 
                        if (n < (step & ~1)) {

-                               n+=2;
+                               n += 2;

                                continue;
                        }
                                continue;
                        }

-                       if((step & 1)==0){
-                               buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name);
+                       if ((step & 1) == 0) {
+                               buf +=
+                                   sprintf(buf, "\nDevice %d \"%s\"\n", n,
+                                           dev->param.name);

                                buf = yaffs_dump_dev_part0(buf, dev);
                        } else
                                buf = yaffs_dump_dev_part1(buf, dev);
                                buf = yaffs_dump_dev_part0(buf, dev);
                        } else
                                buf = yaffs_dump_dev_part1(buf, dev);

-                       
+

                        break;
                }
                up(&yaffs_context_lock);
                        break;
                }
                up(&yaffs_context_lock);


@@ -3302,8 +3280,8 @@ static int yaffs_proc_read(char *page,
 }
 
 static int yaffs_stats_proc_read(char *page,
 }
 
 static int yaffs_stats_proc_read(char *page,

-                               char **start,
-                               off_t offset, int count, int *eof, void *data)
+                                char **start,
+                                off_t offset, int count, int *eof, void *data)

 {
        struct list_head *item;
        char *buf = page;
 {
        struct list_head *item;
        char *buf = page;


@@ -3313,21 +3291,22 @@ static int yaffs_stats_proc_read(char *page,
 
        /* Locate and print the Nth entry.  Order N-squared but N is small. */
        list_for_each(item, &yaffs_context_list) {
 
        /* Locate and print the Nth entry.  Order N-squared but N is small. */
        list_for_each(item, &yaffs_context_list) {

-               struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list);
+               struct yaffs_linux_context *dc =
+                   list_entry(item, struct yaffs_linux_context, context_list);

                struct yaffs_dev *dev = dc->dev;
 
                int erased_chunks;
 
                struct yaffs_dev *dev = dc->dev;
 
                int erased_chunks;
 

-               erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
-               
-               buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n",
-                               n, dev->n_free_chunks, erased_chunks,
-                               dev->bg_gcs, dev->oldest_dirty_gc_count,
-                               dev->n_obj, dev->n_tnodes);
+               erased_chunks =
+                   dev->n_erased_blocks * dev->param.chunks_per_block;
+
+               buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n",
+                              n, dev->n_free_chunks, erased_chunks,
+                              dev->bg_gcs, dev->oldest_dirty_gc_count,
+                              dev->n_obj, dev->n_tnodes);

        }
        up(&yaffs_context_lock);
 
        }
        up(&yaffs_context_lock);
 

-

        return buf - page < count ? buf - page : count;
 }
 
        return buf - page < count ? buf - page : count;
 }
 


@@ -3341,41 +3320,39 @@ static struct {
        char *mask_name;
        unsigned mask_bitfield;
 } mask_flags[] = {
        char *mask_name;
        unsigned mask_bitfield;
 } mask_flags[] = {

-       {"allocate", YAFFS_TRACE_ALLOCATE},
-       {"always", YAFFS_TRACE_ALWAYS},
-       {"background", YAFFS_TRACE_BACKGROUND},
-       {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
-       {"buffers", YAFFS_TRACE_BUFFERS},
-       {"bug", YAFFS_TRACE_BUG},
-       {"checkpt", YAFFS_TRACE_CHECKPOINT},
-       {"deletion", YAFFS_TRACE_DELETION},
-       {"erase", YAFFS_TRACE_ERASE},
-       {"error", YAFFS_TRACE_ERROR},
-       {"gc_detail", YAFFS_TRACE_GC_DETAIL},
-       {"gc", YAFFS_TRACE_GC},
-       {"lock", YAFFS_TRACE_LOCK},
-       {"mtd", YAFFS_TRACE_MTD},
-       {"nandaccess", YAFFS_TRACE_NANDACCESS},
-       {"os", YAFFS_TRACE_OS},
-       {"scan_debug", YAFFS_TRACE_SCAN_DEBUG},
-       {"scan", YAFFS_TRACE_SCAN},
-       {"tracing", YAFFS_TRACE_TRACING},
-       {"sync", YAFFS_TRACE_SYNC},
-       {"write", YAFFS_TRACE_WRITE},
-
-       {"verify", YAFFS_TRACE_VERIFY},
-       {"verify_nand", YAFFS_TRACE_VERIFY_NAND},
-       {"verify_full", YAFFS_TRACE_VERIFY_FULL},
-       {"verify_all", YAFFS_TRACE_VERIFY_ALL},
-
-       {"all", 0xffffffff},
-       {"none", 0},
-       {NULL, 0},
-};
+       {
+       "allocate", YAFFS_TRACE_ALLOCATE}, {
+       "always", YAFFS_TRACE_ALWAYS}, {
+       "background", YAFFS_TRACE_BACKGROUND}, {
+       "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, {
+       "buffers", YAFFS_TRACE_BUFFERS}, {
+       "bug", YAFFS_TRACE_BUG}, {
+       "checkpt", YAFFS_TRACE_CHECKPOINT}, {
+       "deletion", YAFFS_TRACE_DELETION}, {
+       "erase", YAFFS_TRACE_ERASE}, {
+       "error", YAFFS_TRACE_ERROR}, {
+       "gc_detail", YAFFS_TRACE_GC_DETAIL}, {
+       "gc", YAFFS_TRACE_GC}, {
+       "lock", YAFFS_TRACE_LOCK}, {
+       "mtd", YAFFS_TRACE_MTD}, {
+       "nandaccess", YAFFS_TRACE_NANDACCESS}, {
+       "os", YAFFS_TRACE_OS}, {
+       "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, {
+       "scan", YAFFS_TRACE_SCAN}, {
+       "tracing", YAFFS_TRACE_TRACING}, {
+       "sync", YAFFS_TRACE_SYNC}, {
+       "write", YAFFS_TRACE_WRITE}, {
+       "verify", YAFFS_TRACE_VERIFY}, {
+       "verify_nand", YAFFS_TRACE_VERIFY_NAND}, {
+       "verify_full", YAFFS_TRACE_VERIFY_FULL}, {
+       "verify_all", YAFFS_TRACE_VERIFY_ALL}, {
+       "all", 0xffffffff}, {
+       "none", 0}, {
+NULL, 0},};

 
 #define MAX_MASK_NAME_LENGTH 40
 static int yaffs_proc_write_trace_options(struct file *file, const char *buf,
 
 #define MAX_MASK_NAME_LENGTH 40
 static int yaffs_proc_write_trace_options(struct file *file, const char *buf,

-                                        unsigned long count, void *data)
+                                         unsigned long count, void *data)

 {
        unsigned rg = 0, mask_bitfield;
        char *end;
 {
        unsigned rg = 0, mask_bitfield;
        char *end;


@@ -3417,15 +3394,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf,
                        done = 0;
                } else {
                        for (x = buf + pos, i = 0;
                        done = 0;
                } else {
                        for (x = buf + pos, i = 0;

-                           (*x == '_' || (*x >= 'a' && *x <= 'z')) &&
-                           i < MAX_MASK_NAME_LENGTH; x++, i++, pos++)
+                            (*x == '_' || (*x >= 'a' && *x <= 'z')) &&
+                            i < MAX_MASK_NAME_LENGTH; x++, i++, pos++)

                                substring[i] = *x;
                        substring[i] = '\0';
 
                        for (i = 0; mask_flags[i].mask_name != NULL; i++) {
                                substring[i] = *x;
                        substring[i] = '\0';
 
                        for (i = 0; mask_flags[i].mask_name != NULL; i++) {

-                               if (strcmp(substring, mask_flags[i].mask_name) == 0) {
+                               if (strcmp(substring, mask_flags[i].mask_name)
+                                   == 0) {

                                        mask_name = mask_flags[i].mask_name;
                                        mask_name = mask_flags[i].mask_name;

-                                       mask_bitfield = mask_flags[i].mask_bitfield;
+                                       mask_bitfield =
+                                           mask_flags[i].mask_bitfield;

                                        done = 0;
                                        break;
                                }
                                        done = 0;
                                        break;
                                }


@@ -3460,18 +3439,18 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf,
                        char flag;
                        flag = ((rg & mask_flags[i].mask_bitfield) ==
                                mask_flags[i].mask_bitfield) ? '+' : '-';
                        char flag;
                        flag = ((rg & mask_flags[i].mask_bitfield) ==
                                mask_flags[i].mask_bitfield) ? '+' : '-';

-                       printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name);
+                       printk(KERN_DEBUG "%c%s\n", flag,
+                              mask_flags[i].mask_name);

                }
        }
 
        return count;
 }
 
                }
        }
 
        return count;
 }
 

-

 static int yaffs_proc_write(struct file *file, const char *buf,
 static int yaffs_proc_write(struct file *file, const char *buf,

-                                        unsigned long count, void *data)
+                           unsigned long count, void *data)

 {
 {

-        return yaffs_proc_write_trace_options(file, buf, count, data);
+       return yaffs_proc_write_trace_options(file, buf, count, data);

 }
 
 /* Stuff to handle installation of file systems */
 }
 
 /* Stuff to handle installation of file systems */


@@ -3496,18 +3475,15 @@ static int __init init_yaffs_fs(void)
 
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
        T(YAFFS_TRACE_ALWAYS,
 
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
        T(YAFFS_TRACE_ALWAYS,

-         (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n")));
+         (TSTR
+          (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n")));

 #endif
 
 #endif
 

-
-
-

        init_MUTEX(&yaffs_context_lock);
 
        /* Install the proc_fs entries */
        my_proc_entry = create_proc_entry("yaffs",
        init_MUTEX(&yaffs_context_lock);
 
        /* Install the proc_fs entries */
        my_proc_entry = create_proc_entry("yaffs",

-                                              S_IRUGO | S_IFREG,
-                                              YPROC_ROOT);
+                                         S_IRUGO | S_IFREG, YPROC_ROOT);

 
        if (my_proc_entry) {
                my_proc_entry->write_proc = yaffs_proc_write;
 
        if (my_proc_entry) {
                my_proc_entry->write_proc = yaffs_proc_write;


@@ -3517,8 +3493,7 @@ static int __init init_yaffs_fs(void)
                return -ENOMEM;
 
        debug_proc_entry = create_proc_entry("yaffs_stats",
                return -ENOMEM;
 
        debug_proc_entry = create_proc_entry("yaffs_stats",

-                                              S_IRUGO | S_IFREG,
-                                              YPROC_ROOT);
+                                            S_IRUGO | S_IFREG, YPROC_ROOT);

 
        if (debug_proc_entry) {
                debug_proc_entry->write_proc = NULL;
 
        if (debug_proc_entry) {
                debug_proc_entry->write_proc = NULL;


@@ -3560,7 +3535,7 @@ static void __exit exit_yaffs_fs(void)
        struct file_system_to_install *fsinst;
 
        T(YAFFS_TRACE_ALWAYS,
        struct file_system_to_install *fsinst;
 
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n")));
+         (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n")));

 
        remove_proc_entry("yaffs", YPROC_ROOT);
        remove_proc_entry("yaffs_stats", YPROC_ROOT);
 
        remove_proc_entry("yaffs", YPROC_ROOT);
        remove_proc_entry("yaffs_stats", YPROC_ROOT);


@@ -3577,8 +3552,8 @@ static void __exit exit_yaffs_fs(void)
 }
 
 module_init(init_yaffs_fs)
 }
 
 module_init(init_yaffs_fs)

-module_exit(exit_yaffs_fs)
+    module_exit(exit_yaffs_fs)

 
 

-MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
+    MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");

 MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010");
 MODULE_LICENSE("GPL");

diff --git a/yaffs_vfs_single.c b/yaffs_vfs_single.c
index aa1c15ed21d42a4f84a534613737c15e130c6679..176dea7521172b26fecc2f2394d7afb57141c419 100644 (file)
--- a/yaffs_vfs_single.c
+++ b/yaffs_vfs_single.c
@@ -57,7 +57,6 @@
 
 #include <asm/div64.h>
 
 
 #include <asm/div64.h>
 

-

 #include <linux/statfs.h>
 
 #define UnlockPage(p) unlock_page(p)
 #include <linux/statfs.h>
 
 #define UnlockPage(p) unlock_page(p)


@@ -72,12 +71,11 @@
 #define WRITE_SIZE_STR "writesize"
 #define WRITE_SIZE(mtd) ((mtd)->writesize)
 
 #define WRITE_SIZE_STR "writesize"
 #define WRITE_SIZE(mtd) ((mtd)->writesize)
 

-

 static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
 {
        uint64_t result = partition_size;
        do_div(result, block_size);
 static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
 {
        uint64_t result = partition_size;
        do_div(result, block_size);

-       return (uint32_t)result;
+       return (uint32_t) result;

 }
 
 #include <linux/uaccess.h>
 }
 
 #include <linux/uaccess.h>


@@ -116,15 +114,14 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
 #define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info)
 
 #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
 #define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info)
 

-

 #define update_dir_time(dir) do {\
                        (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
                } while(0)
 #define update_dir_time(dir) do {\
                        (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
                } while(0)

-               
+

 static void yaffs_put_super(struct super_block *sb);
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 static void yaffs_put_super(struct super_block *sb);
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,

-                               loff_t *pos);
+                               loff_t * pos);

 static ssize_t yaffs_hold_space(struct file *f);
 static void yaffs_release_space(struct file *f);
 
 static ssize_t yaffs_hold_space(struct file *f);
 static void yaffs_release_space(struct file *f);
 


@@ -137,16 +134,16 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n);
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n);
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,

-                                       struct nameidata *n);
+                                  struct nameidata *n);

 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,

-                       struct dentry *dentry);
+                     struct dentry *dentry);

 static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,

-                       const char *symname);
+                        const char *symname);

 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,

-                       dev_t dev);
+                      dev_t dev);

 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry);
 static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry);
 static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);


@@ -167,23 +164,22 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,

-                       const void *value, size_t size, int flags);
+                  const void *value, size_t size, int flags);

 ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
 ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,

-                       size_t size);
+                      size_t size);

 int yaffs_removexattr(struct dentry *dentry, const char *name);
 ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size);
 #endif
 
 int yaffs_removexattr(struct dentry *dentry, const char *name);
 ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size);
 #endif
 

-

 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned flags,
-                               struct page **pagep, void **fsdata);
+                            loff_t pos, unsigned len, unsigned flags,
+                            struct page **pagep, void **fsdata);

 static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 static int yaffs_write_end(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned copied,
-                               struct page *pg, void *fsdadata);
+                          loff_t pos, unsigned len, unsigned copied,
+                          struct page *pg, void *fsdadata);

 
 

-static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
-                               int buflen);
+static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
+                         int buflen);

 void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias);
 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 
 void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias);
 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 


@@ -193,7 +189,6 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin);
 
 static int yaffs_vfs_setattr(struct inode *, struct iattr *);
 
 
 static int yaffs_vfs_setattr(struct inode *, struct iattr *);
 

-

 static struct address_space_operations yaffs_file_address_operations = {
        .readpage = yaffs_readpage,
        .writepage = yaffs_writepage,
 static struct address_space_operations yaffs_file_address_operations = {
        .readpage = yaffs_readpage,
        .writepage = yaffs_writepage,


@@ -201,7 +196,6 @@ static struct address_space_operations yaffs_file_address_operations = {
        .write_end = yaffs_write_end,
 };
 
        .write_end = yaffs_write_end,
 };
 

-

 static const struct file_operations yaffs_file_operations = {
        .read = do_sync_read,
        .write = do_sync_write,
 static const struct file_operations yaffs_file_operations = {
        .read = do_sync_read,
        .write = do_sync_write,


@@ -215,8 +209,6 @@ static const struct file_operations yaffs_file_operations = {
        .llseek = generic_file_llseek,
 };
 
        .llseek = generic_file_llseek,
 };
 

-
-

 static const struct inode_operations yaffs_file_inode_operations = {
        .setattr = yaffs_setattr,
 #ifdef CONFIG_YAFFS_XATTR
 static const struct inode_operations yaffs_file_inode_operations = {
        .setattr = yaffs_setattr,
 #ifdef CONFIG_YAFFS_XATTR


@@ -277,16 +269,15 @@ static const struct super_operations yaffs_super_ops = {
        .write_super = yaffs_write_super,
 };
 
        .write_super = yaffs_write_super,
 };
 

-
-static  int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)
+static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)

 {
 {

-       setattr_copy(inode,attr);
+       setattr_copy(inode, attr);

        return 0;
 }
 
        return 0;
 }
 

-static  int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)
+static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)

 {
 {

-       truncate_setsize(inode,newsize);
+       truncate_setsize(inode, newsize);

        return 0;
 }
 
        return 0;
 }
 


@@ -294,7 +285,7 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 {
        return yaffs_gc_control;
 }
 {
        return yaffs_gc_control;
 }

-                                                                                                                       
+

 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));


@@ -308,25 +299,27 @@ static void yaffs_gross_unlock(struct yaffs_dev *dev)
        up(&(yaffs_dev_to_lc(dev)->gross_lock));
 }
 
        up(&(yaffs_dev_to_lc(dev)->gross_lock));
 }
 

-
-

 /* ExportFS support */
 /* ExportFS support */

-static struct inode *
-yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation)
+static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
+                                         uint32_t generation)

 {
        return Y_IGET(sb, ino);
 }
 
 {
        return Y_IGET(sb, ino);
 }
 

-static struct dentry *
-yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type)
+static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb,
+                                         struct fid *fid, int fh_len,
+                                         int fh_type)

 {
 {

-       return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ;
+       return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
+                                   yaffs2_nfs_get_inode);

 }
 
 }
 

-static struct dentry *
- yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type)
+static struct dentry *yaffs2_fh_to_parent(struct super_block *sb,
+                                         struct fid *fid, int fh_len,
+                                         int fh_type)

 {
 {

-       return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode);
+       return generic_fh_to_parent(sb, fid, fh_len, fh_type,
+                                   yaffs2_nfs_get_inode);

 }
 
 struct dentry *yaffs2_get_parent(struct dentry *dentry)
 }
 
 struct dentry *yaffs2_get_parent(struct dentry *dentry)


@@ -366,12 +359,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry)
  * using the default functions of exportfs.
  */
 
  * using the default functions of exportfs.
  */
 

-static struct export_operations yaffs_export_ops =
-{
+static struct export_operations yaffs_export_ops = {

        .fh_to_dentry = yaffs2_fh_to_dentry,
        .fh_to_parent = yaffs2_fh_to_parent,
        .get_parent = yaffs2_get_parent,
        .fh_to_dentry = yaffs2_fh_to_dentry,
        .fh_to_parent = yaffs2_fh_to_parent,
        .get_parent = yaffs2_get_parent,

-} ;
+};

 
 /*-----------------------------------------------------------------*/
 /* Directory search context allows us to unlock access to yaffs during
 
 /*-----------------------------------------------------------------*/
 /* Directory search context allows us to unlock access to yaffs during


@@ -405,21 +397,22 @@ struct yaffs_search_context {
  *
  * Called at start of readdir.
  */
  *
  * Called at start of readdir.
  */

-static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir)
+static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir)

 {
        struct yaffs_dev *dev = dir->my_dev;
 {
        struct yaffs_dev *dev = dir->my_dev;

-       struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context));
-       if(sc){
+       struct yaffs_search_context *sc =
+           YMALLOC(sizeof(struct yaffs_search_context));
+       if (sc) {

                sc->dir_obj = dir;
                sc->dev = dev;
                sc->dir_obj = dir;
                sc->dev = dev;

-               if( list_empty(&sc->dir_obj->variant.dir_variant.children))
+               if (list_empty(&sc->dir_obj->variant.dir_variant.children))

                        sc->next_return = NULL;
                else
                        sc->next_return = NULL;
                else

-                       sc->next_return = list_entry(
-                                dir->variant.dir_variant.children.next,
-                               struct yaffs_obj,siblings);
+                       sc->next_return =
+                           list_entry(dir->variant.dir_variant.children.next,
+                                      struct yaffs_obj, siblings);

                INIT_LIST_HEAD(&sc->others);
                INIT_LIST_HEAD(&sc->others);

-               list_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts));
+               list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts));

        }
        return sc;
 }
        }
        return sc;
 }


@@ -427,9 +420,9 @@ static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir)
 /*
  * yaffs_search_end() disposes of a search context and cleans up.
  */
 /*
  * yaffs_search_end() disposes of a search context and cleans up.
  */

-static void yaffs_search_end(struct yaffs_search_context * sc)
+static void yaffs_search_end(struct yaffs_search_context *sc)

 {
 {

-       if(sc){
+       if (sc) {

                list_del(&sc->others);
                YFREE(sc);
        }
                list_del(&sc->others);
                YFREE(sc);
        }


@@ -442,20 +435,21 @@ static void yaffs_search_end(struct yaffs_search_context * sc)
  */
 static void yaffs_search_advance(struct yaffs_search_context *sc)
 {
  */
 static void yaffs_search_advance(struct yaffs_search_context *sc)
 {

-        if(!sc)
-                return;
+       if (!sc)
+               return;

 
 

-        if( sc->next_return == NULL ||
-                list_empty(&sc->dir_obj->variant.dir_variant.children))
-                sc->next_return = NULL;
-        else {
-                struct list_head *next = sc->next_return->siblings.next;
+       if (sc->next_return == NULL ||
+           list_empty(&sc->dir_obj->variant.dir_variant.children))
+               sc->next_return = NULL;
+       else {
+               struct list_head *next = sc->next_return->siblings.next;

 
 

-                if( next == &sc->dir_obj->variant.dir_variant.children)
-                        sc->next_return = NULL; /* end of list */
-                else
-                        sc->next_return = list_entry(next,struct yaffs_obj,siblings);
-        }
+               if (next == &sc->dir_obj->variant.dir_variant.children)
+                       sc->next_return = NULL; /* end of list */
+               else
+                       sc->next_return =
+                           list_entry(next, struct yaffs_obj, siblings);
+       }

 }
 
 /*
 }
 
 /*


@@ -466,30 +460,29 @@ static void yaffs_search_advance(struct yaffs_search_context *sc)
 static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 {
 
 static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 {
 

-        struct list_head *i;
-        struct yaffs_search_context *sc;
-        struct list_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);
-
+       struct list_head *i;
+       struct yaffs_search_context *sc;
+       struct list_head *search_contexts =
+           &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);

 
 

-        /* Iterate through the directory search contexts.
-         * If any are currently on the object being removed, then advance
-         * the search context to the next object to prevent a hanging pointer.
-         */
-         list_for_each(i, search_contexts) {
-                if (i) {
-                        sc = list_entry(i, struct yaffs_search_context,others);
-                        if(sc->next_return == obj)
-                                yaffs_search_advance(sc);
-                }
+       /* Iterate through the directory search contexts.
+        * If any are currently on the object being removed, then advance
+        * the search context to the next object to prevent a hanging pointer.
+        */
+       list_for_each(i, search_contexts) {
+               if (i) {
+                       sc = list_entry(i, struct yaffs_search_context, others);
+                       if (sc->next_return == obj)
+                               yaffs_search_advance(sc);
+               }

        }
 
 }
 
        }
 
 }
 

-

 /*-----------------------------------------------------------------*/
 
 /*-----------------------------------------------------------------*/
 

-static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
-                       int buflen)
+static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
+                         int buflen)

 {
        unsigned char *alias;
        int ret;
 {
        unsigned char *alias;
        int ret;


@@ -532,57 +525,56 @@ out:
        return ret;
 }
 
        return ret;
 }
 

-void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) {
+void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias)
+{

        kfree(alias);
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        kfree(alias);
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,

-                               struct yaffs_obj *obj);
+                             struct yaffs_obj *obj);

 
 /*
  * Lookup is used to find objects in the fs
  */
 
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 
 /*
  * Lookup is used to find objects in the fs
  */
 
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,

-                               struct nameidata *n)
+                                  struct nameidata *n)

 {
        struct yaffs_obj *obj;
        struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
 
        struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
 
 {
        struct yaffs_obj *obj;
        struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
 
        struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
 

-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if (current != yaffs_dev_to_lc(dev)->readdir_process)

                yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,
                yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_lookup for %d:%s\n"),
-               yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
+         (TSTR("yaffs_lookup for %d:%s\n"),
+          yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));

 
 

-       obj = yaffs_find_by_name(yaffs_inode_to_obj(dir),
-                                       dentry->d_name.name);
+       obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);

 
        obj = yaffs_get_equivalent_obj(obj);    /* in case it was a hardlink */
 
        /* Can't hold gross lock when calling yaffs_get_inode() */
 
        obj = yaffs_get_equivalent_obj(obj);    /* in case it was a hardlink */
 
        /* Can't hold gross lock when calling yaffs_get_inode() */

-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if (current != yaffs_dev_to_lc(dev)->readdir_process)

                yaffs_gross_unlock(dev);
 
        if (obj) {
                T(YAFFS_TRACE_OS,
                yaffs_gross_unlock(dev);
 
        if (obj) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
+                 (TSTR("yaffs_lookup found %d\n"), obj->obj_id));

 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
 
                if (inode) {
 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
 
                if (inode) {

-                       T(YAFFS_TRACE_OS,
-                               (TSTR("yaffs_loookup dentry \n")));
+                       T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));

                        d_add(dentry, inode);
                        /* return dentry; */
                        return NULL;
                }
 
        } else {
                        d_add(dentry, inode);
                        /* return dentry; */
                        return NULL;
                }
 
        } else {

-               T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n")));
+               T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));

 
        }
 
 
        }
 


@@ -591,7 +583,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
        return NULL;
 }
 
        return NULL;
 }
 

-

 #ifdef YAFFS_HAS_PUT_INODE
 
 /* For now put inode is just for debugging
 #ifdef YAFFS_HAS_PUT_INODE
 
 /* For now put inode is just for debugging


@@ -600,13 +591,12 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 static void yaffs_put_inode(struct inode *inode)
 {
        T(YAFFS_TRACE_OS,
 static void yaffs_put_inode(struct inode *inode)
 {
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
-               atomic_read(&inode->i_count)));
+         (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
+          atomic_read(&inode->i_count)));

 
 }
 #endif
 
 
 }
 #endif
 

-

 static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        /* Clear the association between the inode and
 static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        /* Clear the association between the inode and


@@ -626,7 +616,7 @@ static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
  * yaffs_clear_inode() and yaffs_delete_inode()
  *
  */
  * yaffs_clear_inode() and yaffs_delete_inode()
  *
  */

-static void yaffs_evict_inode( struct inode *inode)
+static void yaffs_evict_inode(struct inode *inode)

 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;


@@ -635,16 +625,16 @@ static void yaffs_evict_inode( struct inode *inode)
        obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-               atomic_read(&inode->i_count),
-               obj ? "object exists" : "null object"));
+         (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
+          atomic_read(&inode->i_count),
+          obj ? "object exists" : "null object"));

 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;
 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;

-       truncate_inode_pages(&inode->i_data,0);
+       truncate_inode_pages(&inode->i_data, 0);

        end_writeback(inode);
 
        end_writeback(inode);
 

-       if(deleteme && obj){
+       if (deleteme && obj) {

                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                yaffs_del_obj(obj);
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                yaffs_del_obj(obj);


@@ -653,14 +643,12 @@ static void yaffs_evict_inode( struct inode *inode)
        if (obj) {
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
        if (obj) {
                dev = obj->my_dev;
                yaffs_gross_lock(dev);

-               yaffs_unstitch_obj(inode,obj);
+               yaffs_unstitch_obj(inode, obj);

                yaffs_gross_unlock(dev);
        }
 
                yaffs_gross_unlock(dev);
        }
 

-

 }
 
 }
 

-

 static int yaffs_file_flush(struct file *file, fl_owner_t id)
 {
        struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);
 static int yaffs_file_flush(struct file *file, fl_owner_t id)
 {
        struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);


@@ -668,8 +656,8 @@ static int yaffs_file_flush(struct file *file, fl_owner_t id)
        struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
-               obj->dirty ? "dirty" : "clean"));
+         (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
+          obj->dirty ? "dirty" : "clean"));

 
        yaffs_gross_lock(dev);
 
 
        yaffs_gross_lock(dev);
 


@@ -691,9 +679,9 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
-               (unsigned)(pg->index << PAGE_CACHE_SHIFT),
-               (unsigned)PAGE_CACHE_SIZE));
+         (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
+          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
+          (unsigned)PAGE_CACHE_SIZE));

 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 


@@ -707,8 +695,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        yaffs_gross_lock(dev);
 
        ret = yaffs_file_rd(obj, pg_buf,
        yaffs_gross_lock(dev);
 
        ret = yaffs_file_rd(obj, pg_buf,

-                               pg->index << PAGE_CACHE_SHIFT,
-                               PAGE_CACHE_SIZE);
+                           pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE);

 
        yaffs_gross_unlock(dev);
 
 
        yaffs_gross_unlock(dev);
 


@@ -742,7 +729,7 @@ static int yaffs_readpage(struct file *f, struct page *pg)
        int ret;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));
        int ret;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));

-       ret=yaffs_readpage_unlock(f, pg);
+       ret = yaffs_readpage_unlock(f, pg);

        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
        return ret;
 }
        T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
        return ret;
 }


@@ -770,20 +757,21 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 
        end_index = i_size >> PAGE_CACHE_SHIFT;
 
 
        end_index = i_size >> PAGE_CACHE_SHIFT;
 

-       if(page->index < end_index)
+       if (page->index < end_index)

                n_bytes = PAGE_CACHE_SIZE;
        else {
                n_bytes = PAGE_CACHE_SIZE;
        else {

-               n_bytes = i_size & (PAGE_CACHE_SIZE -1);
+               n_bytes = i_size & (PAGE_CACHE_SIZE - 1);

 
                if (page->index > end_index || !n_bytes) {
                        T(YAFFS_TRACE_OS,
 
                if (page->index > end_index || !n_bytes) {
                        T(YAFFS_TRACE_OS,

-                               (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"),
-                               (unsigned)(page->index << PAGE_CACHE_SHIFT),
-                               (unsigned)inode->i_size));
+                         (TSTR
+                          ("yaffs_writepage at %08x, inode size = %08x!!!\n"),
+                          (unsigned)(page->index << PAGE_CACHE_SHIFT),
+                          (unsigned)inode->i_size));

                        T(YAFFS_TRACE_OS,
                        T(YAFFS_TRACE_OS,

-                               (TSTR("                -> don't care!!\n")));
+                         (TSTR("                -> don't care!!\n")));

 
 

-                       zero_user_segment(page,0,PAGE_CACHE_SIZE);
+                       zero_user_segment(page, 0, PAGE_CACHE_SIZE);

                        set_page_writeback(page);
                        unlock_page(page);
                        end_page_writeback(page);
                        set_page_writeback(page);
                        unlock_page(page);
                        end_page_writeback(page);


@@ -791,8 +779,8 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
                }
        }
 
                }
        }
 

-       if(n_bytes != PAGE_CACHE_SIZE)
-               zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE);
+       if (n_bytes != PAGE_CACHE_SIZE)
+               zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE);

 
        get_page(page);
 
 
        get_page(page);
 


@@ -803,20 +791,20 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
        yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,
        yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_writepage at %08x, size %08x\n"),
-               (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes));
+         (TSTR("yaffs_writepage at %08x, size %08x\n"),
+          (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes));

        T(YAFFS_TRACE_OS,
        T(YAFFS_TRACE_OS,

-               (TSTR("writepag0: obj = %05x, ino = %05x\n"),
-               (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+         (TSTR("writepag0: obj = %05x, ino = %05x\n"),
+          (int)obj->variant.file_variant.file_size, (int)inode->i_size));

 
        n_written = yaffs_wr_file(obj, buffer,
 
        n_written = yaffs_wr_file(obj, buffer,

-                       page->index << PAGE_CACHE_SHIFT, n_bytes, 0);
+                                 page->index << PAGE_CACHE_SHIFT, n_bytes, 0);

 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,
 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("writepag1: obj = %05x, ino = %05x\n"),
-               (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+         (TSTR("writepag1: obj = %05x, ino = %05x\n"),
+          (int)obj->variant.file_variant.file_size, (int)inode->i_size));

 
        yaffs_gross_unlock(dev);
 
 
        yaffs_gross_unlock(dev);
 


@@ -829,10 +817,9 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
        return (n_written == n_bytes) ? 0 : -ENOSPC;
 }
 
        return (n_written == n_bytes) ? 0 : -ENOSPC;
 }
 

-

 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 static int yaffs_write_begin(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned flags,
-                               struct page **pagep, void **fsdata)
+                            loff_t pos, unsigned len, unsigned flags,
+                            struct page **pagep, void **fsdata)

 {
        struct page *pg = NULL;
        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 {
        struct page *pg = NULL;
        pgoff_t index = pos >> PAGE_CACHE_SHIFT;


@@ -845,12 +832,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 
        *pagep = pg;
        if (!pg) {
 
        *pagep = pg;
        if (!pg) {

-               ret =  -ENOMEM;
+               ret = -ENOMEM;

                goto out;
        }
        T(YAFFS_TRACE_OS,
                goto out;
        }
        T(YAFFS_TRACE_OS,

-               (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
-               (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0));
+         (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
+          (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0));

 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);
 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);


@@ -875,7 +862,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 
 out:
        T(YAFFS_TRACE_OS,
 
 out:
        T(YAFFS_TRACE_OS,

-               (TSTR("end yaffs_write_begin fail returning %d\n"), ret));
+         (TSTR("end yaffs_write_begin fail returning %d\n"), ret));

        if (space_held)
                yaffs_release_space(filp);
        if (pg) {
        if (space_held)
                yaffs_release_space(filp);
        if (pg) {


@@ -885,10 +872,9 @@ out:
        return ret;
 }
 
        return ret;
 }
 

-

 static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 static int yaffs_write_end(struct file *filp, struct address_space *mapping,

-                               loff_t pos, unsigned len, unsigned copied,
-                               struct page *pg, void *fsdadata)
+                          loff_t pos, unsigned len, unsigned copied,
+                          struct page *pg, void *fsdadata)

 {
        int ret = 0;
        void *addr, *kva;
 {
        int ret = 0;
        void *addr, *kva;


@@ -898,15 +884,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
        addr = kva + offset_into_page;
 
        T(YAFFS_TRACE_OS,
        addr = kva + offset_into_page;
 
        T(YAFFS_TRACE_OS,

-               ("yaffs_write_end addr %p pos %x n_bytes %d\n",
-               addr,(unsigned)pos, copied));
+         ("yaffs_write_end addr %p pos %x n_bytes %d\n",
+          addr, (unsigned)pos, copied));

 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
                T(YAFFS_TRACE_OS,
 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
-                       ret, copied));
+                 (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
+                  ret, copied));

                SetPageError(pg);
        } else {
                /* Nothing */
                SetPageError(pg);
        } else {
                /* Nothing */


@@ -920,12 +906,11 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
        return ret;
 }
 
        return ret;
 }
 

-
-static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj)
+static void yaffs_fill_inode_from_obj(struct inode *inode,
+                                     struct yaffs_obj *obj)

 {
        if (inode && obj) {
 
 {
        if (inode && obj) {
 

-

                /* Check mode against the variant type and attempt to repair if broken. */
                u32 mode = obj->yst_mode;
                switch (obj->variant_type) {
                /* Check mode against the variant type and attempt to repair if broken. */
                u32 mode = obj->yst_mode;
                switch (obj->variant_type) {


@@ -979,20 +964,21 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
                T(YAFFS_TRACE_OS,
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
-                       inode->i_mode, inode->i_uid, inode->i_gid,
-                       (int)inode->i_size, atomic_read(&inode->i_count)));
+                 (TSTR
+                  ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"),
+                  inode->i_mode, inode->i_uid, inode->i_gid,
+                  (int)inode->i_size, atomic_read(&inode->i_count)));

 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
                        init_special_inode(inode, obj->yst_mode,
 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
                        init_special_inode(inode, obj->yst_mode,

-                                       old_decode_dev(obj->yst_rdev));
+                                          old_decode_dev(obj->yst_rdev));

                        break;
                case S_IFREG:   /* file */
                        inode->i_op = &yaffs_file_inode_operations;
                        inode->i_fop = &yaffs_file_operations;
                        inode->i_mapping->a_ops =
                        break;
                case S_IFREG:   /* file */
                        inode->i_op = &yaffs_file_inode_operations;
                        inode->i_fop = &yaffs_file_operations;
                        inode->i_mapping->a_ops =

-                               &yaffs_file_address_operations;
+                           &yaffs_file_address_operations;

                        break;
                case S_IFDIR:   /* directory */
                        inode->i_op = &yaffs_dir_inode_operations;
                        break;
                case S_IFDIR:   /* directory */
                        inode->i_op = &yaffs_dir_inode_operations;


@@ -1009,32 +995,32 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj
 
        } else {
                T(YAFFS_TRACE_OS,
 
        } else {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_fill_inode invalid parameters\n")));
+                 (TSTR("yaffs_fill_inode invalid parameters\n")));

        }
 
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        }
 
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,

-                               struct yaffs_obj *obj)
+                             struct yaffs_obj *obj)

 {
        struct inode *inode;
 
        if (!sb) {
                T(YAFFS_TRACE_OS,
 {
        struct inode *inode;
 
        if (!sb) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_get_inode for NULL super_block!!\n")));
+                 (TSTR("yaffs_get_inode for NULL super_block!!\n")));

                return NULL;
 
        }
 
        if (!obj) {
                T(YAFFS_TRACE_OS,
                return NULL;
 
        }
 
        if (!obj) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_get_inode for NULL object!!\n")));
+                 (TSTR("yaffs_get_inode for NULL object!!\n")));

                return NULL;
 
        }
 
        T(YAFFS_TRACE_OS,
                return NULL;
 
        }
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
+         (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));

 
        inode = Y_IGET(sb, obj->obj_id);
        if (IS_ERR(inode))
 
        inode = Y_IGET(sb, obj->obj_id);
        if (IS_ERR(inode))


@@ -1048,7 +1034,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 }
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 }
 
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,

-                               loff_t *pos)
+                               loff_t * pos)

 {
        struct yaffs_obj *obj;
        int n_written, ipos;
 {
        struct yaffs_obj *obj;
        int n_written, ipos;


@@ -1070,20 +1056,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 
        if (!obj)
                T(YAFFS_TRACE_OS,
 
        if (!obj)
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_file_write: hey obj is null!\n")));
+                 (TSTR("yaffs_file_write: hey obj is null!\n")));

        else
                T(YAFFS_TRACE_OS,
        else
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_file_write about to write writing %u(%x) bytes"
+                 (TSTR("yaffs_file_write about to write writing %u(%x) bytes"

                        "to object %d at %d(%x)\n"),
                        "to object %d at %d(%x)\n"),

-                       (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos));
+                  (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos));

 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,
 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);
 
        yaffs_touch_super(dev);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_file_write: %d(%x) bytes written\n"),
-               (unsigned )n,(unsigned)n));
+         (TSTR("yaffs_file_write: %d(%x) bytes written\n"),
+          (unsigned)n, (unsigned)n));

 
        if (n_written > 0) {
                ipos += n_written;
 
        if (n_written > 0) {
                ipos += n_written;


@@ -1093,9 +1079,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                        inode->i_blocks = (ipos + 511) >> 9;
 
                        T(YAFFS_TRACE_OS,
                        inode->i_blocks = (ipos + 511) >> 9;
 
                        T(YAFFS_TRACE_OS,

-                               (TSTR("yaffs_file_write size updated to %d bytes, "
-                               "%d blocks\n"),
-                               ipos, (int)(inode->i_blocks)));
+                         (TSTR("yaffs_file_write size updated to %d bytes, "
+                               "%d blocks\n"), ipos, (int)(inode->i_blocks)));

                }
 
        }
                }
 
        }


@@ -1114,7 +1099,6 @@ static ssize_t yaffs_hold_space(struct file *f)
 
        int n_free_chunks;
 
 
        int n_free_chunks;
 

-

        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;


@@ -1133,25 +1117,22 @@ static void yaffs_release_space(struct file *f)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 

-

        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;
 
        yaffs_gross_lock(dev);
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
        dev = obj->my_dev;
 
        yaffs_gross_lock(dev);
 

-

        yaffs_gross_unlock(dev);
 }
 
        yaffs_gross_unlock(dev);
 }
 

-

 static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
 {
        long long retval;
 
        lock_kernel();
 
 static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
 {
        long long retval;
 
        lock_kernel();
 

-       switch (origin){
+       switch (origin) {

        case 2:
                offset += i_size_read(file->f_path.dentry->d_inode);
                break;
        case 2:
                offset += i_size_read(file->f_path.dentry->d_inode);
                break;


@@ -1160,7 +1141,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
        }
        retval = -EINVAL;
 
        }
        retval = -EINVAL;
 

-       if (offset >= 0){
+       if (offset >= 0) {

                if (offset != file->f_pos)
                        file->f_pos = offset;
 
                if (offset != file->f_pos)
                        file->f_pos = offset;
 


@@ -1170,16 +1151,15 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
        return retval;
 }
 
        return retval;
 }
 

-

 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;

-        struct yaffs_search_context *sc;
+       struct yaffs_search_context *sc;

        struct inode *inode = f->f_dentry->d_inode;
        unsigned long offset, curoffs;
        struct yaffs_obj *l;
        struct inode *inode = f->f_dentry->d_inode;
        unsigned long offset, curoffs;
        struct yaffs_obj *l;

-        int ret_val = 0;
+       int ret_val = 0;

 
        char name[YAFFS_MAX_NAME_LENGTH + 1];
 
 
        char name[YAFFS_MAX_NAME_LENGTH + 1];
 


@@ -1192,20 +1172,21 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 
        offset = f->f_pos;
 
 
        offset = f->f_pos;
 

-        sc = yaffs_new_search(obj);
-        if(!sc){
-                ret_val = -ENOMEM;
-                goto out;
-        }
+       sc = yaffs_new_search(obj);
+       if (!sc) {
+               ret_val = -ENOMEM;
+               goto out;
+       }

 
 

-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));
+       T(YAFFS_TRACE_OS,
+         (TSTR("yaffs_readdir: starting at %d\n"), (int)offset));

 
        if (offset == 0) {
                T(YAFFS_TRACE_OS,
 
        if (offset == 0) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_readdir: entry . ino %d \n"),
-                       (int)inode->i_ino));
+                 (TSTR("yaffs_readdir: entry . ino %d \n"),
+                  (int)inode->i_ino));

                yaffs_gross_unlock(dev);
                yaffs_gross_unlock(dev);

-               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){
+               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) {

                        yaffs_gross_lock(dev);
                        goto out;
                }
                        yaffs_gross_lock(dev);
                        goto out;
                }


@@ -1215,11 +1196,12 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
        }
        if (offset == 1) {
                T(YAFFS_TRACE_OS,
        }
        if (offset == 1) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_readdir: entry .. ino %d \n"),
-                       (int)f->f_dentry->d_parent->d_inode->i_ino));
+                 (TSTR("yaffs_readdir: entry .. ino %d \n"),
+                  (int)f->f_dentry->d_parent->d_inode->i_ino));

                yaffs_gross_unlock(dev);
                if (filldir(dirent, "..", 2, offset,
                yaffs_gross_unlock(dev);
                if (filldir(dirent, "..", 2, offset,

-                       f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){
+                           f->f_dentry->d_parent->d_inode->i_ino,
+                           DT_DIR) < 0) {

                        yaffs_gross_lock(dev);
                        goto out;
                }
                        yaffs_gross_lock(dev);
                        goto out;
                }


@@ -1238,37 +1220,34 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
                f->f_version = inode->i_version;
        }
 
                f->f_version = inode->i_version;
        }
 

-       while(sc->next_return){
+       while (sc->next_return) {

                curoffs++;
                curoffs++;

-                l = sc->next_return;
+               l = sc->next_return;

                if (curoffs >= offset) {
                if (curoffs >= offset) {

-                        int this_inode = yaffs_get_obj_inode(l);
-                        int this_type = yaffs_get_obj_type(l);
+                       int this_inode = yaffs_get_obj_inode(l);
+                       int this_type = yaffs_get_obj_type(l);

 
 

-                       yaffs_get_obj_name(l, name,
-                                           YAFFS_MAX_NAME_LENGTH + 1);
+                       yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);

                        T(YAFFS_TRACE_OS,
                          (TSTR("yaffs_readdir: %s inode %d\n"),
                        T(YAFFS_TRACE_OS,
                          (TSTR("yaffs_readdir: %s inode %d\n"),

-                         name, yaffs_get_obj_inode(l)));
+                          name, yaffs_get_obj_inode(l)));

 
 

-                        yaffs_gross_unlock(dev);
+                       yaffs_gross_unlock(dev);

 
                        if (filldir(dirent,
 
                        if (filldir(dirent,

-                                       name,
-                                       strlen(name),
-                                       offset,
-                                       this_inode,
-                                       this_type) < 0){
+                                   name,
+                                   strlen(name),
+                                   offset, this_inode, this_type) < 0) {

                                yaffs_gross_lock(dev);
                                goto out;
                        }
 
                                yaffs_gross_lock(dev);
                                goto out;
                        }
 

-                        yaffs_gross_lock(dev);
+                       yaffs_gross_lock(dev);

 
                        offset++;
                        f->f_pos++;
                }
 
                        offset++;
                        f->f_pos++;
                }

-                yaffs_search_advance(sc);
+               yaffs_search_advance(sc);

        }
 
 out:
        }
 
 out:


@@ -1279,8 +1258,6 @@ out:
        return ret_val;
 }
 
        return ret_val;
 }
 

-
-

 /*
  * File creation. Allocate an inode, and we're done..
  */
 /*
  * File creation. Allocate an inode, and we're done..
  */


@@ -1288,7 +1265,7 @@ out:
 #define YCRED(x) (x->cred)
 
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 #define YCRED(x) (x->cred)
 
 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,

-                       dev_t rdev)
+                      dev_t rdev)

 {
        struct inode *inode;
 
 {
        struct inode *inode;
 


@@ -1299,24 +1276,25 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
        int error = -ENOSPC;
        uid_t uid = YCRED(current)->fsuid;
 
        int error = -ENOSPC;
        uid_t uid = YCRED(current)->fsuid;

-       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
+       gid_t gid =
+           (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;

 
        if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
                mode |= S_ISGID;
 
        if (parent) {
                T(YAFFS_TRACE_OS,
 
        if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
                mode |= S_ISGID;
 
        if (parent) {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_mknod: parent object %d type %d\n"),
-                       parent->obj_id, parent->variant_type));
+                 (TSTR("yaffs_mknod: parent object %d type %d\n"),
+                  parent->obj_id, parent->variant_type));

        } else {
                T(YAFFS_TRACE_OS,
        } else {
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_mknod: could not get parent object\n")));
+                 (TSTR("yaffs_mknod: could not get parent object\n")));

                return -EPERM;
        }
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "
                return -EPERM;
        }
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, "

-                       "mode %x dev %x\n"),
-                       dentry->d_name.name, mode, rdev));
+                               "mode %x dev %x\n"),
+                          dentry->d_name.name, mode, rdev));

 
        dev = parent->my_dev;
 
 
        dev = parent->my_dev;
 


@@ -1326,19 +1304,19 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
        default:
                /* Special (socket, fifo, device...) */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));
        default:
                /* Special (socket, fifo, device...) */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n")));

-               obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid,
-                               gid, old_encode_dev(rdev));
+               obj =
+                   yaffs_create_special(parent, dentry->d_name.name, mode, uid,
+                                        gid, old_encode_dev(rdev));

                break;
        case S_IFREG:           /* file          */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
                obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,
                break;
        case S_IFREG:           /* file          */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n")));
                obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid,

-                               gid);
+                                       gid);

                break;
        case S_IFDIR:           /* directory */
                break;
        case S_IFDIR:           /* directory */

-               T(YAFFS_TRACE_OS,
-                       (TSTR("yaffs_mknod: making directory\n")));
+               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n")));

                obj = yaffs_create_dir(parent, dentry->d_name.name, mode,
                obj = yaffs_create_dir(parent, dentry->d_name.name, mode,

-                                       uid, gid);
+                                      uid, gid);

                break;
        case S_IFLNK:           /* symlink */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));
                break;
        case S_IFLNK:           /* symlink */
                T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n")));


@@ -1354,13 +1332,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
                d_instantiate(dentry, inode);
                update_dir_time(dir);
                T(YAFFS_TRACE_OS,
                d_instantiate(dentry, inode);
                update_dir_time(dir);
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_mknod created object %d count = %d\n"),
-                       obj->obj_id, atomic_read(&inode->i_count)));
+                 (TSTR("yaffs_mknod created object %d count = %d\n"),
+                  obj->obj_id, atomic_read(&inode->i_count)));

                error = 0;
                error = 0;

-               yaffs_fill_inode_from_obj(dir,parent);
+               yaffs_fill_inode_from_obj(dir, parent);

        } else {
        } else {

-               T(YAFFS_TRACE_OS,
-                       (TSTR("yaffs_mknod failed making object\n")));
+               T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n")));

                error = -ENOMEM;
        }
 
                error = -ENOMEM;
        }
 


@@ -1378,7 +1355,7 @@ static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n)
 {
 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
                        struct nameidata *n)
 {

-       T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n")));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n")));

        return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 
        return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
 


@@ -1390,9 +1367,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
        struct yaffs_obj *obj;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_unlink %d:%s\n"),
-               (int)(dir->i_ino),
-               dentry->d_name.name));
+         (TSTR("yaffs_unlink %d:%s\n"),
+          (int)(dir->i_ino), dentry->d_name.name));

        obj = yaffs_inode_to_obj(dir);
        dev = obj->my_dev;
 
        obj = yaffs_inode_to_obj(dir);
        dev = obj->my_dev;
 


@@ -1416,7 +1392,7 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
  * Create a link...
  */
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
  * Create a link...
  */
 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,

-                       struct dentry *dentry)
+                     struct dentry *dentry)

 {
        struct inode *inode = old_dentry->d_inode;
        struct yaffs_obj *obj = NULL;
 {
        struct inode *inode = old_dentry->d_inode;
        struct yaffs_obj *obj = NULL;


@@ -1430,23 +1406,24 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 
        yaffs_gross_lock(dev);
 
 
        yaffs_gross_lock(dev);
 

-       if (!S_ISDIR(inode->i_mode))            /* Don't link directories */
-               link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
-                       obj);
+       if (!S_ISDIR(inode->i_mode))    /* Don't link directories */
+               link =
+                   yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name,
+                                  obj);

 
        if (link) {
                old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
                d_instantiate(dentry, old_dentry->d_inode);
                atomic_inc(&old_dentry->d_inode->i_count);
                T(YAFFS_TRACE_OS,
 
        if (link) {
                old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj);
                d_instantiate(dentry, old_dentry->d_inode);
                atomic_inc(&old_dentry->d_inode->i_count);
                T(YAFFS_TRACE_OS,

-                       (TSTR("yaffs_link link count %d i_count %d\n"),
-                       old_dentry->d_inode->i_nlink,
-                       atomic_read(&old_dentry->d_inode->i_count)));
+                 (TSTR("yaffs_link link count %d i_count %d\n"),
+                  old_dentry->d_inode->i_nlink,
+                  atomic_read(&old_dentry->d_inode->i_count)));

        }
 
        yaffs_gross_unlock(dev);
 
        }
 
        yaffs_gross_unlock(dev);
 

-       if (link){
+       if (link) {

                update_dir_time(dir);
                return 0;
        }
                update_dir_time(dir);
                return 0;
        }


@@ -1455,19 +1432,20 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 }
 
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 }
 
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,

-                               const char *symname)
+                        const char *symname)

 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
        uid_t uid = YCRED(current)->fsuid;
 {
        struct yaffs_obj *obj;
        struct yaffs_dev *dev;
        uid_t uid = YCRED(current)->fsuid;

-       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
+       gid_t gid =
+           (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;

 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
 
        dev = yaffs_inode_to_obj(dir)->my_dev;
        yaffs_gross_lock(dev);
        obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n")));
 
        dev = yaffs_inode_to_obj(dir)->my_dev;
        yaffs_gross_lock(dev);
        obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name,

-                               S_IFLNK | S_IRWXUGO, uid, gid, symname);
+                                  S_IFLNK | S_IRWXUGO, uid, gid, symname);

        yaffs_gross_unlock(dev);
 
        if (obj) {
        yaffs_gross_unlock(dev);
 
        if (obj) {


@@ -1496,8 +1474,7 @@ static int yaffs_sync_object(struct file *file, int datasync)
 
        dev = obj->my_dev;
 
 
        dev = obj->my_dev;
 

-       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
-               (TSTR("yaffs_sync_object\n")));
+       T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n")));

        yaffs_gross_lock(dev);
        yaffs_flush_file(obj, 1, datasync);
        yaffs_gross_unlock(dev);
        yaffs_gross_lock(dev);
        yaffs_flush_file(obj, 1, datasync);
        yaffs_gross_unlock(dev);


@@ -1523,12 +1500,10 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
        /* Check if the target is an existing directory that is not empty. */
        target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),
 
        /* Check if the target is an existing directory that is not empty. */
        target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir),

-                               new_dentry->d_name.name);
-
-
+                                   new_dentry->d_name.name);

 
        if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
 
        if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&

-               !list_empty(&target->variant.dir_variant.children)) {
+           !list_empty(&target->variant.dir_variant.children)) {

 
                T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
 
 
                T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n")));
 


@@ -1538,9 +1513,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
 
                ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),
                T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n")));
 
                ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir),

-                               old_dentry->d_name.name,
-                               yaffs_inode_to_obj(new_dir),
-                               new_dentry->d_name.name);
+                                          old_dentry->d_name.name,
+                                          yaffs_inode_to_obj(new_dir),
+                                          new_dentry->d_name.name);

        }
        yaffs_gross_unlock(dev);
 
        }
        yaffs_gross_unlock(dev);
 


@@ -1549,9 +1524,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        new_dentry->d_inode->i_nlink--;
                        mark_inode_dirty(new_dentry->d_inode);
                }
                        new_dentry->d_inode->i_nlink--;
                        mark_inode_dirty(new_dentry->d_inode);
                }

-               
+

                update_dir_time(old_dir);
                update_dir_time(old_dir);

-               if(old_dir != new_dir)
+               if (old_dir != new_dir)

                        update_dir_time(new_dir);
                return 0;
        } else {
                        update_dir_time(new_dir);
                return 0;
        } else {


@@ -1566,34 +1541,34 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
        struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_setattr of object %d\n"),
-               yaffs_inode_to_obj(inode)->obj_id));
+         (TSTR("yaffs_setattr of object %d\n"),
+          yaffs_inode_to_obj(inode)->obj_id));

 
 

-       /* Fail if a requested resize >= 2GB */         
-       if (attr->ia_valid & ATTR_SIZE &&
-               (attr->ia_size >> 31))
+       /* Fail if a requested resize >= 2GB */
+       if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31))

                error = -EINVAL;
 
        if (error == 0)
                error = inode_change_ok(inode, attr);
        if (error == 0) {
                int result;
                error = -EINVAL;
 
        if (error == 0)
                error = inode_change_ok(inode, attr);
        if (error == 0) {
                int result;

-               if (!error){
+               if (!error) {

                        error = yaffs_vfs_setattr(inode, attr);
                        error = yaffs_vfs_setattr(inode, attr);

-                       T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n")));
-                       if (attr->ia_valid & ATTR_SIZE){
-                               yaffs_vfs_setsize(inode,attr->ia_size);
-                               inode->i_blocks = (inode->i_size + 511) >> 9;
+                       T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n")));
+                       if (attr->ia_valid & ATTR_SIZE) {
+                               yaffs_vfs_setsize(inode, attr->ia_size);
+                               inode->i_blocks = (inode->i_size + 511) >> 9;

                        }
                }
                dev = yaffs_inode_to_obj(inode)->my_dev;
                        }
                }
                dev = yaffs_inode_to_obj(inode)->my_dev;

-               if (attr->ia_valid & ATTR_SIZE){
-                       T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"),
-                               (int)(attr->ia_size),(int)(attr->ia_size)));
+               if (attr->ia_valid & ATTR_SIZE) {
+                       T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"),
+                                          (int)(attr->ia_size),
+                                          (int)(attr->ia_size)));

                }
                yaffs_gross_lock(dev);
                result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
                }
                yaffs_gross_lock(dev);
                result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);

-               if(result == YAFFS_OK) {
+               if (result == YAFFS_OK) {

                        error = 0;
                } else {
                        error = -EPERM;
                        error = 0;
                } else {
                        error = -EPERM;


@@ -1602,47 +1577,41 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 
        }
 
 
        }
 

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_setattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error));

 
        return error;
 }
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,
 
        return error;
 }
 
 #ifdef CONFIG_YAFFS_XATTR
 int yaffs_setxattr(struct dentry *dentry, const char *name,

-                       const void *value, size_t size, int flags)
+                  const void *value, size_t size, int flags)

 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
        struct yaffs_dev *dev;
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_setxattr of object %d\n"),
-               obj->obj_id));
-
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id));

 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_set_xattrib(obj, name, value, size, flags);
 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_set_xattrib(obj, name, value, size, flags);

-               if(result == YAFFS_OK)
+               if (result == YAFFS_OK)

                        error = 0;
                        error = 0;

-               else if(result < 0)
+               else if (result < 0)

                        error = result;
                yaffs_gross_unlock(dev);
 
        }
                        error = result;
                yaffs_gross_unlock(dev);
 
        }

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_setxattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error));

 
        return error;
 }
 
 
        return error;
 }
 

-
-ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
-                       size_t size)
+ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff,
+                      size_t size)

 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;


@@ -1650,8 +1619,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_getxattr \"%s\" from object %d\n"),
-               name, obj->obj_id));
+         (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id));

 
        if (error == 0) {
                dev = obj->my_dev;
 
        if (error == 0) {
                dev = obj->my_dev;


@@ -1660,8 +1628,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
                yaffs_gross_unlock(dev);
 
        }
                yaffs_gross_unlock(dev);
 
        }

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_getxattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error));

 
        return error;
 }
 
        return error;
 }


@@ -1674,29 +1641,27 @@ int yaffs_removexattr(struct dentry *dentry, const char *name)
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_removexattr of object %d\n"),
-               obj->obj_id));
-
+         (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id));

 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_remove_xattrib(obj, name);
 
        if (error == 0) {
                int result;
                dev = obj->my_dev;
                yaffs_gross_lock(dev);
                result = yaffs_remove_xattrib(obj, name);

-               if(result == YAFFS_OK)
+               if (result == YAFFS_OK)

                        error = 0;
                        error = 0;

-               else if(result < 0)
+               else if (result < 0)

                        error = result;
                yaffs_gross_unlock(dev);
 
        }
        T(YAFFS_TRACE_OS,
                        error = result;
                yaffs_gross_unlock(dev);
 
        }
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_removexattr done returning %d\n"),error));
+         (TSTR("yaffs_removexattr done returning %d\n"), error));

 
        return error;
 }
 
 
        return error;
 }
 

-ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
+ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)

 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;


@@ -1704,9 +1669,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_listxattr of object %d\n"),
-               obj->obj_id));
-
+         (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id));

 
        if (error == 0) {
                dev = obj->my_dev;
 
        if (error == 0) {
                dev = obj->my_dev;


@@ -1715,15 +1678,13 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
                yaffs_gross_unlock(dev);
 
        }
                yaffs_gross_unlock(dev);
 
        }

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_listxattr done returning %d\n"),error));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error));

 
        return error;
 }
 
 #endif
 
 
        return error;
 }
 
 #endif
 

-

 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;


@@ -1743,14 +1704,17 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
                uint64_t bytes_in_dev;
                uint64_t bytes_free;
 
                uint64_t bytes_in_dev;
                uint64_t bytes_free;
 

-               bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) *
-                       ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk));
+               bytes_in_dev =
+                   ((uint64_t)
+                    ((dev->param.end_block - dev->param.start_block +
+                      1))) * ((uint64_t) (dev->param.chunks_per_block *
+                                          dev->data_bytes_per_chunk));

 
 

-               do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */
+               do_div(bytes_in_dev, sb->s_blocksize);  /* bytes_in_dev becomes the number of blocks */

                buf->f_blocks = bytes_in_dev;
 
                buf->f_blocks = bytes_in_dev;
 

-               bytes_free  = ((uint64_t)(yaffs_get_n_free_chunks(dev))) *
-                       ((uint64_t)(dev->data_bytes_per_chunk));
+               bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) *
+                   ((uint64_t) (dev->data_bytes_per_chunk));

 
                do_div(bytes_free, sb->s_blocksize);
 
 
                do_div(bytes_free, sb->s_blocksize);
 


@@ -1759,21 +1723,21 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
        } else if (sb->s_blocksize > dev->data_bytes_per_chunk) {
 
                buf->f_blocks =
        } else if (sb->s_blocksize > dev->data_bytes_per_chunk) {
 
                buf->f_blocks =

-                       (dev->param.end_block - dev->param.start_block + 1) *
-                       dev->param.chunks_per_block /
-                       (sb->s_blocksize / dev->data_bytes_per_chunk);
+                   (dev->param.end_block - dev->param.start_block + 1) *
+                   dev->param.chunks_per_block /
+                   (sb->s_blocksize / dev->data_bytes_per_chunk);

                buf->f_bfree =
                buf->f_bfree =

-                       yaffs_get_n_free_chunks(dev) /
-                       (sb->s_blocksize / dev->data_bytes_per_chunk);
+                   yaffs_get_n_free_chunks(dev) /
+                   (sb->s_blocksize / dev->data_bytes_per_chunk);

        } else {
                buf->f_blocks =
        } else {
                buf->f_blocks =

-                       (dev->param.end_block - dev->param.start_block + 1) *
-                       dev->param.chunks_per_block *
-                       (dev->data_bytes_per_chunk / sb->s_blocksize);
+                   (dev->param.end_block - dev->param.start_block + 1) *
+                   dev->param.chunks_per_block *
+                   (dev->data_bytes_per_chunk / sb->s_blocksize);

 
                buf->f_bfree =
 
                buf->f_bfree =

-                       yaffs_get_n_free_chunks(dev) *
-                       (dev->data_bytes_per_chunk / sb->s_blocksize);
+                   yaffs_get_n_free_chunks(dev) *
+                   (dev->data_bytes_per_chunk / sb->s_blocksize);

        }
 
        buf->f_files = 0;
        }
 
        buf->f_files = 0;


@@ -1784,61 +1748,57 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
        return 0;
 }
 
        return 0;
 }
 

-
-

 static void yaffs_flush_inodes(struct super_block *sb)
 {
        struct inode *iptr;
        struct yaffs_obj *obj;
 static void yaffs_flush_inodes(struct super_block *sb)
 {
        struct inode *iptr;
        struct yaffs_obj *obj;

-       
-       list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){
+
+       list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) {

                obj = yaffs_inode_to_obj(iptr);
                obj = yaffs_inode_to_obj(iptr);

-               if(obj){
+               if (obj) {

                        T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),
                        T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"),

-                               obj->obj_id));
-                       yaffs_flush_file(obj,1,0);
+                                          obj->obj_id));
+                       yaffs_flush_file(obj, 1, 0);

                }
        }
 }
 
                }
        }
 }
 

-

 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {
 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {

-       struct yaffs_dev *dev = yaffs_super_to_dev(sb); 
-       if(!dev)
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
+       if (!dev)

                return;
                return;

-       
+

        yaffs_flush_inodes(sb);
        yaffs_update_dirty_dirs(dev);
        yaffs_flush_whole_cache(dev);
        yaffs_flush_inodes(sb);
        yaffs_update_dirty_dirs(dev);
        yaffs_flush_whole_cache(dev);

-       if(do_checkpoint)
+       if (do_checkpoint)

                yaffs_checkpoint_save(dev);
 }
 
                yaffs_checkpoint_save(dev);
 }
 

-

 static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev)
 {
 static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev)
 {

-       unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
+       unsigned erased_chunks =
+           dev->n_erased_blocks * dev->param.chunks_per_block;

        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);

-       unsigned scattered = 0; /* Free chunks not in an erased block */
+       unsigned scattered = 0; /* Free chunks not in an erased block */

 
 

-       if(erased_chunks < dev->n_free_chunks)
+       if (erased_chunks < dev->n_free_chunks)

                scattered = (dev->n_free_chunks - erased_chunks);
 
                scattered = (dev->n_free_chunks - erased_chunks);
 

-       if(!context->bg_running)
+       if (!context->bg_running)

                return 0;
                return 0;

-       else if(scattered < (dev->param.chunks_per_block * 2))
+       else if (scattered < (dev->param.chunks_per_block * 2))

                return 0;
                return 0;

-       else if(erased_chunks > dev->n_free_chunks/2)
+       else if (erased_chunks > dev->n_free_chunks / 2)

                return 0;
                return 0;

-       else if(erased_chunks > dev->n_free_chunks/4)
+       else if (erased_chunks > dev->n_free_chunks / 4)

                return 1;
        else
                return 2;
 }
 
                return 1;
        else
                return 2;
 }
 

-static int yaffs_do_sync_fs(struct super_block *sb,
-                               int request_checkpoint)
+static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint)

 {
 
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 {
 
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);


@@ -1847,21 +1807,20 @@ static int yaffs_do_sync_fs(struct super_block *sb,
        int do_checkpoint;
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
        int do_checkpoint;
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"),
-               gc_urgent,
-               sb->s_dirt ? "dirty" : "clean",
-               request_checkpoint ? "checkpoint requested" : "no checkpoint",
-               oneshot_checkpoint ? " one-shot" : "" ));
+         (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"),
+          gc_urgent,
+          sb->s_dirt ? "dirty" : "clean",
+          request_checkpoint ? "checkpoint requested" : "no checkpoint",
+          oneshot_checkpoint ? " one-shot" : ""));

 
        yaffs_gross_lock(dev);
        do_checkpoint = ((request_checkpoint && !gc_urgent) ||
 
        yaffs_gross_lock(dev);
        do_checkpoint = ((request_checkpoint && !gc_urgent) ||

-                       oneshot_checkpoint) &&
-                       !dev->is_checkpointed;
+                        oneshot_checkpoint) && !dev->is_checkpointed;

 
        if (sb->s_dirt || do_checkpoint) {
                yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint);
                sb->s_dirt = 0;
 
        if (sb->s_dirt || do_checkpoint) {
                yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint);
                sb->s_dirt = 0;

-               if(oneshot_checkpoint)
+               if (oneshot_checkpoint)

                        yaffs_auto_checkpoint &= ~4;
        }
        yaffs_gross_unlock(dev);
                        yaffs_auto_checkpoint &= ~4;
        }
        yaffs_gross_unlock(dev);


@@ -1881,7 +1840,6 @@ static int yaffs_do_sync_fs(struct super_block *sb,
  * The thread should not do any writing while the fs is in read only.
  */
 
  * The thread should not do any writing while the fs is in read only.
  */
 

-

 void yaffs_background_waker(unsigned long data)
 {
        wake_up_process((struct task_struct *)data);
 void yaffs_background_waker(unsigned long data)
 {
        wake_up_process((struct task_struct *)data);


@@ -1901,58 +1859,56 @@ static int yaffs_bg_thread_fn(void *data)
        struct timer_list timer;
 
        T(YAFFS_TRACE_BACKGROUND,
        struct timer_list timer;
 
        T(YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs_background starting for dev %p\n"),
-               (void *)dev));
+         (TSTR("yaffs_background starting for dev %p\n"), (void *)dev));

 
        set_freezable();
 
        set_freezable();

-       while(context->bg_running){
-               T(YAFFS_TRACE_BACKGROUND,
-                       (TSTR("yaffs_background\n")));
+       while (context->bg_running) {
+               T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n")));

 
 

-               if(kthread_should_stop())
+               if (kthread_should_stop())

                        break;
 
                        break;
 

-               if(try_to_freeze())
+               if (try_to_freeze())

                        continue;
 
                yaffs_gross_lock(dev);
 
                now = jiffies;
 
                        continue;
 
                yaffs_gross_lock(dev);
 
                now = jiffies;
 

-               if(time_after(now, next_dir_update) && yaffs_bg_enable){
+               if (time_after(now, next_dir_update) && yaffs_bg_enable) {

                        yaffs_update_dirty_dirs(dev);
                        next_dir_update = now + HZ;
                }
 
                        yaffs_update_dirty_dirs(dev);
                        next_dir_update = now + HZ;
                }
 

-               if(time_after(now,next_gc) && yaffs_bg_enable){
-                       if(!dev->is_checkpointed){
+               if (time_after(now, next_gc) && yaffs_bg_enable) {
+                       if (!dev->is_checkpointed) {

                                urgency = yaffs_bg_gc_urgency(dev);
                                gc_result = yaffs_bg_gc(dev, urgency);
                                urgency = yaffs_bg_gc_urgency(dev);
                                gc_result = yaffs_bg_gc(dev, urgency);

-                               if(urgency > 1)
-                                       next_gc = now + HZ/20+1;
-                               else if(urgency > 0)
-                                       next_gc = now + HZ/10+1;
+                               if (urgency > 1)
+                                       next_gc = now + HZ / 20 + 1;
+                               else if (urgency > 0)
+                                       next_gc = now + HZ / 10 + 1;

                                else
                                        next_gc = now + HZ * 2;
                                else
                                        next_gc = now + HZ * 2;

-                       } else /*
-                               * gc not running so set to next_dir_update
-                               * to cut down on wake ups
-                               */
+                       } else  /*
+                                * gc not running so set to next_dir_update
+                                * to cut down on wake ups
+                                */

                                next_gc = next_dir_update;
                }
                yaffs_gross_unlock(dev);
                expires = next_dir_update;
                                next_gc = next_dir_update;
                }
                yaffs_gross_unlock(dev);
                expires = next_dir_update;

-               if (time_before(next_gc,expires))
+               if (time_before(next_gc, expires))

                        expires = next_gc;
                        expires = next_gc;

-               if(time_before(expires,now))
+               if (time_before(expires, now))

                        expires = now + HZ;
 
                Y_INIT_TIMER(&timer);
                        expires = now + HZ;
 
                Y_INIT_TIMER(&timer);

-               timer.expires = expires+1;
-               timer.data = (unsigned long) current;
+               timer.expires = expires + 1;
+               timer.data = (unsigned long)current;

                timer.function = yaffs_background_waker;
 
                timer.function = yaffs_background_waker;
 

-                set_current_state(TASK_INTERRUPTIBLE);
+               set_current_state(TASK_INTERRUPTIBLE);

                add_timer(&timer);
                schedule();
                del_timer_sync(&timer);
                add_timer(&timer);
                schedule();
                del_timer_sync(&timer);


@@ -1966,15 +1922,16 @@ static int yaffs_bg_start(struct yaffs_dev *dev)
        int retval = 0;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
 
        int retval = 0;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
 

-       if(dev->read_only)
+       if (dev->read_only)

                return -1;
 
        context->bg_running = 1;
 
        context->bg_thread = kthread_run(yaffs_bg_thread_fn,
                return -1;
 
        context->bg_running = 1;
 
        context->bg_thread = kthread_run(yaffs_bg_thread_fn,

-                               (void *)dev,"yaffs-bg-%d",context->mount_id);
+                                        (void *)dev, "yaffs-bg-%d",
+                                        context->mount_id);

 
 

-       if(IS_ERR(context->bg_thread)){
+       if (IS_ERR(context->bg_thread)) {

                retval = PTR_ERR(context->bg_thread);
                context->bg_thread = NULL;
                context->bg_running = 0;
                retval = PTR_ERR(context->bg_thread);
                context->bg_thread = NULL;
                context->bg_running = 0;


@@ -1988,33 +1945,30 @@ static void yaffs_bg_stop(struct yaffs_dev *dev)
 
        ctxt->bg_running = 0;
 
 
        ctxt->bg_running = 0;
 

-       if( ctxt->bg_thread){
+       if (ctxt->bg_thread) {

                kthread_stop(ctxt->bg_thread);
                ctxt->bg_thread = NULL;
        }
 }
 
                kthread_stop(ctxt->bg_thread);
                ctxt->bg_thread = NULL;
        }
 }
 

-

 static void yaffs_write_super(struct super_block *sb)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
 static void yaffs_write_super(struct super_block *sb)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs_write_super%s\n"),
-               request_checkpoint ? " checkpt" : ""));
+         (TSTR("yaffs_write_super%s\n"),
+          request_checkpoint ? " checkpt" : ""));

 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
 }
 
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
 }
 

-

 static int yaffs_sync_fs(struct super_block *sb, int wait)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
 static int yaffs_sync_fs(struct super_block *sb, int wait)
 {
        unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,

-               (TSTR("yaffs_sync_fs%s\n"),
-               request_checkpoint ? " checkpt" : ""));
+         (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : ""));

 
        yaffs_do_sync_fs(sb, request_checkpoint);
 
 
        yaffs_do_sync_fs(sb, request_checkpoint);
 


@@ -2027,8 +1981,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
        struct yaffs_obj *obj;
        struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 

-       T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_iget for %lu\n"), ino));
+       T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino));

 
        inode = iget_locked(sb, ino);
        if (!inode)
 
        inode = iget_locked(sb, ino);
        if (!inode)


@@ -2063,19 +2016,18 @@ static void yaffs_put_super(struct super_block *sb)
        T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
        T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
 
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,

-               (TSTR("Shutting down yaffs background thread\n")));
+         (TSTR("Shutting down yaffs background thread\n")));

        yaffs_bg_stop(dev);
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,
        yaffs_bg_stop(dev);
        T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND,

-               (TSTR("yaffs background thread shut down\n")));
+         (TSTR("yaffs background thread shut down\n")));

 
        yaffs_gross_lock(dev);
 
 
        yaffs_gross_lock(dev);
 

-       yaffs_flush_super(sb,1);
+       yaffs_flush_super(sb, 1);

 
        if (yaffs_dev_to_lc(dev)->put_super_fn)
                yaffs_dev_to_lc(dev)->put_super_fn(sb);
 
 
        if (yaffs_dev_to_lc(dev)->put_super_fn)
                yaffs_dev_to_lc(dev)->put_super_fn(sb);
 

-

        yaffs_deinitialise(dev);
 
        yaffs_gross_unlock(dev);
        yaffs_deinitialise(dev);
 
        yaffs_gross_unlock(dev);


@@ -2092,7 +2044,6 @@ static void yaffs_put_super(struct super_block *sb)
        kfree(dev);
 }
 
        kfree(dev);
 }
 

-

 static void yaffs_mtd_put_super(struct super_block *sb)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
 static void yaffs_mtd_put_super(struct super_block *sb)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));


@@ -2103,7 +2054,6 @@ static void yaffs_mtd_put_super(struct super_block *sb)
        put_mtd_device(mtd);
 }
 
        put_mtd_device(mtd);
 }
 

-

 static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;


@@ -2124,10 +2074,11 @@ struct yaffs_options {
        int lazy_loading_overridden;
        int empty_lost_and_found;
        int empty_lost_and_found_overridden;
        int lazy_loading_overridden;
        int empty_lost_and_found;
        int empty_lost_and_found_overridden;

-} ;
+};

 
 #define MAX_OPT_LEN 30
 
 #define MAX_OPT_LEN 30

-static int yaffs_parse_options(struct yaffs_options *options, const char *options_str)
+static int yaffs_parse_options(struct yaffs_options *options,
+                              const char *options_str)

 {
        char cur_opt[MAX_OPT_LEN + 1];
        int p;
 {
        char cur_opt[MAX_OPT_LEN + 1];
        int p;


@@ -2139,7 +2090,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
                memset(cur_opt, 0, MAX_OPT_LEN + 1);
                p = 0;
 
                memset(cur_opt, 0, MAX_OPT_LEN + 1);
                p = 0;
 

-               while(*options_str == ',')
+               while (*options_str == ',')

                        options_str++;
 
                while (*options_str && *options_str != ',') {
                        options_str++;
 
                while (*options_str && *options_str != ',') {


@@ -2152,24 +2103,24 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
 
                if (!strcmp(cur_opt, "inband-tags"))
                        options->inband_tags = 1;
 
                if (!strcmp(cur_opt, "inband-tags"))
                        options->inband_tags = 1;

-               else if (!strcmp(cur_opt, "tags-ecc-off")){
+               else if (!strcmp(cur_opt, "tags-ecc-off")) {

                        options->tags_ecc_on = 0;
                        options->tags_ecc_on = 0;

-                       options->tags_ecc_overridden=1;
-               } else if (!strcmp(cur_opt, "tags-ecc-on")){
+                       options->tags_ecc_overridden = 1;
+               } else if (!strcmp(cur_opt, "tags-ecc-on")) {

                        options->tags_ecc_on = 1;
                        options->tags_ecc_overridden = 1;
                        options->tags_ecc_on = 1;
                        options->tags_ecc_overridden = 1;

-               } else if (!strcmp(cur_opt, "lazy-loading-off")){
+               } else if (!strcmp(cur_opt, "lazy-loading-off")) {

                        options->lazy_loading_enabled = 0;
                        options->lazy_loading_enabled = 0;

-                       options->lazy_loading_overridden=1;
-               } else if (!strcmp(cur_opt, "lazy-loading-on")){
+                       options->lazy_loading_overridden = 1;
+               } else if (!strcmp(cur_opt, "lazy-loading-on")) {

                        options->lazy_loading_enabled = 1;
                        options->lazy_loading_overridden = 1;
                        options->lazy_loading_enabled = 1;
                        options->lazy_loading_overridden = 1;

-               } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){
+               } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) {

                        options->empty_lost_and_found = 0;
                        options->empty_lost_and_found = 0;

-                       options->empty_lost_and_found_overridden=1;
-               } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){
+                       options->empty_lost_and_found_overridden = 1;
+               } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) {

                        options->empty_lost_and_found = 1;
                        options->empty_lost_and_found = 1;

-                       options->empty_lost_and_found_overridden=1;
+                       options->empty_lost_and_found_overridden = 1;

                } else if (!strcmp(cur_opt, "no-cache"))
                        options->no_cache = 1;
                else if (!strcmp(cur_opt, "no-checkpoint-read"))
                } else if (!strcmp(cur_opt, "no-cache"))
                        options->no_cache = 1;
                else if (!strcmp(cur_opt, "no-checkpoint-read"))


@@ -2181,7 +2132,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
                        options->skip_checkpoint_write = 1;
                } else {
                        printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",
                        options->skip_checkpoint_write = 1;
                } else {
                        printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",

-                                       cur_opt);
+                              cur_opt);

                        error = 1;
                }
        }
                        error = 1;
                }
        }


@@ -2190,8 +2141,8 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option
 }
 
 static struct super_block *yaffs_internal_read_super(int yaffs_version,
 }
 
 static struct super_block *yaffs_internal_read_super(int yaffs_version,

-                                               struct super_block *sb,
-                                               void *data, int silent)
+                                                    struct super_block *sb,
+                                                    void *data, int silent)

 {
        int n_blocks;
        struct inode *inode = NULL;
 {
        int n_blocks;
        struct inode *inode = NULL;


@@ -2217,7 +2168,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        sb->s_op = &yaffs_super_ops;
        sb->s_flags |= MS_NOATIME;
 
        sb->s_op = &yaffs_super_ops;
        sb->s_flags |= MS_NOATIME;
 

-       read_only =((sb->s_flags & MS_RDONLY) != 0);
+       read_only = ((sb->s_flags & MS_RDONLY) != 0);

 
        sb->s_export_op = &yaffs_export_ops;
 
 
        sb->s_export_op = &yaffs_export_ops;
 


@@ -2230,8 +2181,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        else
                printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n",
                       sb->s_dev,
        else
                printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n",
                       sb->s_dev,

-                      yaffs_devname(sb, devname_buf),
-                      read_only ? "ro" : "rw");
+                      yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw");

 
        if (!data_str)
                data_str = "";
 
        if (!data_str)
                data_str = "";


@@ -2245,20 +2195,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                return NULL;
        }
 
                return NULL;
        }
 

-

        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
        T(YAFFS_TRACE_OS,
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
+         (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));

        T(YAFFS_TRACE_OS,
        T(YAFFS_TRACE_OS,

-               (TSTR("yaffs_read_super: block size %d\n"),
-               (int)(sb->s_blocksize)));
+         (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize)));

 
        T(YAFFS_TRACE_ALWAYS,
 
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"),
-              MAJOR(sb->s_dev), MINOR(sb->s_dev),
-              yaffs_devname(sb, devname_buf)));
+         (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"),
+          MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf)));

 
        /* Check it's an mtd device..... */
        if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
 
        /* Check it's an mtd device..... */
        if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)


@@ -2268,15 +2215,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
        if (!mtd) {
                T(YAFFS_TRACE_ALWAYS,
        mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
        if (!mtd) {
                T(YAFFS_TRACE_ALWAYS,

-                       (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"),
-                       MINOR(sb->s_dev)));
+                 (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"),
+                  MINOR(sb->s_dev)));

                return NULL;
        }
        /* Check it's NAND */
        if (mtd->type != MTD_NANDFLASH) {
                T(YAFFS_TRACE_ALWAYS,
                return NULL;
        }
        /* Check it's NAND */
        if (mtd->type != MTD_NANDFLASH) {
                T(YAFFS_TRACE_ALWAYS,

-                       (TSTR("yaffs: MTD device is not NAND it's type %d\n"),
-                       mtd->type));
+                 (TSTR("yaffs: MTD device is not NAND it's type %d\n"),
+                  mtd->type));

                return NULL;
        }
 
                return NULL;
        }
 


@@ -2295,18 +2242,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
        if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
        if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {

-               T(YAFFS_TRACE_ALWAYS,
-                       (TSTR("yaffs: auto selecting yaffs2\n")));
+               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n")));

                yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */
                yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */

-       if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
-               T(YAFFS_TRACE_ALWAYS,
-                       (TSTR("yaffs: auto selecting yaffs1\n")));
+       if (yaffs_version == 2 && !options.inband_tags
+           && WRITE_SIZE(mtd) == 512) {
+               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n")));

                yaffs_version = 1;
        }
                yaffs_version = 1;
        }

-

 #endif
 
        if (yaffs_version == 2) {
 #endif
 
        if (yaffs_version == 2) {


@@ -2315,31 +2260,29 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                    !mtd->block_isbad ||
                    !mtd->block_markbad ||
                    !mtd->read ||
                    !mtd->block_isbad ||
                    !mtd->block_markbad ||
                    !mtd->read ||

-                   !mtd->write ||
-                   !mtd->read_oob || !mtd->write_oob) {
+                   !mtd->write || !mtd->read_oob || !mtd->write_oob) {

                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "

-                          "functions\n")));
+                               "functions\n")));

                        return NULL;
                }
 
                if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
                        return NULL;
                }
 
                if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||

-                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
+                    mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&

                    !options.inband_tags) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not have the "
                    !options.inband_tags) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not have the "

-                          "right page sizes\n")));
+                               "right page sizes\n")));

                        return NULL;
                }
        } else {
                /* Check for V1 style functions */
                if (!mtd->erase ||
                    !mtd->read ||
                        return NULL;
                }
        } else {
                /* Check for V1 style functions */
                if (!mtd->erase ||
                    !mtd->read ||

-                   !mtd->write ||
-                   !mtd->read_oob || !mtd->write_oob) {
+                   !mtd->write || !mtd->read_oob || !mtd->write_oob) {

                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support required "

-                          "functions\n")));
+                               "functions\n")));

                        return NULL;
                }
 
                        return NULL;
                }
 


@@ -2347,7 +2290,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support have the "
                    mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
                        T(YAFFS_TRACE_ALWAYS,
                          (TSTR("yaffs: MTD device does not support have the "

-                          "right page sizes\n")));
+                               "right page sizes\n")));

                        return NULL;
                }
        }
                        return NULL;
                }
        }


@@ -2357,19 +2300,20 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
         * Set the struct yaffs_dev up for mtd
         */
 
         * Set the struct yaffs_dev up for mtd
         */
 

-       if (!read_only && !(mtd->flags & MTD_WRITEABLE)){
+       if (!read_only && !(mtd->flags & MTD_WRITEABLE)) {

                read_only = 1;
                read_only = 1;

-               printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only");
+               printk(KERN_INFO
+                      "yaffs: mtd is read only, setting superblock read only");

                sb->s_flags |= MS_RDONLY;
        }
 
        dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL);
                sb->s_flags |= MS_RDONLY;
        }
 
        dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL);

-       context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL);
-       
-       if(!dev || !context ){
-               if(dev)
+       context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL);
+
+       if (!dev || !context) {
+               if (dev)

                        kfree(dev);
                        kfree(dev);

-               if(context)
+               if (context)

                        kfree(context);
                dev = NULL;
                context = NULL;
                        kfree(context);
                dev = NULL;
                context = NULL;


@@ -2379,13 +2323,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                /* Deep shit could not allocate device structure */
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("yaffs_read_super: Failed trying to allocate "
                /* Deep shit could not allocate device structure */
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("yaffs_read_super: Failed trying to allocate "

-                  "struct yaffs_dev. \n")));
+                       "struct yaffs_dev. \n")));

                return NULL;
        }
        memset(dev, 0, sizeof(struct yaffs_dev));
        param = &(dev->param);
 
                return NULL;
        }
        memset(dev, 0, sizeof(struct yaffs_dev));
        param = &(dev->param);
 

-       memset(context,0,sizeof(struct yaffs_linux_context));
+       memset(context, 0, sizeof(struct yaffs_linux_context));

        dev->os_context = context;
        INIT_LIST_HEAD(&(context->context_list));
        context->dev = dev;
        dev->os_context = context;
        INIT_LIST_HEAD(&(context->context_list));
        context->dev = dev;


@@ -2394,13 +2338,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        dev->read_only = read_only;
 
        sb->s_fs_info = dev;
        dev->read_only = read_only;
 
        sb->s_fs_info = dev;

-       
+

        dev->driver_context = mtd;
        param->name = mtd->name;
 
        /* Set up the memory size parameters.... */
 
        dev->driver_context = mtd;
        param->name = mtd->name;
 
        /* Set up the memory size parameters.... */
 

-       n_blocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK));
+       n_blocks =
+           YCALCBLOCKS(mtd->size,
+                       (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK));

 
        param->start_block = 0;
        param->end_block = n_blocks - 1;
 
        param->start_block = 0;
        param->end_block = n_blocks - 1;


@@ -2416,7 +2362,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 #ifdef CONFIG_YAFFS_XATTR
        param->enable_xattr = 1;
 #endif
 #ifdef CONFIG_YAFFS_XATTR
        param->enable_xattr = 1;
 #endif

-       if(options.lazy_loading_overridden)
+       if (options.lazy_loading_overridden)

                param->disable_lazy_load = !options.lazy_loading_enabled;
 
 #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC
                param->disable_lazy_load = !options.lazy_loading_enabled;
 
 #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC


@@ -2428,7 +2374,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        param->defered_dir_update = 1;
 #endif
 
        param->defered_dir_update = 1;
 #endif
 

-       if(options.tags_ecc_overridden)
+       if (options.tags_ecc_overridden)

                param->no_tags_ecc = !options.tags_ecc_on;
 
 #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND
                param->no_tags_ecc = !options.tags_ecc_on;
 
 #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND


@@ -2445,15 +2391,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        param->always_check_erased = 1;
 #endif
 
        param->always_check_erased = 1;
 #endif
 

-       if(options.empty_lost_and_found_overridden)
+       if (options.empty_lost_and_found_overridden)

                param->empty_lost_n_found = options.empty_lost_and_found;
 
        /* ... and the functions. */
        if (yaffs_version == 2) {
                param->empty_lost_n_found = options.empty_lost_and_found;
 
        /* ... and the functions. */
        if (yaffs_version == 2) {

-               param->write_chunk_tags_fn =
-                   nandmtd2_write_chunk_tags;
-               param->read_chunk_tags_fn =
-                   nandmtd2_read_chunk_tags;
+               param->write_chunk_tags_fn = nandmtd2_write_chunk_tags;
+               param->read_chunk_tags_fn = nandmtd2_read_chunk_tags;

                param->bad_block_fn = nandmtd2_mark_block_bad;
                param->query_block_fn = nandmtd2_query_block;
                yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
                param->bad_block_fn = nandmtd2_mark_block_bad;
                param->query_block_fn = nandmtd2_query_block;
                yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);


@@ -2466,10 +2410,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                param->end_block = n_blocks - 1;
        } else {
                /* use the MTD interface in yaffs_mtdif1.c */
                param->end_block = n_blocks - 1;
        } else {
                /* use the MTD interface in yaffs_mtdif1.c */

-               param->write_chunk_tags_fn =
-                       nandmtd1_write_chunk_tags;
-               param->read_chunk_tags_fn =
-                       nandmtd1_read_chunk_tags;
+               param->write_chunk_tags_fn = nandmtd1_write_chunk_tags;
+               param->read_chunk_tags_fn = nandmtd1_read_chunk_tags;

                param->bad_block_fn = nandmtd1_mark_block_bad;
                param->query_block_fn = nandmtd1_query_block;
                param->is_yaffs2 = 0;
                param->bad_block_fn = nandmtd1_mark_block_bad;
                param->query_block_fn = nandmtd1_query_block;
                param->is_yaffs2 = 0;


@@ -2483,8 +2425,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        param->sb_dirty_fn = yaffs_touch_super;
        param->gc_control = yaffs_gc_control_callback;
 
        param->sb_dirty_fn = yaffs_touch_super;
        param->gc_control = yaffs_gc_control_callback;
 

-       yaffs_dev_to_lc(dev)->super= sb;
-       
+       yaffs_dev_to_lc(dev)->super = sb;

 
 #ifndef CONFIG_YAFFS_DOES_ECC
        param->use_nand_ecc = 1;
 
 #ifndef CONFIG_YAFFS_DOES_ECC
        param->use_nand_ecc = 1;


@@ -2500,22 +2441,25 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        down(&yaffs_context_lock);
        /* Get a mount id */
        found = 0;
        down(&yaffs_context_lock);
        /* Get a mount id */
        found = 0;

-       for(mount_id=0; ! found; mount_id++){
+       for (mount_id = 0; !found; mount_id++) {

                found = 1;
                found = 1;

-               list_for_each(l,&yaffs_context_list){
-                       context_iterator = list_entry(l,struct yaffs_linux_context,context_list);
-                       if(context_iterator->mount_id == mount_id)
+               list_for_each(l, &yaffs_context_list) {
+                       context_iterator =
+                           list_entry(l, struct yaffs_linux_context,
+                                      context_list);
+                       if (context_iterator->mount_id == mount_id)

                                found = 0;
                }
        }
        context->mount_id = mount_id;
 
                                found = 0;
                }
        }
        context->mount_id = mount_id;
 

-       list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list);
+       list_add_tail(&(yaffs_dev_to_lc(dev)->context_list),
+                     &yaffs_context_list);

        up(&yaffs_context_lock);
 
        up(&yaffs_context_lock);
 

-        /* Directory search handling...*/
-        INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
-        param->remove_obj_fn = yaffs_remove_obj_callback;
+       /* Directory search handling... */
+       INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
+       param->remove_obj_fn = yaffs_remove_obj_callback;

 
        init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
 
 
        init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
 


@@ -2526,21 +2470,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        T(YAFFS_TRACE_OS,
          (TSTR("yaffs_read_super: guts initialised %s\n"),
           (err == YAFFS_OK) ? "OK" : "FAILED"));
        T(YAFFS_TRACE_OS,
          (TSTR("yaffs_read_super: guts initialised %s\n"),
           (err == YAFFS_OK) ? "OK" : "FAILED"));

-          
-       if(err == YAFFS_OK)
+
+       if (err == YAFFS_OK)

                yaffs_bg_start(dev);
                yaffs_bg_start(dev);

-               
-       if(!context->bg_thread)
-               param->defered_dir_update = 0;

 
 

+       if (!context->bg_thread)
+               param->defered_dir_update = 0;

 
        /* Release lock before yaffs_get_inode() */
        yaffs_gross_unlock(dev);
 
        /* Create root inode */
        if (err == YAFFS_OK)
 
        /* Release lock before yaffs_get_inode() */
        yaffs_gross_unlock(dev);
 
        /* Create root inode */
        if (err == YAFFS_OK)

-               inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,
-                                       yaffs_root(dev));
+               inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev));

 
        if (!inode)
                return NULL;
 
        if (!inode)
                return NULL;


@@ -2561,14 +2503,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        sb->s_root = root;
        sb->s_dirt = !dev->is_checkpointed;
        T(YAFFS_TRACE_ALWAYS,
        sb->s_root = root;
        sb->s_dirt = !dev->is_checkpointed;
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs_read_super: is_checkpointed %d\n"),
-               dev->is_checkpointed));
+         (TSTR("yaffs_read_super: is_checkpointed %d\n"),
+          dev->is_checkpointed));

 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n")));
        return sb;
 }
 
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n")));
        return sb;
 }
 

-

 static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
                                         int silent)
 {
 static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
                                         int silent)
 {


@@ -2592,7 +2533,6 @@ static struct file_system_type yaffs_fs_type = {
        .fs_flags = FS_REQUIRES_DEV,
 };
 
        .fs_flags = FS_REQUIRES_DEV,
 };
 

-

 #ifdef CONFIG_YAFFS_YAFFS2
 
 static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
 #ifdef CONFIG_YAFFS_YAFFS2
 
 static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,


@@ -2602,11 +2542,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
 }
 
 static int yaffs2_read_super(struct file_system_type *fs,
 }
 
 static int yaffs2_read_super(struct file_system_type *fs,

-                       int flags, const char *dev_name, void *data,
-                       struct vfsmount *mnt)
+                            int flags, const char *dev_name, void *data,
+                            struct vfsmount *mnt)

 {
        return get_sb_bdev(fs, flags, dev_name, data,
 {
        return get_sb_bdev(fs, flags, dev_name, data,

-                       yaffs2_internal_read_super_mtd, mnt);
+                          yaffs2_internal_read_super_mtd, mnt);

 }
 
 static struct file_system_type yaffs2_fs_type = {
 }
 
 static struct file_system_type yaffs2_fs_type = {


@@ -2616,40 +2556,62 @@ static struct file_system_type yaffs2_fs_type = {
        .kill_sb = kill_block_super,
        .fs_flags = FS_REQUIRES_DEV,
 };
        .kill_sb = kill_block_super,
        .fs_flags = FS_REQUIRES_DEV,
 };

-#endif                         /* CONFIG_YAFFS_YAFFS2 */
+#endif /* CONFIG_YAFFS_YAFFS2 */

 
 static struct proc_dir_entry *my_proc_entry;
 static struct proc_dir_entry *debug_proc_entry;
 
 
 static struct proc_dir_entry *my_proc_entry;
 static struct proc_dir_entry *debug_proc_entry;
 

-static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev * dev)
-{
-       buf += sprintf(buf, "start_block........... %d\n", dev->param.start_block);
-       buf += sprintf(buf, "end_block............. %d\n", dev->param.end_block);
-       buf += sprintf(buf, "total_bytes_per_chunk. %d\n", dev->param.total_bytes_per_chunk);
-       buf += sprintf(buf, "use_nand_ecc.......... %d\n", dev->param.use_nand_ecc);
-       buf += sprintf(buf, "no_tags_ecc........... %d\n", dev->param.no_tags_ecc);
-       buf += sprintf(buf, "is_yaffs2............. %d\n", dev->param.is_yaffs2);
-       buf += sprintf(buf, "inband_tags........... %d\n", dev->param.inband_tags);
-       buf += sprintf(buf, "empty_lost_n_found.... %d\n", dev->param.empty_lost_n_found);
-       buf += sprintf(buf, "disable_lazy_load..... %d\n", dev->param.disable_lazy_load);
-       buf += sprintf(buf, "refresh_period........ %d\n", dev->param.refresh_period);
+static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
+{
+       buf +=
+           sprintf(buf, "start_block........... %d\n", dev->param.start_block);
+       buf +=
+           sprintf(buf, "end_block............. %d\n", dev->param.end_block);
+       buf +=
+           sprintf(buf, "total_bytes_per_chunk. %d\n",
+                   dev->param.total_bytes_per_chunk);
+       buf +=
+           sprintf(buf, "use_nand_ecc.......... %d\n",
+                   dev->param.use_nand_ecc);
+       buf +=
+           sprintf(buf, "no_tags_ecc........... %d\n", dev->param.no_tags_ecc);
+       buf +=
+           sprintf(buf, "is_yaffs2............. %d\n", dev->param.is_yaffs2);
+       buf +=
+           sprintf(buf, "inband_tags........... %d\n", dev->param.inband_tags);
+       buf +=
+           sprintf(buf, "empty_lost_n_found.... %d\n",
+                   dev->param.empty_lost_n_found);
+       buf +=
+           sprintf(buf, "disable_lazy_load..... %d\n",
+                   dev->param.disable_lazy_load);
+       buf +=
+           sprintf(buf, "refresh_period........ %d\n",
+                   dev->param.refresh_period);

        buf += sprintf(buf, "n_caches.............. %d\n", dev->param.n_caches);
        buf += sprintf(buf, "n_caches.............. %d\n", dev->param.n_caches);

-       buf += sprintf(buf, "n_reserved_blocks..... %d\n", dev->param.n_reserved_blocks);
-       buf += sprintf(buf, "always_check_erased... %d\n", dev->param.always_check_erased);
+       buf +=
+           sprintf(buf, "n_reserved_blocks..... %d\n",
+                   dev->param.n_reserved_blocks);
+       buf +=
+           sprintf(buf, "always_check_erased... %d\n",
+                   dev->param.always_check_erased);

 
        buf += sprintf(buf, "\n");
 
        return buf;
 }
 
 
        buf += sprintf(buf, "\n");
 
        return buf;
 }
 

-
-static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev)
+static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev)

 {
 {

-       buf += sprintf(buf, "data_bytes_per_chunk.. %d\n", dev->data_bytes_per_chunk);
+       buf +=
+           sprintf(buf, "data_bytes_per_chunk.. %d\n",
+                   dev->data_bytes_per_chunk);

        buf += sprintf(buf, "chunk_grp_bits........ %d\n", dev->chunk_grp_bits);
        buf += sprintf(buf, "chunk_grp_size........ %d\n", dev->chunk_grp_size);
        buf += sprintf(buf, "chunk_grp_bits........ %d\n", dev->chunk_grp_bits);
        buf += sprintf(buf, "chunk_grp_size........ %d\n", dev->chunk_grp_size);

-       buf += sprintf(buf, "n_erased_blocks....... %d\n", dev->n_erased_blocks);
-       buf += sprintf(buf, "blocks_in_checkpt..... %d\n", dev->blocks_in_checkpt);
+       buf +=
+           sprintf(buf, "n_erased_blocks....... %d\n", dev->n_erased_blocks);
+       buf +=
+           sprintf(buf, "blocks_in_checkpt..... %d\n", dev->blocks_in_checkpt);

        buf += sprintf(buf, "\n");
        buf += sprintf(buf, "n_tnodes.............. %d\n", dev->n_tnodes);
        buf += sprintf(buf, "n_obj................. %d\n", dev->n_obj);
        buf += sprintf(buf, "\n");
        buf += sprintf(buf, "n_tnodes.............. %d\n", dev->n_tnodes);
        buf += sprintf(buf, "n_obj................. %d\n", dev->n_obj);


@@ -2660,19 +2622,29 @@ static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev)
        buf += sprintf(buf, "n_erasures............ %u\n", dev->n_erasures);
        buf += sprintf(buf, "n_gc_copies........... %u\n", dev->n_gc_copies);
        buf += sprintf(buf, "all_gcs............... %u\n", dev->all_gcs);
        buf += sprintf(buf, "n_erasures............ %u\n", dev->n_erasures);
        buf += sprintf(buf, "n_gc_copies........... %u\n", dev->n_gc_copies);
        buf += sprintf(buf, "all_gcs............... %u\n", dev->all_gcs);

-       buf += sprintf(buf, "passive_gc_count...... %u\n", dev->passive_gc_count);
-       buf += sprintf(buf, "oldest_dirty_gc_count. %u\n", dev->oldest_dirty_gc_count);
+       buf +=
+           sprintf(buf, "passive_gc_count...... %u\n", dev->passive_gc_count);
+       buf +=
+           sprintf(buf, "oldest_dirty_gc_count. %u\n",
+                   dev->oldest_dirty_gc_count);

        buf += sprintf(buf, "n_gc_blocks........... %u\n", dev->n_gc_blocks);
        buf += sprintf(buf, "bg_gcs................ %u\n", dev->bg_gcs);
        buf += sprintf(buf, "n_gc_blocks........... %u\n", dev->n_gc_blocks);
        buf += sprintf(buf, "bg_gcs................ %u\n", dev->bg_gcs);

-       buf += sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes);
-       buf += sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks);
+       buf +=
+           sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes);
+       buf +=
+           sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks);

        buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed);
        buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed);
        buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed);
        buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed);

-       buf += sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed);
-       buf += sprintf(buf, "n_tags_ecc_unfixed.... %u\n", dev->n_tags_ecc_unfixed);
+       buf +=
+           sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed);
+       buf +=
+           sprintf(buf, "n_tags_ecc_unfixed.... %u\n",
+                   dev->n_tags_ecc_unfixed);

        buf += sprintf(buf, "cache_hits............ %u\n", dev->cache_hits);
        buf += sprintf(buf, "cache_hits............ %u\n", dev->cache_hits);

-       buf += sprintf(buf, "n_deleted_files....... %u\n", dev->n_deleted_files);
-       buf += sprintf(buf, "n_unlinked_files...... %u\n", dev->n_unlinked_files);
+       buf +=
+           sprintf(buf, "n_deleted_files....... %u\n", dev->n_deleted_files);
+       buf +=
+           sprintf(buf, "n_unlinked_files...... %u\n", dev->n_unlinked_files);

        buf += sprintf(buf, "refresh_count......... %u\n", dev->refresh_count);
        buf += sprintf(buf, "n_bg_deletions........ %u\n", dev->n_bg_deletions);
 
        buf += sprintf(buf, "refresh_count......... %u\n", dev->refresh_count);
        buf += sprintf(buf, "n_bg_deletions........ %u\n", dev->n_bg_deletions);
 


@@ -2698,29 +2670,33 @@ static int yaffs_proc_read(char *page,
 
        /* Print header first */
        if (step == 0)
 
        /* Print header first */
        if (step == 0)

-               buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__"\n");
+               buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__ "\n");

        else if (step == 1)
        else if (step == 1)

-               buf += sprintf(buf,"\n");
+               buf += sprintf(buf, "\n");

        else {
        else {

-               step-=2;
-               
+               step -= 2;
+

                down(&yaffs_context_lock);
 
                /* Locate and print the Nth entry.  Order N-squared but N is small. */
                list_for_each(item, &yaffs_context_list) {
                down(&yaffs_context_lock);
 
                /* Locate and print the Nth entry.  Order N-squared but N is small. */
                list_for_each(item, &yaffs_context_list) {

-                       struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list);
+                       struct yaffs_linux_context *dc =
+                           list_entry(item, struct yaffs_linux_context,
+                                      context_list);

                        struct yaffs_dev *dev = dc->dev;
 
                        if (n < (step & ~1)) {
                        struct yaffs_dev *dev = dc->dev;
 
                        if (n < (step & ~1)) {

-                               n+=2;
+                               n += 2;

                                continue;
                        }
                                continue;
                        }

-                       if((step & 1)==0){
-                               buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name);
+                       if ((step & 1) == 0) {
+                               buf +=
+                                   sprintf(buf, "\nDevice %d \"%s\"\n", n,
+                                           dev->param.name);

                                buf = yaffs_dump_dev_part0(buf, dev);
                        } else
                                buf = yaffs_dump_dev_part1(buf, dev);
                                buf = yaffs_dump_dev_part0(buf, dev);
                        } else
                                buf = yaffs_dump_dev_part1(buf, dev);

-                       
+

                        break;
                }
                up(&yaffs_context_lock);
                        break;
                }
                up(&yaffs_context_lock);


@@ -2730,8 +2706,8 @@ static int yaffs_proc_read(char *page,
 }
 
 static int yaffs_stats_proc_read(char *page,
 }
 
 static int yaffs_stats_proc_read(char *page,

-                               char **start,
-                               off_t offset, int count, int *eof, void *data)
+                                char **start,
+                                off_t offset, int count, int *eof, void *data)

 {
        struct list_head *item;
        char *buf = page;
 {
        struct list_head *item;
        char *buf = page;


@@ -2741,21 +2717,22 @@ static int yaffs_stats_proc_read(char *page,
 
        /* Locate and print the Nth entry.  Order N-squared but N is small. */
        list_for_each(item, &yaffs_context_list) {
 
        /* Locate and print the Nth entry.  Order N-squared but N is small. */
        list_for_each(item, &yaffs_context_list) {

-               struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list);
+               struct yaffs_linux_context *dc =
+                   list_entry(item, struct yaffs_linux_context, context_list);

                struct yaffs_dev *dev = dc->dev;
 
                int erased_chunks;
 
                struct yaffs_dev *dev = dc->dev;
 
                int erased_chunks;
 

-               erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
-               
-               buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n",
-                               n, dev->n_free_chunks, erased_chunks,
-                               dev->bg_gcs, dev->oldest_dirty_gc_count,
-                               dev->n_obj, dev->n_tnodes);
+               erased_chunks =
+                   dev->n_erased_blocks * dev->param.chunks_per_block;
+
+               buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n",
+                              n, dev->n_free_chunks, erased_chunks,
+                              dev->bg_gcs, dev->oldest_dirty_gc_count,
+                              dev->n_obj, dev->n_tnodes);

        }
        up(&yaffs_context_lock);
 
        }
        up(&yaffs_context_lock);
 

-

        return buf - page < count ? buf - page : count;
 }
 
        return buf - page < count ? buf - page : count;
 }
 


@@ -2769,41 +2746,39 @@ static struct {
        char *mask_name;
        unsigned mask_bitfield;
 } mask_flags[] = {
        char *mask_name;
        unsigned mask_bitfield;
 } mask_flags[] = {

-       {"allocate", YAFFS_TRACE_ALLOCATE},
-       {"always", YAFFS_TRACE_ALWAYS},
-       {"background", YAFFS_TRACE_BACKGROUND},
-       {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
-       {"buffers", YAFFS_TRACE_BUFFERS},
-       {"bug", YAFFS_TRACE_BUG},
-       {"checkpt", YAFFS_TRACE_CHECKPOINT},
-       {"deletion", YAFFS_TRACE_DELETION},
-       {"erase", YAFFS_TRACE_ERASE},
-       {"error", YAFFS_TRACE_ERROR},
-       {"gc_detail", YAFFS_TRACE_GC_DETAIL},
-       {"gc", YAFFS_TRACE_GC},
-       {"lock", YAFFS_TRACE_LOCK},
-       {"mtd", YAFFS_TRACE_MTD},
-       {"nandaccess", YAFFS_TRACE_NANDACCESS},
-       {"os", YAFFS_TRACE_OS},
-       {"scan_debug", YAFFS_TRACE_SCAN_DEBUG},
-       {"scan", YAFFS_TRACE_SCAN},
-       {"tracing", YAFFS_TRACE_TRACING},
-       {"sync", YAFFS_TRACE_SYNC},
-       {"write", YAFFS_TRACE_WRITE},
-
-       {"verify", YAFFS_TRACE_VERIFY},
-       {"verify_nand", YAFFS_TRACE_VERIFY_NAND},
-       {"verify_full", YAFFS_TRACE_VERIFY_FULL},
-       {"verify_all", YAFFS_TRACE_VERIFY_ALL},
-
-       {"all", 0xffffffff},
-       {"none", 0},
-       {NULL, 0},
-};
+       {
+       "allocate", YAFFS_TRACE_ALLOCATE}, {
+       "always", YAFFS_TRACE_ALWAYS}, {
+       "background", YAFFS_TRACE_BACKGROUND}, {
+       "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, {
+       "buffers", YAFFS_TRACE_BUFFERS}, {
+       "bug", YAFFS_TRACE_BUG}, {
+       "checkpt", YAFFS_TRACE_CHECKPOINT}, {
+       "deletion", YAFFS_TRACE_DELETION}, {
+       "erase", YAFFS_TRACE_ERASE}, {
+       "error", YAFFS_TRACE_ERROR}, {
+       "gc_detail", YAFFS_TRACE_GC_DETAIL}, {
+       "gc", YAFFS_TRACE_GC}, {
+       "lock", YAFFS_TRACE_LOCK}, {
+       "mtd", YAFFS_TRACE_MTD}, {
+       "nandaccess", YAFFS_TRACE_NANDACCESS}, {
+       "os", YAFFS_TRACE_OS}, {
+       "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, {
+       "scan", YAFFS_TRACE_SCAN}, {
+       "tracing", YAFFS_TRACE_TRACING}, {
+       "sync", YAFFS_TRACE_SYNC}, {
+       "write", YAFFS_TRACE_WRITE}, {
+       "verify", YAFFS_TRACE_VERIFY}, {
+       "verify_nand", YAFFS_TRACE_VERIFY_NAND}, {
+       "verify_full", YAFFS_TRACE_VERIFY_FULL}, {
+       "verify_all", YAFFS_TRACE_VERIFY_ALL}, {
+       "all", 0xffffffff}, {
+       "none", 0}, {
+NULL, 0},};

 
 #define MAX_MASK_NAME_LENGTH 40
 static int yaffs_proc_write_trace_options(struct file *file, const char *buf,
 
 #define MAX_MASK_NAME_LENGTH 40
 static int yaffs_proc_write_trace_options(struct file *file, const char *buf,

-                                        unsigned long count, void *data)
+                                         unsigned long count, void *data)

 {
        unsigned rg = 0, mask_bitfield;
        char *end;
 {
        unsigned rg = 0, mask_bitfield;
        char *end;


@@ -2845,15 +2820,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf,
                        done = 0;
                } else {
                        for (x = buf + pos, i = 0;
                        done = 0;
                } else {
                        for (x = buf + pos, i = 0;

-                           (*x == '_' || (*x >= 'a' && *x <= 'z')) &&
-                           i < MAX_MASK_NAME_LENGTH; x++, i++, pos++)
+                            (*x == '_' || (*x >= 'a' && *x <= 'z')) &&
+                            i < MAX_MASK_NAME_LENGTH; x++, i++, pos++)

                                substring[i] = *x;
                        substring[i] = '\0';
 
                        for (i = 0; mask_flags[i].mask_name != NULL; i++) {
                                substring[i] = *x;
                        substring[i] = '\0';
 
                        for (i = 0; mask_flags[i].mask_name != NULL; i++) {

-                               if (strcmp(substring, mask_flags[i].mask_name) == 0) {
+                               if (strcmp(substring, mask_flags[i].mask_name)
+                                   == 0) {

                                        mask_name = mask_flags[i].mask_name;
                                        mask_name = mask_flags[i].mask_name;

-                                       mask_bitfield = mask_flags[i].mask_bitfield;
+                                       mask_bitfield =
+                                           mask_flags[i].mask_bitfield;

                                        done = 0;
                                        break;
                                }
                                        done = 0;
                                        break;
                                }


@@ -2888,18 +2865,18 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf,
                        char flag;
                        flag = ((rg & mask_flags[i].mask_bitfield) ==
                                mask_flags[i].mask_bitfield) ? '+' : '-';
                        char flag;
                        flag = ((rg & mask_flags[i].mask_bitfield) ==
                                mask_flags[i].mask_bitfield) ? '+' : '-';

-                       printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name);
+                       printk(KERN_DEBUG "%c%s\n", flag,
+                              mask_flags[i].mask_name);

                }
        }
 
        return count;
 }
 
                }
        }
 
        return count;
 }
 

-

 static int yaffs_proc_write(struct file *file, const char *buf,
 static int yaffs_proc_write(struct file *file, const char *buf,

-                                        unsigned long count, void *data)
+                           unsigned long count, void *data)

 {
 {

-        return yaffs_proc_write_trace_options(file, buf, count, data);
+       return yaffs_proc_write_trace_options(file, buf, count, data);

 }
 
 /* Stuff to handle installation of file systems */
 }
 
 /* Stuff to handle installation of file systems */


@@ -2924,18 +2901,15 @@ static int __init init_yaffs_fs(void)
 
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
        T(YAFFS_TRACE_ALWAYS,
 
 #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
        T(YAFFS_TRACE_ALWAYS,

-         (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n")));
+         (TSTR
+          (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n")));

 #endif
 
 #endif
 

-
-
-

        init_MUTEX(&yaffs_context_lock);
 
        /* Install the proc_fs entries */
        my_proc_entry = create_proc_entry("yaffs",
        init_MUTEX(&yaffs_context_lock);
 
        /* Install the proc_fs entries */
        my_proc_entry = create_proc_entry("yaffs",

-                                              S_IRUGO | S_IFREG,
-                                              YPROC_ROOT);
+                                         S_IRUGO | S_IFREG, YPROC_ROOT);

 
        if (my_proc_entry) {
                my_proc_entry->write_proc = yaffs_proc_write;
 
        if (my_proc_entry) {
                my_proc_entry->write_proc = yaffs_proc_write;


@@ -2945,8 +2919,7 @@ static int __init init_yaffs_fs(void)
                return -ENOMEM;
 
        debug_proc_entry = create_proc_entry("yaffs_stats",
                return -ENOMEM;
 
        debug_proc_entry = create_proc_entry("yaffs_stats",

-                                              S_IRUGO | S_IFREG,
-                                              YPROC_ROOT);
+                                            S_IRUGO | S_IFREG, YPROC_ROOT);

 
        if (debug_proc_entry) {
                debug_proc_entry->write_proc = NULL;
 
        if (debug_proc_entry) {
                debug_proc_entry->write_proc = NULL;


@@ -2988,7 +2961,7 @@ static void __exit exit_yaffs_fs(void)
        struct file_system_to_install *fsinst;
 
        T(YAFFS_TRACE_ALWAYS,
        struct file_system_to_install *fsinst;
 
        T(YAFFS_TRACE_ALWAYS,

-               (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n")));
+         (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n")));

 
        remove_proc_entry("yaffs", YPROC_ROOT);
        remove_proc_entry("yaffs_stats", YPROC_ROOT);
 
        remove_proc_entry("yaffs", YPROC_ROOT);
        remove_proc_entry("yaffs_stats", YPROC_ROOT);


@@ -3005,8 +2978,8 @@ static void __exit exit_yaffs_fs(void)
 }
 
 module_init(init_yaffs_fs)
 }
 
 module_init(init_yaffs_fs)

-module_exit(exit_yaffs_fs)
+    module_exit(exit_yaffs_fs)

 
 

-MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
+    MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");

 MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010");
 MODULE_LICENSE("GPL");

diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c
index 059d12515eb89b5431ff7ca6b087ee8ee32968c1..4ab0f22bb563959febbd22f0715237482f14ff60 100644 (file)
--- a/yaffs_yaffs1.c
+++ b/yaffs_yaffs1.c
@@ -40,11 +40,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
        struct yaffs_shadow_fixer *shadow_fixers = NULL;
 
 
        struct yaffs_shadow_fixer *shadow_fixers = NULL;
 

-

        u8 *chunk_data;
 
        u8 *chunk_data;
 

-
-

        T(YAFFS_TRACE_SCAN,
          (TSTR("yaffs1_scan starts  intstartblk %d intendblk %d..." TENDSTR),
           dev->internal_start_block, dev->internal_end_block));
        T(YAFFS_TRACE_SCAN,
          (TSTR("yaffs1_scan starts  intstartblk %d intendblk %d..." TENDSTR),
           dev->internal_start_block, dev->internal_end_block));


@@ -55,7 +52,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
        /* Scan all the blocks to determine their state */
        bi = dev->block_info;
 
        /* Scan all the blocks to determine their state */
        bi = dev->block_info;

-       for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) {
+       for (blk = dev->internal_start_block; blk <= dev->internal_end_block;
+            blk++) {

                yaffs_clear_chunk_bits(dev, blk);
                bi->pages_in_use = 0;
                bi->soft_del_pages = 0;
                yaffs_clear_chunk_bits(dev, blk);
                bi->pages_in_use = 0;
                bi->soft_del_pages = 0;


@@ -85,9 +83,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
        }
 
        /* For each block.... */
        }
 
        /* For each block.... */

-       for (blk= dev->internal_start_block; 
-               !alloc_failed && blk <= dev->internal_end_block;
-               blk++) {
+       for (blk = dev->internal_start_block;
+            !alloc_failed && blk <= dev->internal_end_block; blk++) {

 
                YYIELD();
 
 
                YYIELD();
 


@@ -96,18 +93,19 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
                deleted = 0;
 
 
                deleted = 0;
 

-               /* For each chunk in each block that needs scanning....*/
+               /* For each chunk in each block that needs scanning.... */

                for (c = 0; !alloc_failed && c < dev->param.chunks_per_block &&
                     state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) {
                        /* Read the tags and decide what to do */
                        chunk = blk * dev->param.chunks_per_block + c;
 
                        result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,
                for (c = 0; !alloc_failed && c < dev->param.chunks_per_block &&
                     state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) {
                        /* Read the tags and decide what to do */
                        chunk = blk * dev->param.chunks_per_block + c;
 
                        result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,

-                                                       &tags);
+                                                         &tags);

 
                        /* Let's have a good look at this chunk... */
 
 
                        /* Let's have a good look at this chunk... */
 

-                       if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED || tags.is_deleted) {
+                       if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED
+                           || tags.is_deleted) {

                                /* YAFFS1 only...
                                 * A deleted chunk
                                 */
                                /* YAFFS1 only...
                                 * A deleted chunk
                                 */


@@ -138,7 +136,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
                                }
 
 
                                }
 

-                               dev->n_free_chunks += (dev->param.chunks_per_block - c);
+                               dev->n_free_chunks +=
+                                   (dev->param.chunks_per_block - c);

                        } else if (tags.chunk_id > 0) {
                                /* chunk_id > 0 so it is a data chunk... */
                                unsigned int endpos;
                        } else if (tags.chunk_id > 0) {
                                /* chunk_id > 0 so it is a data chunk... */
                                unsigned int endpos;


@@ -147,9 +146,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                bi->pages_in_use++;
 
                                in = yaffs_find_or_create_by_number(dev,
                                bi->pages_in_use++;
 
                                in = yaffs_find_or_create_by_number(dev,

-                                                                     tags.
-                                                                     obj_id,
-                                                                     YAFFS_OBJECT_TYPE_FILE);
+                                                                   tags.obj_id,
+                                                                   YAFFS_OBJECT_TYPE_FILE);

                                /* PutChunkIntoFile checks for a clash (two data chunks with
                                 * the same chunk_id).
                                 */
                                /* PutChunkIntoFile checks for a clash (two data chunks with
                                 * the same chunk_id).
                                 */


@@ -158,24 +156,27 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                        alloc_failed = 1;
 
                                if (in) {
                                        alloc_failed = 1;
 
                                if (in) {

-                                       if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, 1))
+                                       if (!yaffs_put_chunk_in_file
+                                           (in, tags.chunk_id, chunk, 1))

                                                alloc_failed = 1;
                                }
 
                                endpos =
                                                alloc_failed = 1;
                                }
 
                                endpos =

-                                   (tags.chunk_id - 1) * dev->data_bytes_per_chunk +
+                                   (tags.chunk_id -
+                                    1) * dev->data_bytes_per_chunk +

                                    tags.n_bytes;
                                    tags.n_bytes;

-                               if (in &&
-                                   in->variant_type == YAFFS_OBJECT_TYPE_FILE
+                               if (in
+                                   && in->variant_type ==
+                                   YAFFS_OBJECT_TYPE_FILE

                                    && in->variant.file_variant.scanned_size <
                                    endpos) {
                                    && in->variant.file_variant.scanned_size <
                                    endpos) {

-                                       in->variant.file_variant.
-                                           scanned_size = endpos;
+                                       in->variant.file_variant.scanned_size =
+                                           endpos;

                                        if (!dev->param.use_header_file_size) {
                                        if (!dev->param.use_header_file_size) {

-                                               in->variant.file_variant.
-                                                   file_size =
-                                                   in->variant.file_variant.
-                                                   scanned_size;
+                                               in->variant.
+                                                   file_variant.file_size =
+                                                   in->variant.
+                                                   file_variant.scanned_size;

                                        }
 
                                }
                                        }
 
                                }


@@ -188,13 +189,12 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                bi->pages_in_use++;
 
                                result = yaffs_rd_chunk_tags_nand(dev, chunk,
                                bi->pages_in_use++;
 
                                result = yaffs_rd_chunk_tags_nand(dev, chunk,

-                                                               chunk_data,
-                                                               NULL);
+                                                                 chunk_data,
+                                                                 NULL);

 
 

-                               oh = (struct yaffs_obj_hdr *) chunk_data;
+                               oh = (struct yaffs_obj_hdr *)chunk_data;

 
 

-                               in = yaffs_find_by_number(dev,
-                                                             tags.obj_id);
+                               in = yaffs_find_by_number(dev, tags.obj_id);

                                if (in && in->variant_type != oh->type) {
                                        /* This should not happen, but somehow
                                         * Wev'e ended up with an obj_id that has been reused but not yet
                                if (in && in->variant_type != oh->type) {
                                        /* This should not happen, but somehow
                                         * Wev'e ended up with an obj_id that has been reused but not yet


@@ -207,9 +207,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                }
 
                                in = yaffs_find_or_create_by_number(dev,
                                }
 
                                in = yaffs_find_or_create_by_number(dev,

-                                                                     tags.
-                                                                     obj_id,
-                                                                     oh->type);
+                                                                   tags.obj_id,
+                                                                   oh->type);

 
                                if (!in)
                                        alloc_failed = 1;
 
                                if (!in)
                                        alloc_failed = 1;


@@ -217,16 +216,21 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                if (in && oh->shadows_obj > 0) {
 
                                        struct yaffs_shadow_fixer *fixer;
                                if (in && oh->shadows_obj > 0) {
 
                                        struct yaffs_shadow_fixer *fixer;

-                                       fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer));
+                                       fixer =
+                                           YMALLOC(sizeof
+                                                   (struct
+                                                    yaffs_shadow_fixer));

                                        if (fixer) {
                                                fixer->next = shadow_fixers;
                                                shadow_fixers = fixer;
                                                fixer->obj_id = tags.obj_id;
                                        if (fixer) {
                                                fixer->next = shadow_fixers;
                                                shadow_fixers = fixer;
                                                fixer->obj_id = tags.obj_id;

-                                               fixer->shadowed_id = oh->shadows_obj;
+                                               fixer->shadowed_id =
+                                                   oh->shadows_obj;

                                                T(YAFFS_TRACE_SCAN,
                                                  (TSTR
                                                T(YAFFS_TRACE_SCAN,
                                                  (TSTR

-                                                  (" Shadow fixer: %d shadows %d" TENDSTR),
-                                                  fixer->obj_id, fixer->shadowed_id));
+                                                  (" Shadow fixer: %d shadows %d"
+                                                   TENDSTR), fixer->obj_id,
+                                                  fixer->shadowed_id));

 
                                        }
 
 
                                        }
 


@@ -236,24 +240,27 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                        /* We have already filled this one. We have a duplicate and need to resolve it. */
 
                                        unsigned existing_serial = in->serial;
                                        /* We have already filled this one. We have a duplicate and need to resolve it. */
 
                                        unsigned existing_serial = in->serial;

-                                       unsigned new_serial = tags.serial_number;
+                                       unsigned new_serial =
+                                           tags.serial_number;

 
 

-                                       if (((existing_serial + 1) & 3) == new_serial) {
+                                       if (((existing_serial + 1) & 3) ==
+                                           new_serial) {

                                                /* Use new one - destroy the exisiting one */
                                                yaffs_chunk_del(dev,
                                                /* Use new one - destroy the exisiting one */
                                                yaffs_chunk_del(dev,

-                                                                 in->hdr_chunk,
-                                                                 1, __LINE__);
+                                                               in->hdr_chunk,
+                                                               1, __LINE__);

                                                in->valid = 0;
                                        } else {
                                                /* Use existing - destroy this one. */
                                                yaffs_chunk_del(dev, chunk, 1,
                                                in->valid = 0;
                                        } else {
                                                /* Use existing - destroy this one. */
                                                yaffs_chunk_del(dev, chunk, 1,

-                                                                 __LINE__);
+                                                               __LINE__);

                                        }
                                }
 
                                if (in && !in->valid &&
                                    (tags.obj_id == YAFFS_OBJECTID_ROOT ||
                                        }
                                }
 
                                if (in && !in->valid &&
                                    (tags.obj_id == YAFFS_OBJECTID_ROOT ||

-                                    tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) {
+                                    tags.obj_id ==
+                                    YAFFS_OBJECTID_LOSTNFOUND)) {

                                        /* We only load some info, don't fiddle with directory structure */
                                        in->valid = 1;
                                        in->variant_type = oh->type;
                                        /* We only load some info, don't fiddle with directory structure */
                                        in->valid = 1;
                                        in->variant_type = oh->type;


@@ -291,12 +298,13 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                            YAFFS_OBJECT_TYPE_UNKNOWN) {
                                                /* Set up as a directory */
                                                parent->variant_type =
                                            YAFFS_OBJECT_TYPE_UNKNOWN) {
                                                /* Set up as a directory */
                                                parent->variant_type =

-                                                       YAFFS_OBJECT_TYPE_DIRECTORY;
-                                               INIT_LIST_HEAD(&parent->variant.
-                                                               dir_variant.
-                                                               children);
-                                       } else if (!parent || parent->variant_type !=
-                                                  YAFFS_OBJECT_TYPE_DIRECTORY) {
+                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
+                                               INIT_LIST_HEAD(&parent->
+                                                              variant.dir_variant.children);
+                                       } else if (!parent
+                                                  || parent->variant_type !=
+                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
+                                       {

                                                /* Hoosterman, another problem....
                                                 * We're trying to use a non-directory as a directory
                                                 */
                                                /* Hoosterman, another problem....
                                                 * We're trying to use a non-directory as a directory
                                                 */


@@ -311,7 +319,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                        yaffs_add_obj_to_dir(parent, in);
 
                                        if (0 && (parent == dev->del_dir ||
                                        yaffs_add_obj_to_dir(parent, in);
 
                                        if (0 && (parent == dev->del_dir ||

-                                                 parent == dev->unlinked_dir)) {
+                                                 parent ==
+                                                 dev->unlinked_dir)) {

                                                in->deleted = 1;        /* If it is unlinked at start up then it wants deleting */
                                                dev->n_deleted_files++;
                                        }
                                                in->deleted = 1;        /* If it is unlinked at start up then it wants deleting */
                                                dev->n_deleted_files++;
                                        }


@@ -327,20 +336,21 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:

-                                               if (dev->param.use_header_file_size)
+                                               if (dev->param.
+                                                   use_header_file_size)

 
 

-                                                       in->variant.file_variant.
-                                                           file_size =
-                                                           oh->file_size;
+                                                       in->variant.
+                                                           file_variant.file_size
+                                                           = oh->file_size;

 
                                                break;
                                        case YAFFS_OBJECT_TYPE_HARDLINK:
 
                                                break;
                                        case YAFFS_OBJECT_TYPE_HARDLINK:

-                                               in->variant.hardlink_variant.
-                                                       equiv_id =
-                                                       oh->equiv_id;
+                                               in->variant.
+                                                   hardlink_variant.equiv_id =
+                                                   oh->equiv_id;

                                                in->hard_links.next =
                                                in->hard_links.next =

-                                                       (struct list_head *)
-                                                       hard_list;
+                                                   (struct list_head *)
+                                                   hard_list;

                                                hard_list = in;
                                                break;
                                        case YAFFS_OBJECT_TYPE_DIRECTORY:
                                                hard_list = in;
                                                break;
                                        case YAFFS_OBJECT_TYPE_DIRECTORY:


@@ -350,9 +360,11 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                                /* Do nothing */
                                                break;
                                        case YAFFS_OBJECT_TYPE_SYMLINK:
                                                /* Do nothing */
                                                break;
                                        case YAFFS_OBJECT_TYPE_SYMLINK:

-                                               in->variant.symlink_variant.alias =
+                                               in->variant.symlink_variant.
+                                                   alias =

                                                    yaffs_clone_str(oh->alias);
                                                    yaffs_clone_str(oh->alias);

-                                               if (!in->variant.symlink_variant.alias)
+                                               if (!in->variant.
+                                                   symlink_variant.alias)

                                                        alloc_failed = 1;
                                                break;
                                        }
                                                        alloc_failed = 1;
                                                break;
                                        }


@@ -362,12 +374,12 @@ int yaffs1_scan(struct yaffs_dev *dev)
                }
 
                if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
                }
 
                if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {

-                       /* If we got this far while scanning, then the block is fully allocated.*/
+                       /* If we got this far while scanning, then the block is fully allocated. */

                        state = YAFFS_BLOCK_STATE_FULL;
                }
 
                if (state == YAFFS_BLOCK_STATE_ALLOCATING) {
                        state = YAFFS_BLOCK_STATE_FULL;
                }
 
                if (state == YAFFS_BLOCK_STATE_ALLOCATING) {

-                       /* If the block was partially allocated then treat it as fully allocated.*/
+                       /* If the block was partially allocated then treat it as fully allocated. */

                        state = YAFFS_BLOCK_STATE_FULL;
                        dev->alloc_block = -1;
                }
                        state = YAFFS_BLOCK_STATE_FULL;
                        dev->alloc_block = -1;
                }


@@ -383,7 +395,6 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
        }
 
 
        }
 

-

        /* Ok, we've done all the scanning.
         * Fix up the hard link chains.
         * We should now have scanned all the objects, now it's time to add these
        /* Ok, we've done all the scanning.
         * Fix up the hard link chains.
         * We should now have scanned all the objects, now it's time to add these


@@ -423,7 +434,5 @@ int yaffs1_scan(struct yaffs_dev *dev)
 
        T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR)));
 
 
        T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR)));
 

-

        return YAFFS_OK;
 }
        return YAFFS_OK;
 }

-

diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c
index debb56d98bd931b15c8309a0532ca3e273cb87d4..97dac454f34cf3b8ed4649eae8e8f56a1d2b3e52 100644 (file)
--- a/yaffs_yaffs2.c
+++ b/yaffs_yaffs2.c
@@ -11,7 +11,6 @@
  * published by the Free Software Foundation.
  */
 
  * published by the Free Software Foundation.
  */
 

-

 #include "yaffs_guts.h"
 #include "yaffs_trace.h"
 #include "yaffs_yaffs2.h"
 #include "yaffs_guts.h"
 #include "yaffs_trace.h"
 #include "yaffs_yaffs2.h"


@@ -32,11 +31,10 @@
 
 #define YAFFS_SMALL_HOLE_THRESHOLD 4
 
 
 #define YAFFS_SMALL_HOLE_THRESHOLD 4
 

-

 /*
  * Oldest Dirty Sequence Number handling.
  */
 /*
  * Oldest Dirty Sequence Number handling.
  */

- 
+

 /* yaffs_calc_oldest_dirty_seq()
  * yaffs2_find_oldest_dirty_seq()
  * Calculate the oldest dirty sequence number if we don't know it.
 /* yaffs_calc_oldest_dirty_seq()
  * yaffs2_find_oldest_dirty_seq()
  * Calculate the oldest dirty sequence number if we don't know it.


@@ -48,7 +46,7 @@ void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
        unsigned block_no = 0;
        struct yaffs_block_info *b;
 
        unsigned block_no = 0;
        struct yaffs_block_info *b;
 

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return;
 
        /* Find the oldest dirty sequence number. */
                return;
 
        /* Find the oldest dirty sequence number. */


@@ -56,28 +54,27 @@ void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
        b = dev->block_info;
        for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
                if (b->block_state == YAFFS_BLOCK_STATE_FULL &&
        b = dev->block_info;
        for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
                if (b->block_state == YAFFS_BLOCK_STATE_FULL &&

-                       (b->pages_in_use - b->soft_del_pages) < dev->param.chunks_per_block &&
-                       b->seq_number < seq) {
+                   (b->pages_in_use - b->soft_del_pages) <
+                   dev->param.chunks_per_block && b->seq_number < seq) {

                        seq = b->seq_number;
                        block_no = i;
                }
                b++;
        }
 
                        seq = b->seq_number;
                        block_no = i;
                }
                b++;
        }
 

-       if(block_no){
+       if (block_no) {

                dev->oldest_dirty_seq = seq;
                dev->oldest_dirty_block = block_no;
        }
 
 }
 
                dev->oldest_dirty_seq = seq;
                dev->oldest_dirty_block = block_no;
        }
 
 }
 

-

 void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
 {
 void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
 {

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return;
 
                return;
 

-       if(!dev->oldest_dirty_seq)
+       if (!dev->oldest_dirty_seq)

                yaffs_calc_oldest_dirty_seq(dev);
 }
 
                yaffs_calc_oldest_dirty_seq(dev);
 }
 


@@ -87,13 +84,14 @@ void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
  * becomes invalid). If the value matches the oldest then we clear 
  * dev->oldest_dirty_seq to force its recomputation.
  */
  * becomes invalid). If the value matches the oldest then we clear 
  * dev->oldest_dirty_seq to force its recomputation.
  */

-void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *bi)
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev,
+                                  struct yaffs_block_info *bi)

 {
 
 {
 

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return;
 
                return;
 

-       if(!bi || bi->seq_number == dev->oldest_dirty_seq){
+       if (!bi || bi->seq_number == dev->oldest_dirty_seq) {

                dev->oldest_dirty_seq = 0;
                dev->oldest_dirty_block = 0;
        }
                dev->oldest_dirty_seq = 0;
                dev->oldest_dirty_block = 0;
        }


@@ -104,21 +102,21 @@ void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_inf
  * Update the oldest dirty sequence number whenever we dirty a block.
  * Only do this if the oldest_dirty_seq is actually being tracked.
  */
  * Update the oldest dirty sequence number whenever we dirty a block.
  * Only do this if the oldest_dirty_seq is actually being tracked.
  */

-void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi)
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no,
+                                   struct yaffs_block_info *bi)

 {
 {

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return;
 
                return;
 

-       if(dev->oldest_dirty_seq){
-               if(dev->oldest_dirty_seq > bi->seq_number){
+       if (dev->oldest_dirty_seq) {
+               if (dev->oldest_dirty_seq > bi->seq_number) {

                        dev->oldest_dirty_seq = bi->seq_number;
                        dev->oldest_dirty_block = block_no;
                }
        }
 }
 
                        dev->oldest_dirty_seq = bi->seq_number;
                        dev->oldest_dirty_block = block_no;
                }
        }
 }
 

-int yaffs_block_ok_for_gc(struct yaffs_dev *dev,
-                                       struct yaffs_block_info *bi)
+int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi)

 {
 
        if (!dev->param.is_yaffs2)
 {
 
        if (!dev->param.is_yaffs2)


@@ -140,32 +138,32 @@ int yaffs_block_ok_for_gc(struct yaffs_dev *dev,
  * periodically finds the oldest full block by sequence number for refreshing.
  * Only for yaffs2.
  */
  * periodically finds the oldest full block by sequence number for refreshing.
  * Only for yaffs2.
  */

-u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
+u32 yaffs2_find_refresh_block(struct yaffs_dev * dev)

 {
 {

-       u32 b ;
+       u32 b;

 
        u32 oldest = 0;
        u32 oldest_seq = 0;
 
        struct yaffs_block_info *bi;
 
 
        u32 oldest = 0;
        u32 oldest_seq = 0;
 
        struct yaffs_block_info *bi;
 

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return oldest;
 
        /*
         * If refresh period < 10 then refreshing is disabled.
         */
                return oldest;
 
        /*
         * If refresh period < 10 then refreshing is disabled.
         */

-       if(dev->param.refresh_period < 10)
-               return oldest;
+       if (dev->param.refresh_period < 10)
+               return oldest;

 
 

-        /*
-         * Fix broken values.
-         */
-        if(dev->refresh_skip > dev->param.refresh_period)
-                dev->refresh_skip = dev->param.refresh_period;
+       /*
+        * Fix broken values.
+        */
+       if (dev->refresh_skip > dev->param.refresh_period)
+               dev->refresh_skip = dev->param.refresh_period;

 
 

-       if(dev->refresh_skip > 0)
-               return oldest;
+       if (dev->refresh_skip > 0)
+               return oldest;

 
        /*
         * Refresh skip is now zero.
 
        /*
         * Refresh skip is now zero.


@@ -175,23 +173,23 @@ u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
        dev->refresh_skip = dev->param.refresh_period;
        dev->refresh_count++;
        bi = dev->block_info;
        dev->refresh_skip = dev->param.refresh_period;
        dev->refresh_count++;
        bi = dev->block_info;

-       for (b = dev->internal_start_block; b <=dev->internal_end_block; b++){
+       for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) {

 
 

-               if (bi->block_state == YAFFS_BLOCK_STATE_FULL){
+               if (bi->block_state == YAFFS_BLOCK_STATE_FULL) {

 
 

-                       if(oldest < 1 ||
-                                bi->seq_number < oldest_seq){
-                                oldest = b;
-                                oldest_seq = bi->seq_number;
-                        }
+                       if (oldest < 1 || bi->seq_number < oldest_seq) {
+                               oldest = b;
+                               oldest_seq = bi->seq_number;
+                       }

                }
                bi++;
        }
 
        if (oldest > 0) {
                T(YAFFS_TRACE_GC,
                }
                bi++;
        }
 
        if (oldest > 0) {
                T(YAFFS_TRACE_GC,

-                 (TSTR("GC refresh count %d selected block %d with seq_number %d" TENDSTR),
-                  dev->refresh_count, oldest, oldest_seq));
+                 (TSTR
+                  ("GC refresh count %d selected block %d with seq_number %d"
+                   TENDSTR), dev->refresh_count, oldest, oldest_seq));

        }
 
        return oldest;
        }
 
        return oldest;


@@ -200,56 +198,59 @@ u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
 int yaffs2_checkpt_required(struct yaffs_dev *dev)
 {
        int nblocks;
 int yaffs2_checkpt_required(struct yaffs_dev *dev)
 {
        int nblocks;

-       
-       if(!dev->param.is_yaffs2)
+
+       if (!dev->param.is_yaffs2)

                return 0;
                return 0;

-       
-       nblocks = dev->internal_end_block - dev->internal_start_block + 1 ;

 
 

-       return  !dev->param.skip_checkpt_wr &&
-               !dev->read_only &&
-               (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);
+       nblocks = dev->internal_end_block - dev->internal_start_block + 1;
+
+       return !dev->param.skip_checkpt_wr &&
+           !dev->read_only && (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);

 }
 
 int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev)
 {
        int retval;
 
 }
 
 int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev)
 {
        int retval;
 

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return 0;
 
                return 0;
 

-       if (!dev->checkpoint_blocks_required &&
-               yaffs2_checkpt_required(dev)){
+       if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)) {

                /* Not a valid value so recalculate */
                int n_bytes = 0;
                int n_blocks;
                /* Not a valid value so recalculate */
                int n_bytes = 0;
                int n_blocks;

-               int dev_blocks = (dev->param.end_block - dev->param.start_block + 1);
+               int dev_blocks =
+                   (dev->param.end_block - dev->param.start_block + 1);

 
                n_bytes += sizeof(struct yaffs_checkpt_validity);
                n_bytes += sizeof(struct yaffs_checkpt_dev);
                n_bytes += dev_blocks * sizeof(struct yaffs_block_info);
                n_bytes += dev_blocks * dev->chunk_bit_stride;
 
                n_bytes += sizeof(struct yaffs_checkpt_validity);
                n_bytes += sizeof(struct yaffs_checkpt_dev);
                n_bytes += dev_blocks * sizeof(struct yaffs_block_info);
                n_bytes += dev_blocks * dev->chunk_bit_stride;

-               n_bytes += (sizeof(struct yaffs_checkpt_obj) + sizeof(u32)) * (dev->n_obj);
+               n_bytes +=
+                   (sizeof(struct yaffs_checkpt_obj) +
+                    sizeof(u32)) * (dev->n_obj);

                n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes);
                n_bytes += sizeof(struct yaffs_checkpt_validity);
                n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes);
                n_bytes += sizeof(struct yaffs_checkpt_validity);

-               n_bytes += sizeof(u32); /* checksum*/
+               n_bytes += sizeof(u32); /* checksum */

 
                /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
 
 
                /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
 

-               n_blocks = (n_bytes/(dev->data_bytes_per_chunk * dev->param.chunks_per_block)) + 3;
+               n_blocks =
+                   (n_bytes /
+                    (dev->data_bytes_per_chunk *
+                     dev->param.chunks_per_block)) + 3;

 
                dev->checkpoint_blocks_required = n_blocks;
        }
 
        retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt;
 
                dev->checkpoint_blocks_required = n_blocks;
        }
 
        retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt;

-       if(retval < 0)
+       if (retval < 0)

                retval = 0;
        return retval;
 }
 
 /*--------------------- Checkpointing --------------------*/
 
                retval = 0;
        return retval;
 }
 
 /*--------------------- Checkpointing --------------------*/
 

-

 static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
 {
        struct yaffs_checkpt_validity cp;
 static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
 {
        struct yaffs_checkpt_validity cp;


@@ -261,8 +262,7 @@ static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
        cp.version = YAFFS_CHECKPOINT_VERSION;
        cp.head = (head) ? 1 : 0;
 
        cp.version = YAFFS_CHECKPOINT_VERSION;
        cp.head = (head) ? 1 : 0;
 

-       return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ?
-               1 : 0;
+       return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? 1 : 0;

 }
 
 static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head)
 }
 
 static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head)


@@ -274,14 +274,14 @@ static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head)
 
        if (ok)
                ok = (cp.struct_type == sizeof(cp)) &&
 
        if (ok)
                ok = (cp.struct_type == sizeof(cp)) &&

-                    (cp.magic == YAFFS_MAGIC) &&
-                    (cp.version == YAFFS_CHECKPOINT_VERSION) &&
-                    (cp.head == ((head) ? 1 : 0));
+                   (cp.magic == YAFFS_MAGIC) &&
+                   (cp.version == YAFFS_CHECKPOINT_VERSION) &&
+                   (cp.head == ((head) ? 1 : 0));

        return ok ? 1 : 0;
 }
 
 static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,
        return ok ? 1 : 0;
 }
 
 static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,

-                                          struct yaffs_dev *dev)
+                                     struct yaffs_dev *dev)

 {
        cp->n_erased_blocks = dev->n_erased_blocks;
        cp->alloc_block = dev->alloc_block;
 {
        cp->n_erased_blocks = dev->n_erased_blocks;
        cp->alloc_block = dev->alloc_block;


@@ -296,7 +296,7 @@ static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,
 }
 
 static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
 }
 
 static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,

-                                  struct yaffs_checkpt_dev *cp)
+                                    struct yaffs_checkpt_dev *cp)

 {
        dev->n_erased_blocks = cp->n_erased_blocks;
        dev->alloc_block = cp->alloc_block;
 {
        dev->n_erased_blocks = cp->n_erased_blocks;
        dev->alloc_block = cp->alloc_block;


@@ -309,16 +309,16 @@ static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
        dev->seq_number = cp->seq_number;
 }
 
        dev->seq_number = cp->seq_number;
 }
 

-

 static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
 {
        struct yaffs_checkpt_dev cp;
        u32 n_bytes;
 static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
 {
        struct yaffs_checkpt_dev cp;
        u32 n_bytes;

-       u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
+       u32 n_blocks =
+           (dev->internal_end_block - dev->internal_start_block + 1);

 
        int ok;
 
 
        int ok;
 

-       /* Write device runtime values*/
+       /* Write device runtime values */

        yaffs2_dev_to_checkpt_dev(&cp, dev);
        cp.struct_type = sizeof(cp);
 
        yaffs2_dev_to_checkpt_dev(&cp, dev);
        cp.struct_type = sizeof(cp);
 


@@ -327,15 +327,17 @@ static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
        /* Write block info */
        if (ok) {
                n_bytes = n_blocks * sizeof(struct yaffs_block_info);
        /* Write block info */
        if (ok) {
                n_bytes = n_blocks * sizeof(struct yaffs_block_info);

-               ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes);
+               ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) ==
+                     n_bytes);

        }
 
        /* Write chunk bits */
        if (ok) {
                n_bytes = n_blocks * dev->chunk_bit_stride;
        }
 
        /* Write chunk bits */
        if (ok) {
                n_bytes = n_blocks * dev->chunk_bit_stride;

-               ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == n_bytes);
+               ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) ==
+                     n_bytes);

        }
        }

-       return   ok ? 1 : 0;
+       return ok ? 1 : 0;

 
 }
 
 
 }
 


@@ -343,7 +345,8 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
 {
        struct yaffs_checkpt_dev cp;
        u32 n_bytes;
 {
        struct yaffs_checkpt_dev cp;
        u32 n_bytes;

-       u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
+       u32 n_blocks =
+           (dev->internal_end_block - dev->internal_start_block + 1);

 
        int ok;
 
 
        int ok;
 


@@ -354,7 +357,6 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
        if (cp.struct_type != sizeof(cp))
                return 0;
 
        if (cp.struct_type != sizeof(cp))
                return 0;
 

-

        yaffs_checkpt_dev_to_dev(dev, &cp);
 
        n_bytes = n_blocks * sizeof(struct yaffs_block_info);
        yaffs_checkpt_dev_to_dev(dev, &cp);
 
        n_bytes = n_blocks * sizeof(struct yaffs_block_info);


@@ -371,7 +373,7 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
 }
 
 static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
 }
 
 static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,

-                                          struct yaffs_obj *obj)
+                                  struct yaffs_obj *obj)

 {
 
        cp->obj_id = obj->obj_id;
 {
 
        cp->obj_id = obj->obj_id;


@@ -393,36 +395,40 @@ static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
                cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
 }
 
                cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
 }
 

-static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt_obj *cp)
+static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj,
+                                    struct yaffs_checkpt_obj *cp)

 {
 
        struct yaffs_obj *parent;
 
        if (obj->variant_type != cp->variant_type) {
                T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "
 {
 
        struct yaffs_obj *parent;
 
        if (obj->variant_type != cp->variant_type) {
                T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "

-                       TCONT("chunk %d does not match existing object type %d")
-                       TENDSTR), cp->obj_id, cp->variant_type, cp->hdr_chunk,
-                       obj->variant_type));
+                                          TCONT
+                                          ("chunk %d does not match existing object type %d")
+                                          TENDSTR), cp->obj_id,
+                                     cp->variant_type, cp->hdr_chunk,
+                                     obj->variant_type));

                return 0;
        }
 
        obj->obj_id = cp->obj_id;
 
        if (cp->parent_id)
                return 0;
        }
 
        obj->obj_id = cp->obj_id;
 
        if (cp->parent_id)

-               parent = yaffs_find_or_create_by_number(
-                                       obj->my_dev,
-                                       cp->parent_id,
-                                       YAFFS_OBJECT_TYPE_DIRECTORY);
+               parent = yaffs_find_or_create_by_number(obj->my_dev,
+                                                       cp->parent_id,
+                                                       YAFFS_OBJECT_TYPE_DIRECTORY);

        else
                parent = NULL;
 
        if (parent) {
                if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
        else
                parent = NULL;
 
        if (parent) {
                if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {

-                       T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d"
-                               TCONT(" chunk %d Parent type, %d, not directory")
-                               TENDSTR),
-                               cp->obj_id, cp->parent_id, cp->variant_type,
-                               cp->hdr_chunk, parent->variant_type));
+                       T(YAFFS_TRACE_ALWAYS,
+                         (TSTR
+                          ("Checkpoint read object %d parent %d type %d"
+                           TCONT(" chunk %d Parent type, %d, not directory")
+                           TENDSTR), cp->obj_id, cp->parent_id,
+                          cp->variant_type, cp->hdr_chunk,
+                          parent->variant_type));

                        return 0;
                }
                yaffs_add_obj_to_dir(parent, obj);
                        return 0;
                }
                yaffs_add_obj_to_dir(parent, obj);


@@ -449,10 +455,9 @@ static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt
        return 1;
 }
 
        return 1;
 }
 

-
-
-static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
-                                       u32 level, int chunk_offset)
+static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in,
+                                      struct yaffs_tnode *tn, u32 level,
+                                      int chunk_offset)

 {
        int i;
        struct yaffs_dev *dev = in->my_dev;
 {
        int i;
        struct yaffs_dev *dev = in->my_dev;


@@ -464,17 +469,27 @@ static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode
                        for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
                                if (tn->internal[i]) {
                                        ok = yaffs2_checkpt_tnode_worker(in,
                        for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
                                if (tn->internal[i]) {
                                        ok = yaffs2_checkpt_tnode_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);

                                }
                        }
                } else if (level == 0) {
                                }
                        }
                } else if (level == 0) {

-                       u32 base_offset = chunk_offset <<  YAFFS_TNODES_LEVEL0_BITS;
-                       ok = (yaffs2_checkpt_wr(dev, &base_offset, sizeof(base_offset)) == 
-                               sizeof(base_offset));
+                       u32 base_offset =
+                           chunk_offset << YAFFS_TNODES_LEVEL0_BITS;
+                       ok = (yaffs2_checkpt_wr
+                             (dev, &base_offset,
+                              sizeof(base_offset)) == sizeof(base_offset));

                        if (ok)
                        if (ok)

-                               ok = (yaffs2_checkpt_wr(dev, tn, dev->tnode_size) == dev->tnode_size);
+                               ok = (yaffs2_checkpt_wr
+                                     (dev, tn,
+                                      dev->tnode_size) == dev->tnode_size);

                }
        }
 
                }
        }
 


@@ -489,12 +504,13 @@ static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj)
 
        if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
                ok = yaffs2_checkpt_tnode_worker(obj,
 
        if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
                ok = yaffs2_checkpt_tnode_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);

                if (ok)
                if (ok)

-                       ok = (yaffs2_checkpt_wr(obj->my_dev, &end_marker, sizeof(end_marker)) ==
-                               sizeof(end_marker));
+                       ok = (yaffs2_checkpt_wr
+                             (obj->my_dev, &end_marker,
+                              sizeof(end_marker)) == sizeof(end_marker));

        }
 
        return ok ? 1 : 0;
        }
 
        return ok ? 1 : 0;


@@ -509,38 +525,39 @@ static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj)
        struct yaffs_tnode *tn;
        int nread = 0;
 
        struct yaffs_tnode *tn;
        int nread = 0;
 

-       ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk));
+       ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) ==
+             sizeof(base_chunk));

 
        while (ok && (~base_chunk)) {
                nread++;
                /* Read level 0 tnode */
 
 
        while (ok && (~base_chunk)) {
                nread++;
                /* Read level 0 tnode */
 

-

                tn = yaffs_get_tnode(dev);
                tn = yaffs_get_tnode(dev);

-               if (tn){
-                       ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == dev->tnode_size);
+               if (tn) {
+                       ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) ==
+                             dev->tnode_size);

                } else
                        ok = 0;
 
                if (tn && ok)
                        ok = yaffs_add_find_tnode_0(dev,
                } else
                        ok = 0;
 
                if (tn && ok)
                        ok = yaffs_add_find_tnode_0(dev,

-                                                       file_stuct_ptr,
-                                                       base_chunk,
-                                                       tn) ? 1 : 0;
+                                                   file_stuct_ptr,
+                                                   base_chunk, tn) ? 1 : 0;

 
                if (ok)
 
                if (ok)

-                       ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk));
+                       ok = (yaffs2_checkpt_rd
+                             (dev, &base_chunk,
+                              sizeof(base_chunk)) == sizeof(base_chunk));

 
        }
 
 
        }
 

-       T(YAFFS_TRACE_CHECKPOINT, (
-               TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
-               nread, base_chunk, ok));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
+          nread, base_chunk, ok));

 
        return ok ? 1 : 0;
 }
 
 
        return ok ? 1 : 0;
 }
 

-

 static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
 {
        struct yaffs_obj *obj;
 static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
 {
        struct yaffs_obj *obj;


@@ -549,27 +566,34 @@ static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
        int ok = 1;
        struct list_head *lh;
 
        int ok = 1;
        struct list_head *lh;
 

-

        /* Iterate through the objects in each hash entry,
         * dumping them to the checkpointing stream.
         */
 
        /* Iterate through the objects in each hash entry,
         * dumping them to the checkpointing stream.
         */
 

-       for (i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++) {
+       for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) {

                list_for_each(lh, &dev->obj_bucket[i].list) {
                        if (lh) {
                list_for_each(lh, &dev->obj_bucket[i].list) {
                        if (lh) {

-                               obj = list_entry(lh, struct yaffs_obj, hash_link);
+                               obj =
+                                   list_entry(lh, struct yaffs_obj, hash_link);

                                if (!obj->defered_free) {
                                        yaffs2_obj_checkpt_obj(&cp, obj);
                                        cp.struct_type = sizeof(cp);
 
                                if (!obj->defered_free) {
                                        yaffs2_obj_checkpt_obj(&cp, obj);
                                        cp.struct_type = sizeof(cp);
 

-                                       T(YAFFS_TRACE_CHECKPOINT, (
-                                               TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR),
-                                               cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk, obj));
-
-                                       ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp));
-
-                                       if (ok && obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
-                                               ok = yaffs2_wr_checkpt_tnodes(obj);
+                                       T(YAFFS_TRACE_CHECKPOINT,
+                                         (TSTR
+                                          ("Checkpoint write object %d parent %d type %d chunk %d obj addr %p"
+                                           TENDSTR), cp.obj_id, cp.parent_id,
+                                          cp.variant_type, cp.hdr_chunk, obj));
+
+                                       ok = (yaffs2_checkpt_wr
+                                             (dev, &cp,
+                                              sizeof(cp)) == sizeof(cp));
+
+                                       if (ok
+                                           && obj->variant_type ==
+                                           YAFFS_OBJECT_TYPE_FILE)
+                                               ok = yaffs2_wr_checkpt_tnodes
+                                                   (obj);

                                }
                        }
                }
                                }
                        }
                }


@@ -596,27 +620,34 @@ static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
        while (ok && !done) {
                ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
                if (cp.struct_type != sizeof(cp)) {
        while (ok && !done) {
                ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
                if (cp.struct_type != sizeof(cp)) {

-                       T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR),
-                               cp.struct_type, (int)sizeof(cp), ok));
+                       T(YAFFS_TRACE_CHECKPOINT,
+                         (TSTR("struct size %d instead of %d ok %d" TENDSTR),
+                          cp.struct_type, (int)sizeof(cp), ok));

                        ok = 0;
                }
 
                        ok = 0;
                }
 

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
-                       cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR
+                  ("Checkpoint read object %d parent %d type %d chunk %d "
+                   TENDSTR), cp.obj_id, cp.parent_id, cp.variant_type,
+                  cp.hdr_chunk));

 
                if (ok && cp.obj_id == ~0)
                        done = 1;
                else if (ok) {
 
                if (ok && cp.obj_id == ~0)
                        done = 1;
                else if (ok) {

-                       obj = yaffs_find_or_create_by_number(dev, cp.obj_id, cp.variant_type);
+                       obj =
+                           yaffs_find_or_create_by_number(dev, cp.obj_id,
+                                                          cp.variant_type);

                        if (obj) {
                                ok = taffs2_checkpt_obj_to_obj(obj, &cp);
                                if (!ok)
                                        break;
                                if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
                                        ok = yaffs2_rd_checkpt_tnodes(obj);
                        if (obj) {
                                ok = taffs2_checkpt_obj_to_obj(obj, &cp);
                                if (!ok)
                                        break;
                                if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
                                        ok = yaffs2_rd_checkpt_tnodes(obj);

-                               } else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) {
+                               } else if (obj->variant_type ==
+                                          YAFFS_OBJECT_TYPE_HARDLINK) {

                                        obj->hard_links.next =
                                        obj->hard_links.next =

-                                               (struct list_head *) hard_list;
+                                           (struct list_head *)hard_list;

                                        hard_list = obj;
                                }
                        } else
                                        hard_list = obj;
                                }
                        } else


@@ -637,7 +668,8 @@ static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev)
 
        yaffs2_get_checkpt_sum(dev, &checkpt_sum);
 
 
        yaffs2_get_checkpt_sum(dev, &checkpt_sum);
 

-       ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == sizeof(checkpt_sum));
+       ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) ==
+             sizeof(checkpt_sum));

 
        if (!ok)
                return 0;
 
        if (!ok)
                return 0;


@@ -653,7 +685,8 @@ static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev)
 
        yaffs2_get_checkpt_sum(dev, &checkpt_sum0);
 
 
        yaffs2_get_checkpt_sum(dev, &checkpt_sum0);
 

-       ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == sizeof(checkpt_sum1));
+       ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) ==
+             sizeof(checkpt_sum1));

 
        if (!ok)
                return 0;
 
        if (!ok)
                return 0;


@@ -664,13 +697,13 @@ static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev)
        return 1;
 }
 
        return 1;
 }
 

-

 static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
 {
        int ok = 1;
 
        if (!yaffs2_checkpt_required(dev)) {
 static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
 {
        int ok = 1;
 
        if (!yaffs2_checkpt_required(dev)) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("skipping checkpoint write" TENDSTR)));

                ok = 0;
        }
 
                ok = 0;
        }
 


@@ -678,19 +711,23 @@ static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
                ok = yaffs2_checkpt_open(dev, 1);
 
        if (ok) {
                ok = yaffs2_checkpt_open(dev, 1);
 
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("write checkpoint validity" TENDSTR)));

                ok = yaffs2_wr_checkpt_validity_marker(dev, 1);
        }
        if (ok) {
                ok = yaffs2_wr_checkpt_validity_marker(dev, 1);
        }
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("write checkpoint device" TENDSTR)));

                ok = yaffs2_wr_checkpt_dev(dev);
        }
        if (ok) {
                ok = yaffs2_wr_checkpt_dev(dev);
        }
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("write checkpoint objects" TENDSTR)));

                ok = yaffs2_wr_checkpt_objs(dev);
        }
        if (ok) {
                ok = yaffs2_wr_checkpt_objs(dev);
        }
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("write checkpoint validity" TENDSTR)));

                ok = yaffs2_wr_checkpt_validity_marker(dev, 0);
        }
 
                ok = yaffs2_wr_checkpt_validity_marker(dev, 0);
        }
 


@@ -711,38 +748,44 @@ static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
 static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
 {
        int ok = 1;
 static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
 {
        int ok = 1;

-       
-       if(!dev->param.is_yaffs2)
+
+       if (!dev->param.is_yaffs2)

                ok = 0;
 
        if (ok && dev->param.skip_checkpt_rd) {
                ok = 0;
 
        if (ok && dev->param.skip_checkpt_rd) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("skipping checkpoint read" TENDSTR)));

                ok = 0;
        }
 
        if (ok)
                ok = 0;
        }
 
        if (ok)

-               ok = yaffs2_checkpt_open(dev, 0); /* open for read */
+               ok = yaffs2_checkpt_open(dev, 0);       /* open for read */

 
        if (ok) {
 
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("read checkpoint validity" TENDSTR)));

                ok = yaffs2_rd_checkpt_validity_marker(dev, 1);
        }
        if (ok) {
                ok = yaffs2_rd_checkpt_validity_marker(dev, 1);
        }
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("read checkpoint device" TENDSTR)));

                ok = yaffs2_rd_checkpt_dev(dev);
        }
        if (ok) {
                ok = yaffs2_rd_checkpt_dev(dev);
        }
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("read checkpoint objects" TENDSTR)));

                ok = yaffs2_rd_checkpt_objs(dev);
        }
        if (ok) {
                ok = yaffs2_rd_checkpt_objs(dev);
        }
        if (ok) {

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("read checkpoint validity" TENDSTR)));

                ok = yaffs2_rd_checkpt_validity_marker(dev, 0);
        }
 
        if (ok) {
                ok = yaffs2_rd_checkpt_sum(dev);
                ok = yaffs2_rd_checkpt_validity_marker(dev, 0);
        }
 
        if (ok) {
                ok = yaffs2_rd_checkpt_sum(dev);

-               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok));
+               T(YAFFS_TRACE_CHECKPOINT,
+                 (TSTR("read checkpoint checksum %d" TENDSTR), ok));

        }
 
        if (!yaffs_checkpt_close(dev))
        }
 
        if (!yaffs_checkpt_close(dev))


@@ -759,8 +802,7 @@ static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
 
 void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
 {
 
 void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
 {

-       if (dev->is_checkpointed ||
-                       dev->blocks_in_checkpt > 0) {
+       if (dev->is_checkpointed || dev->blocks_in_checkpt > 0) {

                dev->is_checkpointed = 0;
                yaffs2_checkpt_invalidate_stream(dev);
        }
                dev->is_checkpointed = 0;
                yaffs2_checkpt_invalidate_stream(dev);
        }


@@ -768,11 +810,12 @@ void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
                dev->param.sb_dirty_fn(dev);
 }
 
                dev->param.sb_dirty_fn(dev);
 }
 

-

 int yaffs_checkpoint_save(struct yaffs_dev *dev)
 {
 
 int yaffs_checkpoint_save(struct yaffs_dev *dev)
 {
 

-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("save entry: is_checkpointed %d" TENDSTR),
+          dev->is_checkpointed));

 
        yaffs_verify_objects(dev);
        yaffs_verify_blocks(dev);
 
        yaffs_verify_objects(dev);
        yaffs_verify_blocks(dev);


@@ -783,7 +826,9 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev)
                yaffs2_wr_checkpt_data(dev);
        }
 
                yaffs2_wr_checkpt_data(dev);
        }
 

-       T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
+       T(YAFFS_TRACE_ALWAYS,
+         (TSTR("save exit: is_checkpointed %d" TENDSTR),
+          dev->is_checkpointed));

 
        return dev->is_checkpointed;
 }
 
        return dev->is_checkpointed;
 }


@@ -791,7 +836,9 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev)
 int yaffs2_checkpt_restore(struct yaffs_dev *dev)
 {
        int retval;
 int yaffs2_checkpt_restore(struct yaffs_dev *dev)
 {
        int retval;

-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("restore entry: is_checkpointed %d" TENDSTR),
+          dev->is_checkpointed));

 
        retval = yaffs2_rd_checkpt_data(dev);
 
 
        retval = yaffs2_rd_checkpt_data(dev);
 


@@ -801,7 +848,9 @@ int yaffs2_checkpt_restore(struct yaffs_dev *dev)
                yaffs_verify_free_chunks(dev);
        }
 
                yaffs_verify_free_chunks(dev);
        }
 

-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
+       T(YAFFS_TRACE_CHECKPOINT,
+         (TSTR("restore exit: is_checkpointed %d" TENDSTR),
+          dev->is_checkpointed));

 
        return retval;
 }
 
        return retval;
 }


@@ -812,28 +861,27 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
         * We're going to be writing a hole.
         * If the hole is small then write zeros otherwise write a start of hole marker.
         */
         * We're going to be writing a hole.
         * If the hole is small then write zeros otherwise write a start of hole marker.
         */

-               

 
        loff_t old_file_size;
        int increase;
 
        loff_t old_file_size;
        int increase;

-       int small_hole   ;
+       int small_hole;

        int result = YAFFS_OK;
        struct yaffs_dev *dev = NULL;
 
        u8 *local_buffer = NULL;
        int result = YAFFS_OK;
        struct yaffs_dev *dev = NULL;
 
        u8 *local_buffer = NULL;

-       
+

        int small_increase_ok = 0;
        int small_increase_ok = 0;

-       
-       if(!obj)
+
+       if (!obj)

                return YAFFS_FAIL;
 
                return YAFFS_FAIL;
 

-       if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
+       if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE)

                return YAFFS_FAIL;
                return YAFFS_FAIL;

-       
+

        dev = obj->my_dev;
        dev = obj->my_dev;

-       
+

        /* Bail out if not yaffs2 mode */
        /* Bail out if not yaffs2 mode */

-       if(!dev->param.is_yaffs2)
+       if (!dev->param.is_yaffs2)

                return YAFFS_OK;
 
        old_file_size = obj->variant.file_variant.file_size;
                return YAFFS_OK;
 
        old_file_size = obj->variant.file_variant.file_size;


@@ -843,46 +891,48 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
 
        increase = new_size - old_file_size;
 
 
        increase = new_size - old_file_size;
 

-       if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk &&
-               yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1))
+       if (increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk &&
+           yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1))

                small_hole = 1;
        else
                small_hole = 0;
 
                small_hole = 1;
        else
                small_hole = 0;
 

-       if(small_hole)
-               local_buffer= yaffs_get_temp_buffer(dev, __LINE__);
-       
-       if(local_buffer){
+       if (small_hole)
+               local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
+
+       if (local_buffer) {

                /* fill hole with zero bytes */
                int pos = old_file_size;
                int this_write;
                int written;
                /* fill hole with zero bytes */
                int pos = old_file_size;
                int this_write;
                int written;

-               memset(local_buffer,0,dev->data_bytes_per_chunk);
+               memset(local_buffer, 0, dev->data_bytes_per_chunk);

                small_increase_ok = 1;
 
                small_increase_ok = 1;
 

-               while(increase > 0 && small_increase_ok){
+               while (increase > 0 && small_increase_ok) {

                        this_write = increase;
                        this_write = increase;

-                       if(this_write > dev->data_bytes_per_chunk)
+                       if (this_write > dev->data_bytes_per_chunk)

                                this_write = dev->data_bytes_per_chunk;
                                this_write = dev->data_bytes_per_chunk;

-                       written = yaffs_do_file_wr(obj,local_buffer,pos,this_write,0);
-                       if(written == this_write){
+                       written =
+                           yaffs_do_file_wr(obj, local_buffer, pos, this_write,
+                                            0);
+                       if (written == this_write) {

                                pos += this_write;
                                increase -= this_write;
                        } else
                                small_increase_ok = 0;
                }
 
                                pos += this_write;
                                increase -= this_write;
                        } else
                                small_increase_ok = 0;
                }
 

-               yaffs_release_temp_buffer(dev,local_buffer,__LINE__);
+               yaffs_release_temp_buffer(dev, local_buffer, __LINE__);

 
 

-               /* If we were out of space then reverse any chunks we've added */               
-               if(!small_increase_ok)
+               /* If we were out of space then reverse any chunks we've added */
+               if (!small_increase_ok)

                        yaffs_resize_file_down(obj, old_file_size);
        }
                        yaffs_resize_file_down(obj, old_file_size);
        }

-       
+

        if (!small_increase_ok &&
        if (!small_increase_ok &&

-               obj->parent &&
-               obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED &&
-               obj->parent->obj_id != YAFFS_OBJECTID_DELETED){
+           obj->parent &&
+           obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED &&
+           obj->parent->obj_id != YAFFS_OBJECTID_DELETED) {

                /* Write a hole start header with the old file size */
                yaffs_update_oh(obj, NULL, 0, 1, 0, NULL);
        }
                /* Write a hole start header with the old file size */
                yaffs_update_oh(obj, NULL, 0, 1, 0, NULL);
        }


@@ -891,13 +941,11 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
 
 }
 
 
 }
 

-
-struct yaffs_block_index{
+struct yaffs_block_index {

        int seq;
        int block;
 };
 
        int seq;
        int block;
 };
 

-

 static int yaffs2_ybicmp(const void *a, const void *b)
 {
        int aseq = ((struct yaffs_block_index *)a)->seq;
 static int yaffs2_ybicmp(const void *a, const void *b)
 {
        int aseq = ((struct yaffs_block_index *)a)->seq;


@@ -940,7 +988,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
        int equiv_id;
        int alloc_failed = 0;
 
        int equiv_id;
        int alloc_failed = 0;
 

-

        struct yaffs_block_index *block_index = NULL;
        int alt_block_index = 0;
 
        struct yaffs_block_index *block_index = NULL;
        int alt_block_index = 0;
 


@@ -949,19 +996,21 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
           ("yaffs2_scan_backwards starts  intstartblk %d intendblk %d..."
            TENDSTR), dev->internal_start_block, dev->internal_end_block));
 
           ("yaffs2_scan_backwards starts  intstartblk %d intendblk %d..."
            TENDSTR), dev->internal_start_block, dev->internal_end_block));
 

-

        dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
 
        block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index));
 
        if (!block_index) {
        dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
 
        block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index));
 
        if (!block_index) {

-               block_index = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index));
+               block_index =
+                   YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index));

                alt_block_index = 1;
        }
 
        if (!block_index) {
                T(YAFFS_TRACE_SCAN,
                alt_block_index = 1;
        }
 
        if (!block_index) {
                T(YAFFS_TRACE_SCAN,

-                 (TSTR("yaffs2_scan_backwards() could not allocate block index!" TENDSTR)));
+                 (TSTR
+                  ("yaffs2_scan_backwards() could not allocate block index!"
+                   TENDSTR)));

                return YAFFS_FAIL;
        }
 
                return YAFFS_FAIL;
        }
 


@@ -971,7 +1020,8 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
        /* Scan all the blocks to determine their state */
        bi = dev->block_info;
 
        /* Scan all the blocks to determine their state */
        bi = dev->block_info;

-       for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) {
+       for (blk = dev->internal_start_block; blk <= dev->internal_end_block;
+            blk++) {

                yaffs_clear_chunk_bits(dev, blk);
                bi->pages_in_use = 0;
                bi->soft_del_pages = 0;
                yaffs_clear_chunk_bits(dev, blk);
                bi->pages_in_use = 0;
                bi->soft_del_pages = 0;


@@ -990,7 +1040,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                  (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
                   state, seq_number));
 
                  (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
                   state, seq_number));
 

-

                if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
                        dev->blocks_in_checkpt++;
 
                if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
                        dev->blocks_in_checkpt++;
 


@@ -1028,14 +1077,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
        }
 
        T(YAFFS_TRACE_SCAN,
        }
 
        T(YAFFS_TRACE_SCAN,

-       (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan));
-
-
+         (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan));

 
        YYIELD();
 
 
        YYIELD();
 

-       /* Sort the blocks by sequence number*/
-       yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), yaffs2_ybicmp);
+       /* Sort the blocks by sequence number */
+       yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index),
+                  yaffs2_ybicmp);

 
        YYIELD();
 
 
        YYIELD();
 


@@ -1049,7 +1097,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
        /* For each block.... backwards */
        for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter;
 
        /* For each block.... backwards */
        for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter;

-                       block_iter--) {
+            block_iter--) {

                /* Cooperative multitasking! This loop can run for so
                   long that watchdog timers expire. */
                YYIELD();
                /* Cooperative multitasking! This loop can run for so
                   long that watchdog timers expire. */
                YYIELD();


@@ -1059,7 +1107,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                bi = yaffs_get_block_info(dev, blk);
 
 
                bi = yaffs_get_block_info(dev, blk);
 

-

                state = bi->block_state;
 
                deleted = 0;
                state = bi->block_state;
 
                deleted = 0;


@@ -1077,7 +1124,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                        chunk = blk * dev->param.chunks_per_block + c;
 
                        result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,
                        chunk = blk * dev->param.chunks_per_block + c;
 
                        result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,

-                                                       &tags);
+                                                         &tags);

 
                        /* Let's have a good look at this chunk... */
 
 
                        /* Let's have a good look at this chunk... */
 


@@ -1098,9 +1145,12 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                        state = YAFFS_BLOCK_STATE_EMPTY;
                                        dev->n_erased_blocks++;
                                } else {
                                        state = YAFFS_BLOCK_STATE_EMPTY;
                                        dev->n_erased_blocks++;
                                } else {

-                                       if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
-                                           state == YAFFS_BLOCK_STATE_ALLOCATING) {
-                                               if (dev->seq_number == bi->seq_number) {
+                                       if (state ==
+                                           YAFFS_BLOCK_STATE_NEEDS_SCANNING
+                                           || state ==
+                                           YAFFS_BLOCK_STATE_ALLOCATING) {
+                                               if (dev->seq_number ==
+                                                   bi->seq_number) {

                                                        /* this is the block being allocated from */
 
                                                        T(YAFFS_TRACE_SCAN,
                                                        /* this is the block being allocated from */
 
                                                        T(YAFFS_TRACE_SCAN,


@@ -1108,18 +1158,22 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                           (" Allocating from %d %d"
                                                            TENDSTR), blk, c));
 
                                                           (" Allocating from %d %d"
                                                            TENDSTR), blk, c));
 

-                                                       state = YAFFS_BLOCK_STATE_ALLOCATING;
+                                                       state =
+                                                           YAFFS_BLOCK_STATE_ALLOCATING;

                                                        dev->alloc_block = blk;
                                                        dev->alloc_page = c;
                                                        dev->alloc_block = blk;
                                                        dev->alloc_page = c;

-                                                       dev->alloc_block_finder = blk;
+                                                       dev->
+                                                           alloc_block_finder =
+                                                           blk;

                                                } else {
                                                        /* This is a partially written block that is not
                                                         * the current allocation block.
                                                         */
 
                                                } else {
                                                        /* This is a partially written block that is not
                                                         * the current allocation block.
                                                         */
 

-                                                        T(YAFFS_TRACE_SCAN,
-                                                        (TSTR("Partially written block %d detected" TENDSTR),
-                                                        blk));
+                                                       T(YAFFS_TRACE_SCAN,
+                                                         (TSTR
+                                                          ("Partially written block %d detected"
+                                                           TENDSTR), blk));

                                                }
                                        }
                                }
                                                }
                                        }
                                }


@@ -1128,37 +1182,40 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                        } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) {
                                T(YAFFS_TRACE_SCAN,
 
                        } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) {
                                T(YAFFS_TRACE_SCAN,

-                                 (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR),
-                                 blk, c));
+                                 (TSTR
+                                  (" Unfixed ECC in chunk(%d:%d), chunk ignored"
+                                   TENDSTR), blk, c));

 
 

-                                 dev->n_free_chunks++;
+                               dev->n_free_chunks++;

 
                        } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID ||
 
                        } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID ||

-                               tags.chunk_id > YAFFS_MAX_CHUNK_ID ||
-                               (tags.chunk_id > 0 && tags.n_bytes > dev->data_bytes_per_chunk) ||
-                               tags.seq_number != bi->seq_number ) {
+                                  tags.chunk_id > YAFFS_MAX_CHUNK_ID ||
+                                  (tags.chunk_id > 0
+                                   && tags.n_bytes > dev->data_bytes_per_chunk)
+                                  || tags.seq_number != bi->seq_number) {

                                T(YAFFS_TRACE_SCAN,
                                T(YAFFS_TRACE_SCAN,

-                                 (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored"TENDSTR),
-                                 blk, c,tags.obj_id, tags.chunk_id, tags.n_bytes));
+                                 (TSTR
+                                  ("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored"
+                                   TENDSTR), blk, c, tags.obj_id,
+                                  tags.chunk_id, tags.n_bytes));

 
 

-                                 dev->n_free_chunks++;
+                               dev->n_free_chunks++;

 
                        } else if (tags.chunk_id > 0) {
                                /* chunk_id > 0 so it is a data chunk... */
                                unsigned int endpos;
                                u32 chunk_base =
 
                        } else if (tags.chunk_id > 0) {
                                /* chunk_id > 0 so it is a data chunk... */
                                unsigned int endpos;
                                u32 chunk_base =

-                                   (tags.chunk_id - 1) * dev->data_bytes_per_chunk;
+                                   (tags.chunk_id -
+                                    1) * dev->data_bytes_per_chunk;

 
                                found_chunks = 1;
 
 
                                found_chunks = 1;
 

-

                                yaffs_set_chunk_bit(dev, blk, c);
                                bi->pages_in_use++;
 
                                in = yaffs_find_or_create_by_number(dev,
                                yaffs_set_chunk_bit(dev, blk, c);
                                bi->pages_in_use++;
 
                                in = yaffs_find_or_create_by_number(dev,

-                                                                     tags.
-                                                                     obj_id,
-                                                                     YAFFS_OBJECT_TYPE_FILE);
+                                                                   tags.obj_id,
+                                                                   YAFFS_OBJECT_TYPE_FILE);

                                if (!in) {
                                        /* Out of memory */
                                        alloc_failed = 1;
                                if (!in) {
                                        /* Out of memory */
                                        alloc_failed = 1;


@@ -1166,9 +1223,11 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                                if (in &&
                                    in->variant_type == YAFFS_OBJECT_TYPE_FILE
 
                                if (in &&
                                    in->variant_type == YAFFS_OBJECT_TYPE_FILE

-                                   && chunk_base < in->variant.file_variant.shrink_size) {
+                                   && chunk_base <
+                                   in->variant.file_variant.shrink_size) {

                                        /* This has not been invalidated by a resize */
                                        /* This has not been invalidated by a resize */

-                                       if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, -1)) {
+                                       if (!yaffs_put_chunk_in_file
+                                           (in, tags.chunk_id, chunk, -1)) {

                                                alloc_failed = 1;
                                        }
 
                                                alloc_failed = 1;
                                        }
 


@@ -1178,15 +1237,19 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                        endpos = chunk_base + tags.n_bytes;
 
                                        if (!in->valid &&       /* have not got an object header yet */
                                        endpos = chunk_base + tags.n_bytes;
 
                                        if (!in->valid &&       /* have not got an object header yet */

-                                           in->variant.file_variant.scanned_size < endpos) {
-                                               in->variant.file_variant.scanned_size = endpos;
-                                               in->variant.file_variant.file_size = endpos;
+                                           in->variant.file_variant.
+                                           scanned_size < endpos) {
+                                               in->variant.file_variant.
+                                                   scanned_size = endpos;
+                                               in->variant.file_variant.
+                                                   file_size = endpos;

                                        }
 
                                } else if (in) {
                                        /* This chunk has been invalidated by a resize, or a past file deletion
                                         * so delete the chunk*/
                                        }
 
                                } else if (in) {
                                        /* This chunk has been invalidated by a resize, or a past file deletion
                                         * so delete the chunk*/

-                                       yaffs_chunk_del(dev, chunk, 1, __LINE__);
+                                       yaffs_chunk_del(dev, chunk, 1,
+                                                       __LINE__);

 
                                }
                        } else {
 
                                }
                        } else {


@@ -1203,18 +1266,23 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                                if (tags.extra_available) {
                                        in = yaffs_find_or_create_by_number(dev,
 
                                if (tags.extra_available) {
                                        in = yaffs_find_or_create_by_number(dev,

-                                               tags.obj_id,
-                                               tags.extra_obj_type);
+                                                                           tags.
+                                                                           obj_id,
+                                                                           tags.
+                                                                           extra_obj_type);

                                        if (!in)
                                                alloc_failed = 1;
                                }
 
                                if (!in ||
                                        if (!in)
                                                alloc_failed = 1;
                                }
 
                                if (!in ||

-                                   (!in->valid && dev->param.disable_lazy_load) ||
-                                   tags.extra_shadows ||
-                                   (!in->valid &&
-                                   (tags.obj_id == YAFFS_OBJECTID_ROOT ||
-                                    tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND))) {
+                                   (!in->valid && dev->param.disable_lazy_load)
+                                   || tags.extra_shadows || (!in->valid
+                                                             && (tags.obj_id ==
+                                                                 YAFFS_OBJECTID_ROOT
+                                                                 || tags.
+                                                                 obj_id ==
+                                                                 YAFFS_OBJECTID_LOSTNFOUND)))
+                               {

 
                                        /* If we don't have  valid info then we need to read the chunk
                                         * TODO In future we can probably defer reading the chunk and
 
                                        /* If we don't have  valid info then we need to read the chunk
                                         * TODO In future we can probably defer reading the chunk and


@@ -1222,16 +1290,18 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                         */
 
                                        result = yaffs_rd_chunk_tags_nand(dev,
                                         */
 
                                        result = yaffs_rd_chunk_tags_nand(dev,

-                                                                       chunk,
-                                                                       chunk_data,
-                                                                       NULL);
+                                                                         chunk,
+                                                                         chunk_data,
+                                                                         NULL);

 
 

-                                       oh = (struct yaffs_obj_hdr *) chunk_data;
+                                       oh = (struct yaffs_obj_hdr *)chunk_data;

 
                                        if (dev->param.inband_tags) {
                                                /* Fix up the header if they got corrupted by inband tags */
 
                                        if (dev->param.inband_tags) {
                                                /* Fix up the header if they got corrupted by inband tags */

-                                               oh->shadows_obj = oh->inband_shadowed_obj_id;
-                                               oh->is_shrink = oh->inband_is_shrink;
+                                               oh->shadows_obj =
+                                                   oh->inband_shadowed_obj_id;
+                                               oh->is_shrink =
+                                                   oh->inband_is_shrink;

                                        }
 
                                        if (!in) {
                                        }
 
                                        if (!in) {


@@ -1257,23 +1327,34 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                         * we first have to suck out resize info if it is a file.
                                         */
 
                                         * we first have to suck out resize info if it is a file.
                                         */
 

-                                       if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) &&
-                                            ((oh &&
-                                              oh->type == YAFFS_OBJECT_TYPE_FILE) ||
-                                             (tags.extra_available  &&
-                                              tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) {
+                                       if ((in->variant_type ==
+                                            YAFFS_OBJECT_TYPE_FILE) && ((oh
+                                                                         &&
+                                                                         oh->
+                                                                         type
+                                                                         ==
+                                                                         YAFFS_OBJECT_TYPE_FILE)
+                                                                        ||
+                                                                        (tags.
+                                                                         extra_available
+                                                                         &&
+                                                                         tags.
+                                                                         extra_obj_type
+                                                                         ==
+                                                                         YAFFS_OBJECT_TYPE_FILE)))
+                                       {

                                                u32 this_size =
                                                u32 this_size =

-                                                   (oh) ? oh->file_size : tags.
-                                                   extra_length;
-                                               u32 parent_obj_id =

                                                    (oh) ? oh->
                                                    (oh) ? oh->

-                                                   parent_obj_id : tags.
-                                                   extra_parent_id;
-
+                                                   file_size :
+                                                   tags.extra_length;
+                                               u32 parent_obj_id =
+                                                   (oh) ? oh->parent_obj_id :
+                                                   tags.extra_parent_id;

 
                                                is_shrink =
 
                                                is_shrink =

-                                                   (oh) ? oh->is_shrink : tags.
-                                                   extra_is_shrink;
+                                                   (oh) ? oh->
+                                                   is_shrink :
+                                                   tags.extra_is_shrink;

 
                                                /* If it is deleted (unlinked at start also means deleted)
                                                 * we treat the file size as being zeroed at this point.
 
                                                /* If it is deleted (unlinked at start also means deleted)
                                                 * we treat the file size as being zeroed at this point.


@@ -1286,28 +1367,36 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                        is_shrink = 1;
                                                }
 
                                                        is_shrink = 1;
                                                }
 

-                                               if (is_shrink && in->variant.file_variant.shrink_size > this_size)
-                                                       in->variant.file_variant.shrink_size = this_size;
+                                               if (is_shrink
+                                                   && in->variant.file_variant.
+                                                   shrink_size > this_size)
+                                                       in->variant.
+                                                           file_variant.
+                                                           shrink_size =
+                                                           this_size;

 
                                                if (is_shrink)
                                                        bi->has_shrink_hdr = 1;
 
                                        }
                                        /* Use existing - destroy this one. */
 
                                                if (is_shrink)
                                                        bi->has_shrink_hdr = 1;
 
                                        }
                                        /* Use existing - destroy this one. */

-                                       yaffs_chunk_del(dev, chunk, 1, __LINE__);
+                                       yaffs_chunk_del(dev, chunk, 1,
+                                                       __LINE__);

 
                                }
 
                                if (!in->valid && in->variant_type !=
                                    (oh ? oh->type : tags.extra_obj_type))
 
                                }
 
                                if (!in->valid && in->variant_type !=
                                    (oh ? oh->type : tags.extra_obj_type))

-                                       T(YAFFS_TRACE_ERROR, (
-                                               TSTR("yaffs tragedy: Bad object type, "
-                                           TCONT("%d != %d, for object %d at chunk ")
+                                       T(YAFFS_TRACE_ERROR,
+                                         (TSTR
+                                          ("yaffs tragedy: Bad object type, "
+                                           TCONT
+                                           ("%d != %d, for object %d at chunk ")

                                            TCONT("%d during scan")
                                            TCONT("%d during scan")

-                                               TENDSTR), oh ?
-                                           oh->type : tags.extra_obj_type,
-                                           in->variant_type, tags.obj_id,
-                                           chunk));
+                                           TENDSTR), oh ?
+                                          oh->type : tags.extra_obj_type,
+                                          in->variant_type, tags.obj_id,
+                                          chunk));

 
                                if (!in->valid &&
                                    (tags.obj_id == YAFFS_OBJECTID_ROOT ||
 
                                if (!in->valid &&
                                    (tags.obj_id == YAFFS_OBJECTID_ROOT ||


@@ -1339,32 +1428,33 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                yaffs_load_attribs(in, oh);
 
                                                if (oh->shadows_obj > 0)
                                                yaffs_load_attribs(in, oh);
 
                                                if (oh->shadows_obj > 0)

-                                                       yaffs_handle_shadowed_obj(dev,
-                                                                          oh->
-                                                                          shadows_obj,
-                                                                          1);
-                                                       
-
+                                                       yaffs_handle_shadowed_obj
+                                                           (dev,
+                                                            oh->shadows_obj,
+                                                            1);

 
 

-                                               yaffs_set_obj_name_from_oh(in, oh);
+                                               yaffs_set_obj_name_from_oh(in,
+                                                                          oh);

                                                parent =
                                                    yaffs_find_or_create_by_number
                                                parent =
                                                    yaffs_find_or_create_by_number

-                                                       (dev, oh->parent_obj_id,
-                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
+                                                   (dev, oh->parent_obj_id,
+                                                    YAFFS_OBJECT_TYPE_DIRECTORY);

 
 

-                                                file_size = oh->file_size;
-                                                is_shrink = oh->is_shrink;
-                                                equiv_id = oh->equiv_id;
+                                               file_size = oh->file_size;
+                                               is_shrink = oh->is_shrink;
+                                               equiv_id = oh->equiv_id;

 
                                        } else {
 
                                        } else {

-                                               in->variant_type = tags.extra_obj_type;
+                                               in->variant_type =
+                                                   tags.extra_obj_type;

                                                parent =
                                                    yaffs_find_or_create_by_number
                                                parent =
                                                    yaffs_find_or_create_by_number

-                                                       (dev, tags.extra_parent_id,
-                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
-                                                file_size = tags.extra_length;
-                                                is_shrink = tags.extra_is_shrink;
-                                                equiv_id = tags.extra_equiv_id;
+                                                   (dev, tags.extra_parent_id,
+                                                    YAFFS_OBJECT_TYPE_DIRECTORY);
+                                               file_size = tags.extra_length;
+                                               is_shrink =
+                                                   tags.extra_is_shrink;
+                                               equiv_id = tags.extra_equiv_id;

                                                in->lazy_loaded = 1;
 
                                        }
                                                in->lazy_loaded = 1;
 
                                        }


@@ -1381,12 +1471,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                            YAFFS_OBJECT_TYPE_UNKNOWN) {
                                                /* Set up as a directory */
                                                parent->variant_type =
                                            YAFFS_OBJECT_TYPE_UNKNOWN) {
                                                /* Set up as a directory */
                                                parent->variant_type =

-                                                       YAFFS_OBJECT_TYPE_DIRECTORY;
-                                               INIT_LIST_HEAD(&parent->variant.
-                                                       dir_variant.
-                                                       children);
-                                       } else if (!parent || parent->variant_type !=
-                                                  YAFFS_OBJECT_TYPE_DIRECTORY) {
+                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
+                                               INIT_LIST_HEAD(&parent->
+                                                              variant.dir_variant.children);
+                                       } else if (!parent
+                                                  || parent->variant_type !=
+                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
+                                       {

                                                /* Hoosterman, another problem....
                                                 * We're trying to use a non-directory as a directory
                                                 */
                                                /* Hoosterman, another problem....
                                                 * We're trying to use a non-directory as a directory
                                                 */


@@ -1400,8 +1491,8 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                                        yaffs_add_obj_to_dir(parent, in);
 
 
                                        yaffs_add_obj_to_dir(parent, in);
 

-                                       is_unlinked = (parent == dev->del_dir) ||
-                                                     (parent == dev->unlinked_dir);
+                                       is_unlinked = (parent == dev->del_dir)
+                                           || (parent == dev->unlinked_dir);

 
                                        if (is_shrink) {
                                                /* Mark the block as having a shrink header */
 
                                        if (is_shrink) {
                                                /* Mark the block as having a shrink header */


@@ -1421,28 +1512,40 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
 
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
 

-                                               if (in->variant.file_variant.
-                                                   scanned_size < file_size) {
+                                               if (in->variant.
+                                                   file_variant.scanned_size <
+                                                   file_size) {

                                                        /* This covers the case where the file size is greater
                                                         * than where the data is
                                                         * This will happen if the file is resized to be larger
                                                         * than its current data extents.
                                                         */
                                                        /* This covers the case where the file size is greater
                                                         * than where the data is
                                                         * This will happen if the file is resized to be larger
                                                         * than its current data extents.
                                                         */

-                                                       in->variant.file_variant.file_size = file_size;
-                                                       in->variant.file_variant.scanned_size = file_size;
+                                                       in->variant.
+                                                           file_variant.
+                                                           file_size =
+                                                           file_size;
+                                                       in->variant.
+                                                           file_variant.
+                                                           scanned_size =
+                                                           file_size;

                                                }
 
                                                }
 

-                                               if (in->variant.file_variant.shrink_size > file_size)
-                                                       in->variant.file_variant.shrink_size = file_size;
-                               
+                                               if (in->variant.file_variant.
+                                                   shrink_size > file_size)
+                                                       in->variant.
+                                                           file_variant.
+                                                           shrink_size =
+                                                           file_size;

 
                                                break;
                                        case YAFFS_OBJECT_TYPE_HARDLINK:
                                                if (!is_unlinked) {
 
                                                break;
                                        case YAFFS_OBJECT_TYPE_HARDLINK:
                                                if (!is_unlinked) {

-                                                       in->variant.hardlink_variant.equiv_id =
-                                                               equiv_id;
+                                                       in->variant.
+                                                           hardlink_variant.
+                                                           equiv_id = equiv_id;

                                                        in->hard_links.next =
                                                        in->hard_links.next =

-                                                               (struct list_head *) hard_list;
+                                                           (struct list_head *)
+                                                           hard_list;

                                                        hard_list = in;
                                                }
                                                break;
                                                        hard_list = in;
                                                }
                                                break;


@@ -1454,10 +1557,16 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                                                break;
                                        case YAFFS_OBJECT_TYPE_SYMLINK:
                                                if (oh) {
                                                break;
                                        case YAFFS_OBJECT_TYPE_SYMLINK:
                                                if (oh) {

-                                                       in->variant.symlink_variant.alias =
-                                                               yaffs_clone_str(oh->alias);
-                                                       if (!in->variant.symlink_variant.alias)
-                                                               alloc_failed = 1;
+                                                       in->variant.
+                                                           symlink_variant.
+                                                           alias =
+                                                           yaffs_clone_str(oh->
+                                                                           alias);
+                                                       if (!in->variant.
+                                                           symlink_variant.
+                                                           alias)
+                                                               alloc_failed =
+                                                                   1;

                                                }
                                                break;
                                        }
                                                }
                                                break;
                                        }


@@ -1466,14 +1575,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                        }
 
 
                        }
 

-               } /* End of scanning for each chunk */
+               }               /* End of scanning for each chunk */

 
                if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
                        /* If we got this far while scanning, then the block is fully allocated. */
                        state = YAFFS_BLOCK_STATE_FULL;
                }
 
 
                if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
                        /* If we got this far while scanning, then the block is fully allocated. */
                        state = YAFFS_BLOCK_STATE_FULL;
                }
 

-

                bi->block_state = state;
 
                /* Now let's see if it was dirty */
                bi->block_state = state;
 
                /* Now let's see if it was dirty */


@@ -1484,7 +1592,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
                }
 
        }
                }
 
        }

-       
+

        yaffs_skip_rest_of_block(dev);
 
        if (alt_block_index)
        yaffs_skip_rest_of_block(dev);
 
        if (alt_block_index)


@@ -1499,7 +1607,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
         */
        yaffs_link_fixup(dev, hard_list);
 
         */
        yaffs_link_fixup(dev, hard_list);
 

-

        yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
 
        if (alloc_failed)
        yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
 
        if (alloc_failed)

diff --git a/yaffs_yaffs2.h b/yaffs_yaffs2.h
index ceece88b751eb08cf409ec06428b94c992a9329d..e1a9287fc5065b2cb0883efe1bb4b143a9997068 100644 (file)
--- a/yaffs_yaffs2.h
+++ b/yaffs_yaffs2.h
@@ -20,14 +20,15 @@
 
 void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev);
 void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev);
 
 void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev);
 void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev);

-void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *bi);
-void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi);
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev,
+                                  struct yaffs_block_info *bi);
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no,
+                                   struct yaffs_block_info *bi);

 int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi);
 u32 yaffs2_find_refresh_block(struct yaffs_dev *dev);
 int yaffs2_checkpt_required(struct yaffs_dev *dev);
 int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev);
 
 int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi);
 u32 yaffs2_find_refresh_block(struct yaffs_dev *dev);
 int yaffs2_checkpt_required(struct yaffs_dev *dev);
 int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev);
 

-

 void yaffs2_checkpt_invalidate(struct yaffs_dev *dev);
 int yaffs2_checkpt_save(struct yaffs_dev *dev);
 int yaffs2_checkpt_restore(struct yaffs_dev *dev);
 void yaffs2_checkpt_invalidate(struct yaffs_dev *dev);
 int yaffs2_checkpt_save(struct yaffs_dev *dev);
 int yaffs2_checkpt_restore(struct yaffs_dev *dev);

diff --git a/yportenv_multi.h b/yportenv_multi.h
index 3295ca0aeebc13e118001cdebe94ef38eec835a0..ec43fd588db3a7ee40041f58ab0aabcbfd2a7281 100644 (file)
--- a/yportenv_multi.h
+++ b/yportenv_multi.h
@@ -13,7 +13,6 @@
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 

-

 #ifndef __YPORTENV_H__
 #define __YPORTENV_H__
 
 #ifndef __YPORTENV_H__
 #define __YPORTENV_H__
 


@@ -67,7 +66,6 @@
 #define yaffs_toupper(a)       toupper(a)
 #define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL)
 
 #define yaffs_toupper(a)       toupper(a)
 #define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL)
 

-

 #define Y_INLINE __inline__
 
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"
 #define Y_INLINE __inline__
 
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"


@@ -120,7 +118,6 @@
 #include "stdio.h"
 #include "string.h"
 
 #include "stdio.h"
 #include "string.h"
 

-

 #define YMALLOC(x) malloc(x)
 #define YFREE(x)   free(x)
 #define YMALLOC_ALT(x) malloc(x)
 #define YMALLOC(x) malloc(x)
 #define YFREE(x)   free(x)
 #define YMALLOC_ALT(x) malloc(x)


@@ -177,7 +174,7 @@
 #define O_RDWR         02
 #endif
 
 #define O_RDWR         02
 #endif
 

-#ifndef O_CREAT                
+#ifndef O_CREAT

 #define O_CREAT        0100
 #endif
 
 #define O_CREAT        0100
 #endif
 


@@ -229,7 +226,7 @@
 #define EACCES 13
 #endif
 
 #define EACCES 13
 #endif
 

-#ifndef EXDEV  
+#ifndef EXDEV

 #define EXDEV  18
 #endif
 
 #define EXDEV  18
 #endif
 


@@ -273,7 +270,6 @@
 #define EISDIR 21
 #endif
 
 #define EISDIR 21
 #endif
 

-

 // Mode flags
 
 #ifndef S_IFMT
 // Mode flags
 
 #ifndef S_IFMT


@@ -292,7 +288,7 @@
 #define S_IFREG                0100000
 #endif
 
 #define S_IFREG                0100000
 #endif
 

-#ifndef S_IREAD 
+#ifndef S_IREAD

 #define S_IREAD                0000400
 #endif
 
 #define S_IREAD                0000400
 #endif
 


@@ -340,5 +336,4 @@
 } while (0)
 #endif
 
 } while (0)
 #endif
 

-

 #endif
 #endif

diff --git a/yportenv_single.h b/yportenv_single.h
index 42892b87ffa9023cb09c10a7eba0564a89fcb3b9..2eae429a9410ceafabef3f72f9f3f88495c55b07 100644 (file)
--- a/yportenv_single.h
+++ b/yportenv_single.h
@@ -13,7 +13,6 @@
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
 

-

 #ifndef __YPORTENV_LINUX_H__
 #define __YPORTENV_LINUX_H__
 
 #ifndef __YPORTENV_LINUX_H__
 #define __YPORTENV_LINUX_H__
 


@@ -61,10 +60,9 @@
 #define YAFFS_ROOT_MODE                        0755
 #define YAFFS_LOSTNFOUND_MODE          0700
 
 #define YAFFS_ROOT_MODE                        0755
 #define YAFFS_LOSTNFOUND_MODE          0700
 

-

 #define Y_CURRENT_TIME CURRENT_TIME.tv_sec
 #define Y_TIME_CONVERT(x) (x).tv_sec
 #define Y_CURRENT_TIME CURRENT_TIME.tv_sec
 #define Y_TIME_CONVERT(x) (x).tv_sec

- 
+

 #define yaffs_sum_cmp(x, y) ((x) == (y))
 #define yaffs_strcmp(a, b) strcmp(a, b)
 
 #define yaffs_sum_cmp(x, y) ((x) == (y))
 #define yaffs_strcmp(a, b) strcmp(a, b)
 


@@ -76,8 +74,6 @@
 #define compile_time_assertion(assertion) \
        ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
 
 #define compile_time_assertion(assertion) \
        ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
 

-
-

 #ifndef Y_DUMP_STACK
 #define Y_DUMP_STACK() do { } while (0)
 #endif
 #ifndef Y_DUMP_STACK
 #define Y_DUMP_STACK() do { } while (0)
 #endif


@@ -91,5 +87,4 @@
 } while (0)
 #endif
 
 } while (0)
 #endif
 

-

 #endif
 #endif