Clean up checkin. Do not use
authorCharles Manning <cdhmanning@gmail.com>
Tue, 1 May 2012 03:57:53 +0000 (15:57 +1200)
committerCharles Manning <cdhmanning@gmail.com>
Tue, 1 May 2012 03:57:53 +0000 (15:57 +1200)
This is a clean-up checkin that should have been on a branch.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>
30 files changed:
direct/u-boot/fs/yaffs2/yaffs_mtdif.c
direct/u-boot/fs/yaffs2/yaffs_mtdif.h
direct/u-boot/fs/yaffs2/yaffs_mtdif2.c
direct/u-boot/fs/yaffs2/yaffs_mtdif2.h
direct/u-boot/fs/yaffs2/yaffs_uboot_glue.c
direct/yaffs_attribs.c
direct/yaffs_error.c
direct/yaffs_flashif.c [deleted file]
direct/yaffs_flashif.h
direct/yaffs_flashif2.h
direct/yaffs_hweight.c
direct/yaffs_hweight.h
direct/yaffs_list.h
direct/yaffs_nandif.c
direct/yaffs_nandif.h
direct/yaffs_osglue.h
direct/yaffs_qsort.c
direct/yaffscfg.h
direct/yaffsfs.c
direct/yaffsfs.h
direct/ydirectenv.h
direct/yportenv.h
yaffs_guts.c
yaffs_guts.h
yaffs_mtdif1_single.c
yaffs_packedtags2.c
yaffs_summary.c
yaffs_vfs_single.c
yaffs_yaffs1.c
yaffs_yaffs2.c

index 6f3a028..5f3a8cd 100644 (file)
@@ -14,9 +14,6 @@
 /* XXX U-BOOT XXX */
 #include <common.h>
 
-const char *yaffs_mtdif_c_version =
-    "$Id: yaffs_mtdif.c,v 1.19 2007/02/14 01:09:06 wookey Exp $";
-
 #include "yportenv.h"
 
 
@@ -27,7 +24,7 @@ const char *yaffs_mtdif_c_version =
 #include "linux/time.h"
 #include "linux/mtd/nand.h"
 
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
 static struct nand_oobinfo yaffs_oobinfo = {
        .useecc = 1,
        .eccbytes = 6,
@@ -39,7 +36,7 @@ static struct nand_oobinfo yaffs_noeccinfo = {
 };
 #endif
 
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static inline void translate_spare2oob(const struct yaffs_spare *spare, u8 *oob)
 {
        oob[0] = spare->tb0;
@@ -48,8 +45,8 @@ static inline void translate_spare2oob(const struct yaffs_spare *spare, u8 *oob)
        oob[3] = spare->tb3;
        oob[4] = spare->tb4;
        oob[5] = spare->tb5 & 0x3f;
-       oob[5] |= spare->block_status == 'Y' ? 0: 0x80;
-       oob[5] |= spare->page_status == 0 ? 0: 0x40;
+       oob[5] |= spare->block_status == 'Y' ? 0 : 0x80;
+       oob[5] |= spare->page_status == 0 ? 0 : 0x40;
        oob[6] = spare->tb6;
        oob[7] = spare->tb7;
 }
@@ -74,18 +71,18 @@ static inline void translate_oob2spare(struct yaffs_spare *spare, u8 *oob)
 }
 #endif
 
-int nandmtd_WriteChunkToNAND(struct yaffs_dev * dev, int chunkInNAND,
-                            const u8 * data, const struct yaffs_spare * spare)
+int nandmtd_WriteChunkToNAND(struct yaffs_dev *dev, int chunkInNAND,
+                            const u8 *data, const struct yaffs_spare *spare)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        struct mtd_oob_ops ops;
 #endif
        size_t dummy;
        int retval = 0;
 
        loff_t addr = ((loff_t) chunkInNAND) * dev->data_bytes_per_chunk;
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        u8 spareAsBytes[8]; /* OOB */
 
        if (data && !spare)
@@ -123,8 +120,8 @@ int nandmtd_WriteChunkToNAND(struct yaffs_dev * dev, int chunkInNAND,
        } else {
                if (data)
                        retval =
-                           mtd->write(mtd, addr, dev->data_bytes_per_chunk, &dummy,
-                                      data);
+                           mtd->write(mtd, addr, dev->data_bytes_per_chunk,
+                                       &dummy, data);
                if (spare)
                        retval =
                            mtd->write_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
@@ -138,18 +135,18 @@ int nandmtd_WriteChunkToNAND(struct yaffs_dev * dev, int chunkInNAND,
                return YAFFS_FAIL;
 }
 
-int nandmtd_ReadChunkFromNAND(struct yaffs_dev * dev, int chunkInNAND, u8 * data,
-                             struct yaffs_spare * spare)
+int nandmtd_ReadChunkFromNAND(struct yaffs_dev *dev, int chunkInNAND, u8 *data,
+                             struct yaffs_spare *spare)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        struct mtd_oob_ops ops;
 #endif
        size_t dummy;
        int retval = 0;
 
        loff_t addr = ((loff_t) chunkInNAND) * dev->data_bytes_per_chunk;
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        u8 spareAsBytes[8]; /* OOB */
 
        if (data && !spare)
@@ -193,8 +190,8 @@ int nandmtd_ReadChunkFromNAND(struct yaffs_dev * dev, int chunkInNAND, u8 * data
        } 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 (spare)
                        retval =
                            mtd->read_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
@@ -208,7 +205,7 @@ int nandmtd_ReadChunkFromNAND(struct yaffs_dev * dev, int chunkInNAND, u8 * data
                return YAFFS_FAIL;
 }
 
-int nandmtd_EraseBlockInNAND(struct yaffs_dev * dev, int blockNumber)
+int nandmtd_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context);
        __u32 addr =
@@ -227,10 +224,6 @@ int nandmtd_EraseBlockInNAND(struct yaffs_dev * dev, int blockNumber)
 
        /* Todo finish off the ei if required */
 
-/* XXX U-BOOT XXX */
-#if 0
-       sema_init(&dev->sem, 0);
-#endif
 
        retval = mtd->erase(mtd, &ei);
 
@@ -240,7 +233,7 @@ int nandmtd_EraseBlockInNAND(struct yaffs_dev * dev, int blockNumber)
                return YAFFS_FAIL;
 }
 
-int nandmtd_InitialiseNAND(struct yaffs_dev * dev)
+int nandmtd_InitialiseNAND(struct yaffs_dev *dev)
 {
        return YAFFS_OK;
 }
index 91e8dc9..1a12582 100644 (file)
 
 #include "yaffs_guts.h"
 
-int nandmtd_WriteChunkToNAND(struct yaffs_dev * dev, int chunkInNAND,
-                            const u8 * data, const struct yaffs_spare * spare);
-int nandmtd_ReadChunkFromNAND(struct yaffs_dev * dev, int chunkInNAND, u8 * data,
-                             struct yaffs_spare * spare);
-int nandmtd_EraseBlockInNAND(struct yaffs_dev * dev, int blockNumber);
-int nandmtd_InitialiseNAND(struct yaffs_dev * dev);
+int nandmtd_WriteChunkToNAND(struct yaffs_dev *dev, int chunkInNAND,
+                            const u8 *data, const struct yaffs_spare *spare);
+int nandmtd_ReadChunkFromNAND(struct yaffs_dev *dev, int chunkInNAND, u8 *data,
+                             struct yaffs_spare *spare);
+int nandmtd_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
+int nandmtd_InitialiseNAND(struct yaffs_dev *dev);
 #endif
index 4d96872..e4d7f6b 100644 (file)
@@ -234,7 +234,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int blockNo)
 }
 
 int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int blockNo,
-                           enum yaffs_block_state * state, u32 *sequenceNumber)
+                           enum yaffs_block_state *state, u32 *sequenceNumber)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context);
        int retval;
@@ -253,9 +253,9 @@ int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int blockNo,
        } else {
                struct yaffs_ext_tags t;
                nandmtd2_read_chunk_tags(dev,
-                                                  blockNo *
-                                                  dev->param.chunks_per_block, NULL,
-                                                  &t);
+                                          blockNo *
+                                          dev->param.chunks_per_block, NULL,
+                                          &t);
 
                if (t.chunk_used) {
                        *sequenceNumber = t.seq_number;
@@ -265,7 +265,8 @@ int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int blockNo,
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
        }
-       yaffs_trace(YAFFS_TRACE_MTD, "block is bad seq %d state %d", *sequenceNumber, *state);
+       yaffs_trace(YAFFS_TRACE_MTD, "block is bad seq %d state %d",
+                       *sequenceNumber, *state);
 
        if (retval == 0)
                return YAFFS_OK;
index 46ec3c6..62be173 100644 (file)
 
 #include "yaffs_guts.h"
 
-int nandmtd2_write_chunk_tags(struct yaffs_dev * dev, int chunkInNAND,
-                                     const u8 * data,
-                                     const struct yaffs_ext_tags * tags);
-int nandmtd2_read_chunk_tags(struct yaffs_dev * dev, int chunkInNAND,
-                                      __u8 * data, struct yaffs_ext_tags * tags);
+int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int chunkInNAND,
+                                     const u8 *data,
+                                     const struct yaffs_ext_tags *tags);
+int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int chunkInNAND,
+                                      u8 *data, struct yaffs_ext_tags *tags);
 int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int blockNo);
 int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int blockNo,
-                           enum yaffs_block_state * state, u32 *sequenceNumber);
+                           enum yaffs_block_state *state, u32 *sequenceNumber);
 
 #endif
index f4a3eb6..4fd9af9 100644 (file)
@@ -38,8 +38,6 @@ unsigned yaffs_trace_mask = 0x0; /* Disable logging */
 static int yaffs_errno = 0;
 
 
-
-
 void yaffs_bug_fn(const char *fn, int n)
 {
        printf("yaffs bug at %s:%d\n", fn, n);
@@ -57,7 +55,6 @@ void yaffsfs_free(void *x)
 
 void yaffsfs_SetError(int err)
 {
-       //Do whatever to set error
        yaffs_errno = err;
 }
 
@@ -97,11 +94,11 @@ void yaffs_free(void *ptr)
 
 void yaffsfs_LocalInitialisation(void)
 {
-       // Define locking semaphore.
+       /* No locking used */
 }
 
 
-static const char * yaffs_file_type_str(struct yaffs_stat *stat)
+static const char *yaffs_file_type_str(struct yaffs_stat *stat)
 {
        switch(stat->st_mode & S_IFMT) {
                case S_IFREG: return "regular file";
@@ -111,7 +108,7 @@ static const char * yaffs_file_type_str(struct yaffs_stat *stat)
        }
 }
 
-static const char * yaffs_error_str(void)
+static const char *yaffs_error_str(void)
 {
        int error = yaffsfs_GetLastError();
 
@@ -162,7 +159,8 @@ static int yaffs_regions_overlap(int a, int b, int x, int y)
                (x <= b && b <= y);
 }
 
-void cmd_yaffs_devconfig(char *_mp, int flash_dev, int start_block, int end_block)
+void cmd_yaffs_devconfig(char *_mp, int flash_dev,
+                       int start_block, int end_block)
 {
        struct mtd_info *mtd = NULL;
        struct yaffs_dev *dev = NULL;
@@ -185,11 +183,11 @@ void cmd_yaffs_devconfig(char *_mp, int flash_dev, int start_block, int end_bloc
                printf("Flash device invalid\n");
                goto err;
        }
-       
-       if(end_block == 0)
+
+       if (end_block == 0)
                end_block = mtd->size / mtd->erasesize - 1;
 
-       if(end_block < start_block) {
+       if (end_block < start_block) {
                printf("Bad start/end\n");
                goto err;
        }
@@ -198,7 +196,7 @@ void cmd_yaffs_devconfig(char *_mp, int flash_dev, int start_block, int end_bloc
 
        /* Check for any conflicts */
        yaffs_dev_rewind();
-       while(1) {
+       while (1) {
                chk = yaffs_next_dev();
                if(!chk)
                        break;
@@ -241,7 +239,7 @@ void cmd_yaffs_devconfig(char *_mp, int flash_dev, int start_block, int end_bloc
        yaffs_add_device(dev);
 
        printf("Configures yaffs mount %s: dev %d start block %d, end block %d %s\n",
-               mp, flash_dev, start_block, end_block, 
+               mp, flash_dev, start_block, end_block,
                dev->param.inband_tags ? "using inband tags" : "");
        return;
 
@@ -262,7 +260,8 @@ void cmd_yaffs_dev_ls(void)
                dev = yaffs_next_dev();
                if(!dev)
                        return;
-               flash_dev = ((unsigned) dev->driver_context - (unsigned) nand_info)/
+               flash_dev =
+                       ((unsigned) dev->driver_context - (unsigned) nand_info)/
                                sizeof(nand_info[0]);
                printf("%-10s %5d 0x%05x 0x%05x %s",
                        dev->param.name, flash_dev,
@@ -284,9 +283,10 @@ void make_a_file(char *yaffsName,char bval,int sizeOfFile)
        int i;
        unsigned char buffer[100];
 
-       outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
-       if (outh < 0)
-       {
+       outh = yaffs_open(yaffsName,
+                               O_CREAT | O_RDWR | O_TRUNC,
+                               S_IREAD | S_IWRITE);
+       if (outh < 0) {
                printf("Error opening file: %d. %s\n", outh, yaffs_error_str());
                return;
        }
index 82111c2..648e137 100644 (file)
@@ -54,7 +54,7 @@ void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev)
                obj->win_ctime[1] = obj->win_mtime[1] = obj->win_atime[1];
 
 #else
-       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;
@@ -72,11 +72,11 @@ void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c)
 
 #else
 
-        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;
 #endif
 }
 
@@ -90,9 +90,9 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj)
                return obj->variant.file_variant.file_size;
        case YAFFS_OBJECT_TYPE_SYMLINK:
                alias = obj->variant.symlink_variant.alias;
-               if(!alias)
+               if (!alias)
                        return 0;
-               return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
+               return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
        default:
                return 0;
        }
index dfdb798..11b75f7 100644 (file)
@@ -14,8 +14,8 @@
 #include "yaffsfs.h"
 
 struct error_entry {
-  int code;
-  char * text;  
+       int code;
+       const char *text;
 };
 
 static const struct error_entry error_list[] = {
@@ -31,7 +31,7 @@ static const struct error_entry error_list[] = {
        { ERANGE , "ERANGE"},
        { ENODATA, "ENODATA"},
        { ENOTEMPTY, "ENOTEMPTY"},
-       { ENAMETOOLONG,"ENAMETOOLONG"},
+       { ENAMETOOLONG, "ENAMETOOLONG"},
        { ENOMEM , "ENOMEM"},
        { EEXIST , "EEXIST"},
        { ENOTDIR , "ENOTDIR"},
@@ -42,15 +42,15 @@ static const struct error_entry error_list[] = {
        { 0, NULL }
 };
 
-const char * yaffs_error_to_str(int err)
+const char *yaffs_error_to_str(int err)
 {
        const struct error_entry *e = error_list;
 
-       if (err < 0) 
+       if (err < 0)
                err = -err;
 
-       while(e->code && e->text){
-               if(err == e->code)
+       while (e->code && e->text) {
+               if (err == e->code)
                        return e->text;
                e++;
        }
diff --git a/direct/yaffs_flashif.c b/direct/yaffs_flashif.c
deleted file mode 100644 (file)
index f7c1998..0000000
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2011 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-
-const char *yaffs_flashif_c_version = "$Id: yaffs_flashif.c,v 1.3 2007-02-14 01:09:06 wookey Exp $";
-
-
-#include "yportenv.h"
-
-#include "yaffs_flashif.h"
-#include "yaffs_guts.h"
-
-
-#define SIZE_IN_MB 16
-
-#define BLOCK_SIZE (32 * 528)
-#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
-
-
-
-typedef struct 
-{
-       u8 data[528]; // Data + spare
-} yflash_Page;
-
-typedef struct
-{
-       yflash_Page page[32]; // The pages in the block
-       
-} yflash_Block;
-
-
-
-typedef struct
-{
-       yflash_Block **block;
-       int nBlocks;
-} yflash_Device;
-
-static yflash_Device ramdisk;
-
-static int  CheckInit(struct yaffs_dev *dev)
-{
-       static int initialised = 0;
-       
-       int i;
-       int fail = 0;
-       int nAllocated = 0;
-       
-       if(initialised) 
-       {
-               return YAFFS_OK;
-       }
-
-       initialised = 1;
-       
-       
-       ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
-       
-       ramdisk.block = kmalloc(sizeof(yflash_Block *) * ramdisk.nBlocks);
-       
-       if(!ramdisk.block) return 0;
-       
-       for(i=0; i <ramdisk.nBlocks; i++)
-       {
-               ramdisk.block[i] = NULL;
-       }
-       
-       for(i=0; i <ramdisk.nBlocks && !fail; i++)
-       {
-               if((ramdisk.block[i] = kmalloc(sizeof(yflash_Block))) == 0)
-               {
-                       fail = 1;
-               }
-               else
-               {
-                       yflash_EraseBlockInNAND(dev,i);
-                       nAllocated++;
-               }
-       }
-       
-       if(fail)
-       {
-               for(i = 0; i < nAllocated; i++)
-               {
-                       kfree(ramdisk.block[i]);
-               }
-               kfree(ramdisk.block);
-               
-               T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
-                  nAllocated/64,ramdisk.nBlocks * YAFFS_BYTES_PER_BLOCK));
-               return 0;
-       }
-       
-       
-       
-       return 1;
-}
-
-int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, struct yaffs_ext_tags *tags)
-{
-       int blk;
-       int pg;
-       
-
-       CheckInit(dev);
-       
-       blk = nand_chunk/32;
-       pg = nand_chunk%32;
-       
-       
-       if(data)
-       {
-               memcpy(ramdisk.block[blk]->page[pg].data,data,512);
-       }
-       
-       
-       if(tags)
-       {
-               yaffs_PackedTags pt;
-               yaffs_PackTags(&pt,tags);
-               memcpy(&ramdisk.block[blk]->page[pg].data[512],&pt,sizeof(pt));
-       }
-
-       return YAFFS_OK;        
-
-}
-
-
-int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_tags *tags)
-{
-       int blk;
-       int pg;
-
-       
-       CheckInit(dev);
-       
-       blk = nand_chunk/32;
-       pg = nand_chunk%32;
-       
-       
-       if(data)
-       {
-               memcpy(data,ramdisk.block[blk]->page[pg].data,512);
-       }
-       
-       
-       if(tags)
-       {
-               yaffs_PackedTags pt;
-               memcpy(&pt,&ramdisk.block[blk]->page[pg].data[512],sizeof(yaffs_PackedTags));
-               yaffs_unpack_tags(tags,&pt);
-       }
-
-       return YAFFS_OK;
-}
-
-
-int yflash_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk)
-{
-       int blk;
-       int pg;
-       int i;
-
-       
-       CheckInit(dev);
-       
-       blk = nand_chunk/32;
-       pg = nand_chunk%32;
-       
-       
-       for(i = 0; i < 528; i++)
-       {
-               if(ramdisk.block[blk]->page[pg].data[i] != 0xFF)
-               {
-                       return YAFFS_FAIL;
-               }
-       }
-
-       return YAFFS_OK;
-
-}
-
-int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
-{
-       
-       CheckInit(dev);
-       
-       if(blockNumber < 0 || blockNumber >= ramdisk.nBlocks)
-       {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
-               return YAFFS_FAIL;
-       }
-       else
-       {
-               memset(ramdisk.block[blockNumber],0xFF,sizeof(yflash_Block));
-               return YAFFS_OK;
-       }
-       
-}
-
-int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
-{
-       return YAFFS_OK;
-       
-}
-int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, int *seq_number)
-{
-       *state = YAFFS_BLOCK_STATE_EMPTY;
-       *seq_number = 0;
-}
-
-
-int yflash_InitialiseNAND(struct yaffs_dev *dev)
-{
-       return YAFFS_OK;
-}
-
index a7b854f..e6e8979 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
 
 #include "yaffs_guts.h"
 int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
-int yflash_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare);
-int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
-int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare);
-int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
+int yflash_WriteChunkToNAND(struct yaffs_dev *dev, int nand_chunk,
+                       const u8 *data, const struct yaffs_spare *spare);
+int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, int nand_chunk,
+                       const u8 *data, const struct yaffs_ext_tags *tags);
+int yflash_ReadChunkFromNAND(struct yaffs_dev *dev, int nand_chunk,
+                       u8 *data, struct yaffs_spare *spare);
+int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, int nand_chunk,
+                       u8 *data, struct yaffs_ext_tags *tags);
 int yflash_InitialiseNAND(struct yaffs_dev *dev);
 int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no);
-int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number);
+int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no,
+                       enum yaffs_block_state *state, u32 *seq_number);
 
 #endif
index 40e01aa..cfdbde9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
 
 #include "yaffs_guts.h"
 int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
-int yflash2_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare);
-int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
-int yflash2_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare);
-int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
+int yflash2_WriteChunkToNAND(struct yaffs_dev *dev, int nand_chunk,
+                       const u8 *data, const struct yaffs_spare *spare);
+int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, int nand_chunk,
+                       const u8 *data, const struct yaffs_ext_tags *tags);
+int yflash2_ReadChunkFromNAND(struct yaffs_dev *dev, int nand_chunk,
+                       u8 *data, struct yaffs_spare *spare);
+int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, int nand_chunk,
+                       u8 *data, struct yaffs_ext_tags *tags);
 int yflash2_InitialiseNAND(struct yaffs_dev *dev);
 int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no);
-int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number);
+int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no,
+                       enum yaffs_block_state *state, u32 *seq_number);
 
 #endif
index 9851683..7e2c250 100644 (file)
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
- /* These functions have been renamed to hweightxx to match the
 * equivaqlent functions in the Linux kernel.
 */
+
+/* These functions have been renamed to hweightxx to match the
+ * equivaqlent functions in the Linux kernel.
+ */
 
 #include "yaffs_hweight.h"
 
@@ -45,7 +45,7 @@ int yaffs_hweight8(u8 x)
 
 int yaffs_hweight32(u32 x)
 {
-       return yaffs_hweight8(x & 0xff) + 
+       return yaffs_hweight8(x & 0xff) +
                yaffs_hweight8((x >> 8) & 0xff) +
                yaffs_hweight8((x >> 16) & 0xff) +
                yaffs_hweight8((x >> 24) & 0xff);
index 58d826c..3f7c6c3 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 3038ca3..a7afaea 100644 (file)
@@ -119,7 +119,8 @@ static inline int list_empty(struct list_head *entry)
 
 #define list_for_each_safe(itervar, save_var, list) \
        for (itervar = (list)->next, save_var = (list)->next->next; \
-               itervar != (list); itervar = save_var, save_var = save_var->next)
+               itervar != (list); \
+               itervar = save_var, save_var = save_var->next)
 
 
 #endif
index b93b55a..e5775b9 100644 (file)
 
 
 /* NB For use with inband tags....
- * We assume that the data buffer is of size totalBytersPerChunk so that we can also
- * use it to load the tags.
+ * We assume that the data buffer is of size totalBytersPerChunk so that
+ * we can also use it to load the tags.
  */
-int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
-                                     const u8 * data,
-                                     const struct yaffs_ext_tags * tags)
+int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, int nand_chunk,
+                                     const u8 *data,
+                                     const struct yaffs_ext_tags *tags)
 {
 
        int retval = 0;
@@ -42,99 +42,97 @@ int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
        yaffs_trace(YAFFS_TRACE_MTD,
                "nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p",
                nand_chunk, data, tags);
-           
+
 
        /* For yaffs2 writing there must be both data and tags.
         * If we're using inband tags, then the tags are stuffed into
         * the end of the data buffer.
         */
 
-       if(dev->param.inband_tags){
+       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);
-               yaffs_pack_tags2_tags_only(pt2tp,tags);
+               yaffs_pack_tags2_tags_only(pt2tp, tags);
                spare = NULL;
                spareSize = 0;
-       }
-       else{
-               yaffs_pack_tags2(&pt, tags,!dev->param.no_tags_ecc);
+       } else {
+               yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);
                spare = &pt;
                spareSize = sizeof(struct yaffs_packed_tags2);
        }
-       
-       retval = geometry->writeChunk(dev,nand_chunk,
+
+       retval = geometry->writeChunk(dev, nand_chunk,
                                data, dev->param.total_bytes_per_chunk,
                                spare, spareSize);
 
        return retval;
 }
 
-int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk,
-                                      u8 * data, struct yaffs_ext_tags * tags)
+int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, int nand_chunk,
+                                      u8 *data, struct yaffs_ext_tags *tags)
 {
        struct yaffs_packed_tags2 pt;
        int localData = 0;
        void *spare = NULL;
        unsigned spareSize;
        int retval = 0;
-       int eccStatus; //0 = ok, 1 = fixed, -1 = unfixed
+       int eccStatus; /* 0 = ok, 1 = fixed, -1 = unfixed */
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
        yaffs_trace(YAFFS_TRACE_MTD,
                "nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p",
                nand_chunk, data, tags);
-           
-       if(!tags){
+
+       if (!tags) {
                spare = NULL;
                spareSize = 0;
-       }else if(dev->param.inband_tags){
-               
-               if(!data) {
+       } else if (dev->param.inband_tags) {
+
+               if (!data) {
                        localData = 1;
                        data = yaffs_get_temp_buffer(dev);
                }
                spare = NULL;
                spareSize = 0;
-       }
-       else {
+       } else {
                spare = &pt;
                spareSize = sizeof(struct yaffs_packed_tags2);
        }
 
-       retval = geometry->readChunk(dev,nand_chunk,
-                                        data,
-                                        data ? dev->param.total_bytes_per_chunk : 0,
-                                        spare,spareSize,
-                                        &eccStatus);
-
-       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];        
-                       yaffs_unpack_tags2_tags_only(tags,pt2tp);
-               }
-       }
-       else {
-               if (tags){
-                       yaffs_unpack_tags2(tags, &pt,!dev->param.no_tags_ecc);
+       retval = geometry->readChunk(dev, nand_chunk,
+                                data,
+                                data ? dev->param.total_bytes_per_chunk : 0,
+                                spare, spareSize,
+                                &eccStatus);
+
+       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];
+                       yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
+       } else {
+               if (tags)
+                       yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
        }
 
-       if(tags && tags->chunk_used){
-               if(eccStatus < 0 || 
+       if (tags && tags->chunk_used) {
+               if (eccStatus < 0 ||
                   tags->ecc_result == YAFFS_ECC_RESULT_UNFIXED)
                        tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED;
-               else if(eccStatus > 0 ||
+               else if (eccStatus > 0 ||
                             tags->ecc_result == YAFFS_ECC_RESULT_FIXED)
                        tags->ecc_result = YAFFS_ECC_RESULT_FIXED;
                else
                        tags->ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
        }
 
-       if(localData)
+       if (localData)
                yaffs_release_temp_buffer(dev, data);
-       
+
        return retval;
 }
 
@@ -142,14 +140,14 @@ int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev, int blockId)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
-       return geometry->markBlockBad(dev,blockId);
+       return geometry->markBlockBad(dev, blockId);
 }
 
 int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockId)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
-       return geometry->eraseBlock(dev,blockId);
+       return geometry->eraseBlock(dev, blockId);
 
 }
 
@@ -158,32 +156,27 @@ static int ynandif_IsBlockOk(struct yaffs_dev *dev, int blockId)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
-       return geometry->checkBlockOk(dev,blockId);
+       return geometry->checkBlockOk(dev, blockId);
 }
 
-int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, 
+int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId,
                enum yaffs_block_state *state, u32 *seq_number)
 {
        unsigned chunkNo;
        struct yaffs_ext_tags tags;
 
        *seq_number = 0;
-       
+
        chunkNo = blockId * dev->param.chunks_per_block;
-       
-       if(!ynandif_IsBlockOk(dev,blockId)){
+
+       if (!ynandif_IsBlockOk(dev, blockId)) {
                *state = YAFFS_BLOCK_STATE_DEAD;
-       } 
-       else 
-       {
-               ynandif_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
+       } else {
+               ynandif_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &tags);
 
-               if(!tags.chunk_used)
-               {
+               if (!tags.chunk_used) {
                        *state = YAFFS_BLOCK_STATE_EMPTY;
-               }
-               else 
-               {
+               } else {
                        *state = YAFFS_BLOCK_STATE_NEEDS_SCAN;
                        *seq_number = tags.seq_number;
                }
@@ -212,34 +205,38 @@ int ynandif_Deinitialise_flash_fn(struct yaffs_dev *dev)
 }
 
 
-struct yaffs_dev * 
+struct yaffs_dev *
        yaffs_add_dev_from_geometry(const YCHAR *name,
                                        const ynandif_Geometry *geometry)
 {
-       YCHAR *clonedName = malloc(sizeof(YCHAR) * (strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
+       YCHAR *clonedName = malloc(sizeof(YCHAR) *
+                               (strnlen(name, YAFFS_MAX_NAME_LENGTH)+1));
        struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev));
-
-       if(dev && clonedName){
-               memset(dev,0,sizeof(struct yaffs_dev));
-               strcpy(clonedName,name);
-
-               dev->param.name = clonedName;
-               dev->param.write_chunk_tags_fn = ynandif_WriteChunkWithTagsToNAND;
-               dev->param.read_chunk_tags_fn = ynandif_ReadChunkWithTagsFromNAND;
-               dev->param.erase_fn = ynandif_EraseBlockInNAND;
-               dev->param.initialise_flash_fn = ynandif_InitialiseNAND;
-               dev->param.query_block_fn = ynandif_QueryNANDBlock;
-               dev->param.bad_block_fn = ynandif_MarkNANDBlockBad;
-               dev->param.n_caches = 20;
-               dev->param.start_block = geometry->start_block;
-               dev->param.end_block   = geometry->end_block;
-               dev->param.total_bytes_per_chunk  = geometry->dataSize;
-               dev->param.spare_bytes_per_chunk  = geometry->spareSize;
-               dev->param.inband_tags            = geometry->inband_tags;
-               dev->param.chunks_per_block       = geometry->pagesPerBlock;
-               dev->param.use_nand_ecc           = geometry->hasECC;
-               dev->param.is_yaffs2              = geometry->useYaffs2;
-               dev->param.n_reserved_blocks      = 5;
+       struct yaffs_param *param;
+
+       if (dev && clonedName) {
+               memset(dev, 0, sizeof(struct yaffs_dev));
+               strcpy(clonedName, name);
+
+               param = &dev->param;
+
+               param->name = clonedName;
+               param->write_chunk_tags_fn = ynandif_WriteChunkWithTagsToNAND;
+               param->read_chunk_tags_fn = ynandif_ReadChunkWithTagsFromNAND;
+               param->erase_fn = ynandif_EraseBlockInNAND;
+               param->initialise_flash_fn = ynandif_InitialiseNAND;
+               param->query_block_fn = ynandif_QueryNANDBlock;
+               param->bad_block_fn = ynandif_MarkNANDBlockBad;
+               param->n_caches = 20;
+               param->start_block = geometry->start_block;
+               param->end_block   = geometry->end_block;
+               param->total_bytes_per_chunk  = geometry->dataSize;
+               param->spare_bytes_per_chunk  = geometry->spareSize;
+               param->inband_tags                = geometry->inband_tags;
+               param->chunks_per_block   = geometry->pagesPerBlock;
+               param->use_nand_ecc               = geometry->hasECC;
+               param->is_yaffs2                  = geometry->useYaffs2;
+               param->n_reserved_blocks          = 5;
                dev->driver_context               = (void *)geometry;
 
                yaffs_add_device(dev);
@@ -247,10 +244,8 @@ struct yaffs_dev *
                return dev;
        }
 
-       if(dev)
-               free(dev);
-       if(clonedName)
-               free(clonedName);
+       free(dev);
+       free(clonedName);
 
        return NULL;
 }
index 5065e7f..f2b2186 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -19,8 +19,7 @@
 
 #include "yaffs_guts.h"
 
-
-typedef struct {
+struct ynandif_Geometry {
        unsigned start_block;
        unsigned end_block;
        unsigned dataSize;
@@ -34,16 +33,20 @@ typedef struct {
        int (*deinitialise)(struct yaffs_dev *dev);
 
        int (*readChunk) (struct yaffs_dev *dev,
-                                         unsigned pageId, 
-                                         unsigned char *data, unsigned dataLength,
-                                         unsigned char *spare, unsigned spareLength,
+                                         unsigned pageId,
+                                         unsigned char *data,
+                                         unsigned dataLength,
+                                         unsigned char *spare,
+                                         unsigned spareLength,
                                          int *eccStatus);
-// ECC status is set to 0 for OK, 1 for fixed, -1 for unfixed.
+       /* ECC status is set to 0 for OK, 1 for fixed, -1 for unfixed. */
 
        int (*writeChunk)(struct yaffs_dev *dev,
-                                         unsigned pageId, 
-                                         const unsigned char *data, unsigned dataLength,
-                                         const unsigned char *spare, unsigned spareLength);
+                                         unsigned pageId,
+                                         const unsigned char *data,
+                                         unsigned dataLength,
+                                         const unsigned char *spare,
+                                         unsigned spareLength);
 
        int (*eraseBlock)(struct yaffs_dev *dev, unsigned blockId);
 
@@ -52,22 +55,11 @@ typedef struct {
 
        void *privateData;
 
-} ynandif_Geometry;
+};
 
-struct yaffs_dev * 
+struct yaffs_dev *
        yaffs_add_dev_from_geometry(const YCHAR *name,
                                        const ynandif_Geometry *geometry);
 
-#if 0
-
-int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
-int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
-int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
-int ynandif_InitialiseNAND(struct yaffs_dev *dev);
-int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev,int blockNumber);
-int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number);
-int ynandif_GetGeometry(struct yaffs_dev *dev, ynandif_Geometry *geometry);
-#endif
-
 
 #endif
index e81c8e8..bb008f9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -36,7 +36,7 @@ void *yaffsfs_malloc(size_t size);
 void yaffsfs_free(void *ptr);
 
 void yaffsfs_OSInitialisation(void);
+
 
 #endif
 
index 187519f..afd1ffa 100644 (file)
 /*
  * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
  */
-#define swapcode(TYPE, parmi, parmj, n) do {           \
-       long i = (n) / sizeof (TYPE);                   \
-       register TYPE *pi = (TYPE *) (parmi);           \
-       register TYPE *pj = (TYPE *) (parmj);           \
-       do {                                            \
+#define swapcode(TYPE, parmi, parmj, n) do {           \
+       long i = (n) / sizeof(TYPE);                    \
+       register TYPE *pi = (TYPE *) (parmi);           \
+       register TYPE *pj = (TYPE *) (parmj);           \
+       do {                                            \
                register TYPE   t = *pi;                \
                *pi++ = *pj;                            \
                *pj++ = t;                              \
@@ -47,7 +47,7 @@
 #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
        es % sizeof(long) ? 2 : es == sizeof(long) ? 0 : 1;
 
-static __inline void
+static inline void
 swapfunc(char *a, char *b, int n, int swaptype)
 {
        if (swaptype <= 1)
@@ -65,9 +65,9 @@ swapfunc(char *a, char *b, int n, int swaptype)
                swapfunc(a, b, es, swaptype);           \
 } while (0)
 
-#define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
+#define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
 
-static __inline char *
+static inline char *
 med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
 {
        return cmp(a, b) < 0 ?
index c068642..1ffaae9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
 #define __YAFFSCFG_H__
 
 
-#include "yportenv.h"     
+#include "yportenv.h"
 
 #define YAFFSFS_N_HANDLES      100
 #define YAFFSFS_N_DSC          20
 
 
-typedef struct yaffsfs_DeviceConfigurationStruct {
+struct yaffsfs_DeviceConfiguration {
        const YCHAR *prefix;
        struct yaffs_dev *dev;
-} yaffsfs_DeviceConfiguration;
+};
 
 
 #endif
index 2110fe8..9f1397b 100644 (file)
 #define NULL ((void *)0)
 #endif
 
-
 /* YAFFSFS_RW_SIZE must be a power of 2 */
 #define YAFFSFS_RW_SHIFT (13)
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
 /* Some forward references */
 static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory,
-                       const YCHAR *path,
-                       int symDepth, int getEquiv,
-                       struct yaffs_obj **dirOut,
-                       int *notDir, int *loop);
+                                           const YCHAR *path,
+                                           int symDepth, int getEquiv,
+                                           struct yaffs_obj **dirOut,
+                                           int *notDir, int *loop);
 
 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
 
@@ -43,7 +42,7 @@ unsigned int yaffs_wr_attempts;
 
 /*
  * Handle management.
- * There are open inodes in yaffsfs_Inode.
+ * There are open inodes in struct yaffsfs_Inode.
  * There are open file descriptors in yaffsfs_FileDes.
  * There are open handles in yaffsfs_FileDes.
  *
@@ -62,49 +61,46 @@ unsigned int yaffs_wr_attempts;
  * has its own permsiions and offset.
  */
 
-typedef struct {
-       int count;      /* Number of handles accessing this inode */
+struct yaffsfs_Inode {
+       int count;              /* Number of handles accessing this inode */
        struct yaffs_obj *iObj;
-} yaffsfs_Inode;
-
-typedef struct{
-       u8      reading:1;
-       u8      writing:1;
-       u8      append:1;
-       u8      shareRead:1;
-       u8      shareWrite:1;
-       int     inodeId:12;     /* Index to corresponding yaffsfs_Inode */
-       int     handleCount:10; /* Number of handles for this fd */
-       loff_t  position;               /* current position in file */
-}yaffsfs_FileDes;
-
-typedef struct {
+};
+
+struct yaffsfs_FileDes {
+       u8 reading:1;
+       u8 writing:1;
+       u8 append:1;
+       u8 shareRead:1;
+       u8 shareWrite:1;
+       int inodeId:12;         /* Index to corresponding yaffsfs_Inode */
+       int handleCount:10;     /* Number of handles for this fd */
+       loff_t position;        /* current position in file */
+};
+
+struct yaffsfs_Handle {
        short int fdId;
        short int useCount;
-} yaffsfs_Handle;
-
+};
 
-typedef struct
-{
-       yaffs_dirent de;                /* directory entry being used by this dsc */
-       YCHAR name[NAME_MAX+1];         /* name of directory being searched */
-        struct yaffs_obj *dirObj;           /* ptr to directory being searched */
-        struct yaffs_obj *nextReturn;       /* obj to be returned by next readddir */
-        struct list_head others;
-        int offset:20;
-        unsigned inUse:1;
-} yaffsfs_DirectorySearchContext;
 
+struct yaffsfs_DirSearchContxt {
+       struct yaffs_dirent de; /* directory entry */
+       YCHAR name[NAME_MAX + 1];       /* name of directory being searched */
+       struct yaffs_obj *dirObj;       /* ptr to directory being searched */
+       struct yaffs_obj *nextReturn;   /* obj  returned by next readddir */
+       struct list_head others;
+       int offset:20;
+       unsigned inUse:1;
+};
 
-static yaffsfs_DirectorySearchContext yaffsfs_dsc[YAFFSFS_N_DSC];
-static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
-static yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES];
-static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
+static struct yaffsfs_DirSearchContxt yaffsfs_dsc[YAFFSFS_N_DSC];
+static struct yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
+static struct yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES];
+static struct yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 
 static int yaffsfs_handlesInitialised;
 
-
-unsigned yaffs_set_trace(unsigned  tm)
+unsigned yaffs_set_trace(unsigned tm)
 {
        yaffs_trace_mask = tm;
        return yaffs_trace_mask;
@@ -123,53 +119,53 @@ unsigned yaffs_get_trace(void)
 static void yaffsfs_InitHandles(void)
 {
        int i;
-       if(yaffsfs_handlesInitialised)
-                return;
+       if (yaffsfs_handlesInitialised)
+               return;
 
        memset(yaffsfs_inode, 0, sizeof(yaffsfs_inode));
        memset(yaffsfs_fd, 0, sizeof(yaffsfs_fd));
        memset(yaffsfs_handle, 0, sizeof(yaffsfs_handle));
        memset(yaffsfs_dsc, 0, sizeof(yaffsfs_dsc));
 
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
+       for (i = 0; i < YAFFSFS_N_HANDLES; i++)
                yaffsfs_fd[i].inodeId = -1;
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
+       for (i = 0; i < YAFFSFS_N_HANDLES; i++)
                yaffsfs_handle[i].fdId = -1;
 }
 
-static yaffsfs_Handle *yaffsfs_HandleToPointer(int h)
+static struct yaffsfs_Handle *yaffsfs_HandleToPointer(int h)
 {
-       if(h >= 0 && h < YAFFSFS_N_HANDLES)
+       if (h >= 0 && h < YAFFSFS_N_HANDLES)
                return &yaffsfs_handle[h];
        return NULL;
 }
 
-static yaffsfs_FileDes *yaffsfs_HandleToFileDes(int handle)
+static struct yaffsfs_FileDes *yaffsfs_HandleToFileDes(int handle)
 {
-       yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
+       struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 
-       if(h && h->useCount > 0 && h->fdId >= 0 && h->fdId < YAFFSFS_N_HANDLES)
-               return  &yaffsfs_fd[h->fdId];
+       if (h && h->useCount > 0 && h->fdId >= 0 && h->fdId < YAFFSFS_N_HANDLES)
+               return &yaffsfs_fd[h->fdId];
 
        return NULL;
 }
 
-static yaffsfs_Inode *yaffsfs_HandleToInode(int handle)
+static struct yaffsfs_Inode *yaffsfs_HandleToInode(int handle)
 {
-       yaffsfs_FileDes *fd = yaffsfs_HandleToFileDes(handle);
+       struct yaffsfs_FileDes *fd = yaffsfs_HandleToFileDes(handle);
 
-       if(fd && fd->handleCount > 0 &&
-               fd->inodeId >= 0 && fd->inodeId < YAFFSFS_N_HANDLES)
-               return  &yaffsfs_inode[fd->inodeId];
+       if (fd && fd->handleCount > 0 &&
+           fd->inodeId >= 0 && fd->inodeId < YAFFSFS_N_HANDLES)
+               return &yaffsfs_inode[fd->inodeId];
 
        return NULL;
 }
 
 static struct yaffs_obj *yaffsfs_HandleToObject(int handle)
 {
-       yaffsfs_Inode *in = yaffsfs_HandleToInode(handle);
+       struct yaffsfs_Inode *in = yaffsfs_HandleToInode(handle);
 
-       if(in)
+       if (in)
                return in->iObj;
 
        return NULL;
@@ -185,12 +181,12 @@ static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)
        int i;
        int ret = -1;
 
-       if(obj)
+       if (obj)
                obj = yaffs_get_equivalent_obj(obj);
 
-       /* Look for it in open inode table*/
-       for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
-               if(yaffsfs_inode[i].iObj == obj)
+       /* Look for it in open inode table */
+       for (i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++) {
+               if (yaffsfs_inode[i].iObj == obj)
                        ret = i;
        }
        return ret;
@@ -204,48 +200,46 @@ static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)
 {
        int i;
        int ret;
-       yaffsfs_Inode *in = NULL;
+       struct yaffsfs_Inode *in = NULL;
 
-       if(obj)
+       if (obj)
                obj = yaffs_get_equivalent_obj(obj);
 
-        ret = yaffsfs_FindInodeIdForObject(obj);
+       ret = yaffsfs_FindInodeIdForObject(obj);
 
-       for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
-               if(!yaffsfs_inode[i].iObj)
+       for (i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++) {
+               if (!yaffsfs_inode[i].iObj)
                        ret = i;
        }
 
-       if(ret>=0){
+       if (ret >= 0) {
                in = &yaffsfs_inode[ret];
-               if(!in->iObj)
+               if (!in->iObj)
                        in->count = 0;
                in->iObj = obj;
                in->count++;
        }
 
-
        return ret;
 }
 
-
 static int yaffsfs_CountHandles(struct yaffs_obj *obj)
 {
        int i = yaffsfs_FindInodeIdForObject(obj);
 
-       if(i >= 0)
+       if (i >= 0)
                return yaffsfs_inode[i].count;
        else
                return 0;
 }
 
-static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
+static void yaffsfs_ReleaseInode(struct yaffsfs_Inode *in)
 {
        struct yaffs_obj *obj;
 
        obj = in->iObj;
 
-       if(obj->unlinked)
+       if (obj->unlinked)
                yaffs_del_obj(obj);
 
        obj->my_inode = NULL;
@@ -255,30 +249,28 @@ static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 
 static void yaffsfs_PutInode(int inodeId)
 {
-       if(inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES){
-               yaffsfs_Inode *in = & yaffsfs_inode[inodeId];
+       if (inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES) {
+               struct yaffsfs_Inode *in = &yaffsfs_inode[inodeId];
                in->count--;
-               if(in->count <= 0){
+               if (in->count <= 0) {
                        yaffsfs_ReleaseInode(in);
                        in->count = 0;
                }
        }
 }
 
-
-
-static int yaffsfs_NewHandle(yaffsfs_Handle **hptr)
+static int yaffsfs_NewHandle(struct yaffsfs_Handle **hptr)
 {
        int i;
-       yaffsfs_Handle *h;
+       struct yaffsfs_Handle *h;
 
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+       for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
                h = &yaffsfs_handle[i];
-               if(h->useCount < 1){
-                       memset(h,0,sizeof(yaffsfs_Handle));
-                       h->fdId=-1;
-                       h->useCount=1;
-                       if(hptr)
+               if (h->useCount < 1) {
+                       memset(h, 0, sizeof(struct yaffsfs_Handle));
+                       h->fdId = -1;
+                       h->useCount = 1;
+                       if (hptr)
                                *hptr = h;
                        return i;
                }
@@ -289,19 +281,19 @@ static int yaffsfs_NewHandle(yaffsfs_Handle **hptr)
 static int yaffsfs_NewHandleAndFileDes(void)
 {
        int i;
-       yaffsfs_FileDes *fd;
-       yaffsfs_Handle  *h = NULL;
+       struct yaffsfs_FileDes *fd;
+       struct yaffsfs_Handle *h = NULL;
        int handle = yaffsfs_NewHandle(&h);
 
-       if(handle < 0)
+       if (handle < 0)
                return -1;
 
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+       for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
                fd = &yaffsfs_fd[i];
-               if(fd->handleCount < 1){
-                       memset(fd,0,sizeof(yaffsfs_FileDes));
-                       fd->inodeId=-1;
-                       fd->handleCount=1;
+               if (fd->handleCount < 1) {
+                       memset(fd, 0, sizeof(struct yaffsfs_FileDes));
+                       fd->inodeId = -1;
+                       fd->handleCount = 1;
                        h->fdId = i;
                        return handle;
                }
@@ -320,9 +312,9 @@ static int yaffsfs_NewHandleAndFileDes(void)
 
 static int yaffsfs_GetHandle(int handle)
 {
-       yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
+       struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 
-       if(h && h->useCount > 0){
+       if (h && h->useCount > 0) {
                h->useCount++;
                return 0;
        }
@@ -337,13 +329,13 @@ static int yaffsfs_GetHandle(int handle)
 
 static int yaffsfs_PutFileDes(int fdId)
 {
-       yaffsfs_FileDes *fd;
+       struct yaffsfs_FileDes *fd;
 
-       if(fdId >= 0 && fdId < YAFFSFS_N_HANDLES){
+       if (fdId >= 0 && fdId < YAFFSFS_N_HANDLES) {
                fd = &yaffsfs_fd[fdId];
                fd->handleCount--;
-               if(fd->handleCount < 1){
-                       if(fd->inodeId >= 0){
+               if (fd->handleCount < 1) {
+                       if (fd->inodeId >= 0) {
                                yaffsfs_PutInode(fd->inodeId);
                                fd->inodeId = -1;
                        }
@@ -351,13 +343,14 @@ static int yaffsfs_PutFileDes(int fdId)
        }
        return 0;
 }
+
 static int yaffsfs_PutHandle(int handle)
 {
-       yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
+       struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 
-       if(h && h->useCount > 0){
+       if (h && h->useCount > 0) {
                h->useCount--;
-               if(h->useCount < 1){
+               if (h->useCount < 1) {
                        yaffsfs_PutFileDes(h->fdId);
                        h->fdId = -1;
                }
@@ -368,20 +361,19 @@ static int yaffsfs_PutHandle(int handle)
 
 static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
 {
-       yaffsfs_FileDes *fd;
-       yaffsfs_Handle *h;
+       struct yaffsfs_FileDes *fd;
+       struct yaffsfs_Handle *h;
        struct yaffs_obj *obj;
        int i;
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+       for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
                h = yaffsfs_HandleToPointer(i);
                fd = yaffsfs_HandleToFileDes(i);
                obj = yaffsfs_HandleToObject(i);
-               if(h && h->useCount > 0){
+               if (h && h->useCount > 0) {
                        h->useCount = 0;
                        h->fdId = 0;
                }
-               if(fd && fd->handleCount>0 && obj && obj->my_dev == dev){
-
+               if (fd && fd->handleCount > 0 && obj && obj->my_dev == dev) {
                        fd->handleCount = 0;
                        yaffsfs_PutInode(fd->inodeId);
                        fd->inodeId = -1;
@@ -389,9 +381,6 @@ static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
        }
 }
 
-
-
-
 /*
  *  Stuff to handle names.
  */
@@ -399,7 +388,7 @@ static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
 
 static int yaffs_toupper(YCHAR a)
 {
-       if(a >= 'a' && a <= 'z')
+       if (a >= 'a' && a <= 'z')
                return (a - 'a') + 'A';
        else
                return a;
@@ -421,8 +410,8 @@ int yaffsfs_IsPathDivider(YCHAR ch)
 {
        const YCHAR *str = YAFFS_PATH_DIVIDERS;
 
-       while(*str){
-               if(*str == ch)
+       while (*str) {
+               if (*str == ch)
                        return 1;
                str++;
        }
@@ -434,12 +423,12 @@ int yaffsfs_CheckNameLength(const char *name)
 {
        int retVal = 0;
 
-       int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+       int nameLength = yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH + 1);
 
-       if(nameLength == 0){
+       if (nameLength == 0) {
                yaffsfs_SetError(-ENOENT);
                retVal = -1;
-       } else if (nameLength > YAFFS_MAX_NAME_LENGTH){
+       } else if (nameLength > YAFFS_MAX_NAME_LENGTH) {
                yaffsfs_SetError(-ENAMETOOLONG);
                retVal = -1;
        }
@@ -447,7 +436,6 @@ int yaffsfs_CheckNameLength(const char *name)
        return retVal;
 }
 
-
 static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
 {
        YCHAR *alt_path = NULL;
@@ -459,7 +447,7 @@ static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
         * We will use 3 * max name length instead.
         */
        *ret_path = NULL;
-       path_length = yaffs_strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
+       path_length = yaffs_strnlen(path, (YAFFS_MAX_NAME_LENGTH + 1) * 3 + 1);
 
        /* If the last character is a path divider, then we need to
         * trim it back so that the name look-up works properly.
@@ -467,22 +455,19 @@ static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
         * Curveball: Need to handle multiple path dividers:
         * eg. /foof/sdfse///// -> /foo/sdfse
         */
-       if(path_length > 0 &&
-               yaffsfs_IsPathDivider(path[path_length-1])){
+       if (path_length > 0 && yaffsfs_IsPathDivider(path[path_length - 1])) {
                alt_path = kmalloc(path_length + 1, 0);
-               if(!alt_path)
+               if (!alt_path)
                        return -1;
                yaffs_strcpy(alt_path, path);
-               for(i = path_length-1;
-                       i >= 0 && yaffsfs_IsPathDivider(alt_path[i]);
-                       i--)
+               for (i = path_length - 1;
+                    i >= 0 && yaffsfs_IsPathDivider(alt_path[i]); i--)
                        alt_path[i] = (YCHAR) 0;
        }
        *ret_path = alt_path;
        return 0;
 }
 
-
 LIST_HEAD(yaffsfs_deviceList);
 
 /*
@@ -492,7 +477,8 @@ LIST_HEAD(yaffsfs_deviceList);
  * Curveballs: Should match paths that end in '/' too
  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
  */
-static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path,
+                                           YCHAR **restOfPath)
 {
        struct list_head *cfg;
        const YCHAR *leftOver;
@@ -508,31 +494,30 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPat
         * 1) Actually matches a prefix (ie /a amd /abc will not match
         * 2) Matches the longest.
         */
-       list_for_each(cfg, &yaffsfs_deviceList){
+       list_for_each(cfg, &yaffsfs_deviceList) {
                dev = list_entry(cfg, struct yaffs_dev, dev_list);
                leftOver = path;
                p = dev->param.name;
                thisMatchLength = 0;
                matching = 1;
 
-
-               while(matching && *p && *leftOver){
+               while (matching && *p && *leftOver) {
                        /* Skip over any /s */
-                       while(yaffsfs_IsPathDivider(*p))
-                             p++;
+                       while (yaffsfs_IsPathDivider(*p))
+                               p++;
 
                        /* Skip over any /s */
-                       while(yaffsfs_IsPathDivider(*leftOver))
-                             leftOver++;
+                       while (yaffsfs_IsPathDivider(*leftOver))
+                               leftOver++;
 
                        /* Now match the text part */
-                       while(matching &&
-                             *p && !yaffsfs_IsPathDivider(*p) &&
-                             *leftOver && !yaffsfs_IsPathDivider(*leftOver)){
-                               if(yaffsfs_Match(*p,*leftOver)){
-                                       p++;
-                                       leftOver++;
-                                       thisMatchLength++;
+                       while (matching &&
+                              *p && !yaffsfs_IsPathDivider(*p) &&
+                              *leftOver && !yaffsfs_IsPathDivider(*leftOver)) {
+                               if (yaffsfs_Match(*p, *leftOver)) {
+                                       p++;
+                                       leftOver++;
+                                       thisMatchLength++;
                                } else {
                                        matching = 0;
                                }
@@ -540,21 +525,20 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPat
                }
 
                /* Skip over any /s in leftOver */
-               while(yaffsfs_IsPathDivider(*leftOver))
-                     leftOver++;
+               while (yaffsfs_IsPathDivider(*leftOver))
+                       leftOver++;
 
-               // Skip over any /s in p
-               while(yaffsfs_IsPathDivider(*p))
-                     p++;
+               /*Skip over any /s in p */
+               while (yaffsfs_IsPathDivider(*p))
+                       p++;
 
-               // p should now be at the end of the string (ie. fully matched)
-               if(*p)
+               /* p should now be at the end of the string if fully matched */
+               if (*p)
                        matching = 0;
 
-               if( matching && (thisMatchLength > longestMatch))
-               {
-                       // Matched prefix
-                       *restOfPath = (YCHAR *)leftOver;
+               if (matching && (thisMatchLength > longestMatch)) {
+                       /* Matched prefix */
+                       *restOfPath = (YCHAR *) leftOver;
                        retval = dev;
                        longestMatch = thisMatchLength;
                }
@@ -565,11 +549,12 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPat
 
 static int yaffsfs_CheckPath(const YCHAR *path)
 {
-       int n=0;
-       int divs=0;
-       while(*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100){
-               if(yaffsfs_IsPathDivider(*path)){
-                       n=0;
+       int n = 0;
+       int divs = 0;
+
+       while (*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100) {
+               if (yaffsfs_IsPathDivider(*path)) {
+                       n = 0;
                        divs++;
                } else
                        n++;
@@ -583,48 +568,51 @@ static int yaffsfs_CheckPath(const YCHAR *path)
 static struct yaffs_dev *yaffsfs_FindMountPoint(const YCHAR *path)
 {
        struct yaffs_dev *dev;
-       YCHAR *restOfPath=NULL;
-       dev = yaffsfs_FindDevice(path,&restOfPath);
-       if(dev && restOfPath && *restOfPath)
+       YCHAR *restOfPath = NULL;
+
+       dev = yaffsfs_FindDevice(path, &restOfPath);
+       if (dev && restOfPath && *restOfPath)
                dev = NULL;
        return dev;
 }
 
-static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path,
+                                         YCHAR **restOfPath)
 {
-
        struct yaffs_dev *dev;
 
-       dev= yaffsfs_FindDevice(path,restOfPath);
-       if(dev && dev->is_mounted){
+       dev = yaffsfs_FindDevice(path, restOfPath);
+       if (dev && dev->is_mounted)
                return dev->root_dir;
-       }
+
        return NULL;
 }
 
 static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
-                                       int symDepth, int *loop)
+                                           int symDepth, int *loop)
 {
 
-       if(obj)
+       if (obj)
                obj = yaffs_get_equivalent_obj(obj);
 
-       while(obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){
+       while (obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
                YCHAR *alias = obj->variant.symlink_variant.alias;
 
-               if(yaffsfs_IsPathDivider(*alias))
+               if (yaffsfs_IsPathDivider(*alias))
                        /* Starts with a /, need to scan from root up */
-                       obj = yaffsfs_FindObject(NULL,alias,symDepth++,
-                                               1,NULL,NULL,loop);
+                       obj = yaffsfs_FindObject(NULL, alias, symDepth++,
+                                                1, NULL, NULL, loop);
                else
-                       /* Relative to here, so use the parent of the symlink as a start */
-                       obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,
-                                               1,NULL,NULL,loop);
+                       /*
+                        * Relative to here so use the parent of the
+                        * symlink as a start
+                        */
+                       obj = yaffsfs_FindObject(obj->parent, alias, symDepth++,
+                                                1, NULL, NULL, loop);
        }
        return obj;
 }
 
-
 /*
  * yaffsfs_FindDirectory
  * Parse a path to determine the directory and the name within the directory.
@@ -632,65 +620,64 @@ static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
  */
 static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
-                               const YCHAR *path, YCHAR **name, int symDepth,
-                               int *notDir,int *loop)
+                                                const YCHAR *path,
+                                                YCHAR **name, int symDepth,
+                                                int *notDir, int *loop)
 {
        struct yaffs_obj *dir;
        YCHAR *restOfPath;
-       YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
+       YCHAR str[YAFFS_MAX_NAME_LENGTH + 1];
        int i;
 
-       if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES){
-               if(loop)
+       if (symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES) {
+               if (loop)
                        *loop = 1;
                return NULL;
        }
 
-       if(startDir){
+       if (startDir) {
                dir = startDir;
-               restOfPath = (YCHAR *)path;
-       }
-       else
-               dir = yaffsfs_FindRoot(path,&restOfPath);
-
+               restOfPath = (YCHAR *) path;
+       } else
+               dir = yaffsfs_FindRoot(path, &restOfPath);
 
-       while(dir){
+       while (dir) {
                /*
                 * parse off /.
                 * curve ball: also throw away surplus '/'
                 * eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
                 */
-               while(yaffsfs_IsPathDivider(*restOfPath))
-                       restOfPath++; /* get rid of '/' */
+               while (yaffsfs_IsPathDivider(*restOfPath))
+                       restOfPath++;   /* get rid of '/' */
 
                *name = restOfPath;
                i = 0;
 
-               while(*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)){
-                       if (i < YAFFS_MAX_NAME_LENGTH){
+               while (*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)) {
+                       if (i < YAFFS_MAX_NAME_LENGTH) {
                                str[i] = *restOfPath;
-                               str[i+1] = '\0';
+                               str[i + 1] = '\0';
                                i++;
                        }
                        restOfPath++;
                }
 
-               if(!*restOfPath)
+               if (!*restOfPath)
                        /* got to the end of the string */
                        return dir;
-               else{
-                       if(yaffs_strcmp(str,_Y(".")) == 0){
+               else {
+                       if (yaffs_strcmp(str, _Y(".")) == 0) {
                                /* Do nothing */
-                       } else if(yaffs_strcmp(str,_Y("..")) == 0) {
+                       } else if (yaffs_strcmp(str, _Y("..")) == 0) {
                                dir = dir->parent;
-                       } else{
-                               dir = yaffs_find_by_name(dir,str);
+                       } else {
+                               dir = yaffs_find_by_name(dir, str);
 
-                               dir = yaffsfs_FollowLink(dir,symDepth,loop);
+                               dir = yaffsfs_FollowLink(dir, symDepth, loop);
 
-                               if(dir && dir->variant_type !=
-                                       YAFFS_OBJECT_TYPE_DIRECTORY){
-                                       if(notDir)
+                               if (dir && dir->variant_type !=
+                                   YAFFS_OBJECT_TYPE_DIRECTORY) {
+                                       if (notDir)
                                                *notDir = 1;
                                        dir = NULL;
                                }
@@ -703,43 +690,45 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
 }
 
 static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relDir,
-                                       const YCHAR *path,
-                                       YCHAR **name,
-                                       int symDepth,
-                                       int *notDir,
-                                       int *loop)
+                                              const YCHAR *path,
+                                              YCHAR **name,
+                                              int symDepth,
+                                              int *notDir, int *loop)
 {
-       return yaffsfs_DoFindDirectory(relDir,path,name,symDepth,notDir,loop);
+       return yaffsfs_DoFindDirectory(relDir, path, name, symDepth, notDir,
+                                               loop);
 }
 
 /*
  * yaffsfs_FindObject turns a path for an existing object into the object
  */
 static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
-                       const YCHAR *path,int symDepth, int getEquiv,
-                       struct yaffs_obj **dirOut, int *notDir,int *loop)
+                                           const YCHAR *path, int symDepth,
+                                           int getEquiv,
+                                           struct yaffs_obj **dirOut,
+                                           int *notDir, int *loop)
 {
        struct yaffs_obj *dir;
        struct yaffs_obj *obj;
        YCHAR *name;
 
-       dir = yaffsfs_FindDirectory(relDir,path,&name,symDepth,notDir,loop);
+       dir =
+           yaffsfs_FindDirectory(relDir, path, &name, symDepth, notDir, loop);
 
-       if(dirOut)
-               *dirOut =  dir;
+       if (dirOut)
+               *dirOut = dir;
 
-       if(dir && *name)
-               obj = yaffs_find_by_name(dir,name);
+       if (dir && *name)
+               obj = yaffs_find_by_name(dir, name);
        else
                obj = dir;
 
-       if(getEquiv)
+       if (getEquiv)
                obj = yaffs_get_equivalent_obj(obj);
 
        return obj;
 }
 
-
 /*************************************************************************
  *     Start of yaffsfs visible functions.
  *************************************************************************/
@@ -747,23 +736,23 @@ static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
 int yaffs_dup(int handle)
 {
        int newHandleNumber = -1;
-       yaffsfs_FileDes *existingFD = NULL;
-       yaffsfs_Handle *existingHandle = NULL;
-       yaffsfs_Handle *newHandle = NULL;
+       struct yaffsfs_FileDes *existingFD = NULL;
+       struct yaffsfs_Handle *existingHandle = NULL;
+       struct yaffsfs_Handle *newHandle = NULL;
 
        yaffsfs_Lock();
        existingHandle = yaffsfs_HandleToPointer(handle);
        existingFD = yaffsfs_HandleToFileDes(handle);
-       if(existingFD)
+       if (existingFD)
                newHandleNumber = yaffsfs_NewHandle(&newHandle);
-       if(newHandle){
+       if (newHandle) {
                newHandle->fdId = existingHandle->fdId;
                existingFD->handleCount++;
        }
 
        yaffsfs_Unlock();
 
-       if(!existingFD)
+       if (!existingFD)
                yaffsfs_SetError(-EBADF);
        else if (!newHandle)
                yaffsfs_SetError(-ENOMEM);
@@ -776,7 +765,7 @@ static int yaffsfs_TooManyObjects(struct yaffs_dev *dev)
 {
        int current_objects = dev->n_obj - dev->n_deleted_files;
 
-       if(dev->param.max_objects && current_objects > dev->param.max_objects)
+       if (dev->param.max_objects && current_objects > dev->param.max_objects)
                return 1;
        else
                return 0;
@@ -788,12 +777,12 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
        struct yaffs_obj *dir = NULL;
        YCHAR *name;
        int handle = -1;
-       yaffsfs_FileDes *fd = NULL;
+       struct yaffsfs_FileDes *fd = NULL;
        int openDenied = 0;
        int symDepth = 0;
        int errorReported = 0;
-       int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);
-       u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
+       int rwflags = oflag & (O_RDWR | O_RDONLY | O_WRONLY);
+       u8 shareRead = (sharing & YAFFS_SHARE_READ) ? 1 : 0;
        u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
        u8 sharedReadAllowed;
        u8 sharedWriteAllowed;
@@ -804,22 +793,22 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
        int notDir = 0;
        int loop = 0;
 
-       if(!path) {
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        /* O_EXCL only has meaning if O_CREAT is specified */
-       if(!(oflag & O_CREAT))
+       if (!(oflag & O_CREAT))
                oflag &= ~(O_EXCL);
 
        /* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */
-       if(oflag & O_CREAT) & (oflag & O_EXCL))
+       if ((oflag & O_CREAT) & (oflag & O_EXCL))
                oflag &= ~(O_TRUNC);
 
        /* Todo: Are there any more flag combos to sanitise ? */
@@ -833,7 +822,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 
        handle = yaffsfs_NewHandleAndFileDes();
 
-       if(handle < 0){
+       if (handle < 0) {
                yaffsfs_SetError(-ENFILE);
                errorReported = 1;
        } else {
@@ -841,90 +830,88 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                fd = yaffsfs_HandleToFileDes(handle);
 
                /* try to find the exisiting object */
-               obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
+               obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL);
 
-               obj = yaffsfs_FollowLink(obj,symDepth++,&loop);
+               obj = yaffsfs_FollowLink(obj, symDepth++, &loop);
 
-               if(obj &&
-                       obj->variant_type != YAFFS_OBJECT_TYPE_FILE &&
-                       obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+               if (obj &&
+                   obj->variant_type != YAFFS_OBJECT_TYPE_FILE &&
+                   obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 
-
-               if(obj){
+               if (obj) {
 
                        /* The file already exists or it might be a directory */
 
-                       /* If it is a directory then we can't open it as a file */
-                       if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+                       /* A directory can't be opened as a file */
+                       if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
                                openDenied = 1;
                                yaffsfs_SetError(-EISDIR);
                                errorReported = 1;
                        }
 
-                       /* Open should fail if O_CREAT and O_EXCL are specified since
-                        * the file exists
+                       /* Open should fail if O_CREAT and O_EXCL are specified
+                        * for a file that exists.
                         */
-                       if(!errorReported && (oflag & O_EXCL) && (oflag & O_CREAT)){
+                       if (!errorReported &&
+                           (oflag & O_EXCL) && (oflag & O_CREAT)) {
                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
                        }
 
                        /* Check file permissions */
-                       ifreadRequested && !(obj->yst_mode & S_IREAD))
+                       if (readRequested && !(obj->yst_mode & S_IREAD))
                                openDenied = 1;
 
-                       ifwriteRequested && !(obj->yst_mode & S_IWRITE))
+                       if (writeRequested && !(obj->yst_mode & S_IWRITE))
                                openDenied = 1;
 
-                       if!errorReported && writeRequested &&
-                               obj->my_dev->read_only){
+                       if (!errorReported && writeRequested &&
+                           obj->my_dev->read_only) {
                                openDenied = 1;
                                yaffsfs_SetError(-EROFS);
                                errorReported = 1;
                        }
 
-                       if(openDenied && !errorReported ) {
-                               /* Error if the file exists but permissions are refused. */
+                       if (openDenied && !errorReported) {
                                yaffsfs_SetError(-EACCES);
                                errorReported = 1;
                        }
 
                        /* Check sharing of an existing object. */
-                       if(!openDenied){
-                               yaffsfs_FileDes *fdx;
+                       if (!openDenied) {
+                               struct yaffsfs_FileDes *fdx;
                                int i;
 
                                sharedReadAllowed = 1;
                                sharedWriteAllowed = 1;
                                alreadyReading = 0;
                                alreadyWriting = 0;
-                               for( i = 0; i < YAFFSFS_N_HANDLES; i++){
+                               for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
                                        fdx = &yaffsfs_fd[i];
-                                       if(fdx->handleCount > 0 &&
-                                               fdx->inodeId >= 0 &&
-                                               yaffsfs_inode[fdx->inodeId].iObj == obj){
-                                               if(!fdx->shareRead)
+                                       if (fdx->handleCount > 0 &&
+                                           fdx->inodeId >= 0 &&
+                                           yaffsfs_inode[fdx->inodeId].iObj
+                                           == obj) {
+                                               if (!fdx->shareRead)
                                                        sharedReadAllowed = 0;
-                                               if(!fdx->shareWrite)
+                                               if (!fdx->shareWrite)
                                                        sharedWriteAllowed = 0;
-                                               if(fdx->reading)
+                                               if (fdx->reading)
                                                        alreadyReading = 1;
-                                               if(fdx->writing)
+                                               if (fdx->writing)
                                                        alreadyWriting = 1;
                                        }
                                }
 
-
-
-                               if((!sharedReadAllowed && readRequested)||
-                                       (!shareRead  && alreadyReading) ||
-                                       (!sharedWriteAllowed && writeRequested) ||
-                                       (!shareWrite && alreadyWriting)){
+                               if ((!sharedReadAllowed && readRequested) ||
+                                   (!shareRead && alreadyReading) ||
+                                   (!sharedWriteAllowed && writeRequested) ||
+                                   (!shareWrite && alreadyWriting)) {
                                        openDenied = 1;
                                        yaffsfs_SetError(-EBUSY);
-                                       errorReported=1;
+                                       errorReported = 1;
                                }
                        }
 
@@ -933,70 +920,71 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                /* If we could not open an existing object, then let's see if
                 * the directory exists. If not, error.
                 */
-               if(!obj && !errorReported){
-                       dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
-                       if(!dir && notDir){
+               if (!obj && !errorReported) {
+                       dir = yaffsfs_FindDirectory(NULL, path, &name, 0,
+                                                   &notDir, &loop);
+                       if (!dir && notDir) {
                                yaffsfs_SetError(-ENOTDIR);
                                errorReported = 1;
-                       } else if(loop){
+                       } else if (loop) {
                                yaffsfs_SetError(-ELOOP);
                                errorReported = 1;
-                       } else  if(!dir){
+                       } else if (!dir) {
                                yaffsfs_SetError(-ENOENT);
                                errorReported = 1;
                        }
                }
 
-               if(!obj && dir && !errorReported && (oflag & O_CREAT)) {
-                       /* Let's see if we can create this file if it does not exist. */
-                       if(dir->my_dev->read_only){
+               if (!obj && dir && !errorReported && (oflag & O_CREAT)) {
+                       /* Let's see if we can create this file */
+                       if (dir->my_dev->read_only) {
                                yaffsfs_SetError(-EROFS);
                                errorReported = 1;
-                       } else if(yaffsfs_TooManyObjects(dir->my_dev)) {
+                       } else if (yaffsfs_TooManyObjects(dir->my_dev)) {
                                yaffsfs_SetError(-ENFILE);
                                errorReported = 1;
                        } else
-                               obj = yaffs_create_file(dir,name,mode,0,0);
+                               obj = yaffs_create_file(dir, name, mode, 0, 0);
 
-                       if(!obj && !errorReported){
+                       if (!obj && !errorReported) {
                                yaffsfs_SetError(-ENOSPC);
                                errorReported = 1;
                        }
                }
 
-               if(!obj && dir && !errorReported && !(oflag & O_CREAT)) {
-                       /* Error if the file does not exist and CREAT is not set. */
+               if (!obj && dir && !errorReported && !(oflag & O_CREAT)) {
                        yaffsfs_SetError(-ENOENT);
                        errorReported = 1;
                }
 
-               if(obj && !openDenied) {
+               if (obj && !openDenied) {
                        int inodeId = yaffsfs_GetInodeIdForObject(obj);
 
-                       if(inodeId<0) {
+                       if (inodeId < 0) {
                                /*
-                                * Todo: Fix any problem if inodes run out, though that
-                                * can't happen if the number of inode items >= number of handles.
+                                * Todo: Fix any problem if inodes run out,
+                                * That can't happen if the number of inode
+                                * items >= number of handles.
                                 */
                        }
 
                        fd->inodeId = inodeId;
                        fd->reading = readRequested;
                        fd->writing = writeRequested;
-                       fd->append =  (oflag & O_APPEND) ? 1 : 0;
+                       fd->append = (oflag & O_APPEND) ? 1 : 0;
                        fd->position = 0;
                        fd->shareRead = shareRead;
                        fd->shareWrite = shareWrite;
 
                        /* Hook inode to object */
-                        obj->my_inode = (void*) &yaffsfs_inode[inodeId];
+                       obj->my_inode = (void *)&yaffsfs_inode[inodeId];
 
-                        if((oflag & O_TRUNC) && fd->writing)
-                                yaffs_resize_file(obj,0);
+                       if ((oflag & O_TRUNC) && fd->writing)
+                               yaffs_resize_file(obj, 0);
                } else {
                        yaffsfs_PutHandle(handle);
-                       if(!errorReported)
-                               yaffsfs_SetError(0); /* Problem */
+                       if (!errorReported)
+                               yaffsfs_SetError(0);    /* Problem */
                        handle = -1;
                }
        }
@@ -1009,10 +997,10 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 int yaffs_open(const YCHAR *path, int oflag, int mode)
 {
        return yaffs_open_sharing(path, oflag, mode,
-                       YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
+                                 YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
 }
 
-int yaffs_Dofsync(int handle,int datasync)
+int yaffs_Dofsync(int handle, int datasync)
 {
        int retVal = -1;
        struct yaffs_obj *obj;
@@ -1021,12 +1009,12 @@ int yaffs_Dofsync(int handle,int datasync)
 
        obj = yaffsfs_HandleToObject(handle);
 
-       if(!obj)
+       if (!obj)
                yaffsfs_SetError(-EBADF);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
        else {
-               yaffs_flush_file(obj,1,datasync);
+               yaffs_flush_file(obj, 1, datasync);
                retVal = 0;
        }
 
@@ -1037,7 +1025,7 @@ int yaffs_Dofsync(int handle,int datasync)
 
 int yaffs_fsync(int handle)
 {
-       return yaffs_Dofsync(handle,0);
+       return yaffs_Dofsync(handle, 0);
 }
 
 int yaffs_flush(int handle)
@@ -1047,12 +1035,12 @@ int yaffs_flush(int handle)
 
 int yaffs_fdatasync(int handle)
 {
-       return yaffs_Dofsync(handle,1);
+       return yaffs_Dofsync(handle, 1);
 }
 
 int yaffs_close(int handle)
 {
-       yaffsfs_Handle *h = NULL;
+       struct yaffsfs_Handle *h = NULL;
        struct yaffs_obj *obj = NULL;
        int retVal = -1;
 
@@ -1061,11 +1049,11 @@ int yaffs_close(int handle)
        h = yaffsfs_HandleToPointer(handle);
        obj = yaffsfs_HandleToObject(handle);
 
-       if(!h  || !obj)
+       if (!h || !obj)
                yaffsfs_SetError(-EBADF);
        else {
                /* clean up */
-               yaffs_flush_file(obj,1,0);
+               yaffs_flush_file(obj, 1, 0);
                yaffsfs_PutHandle(handle);
                retVal = 0;
        }
@@ -1075,11 +1063,10 @@ int yaffs_close(int handle)
        return retVal;
 }
 
-
-
-int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, int isPread, loff_t offset)
+int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
+                   int isPread, loff_t offset)
 {
-       yaffsfs_FileDes *fd = NULL;
+       struct yaffsfs_FileDes *fd = NULL;
        struct yaffs_obj *obj = NULL;
        loff_t pos = 0;
        loff_t startPos = 0;
@@ -1088,9 +1075,9 @@ int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, int isPread, lof
        int nToRead = 0;
        int totalRead = 0;
        loff_t maxRead;
-       u8 *buf = (u8 *)vbuf;
+       u8 *buf = (u8 *) vbuf;
 
-       if(!vbuf){
+       if (!vbuf) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -1099,48 +1086,48 @@ int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, int isPread, lof
        fd = yaffsfs_HandleToFileDes(handle);
        obj = yaffsfs_HandleToObject(handle);
 
-       if(!fd || !obj){
+       if (!fd || !obj) {
                /* bad handle */
                yaffsfs_SetError(-EBADF);
                totalRead = -1;
-       } else if(!fd->reading){
+       } else if (!fd->reading) {
                /* Not a reading handle */
                yaffsfs_SetError(-EINVAL);
                totalRead = -1;
-       } else if(nbyte > YAFFS_MAX_FILE_SIZE){
+       } else if (nbyte > YAFFS_MAX_FILE_SIZE) {
                yaffsfs_SetError(-EINVAL);
                totalRead = -1;
        } else {
-               if(isPread)
+               if (isPread)
                        startPos = offset;
                else
                        startPos = fd->position;
 
                pos = startPos;
 
-               if(yaffs_get_obj_length(obj) > pos)
+               if (yaffs_get_obj_length(obj) > pos)
                        maxRead = yaffs_get_obj_length(obj) - pos;
                else
                        maxRead = 0;
 
-               if(nbyte > maxRead)
+               if (nbyte > maxRead)
                        nbyte = maxRead;
 
-
                yaffsfs_GetHandle(handle);
 
                endPos = pos + nbyte;
 
-               if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
-                       nbyte > YAFFS_MAX_FILE_SIZE ||
-                       endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
+               if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
+                   nbyte > YAFFS_MAX_FILE_SIZE ||
+                   endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
                        totalRead = -1;
                        nbyte = 0;
                }
 
-               while(nbyte > 0) {
-                       nToRead = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
-                       if(nToRead > nbyte)
+               while (nbyte > 0) {
+                       nToRead = YAFFSFS_RW_SIZE -
+                           (pos & (YAFFSFS_RW_SIZE - 1));
+                       if (nToRead > nbyte)
                                nToRead = nbyte;
 
                        /* Tricky bit...
@@ -1148,24 +1135,23 @@ int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, int isPread, lof
                         * unmounted in another thread.
                         */
                        obj = yaffsfs_HandleToObject(handle);
-                       if(!obj)
+                       if (!obj)
                                nRead = 0;
                        else
-                               nRead = yaffs_file_rd(obj,buf,pos,nToRead);
+                               nRead = yaffs_file_rd(obj, buf, pos, nToRead);
 
-                       if(nRead > 0){
+                       if (nRead > 0) {
                                totalRead += nRead;
                                pos += nRead;
                                buf += nRead;
                        }
 
-                       if(nRead == nToRead)
-                               nbyte-=nRead;
+                       if (nRead == nToRead)
+                               nbyte -= nRead;
                        else
-                               nbyte = 0; /* no more to read */
+                               nbyte = 0;      /* no more to read */
 
-
-                       if(nbyte > 0){
+                       if (nbyte > 0) {
                                yaffsfs_Unlock();
                                yaffsfs_Lock();
                        }
@@ -1174,8 +1160,8 @@ int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, int isPread, lof
 
                yaffsfs_PutHandle(handle);
 
-               if(!isPread) {
-                       if(totalRead >= 0)
+               if (!isPread) {
+                       if (totalRead >= 0)
                                fd->position = startPos + totalRead;
                        else
                                yaffsfs_SetError(-EINVAL);
@@ -1199,9 +1185,10 @@ int yaffs_pread(int handle, void *buf, unsigned int nbyte, loff_t offset)
        return yaffsfs_do_read(handle, buf, nbyte, 1, offset);
 }
 
-int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwrite, loff_t offset)
+int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte,
+                    int isPwrite, loff_t offset)
 {
-       yaffsfs_FileDes *fd = NULL;
+       struct yaffsfs_FileDes *fd = NULL;
        struct yaffs_obj *obj = NULL;
        loff_t pos = 0;
        loff_t startPos = 0;
@@ -1212,7 +1199,7 @@ int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwr
        int nToWrite = 0;
        const u8 *buf = (const u8 *)vbuf;
 
-       if(!vbuf){
+       if (!vbuf) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -1221,20 +1208,20 @@ int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwr
        fd = yaffsfs_HandleToFileDes(handle);
        obj = yaffsfs_HandleToObject(handle);
 
-       if(!fd || !obj){
+       if (!fd || !obj) {
                /* bad handle */
                yaffsfs_SetError(-EBADF);
                totalWritten = -1;
-       } else if(!fd->writing){
+       } else if (!fd->writing) {
                yaffsfs_SetError(-EINVAL);
-               totalWritten=-1;
-       } else if(obj->my_dev->read_only){
+               totalWritten = -1;
+       } else if (obj->my_dev->read_only) {
                yaffsfs_SetError(-EROFS);
-               totalWritten=-1;
+               totalWritten = -1;
        } else {
-               if(fd->append)
+               if (fd->append)
                        startPos = yaffs_get_obj_length(obj);
-               else if(isPwrite)
+               else if (isPwrite)
                        startPos = offset;
                else
                        startPos = fd->position;
@@ -1243,17 +1230,18 @@ int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwr
                pos = startPos;
                endPos = pos + nbyte;
 
-               if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
-                       nbyte > YAFFS_MAX_FILE_SIZE ||
-                       endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
+               if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
+                   nbyte > YAFFS_MAX_FILE_SIZE ||
+                   endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
                        totalWritten = -1;
                        nbyte = 0;
                }
 
-               while(nbyte > 0) {
+               while (nbyte > 0) {
 
-                       nToWrite = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
-                       if(nToWrite > nbyte)
+                       nToWrite = YAFFSFS_RW_SIZE -
+                           (pos & (YAFFSFS_RW_SIZE - 1));
+                       if (nToWrite > nbyte)
                                nToWrite = nbyte;
 
                        /* Tricky bit...
@@ -1261,28 +1249,29 @@ int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwr
                         * remounted or unmounted in another thread.
                         */
                        obj = yaffsfs_HandleToObject(handle);
-                       if(!obj || obj->my_dev->read_only)
+                       if (!obj || obj->my_dev->read_only)
                                nWritten = 0;
                        else
-                               nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,
-                                                       write_trhrough);
-                       if(nWritten > 0){
+                               nWritten =
+                                   yaffs_wr_file(obj, buf, pos, nToWrite,
+                                                 write_trhrough);
+                       if (nWritten > 0) {
                                totalWritten += nWritten;
                                pos += nWritten;
                                buf += nWritten;
                        }
 
-                       if(nWritten == nToWrite)
+                       if (nWritten == nToWrite)
                                nbyte -= nToWrite;
                        else
                                nbyte = 0;
 
-                       if(nWritten < 1 && totalWritten < 1){
+                       if (nWritten < 1 && totalWritten < 1) {
                                yaffsfs_SetError(-ENOSPC);
                                totalWritten = -1;
                        }
 
-                       if(nbyte > 0){
+                       if (nbyte > 0) {
                                yaffsfs_Unlock();
                                yaffsfs_Lock();
                        }
@@ -1290,8 +1279,8 @@ int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, int isPwr
 
                yaffsfs_PutHandle(handle);
 
-               if(!isPwrite){
-                       if(totalWritten > 0)
+               if (!isPwrite) {
+                       if (totalWritten > 0)
                                fd->position = startPos + totalWritten;
                        else
                                yaffsfs_SetError(-EINVAL);
@@ -1313,8 +1302,7 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, loff_t offset)
        return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
 }
 
-
-int yaffs_truncate(const YCHAR *path,loff_t new_size)
+int yaffs_truncate(const YCHAR *path, loff_t new_size)
 {
        struct yaffs_obj *obj = NULL;
        struct yaffs_obj *dir = NULL;
@@ -1322,34 +1310,34 @@ int yaffs_truncate(const YCHAR *path,loff_t new_size)
        int notDir = 0;
        int loop = 0;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
-       obj = yaffsfs_FollowLink(obj,0,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+       obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
+       else if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
                yaffsfs_SetError(-EISDIR);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else if(new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
+       else if (new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
                yaffsfs_SetError(-EINVAL);
        else
                result = yaffs_resize_file(obj, new_size);
@@ -1361,7 +1349,7 @@ int yaffs_truncate(const YCHAR *path,loff_t new_size)
 
 int yaffs_ftruncate(int handle, loff_t new_size)
 {
-       yaffsfs_FileDes *fd = NULL;
+       struct yaffsfs_FileDes *fd = NULL;
        struct yaffs_obj *obj = NULL;
        int result = 0;
 
@@ -1369,14 +1357,14 @@ int yaffs_ftruncate(int handle, loff_t new_size)
        fd = yaffsfs_HandleToFileDes(handle);
        obj = yaffsfs_HandleToObject(handle);
 
-       if(!fd || !obj)
+       if (!fd || !obj)
                /* bad handle */
                yaffsfs_SetError(-EBADF);
-       else if(!fd->writing)
+       else if (!fd->writing)
                yaffsfs_SetError(-EINVAL);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else ifnew_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
+       else if (new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
                yaffsfs_SetError(-EINVAL);
        else
                /* resize the file */
@@ -1389,7 +1377,7 @@ int yaffs_ftruncate(int handle, loff_t new_size)
 
 loff_t yaffs_lseek(int handle, loff_t offset, int whence)
 {
-       yaffsfs_FileDes *fd = NULL;
+       struct yaffsfs_FileDes *fd = NULL;
        struct yaffs_obj *obj = NULL;
        loff_t pos = -1;
        loff_t fSize = -1;
@@ -1398,26 +1386,26 @@ loff_t yaffs_lseek(int handle, loff_t offset, int whence)
        fd = yaffsfs_HandleToFileDes(handle);
        obj = yaffsfs_HandleToObject(handle);
 
-       if(!fd || !obj)
+       if (!fd || !obj)
                yaffsfs_SetError(-EBADF);
-       else if(offset > YAFFS_MAX_FILE_SIZE)
+       else if (offset > YAFFS_MAX_FILE_SIZE)
                yaffsfs_SetError(-EINVAL);
        else {
-               if(whence == SEEK_SET){
-                       if(offset >= 0)
+               if (whence == SEEK_SET) {
+                       if (offset >= 0)
                                pos = offset;
-               } else if(whence == SEEK_CUR) {
-                       if(fd->position + offset) >= 0)
+               } else if (whence == SEEK_CUR) {
+                       if ((fd->position + offset) >= 0)
                                pos = (fd->position + offset);
-               } else if(whence == SEEK_END) {
+               } else if (whence == SEEK_END) {
                        fSize = yaffs_get_obj_length(obj);
-                       if(fSize >= 0 && (fSize + offset) >= 0)
+                       if (fSize >= 0 && (fSize + offset) >= 0)
                                pos = fSize + offset;
                }
 
-               if(pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
+               if (pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
                        fd->position = pos;
-               else{
+               else {
                        yaffsfs_SetError(-EINVAL);
                        pos = -1;
                }
@@ -1428,8 +1416,7 @@ loff_t yaffs_lseek(int handle, loff_t offset, int whence)
        return pos;
 }
 
-
-int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
+int yaffsfs_DoUnlink(const YCHAR *path, int isDirectory)
 {
        struct yaffs_obj *dir = NULL;
        struct yaffs_obj *obj = NULL;
@@ -1438,43 +1425,45 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
        int notDir = 0;
        int loop = 0;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,0,NULL,NULL,NULL);
-       dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 0, NULL, NULL, NULL);
+       dir = yaffsfs_FindDirectory(NULL, path, &name, 0, &notDir, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir)
+       else if (!dir)
                yaffsfs_SetError(-ENOENT);
-       else if(yaffs_strncmp(name,_Y("."),2) == 0)
+       else if (yaffs_strncmp(name, _Y("."), 2) == 0)
                yaffsfs_SetError(-EINVAL);
-       else if(!obj)
+       else if (!obj)
                yaffsfs_SetError(-ENOENT);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else if(!isDirectory && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
+       else if (!isDirectory &&
+                obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-EISDIR);
-       else if(isDirectory && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+       else if (isDirectory &&
+                obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-ENOTDIR);
-       else if(isDirectory && obj == obj->my_dev->root_dir)
-               yaffsfs_SetError(-EBUSY); /* Can't rmdir a root */
+       else if (isDirectory && obj == obj->my_dev->root_dir)
+               yaffsfs_SetError(-EBUSY);       /* Can't rmdir a root */
        else {
-               result = yaffs_unlinker(dir,name);
+               result = yaffs_unlinker(dir, name);
 
-               if(result == YAFFS_FAIL && isDirectory)
+               if (result == YAFFS_FAIL && isDirectory)
                        yaffsfs_SetError(-ENOTEMPTY);
        }
 
@@ -1483,10 +1472,9 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
-
 int yaffs_unlink(const YCHAR *path)
 {
-       return yaffsfs_DoUnlink(path,0);
+       return yaffsfs_DoUnlink(path, 0);
 }
 
 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
@@ -1497,40 +1485,40 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        struct yaffs_obj *newobj = NULL;
        YCHAR *oldname;
        YCHAR *newname;
-       int result= YAFFS_FAIL;
+       int result = YAFFS_FAIL;
        int rename_allowed = 1;
        int notOldDir = 0;
        int notNewDir = 0;
        int oldLoop = 0;
        int newLoop = 0;
 
-       YCHAR *alt_newpath=NULL;
+       YCHAR *alt_newpath = NULL;
 
-       if(!oldPath || !newPath){
+       if (!oldPath || !newPath) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(oldPath) < 0 ||
-               yaffsfs_CheckPath(newPath) < 0){
+       if (yaffsfs_CheckPath(oldPath) < 0 || yaffsfs_CheckPath(newPath) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-       if(yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0){
+       if (yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0) {
                yaffsfs_SetError(-ENOMEM);
                return -1;
        }
-       if(alt_newpath)
+       if (alt_newpath)
                newPath = alt_newpath;
 
        yaffsfs_Lock();
 
-
-       olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0,&notOldDir,&oldLoop);
-       newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0,&notNewDir,&newLoop);
-       obj = yaffsfs_FindObject(NULL,oldPath,0,0,NULL,NULL,NULL);
-       newobj = yaffsfs_FindObject(NULL,newPath,0,0,NULL,NULL,NULL);
+       olddir = yaffsfs_FindDirectory(NULL, oldPath, &oldname, 0,
+                                      &notOldDir, &oldLoop);
+       newdir = yaffsfs_FindDirectory(NULL, newPath, &newname, 0,
+                                      &notNewDir, &newLoop);
+       obj = yaffsfs_FindObject(NULL, oldPath, 0, 0, NULL, NULL, NULL);
+       newobj = yaffsfs_FindObject(NULL, newPath, 0, 0, NULL, NULL, NULL);
 
        /* If the object being renamed is a directory and the
         * path ended with a "/" then the olddir == obj.
@@ -1538,32 +1526,33 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
         * to use olddir as the object.
         */
 
-       if(olddir == obj)
+       if (olddir == obj)
                oldname = NULL;
 
-       if((!olddir && notOldDir) || (!newdir && notNewDir)) {
+       if ((!olddir && notOldDir) || (!newdir && notNewDir)) {
                yaffsfs_SetError(-ENOTDIR);
                rename_allowed = 0;
-       } else if(oldLoop || newLoop) {
+       } else if (oldLoop || newLoop) {
                yaffsfs_SetError(-ELOOP);
                rename_allowed = 0;
-       } else if (olddir && oldname && yaffs_strncmp(oldname, _Y("."),2) == 0){
+       } else if (olddir && oldname &&
+                       yaffs_strncmp(oldname, _Y("."), 2) == 0) {
                yaffsfs_SetError(-EINVAL);
                rename_allowed = 0;
-       }else if(!olddir || !newdir || !obj) {
+       } else if (!olddir || !newdir || !obj) {
                yaffsfs_SetError(-ENOENT);
                rename_allowed = 0;
-       } else if(obj->my_dev->read_only){
+       } else if (obj->my_dev->read_only) {
                yaffsfs_SetError(-EROFS);
                rename_allowed = 0;
-       } else if(yaffs_is_non_empty_dir(newobj)){
+       } else if (yaffs_is_non_empty_dir(newobj)) {
                yaffsfs_SetError(-ENOTEMPTY);
                rename_allowed = 0;
-       } else if(olddir->my_dev != newdir->my_dev) {
+       } else if (olddir->my_dev != newdir->my_dev) {
                /* Rename must be on same device */
                yaffsfs_SetError(-EXDEV);
                rename_allowed = 0;
-       } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
+       } else if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
                /*
                 * It is a directory, check that it is not being renamed to
                 * being its own decendent.
@@ -1573,52 +1562,51 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 
                struct yaffs_obj *xx = newdir;
 
-               while( rename_allowed && xx){
-                       if(xx == obj)
+               while (rename_allowed && xx) {
+                       if (xx == obj)
                                rename_allowed = 0;
                        xx = xx->parent;
                }
-               if(!rename_allowed)
+               if (!rename_allowed)
                        yaffsfs_SetError(-EINVAL);
        }
 
-       if(rename_allowed)
-               result = yaffs_rename_obj(olddir,oldname,newdir,newname);
+       if (rename_allowed)
+               result = yaffs_rename_obj(olddir, oldname, newdir, newname);
 
        yaffsfs_Unlock();
 
-       if(alt_newpath)
-               kfree(alt_newpath);
+       kfree(alt_newpath);
 
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
-
-static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
+static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf)
 {
        int retVal = -1;
 
        obj = yaffs_get_equivalent_obj(obj);
 
-       if(obj && buf){
-               buf->st_dev = (int)obj->my_dev->os_context;
-               buf->st_ino = obj->obj_id;
-               buf->st_mode = obj->yst_mode & ~S_IFMT; /* clear out file type bits */
+       if (obj && buf) {
+               buf->st_dev = (int)obj->my_dev->os_context;
+               buf->st_ino = obj->obj_id;
+               buf->st_mode = obj->yst_mode & ~S_IFMT;
 
-               if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
+               if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                        buf->st_mode |= S_IFDIR;
-               else if(obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
+               else if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
                        buf->st_mode |= S_IFLNK;
-               else if(obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
+               else if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
                        buf->st_mode |= S_IFREG;
 
-               buf->st_nlink = yaffs_get_obj_link_count(obj);
-               buf->st_uid = 0;
-               buf->st_gid = 0;;
-               buf->st_rdev = obj->yst_rdev;
-               buf->st_size = yaffs_get_obj_length(obj);
-               buf->st_blksize = obj->my_dev->data_bytes_per_chunk;
-               buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
+               buf->st_nlink = yaffs_get_obj_link_count(obj);
+               buf->st_uid = 0;
+               buf->st_gid = 0;
+               buf->st_rdev = obj->yst_rdev;
+               buf->st_size = yaffs_get_obj_length(obj);
+               buf->st_blksize = obj->my_dev->data_bytes_per_chunk;
+               buf->st_blocks = (buf->st_size + buf->st_blksize - 1) /
+                   buf->st_blksize;
 #if CONFIG_YAFFS_WINCE
                buf->yst_wince_atime[0] = obj->win_atime[0];
                buf->yst_wince_atime[1] = obj->win_atime[1];
@@ -1627,48 +1615,49 @@ static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
                buf->yst_wince_mtime[0] = obj->win_mtime[0];
                buf->yst_wince_mtime[1] = obj->win_mtime[1];
 #else
-               buf->yst_atime = obj->yst_atime;
-               buf->yst_ctime = obj->yst_ctime;
-               buf->yst_mtime = obj->yst_mtime;
+               buf->yst_atime = obj->yst_atime;
+               buf->yst_ctime = obj->yst_ctime;
+               buf->yst_mtime = obj->yst_mtime;
 #endif
                retVal = 0;
        }
        return retVal;
 }
 
-static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
+static int yaffsfs_DoStatOrLStat(const YCHAR *path,
+                                struct yaffs_stat *buf, int doLStat)
 {
-       struct yaffs_obj *obj=NULL;
-       struct yaffs_obj *dir=NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int retVal = -1;
        int notDir = 0;
        int loop = 0;
 
-       if(!path || !buf){
+       if (!path || !buf) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(!doLStat && obj)
-               obj = yaffsfs_FollowLink(obj,0,&loop);
+       if (!doLStat && obj)
+               obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
        else
-               retVal = yaffsfs_DoStat(obj,buf);
+               retVal = yaffsfs_DoStat(obj, buf);
 
        yaffsfs_Unlock();
 
@@ -1678,12 +1667,12 @@ static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int d
 
 int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
 {
-       return yaffsfs_DoStatOrLStat(path,buf,0);
+       return yaffsfs_DoStatOrLStat(path, buf, 0);
 }
 
 int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 {
-       return yaffsfs_DoStatOrLStat(path,buf,1);
+       return yaffsfs_DoStatOrLStat(path, buf, 1);
 }
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
@@ -1692,7 +1681,7 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
 
        int retVal = -1;
 
-       if(!buf){
+       if (!buf) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -1700,8 +1689,8 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj)
-               retVal = yaffsfs_DoStat(obj,buf);
+       if (obj)
+               retVal = yaffsfs_DoStat(obj, buf);
        else
                /* bad handle */
                yaffsfs_SetError(-EBADF);
@@ -1711,7 +1700,8 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
        return retVal;
 }
 
-static int yaffsfs_DoUtime(struct yaffs_obj *obj,const struct yaffs_utimbuf *buf)
+static int yaffsfs_DoUtime(struct yaffs_obj *obj,
+                          const struct yaffs_utimbuf *buf)
 {
        int retVal = -1;
        int result;
@@ -1720,23 +1710,22 @@ static int yaffsfs_DoUtime(struct yaffs_obj *obj,const struct yaffs_utimbuf *buf
 
        obj = yaffs_get_equivalent_obj(obj);
 
-       if(obj && obj->my_dev->read_only) {
+       if (obj && obj->my_dev->read_only) {
                yaffsfs_SetError(-EROFS);
                return -1;
        }
 
-
-       if(!buf){
+       if (!buf) {
                local.actime = Y_CURRENT_TIME;
                local.modtime = local.actime;
                buf = &local;
        }
 
-       if(obj){
+       if (obj) {
                obj->yst_atime = buf->actime;
                obj->yst_mtime = buf->modtime;
                obj->dirty = 1;
-               result = yaffs_flush_file(obj,0,0);
+               result = yaffs_flush_file(obj, 0, 0);
                retVal = result == YAFFS_OK ? 0 : -1;
        }
 
@@ -1745,40 +1734,41 @@ static int yaffsfs_DoUtime(struct yaffs_obj *obj,const struct yaffs_utimbuf *buf
 
 int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
 {
-       struct yaffs_obj *obj=NULL;
-       struct yaffs_obj *dir=NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int retVal = -1;
        int notDir = 0;
        int loop = 0;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
        else
-               retVal = yaffsfs_DoUtime(obj,buf);
+               retVal = yaffsfs_DoUtime(obj, buf);
 
        yaffsfs_Unlock();
 
        return retVal;
 
 }
+
 int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
 {
        struct yaffs_obj *obj;
@@ -1788,8 +1778,8 @@ int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj)
-               retVal = yaffsfs_DoUtime(obj,buf);
+       if (obj)
+               retVal = yaffsfs_DoUtime(obj, buf);
        else
                /* bad handle */
                yaffsfs_SetError(-EBADF);
@@ -1799,13 +1789,11 @@ int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
        return retVal;
 }
 
-
 #ifndef CONFIG_YAFFS_WINCE
 /* xattrib functions */
 
-
 static int yaffs_do_setxattr(const YCHAR *path, const char *name,
-                       const void *data, int size, int flags, int follow)
+                            const void *data, int size, int flags, int follow)
 {
        struct yaffs_obj *obj;
        struct yaffs_obj *dir;
@@ -1814,32 +1802,32 @@ static int yaffs_do_setxattr(const YCHAR *path, const char *name,
 
        int retVal = -1;
 
-       if(!path || !name || !data){
+       if (!path || !name || !data) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(follow)
-               obj = yaffsfs_FollowLink(obj,0,&loop);
+       if (follow)
+               obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
        else {
-               retVal = yaffs_set_xattrib(obj,name,data,size,flags);
-               if(retVal< 0){
+               retVal = yaffs_set_xattrib(obj, name, data, size, flags);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -1851,25 +1839,26 @@ static int yaffs_do_setxattr(const YCHAR *path, const char *name,
 
 }
 
-int yaffs_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
+int yaffs_setxattr(const YCHAR *path, const char *name,
+                  const void *data, int size, int flags)
 {
        return yaffs_do_setxattr(path, name, data, size, flags, 1);
 }
 
-int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
+int yaffs_lsetxattr(const YCHAR *path, const char *name,
+                   const void *data, int size, int flags)
 {
        return yaffs_do_setxattr(path, name, data, size, flags, 0);
 }
 
-
-
-int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
+int yaffs_fsetxattr(int fd, const char *name,
+                   const void *data, int size, int flags)
 {
        struct yaffs_obj *obj;
 
        int retVal = -1;
 
-       if(!name || !data){
+       if (!name || !data) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -1877,11 +1866,11 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(!obj)
+       if (!obj)
                yaffsfs_SetError(-EBADF);
        else {
-               retVal = yaffs_set_xattrib(obj,name,data,size,flags);
-               if(retVal< 0){
+               retVal = yaffs_set_xattrib(obj, name, data, size, flags);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -1892,7 +1881,8 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
        return retVal;
 }
 
-static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
+static int yaffs_do_getxattr(const YCHAR *path, const char *name,
+                            void *data, int size, int follow)
 {
        struct yaffs_obj *obj;
        struct yaffs_obj *dir;
@@ -1900,32 +1890,32 @@ static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, in
        int notDir = 0;
        int loop = 0;
 
-       if(!path || !name || !data ){
+       if (!path || !name || !data) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(follow)
-               obj = yaffsfs_FollowLink(obj,0,&loop);
+       if (follow)
+               obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
        else {
-               retVal = yaffs_get_xattrib(obj,name,data,size);
-               if(retVal< 0){
+               retVal = yaffs_get_xattrib(obj, name, data, size);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -1938,22 +1928,21 @@ static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, in
 
 int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
 {
-       return yaffs_do_getxattr( path, name, data, size, 1);
+       return yaffs_do_getxattr(path, name, data, size, 1);
 }
+
 int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
 {
-       return yaffs_do_getxattr( path, name, data, size, 0);
+       return yaffs_do_getxattr(path, name, data, size, 0);
 }
 
-
-
 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 {
        struct yaffs_obj *obj;
 
        int retVal = -1;
 
-       if(!name || !data ){
+       if (!name || !data) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -1961,9 +1950,9 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj) {
-               retVal = yaffs_get_xattrib(obj,name,data,size);
-               if(retVal< 0){
+       if (obj) {
+               retVal = yaffs_get_xattrib(obj, name, data, size);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -1976,40 +1965,41 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
        return retVal;
 }
 
-static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
+static int yaffs_do_listxattr(const YCHAR *path, char *data,
+                             int size, int follow)
 {
-       struct yaffs_obj *obj=NULL;
-       struct yaffs_obj *dir=NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int retVal = -1;
        int notDir = 0;
        int loop = 0;
 
-       if(!path || !data ){
+       if (!path || !data) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(follow)
-               obj = yaffsfs_FollowLink(obj,0,&loop);
+       if (follow)
+               obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
        else {
-               retVal = yaffs_list_xattrib(obj, data,size);
-               if(retVal< 0){
+               retVal = yaffs_list_xattrib(obj, data, size);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -2037,7 +2027,7 @@ int yaffs_flistxattr(int fd, char *data, int size)
 
        int retVal = -1;
 
-       if(!data ){
+       if (!data) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -2045,9 +2035,9 @@ int yaffs_flistxattr(int fd, char *data, int size)
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj) {
-               retVal = yaffs_list_xattrib(obj,data,size);
-               if(retVal< 0){
+       if (obj) {
+               retVal = yaffs_list_xattrib(obj, data, size);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -2060,40 +2050,41 @@ int yaffs_flistxattr(int fd, char *data, int size)
        return retVal;
 }
 
-static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
+static int yaffs_do_removexattr(const YCHAR *path, const char *name,
+                               int follow)
 {
-       struct yaffs_obj *obj=NULL;
-       struct yaffs_obj *dir=NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int notDir = 0;
        int loop = 0;
        int retVal = -1;
 
-       if(!path || !name){
+       if (!path || !name) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(follow)
-               obj = yaffsfs_FollowLink(obj,0,&loop);
+       if (follow)
+               obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
        else {
-               retVal = yaffs_remove_xattrib(obj,name);
-               if(retVal< 0){
+               retVal = yaffs_remove_xattrib(obj, name);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
@@ -2121,7 +2112,7 @@ int yaffs_fremovexattr(int fd, const char *name)
 
        int retVal = -1;
 
-       if(!name){
+       if (!name) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
@@ -2129,13 +2120,13 @@ int yaffs_fremovexattr(int fd, const char *name)
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj){
-               retVal = yaffs_remove_xattrib(obj,name);
-               if(retVal< 0){
+       if (obj) {
+               retVal = yaffs_remove_xattrib(obj, name);
+               if (retVal < 0) {
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
-       }else
+       } else
                /* bad handle */
                yaffsfs_SetError(-EBADF);
 
@@ -2146,7 +2137,8 @@ int yaffs_fremovexattr(int fd, const char *name)
 #endif
 
 #ifdef CONFIG_YAFFS_WINCE
-int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
+int yaffs_get_wince_times(int fd, unsigned *wctime,
+                         unsigned *watime, unsigned *wmtime)
 {
        struct yaffs_obj *obj;
 
@@ -2155,22 +2147,21 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj){
+       if (obj) {
 
-               if(wctime){
+               if (wctime) {
                        wctime[0] = obj->win_ctime[0];
                        wctime[1] = obj->win_ctime[1];
                }
-               if(watime){
+               if (watime) {
                        watime[0] = obj->win_atime[0];
                        watime[1] = obj->win_atime[1];
                }
-               if(wmtime){
+               if (wmtime) {
                        wmtime[0] = obj->win_mtime[0];
                        wmtime[1] = obj->win_mtime[1];
                }
 
-
                retVal = 0;
        } else
                /*  bad handle */
@@ -2181,38 +2172,36 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
        return retVal;
 }
 
-
 int yaffs_set_wince_times(int fd,
-                                                 const unsigned *wctime,
-                                                 const unsigned *watime,
-                                                  const unsigned *wmtime)
+                         const unsigned *wctime,
+                         const unsigned *watime, const unsigned *wmtime)
 {
-        struct yaffs_obj *obj;
-        int result;
-        int retVal = -1;
+       struct yaffs_obj *obj;
+       int result;
+       int retVal = -1;
 
-        yaffsfs_Lock();
+       yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(obj){
+       if (obj) {
 
-               if(wctime){
+               if (wctime) {
                        obj->win_ctime[0] = wctime[0];
                        obj->win_ctime[1] = wctime[1];
                }
-               if(watime){
-                        obj->win_atime[0] = watime[0];
-                        obj->win_atime[1] = watime[1];
-                }
-                if(wmtime){
-                        obj->win_mtime[0] = wmtime[0];
-                        obj->win_mtime[1] = wmtime[1];
-                }
-
-                obj->dirty = 1;
-                result = yaffs_flush_file(obj,0,0);
-                retVal = 0;
-        } else
+               if (watime) {
+                       obj->win_atime[0] = watime[0];
+                       obj->win_atime[1] = watime[1];
+               }
+               if (wmtime) {
+                       obj->win_mtime[0] = wmtime[0];
+                       obj->win_mtime[1] = wmtime[1];
+               }
+
+               obj->dirty = 1;
+               result = yaffs_flush_file(obj, 0, 0);
+               retVal = 0;
+       } else
                /* bad handle */
                yaffsfs_SetError(-EBADF);
 
@@ -2223,71 +2212,69 @@ int yaffs_set_wince_times(int fd,
 
 #endif
 
-
-static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)
+static int yaffsfs_DoChMod(struct yaffs_obj *obj, mode_t mode)
 {
        int result = -1;
 
-       if(obj)
+       if (obj)
                obj = yaffs_get_equivalent_obj(obj);
 
-       if(obj) {
+       if (obj) {
                obj->yst_mode = mode;
                obj->dirty = 1;
-               result = yaffs_flush_file(obj,0,0);
+               result = yaffs_flush_file(obj, 0, 0);
        }
 
        return result == YAFFS_OK ? 0 : -1;
 }
 
-
 int yaffs_access(const YCHAR *path, int amode)
 {
-       struct yaffs_obj *obj=NULL;
-       struct yaffs_obj *dir=NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int notDir = 0;
        int loop = 0;
        int retval = -1;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-       if(amode & ~(R_OK | W_OK | X_OK)){
+       if (amode & ~(R_OK | W_OK | X_OK)) {
                yaffsfs_SetError(-EINVAL);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
-       obj = yaffsfs_FollowLink(obj,0,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+       obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
-       else if((amode & W_OK) && obj->my_dev->read_only)
+       else if ((amode & W_OK) && obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else{
+       else {
                int access_ok = 1;
 
-               if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
+               if ((amode & R_OK) && !(obj->yst_mode & S_IREAD))
                        access_ok = 0;
-               if((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
+               if ((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
                        access_ok = 0;
-               if((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
+               if ((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
                        access_ok = 0;
 
-               if(!access_ok)
+               if (!access_ok)
                        yaffsfs_SetError(-EACCES);
                else
                        retval = 0;
@@ -2299,45 +2286,44 @@ int yaffs_access(const YCHAR *path, int amode)
 
 }
 
-
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {
-       struct yaffs_obj *obj=NULL;
-       struct yaffs_obj *dir=NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int retVal = -1;
        int notDir = 0;
        int loop = 0;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-       if(mode & ~(0777)){
+       if (mode & ~(0777)) {
                yaffsfs_SetError(-EINVAL);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1, &dir, &notDir,&loop);
-       obj = yaffsfs_FollowLink(obj,0,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
+       obj = yaffsfs_FollowLink(obj, 0, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
        else
-               retVal = yaffsfs_DoChMod(obj,mode);
+               retVal = yaffsfs_DoChMod(obj, mode);
 
        yaffsfs_Unlock();
 
@@ -2345,13 +2331,12 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 
 }
 
-
 int yaffs_fchmod(int fd, mode_t mode)
 {
        struct yaffs_obj *obj;
        int retVal = -1;
 
-       if(mode & ~(0777)){
+       if (mode & ~(0777)) {
                yaffsfs_SetError(-EINVAL);
                return -1;
        }
@@ -2359,12 +2344,12 @@ int yaffs_fchmod(int fd, mode_t mode)
        yaffsfs_Lock();
        obj = yaffsfs_HandleToObject(fd);
 
-       if(!obj)
+       if (!obj)
                yaffsfs_SetError(-EBADF);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
        else
-               retVal = yaffsfs_DoChMod(obj,mode);
+               retVal = yaffsfs_DoChMod(obj, mode);
 
        yaffsfs_Unlock();
 
@@ -2377,56 +2362,55 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
        struct yaffs_obj *dir = NULL;
        YCHAR *name;
        YCHAR *alt_path = NULL;
-       int retVal= -1;
+       int retVal = -1;
        int notDir = 0;
        int loop = 0;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-       if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
+       if (yaffsfs_alt_dir_path(path, &alt_path) < 0) {
                yaffsfs_SetError(-ENOMEM);
                return -1;
        }
-       if(alt_path)
+       if (alt_path)
                path = alt_path;
 
        yaffsfs_Lock();
-       parent = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
-       if(!parent && notDir)
+       parent = yaffsfs_FindDirectory(NULL, path, &name, 0, &notDir, &loop);
+       if (!parent && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!parent)
+       else if (!parent)
                yaffsfs_SetError(-ENOENT);
-       else if(yaffsfs_TooManyObjects(parent->my_dev))
+       else if (yaffsfs_TooManyObjects(parent->my_dev))
                yaffsfs_SetError(-ENFILE);
-       else if(yaffs_strnlen(name,5) == 0){
+       else if (yaffs_strnlen(name, 5) == 0) {
                /* Trying to make the root itself */
                yaffsfs_SetError(-EEXIST);
-       } else if(parent->my_dev->read_only)
+       } else if (parent->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
        else {
-               dir = yaffs_create_dir(parent,name,mode,0,0);
-               if(dir)
+               dir = yaffs_create_dir(parent, name, mode, 0, 0);
+               if (dir)
                        retVal = 0;
-               else if (yaffs_find_by_name(parent,name))
-                       yaffsfs_SetError(-EEXIST); /* the name already exists */
+               else if (yaffs_find_by_name(parent, name))
+                       yaffsfs_SetError(-EEXIST);      /* name exists */
                else
-                       yaffsfs_SetError(-ENOSPC); /* just assume no space */
+                       yaffsfs_SetError(-ENOSPC);      /* assume no space */
        }
 
        yaffsfs_Unlock();
 
-       if(alt_path)
-               kfree(alt_path);
+       kfree(alt_path);
 
        return retVal;
 }
@@ -2436,51 +2420,51 @@ int yaffs_rmdir(const YCHAR *path)
        int result;
        YCHAR *alt_path;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-       if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
+       if (yaffsfs_alt_dir_path(path, &alt_path) < 0) {
                yaffsfs_SetError(-ENOMEM);
                return -1;
        }
-       if(alt_path)
+       if (alt_path)
                path = alt_path;
-       result =  yaffsfs_DoUnlink(path,1);
-       if(alt_path)
-               kfree(alt_path);
+       result = yaffsfs_DoUnlink(path, 1);
+
+       kfree(alt_path);
+
        return result;
 }
 
-
-void * yaffs_getdev(const YCHAR *path)
+void *yaffs_getdev(const YCHAR *path)
 {
-       struct yaffs_dev *dev=NULL;
+       struct yaffs_dev *dev = NULL;
        YCHAR *dummy;
-       dev = yaffsfs_FindDevice(path,&dummy);
+       dev = yaffsfs_FindDevice(path, &dummy);
        return (void *)dev;
 }
 
-int yaffs_mount_common(const YCHAR *path,int read_only, int skip_checkpt)
+int yaffs_mount_common(const YCHAR *path, int read_only, int skip_checkpt)
 {
-       int retVal=-1;
-       int result=YAFFS_FAIL;
-       struct yaffs_dev *dev=NULL;
+       int retVal = -1;
+       int result = YAFFS_FAIL;
+       struct yaffs_dev *dev = NULL;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       yaffs_trace(YAFFS_TRACE_MOUNT,"yaffs: Mounting %s",path);
+       yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path);
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
@@ -2490,10 +2474,10 @@ int yaffs_mount_common(const YCHAR *path,int read_only, int skip_checkpt)
        yaffsfs_InitHandles();
 
        dev = yaffsfs_FindMountPoint(path);
-       if(dev){
-               if(!dev->is_mounted){
+       if (dev) {
+               if (!dev->is_mounted) {
                        dev->read_only = read_only ? 1 : 0;
-                       if(skip_checkpt) {
+                       if (skip_checkpt) {
                                u8 skip = dev->param.skip_checkpt_rd;
                                dev->param.skip_checkpt_rd = 1;
                                result = yaffs_guts_initialise(dev);
@@ -2502,12 +2486,11 @@ int yaffs_mount_common(const YCHAR *path,int read_only, int skip_checkpt)
                                result = yaffs_guts_initialise(dev);
                        }
 
-                       if(result == YAFFS_FAIL)
+                       if (result == YAFFS_FAIL)
                                yaffsfs_SetError(-ENOMEM);
                        retVal = result ? 0 : -1;
 
-               }
-               else
+               } else
                        yaffsfs_SetError(-EBUSY);
        } else
                yaffsfs_SetError(-ENODEV);
@@ -2521,6 +2504,7 @@ int yaffs_mount2(const YCHAR *path, int readonly)
 {
        return yaffs_mount_common(path, readonly, 0);
 }
+
 int yaffs_mount(const YCHAR *path)
 {
        return yaffs_mount_common(path, 0, 0);
@@ -2528,81 +2512,79 @@ int yaffs_mount(const YCHAR *path)
 
 int yaffs_sync(const YCHAR *path)
 {
-        int retVal=-1;
-        struct yaffs_dev *dev=NULL;
-        YCHAR *dummy;
+       int retVal = -1;
+       struct yaffs_dev *dev = NULL;
+       YCHAR *dummy;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-        yaffsfs_Lock();
-        dev = yaffsfs_FindDevice(path,&dummy);
-        if(dev){
-                if(!dev->is_mounted)
+       yaffsfs_Lock();
+       dev = yaffsfs_FindDevice(path, &dummy);
+       if (dev) {
+               if (!dev->is_mounted)
                        yaffsfs_SetError(-EINVAL);
-               else if(dev->read_only)
+               else if (dev->read_only)
                        yaffsfs_SetError(-EROFS);
                else {
 
-                        yaffs_flush_whole_cache(dev);
-                        yaffs_checkpoint_save(dev);
-                        retVal = 0;
+                       yaffs_flush_whole_cache(dev);
+                       yaffs_checkpoint_save(dev);
+                       retVal = 0;
 
-                }
-        }else
-                yaffsfs_SetError(-ENODEV);
+               }
+       else
+               yaffsfs_SetError(-ENODEV);
 
-        yaffsfs_Unlock();
-        return retVal;
+       yaffsfs_Unlock();
+       return retVal;
 }
 
-
-static int yaffsfs_IsDevBusy(struct yaffs_dev * dev)
+static int yaffsfs_IsDevBusy(struct yaffs_dev *dev)
 {
        int i;
        struct yaffs_obj *obj;
 
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+       for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
                obj = yaffsfs_HandleToObject(i);
-               if(obj && obj->my_dev == dev)
-               return 1;
+               if (obj && obj->my_dev == dev)
+                       return 1;
        }
        return 0;
 }
 
-
 int yaffs_remount(const YCHAR *path, int force, int read_only)
 {
-        int retVal=-1;
-       struct yaffs_dev *dev=NULL;
+       int retVal = -1;
+       struct yaffs_dev *dev = NULL;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
        dev = yaffsfs_FindMountPoint(path);
-       if(dev){
-               if(dev->is_mounted){
+       if (dev) {
+               if (dev->is_mounted) {
                        yaffs_flush_whole_cache(dev);
 
-                       if(force || ! yaffsfs_IsDevBusy(dev)){
-                               if(read_only)
+                       if (force || !yaffsfs_IsDevBusy(dev)) {
+                               if (read_only)
                                        yaffs_checkpoint_save(dev);
-                               dev->read_only =  read_only ? 1 : 0;
+                               dev->read_only = read_only ? 1 : 0;
                                retVal = 0;
                        } else
                                yaffsfs_SetError(-EBUSY);
@@ -2610,8 +2592,7 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
                } else
                        yaffsfs_SetError(-EINVAL);
 
-       }
-       else
+       } else
                yaffsfs_SetError(-ENODEV);
 
        yaffsfs_Unlock();
@@ -2621,29 +2602,29 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
 
 int yaffs_unmount2(const YCHAR *path, int force)
 {
-        int retVal=-1;
-       struct yaffs_dev *dev=NULL;
+       int retVal = -1;
+       struct yaffs_dev *dev = NULL;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
        dev = yaffsfs_FindMountPoint(path);
-       if(dev){
-               if(dev->is_mounted){
+       if (dev) {
+               if (dev->is_mounted) {
                        int inUse;
                        yaffs_flush_whole_cache(dev);
                        yaffs_checkpoint_save(dev);
                        inUse = yaffsfs_IsDevBusy(dev);
-                       if(!inUse || force){
-                               if(inUse)
+                       if (!inUse || force) {
+                               if (inUse)
                                        yaffsfs_BreakDeviceHandles(dev);
                                yaffs_deinitialise(dev);
 
@@ -2664,28 +2645,28 @@ int yaffs_unmount2(const YCHAR *path, int force)
 
 int yaffs_unmount(const YCHAR *path)
 {
-       return yaffs_unmount2(path,0);
+       return yaffs_unmount2(path, 0);
 }
 
 loff_t yaffs_freespace(const YCHAR *path)
 {
-       loff_t retVal=-1;
-       struct yaffs_dev *dev=NULL;
+       loff_t retVal = -1;
+       struct yaffs_dev *dev = NULL;
        YCHAR *dummy;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev  && dev->is_mounted){
+       dev = yaffsfs_FindDevice(path, &dummy);
+       if (dev && dev->is_mounted) {
                retVal = yaffs_get_n_free_chunks(dev);
                retVal *= dev->data_bytes_per_chunk;
 
@@ -2698,25 +2679,25 @@ loff_t yaffs_freespace(const YCHAR *path)
 
 loff_t yaffs_totalspace(const YCHAR *path)
 {
-       loff_t retVal=-1;
-       struct yaffs_dev *dev=NULL;
+       loff_t retVal = -1;
+       struct yaffs_dev *dev = NULL;
        YCHAR *dummy;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev  && dev->is_mounted){
+       dev = yaffsfs_FindDevice(path, &dummy);
+       if (dev && dev->is_mounted) {
                retVal = (dev->param.end_block - dev->param.start_block + 1) -
-                       dev->param.n_reserved_blocks;
+                   dev->param.n_reserved_blocks;
                retVal *= dev->param.chunks_per_block;
                retVal *= dev->data_bytes_per_chunk;
 
@@ -2729,53 +2710,52 @@ loff_t yaffs_totalspace(const YCHAR *path)
 
 int yaffs_inodecount(const YCHAR *path)
 {
-       loff_t retVal= -1;
-       struct yaffs_dev *dev=NULL;
+       loff_t retVal = -1;
+       struct yaffs_dev *dev = NULL;
        YCHAR *dummy;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev  && dev->is_mounted) {
-          int n_obj = dev->n_obj;
-          if(n_obj > dev->n_hardlinks)
-               retVal = n_obj - dev->n_hardlinks;
+       dev = yaffsfs_FindDevice(path, &dummy);
+       if (dev && dev->is_mounted) {
+               int n_obj = dev->n_obj;
+               if (n_obj > dev->n_hardlinks)
+                       retVal = n_obj - dev->n_hardlinks;
        }
 
-       if(retVal < 0)
+       if (retVal < 0)
                yaffsfs_SetError(-EINVAL);
 
        yaffsfs_Unlock();
        return retVal;
 }
 
-
 void yaffs_add_device(struct yaffs_dev *dev)
 {
        struct list_head *cfg;
        /* First check that the device is not in the list. */
 
-       list_for_each(cfg, &yaffsfs_deviceList){
-               if(dev == list_entry(cfg, struct yaffs_dev, dev_list))
+       list_for_each(cfg, &yaffsfs_deviceList) {
+               if (dev == list_entry(cfg, struct yaffs_dev, dev_list))
                        return;
        }
 
        dev->is_mounted = 0;
        dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
 
-       if(!dev->dev_list.next)
+       if (!dev->dev_list.next)
                INIT_LIST_HEAD(&dev->dev_list);
 
-       list_add(&dev->dev_list,&yaffsfs_deviceList);
+       list_add(&dev->dev_list, &yaffsfs_deviceList);
 }
 
 void yaffs_remove_device(struct yaffs_dev *dev)
@@ -2795,9 +2775,9 @@ struct yaffs_dev *yaffs_next_dev(void)
 {
        struct yaffs_dev *retval;
 
-       if(!dev_iterator)
+       if (!dev_iterator)
                return NULL;
-       if(dev_iterator == &yaffsfs_deviceList)
+       if (dev_iterator == &yaffsfs_deviceList)
                return NULL;
 
        retval = list_entry(dev_iterator, struct yaffs_dev, dev_list);
@@ -2807,70 +2787,73 @@ struct yaffs_dev *yaffs_next_dev(void)
 
 /* Directory search stuff. */
 
-
 static struct list_head search_contexts;
 
-
-static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
+static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContxt *dsc)
 {
-       if(dsc &&
-          dsc->dirObj &&
-          dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+       if (dsc &&
+           dsc->dirObj &&
+           dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
 
-           dsc->offset = 0;
+               dsc->offset = 0;
 
-           if( list_empty(&dsc->dirObj->variant.dir_variant.children))
-                dsc->nextReturn = NULL;
-           else
-                dsc->nextReturn = list_entry(dsc->dirObj->variant.dir_variant.children.next,
-                                                struct yaffs_obj,siblings);
-        } else {
+               if (list_empty(&dsc->dirObj->variant.dir_variant.children))
+                       dsc->nextReturn = NULL;
+               else
+                       dsc->nextReturn =
+                           list_entry(dsc->dirObj->variant.dir_variant.
+                                      children.next, struct yaffs_obj,
+                                      siblings);
+       } else {
                /* Hey someone isn't playing nice! */
        }
 }
 
-static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
+static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContxt *dsc)
 {
-       if(dsc &&
-          dsc->dirObj &&
-           dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+       if (dsc &&
+           dsc->dirObj &&
+           dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
 
-           if( dsc->nextReturn == NULL ||
-               list_empty(&dsc->dirObj->variant.dir_variant.children))
-                dsc->nextReturn = NULL;
-           else {
-                   struct list_head *next = dsc->nextReturn->siblings.next;
+               if (dsc->nextReturn == NULL ||
+                   list_empty(&dsc->dirObj->variant.dir_variant.children))
+                       dsc->nextReturn = NULL;
+               else {
+                       struct list_head *next = dsc->nextReturn->siblings.next;
 
-                   if( next == &dsc->dirObj->variant.dir_variant.children)
-                        dsc->nextReturn = NULL; /* end of list */
-                   else
-                        dsc->nextReturn = list_entry(next,struct yaffs_obj,siblings);
-           }
-        } else {
-                /* Hey someone isn't playing nice! */
+                       if (next == &dsc->dirObj->variant.dir_variant.children)
+                               dsc->nextReturn = NULL; /* end of list */
+                       else
+                               dsc->nextReturn = list_entry(next,
+                                                            struct yaffs_obj,
+                                                            siblings);
+               }
+       } else {
+               /* Hey someone isn't playing nice! */
        }
 }
 
 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 {
 
-        struct list_head *i;
-        yaffsfs_DirectorySearchContext *dsc;
+       struct list_head *i;
+       struct yaffsfs_DirSearchContxt *dsc;
 
-        /* if search contexts not initilised then skip */
-        if(!search_contexts.next)
-                return;
+       /* if search contexts not initilised then skip */
+       if (!search_contexts.next)
+               return;
 
-        /* Iterate through the directory search contexts.
-         * If any are the one being removed, then advance the dsc to
-         * the next one to prevent a hanging ptr.
-         */
-         list_for_each(i, &search_contexts) {
-                if (i) {
-                        dsc = list_entry(i, yaffsfs_DirectorySearchContext,others);
-                        if(dsc->nextReturn == obj)
-                                yaffsfs_DirAdvance(dsc);
-                }
+       /* Iterate through the directory search contexts.
+        * If any are the one being removed, then advance the dsc to
+        * the next one to prevent a hanging ptr.
+        */
+       list_for_each(i, &search_contexts) {
+               if (i) {
+                       dsc = list_entry(i, struct yaffsfs_DirSearchContxt,
+                                        others);
+                       if (dsc->nextReturn == obj)
+                               yaffsfs_DirAdvance(dsc);
+               }
        }
 
 }
@@ -2878,82 +2861,84 @@ static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
        yaffs_DIR *dir = NULL;
-       struct yaffs_obj *obj = NULL;
-       yaffsfs_DirectorySearchContext *dsc = NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffsfs_DirSearchContxt *dsc = NULL;
        int notDir = 0;
        int loop = 0;
 
-       if(!dirname){
+       if (!dirname) {
                yaffsfs_SetError(-EFAULT);
                return NULL;
        }
 
-       if(yaffsfs_CheckPath(dirname) < 0){
+       if (yaffsfs_CheckPath(dirname) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return NULL;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,dirname,0,1,NULL,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, dirname, 0, 1, NULL, &notDir, &loop);
 
-       if(!obj && notDir)
+       if (!obj && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!obj)
+       else if (!obj)
                yaffsfs_SetError(-ENOENT);
-       else if(obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+       else if (obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-ENOTDIR);
        else {
                int i;
 
-               for(i = 0, dsc = NULL; i < YAFFSFS_N_DSC && !dsc; i++) {
-                       if(!yaffsfs_dsc[i].inUse)
-                               dsc = & yaffsfs_dsc[i];
+               for (i = 0, dsc = NULL; i < YAFFSFS_N_DSC && !dsc; i++) {
+                       if (!yaffsfs_dsc[i].inUse)
+                               dsc = &yaffsfs_dsc[i];
                }
 
-               dir = (yaffs_DIR *)dsc;
+               dir = (yaffs_DIR *) dsc;
 
-               if(dsc){
-                       memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
-                        dsc->inUse = 1;
-                        dsc->dirObj = obj;
-                        yaffs_strncpy(dsc->name,dirname,NAME_MAX);
-                        INIT_LIST_HEAD(&dsc->others);
+               if (dsc) {
+                       memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContxt));
+                       dsc->inUse = 1;
+                       dsc->dirObj = obj;
+                       yaffs_strncpy(dsc->name, dirname, NAME_MAX);
+                       INIT_LIST_HEAD(&dsc->others);
 
-                        if(!search_contexts.next)
-                                INIT_LIST_HEAD(&search_contexts);
+                       if (!search_contexts.next)
+                               INIT_LIST_HEAD(&search_contexts);
 
-                        list_add(&dsc->others,&search_contexts);
-                        yaffsfs_SetDirRewound(dsc);
+                       list_add(&dsc->others, &search_contexts);
+                       yaffsfs_SetDirRewound(dsc);
                }
 
-        }
+       }
 
        yaffsfs_Unlock();
 
        return dir;
 }
 
-struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
+struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
 {
-       yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
+       struct yaffsfs_DirSearchContxt *dsc;
        struct yaffs_dirent *retVal = NULL;
 
+       dsc = (struct yaffsfs_DirSearchContxt *) dirp;
        yaffsfs_Lock();
 
-       if(dsc && dsc->inUse){
+       if (dsc && dsc->inUse) {
                yaffsfs_SetError(0);
-               if(dsc->nextReturn){
-                       dsc->de.d_ino = yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
+               if (dsc->nextReturn) {
+                       dsc->de.d_ino =
+                           yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
                        dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
                        dsc->de.d_off = dsc->offset++;
-                       yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
-                       if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
-                       {
+                       yaffs_get_obj_name(dsc->nextReturn,
+                                          dsc->de.d_name, NAME_MAX);
+                       if (yaffs_strnlen(dsc->de.d_name, NAME_MAX + 1) == 0) {
                                /* this should not happen! */
-                               yaffs_strcpy(dsc->de.d_name,_Y("zz"));
+                               yaffs_strcpy(dsc->de.d_name, _Y("zz"));
                        }
                        dsc->de.d_reclen = sizeof(struct yaffs_dirent);
                        retVal = &dsc->de;
@@ -2969,10 +2954,11 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 
 }
 
-
 void yaffs_rewinddir(yaffs_DIR *dirp)
 {
-       yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
+       struct yaffsfs_DirSearchContxt *dsc;
+
+       dsc = (struct yaffsfs_DirSearchContxt *) dirp;
 
        yaffsfs_Lock();
 
@@ -2981,64 +2967,64 @@ void yaffs_rewinddir(yaffs_DIR *dirp)
        yaffsfs_Unlock();
 }
 
-
 int yaffs_closedir(yaffs_DIR *dirp)
 {
-       yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
+       struct yaffsfs_DirSearchContxt *dsc;
+
+       dsc = (struct yaffsfs_DirSearchContxt *) dirp;
 
-       if(!dsc){
+       if (!dsc) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-        yaffsfs_Lock();
-        dsc->inUse = 0;
-        list_del(&dsc->others); /* unhook from list */
-        yaffsfs_Unlock();
-        return 0;
+       yaffsfs_Lock();
+       dsc->inUse = 0;
+       list_del(&dsc->others); /* unhook from list */
+       yaffsfs_Unlock();
+       return 0;
 }
 
 /* End of directory stuff */
 
-
 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 {
        struct yaffs_obj *parent = NULL;
        struct yaffs_obj *obj;
        YCHAR *name;
-       int retVal= -1;
-       int mode = 0; /* ignore for now */
+       int retVal = -1;
+       int mode = 0;           /* ignore for now */
        int notDir = 0;
        int loop = 0;
 
-       if(!oldpath || !newpath){
+       if (!oldpath || !newpath) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(newpath) < 0 ||
-               yaffsfs_CheckPath(oldpath) < 0){
+       if (yaffsfs_CheckPath(newpath) < 0 || yaffsfs_CheckPath(oldpath) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
-       parent = yaffsfs_FindDirectory(NULL,newpath,&name,0,&notDir,&loop);
-       if(!parent && notDir)
+       parent = yaffsfs_FindDirectory(NULL, newpath, &name, 0, &notDir, &loop);
+       if (!parent && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if( !parent || yaffs_strnlen(name,5) < 1)
+       else if (!parent || yaffs_strnlen(name, 5) < 1)
                yaffsfs_SetError(-ENOENT);
-       else if(yaffsfs_TooManyObjects(parent->my_dev))
+       else if (yaffsfs_TooManyObjects(parent->my_dev))
                yaffsfs_SetError(-ENFILE);
-       else if(parent->my_dev->read_only)
+       else if (parent->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else if(parent){
-               obj = yaffs_create_symlink(parent,name,mode,0,0,oldpath);
-               if(obj)
+       else if (parent) {
+               obj = yaffs_create_symlink(parent, name, mode, 0, 0, oldpath);
+               if (obj)
                        retVal = 0;
-               else if (yaffsfs_FindObject(NULL,newpath,0,0, NULL,NULL,NULL))
+               else if (yaffsfs_FindObject
+                        (NULL, newpath, 0, 0, NULL, NULL, NULL))
                        yaffsfs_SetError(-EEXIST);
                else
                        yaffsfs_SetError(-ENOSPC);
@@ -3054,31 +3040,31 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {
        struct yaffs_obj *obj = NULL;
        struct yaffs_obj *dir = NULL;
-       int retVal= -1;
+       int retVal = -1;
        int notDir = 0;
        int loop = 0;
 
-       if(!path || !buf){
+       if (!path || !buf) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop);
 
-       if(!dir && notDir)
+       if (!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
-       else if(loop)
+       else if (loop)
                yaffsfs_SetError(-ELOOP);
-       else if(!dir || !obj)
+       else if (!dir || !obj)
                yaffsfs_SetError(-ENOENT);
-       else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
+       else if (obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
                yaffsfs_SetError(-EINVAL);
        else {
                YCHAR *alias = obj->variant.symlink_variant.alias;
-               memset(buf,0,bufsiz);
-               yaffs_strncpy(buf,alias,bufsiz - 1);
+               memset(buf, 0, bufsiz);
+               yaffs_strncpy(buf, alias, bufsiz - 1);
                retVal = 0;
        }
        yaffsfs_Unlock();
@@ -3099,45 +3085,46 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
        int lnkLoop = 0;
        YCHAR *newname;
 
-       if(!oldpath || !linkpath){
+       if (!oldpath || !linkpath) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(linkpath) < 0 ||
-               yaffsfs_CheckPath(oldpath) < 0){
+       if (yaffsfs_CheckPath(linkpath) < 0 || yaffsfs_CheckPath(oldpath) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,oldpath,0,1,&obj_dir,&notDirObj,&objLoop);
-       lnk = yaffsfs_FindObject(NULL,linkpath,0,0,NULL,NULL,NULL);
-       lnk_dir = yaffsfs_FindDirectory(NULL,linkpath,&newname,0,&notDirLnk,&lnkLoop);
+       obj = yaffsfs_FindObject(NULL, oldpath, 0, 1,
+                                &obj_dir, &notDirObj, &objLoop);
+       lnk = yaffsfs_FindObject(NULL, linkpath, 0, 0, NULL, NULL, NULL);
+       lnk_dir = yaffsfs_FindDirectory(NULL, linkpath, &newname,
+                                       0, &notDirLnk, &lnkLoop);
 
-       if((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
+       if ((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
                yaffsfs_SetError(-ENOTDIR);
-       else if(objLoop || lnkLoop)
+       else if (objLoop || lnkLoop)
                yaffsfs_SetError(-ELOOP);
-       else if(!obj_dir || !lnk_dir || !obj)
+       else if (!obj_dir || !lnk_dir || !obj)
                yaffsfs_SetError(-ENOENT);
-       else if(obj->my_dev->read_only)
+       else if (obj->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
-       else if(yaffsfs_TooManyObjects(obj->my_dev))
+       else if (yaffsfs_TooManyObjects(obj->my_dev))
                yaffsfs_SetError(-ENFILE);
-       else if(lnk)
+       else if (lnk)
                yaffsfs_SetError(-EEXIST);
-       else if(lnk_dir->my_dev != obj->my_dev)
+       else if (lnk_dir->my_dev != obj->my_dev)
                yaffsfs_SetError(-EXDEV);
        else {
                retVal = yaffsfs_CheckNameLength(newname);
 
-               if(retVal == 0) {
-                       lnk = yaffs_link_obj(lnk_dir,newname,obj);
-                       if(lnk)
+               if (retVal == 0) {
+                       lnk = yaffs_link_obj(lnk_dir, newname, obj);
+                       if (lnk)
                                retVal = 0;
-                       else{
+                       else {
                                yaffsfs_SetError(-ENOSPC);
                                retVal = -1;
                        }
@@ -3150,15 +3137,14 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
 
 int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
 {
-       pathname=pathname;
-       mode=mode;
-       dev=dev;
+       pathname = pathname;
+       mode = mode;
+       dev = dev;
 
        yaffsfs_SetError(-EINVAL);
        return -1;
 }
 
-
 /*
  * D E B U G   F U N C T I O N S
  */
@@ -3171,19 +3157,19 @@ int yaffs_n_handles(const YCHAR *path)
 {
        struct yaffs_obj *obj;
 
-       if(!path){
+       if (!path) {
                yaffsfs_SetError(-EFAULT);
                return -1;
        }
 
-       if(yaffsfs_CheckPath(path) < 0){
+       if (yaffsfs_CheckPath(path) < 0) {
                yaffsfs_SetError(-ENAMETOOLONG);
                return -1;
        }
 
-       obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
+       obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL);
 
-       if(obj)
+       if (obj)
                return yaffsfs_CountHandles(obj);
        else
                return -1;
@@ -3203,34 +3189,30 @@ int yaffs_set_error(int error)
 int yaffs_dump_dev(const YCHAR *path)
 {
 #if 1
-       path=path;
+       path = path;
 #else
        YCHAR *rest;
 
-       struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);
+       struct yaffs_obj *obj = yaffsfs_FindRoot(path, &rest);
 
-       if(obj){
+       if (obj) {
                struct yaffs_dev *dev = obj->my_dev;
 
                printf("\n"
-                          "n_page_writes.......... %d\n"
-                          "n_page_reads........... %d\n"
-                          "n_erasures....... %d\n"
-                          "n_gc_copies............ %d\n"
-                          "garbageCollections... %d\n"
-                          "passiveGarbageColl'ns %d\n"
-                          "\n",
-                               dev->n_page_writes,
-                               dev->n_page_reads,
-                               dev->n_erasures,
-                               dev->n_gc_copies,
-                               dev->garbageCollections,
-                               dev->passiveGarbageCollections
-               );
+                      "n_page_writes.......... %d\n"
+                      "n_page_reads........... %d\n"
+                      "n_erasures....... %d\n"
+                      "n_gc_copies............ %d\n"
+                      "garbageCollections... %d\n"
+                      "passiveGarbageColl'ns %d\n"
+                      "\n",
+                      dev->n_page_writes,
+                      dev->n_page_reads,
+                      dev->n_erasures,
+                      dev->n_gc_copies,
+                      dev->garbageCollections, dev->passiveGarbageCollections);
 
        }
-
 #endif
        return 0;
 }
-
index 0d4ea15..f2c7666 100644 (file)
 #include "yportenv.h"
 
 
-//typedef long off_t;
-//typedef long dev_t;
-//typedef unsigned long mode_t;
-
-
 #ifndef NAME_MAX
 #define NAME_MAX       256
 #endif
 #define YAFFS_MAX_FILE_SIZE (0x800000000LL - 1)
 
 
-struct yaffs_dirent{
-    long d_ino;                 /* inode number */
-    off_t d_off;                /* offset to this dirent */
-    unsigned short d_reclen;    /* length of this dirent */
-    YUCHAR  d_type;    /* type of this record */
-    YCHAR d_name [NAME_MAX+1];   /* file name (null-terminated) */
-    unsigned d_dont_use;       /* debug pointer, not for public consumption */
+struct yaffs_dirent {
+       long d_ino;                     /* inode number */
+       off_t d_off;                    /* offset to this dirent */
+       unsigned short d_reclen;        /* length of this dirent */
+       YUCHAR d_type;                  /* type of this record */
+       YCHAR d_name[NAME_MAX+1];       /* file name (null-terminated) */
+       unsigned d_dont_use;            /* debug: not for public consumption */
 };
 
-typedef struct yaffs_dirent yaffs_dirent;
-
-
-typedef struct __opaque yaffs_DIR;
+typedef struct opaque_structure yaffs_DIR;
 
 
 
-struct yaffs_stat{
-    int                  st_dev;      /* device */
-    int           st_ino;      /* inode */
-    unsigned      st_mode;     /* protection */
-    int           st_nlink;    /* number of hard links */
-    int           st_uid;      /* user ID of owner */
-    int           st_gid;      /* group ID of owner */
-    unsigned      st_rdev;     /* device type (if inode device) */
-    loff_t         st_size;     /* total size, in bytes */
-    unsigned long st_blksize;  /* blocksize for filesystem I/O */
-    unsigned long st_blocks;   /* number of blocks allocated */
+struct yaffs_stat {
+       int             st_dev;         /* device */
+       int             st_ino;         /* inode */
+       unsigned        st_mode;        /* protection */
+       int             st_nlink;       /* number of hard links */
+       int             st_uid;         /* user ID of owner */
+       int             st_gid;         /* group ID of owner */
+       unsigned        st_rdev;        /* device type (if inode device) */
+       loff_t          st_size;        /* total size, in bytes */
+       unsigned long   st_blksize;     /* blocksize for filesystem I/O */
+       unsigned long   st_blocks;      /* number of blocks allocated */
 #ifdef CONFIG_YAFFS_WINCE
        /* Special 64-bit times for WinCE */
-       unsigned long yst_wince_atime[2];
-       unsigned long yst_wince_mtime[2];
-       unsigned long yst_wince_ctime[2];
+       unsigned long   yst_wince_atime[2];
+       unsigned long   yst_wince_mtime[2];
+       unsigned long   yst_wince_ctime[2];
 #else
-    unsigned long yst_atime;    /* time of last access */
-    unsigned long yst_mtime;    /* time of last modification */
-    unsigned long yst_ctime;    /* time of last change */
+       unsigned long   yst_atime;      /* time of last access */
+       unsigned long   yst_mtime;      /* time of last modification */
+       unsigned long   yst_ctime;      /* time of last change */
 #endif
 };
 
@@ -117,13 +109,19 @@ int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf);
 int yaffs_futime(int fd, const struct yaffs_utimbuf *buf);
 
 
-int yaffs_setxattr(const char *path, const char *name, const void *data, int size, int flags);
-int yaffs_lsetxattr(const char *path, const char *name, const void *data, int size, int flags);
-int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags);
+int yaffs_setxattr(const char *path, const char *name,
+                       const void *data, int size, int flags);
+int yaffs_lsetxattr(const char *path, const char *name,
+                       const void *data, int size, int flags);
+int yaffs_fsetxattr(int fd, const char *name,
+                       const void *data, int size, int flags);
 
-int yaffs_getxattr(const char *path, const char *name, void *data, int size);
-int yaffs_lgetxattr(const char *path, const char *name, void *data, int size);
-int yaffs_fgetxattr(int fd, const char *name, void *data, int size);
+int yaffs_getxattr(const char *path, const char *name,
+                       void *data, int size);
+int yaffs_lgetxattr(const char *path, const char *name,
+                       void *data, int size);
+int yaffs_fgetxattr(int fd, const char *name,
+                       void *data, int size);
 
 int yaffs_removexattr(const char *path, const char *name);
 int yaffs_lremovexattr(const char *path, const char *name);
@@ -136,8 +134,14 @@ int yaffs_flistxattr(int fd, char *list, int size);
 
 #ifdef CONFIG_YAFFS_WINCE
 
-int yaffs_set_wince_times(int fd, const unsigned *wctime, const unsigned *watime, const unsigned *wmtime);
-int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime);
+int yaffs_set_wince_times(int fd,
+                       const unsigned *wctime,
+                       const unsigned *watime,
+                       const unsigned *wmtime);
+int yaffs_get_wince_times(int fd,
+                       unsigned *wctime,
+                       unsigned *watime,
+                       unsigned *wmtime);
 
 #endif
 
@@ -178,7 +182,7 @@ int yaffs_n_handles(const YCHAR *path);
 
 #define YAFFS_SHARE_READ  1
 #define YAFFS_SHARE_WRITE 2
-int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int shareMode) ;
+int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int shareMode);
 
 struct yaffs_dev;
 void yaffs_add_device(struct yaffs_dev *dev);
@@ -192,10 +196,10 @@ struct yaffs_dev *yaffs_next_dev(void);
 
 /* Function to get the last error */
 int yaffs_get_error(void);
-const char * yaffs_error_to_str(int err);
+const char *yaffs_error_to_str(int err);
 
 /* Function only for debugging */
-void * yaffs_getdev(const YCHAR *path);
+void *yaffs_getdev(const YCHAR *path);
 int yaffs_dump_dev(const YCHAR *path);
 int yaffs_set_error(int error);
 
index f2bb496..eff8ff9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2011 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -20,8 +20,6 @@
 #ifndef __YDIRECTENV_H__
 #define __YDIRECTENV_H__
 
-// Direct interface
-
 #include "stdlib.h"
 #include "stdio.h"
 #include "string.h"
@@ -37,26 +35,26 @@ void yaffs_bug_fn(const char *file_name, int line_no);
 #define YUCHAR unsigned char
 #define _Y(x) x
 
-#define yaffs_strcat(a,b)    strcat(a,b)
-#define yaffs_strcpy(a,b)    strcpy(a,b)
-#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
-#define yaffs_strnlen(s,m)           strnlen(s,m)
+#define yaffs_strcat(a, b)     strcat(a, b)
+#define yaffs_strcpy(a, b)     strcpy(a, b)
+#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
+#define yaffs_strnlen(s, m)    strnlen(s, m)
 #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-#define yaffs_strcmp(a,b) strcasecmp(a,b)
-#define yaffs_strncmp(a,b,c) strncasecmp(a,b,c)
+#define yaffs_strcmp(a, b)     strcasecmp(a, b)
+#define yaffs_strncmp(a, b, c) strncasecmp(a, b, c)
 #else
-#define yaffs_strcmp(a,b) strcmp(a,b)
-#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
+#define yaffs_strcmp(a, b)     strcmp(a, b)
+#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
 #endif
 
 #define hweight8(x)    yaffs_hweight8(x)
 #define hweight32(x)   yaffs_hweight32(x)
 
 void yaffs_qsort(void *aa, size_t n, size_t es,
-        int (*cmp)(const void *, const void *));
+               int (*cmp)(const void *, const void *));
 
 #define sort(base, n, sz, cmp_fn, swp) yaffs_qsort(base, n, sz, cmp_fn)
-        
+
 #define YAFFS_PATH_DIVIDERS  "/"
 
 #ifdef NO_inline
@@ -65,17 +63,17 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
 #define inline __inline__
 #endif
 
-#define kmalloc(x,flags) yaffsfs_malloc(x)
+#define kmalloc(x, flags) yaffsfs_malloc(x)
 #define kfree(x)   yaffsfs_free(x)
 #define vmalloc(x) yaffsfs_malloc(x)
 #define vfree(x) yaffsfs_free(x)
 
-#define cond_resched()  do {} while(0)
+#define cond_resched()  do {} while (0)
 
 #define yaffs_trace(msk, fmt, ...) do { \
-       if(yaffs_trace_mask & (msk)) \
+       if (yaffs_trace_mask & (msk)) \
                printf("yaffs: " fmt "\n", ##__VA_ARGS__); \
-} while(0)
+} while (0)
 
 
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"
@@ -86,7 +84,7 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
 #define Y_CURRENT_TIME yaffsfs_CurrentTime()
 #define Y_TIME_CONVERT(x) x
 
-#define YAFFS_ROOT_MODE                                0666
+#define YAFFS_ROOT_MODE                        0666
 #define YAFFS_LOSTNFOUND_MODE          0666
 
 #include "yaffs_list.h"
index a797c8a..b47a4d6 100644 (file)
@@ -94,7 +94,7 @@ struct iattr {
 #ifdef CONFIG_YAFFSFS_PROVIDE_VALUES
 
 #ifndef O_RDONLY
-#define O_RDONLY        00
+#define O_RDONLY       00
 #endif
 
 #ifndef O_WRONLY
@@ -105,8 +105,8 @@ struct iattr {
 #define O_RDWR         02
 #endif
 
-#ifndef O_CREAT                
-#define O_CREAT        0100
+#ifndef O_CREAT
+#define O_CREAT                0100
 #endif
 
 #ifndef O_EXCL
@@ -157,7 +157,7 @@ struct iattr {
 #define EACCES 13
 #endif
 
-#ifndef EXDEV  
+#ifndef EXDEV
 #define EXDEV  18
 #endif
 
@@ -214,7 +214,7 @@ struct iattr {
 #endif
 
 
-// Mode flags
+/* Mode flags */
 
 #ifndef S_IFMT
 #define S_IFMT         0170000
@@ -257,7 +257,7 @@ struct iattr {
 #define S_ISFIFO(m)    (((m) & S_IFMT) == S_IFIFO)
 
 
-#ifndef S_IREAD 
+#ifndef S_IREAD
 #define S_IREAD                0000400
 #endif
 
index 8acb59b..e5a15f9 100644 (file)
@@ -177,7 +177,8 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer)
 
        if (buffer) {
                /* assume it is an unmanaged one. */
-               yaffs_trace(YAFFS_TRACE_BUFFERS, "Releasing unmanaged temp buffer");
+               yaffs_trace(YAFFS_TRACE_BUFFERS,
+                       "Releasing unmanaged temp buffer");
                kfree(buffer);
                dev->unmanaged_buffer_deallocs++;
        }
@@ -280,7 +281,7 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
 
 static inline int yaffs_hash_fn(int n)
 {
-       if(n < 0)
+       if (n < 0)
                n = -n;
        return n % YAFFS_NOBJECT_BUCKETS;
 }
@@ -2388,7 +2389,7 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
        bi->has_shrink_hdr = 0;
        bi->skip_erased_check = 1;      /* Clean, so no need to check */
        bi->gc_prioritise = 0;
-       bi->has_summary=0;
+       bi->has_summary = 0;
 
        yaffs_clear_chunk_bits(dev, block_no);
 
@@ -2503,7 +2504,7 @@ static inline int yaffs_gc_process_chunk(struct yaffs_dev *dev,
 
                        /* Update file size */
                        if (object->variant_type == YAFFS_OBJECT_TYPE_FILE) {
-                               yaffs_oh_size_load( oh,
+                               yaffs_oh_size_load(oh,
                                    object->variant.file_variant.file_size);
                                tags.extra_file_size =
                                    object->variant.file_variant.file_size;
@@ -3346,8 +3347,8 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                break;
        case YAFFS_OBJECT_TYPE_FILE:
                if (oh->parent_obj_id != YAFFS_OBJECTID_DELETED &&
-                    oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED)
-                    file_size = in->variant.file_variant.file_size;
+                   oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED)
+                       file_size = in->variant.file_variant.file_size;
                yaffs_oh_size_load(oh, file_size);
                break;
        case YAFFS_OBJECT_TYPE_HARDLINK:
@@ -3531,7 +3532,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
        while (n > 0 && chunk_written >= 0) {
                yaffs_addr_to_chunk(dev, offset, &chunk, &start);
 
-               if (((loff_t)chunk) * dev->data_bytes_per_chunk + start != offset ||
+               if (((loff_t)chunk) *
+                   dev->data_bytes_per_chunk + start != offset ||
                    start >= dev->data_bytes_per_chunk) {
                        yaffs_trace(YAFFS_TRACE_ERROR,
                                "AddrToChunk of offset %lld gives chunk %d start %d",
@@ -3552,7 +3554,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                         * before.
                         */
 
-                       chunk_start = (((loff_t)(chunk - 1)) * dev->data_bytes_per_chunk);
+                       chunk_start = (((loff_t)(chunk - 1)) *
+                                       dev->data_bytes_per_chunk);
 
                        if (chunk_start > in->variant.file_variant.file_size)
                                n_bytes_read = 0;       /* Past end of file */
@@ -3699,7 +3702,7 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, loff_t new_size)
        int last_del;
        int start_del;
 
-       if(old_size > 0)
+       if (old_size > 0)
                yaffs_addr_to_chunk(dev, old_size - 1, &last_del, &dummy);
        else
                last_del = 0;
@@ -4831,7 +4834,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        if (!init_failed && !yaffs_create_initial_dir(dev))
                init_failed = 1;
 
-       if(!init_failed && dev->param.is_yaffs2 &&
+       if (!init_failed && dev->param.is_yaffs2 &&
                !dev->param.disable_summary &&
                !yaffs_summary_init(dev))
                init_failed = 1;
@@ -5019,7 +5022,7 @@ loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh)
 {
        loff_t retval;
 
-       if(~(oh->file_size_high))
+       if (~(oh->file_size_high))
                retval = (((loff_t) oh->file_size_high) << 32) |
                        (((loff_t) oh->file_size_low) & 0xFFFFFFFF);
        else
index a9fdde2..e3558c5 100644 (file)
@@ -536,7 +536,7 @@ struct yaffs_param {
                                 */
        int use_nand_ecc;       /* Flag to decide whether or not to use
                                 * NAND driver ECC on data (yaffs1) */
-        int tags_9bytes;       /* Use 9 byte tags */
+       int tags_9bytes;        /* Use 9 byte tags */
        int no_tags_ecc;        /* Flag to decide whether or not to do ECC
                                 * on packed tags (yaffs2) */
 
index a6907bf..dbc9122 100644 (file)
@@ -80,21 +80,21 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
         * that only zeroed-bits stick and set tag bytes to all-ones and
         * zero just the (not) deleted bit.
         */
-        
-       if(dev->param.tags_9bytes) {
-               ((u8 *) &pt1)[8] = 0xff;
-               if (etags->is_deleted) {
-                       memset(&pt1, 0xff, 8);
-                       /* zero page_status byte to indicate deleted */
-                       ((u8 *) &pt1)[8] = 0;
-                }
-        } else {
-               if (etags->is_deleted) {
-                       memset(&pt1, 0xff, 8);
-                       /* clear delete status bit to indicate deleted */
-                       pt1.deleted = 0;
-                }
-        }
+
+       if (dev->param.tags_9bytes) {
+               ((u8 *) &pt1)[8] = 0xff;
+               if (etags->is_deleted) {
+                       memset(&pt1, 0xff, 8);
+                       /* zero page_status byte to indicate deleted */
+                       ((u8 *) &pt1)[8] = 0;
+               }
+       } else {
+               if (etags->is_deleted) {
+                       memset(&pt1, 0xff, 8);
+                       /* clear delete status bit to indicate deleted */
+                       pt1.deleted = 0;
+               }
+       }
 
        memset(&ops, 0, sizeof(ops));
        ops.mode = MTD_OPS_AUTO_OOB;
@@ -259,7 +259,8 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
  *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
-static int nandmtd1_test_prerequists(struct yaffs_dev *dev, struct mtd_info *mtd)
+static int nandmtd1_test_prerequists(struct yaffs_dev *dev,
+                                       struct mtd_info *mtd)
 {
        /* 2.6.18 has mtd->ecclayout->oobavail */
        /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
index b103ef6..e1d18cc 100644 (file)
@@ -62,12 +62,12 @@ static void yaffs_dump_tags2(const struct yaffs_ext_tags *t)
 
 static int yaffs_check_tags_extra_packable(const struct yaffs_ext_tags *t)
 {
-       if(t->chunk_id != 0 || !t->extra_available)
+       if (t->chunk_id != 0 || !t->extra_available)
                return 0;
 
        /* Check if the file size is too long to store */
        if (t->extra_obj_type == YAFFS_OBJECT_TYPE_FILE &&
-           (t->extra_file_size>> 31) != 0)
+           (t->extra_file_size >> 31) != 0)
                return 0;
        return 1;
 }
index def0052..6f3c783 100644 (file)
@@ -35,7 +35,7 @@
  * A summary header is written as the first part of each chunk of summary data.
  * The summary header must match or the summary is rejected.
  */
+
 /* Summary tags don't need the sequence number because that is redundant. */
 struct yaffs_summary_tags {
        unsigned obj_id;
@@ -54,7 +54,7 @@ struct yaffs_summary_header {
 
 static void yaffs_summary_clear(struct yaffs_dev *dev)
 {
-       if(!dev->sum_tags)
+       if (!dev->sum_tags)
                return;
        memset(dev->sum_tags, 0, dev->chunks_per_summary *
                sizeof(struct yaffs_summary_tags));
@@ -80,7 +80,7 @@ int yaffs_summary_init(struct yaffs_dev *dev)
                        sizeof(struct yaffs_summary_tags);
 
        chunks_used = (sum_bytes + dev->data_bytes_per_chunk - 1)/
-                       (dev->data_bytes_per_chunk - 
+                       (dev->data_bytes_per_chunk -
                                sizeof(struct yaffs_summary_header));
 
        dev->chunks_per_summary = dev->param.chunks_per_block - chunks_used;
@@ -88,7 +88,7 @@ int yaffs_summary_init(struct yaffs_dev *dev)
                                dev->chunks_per_summary;
        dev->sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
        dev->gc_sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS);
-       if(!dev->sum_tags || !dev->gc_sum_tags) {
+       if (!dev->sum_tags || !dev->gc_sum_tags) {
                yaffs_summary_deinit(dev);
                return YAFFS_FAIL;
        }
@@ -105,14 +105,14 @@ static unsigned yaffs_summary_sum(struct yaffs_dev *dev)
        unsigned sum = 0;
 
        i = sizeof(struct yaffs_summary_tags) *
-                               dev->chunks_per_summary;;
-       while(i > 0){
+                               dev->chunks_per_summary;
+       while (i > 0) {
                sum += *sum_buffer;
                sum_buffer++;
                i--;
        }
 
-       return sum;     
+       return sum;
 }
 
 static int yaffs_summary_write(struct yaffs_dev *dev, int blk)
@@ -137,12 +137,12 @@ static int yaffs_summary_write(struct yaffs_dev *dev, int blk)
        tags.chunk_id = 1;
        chunk_in_block = dev->chunks_per_summary;
        chunk_in_nand = dev->alloc_block * dev->param.chunks_per_block +
-                                               dev-> chunks_per_summary;
+                                               dev->chunks_per_summary;
        hdr.version = YAFFS_SUMMARY_VERSION;
        hdr.block = blk;
        hdr.seq = bi->seq_number;
        hdr.sum = yaffs_summary_sum(dev);
-       
+
        do {
                this_tx = n_bytes;
                if (this_tx > sum_bytes_per_chunk)
@@ -203,7 +203,7 @@ int yaffs_summary_read(struct yaffs_dev *dev,
        chunk_id = 1;
        do {
                this_tx = n_bytes;
-               if(this_tx > sum_bytes_per_chunk)
+               if (this_tx > sum_bytes_per_chunk)
                        this_tx = sum_bytes_per_chunk;
                result = yaffs_rd_chunk_tags_nand(dev, chunk_in_nand,
                                                buffer, &tags);
@@ -232,15 +232,15 @@ int yaffs_summary_read(struct yaffs_dev *dev,
        } while (result == YAFFS_OK && n_bytes > 0);
        yaffs_release_temp_buffer(dev, buffer);
 
-       if(result == YAFFS_OK) {
-               /* Verify header */             
+       if (result == YAFFS_OK) {
+               /* Verify header */
                if (hdr.version != YAFFS_SUMMARY_VERSION ||
                    hdr.block != blk ||
                    hdr.seq != bi->seq_number ||
                    hdr.sum != yaffs_summary_sum(dev))
-                   result = YAFFS_FAIL;
+                       result = YAFFS_FAIL;
        }
-       
+
        if (st == dev->sum_tags && result == YAFFS_OK)
                bi->has_summary = 1;
 
@@ -256,17 +256,17 @@ int yaffs_summary_add(struct yaffs_dev *dev,
        int block_in_nand = chunk_in_nand / dev->param.chunks_per_block;
        int chunk_in_block = chunk_in_nand % dev->param.chunks_per_block;
 
-       if(!dev->sum_tags)
+       if (!dev->sum_tags)
                return YAFFS_OK;
 
-       if(chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
+       if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
                yaffs_pack_tags2_tags_only(&tags_only, tags);
                sum_tags = &dev->sum_tags[chunk_in_block];
                sum_tags->chunk_id = tags_only.chunk_id;
                sum_tags->n_bytes = tags_only.n_bytes;
                sum_tags->obj_id = tags_only.obj_id;
 
-               if(chunk_in_block == dev->chunks_per_summary - 1) {
+               if (chunk_in_block == dev->chunks_per_summary - 1) {
                        /* Time to write out the summary */
                        yaffs_summary_write(dev, block_in_nand);
                        yaffs_summary_clear(dev);
@@ -282,7 +282,7 @@ int yaffs_summary_fetch(struct yaffs_dev *dev,
 {
        struct yaffs_packed_tags2_tags_only tags_only;
        struct yaffs_summary_tags *sum_tags;
-       if(chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
+       if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) {
                sum_tags = &dev->sum_tags[chunk_in_block];
                tags_only.chunk_id = sum_tags->chunk_id;
                tags_only.n_bytes = sum_tags->n_bytes;
@@ -301,12 +301,13 @@ void yaffs_summary_gc(struct yaffs_dev *dev, int blk)
        if (!bi->has_summary)
                return;
 
-       for (i = dev->chunks_per_summary; i < dev->param.chunks_per_block; i++) {
-               if( yaffs_check_chunk_bit(dev, blk, i)) {
+       for (i = dev->chunks_per_summary;
+            i < dev->param.chunks_per_block;
+            i++) {
+               if (yaffs_check_chunk_bit(dev, blk, i)) {
                        yaffs_clear_chunk_bit(dev, blk, i);
                        bi->pages_in_use--;
                        dev->n_free_chunks++;
                }
        }
-
 }
index 19ced5f..ba6f3d6 100644 (file)
@@ -436,7 +436,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
        return -ENOTEMPTY;
 }
 
-static int yaffs_sync_object(struct file *file, loff_t start, loff_t end, int datasync)
+static int yaffs_sync_object(struct file *file,
+                               loff_t start, loff_t end, int datasync)
 {
 
        struct yaffs_obj *obj;
@@ -1219,7 +1220,8 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
                (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        n_written = yaffs_wr_file(obj, buffer,
-                                 ((loff_t)page->index) << PAGE_CACHE_SHIFT, n_bytes, 0);
+                                 ((loff_t)page->index) << PAGE_CACHE_SHIFT,
+                                 n_bytes, 0);
 
        yaffs_touch_super(dev);
 
@@ -2374,9 +2376,9 @@ static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
 static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev)
 {
        buf += sprintf(buf, "max file size......... %lld\n",
-                       (long long) yaffs_max_file_size(dev));
+                       (long long) yaffs_max_file_size(dev));
        buf += sprintf(buf, "data_bytes_per_chunk.. %d\n",
-                   dev->data_bytes_per_chunk);
+                       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 +=
index 5d09049..d277e20 100644 (file)
@@ -323,8 +323,8 @@ int yaffs1_scan(struct yaffs_dev *dev)
                                        case YAFFS_OBJECT_TYPE_FILE:
                                                if (dev->param.
                                                    use_header_file_size)
-                                                   in->variant.
-                                                     file_variant.file_size
+                                                       in->variant.
+                                                       file_variant.file_size
                                                        = yaffs_oh_to_size(oh);
                                                break;
                                        case YAFFS_OBJECT_TYPE_HARDLINK:
index aa32055..f1dc972 100644 (file)
@@ -1473,7 +1473,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev)
 
                /* For each chunk in each block that needs scanning.... */
                found_chunks = 0;
-               if(summary_available)
+               if (summary_available)
                        c = dev->chunks_per_summary - 1;
                else
                        c = dev->param.chunks_per_block - 1;