From 3ecea787c3d99a5e13bf3b826dd3ad772fbad810 Mon Sep 17 00:00:00 2001 From: Charles Manning Date: Wed, 3 Nov 2010 15:02:10 +1300 Subject: [PATCH] yaffs: Redo Lindent Only applies to Linux files. Signed-off-by: Charles Manning --- moduleconfig.h | 1 - yaffs_allocator.c | 74 +- yaffs_attribs.c | 22 +- yaffs_attribs.h | 4 - yaffs_bitmap.c | 13 +- yaffs_checkptrw.c | 185 ++--- yaffs_checkptrw.h | 3 +- yaffs_ecc.c | 37 +- yaffs_ecc.h | 10 +- yaffs_getblockinfo.h | 3 +- yaffs_guts.c | 1551 ++++++++++++++++++++--------------------- yaffs_guts.h | 353 +++++----- yaffs_linux.h | 13 +- yaffs_mtdif.c | 6 +- yaffs_mtdif1.h | 7 +- yaffs_mtdif1_multi.c | 59 +- yaffs_mtdif1_single.c | 54 +- yaffs_mtdif2.h | 8 +- yaffs_mtdif2_multi.c | 70 +- yaffs_mtdif2_single.c | 58 +- yaffs_nameval.c | 128 ++-- yaffs_nameval.h | 8 +- yaffs_nand.c | 54 +- yaffs_nand.h | 20 +- yaffs_packedtags1.c | 9 +- yaffs_packedtags1.h | 8 +- yaffs_packedtags2.c | 75 +- yaffs_packedtags2.h | 16 +- yaffs_tagscompat.c | 84 +-- yaffs_tagscompat.h | 19 +- yaffs_tagsvalidity.c | 3 +- yaffs_tagsvalidity.h | 1 - yaffs_trace.h | 2 - yaffs_verify.c | 242 ++++--- yaffs_verify.h | 10 +- yaffs_vfs_multi.c | 1163 +++++++++++++++--------------- yaffs_vfs_single.c | 1113 +++++++++++++++-------------- yaffs_yaffs1.c | 139 ++-- yaffs_yaffs2.c | 721 +++++++++++-------- yaffs_yaffs2.h | 7 +- yportenv_multi.h | 11 +- yportenv_single.h | 7 +- 42 files changed, 3212 insertions(+), 3159 deletions(-) diff --git a/moduleconfig.h b/moduleconfig.h index 4b4d642..20a0882 100644 --- a/moduleconfig.h +++ b/moduleconfig.h @@ -62,7 +62,6 @@ /* Meaning: Select to disable background processing */ /* #define CONFIG_DISABLE_BACKGROUND */ - /* Default: Selected */ /* Meaning: Enable XATTR support */ #define CONFIG_YAFFS_XATTR diff --git a/yaffs_allocator.c b/yaffs_allocator.c index 35d8869..03ede86 100644 --- a/yaffs_allocator.c +++ b/yaffs_allocator.c @@ -11,8 +11,6 @@ * published by the Free Software Foundation. */ - - #include "yaffs_allocator.h" #include "yaffs_guts.h" #include "yaffs_trace.h" @@ -54,10 +52,9 @@ void yaffs_deinit_raw_objs(struct yaffs_dev *dev) struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) { dev = dev; - return (struct yaffs_obj *) YMALLOC(sizeof(struct yaffs_obj)); + return (struct yaffs_obj *)YMALLOC(sizeof(struct yaffs_obj)); } - void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { @@ -72,13 +69,11 @@ struct yaffs_tnode_list { struct yaffs_tnode *tnodes; }; - struct yaffs_obj_list { struct yaffs_obj_list *next; struct yaffs_obj *objects; }; - struct yaffs_allocator { int n_tnodes_created; struct yaffs_tnode *free_tnodes; @@ -92,15 +87,15 @@ struct yaffs_allocator { struct yaffs_obj_list *allocated_obj_list; }; - static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev) { - struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; struct yaffs_tnode_list *tmp; - if(!allocator){ + if (!allocator) { YBUG(); return; } @@ -123,7 +118,7 @@ static void yaffs_init_raw_tnodes(struct yaffs_dev *dev) { struct yaffs_allocator *allocator = dev->allocator; - if(allocator){ + if (allocator) { allocator->alloc_tnode_list = NULL; allocator->free_tnodes = NULL; allocator->n_free_tnodes = 0; @@ -134,7 +129,8 @@ static void yaffs_init_raw_tnodes(struct yaffs_dev *dev) static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) { - struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; int i; struct yaffs_tnode *new_tnodes; u8 *mem; @@ -142,7 +138,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) struct yaffs_tnode *next; struct yaffs_tnode_list *tnl; - if(!allocator){ + if (!allocator) { YBUG(); return YAFFS_FAIL; } @@ -150,26 +146,25 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) if (n_tnodes < 1) return YAFFS_OK; - /* make these things */ new_tnodes = YMALLOC(n_tnodes * dev->tnode_size); - mem = (u8 *)new_tnodes; + mem = (u8 *) new_tnodes; if (!new_tnodes) { T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); + (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); return YAFFS_FAIL; } /* New hookup for wide tnodes */ for (i = 0; i < n_tnodes - 1; i++) { - curr = (struct yaffs_tnode *) &mem[i * dev->tnode_size]; - next = (struct yaffs_tnode *) &mem[(i+1) * dev->tnode_size]; + curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size]; + next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size]; curr->internal[0] = next; } - curr = (struct yaffs_tnode *) &mem[(n_tnodes - 1) * dev->tnode_size]; + curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size]; curr->internal[0] = allocator->free_tnodes; allocator->free_tnodes = (struct yaffs_tnode *)mem; @@ -186,7 +181,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) T(YAFFS_TRACE_ERROR, (TSTR ("yaffs: Could not add tnodes to management list" TENDSTR))); - return YAFFS_FAIL; + return YAFFS_FAIL; } else { tnl->tnodes = new_tnodes; tnl->next = allocator->alloc_tnode_list; @@ -198,13 +193,13 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) return YAFFS_OK; } - struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) { - struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; struct yaffs_tnode *tn = NULL; - if(!allocator){ + if (!allocator) { YBUG(); return NULL; } @@ -227,7 +222,7 @@ void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { struct yaffs_allocator *allocator = dev->allocator; - if(!allocator){ + if (!allocator) { YBUG(); return; } @@ -237,16 +232,14 @@ void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) allocator->free_tnodes = tn; allocator->n_free_tnodes++; } - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } - - static void yaffs_init_raw_objs(struct yaffs_dev *dev) { struct yaffs_allocator *allocator = dev->allocator; - if(allocator) { + if (allocator) { allocator->allocated_obj_list = NULL; allocator->free_objs = NULL; allocator->n_free_objects = 0; @@ -259,7 +252,7 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev) struct yaffs_allocator *allocator = dev->allocator; struct yaffs_obj_list *tmp; - if(!allocator){ + if (!allocator) { YBUG(); return; } @@ -277,7 +270,6 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev) allocator->n_obj_created = 0; } - static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) { struct yaffs_allocator *allocator = dev->allocator; @@ -286,7 +278,7 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) struct yaffs_obj *new_objs; struct yaffs_obj_list *list; - if(!allocator){ + if (!allocator) { YBUG(); return YAFFS_FAIL; } @@ -299,11 +291,11 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) list = YMALLOC(sizeof(struct yaffs_obj_list)); if (!new_objs || !list) { - if (new_objs){ + if (new_objs) { YFREE(new_objs); new_objs = NULL; } - if (list){ + if (list) { YFREE(list); list = NULL; } @@ -315,7 +307,7 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) /* Hook them into the free list */ for (i = 0; i < n_obj - 1; i++) { new_objs[i].siblings.next = - (struct list_head *)(&new_objs[i + 1]); + (struct list_head *)(&new_objs[i + 1]); } new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs; @@ -337,7 +329,7 @@ struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) struct yaffs_obj *obj = NULL; struct yaffs_allocator *allocator = dev->allocator; - if(!allocator) { + if (!allocator) { YBUG(); return obj; } @@ -349,20 +341,19 @@ struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) if (allocator->free_objs) { obj = allocator->free_objs; allocator->free_objs = - (struct yaffs_obj *) (allocator->free_objs->siblings.next); + (struct yaffs_obj *)(allocator->free_objs->siblings.next); allocator->n_free_objects--; } return obj; } - void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { struct yaffs_allocator *allocator = dev->allocator; - if(!allocator) + if (!allocator) YBUG(); else { /* Link into the free list. */ @@ -374,12 +365,12 @@ void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) { - if(dev->allocator){ + if (dev->allocator) { yaffs_deinit_raw_tnodes(dev); yaffs_deinit_raw_objs(dev); YFREE(dev->allocator); - dev->allocator=NULL; + dev->allocator = NULL; } else YBUG(); } @@ -388,9 +379,9 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) { struct yaffs_allocator *allocator; - if(!dev->allocator){ + if (!dev->allocator) { allocator = YMALLOC(sizeof(struct yaffs_allocator)); - if(allocator){ + if (allocator) { dev->allocator = allocator; yaffs_init_raw_tnodes(dev); yaffs_init_raw_objs(dev); @@ -399,5 +390,4 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) YBUG(); } - #endif diff --git a/yaffs_attribs.c b/yaffs_attribs.c index 651a473..aaf4685 100644 --- a/yaffs_attribs.c +++ b/yaffs_attribs.c @@ -11,7 +11,6 @@ * published by the Free Software Foundation. */ - #include "yaffs_guts.h" #include "yaffs_attribs.h" @@ -27,7 +26,7 @@ void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj) { - oh->yst_uid = obj->yst_uid; + oh->yst_uid = obj->yst_uid; oh->yst_gid = obj->yst_gid; oh->yst_atime = obj->yst_atime; oh->yst_mtime = obj->yst_mtime; @@ -38,22 +37,21 @@ void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj) void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c) { - obj->yst_mtime = Y_CURRENT_TIME; - if(do_a) - obj->yst_atime = obj->yst_atime; - if(do_c) - obj->yst_ctime = obj->yst_atime; + obj->yst_mtime = Y_CURRENT_TIME; + if (do_a) + obj->yst_atime = obj->yst_atime; + if (do_c) + obj->yst_ctime = obj->yst_atime; } void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev) { - yaffs_load_current_time(obj,1,1); + yaffs_load_current_time(obj, 1, 1); obj->yst_rdev = rdev; obj->yst_uid = uid; obj->yst_gid = gid; } - loff_t yaffs_get_file_size(struct yaffs_obj *obj) { YCHAR *alias = NULL; @@ -64,9 +62,9 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj) return obj->variant.file_variant.file_size; case YAFFS_OBJECT_TYPE_SYMLINK: alias = obj->variant.symlink_variant.alias; - if(!alias) + if (!alias) return 0; - return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH); + return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH); default: return 0; } @@ -124,5 +122,3 @@ int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr) return YAFFS_OK; } - - diff --git a/yaffs_attribs.h b/yaffs_attribs.h index c9a0867..33d541d 100644 --- a/yaffs_attribs.h +++ b/yaffs_attribs.h @@ -16,10 +16,8 @@ #ifndef __YAFFS_ATTRIBS_H__ #define __YAFFS_ATTRIBS_H__ - #include "yaffs_guts.h" - void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh); void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj); void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev); @@ -27,6 +25,4 @@ void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c); int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr); int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr); - #endif - diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c index d54a27a..5d1cfb2 100644 --- a/yaffs_bitmap.c +++ b/yaffs_bitmap.c @@ -21,21 +21,21 @@ static Y_INLINE u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), - blk)); + (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), + blk)); YBUG(); } return dev->chunk_bits + - (dev->chunk_bit_stride * (blk - dev->internal_start_block)); + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); } void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block || - chunk < 0 || chunk >= dev->param.chunks_per_block) { + chunk < 0 || chunk >= dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR), - blk, chunk)); + (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid" TENDSTR), + blk, chunk)); YBUG(); } } @@ -102,4 +102,3 @@ int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk) } return n; } - diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c index 2991305..2cb144c 100644 --- a/yaffs_checkptrw.c +++ b/yaffs_checkptrw.c @@ -19,33 +19,36 @@ static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev) int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, - (TSTR("checkpt blocks available = %d" TENDSTR), - blocks_avail)); + (TSTR("checkpt blocks available = %d" TENDSTR), blocks_avail)); return (blocks_avail <= 0) ? 0 : 1; } - static int yaffs_checkpt_erase(struct yaffs_dev *dev) { int i; if (!dev->param.erase_fn) return 0; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR), - dev->internal_start_block, dev->internal_end_block)); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d" TENDSTR), + dev->internal_start_block, + dev->internal_end_block)); for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("erasing checkpt block %d" TENDSTR), i)); dev->n_erasures++; - if (dev->param.erase_fn(dev, i - dev->block_offset /* realign */)) { + if (dev->param. + erase_fn(dev, + i - dev->block_offset /* realign */ )) { bi->block_state = YAFFS_BLOCK_STATE_EMPTY; dev->n_erased_blocks++; - dev->n_free_chunks += dev->param.chunks_per_block; + dev->n_free_chunks += + dev->param.chunks_per_block; } else { dev->param.bad_block_fn(dev, i); bi->block_state = YAFFS_BLOCK_STATE_DEAD; @@ -58,30 +61,35 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev) return 1; } - static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev) { - int i; + int i; int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, - (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), - dev->n_erased_blocks, dev->param.n_reserved_blocks, blocks_avail, dev->checkpt_next_block)); + (TSTR + ("allocating checkpt block: erased %d reserved %d avail %d next %d " + TENDSTR), dev->n_erased_blocks, dev->param.n_reserved_blocks, + blocks_avail, dev->checkpt_next_block)); if (dev->checkpt_next_block >= 0 && - dev->checkpt_next_block <= dev->internal_end_block && - blocks_avail > 0) { + dev->checkpt_next_block <= dev->internal_end_block && + blocks_avail > 0) { - for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { - struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; + i++) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, i); if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { dev->checkpt_next_block = i + 1; dev->checkpt_cur_block = i; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("allocating checkpt block %d" TENDSTR), + i)); return; } } } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks" TENDSTR))); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; @@ -89,62 +97,67 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev) static void yaffs2_checkpt_find_block(struct yaffs_dev *dev) { - int i; + int i; struct yaffs_ext_tags tags; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), - dev->blocks_in_checkpt, dev->checkpt_next_block)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), + dev->blocks_in_checkpt, dev->checkpt_next_block)); if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) - for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; + i++) { int chunk = i * dev->param.chunks_per_block; int realigned_chunk = chunk - dev->chunk_offset; dev->param.read_chunk_tags_fn(dev, realigned_chunk, - NULL, &tags); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), - i, tags.obj_id, tags.seq_number, tags.ecc_result)); + NULL, &tags); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("find next checkpt block: search: block %d oid %d seq %d eccr %d" + TENDSTR), i, tags.obj_id, tags.seq_number, + tags.ecc_result)); if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { /* Right kind of block */ dev->checkpt_next_block = tags.obj_id; dev->checkpt_cur_block = i; - dev->checkpt_block_list[dev->blocks_in_checkpt] = i; + dev->checkpt_block_list[dev-> + blocks_in_checkpt] = i; dev->blocks_in_checkpt++; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("found checkpt block %d" TENDSTR), i)); return; } } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("found no more checkpt blocks" TENDSTR))); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; } - int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing) { - dev->checkpt_open_write = writing; /* Got the functions we need? */ if (!dev->param.write_chunk_tags_fn || - !dev->param.read_chunk_tags_fn || - !dev->param.erase_fn || - !dev->param.bad_block_fn) + !dev->param.read_chunk_tags_fn || + !dev->param.erase_fn || !dev->param.bad_block_fn) return 0; if (writing && !yaffs2_checkpt_space_ok(dev)) return 0; if (!dev->checkpt_buffer) - dev->checkpt_buffer = YMALLOC_DMA(dev->param.total_bytes_per_chunk); + dev->checkpt_buffer = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); if (!dev->checkpt_buffer) return 0; - dev->checkpt_page_seq = 0; dev->checkpt_byte_count = 0; dev->checkpt_sum = 0; @@ -165,9 +178,12 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing) /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) * going to be way more than we need */ dev->blocks_in_checkpt = 0; - dev->checkpt_max_blocks = (dev->internal_end_block - dev->internal_start_block)/16 + 2; - dev->checkpt_block_list = YMALLOC(sizeof(int) * dev->checkpt_max_blocks); - if(!dev->checkpt_block_list) + dev->checkpt_max_blocks = + (dev->internal_end_block - dev->internal_start_block) / 16 + + 2; + dev->checkpt_block_list = + YMALLOC(sizeof(int) * dev->checkpt_max_blocks); + if (!dev->checkpt_block_list) return 0; for (i = 0; i < dev->checkpt_max_blocks; i++) @@ -177,10 +193,10 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing) return 1; } -int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 *sum) +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum) { u32 composite_sum; - composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); + composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); *sum = composite_sum; return 1; } @@ -201,30 +217,35 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev) return 0; tags.is_deleted = 0; - tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ + tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ tags.chunk_id = dev->checkpt_page_seq + 1; - tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; + tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; tags.n_bytes = dev->data_bytes_per_chunk; if (dev->checkpt_cur_chunk == 0) { /* First chunk we write for the block? Set block state to checkpoint */ - struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block); + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->checkpt_cur_block); bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; dev->blocks_in_checkpt++; } - chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk; - + chunk = + dev->checkpt_cur_block * dev->param.chunks_per_block + + dev->checkpt_cur_chunk; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), - chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), + chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, + tags.chunk_id)); realigned_chunk = chunk - dev->chunk_offset; dev->n_page_writes++; dev->param.write_chunk_tags_fn(dev, realigned_chunk, - dev->checkpt_buffer, &tags); + dev->checkpt_buffer, &tags); dev->checkpt_byte_offs = 0; dev->checkpt_page_seq++; dev->checkpt_cur_chunk++; @@ -237,16 +258,12 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev) return 1; } - int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes) { int i = 0; int ok = 1; - - u8 * data_bytes = (u8 *)data; - - + u8 *data_bytes = (u8 *) data; if (!dev->checkpt_buffer) return 0; @@ -264,9 +281,8 @@ int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes) data_bytes++; dev->checkpt_byte_count++; - if (dev->checkpt_byte_offs < 0 || - dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) ok = yaffs2_checkpt_flush_buffer(dev); } @@ -279,11 +295,10 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) int ok = 1; struct yaffs_ext_tags tags; - int chunk; int realigned_chunk; - u8 *data_bytes = (u8 *)data; + u8 *data_bytes = (u8 *) data; if (!dev->checkpt_buffer) return 0; @@ -293,9 +308,8 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) while (i < n_bytes && ok) { - if (dev->checkpt_byte_offs < 0 || - dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { if (dev->checkpt_cur_block < 0) { yaffs2_checkpt_find_block(dev); @@ -306,35 +320,39 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) ok = 0; else { chunk = dev->checkpt_cur_block * - dev->param.chunks_per_block + - dev->checkpt_cur_chunk; + dev->param.chunks_per_block + + dev->checkpt_cur_chunk; realigned_chunk = chunk - dev->chunk_offset; - + dev->n_page_reads++; /* read in the next chunk */ dev->param.read_chunk_tags_fn(dev, - realigned_chunk, - dev->checkpt_buffer, - &tags); - - if (tags.chunk_id != (dev->checkpt_page_seq + 1) || - tags.ecc_result > YAFFS_ECC_RESULT_FIXED || - tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA) + realigned_chunk, + dev-> + checkpt_buffer, + &tags); + + if (tags.chunk_id != (dev->checkpt_page_seq + 1) + || tags.ecc_result > YAFFS_ECC_RESULT_FIXED + || tags.seq_number != + YAFFS_SEQUENCE_CHECKPOINT_DATA) ok = 0; dev->checkpt_byte_offs = 0; dev->checkpt_page_seq++; dev->checkpt_cur_chunk++; - if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) + if (dev->checkpt_cur_chunk >= + dev->param.chunks_per_block) dev->checkpt_cur_block = -1; } } if (ok) { - *data_bytes = dev->checkpt_buffer[dev->checkpt_byte_offs]; + *data_bytes = + dev->checkpt_buffer[dev->checkpt_byte_offs]; dev->checkpt_sum += *data_bytes; dev->checkpt_xor ^= *data_bytes; dev->checkpt_byte_offs++; @@ -344,7 +362,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) } } - return i; + return i; } int yaffs_checkpt_close(struct yaffs_dev *dev) @@ -353,12 +371,15 @@ int yaffs_checkpt_close(struct yaffs_dev *dev) if (dev->checkpt_open_write) { if (dev->checkpt_byte_offs != 0) yaffs2_checkpt_flush_buffer(dev); - } else if(dev->checkpt_block_list){ + } else if (dev->checkpt_block_list) { int i; - for (i = 0; i < dev->blocks_in_checkpt && dev->checkpt_block_list[i] >= 0; i++) { + for (i = 0; + i < dev->blocks_in_checkpt + && dev->checkpt_block_list[i] >= 0; i++) { int blk = dev->checkpt_block_list[i]; struct yaffs_block_info *bi = NULL; - if( dev->internal_start_block <= blk && blk <= dev->internal_end_block) + if (dev->internal_start_block <= blk + && blk <= dev->internal_end_block) bi = yaffs_get_block_info(dev, blk); if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY) bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; @@ -370,12 +391,12 @@ int yaffs_checkpt_close(struct yaffs_dev *dev) dev->checkpt_block_list = NULL; } - dev->n_free_chunks -= dev->blocks_in_checkpt * dev->param.chunks_per_block; + dev->n_free_chunks -= + dev->blocks_in_checkpt * dev->param.chunks_per_block; dev->n_erased_blocks -= dev->blocks_in_checkpt; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR), - dev->checkpt_byte_count)); + dev->checkpt_byte_count)); if (dev->checkpt_buffer) { /* free the buffer */ @@ -390,11 +411,9 @@ int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev) { /* Erase the checkpoint data */ - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR), - dev->blocks_in_checkpt)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("checkpoint invalidate of %d blocks" TENDSTR), + dev->blocks_in_checkpt)); return yaffs_checkpt_erase(dev); } - - - diff --git a/yaffs_checkptrw.h b/yaffs_checkptrw.h index 07ceb36..361c606 100644 --- a/yaffs_checkptrw.h +++ b/yaffs_checkptrw.h @@ -24,11 +24,10 @@ int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes); int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes); -int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 *sum); +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum); int yaffs_checkpt_close(struct yaffs_dev *dev); int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev); - #endif diff --git a/yaffs_ecc.c b/yaffs_ecc.c index 290f8d3..0ea0305 100644 --- a/yaffs_ecc.c +++ b/yaffs_ecc.c @@ -106,7 +106,7 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { /* odd number of bits in the byte */ + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; } @@ -160,11 +160,10 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) #endif } - /* Correct the ECC on a 256 byte block of data */ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc) + const unsigned char *test_ecc) { unsigned char d0, d1, d2; /* deltas */ @@ -173,7 +172,7 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, d2 = read_ecc[2] ^ test_ecc[2]; if ((d0 | d1 | d2) == 0) - return 0; /* no error */ + return 0; /* no error */ if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 && ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 && @@ -220,19 +219,18 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, data[byte] ^= (1 << bit); - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } if ((yaffs_count_bits(d0) + - yaffs_count_bits(d1) + - yaffs_count_bits(d2)) == 1) { + yaffs_count_bits(d1) + yaffs_count_bits(d2)) == 1) { /* Reccoverable error in ecc */ read_ecc[0] = test_ecc[0]; read_ecc[1] = test_ecc[1]; read_ecc[2] = test_ecc[2]; - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } /* Unrecoverable error */ @@ -241,12 +239,11 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, } - /* * ECCxxxOther does ECC calcs on arbitrary n bytes of data */ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, - struct yaffs_ecc_other *ecc_other) + struct yaffs_ecc_other *ecc_other) { unsigned int i; @@ -259,7 +256,7 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; @@ -273,8 +270,8 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, } int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, - struct yaffs_ecc_other *read_ecc, - const struct yaffs_ecc_other *test_ecc) + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc) { unsigned char delta_col; /* column parity delta */ unsigned delta_line; /* line parity delta */ @@ -283,10 +280,11 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, delta_col = read_ecc->col_parity ^ test_ecc->col_parity; delta_line = read_ecc->line_parity ^ test_ecc->line_parity; - delta_line_prime = read_ecc->line_parity_prime ^ test_ecc->line_parity_prime; + delta_line_prime = + read_ecc->line_parity_prime ^ test_ecc->line_parity_prime; if ((delta_col | delta_line | delta_line_prime) == 0) - return 0; /* no error */ + return 0; /* no error */ if (delta_line == ~delta_line_prime && (((delta_col ^ (delta_col >> 1)) & 0x15) == 0x15)) { @@ -306,15 +304,16 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, data[delta_line] ^= (1 << bit); - return 1; /* corrected */ + return 1; /* corrected */ } - if ((yaffs_count_bits32(delta_line) + yaffs_count_bits32(delta_line_prime) + - yaffs_count_bits(delta_col)) == 1) { + if ((yaffs_count_bits32(delta_line) + + yaffs_count_bits32(delta_line_prime) + + yaffs_count_bits(delta_col)) == 1) { /* Reccoverable error in ecc */ *read_ecc = *test_ecc; - return 1; /* corrected */ + return 1; /* corrected */ } /* Unrecoverable error */ diff --git a/yaffs_ecc.h b/yaffs_ecc.h index c2d0013..b0c461d 100644 --- a/yaffs_ecc.h +++ b/yaffs_ecc.h @@ -30,15 +30,15 @@ struct yaffs_ecc_other { unsigned char col_parity; unsigned line_parity; unsigned line_parity_prime; -} ; +}; void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc); int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc); + const unsigned char *test_ecc); void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, - struct yaffs_ecc_other *ecc); + struct yaffs_ecc_other *ecc); int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, - struct yaffs_ecc_other *read_ecc, - const struct yaffs_ecc_other *test_ecc); + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc); #endif diff --git a/yaffs_getblockinfo.h b/yaffs_getblockinfo.h index 28bcd54..108c361 100644 --- a/yaffs_getblockinfo.h +++ b/yaffs_getblockinfo.h @@ -20,7 +20,8 @@ #include "yaffs_trace.h" /* Function to manipulate block info */ -static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev * dev, int blk) +static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev + *dev, int blk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, diff --git a/yaffs_guts.c b/yaffs_guts.c index ce7ed7e..a9fc46c 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -41,17 +41,15 @@ #include "yaffs_ecc.h" - - /* Robustification (if it ever comes about...) */ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block); static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, - int erased_ok); + int erased_ok); static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *tags); + const u8 * data, + const struct yaffs_ext_tags *tags); static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, - const struct yaffs_ext_tags *tags); + const struct yaffs_ext_tags *tags); /* Other local prototypes */ static void yaffs_update_parent(struct yaffs_obj *obj); @@ -59,62 +57,60 @@ static int yaffs_unlink_obj(struct yaffs_obj *obj); static int yaffs_obj_cache_dirty(struct yaffs_obj *obj); static int yaffs_write_new_chunk(struct yaffs_dev *dev, - const u8 *buffer, - struct yaffs_ext_tags *tags, - int use_reserver); - + const u8 * buffer, + struct yaffs_ext_tags *tags, int use_reserver); static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, - enum yaffs_obj_type type); + enum yaffs_obj_type type); - -static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod); +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod); static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj); static int yaffs_generic_obj_del(struct yaffs_obj *in); -static int yaffs_check_chunk_erased(struct yaffs_dev *dev, - int nand_chunk); +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk); static int yaffs_unlink_worker(struct yaffs_obj *obj); static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, - int chunk_obj); + int chunk_obj); static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, - struct yaffs_block_info **block_ptr); + struct yaffs_block_info **block_ptr); static void yaffs_check_obj_details_loaded(struct yaffs_obj *in); static void yaffs_invalidate_whole_cache(struct yaffs_obj *in); -static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id); +static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, + int chunk_id); static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, - struct yaffs_ext_tags *tags); + struct yaffs_ext_tags *tags); static int yaffs_verify_chunk_written(struct yaffs_dev *dev, - int nand_chunk, - const u8 *data, - struct yaffs_ext_tags *tags); - - -static void yaffs_load_name_from_oh(struct yaffs_dev *dev,YCHAR *name, const YCHAR *oh_name, int buff_size); -static void yaffs_load_oh_from_name(struct yaffs_dev *dev,YCHAR *oh_name, const YCHAR *name); + int nand_chunk, + const u8 * data, + struct yaffs_ext_tags *tags); +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, + const YCHAR * oh_name, int buff_size); +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, + const YCHAR * name); /* Function to calculate chunk and offset */ -static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, int *chunk_out, - u32 *offset_out) +static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, + int *chunk_out, u32 * offset_out) { int chunk; u32 offset; - chunk = (u32)(addr >> dev->chunk_shift); + chunk = (u32) (addr >> dev->chunk_shift); if (dev->chunk_div == 1) { /* easy power of 2 case */ - offset = (u32)(addr & dev->chunk_mask); + offset = (u32) (addr & dev->chunk_mask); } else { /* Non power-of-2 case */ @@ -122,8 +118,8 @@ static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, int *chunk_o chunk /= dev->chunk_div; - chunk_base = ((loff_t)chunk) * dev->data_bytes_per_chunk; - offset = (u32)(addr - chunk_base); + chunk_base = ((loff_t) chunk) * dev->data_bytes_per_chunk; + offset = (u32) (addr - chunk_base); } *chunk_out = chunk; @@ -163,12 +159,12 @@ static u32 calc_shifts(u32 x) { u32 shifts; - shifts = 0; + shifts = 0; if (!x) return 0; - while (!(x&1)) { + while (!(x & 1)) { x >>= 1; shifts++; } @@ -176,8 +172,6 @@ static u32 calc_shifts(u32 x) return shifts; } - - /* * Temporary buffer manipulations. */ @@ -185,7 +179,7 @@ static u32 calc_shifts(u32 x) static int yaffs_init_tmp_buffers(struct yaffs_dev *dev) { int i; - u8 *buf = (u8 *)1; + u8 *buf = (u8 *) 1; memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer)); @@ -198,7 +192,7 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev) return buf ? YAFFS_OK : YAFFS_FAIL; } -u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no) +u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no) { int i, j; @@ -224,7 +218,8 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no) (TSTR("Out of temp buffers at line %d, other held by lines:"), line_no)); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->temp_buffer[i].line)); + T(YAFFS_TRACE_BUFFERS, + (TSTR(" %d "), dev->temp_buffer[i].line)); T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR))); @@ -238,8 +233,7 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no) } -void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, - int line_no) +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no) { int i; @@ -266,7 +260,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, /* * Determine if we have a managed buffer. */ -int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer) +int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer) { int i; @@ -284,7 +278,7 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer) return 1; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); + (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); return 0; } @@ -292,9 +286,6 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer) * Verification code */ - - - /* * Simple hash function. Needs to have a reasonable spread */ @@ -320,12 +311,11 @@ struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev) return dev->lost_n_found; } - /* * Erased NAND checking functions */ -int yaffs_check_ff(u8 *buffer, int n_bytes) +int yaffs_check_ff(u8 * buffer, int n_bytes) { /* Horrible, slow implementation */ while (n_bytes--) { @@ -336,8 +326,7 @@ int yaffs_check_ff(u8 *buffer, int n_bytes) return 1; } -static int yaffs_check_chunk_erased(struct yaffs_dev *dev, - int nand_chunk) +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) { int retval = YAFFS_OK; u8 *data = yaffs_get_temp_buffer(dev, __LINE__); @@ -361,22 +350,21 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, } - static int yaffs_verify_chunk_written(struct yaffs_dev *dev, - int nand_chunk, - const u8 *data, - struct yaffs_ext_tags *tags) + int nand_chunk, + const u8 * data, + struct yaffs_ext_tags *tags) { int retval = YAFFS_OK; struct yaffs_ext_tags temp_tags; - u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__); + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); int result; - - result = yaffs_rd_chunk_tags_nand(dev,nand_chunk,buffer,&temp_tags); - if(memcmp(buffer,data,dev->data_bytes_per_chunk) || - temp_tags.obj_id != tags->obj_id || - temp_tags.chunk_id != tags->chunk_id || - temp_tags.n_bytes != tags->n_bytes) + + result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags); + if (memcmp(buffer, data, dev->data_bytes_per_chunk) || + temp_tags.obj_id != tags->obj_id || + temp_tags.chunk_id != tags->chunk_id || + temp_tags.n_bytes != tags->n_bytes) retval = YAFFS_FAIL; yaffs_release_temp_buffer(dev, buffer, __LINE__); @@ -385,9 +373,8 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev, } static int yaffs_write_new_chunk(struct yaffs_dev *dev, - const u8 *data, - struct yaffs_ext_tags *tags, - int use_reserver) + const u8 * data, + struct yaffs_ext_tags *tags, int use_reserver) { int attempts = 0; int write_ok = 0; @@ -411,7 +398,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev, * * Check the first page we try to write in a block. * If the check passes then we don't need to check any - * more. If the check fails, we check again... + * more. If the check fails, we check again... * If the block has been erased, we don't need to check. * * However, if the block has been prioritised for gc, @@ -432,30 +419,30 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev, /* let's give it a try */ attempts++; - if(dev->param.always_check_erased) + if (dev->param.always_check_erased) bi->skip_erased_check = 0; if (!bi->skip_erased_check) { erased_ok = yaffs_check_chunk_erased(dev, chunk); if (erased_ok != YAFFS_OK) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs chunk %d was not erased" - TENDSTR), chunk)); + (TSTR("**>> yaffs chunk %d was not erased" + TENDSTR), chunk)); /* If not erased, delete this one, * skip rest of block and * try another chunk */ - yaffs_chunk_del(dev,chunk,1,__LINE__); - yaffs_skip_rest_of_block(dev); + yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_skip_rest_of_block(dev); continue; } } - write_ok = yaffs_wr_chunk_tags_nand(dev, chunk, - data, tags); + write_ok = yaffs_wr_chunk_tags_nand(dev, chunk, data, tags); - if(!bi->skip_erased_check) - write_ok = yaffs_verify_chunk_written(dev, chunk, data, tags); + if (!bi->skip_erased_check) + write_ok = + yaffs_verify_chunk_written(dev, chunk, data, tags); if (write_ok != YAFFS_OK) { /* Clean up aborted write, skip to next block and @@ -470,15 +457,15 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev, yaffs_handle_chunk_wr_ok(dev, chunk, data, tags); } while (write_ok != YAFFS_OK && - (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); + (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); if (!write_ok) chunk = -1; if (attempts > 1) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs write required %d attempts" TENDSTR), - attempts)); + (TSTR("**>> yaffs write required %d attempts" TENDSTR), + attempts)); dev->n_retired_writes += (attempts - 1); } @@ -486,8 +473,6 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev, return chunk; } - - /* * Block retiring for handling a broken block. */ @@ -497,17 +482,19 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); yaffs2_checkpt_invalidate(dev); - - yaffs2_clear_oldest_dirty_seq(dev,bi); + + yaffs2_clear_oldest_dirty_seq(dev, bi); if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) { if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) { - T(YAFFS_TRACE_ALWAYS, (TSTR( - "yaffs: Failed to mark bad and erase block %d" - TENDSTR), flash_block)); + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("yaffs: Failed to mark bad and erase block %d" + TENDSTR), flash_block)); } else { struct yaffs_ext_tags tags; - int chunk_id = flash_block * dev->param.chunks_per_block; + int chunk_id = + flash_block * dev->param.chunks_per_block; u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); @@ -515,10 +502,14 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) yaffs_init_tags(&tags); tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK; if (dev->param.write_chunk_tags_fn(dev, chunk_id - - dev->chunk_offset, buffer, &tags) != YAFFS_OK) - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " - TCONT("write bad block marker to block %d") - TENDSTR), flash_block)); + dev->chunk_offset, + buffer, + &tags) != YAFFS_OK) + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("yaffs: Failed to " + TCONT("write bad block marker to block %d") + TENDSTR), flash_block)); yaffs_release_temp_buffer(dev, buffer, __LINE__); } @@ -537,24 +528,25 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) */ static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *tags) + const u8 * data, + const struct yaffs_ext_tags *tags) { - dev=dev; - nand_chunk=nand_chunk; - data=data; - tags=tags; + dev = dev; + nand_chunk = nand_chunk; + data = data; + tags = tags; } static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, - const struct yaffs_ext_tags *tags) + const struct yaffs_ext_tags *tags) { - dev=dev; - nand_chunk=nand_chunk; - tags=tags; + dev = dev; + nand_chunk = nand_chunk; + tags = tags; } -void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi) +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { if (!bi->gc_prioritise) { bi->gc_prioritise = 1; @@ -562,15 +554,16 @@ void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi bi->chunk_error_strikes++; if (bi->chunk_error_strikes > 3) { - bi->needs_retiring = 1; /* Too many stikes, so retire this */ - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); + bi->needs_retiring = 1; /* Too many stikes, so retire this */ + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: Block struck out" TENDSTR))); } } } static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, - int erased_ok) + int erased_ok) { int flash_block = nand_chunk / dev->param.chunks_per_block; struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); @@ -589,17 +582,16 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, yaffs_skip_rest_of_block(dev); } - /*---------------- Name handling functions ------------*/ -static u16 yaffs_calc_name_sum(const YCHAR *name) +static u16 yaffs_calc_name_sum(const YCHAR * name) { u16 sum = 0; u16 i = 1; - const YUCHAR *bname = (const YUCHAR *) name; + const YUCHAR *bname = (const YUCHAR *)name; if (bname) { - while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { + while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH / 2))) { /* 0x1f mask is case insensitive */ sum += ((*bname) & 0x1f) * i; @@ -610,11 +602,15 @@ static u16 yaffs_calc_name_sum(const YCHAR *name) return sum; } -void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name) +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name) { #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - memset(obj->short_name, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); - if (name && yaffs_strnlen(name,YAFFS_SHORT_NAME_LENGTH+1) <= YAFFS_SHORT_NAME_LENGTH) + memset(obj->short_name, 0, + sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH + 1)); + if (name + && yaffs_strnlen(name, + YAFFS_SHORT_NAME_LENGTH + 1) <= + YAFFS_SHORT_NAME_LENGTH) yaffs_strcpy(obj->short_name, name); else obj->short_name[0] = _Y('\0'); @@ -622,15 +618,17 @@ void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name) obj->sum = yaffs_calc_name_sum(name); } -void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hdr *oh) +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH+1]; - memset(tmp_name,0,sizeof(tmp_name)); - yaffs_load_name_from_oh(obj->my_dev,tmp_name,oh->name,YAFFS_MAX_NAME_LENGTH+1); - yaffs_set_obj_name(obj,tmp_name); + YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH + 1]; + memset(tmp_name, 0, sizeof(tmp_name)); + yaffs_load_name_from_oh(obj->my_dev, tmp_name, oh->name, + YAFFS_MAX_NAME_LENGTH + 1); + yaffs_set_obj_name(obj, tmp_name); #else - yaffs_set_obj_name(obj,oh->name); + yaffs_set_obj_name(obj, oh->name); #endif } @@ -641,16 +639,15 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hd * in the tnode. */ - struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev) { struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev); - if (tn){ + if (tn) { memset(tn, 0, dev->tnode_size); dev->n_tnodes++; } - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ return tn; } @@ -658,9 +655,9 @@ struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev) /* FreeTnode frees up a tnode and puts it back on the free list */ static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { - yaffs_free_raw_tnode(dev,tn); + yaffs_free_raw_tnode(dev, tn); dev->n_tnodes--; - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev) @@ -670,11 +667,10 @@ static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev) dev->n_tnodes = 0; } - -void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos, - unsigned val) +void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos, unsigned val) { - u32 *map = (u32 *)tn; + u32 *map = (u32 *) tn; u32 bit_in_map; u32 bit_in_word; u32 word_in_map; @@ -695,16 +691,17 @@ void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned if (dev->tnode_width > (32 - bit_in_word)) { bit_in_word = (32 - bit_in_word); word_in_map++;; - mask = dev->tnode_mask >> (/*dev->tnode_width -*/ bit_in_word); + mask = + dev->tnode_mask >> ( /*dev->tnode_width - */ bit_in_word); map[word_in_map] &= ~mask; map[word_in_map] |= (mask & (val >> bit_in_word)); } } u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, - unsigned pos) + unsigned pos) { - u32 *map = (u32 *)tn; + u32 *map = (u32 *) tn; u32 bit_in_map; u32 bit_in_word; u32 word_in_map; @@ -718,7 +715,7 @@ u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, val = map[word_in_map] >> bit_in_word; - if (dev->tnode_width > (32 - bit_in_word)) { + if (dev->tnode_width > (32 - bit_in_word)) { bit_in_word = (32 - bit_in_word); word_in_map++;; val |= (map[word_in_map] << bit_in_word); @@ -739,15 +736,15 @@ u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, /* FindLevel0Tnode finds the level 0 tnode, if one exists. */ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, - struct yaffs_file_var *file_struct, - u32 chunk_id) + struct yaffs_file_var *file_struct, + u32 chunk_id) { struct yaffs_tnode *tn = file_struct->top; u32 i; int required_depth; int level = file_struct->top_level; - dev=dev; + dev = dev; /* Check sane level and chunk Id */ if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) @@ -766,15 +763,15 @@ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, } if (required_depth > file_struct->top_level) - return NULL; /* Not tall enough, so we can't find it */ + return NULL; /* Not tall enough, so we can't find it */ /* Traverse down to level 0 */ while (level > 0 && tn) { tn = tn->internal[(chunk_id >> - (YAFFS_TNODES_LEVEL0_BITS + - (level - 1) * - YAFFS_TNODES_INTERNAL_BITS)) & - YAFFS_TNODES_INTERNAL_MASK]; + (YAFFS_TNODES_LEVEL0_BITS + + (level - 1) * + YAFFS_TNODES_INTERNAL_BITS)) & + YAFFS_TNODES_INTERNAL_MASK]; level--; } @@ -793,9 +790,9 @@ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, */ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, - struct yaffs_file_var *file_struct, - u32 chunk_id, - struct yaffs_tnode *passed_tn) + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn) { int required_depth; int i; @@ -804,9 +801,9 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, u32 x; - /* Check sane level and page Id */ - if (file_struct->top_level < 0 || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) + if (file_struct->top_level < 0 + || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) return NULL; if (chunk_id > YAFFS_MAX_CHUNK_ID) @@ -821,7 +818,6 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, required_depth++; } - if (required_depth > file_struct->top_level) { /* Not tall enough, gotta make the tree taller */ for (i = file_struct->top_level; i < required_depth; i++) { @@ -834,7 +830,7 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, file_struct->top_level++; } else { T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: no more tnodes" TENDSTR))); + (TSTR("yaffs: no more tnodes" TENDSTR))); return NULL; } } @@ -852,24 +848,25 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & YAFFS_TNODES_INTERNAL_MASK; - if ((l > 1) && !tn->internal[x]) { /* Add missing non-level-zero tnode */ tn->internal[x] = yaffs_get_tnode(dev); - if(!tn->internal[x]) + if (!tn->internal[x]) return NULL; } else if (l == 1) { /* Looking from level 1 at level 0 */ if (passed_tn) { - /* If we already have one, then release it.*/ + /* If we already have one, then release it. */ if (tn->internal[x]) - yaffs_free_tnode(dev, tn->internal[x]); + yaffs_free_tnode(dev, + tn-> + internal[x]); tn->internal[x] = passed_tn; } else if (!tn->internal[x]) { /* Don't have one, none passed in */ tn->internal[x] = yaffs_get_tnode(dev); - if(!tn->internal[x]) + if (!tn->internal[x]) return NULL; } } @@ -880,7 +877,8 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, } else { /* top is level 0 */ if (passed_tn) { - memcpy(tn, passed_tn, (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8); + memcpy(tn, passed_tn, + (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8); yaffs_free_tnode(dev, passed_tn); } } @@ -889,20 +887,21 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, } static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk, - struct yaffs_ext_tags *tags, int obj_id, - int inode_chunk) + struct yaffs_ext_tags *tags, int obj_id, + int inode_chunk) { int j; for (j = 0; the_chunk && j < dev->chunk_grp_size; j++) { - if (yaffs_check_chunk_bit(dev, the_chunk / dev->param.chunks_per_block, - the_chunk % dev->param.chunks_per_block)) { - - if(dev->chunk_grp_size == 1) + if (yaffs_check_chunk_bit + (dev, the_chunk / dev->param.chunks_per_block, + the_chunk % dev->param.chunks_per_block)) { + + if (dev->chunk_grp_size == 1) return the_chunk; else { yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, - tags); + tags); if (yaffs_tags_match(tags, obj_id, inode_chunk)) { /* found it; */ return the_chunk; @@ -914,7 +913,6 @@ static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk, return -1; } - static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) { struct yaffs_block_info *the_block; @@ -922,7 +920,7 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - block_no = chunk / dev->param.chunks_per_block; + block_no = chunk / dev->param.chunks_per_block; the_block = yaffs_get_block_info(dev, block_no); if (the_block) { the_block->soft_del_pages++; @@ -938,7 +936,7 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) */ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, - u32 level, int chunk_offset) + u32 level, int chunk_offset) { int i; int the_chunk; @@ -953,17 +951,17 @@ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, if (tn->internal[i]) { all_done = yaffs_soft_del_worker(in, - tn-> - internal[i], - level - 1, - (chunk_offset - << - YAFFS_TNODES_INTERNAL_BITS) - + i); + tn->internal + [i], + level - 1, + (chunk_offset + << + YAFFS_TNODES_INTERNAL_BITS) + + i); if (all_done) { yaffs_free_tnode(dev, - tn-> - internal[i]); + tn->internal + [i]); tn->internal[i] = NULL; } else { /* Hoosterman... how could this happen? */ @@ -1002,7 +1000,7 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj) if (obj->n_data_chunks <= 0) { /* Empty file with no duplicate object headers, just delete it immediately */ yaffs_free_tnode(obj->my_dev, - obj->variant.file_variant.top); + obj->variant.file_variant.top); obj->variant.file_variant.top = NULL; T(YAFFS_TRACE_TRACING, (TSTR("yaffs: Deleting empty file %d" TENDSTR), @@ -1010,9 +1008,9 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj) yaffs_generic_obj_del(obj); } else { yaffs_soft_del_worker(obj, - obj->variant.file_variant.top, - obj->variant.file_variant. - top_level, 0); + obj->variant.file_variant.top, + obj->variant. + file_variant.top_level, 0); obj->soft_del = 1; } } @@ -1033,8 +1031,9 @@ static void yaffs_soft_del_file(struct yaffs_obj *obj) * If there is no data in a subtree then it is pruned. */ -static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaffs_tnode *tn, - u32 level, int del0) +static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, + struct yaffs_tnode *tn, u32 level, + int del0) { int i; int has_data; @@ -1042,27 +1041,29 @@ static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaff if (tn) { has_data = 0; - if(level > 0){ + if (level > 0) { for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) { if (tn->internal[i]) { tn->internal[i] = - yaffs_prune_worker(dev, tn->internal[i], - level - 1, - (i == 0) ? del0 : 1); + yaffs_prune_worker(dev, + tn->internal[i], + level - 1, + (i == + 0) ? del0 : 1); } if (tn->internal[i]) has_data++; } } else { - int tnode_size_u32 = dev->tnode_size/sizeof(u32); - u32 *map = (u32 *)tn; + int tnode_size_u32 = dev->tnode_size / sizeof(u32); + u32 *map = (u32 *) tn; - for(i = 0; !has_data && i < tnode_size_u32; i++){ - if(map[i]) - has_data++; - } - } + for (i = 0; !has_data && i < tnode_size_u32; i++) { + if (map[i]) + has_data++; + } + } if (has_data == 0 && del0) { /* Free and return NULL */ @@ -1078,7 +1079,7 @@ static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaff } static int yaffs_prune_tree(struct yaffs_dev *dev, - struct yaffs_file_var *file_struct) + struct yaffs_file_var *file_struct) { int i; int has_data; @@ -1087,7 +1088,8 @@ static int yaffs_prune_tree(struct yaffs_dev *dev, if (file_struct->top_level > 0) { file_struct->top = - yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0); + yaffs_prune_worker(dev, file_struct->top, + file_struct->top_level, 0); /* Now we have a tree with all the non-zero branches NULL but the height * is the same as it was. @@ -1120,7 +1122,6 @@ static int yaffs_prune_tree(struct yaffs_dev *dev, /*-------------------- End of File Structure functions.-------------------*/ - /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) { @@ -1141,11 +1142,11 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) INIT_LIST_HEAD(&(obj->hash_link)); INIT_LIST_HEAD(&obj->siblings); - /* Now make the directory sane */ if (dev->root_dir) { obj->parent = dev->root_dir; - list_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children); + list_add(&(obj->siblings), + &dev->root_dir->variant.dir_variant.children); } /* Add it to the lost and found directory. @@ -1158,19 +1159,19 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) obj->being_created = 0; } - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ return obj; } -static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, int number, - u32 mode) +static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, + int number, u32 mode) { struct yaffs_obj *obj = yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); if (obj) { - obj->fake = 1; /* it is fake so it might have no NAND presence... */ + obj->fake = 1; /* it is fake so it might have no NAND presence... */ obj->rename_allowed = 0; /* ... and we're not allowed to rename it... */ obj->unlink_allowed = 0; /* ... or unlink it */ obj->deleted = 0; @@ -1202,7 +1203,8 @@ static void yaffs_free_obj(struct yaffs_obj *obj) { struct yaffs_dev *dev = obj->my_dev; - T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->my_inode)); + T(YAFFS_TRACE_OS, + (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode)); if (!obj) YBUG(); @@ -1211,7 +1213,6 @@ static void yaffs_free_obj(struct yaffs_obj *obj) if (!list_empty(&obj->siblings)) YBUG(); - if (obj->my_inode) { /* We're still hooked up to a cached inode. * Don't delete now, but mark for later deletion @@ -1222,12 +1223,11 @@ static void yaffs_free_obj(struct yaffs_obj *obj) yaffs_unhash_obj(obj); - yaffs_free_raw_obj(dev,obj); + yaffs_free_raw_obj(dev, obj); dev->n_obj--; - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } - void yaffs_handle_defered_free(struct yaffs_obj *obj) { if (obj->defered_free) @@ -1255,7 +1255,6 @@ static int yaffs_find_nice_bucket(struct yaffs_dev *dev) int l = 999; int lowest = 999999; - /* Search for the shortest list or one that * isn't too long. */ @@ -1295,7 +1294,7 @@ static int yaffs_new_obj_id(struct yaffs_dev *dev) list_for_each(i, &dev->obj_bucket[bucket].list) { /* If there is already one in the list */ if (i && list_entry(i, struct yaffs_obj, - hash_link)->obj_id == n) { + hash_link)->obj_id == n) { found = 0; } } @@ -1339,9 +1338,9 @@ struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number) } struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, - enum yaffs_obj_type type) + enum yaffs_obj_type type) { - struct yaffs_obj *the_obj=NULL; + struct yaffs_obj *the_obj = NULL; struct yaffs_tnode *tn = NULL; if (number < 0) @@ -1354,13 +1353,12 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, } the_obj = yaffs_alloc_empty_obj(dev); - if (!the_obj){ - if(tn) - yaffs_free_tnode(dev,tn); + if (!the_obj) { + if (tn) + yaffs_free_tnode(dev, tn); return NULL; } - if (the_obj) { the_obj->fake = 0; the_obj->rename_allowed = 1; @@ -1368,21 +1366,19 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, the_obj->obj_id = number; yaffs_hash_obj(the_obj); the_obj->variant_type = type; - yaffs_load_current_time(the_obj,1,1); + yaffs_load_current_time(the_obj, 1, 1); switch (type) { case YAFFS_OBJECT_TYPE_FILE: the_obj->variant.file_variant.file_size = 0; the_obj->variant.file_variant.scanned_size = 0; - the_obj->variant.file_variant.shrink_size = ~0;/* max */ + the_obj->variant.file_variant.shrink_size = ~0; /* max */ the_obj->variant.file_variant.top_level = 0; the_obj->variant.file_variant.top = tn; break; case YAFFS_OBJECT_TYPE_DIRECTORY: - INIT_LIST_HEAD(&the_obj->variant.dir_variant. - children); - INIT_LIST_HEAD(&the_obj->variant.dir_variant. - dirty); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.children); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.dirty); break; case YAFFS_OBJECT_TYPE_SYMLINK: case YAFFS_OBJECT_TYPE_HARDLINK: @@ -1399,8 +1395,8 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, } struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, - int number, - enum yaffs_obj_type type) + int number, + enum yaffs_obj_type type) { struct yaffs_obj *the_obj = NULL; @@ -1414,8 +1410,7 @@ struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, } - -YCHAR *yaffs_clone_str(const YCHAR *str) +YCHAR *yaffs_clone_str(const YCHAR * str) { YCHAR *new_str = NULL; int len; @@ -1423,10 +1418,10 @@ YCHAR *yaffs_clone_str(const YCHAR *str) if (!str) str = _Y(""); - len = yaffs_strnlen(str,YAFFS_MAX_ALIAS_LENGTH); + len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH); new_str = YMALLOC((len + 1) * sizeof(YCHAR)); - if (new_str){ - yaffs_strncpy(new_str, str,len); + if (new_str) { + yaffs_strncpy(new_str, str, len); new_str[len] = 0; } return new_str; @@ -1441,20 +1436,20 @@ YCHAR *yaffs_clone_str(const YCHAR *str) */ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, - struct yaffs_obj *parent, - const YCHAR *name, - u32 mode, - u32 uid, - u32 gid, - struct yaffs_obj *equiv_obj, - const YCHAR *alias_str, u32 rdev) + struct yaffs_obj *parent, + const YCHAR * name, + u32 mode, + u32 uid, + u32 gid, + struct yaffs_obj *equiv_obj, + const YCHAR * alias_str, u32 rdev) { struct yaffs_obj *in; YCHAR *str = NULL; struct yaffs_dev *dev = parent->my_dev; - /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/ + /* Check if the entry exists. If it does then fail the call since we don't want a dup. */ if (yaffs_find_by_name(parent, name)) return NULL; @@ -1466,16 +1461,12 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, in = yaffs_new_obj(dev, -1, type); - if (!in){ - if(str) + if (!in) { + if (str) YFREE(str); return NULL; } - - - - if (in) { in->hdr_chunk = 0; in->valid = 1; @@ -1499,10 +1490,9 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, in->variant.symlink_variant.alias = str; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardlink_variant.equiv_obj = - equiv_obj; + in->variant.hardlink_variant.equiv_obj = equiv_obj; in->variant.hardlink_variant.equiv_id = - equiv_obj->obj_id; + equiv_obj->obj_id; list_add(&in->hard_links, &equiv_obj->hard_links); break; case YAFFS_OBJECT_TYPE_FILE: @@ -1525,38 +1515,40 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, return in; } -struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid) +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, uid, gid, NULL, NULL, 0); } -struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid) +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, + u32 mode, u32 uid, u32 gid) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, - mode, uid, gid, NULL, NULL, 0); + mode, uid, gid, NULL, NULL, 0); } -struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid, u32 rdev) +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, u32 rdev) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, - uid, gid, NULL, NULL, rdev); + uid, gid, NULL, NULL, rdev); } -struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid, - const YCHAR *alias) +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, const YCHAR * alias) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, uid, gid, NULL, alias, 0); } /* yaffs_link_obj returns the object id of the equivalent object.*/ -struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, - struct yaffs_obj *equiv_obj) +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj) { /* Get the real object in case we were fed a hard link as an equivalent object */ equiv_obj = yaffs_get_equivalent_obj(equiv_obj); @@ -1571,8 +1563,9 @@ struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, } -static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_dir, - const YCHAR *new_name, int force, int shadows) +static int yaffs_change_obj_name(struct yaffs_obj *obj, + struct yaffs_obj *new_dir, + const YCHAR * new_name, int force, int shadows) { int unlink_op; int del_op; @@ -1595,7 +1588,7 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_di unlink_op = (new_dir == obj->my_dev->unlinked_dir); else unlink_op = (new_dir == obj->my_dev->unlinked_dir - && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); + && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); del_op = (new_dir == obj->my_dev->del_dir); @@ -1621,15 +1614,16 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_di obj->unlinked = 1; /* If it is a deletion then we mark it as a shrink for gc purposes. */ - if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= 0) + if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= + 0) return YAFFS_OK; } return YAFFS_FAIL; } -int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, - struct yaffs_obj *new_dir, const YCHAR *new_name) +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name) { struct yaffs_obj *obj = NULL; struct yaffs_obj *existing_target = NULL; @@ -1637,7 +1631,6 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, int result; struct yaffs_dev *dev; - if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) @@ -1649,12 +1642,13 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, /* Special case for case insemsitive systems. * While look-up is case insensitive, the name isn't. * Therefore we might want to change x.txt to X.txt - */ + */ if (old_dir == new_dir && yaffs_strcmp(old_name, new_name) == 0) force = 1; #endif - if(yaffs_strnlen(new_name,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) + if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) > + YAFFS_MAX_NAME_LENGTH) /* ENAMETOOLONG */ return YAFFS_FAIL; @@ -1666,8 +1660,9 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, existing_target = yaffs_find_by_name(new_dir, new_name); if (existing_target && - existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - !list_empty(&existing_target->variant.dir_variant.children)) { + existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY + && !list_empty(&existing_target->variant.dir_variant. + children)) { /* There is a target that is a non-empty directory, so we fail */ return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ } else if (existing_target && existing_target != obj) { @@ -1677,20 +1672,20 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, * Note we must disable gc otherwise it can mess up the shadowing. * */ - dev->gc_disable=1; + dev->gc_disable = 1; yaffs_change_obj_name(obj, new_dir, new_name, force, - existing_target->obj_id); + existing_target->obj_id); existing_target->is_shadowed = 1; yaffs_unlink_obj(existing_target); - dev->gc_disable=0; + dev->gc_disable = 0; } result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0); yaffs_update_parent(old_dir); - if(new_dir != old_dir) + if (new_dir != old_dir) yaffs_update_parent(new_dir); - + return result; } return YAFFS_FAIL; @@ -1710,24 +1705,27 @@ static int yaffs_init_blocks(struct yaffs_dev *dev) /* If the first allocation strategy fails, thry the alternate one */ dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info)); if (!dev->block_info) { - dev->block_info = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info)); + dev->block_info = + YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info)); dev->block_info_alt = 1; } else dev->block_info_alt = 0; if (dev->block_info) { /* Set up dynamic blockinfo stuff. */ - dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ + dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * n_blocks); if (!dev->chunk_bits) { - dev->chunk_bits = YMALLOC_ALT(dev->chunk_bit_stride * n_blocks); + dev->chunk_bits = + YMALLOC_ALT(dev->chunk_bit_stride * n_blocks); dev->chunk_bits_alt = 1; } else dev->chunk_bits_alt = 0; } if (dev->block_info && dev->chunk_bits) { - memset(dev->block_info, 0, n_blocks * sizeof(struct yaffs_block_info)); + memset(dev->block_info, 0, + n_blocks * sizeof(struct yaffs_block_info)); memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks); return YAFFS_OK; } @@ -1765,19 +1763,20 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) */ T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, - (TSTR("yaffs_block_became_dirty block %d state %d %s"TENDSTR), - block_no, bi->block_state, (bi->needs_retiring) ? "needs retiring" : "")); + (TSTR("yaffs_block_became_dirty block %d state %d %s" TENDSTR), + block_no, bi->block_state, + (bi->needs_retiring) ? "needs retiring" : "")); - yaffs2_clear_oldest_dirty_seq(dev,bi); + yaffs2_clear_oldest_dirty_seq(dev, bi); bi->block_state = YAFFS_BLOCK_STATE_DIRTY; /* If this is the block being garbage collected then stop gc'ing this block */ - if(block_no == dev->gc_block) + if (block_no == dev->gc_block) dev->gc_block = 0; /* If this block is currently the best candidate for gc then drop as a candidate */ - if(block_no == dev->gc_dirtiest){ + if (block_no == dev->gc_dirtiest) { dev->gc_dirtiest = 0; dev->gc_pages_in_use = 0; } @@ -1793,7 +1792,8 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) } if (erased_ok && - ((yaffs_trace_mask & YAFFS_TRACE_ERASE) || !yaffs_skip_verification(dev))) { + ((yaffs_trace_mask & YAFFS_TRACE_ERASE) + || !yaffs_skip_verification(dev))) { int i; for (i = 0; i < dev->param.chunks_per_block; i++) { if (!yaffs_check_chunk_erased @@ -1814,7 +1814,7 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) bi->pages_in_use = 0; bi->soft_del_pages = 0; bi->has_shrink_hdr = 0; - bi->skip_erased_check = 1; /* This is clean, so no need to check */ + bi->skip_erased_check = 1; /* This is clean, so no need to check */ bi->gc_prioritise = 0; yaffs_clear_chunk_bits(dev, block_no); @@ -1877,7 +1877,6 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev) return -1; } - /* * Check if there's space to allocate... * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()? @@ -1890,13 +1889,14 @@ int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks) checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev); - reserved_chunks = ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block); + reserved_chunks = + ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block); return (dev->n_free_chunks > (reserved_chunks + n_chunks)); } static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, - struct yaffs_block_info **block_ptr) + struct yaffs_block_info **block_ptr) { int ret_val; struct yaffs_block_info *bi; @@ -1913,7 +1913,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, } if (dev->n_erased_blocks < dev->param.n_reserved_blocks - && dev->alloc_page == 0) { + && dev->alloc_page == 0) { T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); } @@ -1922,10 +1922,9 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, bi = yaffs_get_block_info(dev, dev->alloc_block); ret_val = (dev->alloc_block * dev->param.chunks_per_block) + - dev->alloc_page; + dev->alloc_page; bi->pages_in_use++; - yaffs_set_chunk_bit(dev, dev->alloc_block, - dev->alloc_page); + yaffs_set_chunk_bit(dev, dev->alloc_block, dev->alloc_page); dev->alloc_page++; @@ -1944,7 +1943,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, } T(YAFFS_TRACE_ERROR, - (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); + (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); return -1; } @@ -1968,18 +1967,17 @@ static int yaffs_get_erased_chunks(struct yaffs_dev *dev) */ void yaffs_skip_rest_of_block(struct yaffs_dev *dev) { - if(dev->alloc_block > 0){ - struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->alloc_block); - if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){ + if (dev->alloc_block > 0) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->alloc_block); + if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) { bi->block_state = YAFFS_BLOCK_STATE_FULL; dev->alloc_block = -1; } } } - -static int yaffs_gc_block(struct yaffs_dev *dev, int block, - int whole_block) +static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) { int old_chunk; int new_chunk; @@ -2001,29 +1999,26 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); - T(YAFFS_TRACE_TRACING, - (TSTR("Collecting block %d, in use %d, shrink %d, whole_block %d" TENDSTR), - block, - bi->pages_in_use, - bi->has_shrink_hdr, - whole_block)); + (TSTR + ("Collecting block %d, in use %d, shrink %d, whole_block %d" + TENDSTR), block, bi->pages_in_use, bi->has_shrink_hdr, + whole_block)); /*yaffs_verify_free_chunks(dev); */ - if(bi->block_state == YAFFS_BLOCK_STATE_FULL) + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) bi->block_state = YAFFS_BLOCK_STATE_COLLECTING; - + bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */ dev->gc_disable = 1; - if (is_checkpt_block || - !yaffs_still_some_chunks(dev, block)) { + if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) { T(YAFFS_TRACE_TRACING, - (TSTR - ("Collecting block %d that has no chunks in use" TENDSTR), - block)); + (TSTR + ("Collecting block %d that has no chunks in use" TENDSTR), + block)); yaffs_block_became_dirty(dev, block); } else { @@ -2034,12 +2029,11 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, max_copies = (whole_block) ? dev->param.chunks_per_block : 5; old_chunk = block * dev->param.chunks_per_block + dev->gc_chunk; - for (/* init already done */; + for ( /* init already done */ ; ret_val == YAFFS_OK && dev->gc_chunk < dev->param.chunks_per_block && (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) && - max_copies > 0; - dev->gc_chunk++, old_chunk++) { + max_copies > 0; dev->gc_chunk++, old_chunk++) { if (yaffs_check_chunk_bit(dev, block, dev->gc_chunk)) { /* This page is in use and might need to be copied off */ @@ -2051,30 +2045,35 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, yaffs_init_tags(&tags); yaffs_rd_chunk_tags_nand(dev, old_chunk, - buffer, &tags); + buffer, &tags); - object = - yaffs_find_by_number(dev, - tags.obj_id); + object = yaffs_find_by_number(dev, tags.obj_id); T(YAFFS_TRACE_GC_DETAIL, (TSTR - ("Collecting chunk in block %d, %d %d %d " TENDSTR), - dev->gc_chunk, tags.obj_id, tags.chunk_id, - tags.n_bytes)); + ("Collecting chunk in block %d, %d %d %d " + TENDSTR), dev->gc_chunk, tags.obj_id, + tags.chunk_id, tags.n_bytes)); if (object && !yaffs_skip_verification(dev)) { if (tags.chunk_id == 0) - matching_chunk = object->hdr_chunk; + matching_chunk = + object->hdr_chunk; else if (object->soft_del) - matching_chunk = old_chunk; /* Defeat the test */ + matching_chunk = old_chunk; /* Defeat the test */ else - matching_chunk = yaffs_find_chunk_in_file(object, tags.chunk_id, NULL); + matching_chunk = + yaffs_find_chunk_in_file + (object, tags.chunk_id, + NULL); if (old_chunk != matching_chunk) T(YAFFS_TRACE_ERROR, - (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), - old_chunk, matching_chunk, tags.obj_id, tags.chunk_id)); + (TSTR + ("gc: page in gc mismatch: %d %d %d %d" + TENDSTR), old_chunk, + matching_chunk, tags.obj_id, + tags.chunk_id)); } @@ -2083,19 +2082,19 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, (TSTR ("page %d in gc has no object: %d %d %d " TENDSTR), old_chunk, - tags.obj_id, tags.chunk_id, tags.n_bytes)); + tags.obj_id, tags.chunk_id, + tags.n_bytes)); } if (object && object->deleted && - object->soft_del && - tags.chunk_id != 0) { + object->soft_del && tags.chunk_id != 0) { /* Data chunk in a soft deleted file, throw it away * It's a soft deleted data chunk, * No need to copy this, just forget about it and * fix up the object. */ - + /* Free chunks already includes softdeleted chunks. * How ever this chunk is going to soon be really deleted * which will increment free chunks. @@ -2108,8 +2107,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, if (object->n_data_chunks <= 0) { /* remeber to clean up the object */ - dev->gc_cleanup_list[dev->n_clean_ups] = - tags.obj_id; + dev->gc_cleanup_list[dev-> + n_clean_ups] + = tags.obj_id; dev->n_clean_ups++; } mark_flash = 0; @@ -2120,8 +2120,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, */ object->hdr_chunk = 0; yaffs_free_tnode(object->my_dev, - object->variant. - file_variant.top); + object-> + variant.file_variant. + top); object->variant.file_variant.top = NULL; yaffs_generic_obj_del(object); @@ -2144,7 +2145,8 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, */ struct yaffs_obj_hdr *oh; - oh = (struct yaffs_obj_hdr *)buffer; + oh = (struct yaffs_obj_hdr *) + buffer; oh->is_shrink = 0; tags.extra_is_shrink = 0; @@ -2154,17 +2156,30 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, tags.extra_shadows = 0; /* Update file size */ - if(object->variant_type == YAFFS_OBJECT_TYPE_FILE){ - oh->file_size = object->variant.file_variant.file_size; - tags.extra_length = oh->file_size; + if (object->variant_type == + YAFFS_OBJECT_TYPE_FILE) { + oh->file_size = + object->variant. + file_variant. + file_size; + tags.extra_length = + oh->file_size; } - yaffs_verify_oh(object, oh, &tags, 1); + yaffs_verify_oh(object, oh, + &tags, 1); new_chunk = - yaffs_write_new_chunk(dev,(u8 *) oh, &tags, 1); + yaffs_write_new_chunk(dev, + (u8 *) + oh, + &tags, + 1); } else new_chunk = - yaffs_write_new_chunk(dev, buffer, &tags, 1); + yaffs_write_new_chunk(dev, + buffer, + &tags, + 1); if (new_chunk < 0) { ret_val = YAFFS_FAIL; @@ -2174,35 +2189,31 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, if (tags.chunk_id == 0) { /* It's a header */ - object->hdr_chunk = new_chunk; - object->serial = tags.serial_number; + object->hdr_chunk = + new_chunk; + object->serial = + tags.serial_number; } else { /* It's a data chunk */ int ok; - ok = yaffs_put_chunk_in_file - (object, - tags.chunk_id, - new_chunk, 0); + ok = yaffs_put_chunk_in_file(object, tags.chunk_id, new_chunk, 0); } } } if (ret_val == YAFFS_OK) - yaffs_chunk_del(dev, old_chunk, mark_flash, __LINE__); + yaffs_chunk_del(dev, old_chunk, + mark_flash, __LINE__); } } yaffs_release_temp_buffer(dev, buffer, __LINE__); - - } yaffs_verify_collected_blk(dev, bi, block); - - if (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { /* * The gc did not complete. Set block state back to FULL @@ -2215,12 +2226,11 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, for (i = 0; i < dev->n_clean_ups; i++) { /* Time to delete the file too */ object = - yaffs_find_by_number(dev, - dev->gc_cleanup_list[i]); + yaffs_find_by_number(dev, dev->gc_cleanup_list[i]); if (object) { yaffs_free_tnode(dev, - object->variant.file_variant. - top); + object->variant. + file_variant.top); object->variant.file_variant.top = NULL; T(YAFFS_TRACE_GC, (TSTR @@ -2232,7 +2242,6 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, } - chunks_after = yaffs_get_erased_chunks(dev); if (chunks_before >= chunks_after) { T(YAFFS_TRACE_GC, @@ -2256,8 +2265,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, */ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, - int aggressive, - int background) + int aggressive, int background) { int i; int iterations; @@ -2272,13 +2280,12 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, dev->gc_dirtiest = 0; bi = dev->block_info; for (i = dev->internal_start_block; - i <= dev->internal_end_block && !selected; - i++) { + i <= dev->internal_end_block && !selected; i++) { if (bi->gc_prioritise) { prioritised_exist = 1; if (bi->block_state == YAFFS_BLOCK_STATE_FULL && - yaffs_block_ok_for_gc(dev, bi)) { + yaffs_block_ok_for_gc(dev, bi)) { selected = i; prioritised = 1; } @@ -2292,12 +2299,11 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, * up the works. Let's gc the oldest dirty block. */ - if(prioritised_exist && - !selected && - dev->oldest_dirty_block > 0) + if (prioritised_exist && + !selected && dev->oldest_dirty_block > 0) selected = dev->oldest_dirty_block; - if (!prioritised_exist) /* None found, so we can clear this */ + if (!prioritised_exist) /* None found, so we can clear this */ dev->has_pending_prioritised_gc = 0; } @@ -2307,28 +2313,28 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, * block has only a few pages in use. */ - if (!selected){ + if (!selected) { int pages_used; - int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; - if (aggressive){ + int n_blocks = + dev->internal_end_block - dev->internal_start_block + 1; + if (aggressive) { threshold = dev->param.chunks_per_block; iterations = n_blocks; } else { int max_threshold; - if(background) - max_threshold = dev->param.chunks_per_block/2; + if (background) + max_threshold = dev->param.chunks_per_block / 2; else - max_threshold = dev->param.chunks_per_block/8; + max_threshold = dev->param.chunks_per_block / 8; - if(max_threshold < YAFFS_GC_PASSIVE_THRESHOLD) + if (max_threshold < YAFFS_GC_PASSIVE_THRESHOLD) max_threshold = YAFFS_GC_PASSIVE_THRESHOLD; - threshold = background ? - (dev->gc_not_done + 2) * 2 : 0; - if(threshold gc_not_done + 2) * 2 : 0; + if (threshold < YAFFS_GC_PASSIVE_THRESHOLD) threshold = YAFFS_GC_PASSIVE_THRESHOLD; - if(threshold > max_threshold) + if (threshold > max_threshold) threshold = max_threshold; iterations = n_blocks / 16 + 1; @@ -2337,29 +2343,30 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, } for (i = 0; - i < iterations && - (dev->gc_dirtiest < 1 || - dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); - i++) { + i < iterations && + (dev->gc_dirtiest < 1 || + dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); i++) { dev->gc_block_finder++; if (dev->gc_block_finder < dev->internal_start_block || - dev->gc_block_finder > dev->internal_end_block) - dev->gc_block_finder = dev->internal_start_block; + dev->gc_block_finder > dev->internal_end_block) + dev->gc_block_finder = + dev->internal_start_block; bi = yaffs_get_block_info(dev, dev->gc_block_finder); pages_used = bi->pages_in_use - bi->soft_del_pages; if (bi->block_state == YAFFS_BLOCK_STATE_FULL && - pages_used < dev->param.chunks_per_block && - (dev->gc_dirtiest < 1 || pages_used < dev->gc_pages_in_use) && - yaffs_block_ok_for_gc(dev, bi)) { + pages_used < dev->param.chunks_per_block && + (dev->gc_dirtiest < 1 + || pages_used < dev->gc_pages_in_use) + && yaffs_block_ok_for_gc(dev, bi)) { dev->gc_dirtiest = dev->gc_block_finder; dev->gc_pages_in_use = pages_used; } } - if(dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) + if (dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) selected = dev->gc_dirtiest; } @@ -2368,44 +2375,45 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, * because that's gumming up the works. */ - if(!selected && dev->param.is_yaffs2 && - dev->gc_not_done >= ( background ? 10 : 20)){ + if (!selected && dev->param.is_yaffs2 && + dev->gc_not_done >= (background ? 10 : 20)) { yaffs2_find_oldest_dirty_seq(dev); - if(dev->oldest_dirty_block > 0) { + if (dev->oldest_dirty_block > 0) { selected = dev->oldest_dirty_block; dev->gc_dirtiest = selected; dev->oldest_dirty_gc_count++; bi = yaffs_get_block_info(dev, selected); - dev->gc_pages_in_use = bi->pages_in_use - bi->soft_del_pages; + dev->gc_pages_in_use = + bi->pages_in_use - bi->soft_del_pages; } else dev->gc_not_done = 0; } - if(selected){ + if (selected) { T(YAFFS_TRACE_GC, - (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), - selected, - dev->param.chunks_per_block - dev->gc_pages_in_use, - prioritised)); + (TSTR + ("GC Selected block %d with %d free, prioritised:%d" + TENDSTR), selected, + dev->param.chunks_per_block - dev->gc_pages_in_use, + prioritised)); dev->n_gc_blocks++; - if(background) + if (background) dev->bg_gcs++; dev->gc_dirtiest = 0; dev->gc_pages_in_use = 0; dev->gc_not_done = 0; - if(dev->refresh_skip > 0) + if (dev->refresh_skip > 0) dev->refresh_skip--; - } else{ + } else { dev->gc_not_done++; T(YAFFS_TRACE_GC, - (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), - dev->gc_block_finder, dev->gc_not_done, - threshold, - dev->gc_dirtiest, dev->gc_pages_in_use, - dev->oldest_dirty_block, - background ? " bg" : "")); + (TSTR + ("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" + TENDSTR), dev->gc_block_finder, dev->gc_not_done, threshold, + dev->gc_dirtiest, dev->gc_pages_in_use, + dev->oldest_dirty_block, background ? " bg" : "")); } return selected; @@ -2429,8 +2437,7 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background) int erased_chunks; int checkpt_block_adjust; - if(dev->param.gc_control && - (dev->param.gc_control(dev) & 1) == 0) + if (dev->param.gc_control && (dev->param.gc_control(dev) & 1) == 0) return YAFFS_OK; if (dev->gc_disable) { @@ -2447,21 +2454,23 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background) checkpt_block_adjust = yaffs_calc_checkpt_blocks_required(dev); - min_erased = dev->param.n_reserved_blocks + checkpt_block_adjust + 1; - erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + min_erased = + dev->param.n_reserved_blocks + checkpt_block_adjust + 1; + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; - /* If we need a block soon then do aggressive gc.*/ + /* If we need a block soon then do aggressive gc. */ if (dev->n_erased_blocks < min_erased) aggressive = 1; else { - if(!background && erased_chunks > (dev->n_free_chunks / 4)) + if (!background + && erased_chunks > (dev->n_free_chunks / 4)) break; - if(dev->gc_skip > 20) + if (dev->gc_skip > 20) dev->gc_skip = 20; - if(erased_chunks < dev->n_free_chunks/2 || - dev->gc_skip < 1 || - background) + if (erased_chunks < dev->n_free_chunks / 2 || + dev->gc_skip < 1 || background) aggressive = 0; else { dev->gc_skip--; @@ -2471,17 +2480,18 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background) dev->gc_skip = 5; - /* If we don't already have a block being gc'd then see if we should start another */ + /* If we don't already have a block being gc'd then see if we should start another */ if (dev->gc_block < 1 && !aggressive) { dev->gc_block = yaffs2_find_refresh_block(dev); dev->gc_chunk = 0; - dev->n_clean_ups=0; + dev->n_clean_ups = 0; } if (dev->gc_block < 1) { - dev->gc_block = yaffs_find_gc_block(dev, aggressive, background); + dev->gc_block = + yaffs_find_gc_block(dev, aggressive, background); dev->gc_chunk = 0; - dev->n_clean_ups=0; + dev->n_clean_ups = 0; } if (dev->gc_block > 0) { @@ -2491,21 +2501,22 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background) T(YAFFS_TRACE_GC, (TSTR - ("yaffs: GC n_erased_blocks %d aggressive %d" TENDSTR), - dev->n_erased_blocks, aggressive)); + ("yaffs: GC n_erased_blocks %d aggressive %d" + TENDSTR), dev->n_erased_blocks, aggressive)); gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive); } - if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && dev->gc_block > 0) { + if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) + && dev->gc_block > 0) { T(YAFFS_TRACE_GC, (TSTR ("yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d" - TENDSTR), dev->n_erased_blocks, max_tries, dev->gc_block)); + TENDSTR), dev->n_erased_blocks, max_tries, + dev->gc_block)); } } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && - (dev->gc_block > 0) && - (max_tries < 2)); + (dev->gc_block > 0) && (max_tries < 2)); return aggressive ? gc_ok : YAFFS_OK; } @@ -2519,27 +2530,26 @@ int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency) { int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency)); + T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR), urgency)); yaffs_check_gc(dev, 1); - return erased_chunks > dev->n_free_chunks/2; + return erased_chunks > dev->n_free_chunks / 2; } /*------------------------- TAGS --------------------------------*/ static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, - int chunk_obj) + int chunk_obj) { return (tags->chunk_id == chunk_obj && tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0; } - /*-------------------- Data file manipulation -----------------*/ static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, - struct yaffs_ext_tags *tags) + struct yaffs_ext_tags *tags) { /*Get the Tnode, then get the level 0 offset chunk offset */ struct yaffs_tnode *tn; @@ -2561,13 +2571,13 @@ static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, ret_val = yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, - inode_chunk); + inode_chunk); } return ret_val; } static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, - struct yaffs_ext_tags *tags) + struct yaffs_ext_tags *tags) { /* Get the Tnode, then get the level 0 offset chunk offset */ struct yaffs_tnode *tn; @@ -2590,7 +2600,7 @@ static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, ret_val = yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, - inode_chunk); + inode_chunk); /* Delete the entry in the filestructure (if found) */ if (ret_val != -1) @@ -2600,9 +2610,8 @@ static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, return ret_val; } - int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, - int nand_chunk, int in_scan) + int nand_chunk, int in_scan) { /* NB in_scan is zero unless scanning. * For forward scanning, in_scan is > 0; @@ -2635,13 +2644,12 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, } tn = yaffs_add_find_tnode_0(dev, - &in->variant.file_variant, - inode_chunk, - NULL); + &in->variant.file_variant, + inode_chunk, NULL); if (!tn) return YAFFS_FAIL; - - if(!nand_chunk) + + if (!nand_chunk) /* Dummy insert, bail now */ return YAFFS_OK; @@ -2671,13 +2679,13 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, if (in_scan > 0) { /* Only do this for forward scanning */ yaffs_rd_chunk_tags_nand(dev, - nand_chunk, - NULL, &new_tags); + nand_chunk, + NULL, &new_tags); /* Do a proper find */ existing_cunk = yaffs_find_chunk_in_file(in, inode_chunk, - &existing_tags); + &existing_tags); } if (existing_cunk <= 0) { @@ -2707,14 +2715,13 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, * Delete the old one and drop through to update the tnode */ yaffs_chunk_del(dev, existing_cunk, 1, - __LINE__); + __LINE__); } else { /* Backward scanning or we want to use the existing one * Use existing. * Delete the new one and return early so that the tnode isn't changed */ - yaffs_chunk_del(dev, nand_chunk, 1, - __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; } } @@ -2729,8 +2736,7 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, return YAFFS_OK; } -static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, - u8 *buffer) +static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer) { int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL); @@ -2748,7 +2754,8 @@ static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, } -void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int lyn) +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn) { int block; int page; @@ -2762,14 +2769,12 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int ly block = chunk_id / dev->param.chunks_per_block; page = chunk_id % dev->param.chunks_per_block; - if (!yaffs_check_chunk_bit(dev, block, page)) T(YAFFS_TRACE_VERIFY, - (TSTR("Deleting invalid chunk %d"TENDSTR), - chunk_id)); + (TSTR("Deleting invalid chunk %d" TENDSTR), chunk_id)); bi = yaffs_get_block_info(dev, block); - + yaffs2_update_oldest_dirty_seq(dev, block, bi); T(YAFFS_TRACE_DELETION, @@ -2813,8 +2818,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int ly } static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, - const u8 *buffer, int n_bytes, - int use_reserve) + const u8 * buffer, int n_bytes, int use_reserve) { /* Find old chunk Need to do this to get serial number * Write new one and patch into tree. @@ -2829,15 +2833,15 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, struct yaffs_dev *dev = in->my_dev; - yaffs_check_gc(dev,0); + yaffs_check_gc(dev, 0); /* Get the previous chunk at this location in the file if it exists. * If it does not exist then put a zero into the tree. This creates * the tnode now, rather than later when it is harder to clean up. */ prev_chunk_id = yaffs_find_chunk_in_file(in, inode_chunk, &prev_tags); - if(prev_chunk_id < 1 && - !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) + if (prev_chunk_id < 1 && + !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) return 0; /* Set up new tags */ @@ -2851,14 +2855,13 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) { T(YAFFS_TRACE_ERROR, - (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), n_bytes)); + (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), + n_bytes)); YBUG(); } - - + new_chunk_id = - yaffs_write_new_chunk(dev, buffer, &new_tags, - use_reserve); + yaffs_write_new_chunk(dev, buffer, &new_tags, use_reserve); if (new_chunk_id > 0) { yaffs_put_chunk_in_file(in, inode_chunk, new_chunk_id, 0); @@ -2875,8 +2878,8 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, /* UpdateObjectHeader updates the header on NAND for an object. * If name is not NULL, then that new name is used. */ -int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, - int is_shrink, int shadows, struct yaffs_xattr_mod *xmod) +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, + int is_shrink, int shadows, struct yaffs_xattr_mod *xmod) { struct yaffs_block_info *bi; @@ -2899,22 +2902,20 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, yaffs_strcpy(old_name, _Y("silly old name")); + if (!in->fake || in == dev->root_dir || /* The root_dir should also be saved */ + force || xmod) { - if (!in->fake || - in == dev->root_dir || /* The root_dir should also be saved */ - force || xmod) { - - yaffs_check_gc(dev,0); + yaffs_check_gc(dev, 0); yaffs_check_obj_details_loaded(in); buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__); - oh = (struct yaffs_obj_hdr *) buffer; + oh = (struct yaffs_obj_hdr *)buffer; prev_chunk_id = in->hdr_chunk; if (prev_chunk_id > 0) { result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id, - buffer, &old_tags); + buffer, &old_tags); yaffs_verify_oh(in, oh, &old_tags, 0); @@ -2927,7 +2928,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, oh->yst_mode = in->yst_mode; oh->shadows_obj = oh->inband_shadowed_obj_id = shadows; - yaffs_load_attribs_oh(oh,in); + yaffs_load_attribs_oh(oh, in); if (in->parent) oh->parent_obj_id = in->parent->obj_id; @@ -2936,7 +2937,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, if (name && *name) { memset(oh->name, 0, sizeof(oh->name)); - yaffs_load_oh_from_name(dev,oh->name,name); + yaffs_load_oh_from_name(dev, oh->name, name); } else if (prev_chunk_id > 0) memcpy(oh->name, old_name, sizeof(oh->name)); else @@ -2952,12 +2953,11 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, oh->file_size = (oh->parent_obj_id == YAFFS_OBJECTID_DELETED || oh->parent_obj_id == - YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. - file_variant.file_size; + YAFFS_OBJECTID_UNLINKED) ? 0 : in-> + variant.file_variant.file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - oh->equiv_id = - in->variant.hardlink_variant.equiv_id; + oh->equiv_id = in->variant.hardlink_variant.equiv_id; break; case YAFFS_OBJECT_TYPE_SPECIAL: /* Do nothing */ @@ -2967,20 +2967,17 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, break; case YAFFS_OBJECT_TYPE_SYMLINK: alias = in->variant.symlink_variant.alias; - if(!alias) + if (!alias) alias = _Y("no alias"); - yaffs_strncpy(oh->alias, - alias, - YAFFS_MAX_ALIAS_LENGTH); + yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH); oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; break; } /* process any xattrib modifications */ - if(xmod) + if (xmod) yaffs_apply_xattrib_mod(in, (char *)buffer, xmod); - /* Tags */ yaffs_init_tags(&new_tags); in->serial++; @@ -3003,7 +3000,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, /* Create new chunk in NAND */ new_chunk_id = yaffs_write_new_chunk(dev, buffer, &new_tags, - (prev_chunk_id > 0) ? 1 : 0); + (prev_chunk_id > 0) ? 1 : 0); if (new_chunk_id >= 0) { @@ -3011,7 +3008,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, if (prev_chunk_id > 0) { yaffs_chunk_del(dev, prev_chunk_id, 1, - __LINE__); + __LINE__); } if (!yaffs_obj_cache_dirty(in)) @@ -3020,7 +3017,9 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, /* If this was a shrink, then mark the block that the chunk lives on */ if (is_shrink) { bi = yaffs_get_block_info(in->my_dev, - new_chunk_id / in->my_dev->param.chunks_per_block); + new_chunk_id / + in->my_dev->param. + chunks_per_block); bi->has_shrink_hdr = 1; } @@ -3058,15 +3057,13 @@ static int yaffs_obj_cache_dirty(struct yaffs_obj *obj) for (i = 0; i < n_caches; i++) { cache = &dev->cache[i]; - if (cache->object == obj && - cache->dirty) + if (cache->object == obj && cache->dirty) return 1; } return 0; } - static void yaffs_flush_file_cache(struct yaffs_obj *obj) { struct yaffs_dev *dev = obj->my_dev; @@ -3098,10 +3095,9 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj) chunk_written = yaffs_wr_data_obj(cache->object, - cache->chunk_id, - cache->data, - cache->n_bytes, - 1); + cache->chunk_id, + cache->data, + cache->n_bytes, 1); cache->dirty = 0; cache->object = NULL; } @@ -3111,7 +3107,9 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj) if (cache) { /* Hoosterman, disk full while writing cache out. */ T(YAFFS_TRACE_ERROR, - (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); + (TSTR + ("yaffs tragedy: no space during cache write" + TENDSTR))); } } @@ -3135,8 +3133,7 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev) do { obj = NULL; for (i = 0; i < n_caches && !obj; i++) { - if (dev->cache[i].object && - dev->cache[i].dirty) + if (dev->cache[i].object && dev->cache[i].dirty) obj = dev->cache[i].object; } @@ -3147,7 +3144,6 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev) } - /* Grab us a cache chunk for use. * First look for an empty one. * Then look for the least recently used non-dirty one. @@ -3197,7 +3193,8 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) for (i = 0; i < dev->param.n_caches; i++) { if (dev->cache[i].object && !dev->cache[i].locked && - (dev->cache[i].last_use < usage || !cache)) { + (dev->cache[i].last_use < usage + || !cache)) { usage = dev->cache[i].last_use; the_obj = dev->cache[i].object; cache = &dev->cache[i]; @@ -3220,7 +3217,7 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) /* Find a cached chunk */ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, - int chunk_id) + int chunk_id) { struct yaffs_dev *dev = obj->my_dev; int i; @@ -3239,7 +3236,7 @@ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, /* Mark the chunk for the least recently used algorithym */ static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, - int is_write) + int is_write) { if (dev->param.n_caches > 0) { @@ -3268,7 +3265,8 @@ static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id) { if (object->my_dev->param.n_caches > 0) { - struct yaffs_cache *cache = yaffs_find_chunk_cache(object, chunk_id); + struct yaffs_cache *cache = + yaffs_find_chunk_cache(object, chunk_id); if (cache) cache->object = NULL; @@ -3292,7 +3290,6 @@ static void yaffs_invalidate_whole_cache(struct yaffs_obj *in) } } - /*--------------------- File read/write ------------------------ * Read and write have very similar structures. * In general the read/write has three parts to it @@ -3303,8 +3300,7 @@ static void yaffs_invalidate_whole_cache(struct yaffs_obj *in) * Curve-balls: the first chunk might also be the last chunk. */ -int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset, - int n_bytes) +int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) { int chunk; @@ -3338,20 +3334,21 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset, * or we're using inband tags then use the cache (if there is caching) * else bypass the cache. */ - if (cache || n_copy != dev->data_bytes_per_chunk || dev->param.inband_tags) { + if (cache || n_copy != dev->data_bytes_per_chunk + || dev->param.inband_tags) { if (dev->param.n_caches > 0) { /* If we can't find the data in the cache, then load it up. */ if (!cache) { - cache = yaffs_grab_chunk_cache(in->my_dev); + cache = + yaffs_grab_chunk_cache(in->my_dev); cache->object = in; cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; yaffs_rd_data_obj(in, chunk, - cache-> - data); + cache->data); cache->n_bytes = 0; } @@ -3359,23 +3356,20 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset, cache->locked = 1; - memcpy(buffer, &cache->data[start], n_copy); cache->locked = 0; } else { - /* Read into the local buffer then copy..*/ + /* Read into the local buffer then copy.. */ u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_rd_data_obj(in, chunk, - local_buffer); + yaffs_rd_data_obj(in, chunk, local_buffer); memcpy(buffer, &local_buffer[start], n_copy); - yaffs_release_temp_buffer(dev, local_buffer, - __LINE__); + __LINE__); } } else { @@ -3395,8 +3389,8 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset, return n_done; } -int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough) +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough) { int chunk; @@ -3418,13 +3412,13 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, yaffs_addr_to_chunk(dev, offset, &chunk, &start); if (chunk * dev->data_bytes_per_chunk + start != offset || - start >= dev->data_bytes_per_chunk) { - T(YAFFS_TRACE_ERROR, ( - TSTR("AddrToChunk of offset %d gives chunk %d start %d" - TENDSTR), - (int)offset, chunk, start)); + start >= dev->data_bytes_per_chunk) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("AddrToChunk of offset %d gives chunk %d start %d" + TENDSTR), (int)offset, chunk, start)); } - chunk++; /* File pos to chunk in file offset */ + chunk++; /* File pos to chunk in file offset */ /* OK now check for the curveball where the start and end are in * the same chunk. @@ -3441,9 +3435,11 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk); if (chunk_start > in->variant.file_variant.file_size) - n_bytes_read = 0; /* Past end of file */ + n_bytes_read = 0; /* Past end of file */ else - n_bytes_read = in->variant.file_variant.file_size - chunk_start; + n_bytes_read = + in->variant.file_variant.file_size - + chunk_start; if (n_bytes_read > dev->data_bytes_per_chunk) n_bytes_read = dev->data_bytes_per_chunk; @@ -3452,7 +3448,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, (n_bytes_read > (start + n)) ? n_bytes_read : (start + n); - if (n_writeback < 0 || n_writeback > dev->data_bytes_per_chunk) + if (n_writeback < 0 + || n_writeback > dev->data_bytes_per_chunk) YBUG(); } else { @@ -3460,7 +3457,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, n_writeback = dev->data_bytes_per_chunk; } - if (n_copy != dev->data_bytes_per_chunk || dev->param.inband_tags) { + if (n_copy != dev->data_bytes_per_chunk + || dev->param.inband_tags) { /* An incomplete start or end chunk (or maybe both start and end chunk), * or we're using inband tags, so we want to use the cache buffers. */ @@ -3477,25 +3475,24 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, cache->dirty = 0; cache->locked = 0; yaffs_rd_data_obj(in, chunk, - cache->data); + cache->data); } else if (cache && - !cache->dirty && - !yaffs_check_alloc_available(dev, 1)) { + !cache->dirty && + !yaffs_check_alloc_available(dev, + 1)) { /* Drop the cache if it was a read cache item and * no space check has been made for it. */ - cache = NULL; + cache = NULL; } if (cache) { yaffs_use_cache(dev, cache, 1); cache->locked = 1; - memcpy(&cache->data[start], buffer, n_copy); - cache->locked = 0; cache->n_bytes = n_writeback; @@ -3504,8 +3501,8 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, yaffs_wr_data_obj (cache->object, cache->chunk_id, - cache->data, cache->n_bytes, - 1); + cache->data, + cache->n_bytes, 1); cache->dirty = 0; } @@ -3520,33 +3517,26 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_rd_data_obj(in, chunk, - local_buffer); - - + yaffs_rd_data_obj(in, chunk, local_buffer); memcpy(&local_buffer[start], buffer, n_copy); chunk_written = yaffs_wr_data_obj(in, chunk, - local_buffer, - n_writeback, - 0); + local_buffer, + n_writeback, 0); yaffs_release_temp_buffer(dev, local_buffer, - __LINE__); + __LINE__); } } else { /* A full chunk. Write directly from the supplied buffer. */ - - chunk_written = yaffs_wr_data_obj(in, chunk, buffer, - dev->data_bytes_per_chunk, - 0); + dev->data_bytes_per_chunk, 0); /* Since we've overwritten the cached data, we better invalidate it. */ yaffs_invalidate_chunk_cache(in, chunk); @@ -3571,15 +3561,13 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, return n_done; } -int yaffs_wr_file(struct yaffs_obj *in, const u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough) +int yaffs_wr_file(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough) { - yaffs2_handle_hole(in,offset); - return yaffs_do_file_wr(in,buffer,offset,n_bytes,write_trhrough); + yaffs2_handle_hole(in, offset); + return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_trhrough); } - - /* ---------------------- File resizing stuff ------------------ */ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) @@ -3607,12 +3595,14 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) chunk_id = yaffs_find_del_file_chunk(in, i, NULL); if (chunk_id > 0) { if (chunk_id < - (dev->internal_start_block * dev->param.chunks_per_block) + (dev->internal_start_block * + dev->param.chunks_per_block) || chunk_id >= ((dev->internal_end_block + 1) * dev->param.chunks_per_block)) { T(YAFFS_TRACE_ALWAYS, - (TSTR("Found daft chunk_id %d for %d" TENDSTR), + (TSTR + ("Found daft chunk_id %d for %d" TENDSTR), chunk_id, i)); } else { in->n_data_chunks--; @@ -3623,8 +3613,7 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) } - -void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size) +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size) { int new_full; u32 new_partial; @@ -3641,10 +3630,10 @@ void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size) /* Got to read and rewrite the last chunk with its new size and zero pad */ yaffs_rd_data_obj(obj, last_chunk, local_buffer); memset(local_buffer + new_partial, 0, - dev->data_bytes_per_chunk - new_partial); + dev->data_bytes_per_chunk - new_partial); yaffs_wr_data_obj(obj, last_chunk, local_buffer, - new_partial, 1); + new_partial, 1); yaffs_release_temp_buffer(dev, local_buffer, __LINE__); } @@ -3654,7 +3643,6 @@ void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size) yaffs_prune_tree(dev, &obj->variant.file_variant); } - int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) { struct yaffs_dev *dev = in->my_dev; @@ -3663,21 +3651,21 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) yaffs_flush_file_cache(in); yaffs_invalidate_whole_cache(in); - yaffs_check_gc(dev,0); + yaffs_check_gc(dev, 0); if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; if (new_size == old_size) return YAFFS_OK; - - if(new_size > old_size){ - yaffs2_handle_hole(in,new_size); + + if (new_size > old_size) { + yaffs2_handle_hole(in, new_size); in->variant.file_variant.file_size = new_size; } else { - /* new_size < old_size */ + /* new_size < old_size */ yaffs_resize_file_down(in, new_size); - } + } /* Write a new object header to reflect the resize. * show we've shrunk the file, if need be @@ -3690,24 +3678,22 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) in->parent->obj_id != YAFFS_OBJECTID_DELETED) yaffs_update_oh(in, NULL, 0, 0, 0, NULL); - return YAFFS_OK; } - int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync) { int ret_val; if (in->dirty) { yaffs_flush_file_cache(in); - if(data_sync) /* Only sync data */ - ret_val=YAFFS_OK; + if (data_sync) /* Only sync data */ + ret_val = YAFFS_OK; else { if (update_time) - yaffs_load_current_time(in,0,0); + yaffs_load_current_time(in, 0, 0); ret_val = (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >= - 0) ? YAFFS_OK : YAFFS_FAIL; + 0) ? YAFFS_OK : YAFFS_FAIL; } } else { ret_val = YAFFS_OK; @@ -3725,7 +3711,8 @@ static int yaffs_generic_obj_del(struct yaffs_obj *in) if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) { /* Move to the unlinked directory so we have a record that it was deleted. */ - yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0); + yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, + 0); } @@ -3755,7 +3742,7 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) if (del_now) { ret_val = yaffs_change_obj_name(in, in->my_dev->del_dir, - _Y("deleted"), 0, 0); + _Y("deleted"), 0, 0); T(YAFFS_TRACE_TRACING, (TSTR("yaffs: immediate deletion of file %d" TENDSTR), in->obj_id)); @@ -3767,17 +3754,16 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) } else { ret_val = yaffs_change_obj_name(in, in->my_dev->unlinked_dir, - _Y("unlinked"), 0, 0); + _Y("unlinked"), 0, 0); } - return ret_val; } int yaffs_del_file(struct yaffs_obj *in) { int ret_val = YAFFS_OK; - int deleted; /* Need to cache value on stack if in is freed */ + int deleted; /* Need to cache value on stack if in is freed */ struct yaffs_dev *dev = in->my_dev; if (dev->param.disable_soft_del || dev->param.is_yaffs2) @@ -3812,7 +3798,7 @@ int yaffs_del_file(struct yaffs_obj *in) static int yaffs_is_non_empty_dir(struct yaffs_obj *obj) { return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && - !(list_empty(&obj->variant.dir_variant.children)); + !(list_empty(&obj->variant.dir_variant.children)); } static int yaffs_del_dir(struct yaffs_obj *obj) @@ -3826,9 +3812,9 @@ static int yaffs_del_dir(struct yaffs_obj *obj) static int yaffs_del_symlink(struct yaffs_obj *in) { - if(in->variant.symlink_variant.alias) + if (in->variant.symlink_variant.alias) YFREE(in->variant.symlink_variant.alias); - in->variant.symlink_variant.alias=NULL; + in->variant.symlink_variant.alias = NULL; return yaffs_generic_obj_del(in); } @@ -3844,14 +3830,17 @@ static int yaffs_del_link(struct yaffs_obj *in) int yaffs_del_obj(struct yaffs_obj *obj) { -int ret_val = -1; + int ret_val = -1; switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: ret_val = yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - if(!list_empty(&obj->variant.dir_variant.dirty)){ - T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->obj_id)); + if (!list_empty(&obj->variant.dir_variant.dirty)) { + T(YAFFS_TRACE_BACKGROUND, + (TSTR + ("Remove object %d from dirty directories" TENDSTR), + obj->obj_id)); list_del_init(&obj->variant.dir_variant.dirty); } return yaffs_del_dir(obj); @@ -3881,7 +3870,7 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj) if (!obj->my_inode) del_now = 1; - if(obj) + if (obj) yaffs_update_parent(obj->parent); if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { @@ -3906,16 +3895,17 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj) int ret_val; YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - hl = list_entry(obj->hard_links.next, struct yaffs_obj, hard_links); + hl = list_entry(obj->hard_links.next, struct yaffs_obj, + hard_links); yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1); parent = hl->parent; list_del_init(&hl->hard_links); - yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); + yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); - ret_val = yaffs_change_obj_name(obj,parent, name, 0, 0); + ret_val = yaffs_change_obj_name(obj, parent, name, 0, 0); if (ret_val == YAFFS_OK) ret_val = yaffs_generic_obj_del(hl); @@ -3942,14 +3932,13 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj) default: return YAFFS_FAIL; } - } else if(yaffs_is_non_empty_dir(obj)) + } else if (yaffs_is_non_empty_dir(obj)) return YAFFS_FAIL; else return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir, - _Y("unlinked"), 0, 0); + _Y("unlinked"), 0, 0); } - static int yaffs_unlink_obj(struct yaffs_obj *obj) { @@ -3959,7 +3948,8 @@ static int yaffs_unlink_obj(struct yaffs_obj *obj) return YAFFS_FAIL; } -int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name) + +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name) { struct yaffs_obj *obj; @@ -3970,7 +3960,7 @@ int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name) /*----------------------- Initialisation Scanning ---------------------- */ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, - int backward_scanning) + int backward_scanning) { struct yaffs_obj *obj; @@ -3984,7 +3974,7 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, * If the shadowed object exists then ignore. */ obj = yaffs_find_by_number(dev, obj_id); - if(obj) + if (obj) return; } @@ -3992,8 +3982,7 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, * We put it in unlinked dir to be cleaned up after the scanning */ obj = - yaffs_find_or_create_by_number(dev, obj_id, - YAFFS_OBJECT_TYPE_FILE); + yaffs_find_or_create_by_number(dev, obj_id, YAFFS_OBJECT_TYPE_FILE); if (!obj) return; obj->is_shadowed = 1; @@ -4003,7 +3992,6 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, } - void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) { struct yaffs_obj *hl; @@ -4011,11 +3999,11 @@ void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) while (hard_list) { hl = hard_list; - hard_list = (struct yaffs_obj *) (hard_list->hard_links.next); + hard_list = (struct yaffs_obj *)(hard_list->hard_links.next); in = yaffs_find_by_number(dev, - hl->variant.hardlink_variant. - equiv_id); + hl->variant. + hardlink_variant.equiv_id); if (in) { /* Add the hardlink pointers */ @@ -4032,12 +4020,11 @@ void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) } } - static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) { /* - * Sort out state of unlinked and deleted objects after scanning. - */ + * Sort out state of unlinked and deleted objects after scanning. + */ struct list_head *i; struct list_head *n; struct yaffs_obj *l; @@ -4047,15 +4034,14 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) /* Soft delete all the unlinked files */ list_for_each_safe(i, n, - &dev->unlinked_dir->variant.dir_variant.children) { + &dev->unlinked_dir->variant.dir_variant.children) { if (i) { l = list_entry(i, struct yaffs_obj, siblings); yaffs_del_obj(l); } } - list_for_each_safe(i, n, - &dev->del_dir->variant.dir_variant.children) { + list_for_each_safe(i, n, &dev->del_dir->variant.dir_variant.children) { if (i) { l = list_entry(i, struct yaffs_obj, siblings); yaffs_del_obj(l); @@ -4080,12 +4066,11 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) * This fixes the problem where directories might have inadvertently been deleted * leaving the object "hanging" without being rooted in the directory tree. */ - + static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj) { return (obj == dev->del_dir || - obj == dev->unlinked_dir|| - obj == dev->root_dir); + obj == dev->unlinked_dir || obj == dev->root_dir); } static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) @@ -4106,49 +4091,53 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) * Make sure it is rooted. */ - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { list_for_each_safe(lh, n, &dev->obj_bucket[i].list) { if (lh) { - obj = list_entry(lh, struct yaffs_obj, hash_link); - parent= obj->parent; - - if(yaffs_has_null_parent(dev,obj)){ + obj = + list_entry(lh, struct yaffs_obj, hash_link); + parent = obj->parent; + + if (yaffs_has_null_parent(dev, obj)) { /* These directories are not hanging */ hanging = 0; - } - else if(!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) hanging = 1; - else if(yaffs_has_null_parent(dev,parent)) + else if (yaffs_has_null_parent(dev, parent)) hanging = 0; else { /* * Need to follow the parent chain to see if it is hanging. */ hanging = 0; - depth_limit=100; + depth_limit = 100; - while(parent != dev->root_dir && - parent->parent && - parent->parent->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - depth_limit > 0){ + while (parent != dev->root_dir && + parent->parent && + parent->parent->variant_type == + YAFFS_OBJECT_TYPE_DIRECTORY + && depth_limit > 0) { parent = parent->parent; depth_limit--; } - if(parent != dev->root_dir) + if (parent != dev->root_dir) hanging = 1; } - if(hanging){ + if (hanging) { T(YAFFS_TRACE_SCAN, - (TSTR("Hanging object %d moved to lost and found" TENDSTR), - obj->obj_id)); - yaffs_add_obj_to_dir(dev->lost_n_found,obj); + (TSTR + ("Hanging object %d moved to lost and found" + TENDSTR), obj->obj_id)); + yaffs_add_obj_to_dir(dev->lost_n_found, + obj); } } } } } - /* * Delete directory contents for cleaning up lost and found. */ @@ -4158,26 +4147,26 @@ static void yaffs_del_dir_contents(struct yaffs_obj *dir) struct list_head *lh; struct list_head *n; - if(dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - + list_for_each_safe(lh, n, &dir->variant.dir_variant.children) { if (lh) { obj = list_entry(lh, struct yaffs_obj, siblings); - if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) + if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) yaffs_del_dir_contents(obj); T(YAFFS_TRACE_SCAN, - (TSTR("Deleting lost_found object %d" TENDSTR), - obj->obj_id)); + (TSTR("Deleting lost_found object %d" TENDSTR), + obj->obj_id)); /* Need to use UnlinkObject since Delete would not handle * hardlinked objects correctly. */ - yaffs_unlink_obj(obj); + yaffs_unlink_obj(obj); } } - + } static void yaffs_empty_l_n_f(struct yaffs_dev *dev) @@ -4203,8 +4192,10 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) in->lazy_loaded = 0; chunk_data = yaffs_get_temp_buffer(dev, __LINE__); - result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, &tags); - oh = (struct yaffs_obj_hdr *) chunk_data; + result = + yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, + &tags); + oh = (struct yaffs_obj_hdr *)chunk_data; in->yst_mode = oh->yst_mode; yaffs_load_attribs(in, oh); @@ -4212,9 +4203,9 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { in->variant.symlink_variant.alias = - yaffs_clone_str(oh->alias); + yaffs_clone_str(oh->alias); if (!in->variant.symlink_variant.alias) - alloc_failed = 1; /* Not returned to caller */ + alloc_failed = 1; /* Not returned to caller */ } yaffs_release_temp_buffer(dev, chunk_data, __LINE__); @@ -4238,23 +4229,23 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) * If the directory updating is defered then yaffs_update_dirty_dirs must be * called periodically. */ - + static void yaffs_update_parent(struct yaffs_obj *obj) { struct yaffs_dev *dev; - if(!obj) + if (!obj) return; dev = obj->my_dev; obj->dirty = 1; - yaffs_load_current_time(obj,0,1); - if(dev->param.defered_dir_update){ - struct list_head *link = &obj->variant.dir_variant.dirty; - - if(list_empty(link)){ - list_add(link,&dev->dirty_dirs); - T(YAFFS_TRACE_BACKGROUND, - (TSTR("Added object %d to dirty directories" TENDSTR), - obj->obj_id)); + yaffs_load_current_time(obj, 0, 1); + if (dev->param.defered_dir_update) { + struct list_head *link = &obj->variant.dir_variant.dirty; + + if (list_empty(link)) { + list_add(link, &dev->dirty_dirs); + T(YAFFS_TRACE_BACKGROUND, + (TSTR("Added object %d to dirty directories" TENDSTR), + obj->obj_id)); } } else @@ -4270,17 +4261,18 @@ void yaffs_update_dirty_dirs(struct yaffs_dev *dev) T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR))); - while(!list_empty(&dev->dirty_dirs)){ + while (!list_empty(&dev->dirty_dirs)) { link = dev->dirty_dirs.next; list_del_init(link); - - d_s=list_entry(link,struct yaffs_dir_var,dirty); - o_v = list_entry(d_s,union yaffs_obj_var,dir_variant); - obj = list_entry(o_v,struct yaffs_obj,variant); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id)); + d_s = list_entry(link, struct yaffs_dir_var, dirty); + o_v = list_entry(d_s, union yaffs_obj_var, dir_variant); + obj = list_entry(o_v, struct yaffs_obj, variant); + + T(YAFFS_TRACE_BACKGROUND, + (TSTR("Update directory %d" TENDSTR), obj->obj_id)); - if(obj->dirty) + if (obj->dirty) yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } } @@ -4298,15 +4290,13 @@ static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj) if (dev && dev->param.remove_obj_fn) dev->param.remove_obj_fn(obj); - list_del_init(&obj->siblings); obj->parent = NULL; - + yaffs_verify_dir(parent); } -void yaffs_add_obj_to_dir(struct yaffs_obj *directory, - struct yaffs_obj *obj) +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj) { if (!directory) { T(YAFFS_TRACE_ALWAYS, @@ -4329,18 +4319,16 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory, YBUG(); } - yaffs_verify_dir(directory); yaffs_remove_obj_from_dir(obj); - /* Now add it */ list_add(&obj->siblings, &directory->variant.dir_variant.children); obj->parent = directory; if (directory == obj->my_dev->unlinked_dir - || directory == obj->my_dev->del_dir) { + || directory == obj->my_dev->del_dir) { obj->unlinked = 1; obj->my_dev->n_unlinked_files++; obj->rename_allowed = 0; @@ -4351,7 +4339,7 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory, } struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, - const YCHAR *name) + const YCHAR * name) { int sum; @@ -4373,8 +4361,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, } if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); + (TSTR("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); YBUG(); } @@ -4391,15 +4378,18 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, /* Special case for lost-n-found */ if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { - if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) + if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == + 0) return l; - } else if (yaffs_sum_cmp(l->sum, sum) || l->hdr_chunk <= 0) { + } else if (yaffs_sum_cmp(l->sum, sum) + || l->hdr_chunk <= 0) { /* LostnFound chunk called Objxxx * Do a real check */ yaffs_get_obj_name(l, buffer, - YAFFS_MAX_NAME_LENGTH + 1); - if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) + YAFFS_MAX_NAME_LENGTH + 1); + if (yaffs_strncmp + (name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) return l; } } @@ -4408,7 +4398,6 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, return NULL; } - /* GetEquivalentObject dereferences any hard links to get to the * actual object. */ @@ -4442,128 +4431,130 @@ struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj) * starting at oh->name[1]. */ -static void yaffs_fix_null_name(struct yaffs_obj * obj,YCHAR * name, int buffer_size) +static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name, + int buffer_size) { /* Create an object name if we could not find one. */ - if(yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH) == 0){ + if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) { YCHAR local_name[20]; YCHAR num_string[20]; YCHAR *x = &num_string[19]; unsigned v = obj->obj_id; num_string[19] = 0; - while(v>0){ + while (v > 0) { x--; *x = '0' + (v % 10); v /= 10; } /* make up a name */ yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX); - yaffs_strcat(local_name,x); + yaffs_strcat(local_name, x); yaffs_strncpy(name, local_name, buffer_size - 1); } } -static void yaffs_load_name_from_oh(struct yaffs_dev *dev,YCHAR *name, const YCHAR *oh_name, int buff_size) +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, + const YCHAR * oh_name, int buff_size) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - if(dev->param.auto_unicode){ - if(*oh_name){ + if (dev->param.auto_unicode) { + if (*oh_name) { /* It is an ASCII name, so do an ASCII to unicode conversion */ const char *ascii_oh_name = (const char *)oh_name; int n = buff_size - 1; - while(n > 0 && *ascii_oh_name){ + while (n > 0 && *ascii_oh_name) { *name = *ascii_oh_name; name++; ascii_oh_name++; n--; } - } else - yaffs_strncpy(name,oh_name+1, buff_size -1); + } else + yaffs_strncpy(name, oh_name + 1, buff_size - 1); } else #endif yaffs_strncpy(name, oh_name, buff_size - 1); } - -static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name, const YCHAR *name) +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, + const YCHAR * name) { #ifdef CONFIG_YAFFS_AUTO_UNICODE int is_ascii; YCHAR *w; - if(dev->param.auto_unicode){ + if (dev->param.auto_unicode) { is_ascii = 1; w = name; - + /* Figure out if the name will fit in ascii character set */ - while(is_ascii && *w){ - if((*w) & 0xff00) + while (is_ascii && *w) { + if ((*w) & 0xff00) is_ascii = 0; w++; } - if(is_ascii){ + if (is_ascii) { /* It is an ASCII name, so do a unicode to ascii conversion */ char *ascii_oh_name = (char *)oh_name; - int n = YAFFS_MAX_NAME_LENGTH - 1; - while(n > 0 && *name){ - *ascii_oh_name= *name; + int n = YAFFS_MAX_NAME_LENGTH - 1; + while (n > 0 && *name) { + *ascii_oh_name = *name; name++; ascii_oh_name++; n--; } - } else{ + } else { /* It is a unicode name, so save starting at the second YCHAR */ *oh_name = 0; - yaffs_strncpy(oh_name+1,name, YAFFS_MAX_NAME_LENGTH -2); + yaffs_strncpy(oh_name + 1, name, + YAFFS_MAX_NAME_LENGTH - 2); } - } - else + } else #endif - yaffs_strncpy(oh_name,name, YAFFS_MAX_NAME_LENGTH - 1); + yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1); } -int yaffs_get_obj_name(struct yaffs_obj * obj, YCHAR * name, int buffer_size) +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size) { memset(name, 0, buffer_size * sizeof(YCHAR)); - + yaffs_check_obj_details_loaded(obj); if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); - } + } #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM else if (obj->short_name[0]) { yaffs_strcpy(name, obj->short_name); } #endif - else if(obj->hdr_chunk > 0) { + else if (obj->hdr_chunk > 0) { int result; u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__); - struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *) buffer; + struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer; memset(buffer, 0, obj->my_dev->data_bytes_per_chunk); if (obj->hdr_chunk > 0) { result = yaffs_rd_chunk_tags_nand(obj->my_dev, - obj->hdr_chunk, buffer, - NULL); + obj->hdr_chunk, + buffer, NULL); } - yaffs_load_name_from_oh(obj->my_dev,name,oh->name,buffer_size); + yaffs_load_name_from_oh(obj->my_dev, name, oh->name, + buffer_size); yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__); } - yaffs_fix_null_name(obj,name,buffer_size); + yaffs_fix_null_name(obj, name, buffer_size); - return yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH); + return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH); } - int yaffs_get_obj_length(struct yaffs_obj *obj) { /* Dereference any hard linking */ @@ -4571,10 +4562,11 @@ int yaffs_get_obj_length(struct yaffs_obj *obj) if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) return obj->variant.file_variant.file_size; - if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){ - if(!obj->variant.symlink_variant.alias) + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + if (!obj->variant.symlink_variant.alias) return 0; - return yaffs_strnlen(obj->variant.symlink_variant.alias,YAFFS_MAX_ALIAS_LENGTH); + return yaffs_strnlen(obj->variant.symlink_variant.alias, + YAFFS_MAX_ALIAS_LENGTH); } else { /* Only a directory should drop through to here */ return obj->my_dev->data_bytes_per_chunk; @@ -4587,10 +4579,10 @@ int yaffs_get_obj_link_count(struct yaffs_obj *obj) struct list_head *i; if (!obj->unlinked) - count++; /* the object itself */ + count++; /* the object itself */ list_for_each(i, &obj->hard_links) - count++; /* add the hard links; */ + count++; /* add the hard links; */ return count; } @@ -4643,7 +4635,9 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj) return yaffs_clone_str(_Y("")); } -static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *name, const void *value, int size, int flags) +static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, + const YCHAR * name, const void *value, int size, + int flags) { struct yaffs_xattr_mod xmod; @@ -4652,29 +4646,32 @@ static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *nam xmod.set = set; xmod.name = name; xmod.data = value; - xmod.size = size; + xmod.size = size; xmod.flags = flags; xmod.result = -ENOSPC; result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod); - if(result > 0) + if (result > 0) return xmod.result; else return -ENOSPC; } -static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod) +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod) { int retval = 0; int x_offs = sizeof(struct yaffs_obj_hdr); struct yaffs_dev *dev = obj->my_dev; int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char * x_buffer = buffer + x_offs; + char *x_buffer = buffer + x_offs; - if(xmod->set) - retval = nval_set(x_buffer, x_size, xmod->name, xmod->data, xmod->size, xmod->flags); + if (xmod->set) + retval = + nval_set(x_buffer, x_size, xmod->name, xmod->data, + xmod->size, xmod->flags); else retval = nval_del(x_buffer, x_size, xmod->name); @@ -4686,7 +4683,8 @@ static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct y return retval; } -static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, void *value, int size) +static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name, + void *value, int size) { char *buffer = NULL; int result; @@ -4695,66 +4693,69 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, void int x_offs = sizeof(struct yaffs_obj_hdr); int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char * x_buffer; + char *x_buffer; int retval = 0; - if(obj->hdr_chunk < 1) + if (obj->hdr_chunk < 1) return -ENODATA; /* If we know that the object has no xattribs then don't do all the * reading and parsing. */ - if(obj->xattr_known && !obj->has_xattr){ - if(name) + if (obj->xattr_known && !obj->has_xattr) { + if (name) return -ENODATA; else return 0; } - buffer = (char *) yaffs_get_temp_buffer(dev, __LINE__); - if(!buffer) + buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__); + if (!buffer) return -ENOMEM; - result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (u8 *)buffer, &tags); + result = + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags); - if(result != YAFFS_OK) + if (result != YAFFS_OK) retval = -ENOENT; - else{ - x_buffer = buffer + x_offs; + else { + x_buffer = buffer + x_offs; - if (!obj->xattr_known){ + if (!obj->xattr_known) { obj->has_xattr = nval_hasvalues(x_buffer, x_size); obj->xattr_known = 1; } - if(name) + if (name) retval = nval_get(x_buffer, x_size, name, value, size); else - retval = nval_list(x_buffer, x_size, value,size); + retval = nval_list(x_buffer, x_size, value, size); } - yaffs_release_temp_buffer(dev,(u8 *)buffer,__LINE__); + yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__); return retval; } -int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, const void * value, int size, int flags) +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags) { return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags); } -int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name) +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name) { return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0); } -int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, int size) +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size) { return yaffs_do_xattrib_fetch(obj, name, value, size); } int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size) { - return yaffs_do_xattrib_fetch(obj, NULL, buffer,size); + return yaffs_do_xattrib_fetch(obj, NULL, buffer, size); } /*---------------------------- Initialisation code -------------------------------------- */ @@ -4773,8 +4774,7 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev) dev->param.read_chunk_tags_fn && !dev->param.write_chunk_fn && !dev->param.read_chunk_fn && - dev->param.bad_block_fn && - dev->param.query_block_fn) + dev->param.bad_block_fn && dev->param.query_block_fn) return 1; #endif @@ -4784,19 +4784,17 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev) !dev->param.read_chunk_tags_fn && dev->param.write_chunk_fn && dev->param.read_chunk_fn && - !dev->param.bad_block_fn && - !dev->param.query_block_fn) + !dev->param.bad_block_fn && !dev->param.query_block_fn) return 1; - return 0; /* bad */ + return 0; /* bad */ } - static int yaffs_create_initial_dir(struct yaffs_dev *dev) { /* Initialise the unlinked, deleted, root and lost and found directories */ - dev->lost_n_found = dev->root_dir = NULL; + dev->lost_n_found = dev->root_dir = NULL; dev->unlinked_dir = dev->del_dir = NULL; dev->unlinked_dir = @@ -4807,12 +4805,13 @@ static int yaffs_create_initial_dir(struct yaffs_dev *dev) dev->root_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, - YAFFS_ROOT_MODE | S_IFDIR); + YAFFS_ROOT_MODE | S_IFDIR); dev->lost_n_found = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND, - YAFFS_LOSTNFOUND_MODE | S_IFDIR); + YAFFS_LOSTNFOUND_MODE | S_IFDIR); - if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir && dev->del_dir) { + if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir + && dev->del_dir) { yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); return YAFFS_OK; } @@ -4826,7 +4825,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) unsigned x; int bits; - T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR))); + T(YAFFS_TRACE_TRACING, + (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR))); /* Check stuff that must be set */ @@ -4852,18 +4852,12 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) /* Check geometry parameters. */ - if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || - (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || - (dev->param.inband_tags && !dev->param.is_yaffs2) || - dev->param.chunks_per_block < 2 || - dev->param.n_reserved_blocks < 2 || - dev->internal_start_block <= 0 || - dev->internal_end_block <= 0 || - dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ + if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || (dev->param.inband_tags && !dev->param.is_yaffs2) || dev->param.chunks_per_block < 2 || dev->param.n_reserved_blocks < 2 || dev->internal_start_block <= 0 || dev->internal_end_block <= 0 || dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ T(YAFFS_TRACE_ALWAYS, (TSTR ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d " - TENDSTR), dev->param.total_bytes_per_chunk, dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); + TENDSTR), dev->param.total_bytes_per_chunk, + dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); return YAFFS_FAIL; } @@ -4875,7 +4869,9 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) /* Sort out space for inband tags, if required */ if (dev->param.inband_tags) - dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(struct yaffs_packed_tags2_tags_only); + dev->data_bytes_per_chunk = + dev->param.total_bytes_per_chunk - + sizeof(struct yaffs_packed_tags2_tags_only); else dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk; @@ -4910,7 +4906,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) x >>= dev->chunk_shift; dev->chunk_div = x; /* We only use chunk mask if chunk_div is 1 */ - dev->chunk_mask = (1<chunk_shift) - 1; + dev->chunk_mask = (1 << dev->chunk_shift) - 1; /* * Calculate chunk_grp_bits. @@ -4933,7 +4929,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) } else dev->tnode_width = 16; - dev->tnode_mask = (1<tnode_width)-1; + dev->tnode_mask = (1 << dev->tnode_width) - 1; /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled), * so if the bitwidth of the @@ -4946,8 +4942,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) else dev->chunk_grp_bits = bits - dev->tnode_width; - dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8; - if(dev->tnode_size < sizeof(struct yaffs_tnode)) + dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8; + if (dev->tnode_size < sizeof(struct yaffs_tnode)) dev->tnode_size = sizeof(struct yaffs_tnode); dev->chunk_grp_size = 1 << dev->chunk_grp_bits; @@ -4982,8 +4978,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) dev->n_tags_ecc_unfixed = 0; dev->n_erase_failures = 0; dev->n_erased_blocks = 0; - dev->gc_disable= 0; - dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ + dev->gc_disable = 0; + dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ INIT_LIST_HEAD(&dev->dirty_dirs); dev->oldest_dirty_seq = 0; dev->oldest_dirty_block = 0; @@ -4995,17 +4991,16 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) dev->cache = NULL; dev->gc_cleanup_list = NULL; - - if (!init_failed && - dev->param.n_caches > 0) { + if (!init_failed && dev->param.n_caches > 0) { int i; void *buf; - int cache_bytes = dev->param.n_caches * sizeof(struct yaffs_cache); + int cache_bytes = + dev->param.n_caches * sizeof(struct yaffs_cache); if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES) dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES; - dev->cache = YMALLOC(cache_bytes); + dev->cache = YMALLOC(cache_bytes); buf = (u8 *) dev->cache; @@ -5016,7 +5011,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) dev->cache[i].object = NULL; dev->cache[i].last_use = 0; dev->cache[i].dirty = 0; - dev->cache[i].data = buf = YMALLOC_DMA(dev->param.total_bytes_per_chunk); + dev->cache[i].data = buf = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); } if (!buf) init_failed = 1; @@ -5027,7 +5023,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) dev->cache_hits = 0; if (!init_failed) { - dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(u32)); + dev->gc_cleanup_list = + YMALLOC(dev->param.chunks_per_block * sizeof(u32)); if (!dev->gc_cleanup_list) init_failed = 1; } @@ -5043,14 +5040,15 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) if (!init_failed && !yaffs_create_initial_dir(dev)) init_failed = 1; - if (!init_failed) { /* Now scan the flash. */ if (dev->param.is_yaffs2) { if (yaffs2_checkpt_restore(dev)) { yaffs_check_obj_details_loaded(dev->root_dir); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: restored from checkpoint" TENDSTR))); + (TSTR + ("yaffs: restored from checkpoint" + TENDSTR))); } else { /* Clean up the mess caused by an aborted checkpoint load @@ -5073,18 +5071,19 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) yaffs_init_tnodes_and_objs(dev); - if (!init_failed && !yaffs_create_initial_dir(dev)) + if (!init_failed + && !yaffs_create_initial_dir(dev)) init_failed = 1; if (!init_failed && !yaffs2_scan_backwards(dev)) init_failed = 1; } } else if (!yaffs1_scan(dev)) - init_failed = 1; + init_failed = 1; yaffs_strip_deleted_objs(dev); yaffs_fix_hanging_objs(dev); - if(dev->param.empty_lost_n_found) + if (dev->param.empty_lost_n_found) yaffs_empty_l_n_f(dev); } @@ -5110,7 +5109,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) yaffs_verify_blocks(dev); /* Clean up any aborted checkpoint data */ - if(!dev->is_checkpointed && dev->blocks_in_checkpt > 0) + if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0) yaffs2_checkpt_invalidate(dev); T(YAFFS_TRACE_TRACING, @@ -5126,8 +5125,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev) yaffs_deinit_blocks(dev); yaffs_deinit_tnodes_and_objs(dev); - if (dev->param.n_caches > 0 && - dev->cache) { + if (dev->param.n_caches > 0 && dev->cache) { for (i = 0; i < dev->param.n_caches; i++) { if (dev->cache[i].data) @@ -5153,7 +5151,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev) int yaffs_count_free_chunks(struct yaffs_dev *dev) { - int n_free=0; + int n_free = 0; int b; struct yaffs_block_info *blk; @@ -5199,7 +5197,8 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev) n_free -= n_dirty_caches; - n_free -= ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); + n_free -= + ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); /* Now we figure out how much to reserve for the checkpoint and report that... */ blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev); diff --git a/yaffs_guts.h b/yaffs_guts.h index fe6e934..60770ca 100644 --- a/yaffs_guts.h +++ b/yaffs_guts.h @@ -51,14 +51,12 @@ #define YAFFS_MAX_CHUNK_ID 0x000FFFFF - #define YAFFS_ALLOCATION_NOBJECTS 100 #define YAFFS_ALLOCATION_NTNODES 100 #define YAFFS_ALLOCATION_NLINKS 100 #define YAFFS_NOBJECT_BUCKETS 256 - #define YAFFS_OBJECT_SPACE 0x40000 #define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE -1) @@ -85,7 +83,6 @@ #define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 #define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 - #define YAFFS_MAX_SHORT_OP_CACHES 20 #define YAFFS_N_TEMP_BUFFERS 6 @@ -118,9 +115,7 @@ struct yaffs_cache { int n_bytes; /* Only valid if the cache is dirty */ int locked; /* Can't push out or flush while locked. */ u8 *data; -} ; - - +}; /* Tags structures in RAM * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise @@ -137,10 +132,10 @@ struct yaffs_tags { unsigned n_bytes_msb:2; }; -union yaffs_tags_union{ +union yaffs_tags_union { struct yaffs_tags as_tags; u8 as_bytes[8]; -} ; +}; #endif @@ -151,7 +146,7 @@ enum yaffs_ecc_result { YAFFS_ECC_RESULT_NO_ERROR, YAFFS_ECC_RESULT_FIXED, YAFFS_ECC_RESULT_UNFIXED -} ; +}; enum yaffs_obj_type { YAFFS_OBJECT_TYPE_UNKNOWN, @@ -160,11 +155,11 @@ enum yaffs_obj_type { YAFFS_OBJECT_TYPE_DIRECTORY, YAFFS_OBJECT_TYPE_HARDLINK, YAFFS_OBJECT_TYPE_SPECIAL -} ; +}; #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL -struct yaffs_ext_tags{ +struct yaffs_ext_tags { unsigned validity0; unsigned chunk_used; /* Status of the chunk: used or unused */ @@ -188,11 +183,11 @@ struct yaffs_ext_tags{ unsigned extra_available; /* There is extra info available if this is not zero */ unsigned extra_parent_id; /* The parent object */ unsigned extra_is_shrink; /* Is it a shrink header? */ - unsigned extra_shadows; /* Does this shadow another object? */ + unsigned extra_shadows; /* Does this shadow another object? */ enum yaffs_obj_type extra_obj_type; /* What object type? */ - unsigned extra_length; /* Length if it is a file */ + unsigned extra_length; /* Length if it is a file */ unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */ unsigned validity1; @@ -200,12 +195,12 @@ struct yaffs_ext_tags{ }; /* Spare structure for YAFFS1 */ -struct yaffs_spare{ +struct yaffs_spare { u8 tb0; u8 tb1; u8 tb2; u8 tb3; - u8 page_status; /* set to 0 to delete the chunk */ + u8 page_status; /* set to 0 to delete the chunk */ u8 block_status; u8 tb4; u8 tb5; @@ -213,7 +208,7 @@ struct yaffs_spare{ u8 tb6; u8 tb7; u8 ecc2[3]; -} ; +}; /*Special structure for passing through to mtd */ struct yaffs_nand_spare { @@ -224,11 +219,11 @@ struct yaffs_nand_spare { /* Block data in RAM */ -enum yaffs_block_state{ +enum yaffs_block_state { YAFFS_BLOCK_STATE_UNKNOWN = 0, YAFFS_BLOCK_STATE_SCANNING, - /* Being scanned */ + /* Being scanned */ YAFFS_BLOCK_STATE_NEEDS_SCANNING, /* The block might have something on it (ie it is allocating or full, perhaps empty) @@ -246,13 +241,13 @@ enum yaffs_block_state{ * At least one page holds valid data. * This is the one currently being used for page * allocation. Should never be more than one of these. - * If a block is only partially allocated at mount it is treated as full. + * If a block is only partially allocated at mount it is treated as full. */ YAFFS_BLOCK_STATE_FULL, /* All the pages in this block have been allocated. - * If a block was only partially allocated when mounted we treat - * it as fully allocated. + * If a block was only partially allocated when mounted we treat + * it as fully allocated. */ YAFFS_BLOCK_STATE_DIRTY, @@ -267,30 +262,29 @@ enum yaffs_block_state{ /* This block is being garbage collected */ YAFFS_BLOCK_STATE_DEAD - /* This block has failed and is not in use */ + /* This block has failed and is not in use */ }; #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) - -struct yaffs_block_info{ +struct yaffs_block_info { int soft_del_pages:10; /* number of soft deleted pages */ int pages_in_use:10; /* number of pages in use */ unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */ - /* and retire the block. */ - u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ - u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. + /* and retire the block. */ + u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ + u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. It should be prioritised for GC */ - u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ + u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ #ifdef CONFIG_YAFFS_YAFFS2 - u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ - u32 seq_number; /* block sequence number for yaffs2 */ + u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ + u32 seq_number; /* block sequence number for yaffs2 */ #endif -} ; +}; /* -------------------------- Object structure -------------------------------*/ /* This is the object structure as stored on NAND */ @@ -300,11 +294,11 @@ struct yaffs_obj_hdr { /* Apply to everything */ int parent_obj_id; - u16 sum_no_longer_used; /* checksum of name. No longer used */ + u16 sum_no_longer_used; /* checksum of name. No longer used */ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; /* The following apply to directories, files, symlinks - not hard links */ - u32 yst_mode; /* protection */ + u32 yst_mode; /* protection */ u32 yst_uid; u32 yst_gid; @@ -344,8 +338,6 @@ struct yaffs_tnode { struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL]; }; - - /*------------------------ Object -----------------------------*/ /* An object can be one of: * - a directory (no data, has children links @@ -360,35 +352,33 @@ struct yaffs_file_var { u32 shrink_size; int top_level; struct yaffs_tnode *top; -} ; +}; -struct yaffs_dir_var{ - struct list_head children; /* list of child links */ +struct yaffs_dir_var { + struct list_head children; /* list of child links */ struct list_head dirty; /* Entry for list of dirty directories */ }; -struct yaffs_symlink_var{ +struct yaffs_symlink_var { YCHAR *alias; }; -struct yaffs_hardlink_var{ +struct yaffs_hardlink_var { struct yaffs_obj *equiv_obj; u32 equiv_id; }; -union yaffs_obj_var{ +union yaffs_obj_var { struct yaffs_file_var file_variant; struct yaffs_dir_var dir_variant; struct yaffs_symlink_var symlink_variant; struct yaffs_hardlink_var hardlink_variant; }; - - struct yaffs_obj { u8 deleted:1; /* This should only apply to unlinked files. */ - u8 soft_del:1; /* it has also been soft deleted */ - u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory.*/ + u8 soft_del:1; /* it has also been soft deleted */ + u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory. */ u8 fake:1; /* A fake object has no presence on NAND. */ u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */ u8 unlink_allowed:1; @@ -407,16 +397,16 @@ struct yaffs_obj { u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */ u8 xattr_known:1; /* We know if this has object has xattribs or not. */ - u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ + u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ u8 serial; /* serial number of chunk in NAND. Cached here */ u16 sum; /* sum of the name to speed searching */ - struct yaffs_dev *my_dev; /* The device I'm on */ + struct yaffs_dev *my_dev; /* The device I'm on */ - struct list_head hash_link; /* list of objects in this hash bucket */ + struct list_head hash_link; /* list of objects in this hash bucket */ - struct list_head hard_links; /* all the equivalent hard linked objects */ + struct list_head hard_links; /* all the equivalent hard linked objects */ /* directory structure stuff */ /* also used for linking up the free list */ @@ -461,14 +451,13 @@ struct yaffs_obj { struct yaffs_obj_bucket { struct list_head list; int count; -} ; - +}; /* yaffs_checkpt_obj holds the definition of an object as dumped * by checkpointing. */ -struct yaffs_checkpt_obj{ +struct yaffs_checkpt_obj { int struct_type; u32 obj_id; u32 parent_id; @@ -492,42 +481,40 @@ struct yaffs_checkpt_obj{ struct yaffs_buffer { u8 *buffer; - int line; /* track from whence this buffer was allocated */ + int line; /* track from whence this buffer was allocated */ int max_line; -} ; +}; /*----------------- Device ---------------------------------*/ - struct yaffs_param { const YCHAR *name; /* - * Entry parameters set up way early. Yaffs sets up the rest. - * The structure should be zeroed out before use so that unused - * and defualt values are zero. - */ + * Entry parameters set up way early. Yaffs sets up the rest. + * The structure should be zeroed out before use so that unused + * and defualt values are zero. + */ - int inband_tags; /* Use unband tags */ - u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ + int inband_tags; /* Use unband tags */ + u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ int chunks_per_block; /* does not need to be a power of 2 */ int spare_bytes_per_chunk; /* spare area size */ - int start_block; /* Start block we're allowed to use */ + int start_block; /* Start block we're allowed to use */ int end_block; /* End block we're allowed to use */ int n_reserved_blocks; /* We want this tuneable so that we can reduce */ - /* reserved blocks on NOR and RAM. */ + /* reserved blocks on NOR and RAM. */ - - int n_caches; /* If <= 0, then short op caching is disabled, else + int n_caches; /* If <= 0, then short op caching is disabled, else * the number of short op caches (don't use too many). - * 10 to 20 is a good bet. + * 10 to 20 is a good bet. */ - int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ - int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ + int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ + int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ - int is_yaffs2; /* Use yaffs2 mode on this device */ + int is_yaffs2; /* Use yaffs2 mode on this device */ - int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ + int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ int refresh_period; /* How often we should check to do a block refresh */ @@ -537,63 +524,62 @@ struct yaffs_param { int enable_xattr; /* Enable xattribs */ - /* NAND access functions (Must be set before calling YAFFS)*/ + /* NAND access functions (Must be set before calling YAFFS) */ - int (*write_chunk_fn) (struct yaffs_dev *dev, - int nand_chunk, const u8 *data, - const struct yaffs_spare *spare); - int (*read_chunk_fn) (struct yaffs_dev *dev, - int nand_chunk, u8 *data, - struct yaffs_spare *spare); - int (*erase_fn) (struct yaffs_dev *dev, - int flash_block); - int (*initialise_flash_fn) (struct yaffs_dev *dev); - int (*deinitialise_flash_fn) (struct yaffs_dev *dev); + int (*write_chunk_fn) (struct yaffs_dev * dev, + int nand_chunk, const u8 * data, + const struct yaffs_spare * spare); + int (*read_chunk_fn) (struct yaffs_dev * dev, + int nand_chunk, u8 * data, + struct yaffs_spare * spare); + int (*erase_fn) (struct yaffs_dev * dev, int flash_block); + int (*initialise_flash_fn) (struct yaffs_dev * dev); + int (*deinitialise_flash_fn) (struct yaffs_dev * dev); #ifdef CONFIG_YAFFS_YAFFS2 - int (*write_chunk_tags_fn) (struct yaffs_dev *dev, - int nand_chunk, const u8 *data, - const struct yaffs_ext_tags *tags); - int (*read_chunk_tags_fn) (struct yaffs_dev *dev, - int nand_chunk, u8 *data, - struct yaffs_ext_tags *tags); - int (*bad_block_fn) (struct yaffs_dev *dev, int block_no); - int (*query_block_fn) (struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state, u32 *seq_number); + int (*write_chunk_tags_fn) (struct yaffs_dev * dev, + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags * tags); + int (*read_chunk_tags_fn) (struct yaffs_dev * dev, + int nand_chunk, u8 * data, + struct yaffs_ext_tags * tags); + int (*bad_block_fn) (struct yaffs_dev * dev, int block_no); + int (*query_block_fn) (struct yaffs_dev * dev, int block_no, + enum yaffs_block_state * state, + u32 * seq_number); #endif /* The remove_obj_fn function must be supplied by OS flavours that * need it. - * yaffs direct uses it to implement the faster readdir. - * Linux uses it to protect the directory during unlocking. + * yaffs direct uses it to implement the faster readdir. + * Linux uses it to protect the directory during unlocking. */ - void (*remove_obj_fn)(struct yaffs_obj *obj); + void (*remove_obj_fn) (struct yaffs_obj * obj); /* Callback to mark the superblock dirty */ - void (*sb_dirty_fn)(struct yaffs_dev *dev); - + void (*sb_dirty_fn) (struct yaffs_dev * dev); + /* Callback to control garbage collection. */ - unsigned (*gc_control)(struct yaffs_dev *dev); + unsigned (*gc_control) (struct yaffs_dev * dev); - /* Debug control flags. Don't use unless you know what you're doing */ + /* Debug control flags. Don't use unless you know what you're doing */ int use_header_file_size; /* Flag to determine if we should use file sizes from the header */ int disable_lazy_load; /* Disable lazy loading on this device */ - int wide_tnodes_disabled; /* Set to disable wide tnodes */ - int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ - - int defered_dir_update; /* Set to defer directory updates */ + int wide_tnodes_disabled; /* Set to disable wide tnodes */ + int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ + + int defered_dir_update; /* Set to defer directory updates */ #ifdef CONFIG_YAFFS_AUTO_UNICODE int auto_unicode; #endif - int always_check_erased; /* Force chunk erased check always on */ + int always_check_erased; /* Force chunk erased check always on */ }; - struct yaffs_dev { struct yaffs_param param; - /* Context storage. Holds extra OS specific data for this device */ + /* Context storage. Holds extra OS specific data for this device */ void *os_context; void *driver_context; @@ -601,12 +587,12 @@ struct yaffs_dev { struct list_head dev_list; /* Runtime parameters. Set up by YAFFS. */ - int data_bytes_per_chunk; + int data_bytes_per_chunk; - /* Non-wide tnode stuff */ + /* Non-wide tnode stuff */ u16 chunk_grp_bits; /* Number of bits that need to be resolved if - * the tnodes are not wide enough. - */ + * the tnodes are not wide enough. + */ u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ /* Stuff to support wide tnodes */ @@ -615,26 +601,22 @@ struct yaffs_dev { u32 tnode_size; /* Stuff for figuring out file offset to chunk conversions */ - u32 chunk_shift; /* Shift value */ - u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ - u32 chunk_mask; /* Mask to use for power-of-2 case */ - - + u32 chunk_shift; /* Shift value */ + u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ + u32 chunk_mask; /* Mask to use for power-of-2 case */ int is_mounted; int read_only; int is_checkpointed; - /* Stuff to support block offsetting to support start block zero */ int internal_start_block; int internal_end_block; int block_offset; int chunk_offset; - /* Runtime checkpointing stuff */ - int checkpt_page_seq; /* running sequence number of checkpoint pages */ + int checkpt_page_seq; /* running sequence number of checkpoint pages */ int checkpt_byte_count; int checkpt_byte_offs; u8 *checkpt_buffer; @@ -648,11 +630,11 @@ struct yaffs_dev { u32 checkpt_sum; u32 checkpt_xor; - int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ + int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ /* Block Info */ struct yaffs_block_info *block_info; - u8 *chunk_bits; /* bitmap of chunks in use */ + u8 *chunk_bits; /* bitmap of chunks in use */ unsigned block_info_alt:1; /* was allocated using alternative strategy */ unsigned chunk_bits_alt:1; /* was allocated using alternative strategy */ int chunk_bit_stride; /* Number of bytes of chunk_bits per block. @@ -680,7 +662,7 @@ struct yaffs_dev { u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ u32 n_clean_ups; - unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ + unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ unsigned gc_disable; unsigned gc_block_finder; unsigned gc_dirtiest; @@ -705,12 +687,12 @@ struct yaffs_dev { struct yaffs_cache *cache; int cache_last_use; - /* Stuff for background deletion and unlinked files.*/ + /* Stuff for background deletion and unlinked files. */ struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted files live. */ struct yaffs_obj *del_dir; /* Directory where deleted objects are sent to disappear. */ - struct yaffs_obj *unlinked_deletion; /* Current file being background deleted.*/ - int n_deleted_files; /* Count of files awaiting deletion;*/ - int n_unlinked_files; /* Count of unlinked files. */ + struct yaffs_obj *unlinked_deletion; /* Current file being background deleted. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ int n_bg_deletions; /* Count of background deletions. */ /* Temporary buffer management */ @@ -729,8 +711,7 @@ struct yaffs_dev { int refresh_skip; /* A skip down counter. Refresh happens when this gets to zero. */ /* Dirty directory handling */ - struct list_head dirty_dirs; /* List of dirty directories */ - + struct list_head dirty_dirs; /* List of dirty directories */ /* Statistcs */ u32 n_page_writes; @@ -756,19 +737,18 @@ struct yaffs_dev { }; - /* The CheckpointDevice structure holds the device information that changes at runtime and * must be preserved over unmount/mount cycles. */ -struct yaffs_checkpt_dev{ +struct yaffs_checkpt_dev { int struct_type; int n_erased_blocks; int alloc_block; /* Current block being allocated off */ u32 alloc_page; int n_free_chunks; - int n_deleted_files; /* Count of files awaiting deletion;*/ - int n_unlinked_files; /* Count of unlinked files. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ int n_bg_deletions; /* Count of background deletions. */ /* yaffs2 runtime stuff */ @@ -776,15 +756,13 @@ struct yaffs_checkpt_dev{ }; - -struct yaffs_checkpt_validity{ +struct yaffs_checkpt_validity { int struct_type; u32 magic; u32 version; u32 head; }; - struct yaffs_shadow_fixer { int obj_id; int shadowed_id; @@ -792,8 +770,8 @@ struct yaffs_shadow_fixer { }; /* Structure for doing xattr modifications */ -struct yaffs_xattr_mod{ - int set; /* If 0 then this is a deletion */ +struct yaffs_xattr_mod { + int set; /* If 0 then this is a deletion */ const YCHAR *name; const void *data; int size; @@ -801,7 +779,6 @@ struct yaffs_xattr_mod{ int result; }; - /*----------------------- YAFFS Functions -----------------------*/ int yaffs_guts_initialise(struct yaffs_dev *dev); @@ -809,27 +786,28 @@ void yaffs_deinitialise(struct yaffs_dev *dev); int yaffs_get_n_free_chunks(struct yaffs_dev *dev); -int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, - struct yaffs_obj *new_dir, const YCHAR *new_name); +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name); -int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name); +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); int yaffs_del_obj(struct yaffs_obj *obj); -int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size); +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); int yaffs_get_obj_length(struct yaffs_obj *obj); int yaffs_get_obj_inode(struct yaffs_obj *obj); unsigned yaffs_get_obj_type(struct yaffs_obj *obj); int yaffs_get_obj_link_count(struct yaffs_obj *obj); /* File operations */ -int yaffs_file_rd(struct yaffs_obj *obj, u8 *buffer, loff_t offset, - int n_bytes); -int yaffs_wr_file(struct yaffs_obj *obj, const u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough); +int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, + int n_bytes); +int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); -struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid); +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid); int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync); @@ -840,32 +818,35 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev); int yaffs_checkpoint_restore(struct yaffs_dev *dev); /* Directory operations */ -struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid); -struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, const YCHAR *name); +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, + u32 mode, u32 uid, u32 gid); +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, + const YCHAR * name); struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); /* Link operations */ -struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, - struct yaffs_obj *equiv_obj); +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj); struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); /* Symlink operations */ -struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid, - const YCHAR *alias); +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, const YCHAR * alias); YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); /* Special inodes (fifos, sockets and devices) */ -struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, const YCHAR *name, - u32 mode, u32 uid, u32 gid, u32 rdev); - - -int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, const void * value, int size, int flags); -int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, int size); +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, u32 rdev); + +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags); +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size); int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); -int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name); +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name); /* Special directories */ struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); @@ -883,49 +864,51 @@ int yaffs_dump_obj(struct yaffs_obj *obj); void yaffs_guts_test(struct yaffs_dev *dev); /* A few useful functions to be used within the core files*/ -void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int lyn); -int yaffs_check_ff(u8 *buffer, int n_bytes); -void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi); +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn); +int yaffs_check_ff(u8 * buffer, int n_bytes); +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi); u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no); -void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no); +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no); struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, - int number, - enum yaffs_obj_type type); + int number, + enum yaffs_obj_type type); int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, - int nand_chunk, int in_scan); -void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name); + int nand_chunk, int in_scan); +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name); void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, - const struct yaffs_obj_hdr *oh); -void yaffs_add_obj_to_dir(struct yaffs_obj *directory, - struct yaffs_obj *obj); -YCHAR *yaffs_clone_str(const YCHAR *str); + const struct yaffs_obj_hdr *oh); +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); +YCHAR *yaffs_clone_str(const YCHAR * str); void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list); void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); -int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, - int force, int is_shrink, int shadows, - struct yaffs_xattr_mod *xop); +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, + int force, int is_shrink, int shadows, + struct yaffs_xattr_mod *xop); void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, - int backward_scanning); + int backward_scanning); int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, - struct yaffs_file_var *file_struct, - u32 chunk_id, - struct yaffs_tnode *passed_tn); + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn); -int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough); -void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size); +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); void yaffs_skip_rest_of_block(struct yaffs_dev *dev); int yaffs_count_free_chunks(struct yaffs_dev *dev); struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, - struct yaffs_file_var *file_struct, - u32 chunk_id); + struct yaffs_file_var *file_struct, + u32 chunk_id); -u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos); +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos); #endif diff --git a/yaffs_linux.h b/yaffs_linux.h index 9c463a9..84d1ce8 100644 --- a/yaffs_linux.h +++ b/yaffs_linux.h @@ -19,17 +19,17 @@ #include "yportenv.h" struct yaffs_linux_context { - struct list_head context_list; /* List of these we have mounted */ + struct list_head context_list; /* List of these we have mounted */ struct yaffs_dev *dev; - struct super_block * super; - struct task_struct *bg_thread; /* Background thread for this device */ + struct super_block *super; + struct task_struct *bg_thread; /* Background thread for this device */ int bg_running; - struct semaphore gross_lock; /* Gross locking semaphore */ - u8 *spare_buffer; /* For mtdif2 use. Don't know the size of the buffer + struct semaphore gross_lock; /* Gross locking semaphore */ + u8 *spare_buffer; /* For mtdif2 use. Don't know the size of the buffer * at compile time so we have to allocate it. */ struct list_head search_contexts; - void (*put_super_fn)(struct super_block *sb); + void (*put_super_fn) (struct super_block * sb); struct task_struct *readdir_process; unsigned mount_id; @@ -39,4 +39,3 @@ struct yaffs_linux_context { #define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context)) #endif - diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c index cdbe428..7cf53b3 100644 --- a/yaffs_mtdif.c +++ b/yaffs_mtdif.c @@ -13,7 +13,6 @@ #include "yportenv.h" - #include "yaffs_mtdif.h" #include "linux/mtd/mtd.h" @@ -28,9 +27,9 @@ int nandmtd_erase_block(struct yaffs_dev *dev, int block_no) struct mtd_info *mtd = yaffs_dev_to_mtd(dev); u32 addr = ((loff_t) block_no) * dev->param.total_bytes_per_chunk - * dev->param.chunks_per_block; + * dev->param.chunks_per_block; struct erase_info ei; - + int retval = 0; ei.mtd = mtd; @@ -53,4 +52,3 @@ int nandmtd_initialise(struct yaffs_dev *dev) { return YAFFS_OK; } - diff --git a/yaffs_mtdif1.h b/yaffs_mtdif1.h index 4f0da74..07ce452 100644 --- a/yaffs_mtdif1.h +++ b/yaffs_mtdif1.h @@ -15,14 +15,15 @@ #define __YAFFS_MTDIF1_H__ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - const u8 *data, const struct yaffs_ext_tags *tags); + const u8 * data, + const struct yaffs_ext_tags *tags); int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - u8 *data, struct yaffs_ext_tags *tags); + u8 * data, struct yaffs_ext_tags *tags); int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no); int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state, u32 *seq_number); + enum yaffs_block_state *state, u32 * seq_number); #endif diff --git a/yaffs_mtdif1_multi.c b/yaffs_mtdif1_multi.c index ac0f00c..c3ea8c9 100644 --- a/yaffs_mtdif1_multi.c +++ b/yaffs_mtdif1_multi.c @@ -62,9 +62,9 @@ */ static struct nand_ecclayout nand_oob_16 = { .eccbytes = 6, - .eccpos = { 8, 9, 10, 13, 14, 15 }, + .eccpos = {8, 9, 10, 13, 14, 15}, .oobavail = 9, - .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } } + .oobfree = {{0, 4}, {6, 2}, {11, 2}, {4, 1}} }; #endif @@ -90,11 +90,12 @@ static struct nand_ecclayout nand_oob_16 = { * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, - int nand_chunk, const u8 *data, const struct yaffs_ext_tags *etags) + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; - loff_t addr = ((loff_t)nand_chunk) * chunk_bytes; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; struct mtd_oob_ops ops; struct yaffs_packed_tags1 pt1; int retval; @@ -119,11 +120,11 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, pt1.deleted = 0; } #else - ((u8 *)&pt1)[8] = 0xff; + ((u8 *) & pt1)[8] = 0xff; if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* zero page_status byte to indicate deleted */ - ((u8 *)&pt1)[8] = 0; + ((u8 *) & pt1)[8] = 0; } #endif @@ -131,14 +132,14 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, ops.mode = MTD_OOB_AUTO; ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; - ops.datbuf = (u8 *)data; - ops.oobbuf = (u8 *)&pt1; + ops.datbuf = (u8 *) data; + ops.oobbuf = (u8 *) & pt1; retval = mtd->write_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR), - nand_chunk, retval)); + (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } return retval ? YAFFS_FAIL : YAFFS_OK; } @@ -168,11 +169,12 @@ static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval) * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, - int nand_chunk, u8 *data, struct yaffs_ext_tags *etags) + int nand_chunk, u8 * data, + struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; - loff_t addr = ((loff_t)nand_chunk) * chunk_bytes; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; int eccres = YAFFS_ECC_RESULT_NO_ERROR; struct mtd_oob_ops ops; struct yaffs_packed_tags1 pt1; @@ -184,7 +186,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; ops.datbuf = data; - ops.oobbuf = (u8 *)&pt1; + ops.oobbuf = (u8 *) & pt1; #if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20)) /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug; @@ -198,8 +200,8 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, retval = mtd->read_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR), - nand_chunk, retval)); + (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } switch (retval) { @@ -219,17 +221,16 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, /* fall into... */ default: rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); - etags->block_bad = (mtd->block_isbad)(mtd, addr); + etags->block_bad = (mtd->block_isbad) (mtd, addr); return YAFFS_FAIL; } /* Check for a blank/erased chunk. */ - if (yaffs_check_ff((u8 *)&pt1, 8)) { + if (yaffs_check_ff((u8 *) & pt1, 8)) { /* when blank, upper layers want ecc_result to be <= NO_ERROR */ return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); } - #ifndef CONFIG_YAFFS_9BYTE_TAGS /* Read deleted status (bit) then return it to it's non-deleted * state before performing tags mini-ECC check. pt1.deleted is @@ -238,7 +239,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, deleted = !pt1.deleted; pt1.deleted = 1; #else - deleted = (yaffs_count_bits(((u8 *)&pt1)[8]) < 7); + deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7); #endif /* Check the packed tags mini-ECC and correct if necessary/possible. @@ -285,9 +286,10 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no) int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; - T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no)); + T(YAFFS_TRACE_BAD_BLOCKS, + (TSTR("marking block %d bad" TENDSTR), block_no)); - retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no); + retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; } @@ -303,8 +305,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd) if (oobavail < YTAG1_SIZE) { T(YAFFS_TRACE_ERROR, - (TSTR("mtd device has only %d bytes for tags, need %d"TENDSTR), - oobavail, YTAG1_SIZE)); + (TSTR + ("mtd device has only %d bytes for tags, need %d" TENDSTR), + oobavail, YTAG1_SIZE)); return YAFFS_FAIL; } return YAFFS_OK; @@ -320,11 +323,11 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd) * Always returns YAFFS_OK. */ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state_ptr, u32 *seq_ptr) + enum yaffs_block_state *state_ptr, u32 * seq_ptr) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_num = block_no * dev->param.chunks_per_block; - loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk; + loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk; struct yaffs_ext_tags etags; int state = YAFFS_BLOCK_STATE_DEAD; int seqnum = 0; @@ -337,10 +340,10 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, return YAFFS_FAIL; retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags); - etags.block_bad = (mtd->block_isbad)(mtd, addr); + etags.block_bad = (mtd->block_isbad) (mtd, addr); if (etags.block_bad) { T(YAFFS_TRACE_BAD_BLOCKS, - (TSTR("block %d is marked bad"TENDSTR), block_no)); + (TSTR("block %d is marked bad" TENDSTR), block_no)); state = YAFFS_BLOCK_STATE_DEAD; } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { /* bad tags, need to look more closely */ @@ -359,4 +362,4 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, return YAFFS_OK; } -#endif /*MTD_VERSION*/ +#endif /*MTD_VERSION */ diff --git a/yaffs_mtdif1_single.c b/yaffs_mtdif1_single.c index 02281fd..a0bc04f 100644 --- a/yaffs_mtdif1_single.c +++ b/yaffs_mtdif1_single.c @@ -42,7 +42,6 @@ # define YTAG1_SIZE 9 #endif - /* Write a chunk (page) of data to NAND. * * Caller always provides ExtendedTags data which are converted to a more @@ -65,11 +64,12 @@ * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, - int nand_chunk, const u8 *data, const struct yaffs_ext_tags *etags) + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; - loff_t addr = ((loff_t)nand_chunk) * chunk_bytes; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; struct mtd_oob_ops ops; struct yaffs_packed_tags1 pt1; int retval; @@ -94,11 +94,11 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, pt1.deleted = 0; } #else - ((u8 *)&pt1)[8] = 0xff; + ((u8 *) & pt1)[8] = 0xff; if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* zero page_status byte to indicate deleted */ - ((u8 *)&pt1)[8] = 0; + ((u8 *) & pt1)[8] = 0; } #endif @@ -106,14 +106,14 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, ops.mode = MTD_OOB_AUTO; ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; - ops.datbuf = (u8 *)data; - ops.oobbuf = (u8 *)&pt1; + ops.datbuf = (u8 *) data; + ops.oobbuf = (u8 *) & pt1; retval = mtd->write_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR), - nand_chunk, retval)); + (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } return retval ? YAFFS_FAIL : YAFFS_OK; } @@ -143,11 +143,12 @@ static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval) * Returns YAFFS_OK or YAFFS_FAIL. */ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, - int nand_chunk, u8 *data, struct yaffs_ext_tags *etags) + int nand_chunk, u8 * data, + struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; - loff_t addr = ((loff_t)nand_chunk) * chunk_bytes; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; int eccres = YAFFS_ECC_RESULT_NO_ERROR; struct mtd_oob_ops ops; struct yaffs_packed_tags1 pt1; @@ -159,7 +160,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; ops.datbuf = data; - ops.oobbuf = (u8 *)&pt1; + ops.oobbuf = (u8 *) & pt1; /* Read page and oob using MTD. * Check status and determine ECC result. @@ -167,8 +168,8 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, retval = mtd->read_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR), - nand_chunk, retval)); + (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } switch (retval) { @@ -188,17 +189,16 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, /* fall into... */ default: rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); - etags->block_bad = (mtd->block_isbad)(mtd, addr); + etags->block_bad = (mtd->block_isbad) (mtd, addr); return YAFFS_FAIL; } /* Check for a blank/erased chunk. */ - if (yaffs_check_ff((u8 *)&pt1, 8)) { + if (yaffs_check_ff((u8 *) & pt1, 8)) { /* when blank, upper layers want ecc_result to be <= NO_ERROR */ return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); } - #ifndef CONFIG_YAFFS_9BYTE_TAGS /* Read deleted status (bit) then return it to it's non-deleted * state before performing tags mini-ECC check. pt1.deleted is @@ -207,7 +207,7 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, deleted = !pt1.deleted; pt1.deleted = 1; #else - deleted = (yaffs_count_bits(((u8 *)&pt1)[8]) < 7); + deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7); #endif /* Check the packed tags mini-ECC and correct if necessary/possible. @@ -254,9 +254,10 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no) int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; - T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no)); + T(YAFFS_TRACE_BAD_BLOCKS, + (TSTR("marking block %d bad" TENDSTR), block_no)); - retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no); + retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; } @@ -272,8 +273,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd) if (oobavail < YTAG1_SIZE) { T(YAFFS_TRACE_ERROR, - (TSTR("mtd device has only %d bytes for tags, need %d"TENDSTR), - oobavail, YTAG1_SIZE)); + (TSTR + ("mtd device has only %d bytes for tags, need %d" TENDSTR), + oobavail, YTAG1_SIZE)); return YAFFS_FAIL; } return YAFFS_OK; @@ -289,11 +291,11 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd) * Always returns YAFFS_OK. */ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state_ptr, u32 *seq_ptr) + enum yaffs_block_state *state_ptr, u32 * seq_ptr) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_num = block_no * dev->param.chunks_per_block; - loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk; + loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk; struct yaffs_ext_tags etags; int state = YAFFS_BLOCK_STATE_DEAD; int seqnum = 0; @@ -306,10 +308,10 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, return YAFFS_FAIL; retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags); - etags.block_bad = (mtd->block_isbad)(mtd, addr); + etags.block_bad = (mtd->block_isbad) (mtd, addr); if (etags.block_bad) { T(YAFFS_TRACE_BAD_BLOCKS, - (TSTR("block %d is marked bad"TENDSTR), block_no)); + (TSTR("block %d is marked bad" TENDSTR), block_no)); state = YAFFS_BLOCK_STATE_DEAD; } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { /* bad tags, need to look more closely */ diff --git a/yaffs_mtdif2.h b/yaffs_mtdif2.h index e9759ff..d821126 100644 --- a/yaffs_mtdif2.h +++ b/yaffs_mtdif2.h @@ -18,12 +18,12 @@ #include "yaffs_guts.h" int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *tags); + const u8 * data, + const struct yaffs_ext_tags *tags); int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - u8 *data, struct yaffs_ext_tags *tags); + u8 * data, struct yaffs_ext_tags *tags); int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no); int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state, u32 *seq_number); + enum yaffs_block_state *state, u32 * seq_number); #endif diff --git a/yaffs_mtdif2_multi.c b/yaffs_mtdif2_multi.c index 04fb39d..555f937 100644 --- a/yaffs_mtdif2_multi.c +++ b/yaffs_mtdif2_multi.c @@ -31,8 +31,8 @@ * use it to load the tags. */ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *tags) + const u8 * data, + const struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) @@ -46,16 +46,17 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_write_chunk_tags chunk %d data %p tags %p" TENDSTR), nand_chunk, data, tags)); - - addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into @@ -65,7 +66,10 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, BUG(); else if (dev->param.inband_tags) { struct yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk); + pt2tp = + (struct yaffs_packed_tags2_tags_only *)(data + + dev-> + data_bytes_per_chunk); yaffs_pack_tags2_tags_only(pt2tp, tags); } else yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); @@ -75,7 +79,7 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; - ops.datbuf = (u8 *)data; + ops.datbuf = (u8 *) data; ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); @@ -86,8 +90,8 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, &dummy, data, (u8 *) packed_tags_ptr, NULL); } else { retval = - mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, &dummy, - data); + mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, + &dummy, data); } #endif @@ -98,7 +102,7 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, } int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - u8 *data, struct yaffs_ext_tags *tags) + u8 * data, struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) @@ -112,8 +116,10 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR @@ -127,14 +133,12 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, data = yaffs_get_temp_buffer(dev, __LINE__); } - } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) if (dev->param.inband_tags || (data && !tags)) retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, - &dummy, data); + &dummy, data); else if (tags) { ops.mode = MTD_OOB_AUTO; ops.ooblen = packed_tags_size; @@ -148,13 +152,12 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, if (!dev->param.inband_tags && data && tags) { retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk, - &dummy, data, dev->spare_buffer, - NULL); + &dummy, data, dev->spare_buffer, NULL); } else { if (data) retval = - mtd->read(mtd, addr, dev->data_bytes_per_chunk, &dummy, - data); + mtd->read(mtd, addr, dev->data_bytes_per_chunk, + &dummy, data); if (!dev->param.inband_tags && tags) retval = mtd->read_oob(mtd, addr, mtd->oobsize, &dummy, @@ -162,16 +165,19 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, } #endif - if (dev->param.inband_tags) { if (tags) { struct yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)&data[dev-> + data_bytes_per_chunk]; yaffs_unpack_tags2_tags_only(tags, pt2tp); } } else { if (tags) { - memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size); + memcpy(packed_tags_ptr, + yaffs_dev_to_lc(dev)->spare_buffer, + packed_tags_size); yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); } } @@ -179,11 +185,13 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, if (local_data) yaffs_release_temp_buffer(dev, data, __LINE__); - if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + if (tags && retval == -EBADMSG + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; dev->n_ecc_unfixed++; } - if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + if (tags && retval == -EUCLEAN + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { tags->ecc_result = YAFFS_ECC_RESULT_FIXED; dev->n_ecc_fixed++; } @@ -213,13 +221,12 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no) } int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state, u32 *seq_number) + enum yaffs_block_state *state, u32 * seq_number) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; - T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); + T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, block_no * dev->param.chunks_per_block * @@ -233,8 +240,7 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, } else { struct yaffs_ext_tags t; nandmtd2_read_chunk_tags(dev, block_no * - dev->param.chunks_per_block, NULL, - &t); + dev->param.chunks_per_block, NULL, &t); if (t.chunk_used) { *seq_number = t.seq_number; @@ -245,12 +251,10 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, } } T(YAFFS_TRACE_MTD, - (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, - *state)); + (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state)); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; } - diff --git a/yaffs_mtdif2_single.c b/yaffs_mtdif2_single.c index f5a5c10..00040cd 100644 --- a/yaffs_mtdif2_single.c +++ b/yaffs_mtdif2_single.c @@ -31,8 +31,8 @@ * use it to load the tags. */ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *tags) + const u8 * data, + const struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); struct mtd_oob_ops ops; @@ -42,16 +42,17 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_write_chunk_tags chunk %d data %p tags %p" TENDSTR), nand_chunk, data, tags)); - - addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into @@ -61,7 +62,10 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, BUG(); else if (dev->param.inband_tags) { struct yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk); + pt2tp = + (struct yaffs_packed_tags2_tags_only *)(data + + dev-> + data_bytes_per_chunk); yaffs_pack_tags2_tags_only(pt2tp, tags); } else yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); @@ -70,11 +74,10 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; - ops.datbuf = (u8 *)data; + ops.datbuf = (u8 *) data; ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); - if (retval == 0) return YAFFS_OK; else @@ -82,7 +85,7 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, } int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, - u8 *data, struct yaffs_ext_tags *tags) + u8 * data, struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); struct mtd_oob_ops ops; @@ -95,8 +98,10 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR @@ -110,13 +115,11 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, data = yaffs_get_temp_buffer(dev, __LINE__); } - } - if (dev->param.inband_tags || (data && !tags)) retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, - &dummy, data); + &dummy, data); else if (tags) { ops.mode = MTD_OOB_AUTO; ops.ooblen = packed_tags_size; @@ -130,12 +133,16 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, if (dev->param.inband_tags) { if (tags) { struct yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)&data[dev-> + data_bytes_per_chunk]; yaffs_unpack_tags2_tags_only(tags, pt2tp); } } else { if (tags) { - memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size); + memcpy(packed_tags_ptr, + yaffs_dev_to_lc(dev)->spare_buffer, + packed_tags_size); yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); } } @@ -143,11 +150,13 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, if (local_data) yaffs_release_temp_buffer(dev, data, __LINE__); - if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + if (tags && retval == -EBADMSG + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; dev->n_ecc_unfixed++; } - if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + if (tags && retval == -EUCLEAN + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { tags->ecc_result = YAFFS_ECC_RESULT_FIXED; dev->n_ecc_fixed++; } @@ -177,13 +186,12 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no) } int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, - enum yaffs_block_state *state, u32 *seq_number) + enum yaffs_block_state *state, u32 * seq_number) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; - T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); + T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, block_no * dev->param.chunks_per_block * @@ -197,8 +205,7 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, } else { struct yaffs_ext_tags t; nandmtd2_read_chunk_tags(dev, block_no * - dev->param.chunks_per_block, NULL, - &t); + dev->param.chunks_per_block, NULL, &t); if (t.chunk_used) { *seq_number = t.seq_number; @@ -209,8 +216,7 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, } } T(YAFFS_TRACE_MTD, - (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, - *state)); + (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state)); if (retval == 0) return YAFFS_OK; diff --git a/yaffs_nameval.c b/yaffs_nameval.c index a4ed297..d7cb72a 100644 --- a/yaffs_nameval.c +++ b/yaffs_nameval.c @@ -25,118 +25,120 @@ * This code has not been tested with unicode yet. */ - #include "yaffs_nameval.h" #include "yportenv.h" - -static int nval_find(const char *xb, int xb_size, const YCHAR *name, - int *exist_size) + +static int nval_find(const char *xb, int xb_size, const YCHAR * name, + int *exist_size) { - int pos=0; + int pos = 0; int size; - memcpy(&size,xb,sizeof(int)); - while(size > 0 && (size < xb_size) && (pos + size < xb_size)){ - if(yaffs_strncmp((YCHAR *)(xb+pos+sizeof(int)),name,size) == 0){ - if(exist_size) + memcpy(&size, xb, sizeof(int)); + while (size > 0 && (size < xb_size) && (pos + size < xb_size)) { + if (yaffs_strncmp + ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) { + if (exist_size) *exist_size = size; return pos; } pos += size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } - if(exist_size) + if (exist_size) *exist_size = 0; return -1; } static int nval_used(const char *xb, int xb_size) { - int pos=0; + int pos = 0; int size; - memcpy(&size,xb + pos,sizeof(int)); - while(size > 0 && (size < xb_size) && (pos + size < xb_size)){ + memcpy(&size, xb + pos, sizeof(int)); + while (size > 0 && (size < xb_size) && (pos + size < xb_size)) { pos += size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } return pos; } -int nval_del(char *xb, int xb_size, const YCHAR *name) +int nval_del(char *xb, int xb_size, const YCHAR * name) { - int pos = nval_find(xb, xb_size, name, NULL); + int pos = nval_find(xb, xb_size, name, NULL); int size; - - if(pos >= 0 && pos < xb_size){ + + if (pos >= 0 && pos < xb_size) { /* Find size, shift rest over this record, then zero out the rest of buffer */ - memcpy(&size,xb+pos,sizeof(int)); + memcpy(&size, xb + pos, sizeof(int)); memcpy(xb + pos, xb + pos + size, xb_size - (pos + size)); - memset(xb + (xb_size - size),0,size); + memset(xb + (xb_size - size), 0, size); return 0; } else return -ENODATA; } -int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags) +int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf, + int bsize, int flags) { int pos; - int namelen = yaffs_strnlen(name,xb_size); + int namelen = yaffs_strnlen(name, xb_size); int reclen; int size_exist = 0; int space; int start; - pos = nval_find(xb,xb_size,name, &size_exist); + pos = nval_find(xb, xb_size, name, &size_exist); - if(flags & XATTR_CREATE && pos >= 0) + if (flags & XATTR_CREATE && pos >= 0) return -EEXIST; - if(flags & XATTR_REPLACE && pos < 0) + if (flags & XATTR_REPLACE && pos < 0) return -ENODATA; - start = nval_used(xb,xb_size); + start = nval_used(xb, xb_size); space = xb_size - start + size_exist; reclen = (sizeof(int) + namelen + 1 + bsize); - if(reclen > space) + if (reclen > space) return -ENOSPC; - if(pos >= 0){ - nval_del(xb,xb_size,name); + if (pos >= 0) { + nval_del(xb, xb_size, name); start = nval_used(xb, xb_size); } pos = start; - memcpy(xb + pos,&reclen,sizeof(int)); - pos +=sizeof(int); - yaffs_strncpy((YCHAR *)(xb + pos), name, reclen); - pos+= (namelen+1); - memcpy(xb + pos,buf,bsize); + memcpy(xb + pos, &reclen, sizeof(int)); + pos += sizeof(int); + yaffs_strncpy((YCHAR *) (xb + pos), name, reclen); + pos += (namelen + 1); + memcpy(xb + pos, buf, bsize); return 0; } -int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize) +int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf, + int bsize) { - int pos = nval_find(xb,xb_size,name,NULL); + int pos = nval_find(xb, xb_size, name, NULL); int size; - - if(pos >= 0 && pos< xb_size){ - - memcpy(&size,xb +pos,sizeof(int)); - pos+=sizeof(int); /* advance past record length */ + + if (pos >= 0 && pos < xb_size) { + + memcpy(&size, xb + pos, sizeof(int)); + pos += sizeof(int); /* advance past record length */ size -= sizeof(int); /* Advance over name string */ - while(xb[pos] && size > 0 && pos < xb_size){ + while (xb[pos] && size > 0 && pos < xb_size) { pos++; size--; } @@ -144,13 +146,13 @@ int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsiz pos++; size--; - if(size <= bsize){ - memcpy(buf,xb + pos,size); + if (size <= bsize) { + memcpy(buf, xb + pos, size); return size; } - + } - if(pos >= 0) + if (pos >= 0) return -ERANGE; else return -ENODATA; @@ -164,33 +166,33 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize) int ncopied = 0; int filled = 0; - memcpy(&size,xb + pos,sizeof(int)); - while(size > sizeof(int) && size <= xb_size && (pos + size) < xb_size && !filled){ - pos+= sizeof(int); - size-=sizeof(int); - name_len = yaffs_strnlen((YCHAR *)(xb + pos), size); - if(ncopied + name_len + 1 < bsize){ - memcpy(buf,xb+pos,name_len * sizeof(YCHAR)); - buf+= name_len; + memcpy(&size, xb + pos, sizeof(int)); + while (size > sizeof(int) && size <= xb_size && (pos + size) < xb_size + && !filled) { + pos += sizeof(int); + size -= sizeof(int); + name_len = yaffs_strnlen((YCHAR *) (xb + pos), size); + if (ncopied + name_len + 1 < bsize) { + memcpy(buf, xb + pos, name_len * sizeof(YCHAR)); + buf += name_len; *buf = '\0'; buf++; - if(sizeof(YCHAR) > 1){ + if (sizeof(YCHAR) > 1) { *buf = '\0'; buf++; } - ncopied += (name_len+1); + ncopied += (name_len + 1); } else filled = 1; - pos+=size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + pos += size; + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } return ncopied; } - int nval_hasvalues(const char *xb, int xb_size) { return nval_used(xb, xb_size) > 0; diff --git a/yaffs_nameval.h b/yaffs_nameval.h index bd80859..2bb02b6 100644 --- a/yaffs_nameval.h +++ b/yaffs_nameval.h @@ -18,9 +18,11 @@ #include "yportenv.h" -int nval_del(char *xb, int xb_size, const YCHAR *name); -int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags); -int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize); +int nval_del(char *xb, int xb_size, const YCHAR * name); +int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf, + int bsize, int flags); +int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf, + int bsize); int nval_list(const char *xb, int xb_size, char *buf, int bsize); int nval_hasvalues(const char *xb, int xb_size); #endif diff --git a/yaffs_nand.c b/yaffs_nand.c index d45259e..84ab0f0 100644 --- a/yaffs_nand.c +++ b/yaffs_nand.c @@ -18,8 +18,7 @@ #include "yaffs_getblockinfo.h" int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, - u8 *buffer, - struct yaffs_ext_tags *tags) + u8 * buffer, struct yaffs_ext_tags *tags) { int result; struct yaffs_ext_tags local_tags; @@ -33,18 +32,18 @@ int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, tags = &local_tags; if (dev->param.read_chunk_tags_fn) - result = dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer, - tags); + result = + dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer, + tags); else result = yaffs_tags_compat_rd(dev, - realigned_chunk, - buffer, - tags); - if (tags && - tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { + realigned_chunk, buffer, tags); + if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { struct yaffs_block_info *bi; - bi = yaffs_get_block_info(dev, nand_chunk/dev->param.chunks_per_block); + bi = yaffs_get_block_info(dev, + nand_chunk / + dev->param.chunks_per_block); yaffs_handle_chunk_error(dev, bi); } @@ -52,16 +51,14 @@ int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, } int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, - int nand_chunk, - const u8 *buffer, - struct yaffs_ext_tags *tags) + int nand_chunk, + const u8 * buffer, struct yaffs_ext_tags *tags) { dev->n_page_writes++; nand_chunk -= dev->chunk_offset; - if (tags) { tags->seq_number = dev->seq_number; tags->chunk_used = 1; @@ -80,19 +77,15 @@ int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, if (dev->param.write_chunk_tags_fn) return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, - tags); + tags); else - return yaffs_tags_compat_wr(dev, - nand_chunk, - buffer, - tags); + return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags); } int yaffs_mark_bad(struct yaffs_dev *dev, int block_no) { block_no -= dev->block_offset; - if (dev->param.bad_block_fn) return dev->param.bad_block_fn(dev, block_no); else @@ -100,23 +93,21 @@ int yaffs_mark_bad(struct yaffs_dev *dev, int block_no) } int yaffs_query_init_block_state(struct yaffs_dev *dev, - int block_no, - enum yaffs_block_state *state, - u32 *seq_number) + int block_no, + enum yaffs_block_state *state, + u32 * seq_number) { block_no -= dev->block_offset; if (dev->param.query_block_fn) - return dev->param.query_block_fn(dev, block_no, state, seq_number); + return dev->param.query_block_fn(dev, block_no, state, + seq_number); else return yaffs_tags_compat_query_block(dev, block_no, - state, - seq_number); + state, seq_number); } - -int yaffs_erase_block(struct yaffs_dev *dev, - int flash_block) +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block) { int result; @@ -131,10 +122,7 @@ int yaffs_erase_block(struct yaffs_dev *dev, int yaffs_init_nand(struct yaffs_dev *dev) { - if(dev->param.initialise_flash_fn) + if (dev->param.initialise_flash_fn) return dev->param.initialise_flash_fn(dev); return YAFFS_OK; } - - - diff --git a/yaffs_nand.h b/yaffs_nand.h index 773badb..543f198 100644 --- a/yaffs_nand.h +++ b/yaffs_nand.h @@ -17,28 +17,22 @@ #define __YAFFS_NAND_H__ #include "yaffs_guts.h" - - int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, - u8 *buffer, - struct yaffs_ext_tags *tags); + u8 * buffer, struct yaffs_ext_tags *tags); int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, - int nand_chunk, - const u8 *buffer, - struct yaffs_ext_tags *tags); + int nand_chunk, + const u8 * buffer, struct yaffs_ext_tags *tags); int yaffs_mark_bad(struct yaffs_dev *dev, int block_no); int yaffs_query_init_block_state(struct yaffs_dev *dev, - int block_no, - enum yaffs_block_state *state, - unsigned *seq_number); + int block_no, + enum yaffs_block_state *state, + unsigned *seq_number); -int yaffs_erase_block(struct yaffs_dev *dev, - int flash_block); +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block); int yaffs_init_nand(struct yaffs_dev *dev); #endif - diff --git a/yaffs_packedtags1.c b/yaffs_packedtags1.c index 9055512..a77f095 100644 --- a/yaffs_packedtags1.c +++ b/yaffs_packedtags1.c @@ -14,7 +14,8 @@ #include "yaffs_packedtags1.h" #include "yportenv.h" -void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, const struct yaffs_ext_tags *t) +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t) { pt->chunk_id = t->chunk_id; pt->serial_number = t->serial_number; @@ -27,11 +28,13 @@ void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, const struct yaffs_ext_tags } -void yaffs_unpack_tags1(struct yaffs_ext_tags *t, const struct yaffs_packed_tags1 *pt) +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt) { static const u8 all_ff[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, -0xff }; + 0xff + }; if (memcmp(all_ff, pt, sizeof(struct yaffs_packed_tags1))) { t->block_bad = 0; diff --git a/yaffs_packedtags1.h b/yaffs_packedtags1.h index 9174837..d6861ff 100644 --- a/yaffs_packedtags1.h +++ b/yaffs_packedtags1.h @@ -30,8 +30,10 @@ struct yaffs_packed_tags1 { unsigned unused_stuff:1; unsigned should_be_ff; -} ; +}; -void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, const struct yaffs_ext_tags *t); -void yaffs_unpack_tags1(struct yaffs_ext_tags *t, const struct yaffs_packed_tags1 *pt); +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt); #endif diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c index 6a22939..6c12aed 100644 --- a/yaffs_packedtags2.c +++ b/yaffs_packedtags2.c @@ -38,14 +38,14 @@ #define EXTRA_OBJECT_TYPE_SHIFT (28) #define EXTRA_OBJECT_TYPE_MASK ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT) - -static void yaffs_dump_packed_tags2_tags_only(const struct yaffs_packed_tags2_tags_only *ptt) +static void yaffs_dump_packed_tags2_tags_only(const struct + yaffs_packed_tags2_tags_only *ptt) { T(YAFFS_TRACE_MTD, (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR), - ptt->obj_id, ptt->chunk_id, ptt->n_bytes, - ptt->seq_number)); + ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number)); } + static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt) { yaffs_dump_packed_tags2_tags_only(&pt->t); @@ -63,7 +63,7 @@ static void yaffs_dump_tags2(const struct yaffs_ext_tags *t) } void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt, - const struct yaffs_ext_tags *t) + const struct yaffs_ext_tags *t) { ptt->chunk_id = t->chunk_id; ptt->seq_number = t->seq_number; @@ -73,16 +73,14 @@ void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt, if (t->chunk_id == 0 && t->extra_available) { /* Store the extra header info instead */ /* We save the parent object in the chunk_id */ - ptt->chunk_id = EXTRA_HEADER_INFO_FLAG - | t->extra_parent_id; + ptt->chunk_id = EXTRA_HEADER_INFO_FLAG | t->extra_parent_id; if (t->extra_is_shrink) ptt->chunk_id |= EXTRA_SHRINK_FLAG; if (t->extra_shadows) ptt->chunk_id |= EXTRA_SHADOWS_FLAG; ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; - ptt->obj_id |= - (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); + ptt->obj_id |= (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) ptt->n_bytes = t->extra_equiv_id; @@ -96,20 +94,20 @@ void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt, yaffs_dump_tags2(t); } - -void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, const struct yaffs_ext_tags *t, int tags_ecc) +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc) { yaffs_pack_tags2_tags_only(&pt->t, t); - if(tags_ecc) + if (tags_ecc) yaffs_ecc_calc_other((unsigned char *)&pt->t, - sizeof(struct yaffs_packed_tags2_tags_only), - &pt->ecc); + sizeof(struct + yaffs_packed_tags2_tags_only), + &pt->ecc); } - void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, - struct yaffs_packed_tags2_tags_only *ptt) + struct yaffs_packed_tags2_tags_only *ptt) { memset(t, 0, sizeof(struct yaffs_ext_tags)); @@ -155,36 +153,38 @@ void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, } - -void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, int tags_ecc) +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc) { enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - if (pt->t.seq_number != 0xFFFFFFFF && - tags_ecc){ + if (pt->t.seq_number != 0xFFFFFFFF && tags_ecc) { /* Chunk is in use and we need to do ECC */ - + struct yaffs_ecc_other ecc; int result; yaffs_ecc_calc_other((unsigned char *)&pt->t, - sizeof(struct yaffs_packed_tags2_tags_only), - &ecc); - result = yaffs_ecc_correct_other((unsigned char *)&pt->t, - sizeof(struct yaffs_packed_tags2_tags_only), - &pt->ecc, &ecc); + sizeof(struct + yaffs_packed_tags2_tags_only), + &ecc); + result = + yaffs_ecc_correct_other((unsigned char *)&pt->t, + sizeof(struct + yaffs_packed_tags2_tags_only), + &pt->ecc, &ecc); switch (result) { - case 0: - ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - break; - case 1: - ecc_result = YAFFS_ECC_RESULT_FIXED; - break; - case -1: - ecc_result = YAFFS_ECC_RESULT_UNFIXED; - break; - default: - ecc_result = YAFFS_ECC_RESULT_UNKNOWN; + case 0: + ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + break; + case 1: + ecc_result = YAFFS_ECC_RESULT_FIXED; + break; + case -1: + ecc_result = YAFFS_ECC_RESULT_UNFIXED; + break; + default: + ecc_result = YAFFS_ECC_RESULT_UNKNOWN; } } @@ -195,4 +195,3 @@ void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, yaffs_dump_packed_tags2(pt); yaffs_dump_tags2(t); } - diff --git a/yaffs_packedtags2.h b/yaffs_packedtags2.h index f147c09..f329669 100644 --- a/yaffs_packedtags2.h +++ b/yaffs_packedtags2.h @@ -26,18 +26,22 @@ struct yaffs_packed_tags2_tags_only { unsigned obj_id; unsigned chunk_id; unsigned n_bytes; -} ; +}; struct yaffs_packed_tags2 { struct yaffs_packed_tags2_tags_only t; struct yaffs_ecc_other ecc; -} ; +}; /* Full packed tags with ECC, used for oob tags */ -void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, const struct yaffs_ext_tags *t, int tags_ecc); -void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, int tags_ecc); +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc); +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc); /* Only the tags part (no ECC for use with inband tags */ -void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt, const struct yaffs_ext_tags *t); -void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, struct yaffs_packed_tags2_tags_only *pt); +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *pt); #endif diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c index 57b1e54..3a9a157 100644 --- a/yaffs_tagscompat.c +++ b/yaffs_tagscompat.c @@ -19,7 +19,6 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk); - static const char yaffs_count_bits_table[256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, @@ -48,7 +47,7 @@ int yaffs_count_bits(u8 x) /********** Tags ECC calculations *********/ -void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare) +void yaffs_calc_ecc(const u8 * data, struct yaffs_spare *spare) { yaffs_ecc_cacl(data, spare->ecc1); yaffs_ecc_cacl(&data[256], spare->ecc2); @@ -58,7 +57,7 @@ void yaffs_calc_tags_ecc(struct yaffs_tags *tags) { /* Calculate an ecc */ - unsigned char *b = ((union yaffs_tags_union *) tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -87,7 +86,7 @@ int yaffs_check_tags_ecc(struct yaffs_tags *tags) if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((union yaffs_tags_union *) tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; ecc--; @@ -109,9 +108,9 @@ int yaffs_check_tags_ecc(struct yaffs_tags *tags) /********** Tags **********/ static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr, - struct yaffs_tags *tags_ptr) + struct yaffs_tags *tags_ptr) { - union yaffs_tags_union *tu = (union yaffs_tags_union *) tags_ptr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; yaffs_calc_tags_ecc(tags_ptr); @@ -125,10 +124,11 @@ static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr, spare_ptr->tb7 = tu->as_bytes[7]; } -static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, struct yaffs_spare *spare_ptr, - struct yaffs_tags *tags_ptr) +static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, + struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - union yaffs_tags_union *tu = (union yaffs_tags_union *) tags_ptr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; int result; tu->as_bytes[0] = spare_ptr->tb0; @@ -153,8 +153,8 @@ static void yaffs_spare_init(struct yaffs_spare *spare) } static int yaffs_wr_nand(struct yaffs_dev *dev, - int nand_chunk, const u8 *data, - struct yaffs_spare *spare) + int nand_chunk, const u8 * data, + struct yaffs_spare *spare) { if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, @@ -167,11 +167,11 @@ static int yaffs_wr_nand(struct yaffs_dev *dev, } static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, - int nand_chunk, - u8 *data, - struct yaffs_spare *spare, - enum yaffs_ecc_result *ecc_result, - int correct_errors) + int nand_chunk, + u8 * data, + struct yaffs_spare *spare, + enum yaffs_ecc_result *ecc_result, + int correct_errors) { int ret_val; struct yaffs_spare local_spare; @@ -183,7 +183,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, } if (!dev->param.use_nand_ecc) { - ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); + ret_val = + dev->param.read_chunk_fn(dev, nand_chunk, data, spare); if (data && correct_errors) { /* Do ECC correction */ /* Todo handle any errors */ @@ -195,7 +196,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, yaffs_ecc_correct(data, spare->ecc1, calc_ecc); yaffs_ecc_cacl(&data[256], calc_ecc); ecc_result2 = - yaffs_ecc_correct(&data[256], spare->ecc2, calc_ecc); + yaffs_ecc_correct(&data[256], spare->ecc2, + calc_ecc); if (ecc_result1 > 0) { T(YAFFS_TRACE_ERROR, @@ -245,7 +247,8 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, memset(&nspare, 0, sizeof(nspare)); ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, - (struct yaffs_spare *) &nspare); + (struct yaffs_spare *) + &nspare); memcpy(spare, &nspare, sizeof(struct yaffs_spare)); if (data && correct_errors) { if (nspare.eccres1 > 0) { @@ -289,7 +292,6 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, return ret_val; } - /* * Functions for robustisizing */ @@ -299,7 +301,9 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk) int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1; + yaffs_get_block_info(dev, + flash_block + dev->block_offset)->needs_retiring = + 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); @@ -310,11 +314,9 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk) */ } - int yaffs_tags_compat_wr(struct yaffs_dev *dev, - int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *ext_tags) + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *ext_tags) { struct yaffs_spare spare; struct yaffs_tags tags; @@ -334,7 +336,6 @@ int yaffs_tags_compat_wr(struct yaffs_dev *dev, else tags.n_bytes_msb = 3; - tags.serial_number = ext_tags->serial_number; if (!dev->param.use_nand_ecc && data) @@ -348,9 +349,8 @@ int yaffs_tags_compat_wr(struct yaffs_dev *dev, } int yaffs_tags_compat_rd(struct yaffs_dev *dev, - int nand_chunk, - u8 *data, - struct yaffs_ext_tags *ext_tags) + int nand_chunk, + u8 * data, struct yaffs_ext_tags *ext_tags) { struct yaffs_spare spare; @@ -365,8 +365,7 @@ int yaffs_tags_compat_rd(struct yaffs_dev *dev, init = 1; } - if (yaffs_rd_chunk_nand - (dev, nand_chunk, data, &spare, &ecc_result, 1)) { + if (yaffs_rd_chunk_nand(dev, nand_chunk, data, &spare, &ecc_result, 1)) { /* ext_tags may be NULL */ if (ext_tags) { @@ -389,7 +388,9 @@ int yaffs_tags_compat_rd(struct yaffs_dev *dev, ext_tags->n_bytes = tags.n_bytes_lsb; if (dev->data_bytes_per_chunk >= 1024) - ext_tags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); + ext_tags->n_bytes |= + (((unsigned)tags. + n_bytes_msb) << 10); ext_tags->serial_number = tags.serial_number; } @@ -401,8 +402,7 @@ int yaffs_tags_compat_rd(struct yaffs_dev *dev, } } -int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, - int flash_block) +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block) { struct yaffs_spare spare; @@ -412,18 +412,18 @@ int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, spare.block_status = 'Y'; yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, - &spare); + &spare); yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, - NULL, &spare); + NULL, &spare); return YAFFS_OK; } int yaffs_tags_compat_query_block(struct yaffs_dev *dev, - int block_no, - enum yaffs_block_state *state, - u32 *seq_number) + int block_no, + enum yaffs_block_state *state, + u32 * seq_number) { struct yaffs_spare spare0, spare1; @@ -439,9 +439,9 @@ int yaffs_tags_compat_query_block(struct yaffs_dev *dev, *seq_number = 0; yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, - &spare0, &dummy, 1); - yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL, - &spare1, &dummy, 1); + &spare0, &dummy, 1); + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, + NULL, &spare1, &dummy, 1); if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; diff --git a/yaffs_tagscompat.h b/yaffs_tagscompat.h index cf3402d..8cd35dc 100644 --- a/yaffs_tagscompat.h +++ b/yaffs_tagscompat.h @@ -18,19 +18,16 @@ #include "yaffs_guts.h" int yaffs_tags_compat_wr(struct yaffs_dev *dev, - int nand_chunk, - const u8 *data, - const struct yaffs_ext_tags *tags); + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *tags); int yaffs_tags_compat_rd(struct yaffs_dev *dev, - int nand_chunk, - u8 *data, - struct yaffs_ext_tags *tags); -int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, - int block_no); + int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no); int yaffs_tags_compat_query_block(struct yaffs_dev *dev, - int block_no, - enum yaffs_block_state *state, - u32 *seq_number); + int block_no, + enum yaffs_block_state *state, + u32 * seq_number); void yaffs_calc_tags_ecc(struct yaffs_tags *tags); int yaffs_check_tags_ecc(struct yaffs_tags *tags); diff --git a/yaffs_tagsvalidity.c b/yaffs_tagsvalidity.c index f86882a..4358d79 100644 --- a/yaffs_tagsvalidity.c +++ b/yaffs_tagsvalidity.c @@ -22,7 +22,6 @@ void yaffs_init_tags(struct yaffs_ext_tags *tags) int yaffs_validate_tags(struct yaffs_ext_tags *tags) { - return (tags->validity0 == 0xAAAAAAAA && - tags->validity1 == 0x55555555); + return (tags->validity0 == 0xAAAAAAAA && tags->validity1 == 0x55555555); } diff --git a/yaffs_tagsvalidity.h b/yaffs_tagsvalidity.h index ae3116f..36a021f 100644 --- a/yaffs_tagsvalidity.h +++ b/yaffs_tagsvalidity.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YAFFS_TAGS_VALIDITY_H__ #define __YAFFS_TAGS_VALIDITY_H__ diff --git a/yaffs_trace.h b/yaffs_trace.h index 9fe7214..90dbefc 100644 --- a/yaffs_trace.h +++ b/yaffs_trace.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YTRACE_H__ #define __YTRACE_H__ @@ -54,7 +53,6 @@ extern unsigned int yaffs_wr_attempts; #define YAFFS_TRACE_BUG 0x80000000 #define YAFFS_TRACE_ALWAYS 0xF0000000 - #define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0) #endif diff --git a/yaffs_verify.c b/yaffs_verify.c index e15bb32..fee3a1e 100644 --- a/yaffs_verify.c +++ b/yaffs_verify.c @@ -11,7 +11,6 @@ * published by the Free Software Foundation. */ - #include "yaffs_verify.h" #include "yaffs_trace.h" #include "yaffs_bitmap.h" @@ -20,37 +19,36 @@ int yaffs_skip_verification(struct yaffs_dev *dev) { - dev=dev; - return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); + dev = dev; + return !(yaffs_trace_mask & + (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); } static int yaffs_skip_full_verification(struct yaffs_dev *dev) { - dev=dev; + dev = dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL)); } static int yaffs_skip_nand_verification(struct yaffs_dev *dev) { - dev=dev; + dev = dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND)); } - static const char *block_state_name[] = { -"Unknown", -"Needs scanning", -"Scanning", -"Empty", -"Allocating", -"Full", -"Dirty", -"Checkpoint", -"Collecting", -"Dead" + "Unknown", + "Needs scanning", + "Scanning", + "Empty", + "Allocating", + "Full", + "Dirty", + "Checkpoint", + "Collecting", + "Dead" }; - void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n) { int actually_used; @@ -61,47 +59,56 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n) /* Report illegal runtime states */ if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->block_state)); + T(YAFFS_TRACE_VERIFY, + (TSTR("Block %d has undefined state %d" TENDSTR), n, + bi->block_state)); switch (bi->block_state) { case YAFFS_BLOCK_STATE_UNKNOWN: case YAFFS_BLOCK_STATE_SCANNING: case YAFFS_BLOCK_STATE_NEEDS_SCANNING: - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR), - n, block_state_name[bi->block_state])); + T(YAFFS_TRACE_VERIFY, + (TSTR("Block %d has bad run-state %s" TENDSTR), n, + block_state_name[bi->block_state])); } /* Check pages in use and soft deletions are legal */ actually_used = bi->pages_in_use - bi->soft_del_pages; - if (bi->pages_in_use < 0 || bi->pages_in_use > dev->param.chunks_per_block || - bi->soft_del_pages < 0 || bi->soft_del_pages > dev->param.chunks_per_block || - actually_used < 0 || actually_used > dev->param.chunks_per_block) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pages_in_used %d soft_del_pages %d"TENDSTR), - n, bi->pages_in_use, bi->soft_del_pages)); - + if (bi->pages_in_use < 0 + || bi->pages_in_use > dev->param.chunks_per_block + || bi->soft_del_pages < 0 + || bi->soft_del_pages > dev->param.chunks_per_block + || actually_used < 0 || actually_used > dev->param.chunks_per_block) + T(YAFFS_TRACE_VERIFY, + (TSTR + ("Block %d has illegal values pages_in_used %d soft_del_pages %d" + TENDSTR), n, bi->pages_in_use, bi->soft_del_pages)); /* Check chunk bitmap legal */ in_use = yaffs_count_chunk_bits(dev, n); if (in_use != bi->pages_in_use) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"TENDSTR), - n, bi->pages_in_use, in_use)); + T(YAFFS_TRACE_VERIFY, + (TSTR + ("Block %d has inconsistent values pages_in_use %d counted chunk bits %d" + TENDSTR), n, bi->pages_in_use, in_use)); } - - -void yaffs_verify_collected_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n) +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n) { yaffs_verify_blk(dev, bi, n); /* After collection the block should be in the erased state */ if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING && - bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { - T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR), - n, bi->block_state)); + bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("Block %d is in state %d after gc, should be erased" + TENDSTR), n, bi->block_state)); } } @@ -126,34 +133,37 @@ void yaffs_verify_blocks(struct yaffs_dev *dev) illegal_states++; } - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("Block summary" TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), illegal_states)); + T(YAFFS_TRACE_VERIFY, + (TSTR("%d blocks have illegal states" TENDSTR), illegal_states)); if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1) - T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR))); + T(YAFFS_TRACE_VERIFY, + (TSTR("Too many allocating blocks" TENDSTR))); for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) T(YAFFS_TRACE_VERIFY, - (TSTR("%s %d blocks"TENDSTR), - block_state_name[i], state_count[i])); + (TSTR("%s %d blocks" TENDSTR), + block_state_name[i], state_count[i])); if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT]) T(YAFFS_TRACE_VERIFY, - (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR), - dev->blocks_in_checkpt, state_count[YAFFS_BLOCK_STATE_CHECKPOINT])); + (TSTR("Checkpoint block count wrong dev %d count %d" TENDSTR), + dev->blocks_in_checkpt, + state_count[YAFFS_BLOCK_STATE_CHECKPOINT])); if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY]) T(YAFFS_TRACE_VERIFY, - (TSTR("Erased block count wrong dev %d count %d"TENDSTR), - dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY])); + (TSTR("Erased block count wrong dev %d count %d" TENDSTR), + dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY])); if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1) T(YAFFS_TRACE_VERIFY, - (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR), - state_count[YAFFS_BLOCK_STATE_COLLECTING])); + (TSTR("Too many collecting blocks %d (max is 1)" TENDSTR), + state_count[YAFFS_BLOCK_STATE_COLLECTING])); - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR))); } @@ -161,29 +171,29 @@ void yaffs_verify_blocks(struct yaffs_dev *dev) * Verify the object header. oh must be valid, but obj and tags may be NULL in which * case those tests will not be performed. */ -void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check) +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check) { if (obj && yaffs_skip_verification(obj->my_dev)) return; if (!(tags && obj && oh)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Verifying object header tags %p obj %p oh %p"TENDSTR), - tags, obj, oh)); + (TSTR("Verifying object header tags %p obj %p oh %p" TENDSTR), + tags, obj, oh)); return; } if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN || - oh->type > YAFFS_OBJECT_TYPE_MAX) + oh->type > YAFFS_OBJECT_TYPE_MAX) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR), - tags->obj_id, oh->type)); + (TSTR("Obj %d header type is illegal value 0x%x" TENDSTR), + tags->obj_id, oh->type)); if (tags->obj_id != obj->obj_id) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch obj_id %d"TENDSTR), - tags->obj_id, obj->obj_id)); - + (TSTR("Obj %d header mismatch obj_id %d" TENDSTR), + tags->obj_id, obj->obj_id)); /* * Check that the object's parent ids match if parent_check requested. @@ -193,30 +203,29 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaf if (parent_check && tags->obj_id > 1 && !obj->parent) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parent_id %d obj->parent is NULL"TENDSTR), - tags->obj_id, oh->parent_obj_id)); + (TSTR + ("Obj %d header mismatch parent_id %d obj->parent is NULL" + TENDSTR), tags->obj_id, oh->parent_obj_id)); if (parent_check && obj->parent && - oh->parent_obj_id != obj->parent->obj_id && - (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || - obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) + oh->parent_obj_id != obj->parent->obj_id && + (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || + obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parent_id %d parent_obj_id %d"TENDSTR), - tags->obj_id, oh->parent_obj_id, obj->parent->obj_id)); + (TSTR + ("Obj %d header mismatch parent_id %d parent_obj_id %d" + TENDSTR), tags->obj_id, oh->parent_obj_id, + obj->parent->obj_id)); - if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ + if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is NULL"TENDSTR), - obj->obj_id)); + (TSTR("Obj %d header name is NULL" TENDSTR), obj->obj_id)); - if (tags->obj_id > 1 && ((u8)(oh->name[0])) == 0xff) /* Trashed name */ + if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff) /* Trashed name */ T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is 0xFF"TENDSTR), - obj->obj_id)); + (TSTR("Obj %d header name is 0xFF" TENDSTR), obj->obj_id)); } - - void yaffs_verify_file(struct yaffs_obj *obj) { int required_depth; @@ -239,7 +248,8 @@ void yaffs_verify_file(struct yaffs_obj *obj) obj_id = obj->obj_id; /* Check file size is consistent with tnode depth */ - last_chunk = obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; + last_chunk = + obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; x = last_chunk >> YAFFS_TNODES_LEVEL0_BITS; required_depth = 0; while (x > 0) { @@ -264,18 +274,20 @@ void yaffs_verify_file(struct yaffs_obj *obj) u32 the_chunk = yaffs_get_group_base(dev, tn, i); if (the_chunk > 0) { /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */ - yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags); + yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, + &tags); if (tags.obj_id != obj_id || tags.chunk_id != i) { - T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - obj_id, i, the_chunk, - tags.obj_id, tags.chunk_id)); + T(~0, + (TSTR + ("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)" + TENDSTR), obj_id, i, the_chunk, + tags.obj_id, tags.chunk_id)); } } } } } - void yaffs_verify_link(struct yaffs_obj *obj) { if (obj && yaffs_skip_verification(obj->my_dev)) @@ -324,24 +336,24 @@ void yaffs_verify_obj(struct yaffs_obj *obj) /* Check sane object header chunk */ chunk_min = dev->internal_start_block * dev->param.chunks_per_block; - chunk_max = (dev->internal_end_block+1) * dev->param.chunks_per_block - 1; + chunk_max = + (dev->internal_end_block + 1) * dev->param.chunks_per_block - 1; - chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min && - ((unsigned)(obj->hdr_chunk)) <= chunk_max); + chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min && + ((unsigned)(obj->hdr_chunk)) <= chunk_max); chunk_id_ok = chunk_in_range || (obj->hdr_chunk == 0); chunk_valid = chunk_in_range && - yaffs_check_chunk_bit(dev, - obj->hdr_chunk / dev->param.chunks_per_block, - obj->hdr_chunk % dev->param.chunks_per_block); + yaffs_check_chunk_bit(dev, + obj->hdr_chunk / dev->param.chunks_per_block, + obj->hdr_chunk % dev->param.chunks_per_block); chunk_wrongly_deleted = chunk_in_range && !chunk_valid; - if (!obj->fake && - (!chunk_id_ok || chunk_wrongly_deleted)) { + if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has chunk_id %d %s %s"TENDSTR), - obj->obj_id, obj->hdr_chunk, - chunk_id_ok ? "" : ",out of range", - chunk_wrongly_deleted ? ",marked as deleted" : "")); + (TSTR("Obj %d has chunk_id %d %s %s" TENDSTR), + obj->obj_id, obj->hdr_chunk, + chunk_id_ok ? "" : ",out of range", + chunk_wrongly_deleted ? ",marked as deleted" : "")); } if (chunk_valid && !yaffs_skip_nand_verification(dev)) { @@ -351,8 +363,7 @@ void yaffs_verify_obj(struct yaffs_obj *obj) oh = (struct yaffs_obj_hdr *)buffer; - yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, - &tags); + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, &tags); yaffs_verify_oh(obj, oh, &tags, 1); @@ -360,18 +371,19 @@ void yaffs_verify_obj(struct yaffs_obj *obj) } /* Verify it has a parent */ - if (obj && !obj->fake && - (!obj->parent || obj->parent->my_dev != dev)) { + if (obj && !obj->fake && (!obj->parent || obj->parent->my_dev != dev)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), - obj->obj_id, obj->parent)); + (TSTR + ("Obj %d has parent pointer %p which does not look like an object" + TENDSTR), obj->obj_id, obj->parent)); } /* Verify parent is a directory */ - if (obj->parent && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (obj->parent + && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), - obj->obj_id, obj->parent->variant_type)); + (TSTR("Obj %d's parent is not a directory (type %d)" TENDSTR), + obj->obj_id, obj->parent->variant_type)); } switch (obj->variant_type) { @@ -393,8 +405,8 @@ void yaffs_verify_obj(struct yaffs_obj *obj) case YAFFS_OBJECT_TYPE_UNKNOWN: default: T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has illegaltype %d"TENDSTR), - obj->obj_id, obj->variant_type)); + (TSTR("Obj %d has illegaltype %d" TENDSTR), + obj->obj_id, obj->variant_type)); break; } } @@ -410,17 +422,17 @@ void yaffs_verify_objects(struct yaffs_dev *dev) /* Iterate through the objects in each hash entry */ - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { list_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = list_entry(lh, struct yaffs_obj, hash_link); + obj = + list_entry(lh, struct yaffs_obj, hash_link); yaffs_verify_obj(obj); } } } } - void yaffs_verify_obj_in_dir(struct yaffs_obj *obj) { struct list_head *lh; @@ -438,13 +450,15 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj) return; if (!obj->parent) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR))); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Object does not have parent" TENDSTR))); YBUG(); return; } if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR))); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Parent is not directory" TENDSTR))); YBUG(); } @@ -457,10 +471,11 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj) if (obj == list_obj) count++; } - } + } if (count != 1) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count)); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Object in directory %d times" TENDSTR), count)); YBUG(); } } @@ -480,8 +495,8 @@ void yaffs_verify_dir(struct yaffs_obj *directory) if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, - (TSTR("Directory has wrong type: %d" TENDSTR), - directory->variant_type)); + (TSTR("Directory has wrong type: %d" TENDSTR), + directory->variant_type)); YBUG(); } @@ -491,9 +506,10 @@ void yaffs_verify_dir(struct yaffs_obj *directory) if (lh) { list_obj = list_entry(lh, struct yaffs_obj, siblings); if (list_obj->parent != directory) { - T(YAFFS_TRACE_ALWAYS, ( - TSTR("Object in directory list has wrong parent %p" TENDSTR), - list_obj->parent)); + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("Object in directory list has wrong parent %p" + TENDSTR), list_obj->parent)); YBUG(); } yaffs_verify_obj_in_dir(list_obj); @@ -525,6 +541,6 @@ void yaffs_verify_free_chunks(struct yaffs_dev *dev) int yaffs_verify_file_sane(struct yaffs_obj *in) { - in=in; + in = in; return YAFFS_OK; } diff --git a/yaffs_verify.h b/yaffs_verify.h index 88924ef..cc6f889 100644 --- a/yaffs_verify.h +++ b/yaffs_verify.h @@ -18,11 +18,14 @@ #include "yaffs_guts.h" -void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n); -void yaffs_verify_collected_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n); +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, + int n); +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n); void yaffs_verify_blocks(struct yaffs_dev *dev); -void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check); +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check); void yaffs_verify_file(struct yaffs_obj *obj); void yaffs_verify_link(struct yaffs_obj *obj); void yaffs_verify_symlink(struct yaffs_obj *obj); @@ -38,4 +41,3 @@ int yaffs_verify_file_sane(struct yaffs_obj *obj); int yaffs_skip_verification(struct yaffs_dev *dev); #endif - diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c index 6e2f8f8..c4e3b97 100644 --- a/yaffs_vfs_multi.c +++ b/yaffs_vfs_multi.c @@ -151,7 +151,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) { uint64_t result = partition_size; do_div(result, block_size); - return (uint32_t)result; + return (uint32_t) result; } #else #define YCALCBLOCKS(s, b) ((s)/(b)) @@ -219,15 +219,14 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->u.generic_sbp) #endif - #define update_dir_time(dir) do {\ (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \ } while(0) - + static void yaffs_put_super(struct super_block *sb); static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos); + loff_t * pos); static ssize_t yaffs_hold_space(struct file *f); static void yaffs_release_space(struct file *f); @@ -241,7 +240,7 @@ static int yaffs_file_flush(struct file *file); static int yaffs_sync_object(struct file *file, int datasync); #else static int yaffs_sync_object(struct file *file, struct dentry *dentry, - int datasync); + int datasync); #endif static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); @@ -250,24 +249,24 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n); + struct nameidata *n); #else static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry); #endif static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry); + struct dentry *dentry); static int yaffs_unlink(struct inode *dir, struct dentry *dentry); static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname); + const char *symname); static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t dev); + dev_t dev); #else static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - int dev); + int dev); #endif static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry); @@ -309,31 +308,30 @@ static int yaffs_writepage(struct page *page); #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags); + const void *value, size_t size, int flags); ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size); + size_t size); int yaffs_removexattr(struct dentry *dentry, const char *name); ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size); #endif - #if (YAFFS_USE_WRITE_BEGIN_END != 0) static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata); + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata); static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata); + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata); #else static int yaffs_prepare_write(struct file *f, struct page *pg, - unsigned offset, unsigned to); + unsigned offset, unsigned to); static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, - unsigned to); + unsigned to); #endif -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen); +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen); #if (YAFFS_NEW_FOLLOW_LINK == 1) void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias); static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); @@ -347,7 +345,6 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); static int yaffs_vfs_setattr(struct inode *, struct iattr *); - static struct address_space_operations yaffs_file_address_operations = { .readpage = yaffs_readpage, .writepage = yaffs_writepage, @@ -360,7 +357,6 @@ static struct address_space_operations yaffs_file_address_operations = { #endif }; - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)) static const struct file_operations yaffs_file_operations = { .read = do_sync_read, @@ -405,14 +401,13 @@ static const struct file_operations yaffs_file_operations = { #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) static void zero_user_segment(struct page *page, unsigned start, unsigned end) { - void * kaddr = kmap_atomic(page, KM_USER0); + void *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + start, 0, end - start); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); } #endif - static const struct inode_operations yaffs_file_inode_operations = { .setattr = yaffs_setattr, #ifdef CONFIG_YAFFS_XATTR @@ -484,11 +479,10 @@ static const struct super_operations yaffs_super_ops = { .write_super = yaffs_write_super, }; - -static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) +static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) { #ifdef YAFFS_USE_SETATTR_COPY - setattr_copy(inode,attr); + setattr_copy(inode, attr); return 0; #else return inode_setattr(inode, attr); @@ -496,13 +490,13 @@ static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) } -static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) +static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) { #ifdef YAFFS_USE_TRUNCATE_SETSIZE - truncate_setsize(inode,newsize); + truncate_setsize(inode, newsize); return 0; #else - truncate_inode_pages(&inode->i_data,newsize); + truncate_inode_pages(&inode->i_data, newsize); return 0; #endif @@ -512,7 +506,7 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev) { return yaffs_gc_control; } - + static void yaffs_gross_lock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); @@ -528,22 +522,26 @@ static void yaffs_gross_unlock(struct yaffs_dev *dev) #ifdef YAFFS_COMPILE_EXPORTFS -static struct inode * -yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation) +static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, + uint32_t generation) { return Y_IGET(sb, ino); } -static struct dentry * -yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ; + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } -static struct dentry * - yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_parent(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode); + return generic_fh_to_parent(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } struct dentry *yaffs2_get_parent(struct dentry *dentry) @@ -583,12 +581,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) * using the default functions of exportfs. */ -static struct export_operations yaffs_export_ops = -{ +static struct export_operations yaffs_export_ops = { .fh_to_dentry = yaffs2_fh_to_dentry, .fh_to_parent = yaffs2_fh_to_parent, .get_parent = yaffs2_get_parent, -} ; +}; #endif @@ -624,21 +621,22 @@ struct yaffs_search_context { * * Called at start of readdir. */ -static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir) +static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir) { struct yaffs_dev *dev = dir->my_dev; - struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context)); - if(sc){ + struct yaffs_search_context *sc = + YMALLOC(sizeof(struct yaffs_search_context)); + if (sc) { sc->dir_obj = dir; sc->dev = dev; - if( list_empty(&sc->dir_obj->variant.dir_variant.children)) + if (list_empty(&sc->dir_obj->variant.dir_variant.children)) sc->next_return = NULL; else - sc->next_return = list_entry( - dir->variant.dir_variant.children.next, - struct yaffs_obj,siblings); + sc->next_return = + list_entry(dir->variant.dir_variant.children.next, + struct yaffs_obj, siblings); INIT_LIST_HEAD(&sc->others); - list_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts)); + list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts)); } return sc; } @@ -646,9 +644,9 @@ static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir) /* * yaffs_search_end() disposes of a search context and cleans up. */ -static void yaffs_search_end(struct yaffs_search_context * sc) +static void yaffs_search_end(struct yaffs_search_context *sc) { - if(sc){ + if (sc) { list_del(&sc->others); YFREE(sc); } @@ -661,20 +659,21 @@ static void yaffs_search_end(struct yaffs_search_context * sc) */ static void yaffs_search_advance(struct yaffs_search_context *sc) { - if(!sc) - return; + if (!sc) + return; - if( sc->next_return == NULL || - list_empty(&sc->dir_obj->variant.dir_variant.children)) - sc->next_return = NULL; - else { - struct list_head *next = sc->next_return->siblings.next; + if (sc->next_return == NULL || + list_empty(&sc->dir_obj->variant.dir_variant.children)) + sc->next_return = NULL; + else { + struct list_head *next = sc->next_return->siblings.next; - if( next == &sc->dir_obj->variant.dir_variant.children) - sc->next_return = NULL; /* end of list */ - else - sc->next_return = list_entry(next,struct yaffs_obj,siblings); - } + if (next == &sc->dir_obj->variant.dir_variant.children) + sc->next_return = NULL; /* end of list */ + else + sc->next_return = + list_entry(next, struct yaffs_obj, siblings); + } } /* @@ -685,30 +684,29 @@ static void yaffs_search_advance(struct yaffs_search_context *sc) static void yaffs_remove_obj_callback(struct yaffs_obj *obj) { - struct list_head *i; - struct yaffs_search_context *sc; - struct list_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - + struct list_head *i; + struct yaffs_search_context *sc; + struct list_head *search_contexts = + &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - /* Iterate through the directory search contexts. - * If any are currently on the object being removed, then advance - * the search context to the next object to prevent a hanging pointer. - */ - list_for_each(i, search_contexts) { - if (i) { - sc = list_entry(i, struct yaffs_search_context,others); - if(sc->next_return == obj) - yaffs_search_advance(sc); - } + /* Iterate through the directory search contexts. + * If any are currently on the object being removed, then advance + * the search context to the next object to prevent a hanging pointer. + */ + list_for_each(i, search_contexts) { + if (i) { + sc = list_entry(i, struct yaffs_search_context, others); + if (sc->next_return == obj) + yaffs_search_advance(sc); + } } } - /*-----------------------------------------------------------------*/ -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen) +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen) { unsigned char *alias; int ret; @@ -751,32 +749,32 @@ static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) ret_int = -ENOMEM; goto out; } - #if (YAFFS_NEW_FOLLOW_LINK == 1) nd_set_link(nd, alias); ret = alias; out: - if(ret_int) + if (ret_int) ret = ERR_PTR(ret_int); return ret; #else ret = vfs_follow_link(nd, alias); kfree(alias); out: - if(ret_int) + if (ret_int) ret = ret_int; return ret; #endif } #if (YAFFS_NEW_FOLLOW_LINK == 1) -void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { +void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) +{ kfree(alias); } #endif struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - struct yaffs_obj *obj); + struct yaffs_obj *obj); /* * Lookup is used to find objects in the fs @@ -784,7 +782,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n) + struct nameidata *n) #else static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) #endif @@ -794,31 +792,29 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev; - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); + (TSTR("yaffs_lookup for %d:%s\n"), + yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); - obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), - dentry->d_name.name); + obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name); obj = yaffs_get_equivalent_obj(obj); /* in case it was a hardlink */ /* Can't hold gross lock when calling yaffs_get_inode() */ - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_unlock(dev); if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); if (inode) { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_loookup dentry \n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n"))); /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to * d_add even if NULL inode */ #if 0 @@ -831,7 +827,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) } } else { - T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n"))); } @@ -842,7 +838,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) return NULL; } - #ifdef YAFFS_HAS_PUT_INODE /* For now put inode is just for debugging @@ -851,13 +846,12 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) static void yaffs_put_inode(struct inode *inode) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, - atomic_read(&inode->i_count))); + (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, + atomic_read(&inode->i_count))); } #endif - static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) { /* Clear the association between the inode and @@ -878,7 +872,7 @@ static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) * yaffs_clear_inode() and yaffs_delete_inode() * */ -static void yaffs_evict_inode( struct inode *inode) +static void yaffs_evict_inode(struct inode *inode) { struct yaffs_obj *obj; struct yaffs_dev *dev; @@ -887,16 +881,16 @@ static void yaffs_evict_inode( struct inode *inode) obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (!inode->i_nlink && !is_bad_inode(inode)) deleteme = 1; - truncate_inode_pages(&inode->i_data,0); + truncate_inode_pages(&inode->i_data, 0); end_writeback(inode); - if(deleteme && obj){ + if (deleteme && obj) { dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); @@ -905,11 +899,10 @@ static void yaffs_evict_inode( struct inode *inode) if (obj) { dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_unstitch_obj(inode,obj); + yaffs_unstitch_obj(inode, obj); yaffs_gross_unlock(dev); } - } #else @@ -928,14 +921,14 @@ static void yaffs_clear_inode(struct inode *inode) obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (obj) { dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_unstitch_obj(inode,obj); + yaffs_unstitch_obj(inode, obj); yaffs_gross_unlock(dev); } @@ -952,9 +945,9 @@ static void yaffs_delete_inode(struct inode *inode) struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (obj) { dev = obj->my_dev; @@ -969,7 +962,6 @@ static void yaffs_delete_inode(struct inode *inode) } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_file_flush(struct file *file, fl_owner_t id) #else @@ -981,8 +973,8 @@ static int yaffs_file_flush(struct file *file) struct yaffs_dev *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, - obj->dirty ? "dirty" : "clean")); + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, + obj->dirty ? "dirty" : "clean")); yaffs_gross_lock(dev); @@ -1004,9 +996,9 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), - (unsigned)(pg->index << PAGE_CACHE_SHIFT), - (unsigned)PAGE_CACHE_SIZE)); + (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), + (unsigned)(pg->index << PAGE_CACHE_SHIFT), + (unsigned)PAGE_CACHE_SIZE)); obj = yaffs_dentry_to_obj(f->f_dentry); @@ -1025,8 +1017,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) yaffs_gross_lock(dev); ret = yaffs_file_rd(obj, pg_buf, - pg->index << PAGE_CACHE_SHIFT, - PAGE_CACHE_SIZE); + pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); yaffs_gross_unlock(dev); @@ -1060,7 +1051,7 @@ static int yaffs_readpage(struct file *f, struct page *pg) int ret; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n"))); - ret=yaffs_readpage_unlock(f, pg); + ret = yaffs_readpage_unlock(f, pg); T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n"))); return ret; } @@ -1092,20 +1083,21 @@ static int yaffs_writepage(struct page *page) end_index = i_size >> PAGE_CACHE_SHIFT; - if(page->index < end_index) + if (page->index < end_index) n_bytes = PAGE_CACHE_SIZE; else { - n_bytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE - 1); if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), - (unsigned)inode->i_size)); + (TSTR + ("yaffs_writepage at %08x, inode size = %08x!!!\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), + (unsigned)inode->i_size)); T(YAFFS_TRACE_OS, - (TSTR(" -> don't care!!\n"))); + (TSTR(" -> don't care!!\n"))); - zero_user_segment(page,0,PAGE_CACHE_SIZE); + zero_user_segment(page, 0, PAGE_CACHE_SIZE); set_page_writeback(page); unlock_page(page); end_page_writeback(page); @@ -1113,8 +1105,8 @@ static int yaffs_writepage(struct page *page) } } - if(n_bytes != PAGE_CACHE_SIZE) - zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); + if (n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE); get_page(page); @@ -1125,20 +1117,20 @@ static int yaffs_writepage(struct page *page) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); + (TSTR("yaffs_writepage at %08x, size %08x\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, - (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag0: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); n_written = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, n_bytes, 0); + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag1: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); yaffs_gross_unlock(dev); @@ -1151,11 +1143,10 @@ static int yaffs_writepage(struct page *page) return (n_written == n_bytes) ? 0 : -ENOSPC; } - #if (YAFFS_USE_WRITE_BEGIN_END > 0) static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata) + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata) { struct page *pg = NULL; pgoff_t index = pos >> PAGE_CACHE_SHIFT; @@ -1172,12 +1163,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, *pagep = pg; if (!pg) { - ret = -ENOMEM; + ret = -ENOMEM; goto out; } T(YAFFS_TRACE_OS, - (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), - (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0)); + (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), + (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0)); /* Get fs space */ space_held = yaffs_hold_space(filp); @@ -1202,7 +1193,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, out: T(YAFFS_TRACE_OS, - (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); + (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); if (space_held) yaffs_release_space(filp); if (pg) { @@ -1215,7 +1206,7 @@ out: #else static int yaffs_prepare_write(struct file *f, struct page *pg, - unsigned offset, unsigned to) + unsigned offset, unsigned to) { T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n"))); @@ -1227,8 +1218,8 @@ static int yaffs_prepare_write(struct file *f, struct page *pg, #if (YAFFS_USE_WRITE_BEGIN_END > 0) static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata) + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata) { int ret = 0; void *addr, *kva; @@ -1238,15 +1229,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x n_bytes %d\n", - addr,(unsigned)pos, copied)); + ("yaffs_write_end addr %p pos %x n_bytes %d\n", + addr, (unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); if (ret != copied) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_write_end not same size ret %d copied %d\n"), - ret, copied)); + (TSTR("yaffs_write_end not same size ret %d copied %d\n"), + ret, copied)); SetPageError(pg); } else { /* Nothing */ @@ -1262,7 +1253,7 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, #else static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, - unsigned to) + unsigned to) { void *addr, *kva; @@ -1276,18 +1267,19 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, kva = kmap(pg); addr = kva + offset; - saddr = (unsigned) addr; + saddr = (unsigned)addr; T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), - saddr, spos, n_bytes)); + (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), + saddr, spos, n_bytes)); n_written = yaffs_file_write(f, addr, n_bytes, &pos); if (n_written != n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write not same size n_written %d n_bytes %d\n"), - n_written, n_bytes)); + (TSTR + ("yaffs_commit_write not same size n_written %d n_bytes %d\n"), + n_written, n_bytes)); SetPageError(pg); } else { /* Nothing */ @@ -1296,19 +1288,18 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, kunmap(pg); T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write returning %d\n"), - n_written == n_bytes ? 0 : n_written)); + (TSTR("yaffs_commit_write returning %d\n"), + n_written == n_bytes ? 0 : n_written)); return n_written == n_bytes ? 0 : n_written; } #endif - -static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, + struct yaffs_obj *obj) { if (inode && obj) { - /* Check mode against the variant type and attempt to repair if broken. */ u32 mode = obj->yst_mode; switch (obj->variant_type) { @@ -1371,25 +1362,26 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj inode->i_nlink = yaffs_get_obj_link_count(obj); T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), - inode->i_mode, inode->i_uid, inode->i_gid, - (int)inode->i_size, atomic_read(&inode->i_count))); + (TSTR + ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), + inode->i_mode, inode->i_uid, inode->i_gid, + (int)inode->i_size, atomic_read(&inode->i_count))); switch (obj->yst_mode & S_IFMT) { default: /* fifo, device or socket */ #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) init_special_inode(inode, obj->yst_mode, - old_decode_dev(obj->yst_rdev)); + old_decode_dev(obj->yst_rdev)); #else init_special_inode(inode, obj->yst_mode, - (dev_t) (obj->yst_rdev)); + (dev_t) (obj->yst_rdev)); #endif break; case S_IFREG: /* file */ inode->i_op = &yaffs_file_inode_operations; inode->i_fop = &yaffs_file_operations; inode->i_mapping->a_ops = - &yaffs_file_address_operations; + &yaffs_file_address_operations; break; case S_IFDIR: /* directory */ inode->i_op = &yaffs_dir_inode_operations; @@ -1406,32 +1398,32 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode invalid parameters\n"))); + (TSTR("yaffs_fill_inode invalid parameters\n"))); } } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - struct yaffs_obj *obj) + struct yaffs_obj *obj) { struct inode *inode; if (!sb) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL super_block!!\n"))); + (TSTR("yaffs_get_inode for NULL super_block!!\n"))); return NULL; } if (!obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL object!!\n"))); + (TSTR("yaffs_get_inode for NULL object!!\n"))); return NULL; } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) @@ -1445,7 +1437,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, } static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos) + loff_t * pos) { struct yaffs_obj *obj; int n_written, ipos; @@ -1467,20 +1459,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, if (!obj) T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: hey obj is null!\n"))); + (TSTR("yaffs_file_write: hey obj is null!\n"))); else T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write about to write writing %u(%x) bytes" + (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); + (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos)); n_written = yaffs_wr_file(obj, buf, ipos, n, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: %d(%x) bytes written\n"), - (unsigned )n,(unsigned)n)); + (TSTR("yaffs_file_write: %d(%x) bytes written\n"), + (unsigned)n, (unsigned)n)); if (n_written > 0) { ipos += n_written; @@ -1490,9 +1482,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, inode->i_blocks = (ipos + 511) >> 9; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write size updated to %d bytes, " - "%d blocks\n"), - ipos, (int)(inode->i_blocks))); + (TSTR("yaffs_file_write size updated to %d bytes, " + "%d blocks\n"), ipos, (int)(inode->i_blocks))); } } @@ -1511,7 +1502,6 @@ static ssize_t yaffs_hold_space(struct file *f) int n_free_chunks; - obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; @@ -1530,25 +1520,22 @@ static void yaffs_release_space(struct file *f) struct yaffs_obj *obj; struct yaffs_dev *dev; - obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_gross_unlock(dev); } - static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) { long long retval; lock_kernel(); - switch (origin){ + switch (origin) { case 2: offset += i_size_read(file->f_path.dentry->d_inode); break; @@ -1557,7 +1544,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) } retval = -EINVAL; - if (offset >= 0){ + if (offset >= 0) { if (offset != file->f_pos) file->f_pos = offset; @@ -1567,16 +1554,15 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) return retval; } - static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { struct yaffs_obj *obj; struct yaffs_dev *dev; - struct yaffs_search_context *sc; + struct yaffs_search_context *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; struct yaffs_obj *l; - int ret_val = 0; + int ret_val = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; @@ -1589,20 +1575,21 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) offset = f->f_pos; - sc = yaffs_new_search(obj); - if(!sc){ - ret_val = -ENOMEM; - goto out; - } + sc = yaffs_new_search(obj); + if (!sc) { + ret_val = -ENOMEM; + goto out; + } - T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); if (offset == 0) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry . ino %d \n"), - (int)inode->i_ino)); + (TSTR("yaffs_readdir: entry . ino %d \n"), + (int)inode->i_ino)); yaffs_gross_unlock(dev); - if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){ + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1612,11 +1599,12 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) } if (offset == 1) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry .. ino %d \n"), - (int)f->f_dentry->d_parent->d_inode->i_ino)); + (TSTR("yaffs_readdir: entry .. ino %d \n"), + (int)f->f_dentry->d_parent->d_inode->i_ino)); yaffs_gross_unlock(dev); if (filldir(dirent, "..", 2, offset, - f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){ + f->f_dentry->d_parent->d_inode->i_ino, + DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1635,37 +1623,34 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) f->f_version = inode->i_version; } - while(sc->next_return){ + while (sc->next_return) { curoffs++; - l = sc->next_return; + l = sc->next_return; if (curoffs >= offset) { - int this_inode = yaffs_get_obj_inode(l); - int this_type = yaffs_get_obj_type(l); + int this_inode = yaffs_get_obj_inode(l); + int this_type = yaffs_get_obj_type(l); - yaffs_get_obj_name(l, name, - YAFFS_MAX_NAME_LENGTH + 1); + yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1); T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: %s inode %d\n"), - name, yaffs_get_obj_inode(l))); + name, yaffs_get_obj_inode(l))); - yaffs_gross_unlock(dev); + yaffs_gross_unlock(dev); if (filldir(dirent, - name, - strlen(name), - offset, - this_inode, - this_type) < 0){ + name, + strlen(name), + offset, this_inode, this_type) < 0) { yaffs_gross_lock(dev); goto out; } - yaffs_gross_lock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } - yaffs_search_advance(sc); + yaffs_search_advance(sc); } out: @@ -1676,8 +1661,6 @@ out: return ret_val; } - - /* * File creation. Allocate an inode, and we're done.. */ @@ -1690,10 +1673,10 @@ out: #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t rdev) + dev_t rdev) #else static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - int rdev) + int rdev) #endif { struct inode *inode; @@ -1705,24 +1688,25 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; if ((dir->i_mode & S_ISGID) && S_ISDIR(mode)) mode |= S_ISGID; if (parent) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->obj_id, parent->variant_type)); + (TSTR("yaffs_mknod: parent object %d type %d\n"), + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: could not get parent object\n"))); + (TSTR("yaffs_mknod: could not get parent object\n"))); return -EPERM; } T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, " - "mode %x dev %x\n"), - dentry->d_name.name, mode, rdev)); + "mode %x dev %x\n"), + dentry->d_name.name, mode, rdev)); dev = parent->my_dev; @@ -1733,23 +1717,24 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, /* Special (socket, fifo, device...) */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n"))); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) - obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, - gid, old_encode_dev(rdev)); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, old_encode_dev(rdev)); #else - obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, - gid, rdev); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, rdev); #endif break; case S_IFREG: /* file */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n"))); obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid, - gid); + gid); break; case S_IFDIR: /* directory */ - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: making directory\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n"))); obj = yaffs_create_dir(parent, dentry->d_name.name, mode, - uid, gid); + uid, gid); break; case S_IFLNK: /* symlink */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n"))); @@ -1765,13 +1750,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, d_instantiate(dentry, inode); update_dir_time(dir); T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->obj_id, atomic_read(&inode->i_count))); + (TSTR("yaffs_mknod created object %d count = %d\n"), + obj->obj_id, atomic_read(&inode->i_count))); error = 0; - yaffs_fill_inode_from_obj(dir,parent); + yaffs_fill_inode_from_obj(dir, parent); } else { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod failed making object\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n"))); error = -ENOMEM; } @@ -1793,7 +1777,7 @@ static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode) #endif { - T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n"))); return yaffs_mknod(dir, dentry, mode | S_IFREG, 0); } @@ -1805,9 +1789,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) struct yaffs_obj *obj; T(YAFFS_TRACE_OS, - (TSTR("yaffs_unlink %d:%s\n"), - (int)(dir->i_ino), - dentry->d_name.name)); + (TSTR("yaffs_unlink %d:%s\n"), + (int)(dir->i_ino), dentry->d_name.name)); obj = yaffs_inode_to_obj(dir); dev = obj->my_dev; @@ -1831,7 +1814,7 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) * Create a link... */ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry) + struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; struct yaffs_obj *obj = NULL; @@ -1845,23 +1828,24 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, yaffs_gross_lock(dev); - if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, - obj); + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ + link = + yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, + obj); if (link) { old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); d_instantiate(dentry, old_dentry->d_inode); atomic_inc(&old_dentry->d_inode->i_count); T(YAFFS_TRACE_OS, - (TSTR("yaffs_link link count %d i_count %d\n"), - old_dentry->d_inode->i_nlink, - atomic_read(&old_dentry->d_inode->i_count))); + (TSTR("yaffs_link link count %d i_count %d\n"), + old_dentry->d_inode->i_nlink, + atomic_read(&old_dentry->d_inode->i_count))); } yaffs_gross_unlock(dev); - if (link){ + if (link) { update_dir_time(dir); return 0; } @@ -1870,19 +1854,20 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, } static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname) + const char *symname) { struct yaffs_obj *obj; struct yaffs_dev *dev; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); dev = yaffs_inode_to_obj(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name, - S_IFLNK | S_IRWXUGO, uid, gid, symname); + S_IFLNK | S_IRWXUGO, uid, gid, symname); yaffs_gross_unlock(dev); if (obj) { @@ -1904,7 +1889,7 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry, static int yaffs_sync_object(struct file *file, int datasync) #else static int yaffs_sync_object(struct file *file, struct dentry *dentry, - int datasync) + int datasync) #endif { @@ -1918,8 +1903,7 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry, dev = obj->my_dev; - T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_object\n"))); + T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); yaffs_gross_lock(dev); yaffs_flush_file(obj, 1, datasync); yaffs_gross_unlock(dev); @@ -1945,12 +1929,10 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, /* Check if the target is an existing directory that is not empty. */ target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); - - + new_dentry->d_name.name); if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - !list_empty(&target->variant.dir_variant.children)) { + !list_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); @@ -1960,9 +1942,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n"))); ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir), - old_dentry->d_name.name, - yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); + old_dentry->d_name.name, + yaffs_inode_to_obj(new_dir), + new_dentry->d_name.name); } yaffs_gross_unlock(dev); @@ -1971,9 +1953,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, new_dentry->d_inode->i_nlink--; mark_inode_dirty(new_dentry->d_inode); } - + update_dir_time(old_dir); - if(old_dir != new_dir) + if (old_dir != new_dir) update_dir_time(new_dir); return 0; } else { @@ -1988,34 +1970,34 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr of object %d\n"), - yaffs_inode_to_obj(inode)->obj_id)); + (TSTR("yaffs_setattr of object %d\n"), + yaffs_inode_to_obj(inode)->obj_id)); - /* Fail if a requested resize >= 2GB */ - if (attr->ia_valid & ATTR_SIZE && - (attr->ia_size >> 31)) + /* Fail if a requested resize >= 2GB */ + if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31)) error = -EINVAL; if (error == 0) error = inode_change_ok(inode, attr); if (error == 0) { int result; - if (!error){ + if (!error) { error = yaffs_vfs_setattr(inode, attr); - T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n"))); - if (attr->ia_valid & ATTR_SIZE){ - yaffs_vfs_setsize(inode,attr->ia_size); - inode->i_blocks = (inode->i_size + 511) >> 9; + T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n"))); + if (attr->ia_valid & ATTR_SIZE) { + yaffs_vfs_setsize(inode, attr->ia_size); + inode->i_blocks = (inode->i_size + 511) >> 9; } } dev = yaffs_inode_to_obj(inode)->my_dev; - if (attr->ia_valid & ATTR_SIZE){ - T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), - (int)(attr->ia_size),(int)(attr->ia_size))); + if (attr->ia_valid & ATTR_SIZE) { + T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"), + (int)(attr->ia_size), + (int)(attr->ia_size))); } yaffs_gross_lock(dev); result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr); - if(result == YAFFS_OK) { + if (result == YAFFS_OK) { error = 0; } else { error = -EPERM; @@ -2024,47 +2006,41 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error)); return error; } #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags) + const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error = 0; struct yaffs_dev *dev; struct yaffs_obj *obj = yaffs_inode_to_obj(inode); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr of object %d\n"), - obj->obj_id)); - + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_set_xattrib(obj, name, value, size, flags); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error)); return error; } - -ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size) +ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff, + size_t size) { struct inode *inode = dentry->d_inode; int error = 0; @@ -2072,8 +2048,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->obj_id)); + (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -2082,8 +2057,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error)); return error; } @@ -2096,29 +2070,27 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_remove_xattrib(obj, name); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr done returning %d\n"),error)); + (TSTR("yaffs_removexattr done returning %d\n"), error)); return error; } -ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) +ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; @@ -2126,9 +2098,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -2137,15 +2107,13 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error)); return error; } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { @@ -2175,14 +2143,17 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) uint64_t bytes_in_dev; uint64_t bytes_free; - bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * - ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); + bytes_in_dev = + ((uint64_t) + ((dev->param.end_block - dev->param.start_block + + 1))) * ((uint64_t) (dev->param.chunks_per_block * + dev->data_bytes_per_chunk)); - do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ + do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ buf->f_blocks = bytes_in_dev; - bytes_free = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * - ((uint64_t)(dev->data_bytes_per_chunk)); + bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) * + ((uint64_t) (dev->data_bytes_per_chunk)); do_div(bytes_free, sb->s_blocksize); @@ -2191,21 +2162,21 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block / - (sb->s_blocksize / dev->data_bytes_per_chunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = - yaffs_get_n_free_chunks(dev) / - (sb->s_blocksize / dev->data_bytes_per_chunk); + yaffs_get_n_free_chunks(dev) / + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block * - (dev->data_bytes_per_chunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = - yaffs_get_n_free_chunks(dev) * - (dev->data_bytes_per_chunk / sb->s_blocksize); + yaffs_get_n_free_chunks(dev) * + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; @@ -2216,61 +2187,57 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) return 0; } - - static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; struct yaffs_obj *obj; - - list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ + + list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) { obj = yaffs_inode_to_obj(iptr); - if(obj){ + if (obj) { T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->obj_id)); - yaffs_flush_file(obj,1,0); + obj->obj_id)); + yaffs_flush_file(obj, 1, 0); } } } - static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - struct yaffs_dev *dev = yaffs_super_to_dev(sb); - if(!dev) + struct yaffs_dev *dev = yaffs_super_to_dev(sb); + if (!dev) return; - + yaffs_flush_inodes(sb); yaffs_update_dirty_dirs(dev); yaffs_flush_whole_cache(dev); - if(do_checkpoint) + if (do_checkpoint) yaffs_checkpoint_save(dev); } - static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev) { - unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + unsigned erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - unsigned scattered = 0; /* Free chunks not in an erased block */ + unsigned scattered = 0; /* Free chunks not in an erased block */ - if(erased_chunks < dev->n_free_chunks) + if (erased_chunks < dev->n_free_chunks) scattered = (dev->n_free_chunks - erased_chunks); - if(!context->bg_running) + if (!context->bg_running) return 0; - else if(scattered < (dev->param.chunks_per_block * 2)) + else if (scattered < (dev->param.chunks_per_block * 2)) return 0; - else if(erased_chunks > dev->n_free_chunks/2) + else if (erased_chunks > dev->n_free_chunks / 2) return 0; - else if(erased_chunks > dev->n_free_chunks/4) + else if (erased_chunks > dev->n_free_chunks / 4) return 1; else return 2; } -static int yaffs_do_sync_fs(struct super_block *sb, - int request_checkpoint) +static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { struct yaffs_dev *dev = yaffs_super_to_dev(sb); @@ -2279,21 +2246,20 @@ static int yaffs_do_sync_fs(struct super_block *sb, int do_checkpoint; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), - gc_urgent, - sb->s_dirt ? "dirty" : "clean", - request_checkpoint ? "checkpoint requested" : "no checkpoint", - oneshot_checkpoint ? " one-shot" : "" )); + (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), + gc_urgent, + sb->s_dirt ? "dirty" : "clean", + request_checkpoint ? "checkpoint requested" : "no checkpoint", + oneshot_checkpoint ? " one-shot" : "")); yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || - oneshot_checkpoint) && - !dev->is_checkpointed; + oneshot_checkpoint) && !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; - if(oneshot_checkpoint) + if (oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; } yaffs_gross_unlock(dev); @@ -2334,62 +2300,60 @@ static int yaffs_bg_thread_fn(void *data) struct timer_list timer; T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background starting for dev %p\n"), - (void *)dev)); + (TSTR("yaffs_background starting for dev %p\n"), (void *)dev)); #ifdef YAFFS_COMPILE_FREEZER set_freezable(); #endif - while(context->bg_running){ - T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background\n"))); + while (context->bg_running) { + T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n"))); - if(kthread_should_stop()) + if (kthread_should_stop()) break; #ifdef YAFFS_COMPILE_FREEZER - if(try_to_freeze()) + if (try_to_freeze()) continue; #endif yaffs_gross_lock(dev); now = jiffies; - if(time_after(now, next_dir_update) && yaffs_bg_enable){ + if (time_after(now, next_dir_update) && yaffs_bg_enable) { yaffs_update_dirty_dirs(dev); next_dir_update = now + HZ; } - if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->is_checkpointed){ + if (time_after(now, next_gc) && yaffs_bg_enable) { + if (!dev->is_checkpointed) { urgency = yaffs_bg_gc_urgency(dev); gc_result = yaffs_bg_gc(dev, urgency); - if(urgency > 1) - next_gc = now + HZ/20+1; - else if(urgency > 0) - next_gc = now + HZ/10+1; + if (urgency > 1) + next_gc = now + HZ / 20 + 1; + else if (urgency > 0) + next_gc = now + HZ / 10 + 1; else next_gc = now + HZ * 2; - } else /* - * gc not running so set to next_dir_update - * to cut down on wake ups - */ + } else /* + * gc not running so set to next_dir_update + * to cut down on wake ups + */ next_gc = next_dir_update; } yaffs_gross_unlock(dev); #if 1 expires = next_dir_update; - if (time_before(next_gc,expires)) + if (time_before(next_gc, expires)) expires = next_gc; - if(time_before(expires,now)) + if (time_before(expires, now)) expires = now + HZ; Y_INIT_TIMER(&timer); - timer.expires = expires+1; - timer.data = (unsigned long) current; + timer.expires = expires + 1; + timer.data = (unsigned long)current; timer.function = yaffs_background_waker; - set_current_state(TASK_INTERRUPTIBLE); + set_current_state(TASK_INTERRUPTIBLE); add_timer(&timer); schedule(); del_timer_sync(&timer); @@ -2406,15 +2370,16 @@ static int yaffs_bg_start(struct yaffs_dev *dev) int retval = 0; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - if(dev->read_only) + if (dev->read_only) return -1; context->bg_running = 1; context->bg_thread = kthread_run(yaffs_bg_thread_fn, - (void *)dev,"yaffs-bg-%d",context->mount_id); + (void *)dev, "yaffs-bg-%d", + context->mount_id); - if(IS_ERR(context->bg_thread)){ + if (IS_ERR(context->bg_thread)) { retval = PTR_ERR(context->bg_thread); context->bg_thread = NULL; context->bg_running = 0; @@ -2428,7 +2393,7 @@ static void yaffs_bg_stop(struct yaffs_dev *dev) ctxt->bg_running = 0; - if( ctxt->bg_thread){ + if (ctxt->bg_thread) { kthread_stop(ctxt->bg_thread); ctxt->bg_thread = NULL; } @@ -2449,7 +2414,6 @@ static void yaffs_bg_stop(struct yaffs_dev *dev) } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static void yaffs_write_super(struct super_block *sb) #else @@ -2459,8 +2423,8 @@ static int yaffs_write_super(struct super_block *sb) unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_write_super%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_write_super%s\n"), + request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2469,7 +2433,6 @@ static int yaffs_write_super(struct super_block *sb) #endif } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_sync_fs(struct super_block *sb, int wait) #else @@ -2479,8 +2442,7 @@ static int yaffs_sync_fs(struct super_block *sb) unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_fs%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2495,8 +2457,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) struct yaffs_obj *obj; struct yaffs_dev *dev = yaffs_super_to_dev(sb); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_iget for %lu\n"), ino)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); inode = iget_locked(sb, ino); if (!inode) @@ -2534,16 +2495,16 @@ static void yaffs_read_inode(struct inode *inode) struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); + (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_lock(dev); obj = yaffs_find_by_number(dev, inode->i_ino); yaffs_fill_inode_from_obj(inode, obj); - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_unlock(dev); } @@ -2559,19 +2520,18 @@ static void yaffs_put_super(struct super_block *sb) T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("Shutting down yaffs background thread\n"))); + (TSTR("Shutting down yaffs background thread\n"))); yaffs_bg_stop(dev); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs background thread shut down\n"))); + (TSTR("yaffs background thread shut down\n"))); yaffs_gross_lock(dev); - yaffs_flush_super(sb,1); + yaffs_flush_super(sb, 1); if (yaffs_dev_to_lc(dev)->put_super_fn) yaffs_dev_to_lc(dev)->put_super_fn(sb); - yaffs_deinitialise(dev); yaffs_gross_unlock(dev); @@ -2588,7 +2548,6 @@ static void yaffs_put_super(struct super_block *sb) kfree(dev); } - static void yaffs_mtd_put_super(struct super_block *sb) { struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb)); @@ -2599,7 +2558,6 @@ static void yaffs_mtd_put_super(struct super_block *sb) put_mtd_device(mtd); } - static void yaffs_touch_super(struct yaffs_dev *dev) { struct super_block *sb = yaffs_dev_to_lc(dev)->super; @@ -2620,10 +2578,11 @@ struct yaffs_options { int lazy_loading_overridden; int empty_lost_and_found; int empty_lost_and_found_overridden; -} ; +}; #define MAX_OPT_LEN 30 -static int yaffs_parse_options(struct yaffs_options *options, const char *options_str) +static int yaffs_parse_options(struct yaffs_options *options, + const char *options_str) { char cur_opt[MAX_OPT_LEN + 1]; int p; @@ -2635,7 +2594,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option memset(cur_opt, 0, MAX_OPT_LEN + 1); p = 0; - while(*options_str == ',') + while (*options_str == ',') options_str++; while (*options_str && *options_str != ',') { @@ -2648,24 +2607,24 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option if (!strcmp(cur_opt, "inband-tags")) options->inband_tags = 1; - else if (!strcmp(cur_opt, "tags-ecc-off")){ + else if (!strcmp(cur_opt, "tags-ecc-off")) { options->tags_ecc_on = 0; - options->tags_ecc_overridden=1; - } else if (!strcmp(cur_opt, "tags-ecc-on")){ + options->tags_ecc_overridden = 1; + } else if (!strcmp(cur_opt, "tags-ecc-on")) { options->tags_ecc_on = 1; options->tags_ecc_overridden = 1; - } else if (!strcmp(cur_opt, "lazy-loading-off")){ + } else if (!strcmp(cur_opt, "lazy-loading-off")) { options->lazy_loading_enabled = 0; - options->lazy_loading_overridden=1; - } else if (!strcmp(cur_opt, "lazy-loading-on")){ + options->lazy_loading_overridden = 1; + } else if (!strcmp(cur_opt, "lazy-loading-on")) { options->lazy_loading_enabled = 1; options->lazy_loading_overridden = 1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){ + } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) { options->empty_lost_and_found = 0; - options->empty_lost_and_found_overridden=1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){ + options->empty_lost_and_found_overridden = 1; + } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) { options->empty_lost_and_found = 1; - options->empty_lost_and_found_overridden=1; + options->empty_lost_and_found_overridden = 1; } else if (!strcmp(cur_opt, "no-cache")) options->no_cache = 1; else if (!strcmp(cur_opt, "no-checkpoint-read")) @@ -2677,7 +2636,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option options->skip_checkpoint_write = 1; } else { printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n", - cur_opt); + cur_opt); error = 1; } } @@ -2686,8 +2645,8 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option } static struct super_block *yaffs_internal_read_super(int yaffs_version, - struct super_block *sb, - void *data, int silent) + struct super_block *sb, + void *data, int silent) { int n_blocks; struct inode *inode = NULL; @@ -2713,8 +2672,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - read_only =((sb->s_flags & MS_RDONLY) != 0); - + read_only = ((sb->s_flags & MS_RDONLY) != 0); #ifdef YAFFS_COMPILE_EXPORTFS sb->s_export_op = &yaffs_export_ops; @@ -2729,8 +2687,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, else printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, - yaffs_devname(sb, devname_buf), - read_only ? "ro" : "rw"); + yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2744,20 +2701,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, return NULL; } - sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); + (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: block size %d\n"), - (int)(sb->s_blocksize))); + (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize))); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), - MAJOR(sb->s_dev), MINOR(sb->s_dev), - yaffs_devname(sb, devname_buf))); + (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), + MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf))); /* Check it's an mtd device..... */ if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) @@ -2767,15 +2721,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); if (!mtd) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), - MINOR(sb->s_dev))); + (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), + MINOR(sb->s_dev))); return NULL; } /* Check it's NAND */ if (mtd->type != MTD_NANDFLASH) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device is not NAND it's type %d\n"), - mtd->type)); + (TSTR("yaffs: MTD device is not NAND it's type %d\n"), + mtd->type)); return NULL; } @@ -2798,27 +2752,23 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_AUTO_YAFFS2 if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs2\n"))); + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n"))); yaffs_version = 2; } /* Added NCB 26/5/2006 for completeness */ - if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs1\n"))); + if (yaffs_version == 2 && !options.inband_tags + && WRITE_SIZE(mtd) == 512) { + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n"))); yaffs_version = 1; } - #endif if (yaffs_version == 2) { /* Check for version 2 style functions */ if (!mtd->erase || !mtd->block_isbad || - !mtd->block_markbad || - !mtd->read || - !mtd->write || + !mtd->block_markbad || !mtd->read || !mtd->write || #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) !mtd->read_oob || !mtd->write_oob) { #else @@ -2827,23 +2777,21 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #endif T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE || - mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && !options.inband_tags) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } else { /* Check for V1 style functions */ - if (!mtd->erase || - !mtd->read || - !mtd->write || + if (!mtd->erase || !mtd->read || !mtd->write || #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) !mtd->read_oob || !mtd->write_oob) { #else @@ -2852,7 +2800,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #endif T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } @@ -2860,7 +2808,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd->oobsize != YAFFS_BYTES_PER_SPARE) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } @@ -2870,19 +2818,20 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, * Set the struct yaffs_dev up for mtd */ - if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ + if (!read_only && !(mtd->flags & MTD_WRITEABLE)) { read_only = 1; - printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); + printk(KERN_INFO + "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL); - context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL); - - if(!dev || !context ){ - if(dev) + context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL); + + if (!dev || !context) { + if (dev) kfree(dev); - if(context) + if (context) kfree(context); dev = NULL; context = NULL; @@ -2892,13 +2841,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "struct yaffs_dev. \n"))); + "struct yaffs_dev. \n"))); return NULL; } memset(dev, 0, sizeof(struct yaffs_dev)); param = &(dev->param); - memset(context,0,sizeof(struct yaffs_linux_context)); + memset(context, 0, sizeof(struct yaffs_linux_context)); dev->os_context = context; INIT_LIST_HEAD(&(context->context_list)); context->dev = dev; @@ -2911,13 +2860,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #else sb->u.generic_sbp = dev; #endif - + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ - n_blocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); + n_blocks = + YCALCBLOCKS(mtd->size, + (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); param->start_block = 0; param->end_block = n_blocks - 1; @@ -2933,7 +2884,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_XATTR param->enable_xattr = 1; #endif - if(options.lazy_loading_overridden) + if (options.lazy_loading_overridden) param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC @@ -2945,7 +2896,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->defered_dir_update = 1; #endif - if(options.tags_ecc_overridden) + if (options.tags_ecc_overridden) param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND @@ -2962,15 +2913,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->always_check_erased = 1; #endif - if(options.empty_lost_and_found_overridden) + if (options.empty_lost_and_found_overridden) param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ if (yaffs_version == 2) { - param->write_chunk_tags_fn = - nandmtd2_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd2_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd2_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd2_read_chunk_tags; param->bad_block_fn = nandmtd2_mark_block_bad; param->query_block_fn = nandmtd2_query_block; yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize); @@ -2989,10 +2938,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, } else { #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) /* use the MTD interface in yaffs_mtdif1.c */ - param->write_chunk_tags_fn = - nandmtd1_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd1_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd1_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd1_read_chunk_tags; param->bad_block_fn = nandmtd1_mark_block_bad; param->query_block_fn = nandmtd1_query_block; #else @@ -3010,8 +2957,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->sb_dirty_fn = yaffs_touch_super; param->gc_control = yaffs_gc_control_callback; - yaffs_dev_to_lc(dev)->super= sb; - + yaffs_dev_to_lc(dev)->super = sb; #ifndef CONFIG_YAFFS_DOES_ECC param->use_nand_ecc = 1; @@ -3027,22 +2973,25 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, down(&yaffs_context_lock); /* Get a mount id */ found = 0; - for(mount_id=0; ! found; mount_id++){ + for (mount_id = 0; !found; mount_id++) { found = 1; - list_for_each(l,&yaffs_context_list){ - context_iterator = list_entry(l,struct yaffs_linux_context,context_list); - if(context_iterator->mount_id == mount_id) + list_for_each(l, &yaffs_context_list) { + context_iterator = + list_entry(l, struct yaffs_linux_context, + context_list); + if (context_iterator->mount_id == mount_id) found = 0; } } context->mount_id = mount_id; - list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list); + list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), + &yaffs_context_list); up(&yaffs_context_lock); - /* Directory search handling...*/ - INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); - param->remove_obj_fn = yaffs_remove_obj_callback; + /* Directory search handling... */ + INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); + param->remove_obj_fn = yaffs_remove_obj_callback; init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock)); @@ -3053,21 +3002,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: guts initialised %s\n"), (err == YAFFS_OK) ? "OK" : "FAILED")); - - if(err == YAFFS_OK) + + if (err == YAFFS_OK) yaffs_bg_start(dev); - - if(!context->bg_thread) - param->defered_dir_update = 0; + if (!context->bg_thread) + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ yaffs_gross_unlock(dev); /* Create root inode */ if (err == YAFFS_OK) - inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_root(dev)); + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev)); if (!inode) return NULL; @@ -3088,14 +3035,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_root = root; sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: is_checkpointed %d\n"), - dev->is_checkpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, int silent) @@ -3141,7 +3087,6 @@ static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV); #endif - #ifdef CONFIG_YAFFS_YAFFS2 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) @@ -3153,11 +3098,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs2_read_super(struct file_system_type *fs, - int flags, const char *dev_name, void *data, - struct vfsmount *mnt) + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) { return get_sb_bdev(fs, flags, dev_name, data, - yaffs2_internal_read_super_mtd, mnt); + yaffs2_internal_read_super_mtd, mnt); } #else static struct super_block *yaffs2_read_super(struct file_system_type *fs, @@ -3188,40 +3133,58 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_DEV); #endif -#endif /* CONFIG_YAFFS_YAFFS2 */ +#endif /* CONFIG_YAFFS_YAFFS2 */ static struct proc_dir_entry *my_proc_entry; static struct proc_dir_entry *debug_proc_entry; -static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev * dev) +static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "start_block.......... %d\n", dev->param.start_block); + buf += + sprintf(buf, "start_block.......... %d\n", dev->param.start_block); buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block); - buf += sprintf(buf, "total_bytes_per_chunk %d\n", dev->param.total_bytes_per_chunk); - buf += sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); - buf += sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); + buf += + sprintf(buf, "total_bytes_per_chunk %d\n", + dev->param.total_bytes_per_chunk); + buf += + sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); + buf += + sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); buf += sprintf(buf, "is_yaffs2............ %d\n", dev->param.is_yaffs2); - buf += sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags); - buf += sprintf(buf, "empty_lost_n_found... %d\n", dev->param.empty_lost_n_found); - buf += sprintf(buf, "disable_lazy_load.... %d\n", dev->param.disable_lazy_load); - buf += sprintf(buf, "refresh_period....... %d\n", dev->param.refresh_period); + buf += + sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags); + buf += + sprintf(buf, "empty_lost_n_found... %d\n", + dev->param.empty_lost_n_found); + buf += + sprintf(buf, "disable_lazy_load.... %d\n", + dev->param.disable_lazy_load); + buf += + sprintf(buf, "refresh_period....... %d\n", + dev->param.refresh_period); buf += sprintf(buf, "n_caches............. %d\n", dev->param.n_caches); - buf += sprintf(buf, "n_reserved_blocks.... %d\n", dev->param.n_reserved_blocks); - buf += sprintf(buf, "always_check_erased.. %d\n", dev->param.always_check_erased); + buf += + sprintf(buf, "n_reserved_blocks.... %d\n", + dev->param.n_reserved_blocks); + buf += + sprintf(buf, "always_check_erased.. %d\n", + dev->param.always_check_erased); buf += sprintf(buf, "\n"); return buf; } - -static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev) +static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "data_bytes_per_chunk. %d\n", dev->data_bytes_per_chunk); + buf += + sprintf(buf, "data_bytes_per_chunk. %d\n", + dev->data_bytes_per_chunk); buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits); buf += sprintf(buf, "chunk_grp_size....... %d\n", dev->chunk_grp_size); buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks); - buf += sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt); + buf += + sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt); buf += sprintf(buf, "\n"); buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes); buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj); @@ -3232,19 +3195,27 @@ static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev) buf += sprintf(buf, "n_erasures........... %u\n", dev->n_erasures); buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies); buf += sprintf(buf, "all_gcs.............. %u\n", dev->all_gcs); - buf += sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count); - buf += sprintf(buf, "oldest_dirty_gc_count %u\n", dev->oldest_dirty_gc_count); + buf += + sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count); + buf += + sprintf(buf, "oldest_dirty_gc_count %u\n", + dev->oldest_dirty_gc_count); buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks); buf += sprintf(buf, "bg_gcs............... %u\n", dev->bg_gcs); - buf += sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); - buf += sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks); + buf += + sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); + buf += + sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks); buf += sprintf(buf, "n_ecc_fixed.......... %u\n", dev->n_ecc_fixed); buf += sprintf(buf, "n_ecc_unfixed........ %u\n", dev->n_ecc_unfixed); - buf += sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed); - buf += sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed); + buf += + sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed); + buf += + sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed); buf += sprintf(buf, "cache_hits........... %u\n", dev->cache_hits); buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files); - buf += sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); + buf += + sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count); buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions); @@ -3270,29 +3241,36 @@ static int yaffs_proc_read(char *page, /* Print header first */ if (step == 0) - buf += sprintf(buf, "Multi-version YAFFS built:" __DATE__ " " __TIME__"\n"); + buf += + sprintf(buf, + "Multi-version YAFFS built:" __DATE__ " " __TIME__ + "\n"); else if (step == 1) - buf += sprintf(buf,"\n"); + buf += sprintf(buf, "\n"); else { - step-=2; - + step -= 2; + down(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ list_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, + context_list); struct yaffs_dev *dev = dc->dev; if (n < (step & ~1)) { - n+=2; + n += 2; continue; } - if((step & 1)==0){ - buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name); + if ((step & 1) == 0) { + buf += + sprintf(buf, "\nDevice %d \"%s\"\n", n, + dev->param.name); buf = yaffs_dump_dev_part0(buf, dev); } else buf = yaffs_dump_dev_part1(buf, dev); - + break; } up(&yaffs_context_lock); @@ -3302,8 +3280,8 @@ static int yaffs_proc_read(char *page, } static int yaffs_stats_proc_read(char *page, - char **start, - off_t offset, int count, int *eof, void *data) + char **start, + off_t offset, int count, int *eof, void *data) { struct list_head *item; char *buf = page; @@ -3313,21 +3291,22 @@ static int yaffs_stats_proc_read(char *page, /* Locate and print the Nth entry. Order N-squared but N is small. */ list_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, context_list); struct yaffs_dev *dev = dc->dev; int erased_chunks; - erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - - buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->n_free_chunks, erased_chunks, - dev->bg_gcs, dev->oldest_dirty_gc_count, - dev->n_obj, dev->n_tnodes); + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; + + buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n", + n, dev->n_free_chunks, erased_chunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); } up(&yaffs_context_lock); - return buf - page < count ? buf - page : count; } @@ -3341,41 +3320,39 @@ static struct { char *mask_name; unsigned mask_bitfield; } mask_flags[] = { - {"allocate", YAFFS_TRACE_ALLOCATE}, - {"always", YAFFS_TRACE_ALWAYS}, - {"background", YAFFS_TRACE_BACKGROUND}, - {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, - {"buffers", YAFFS_TRACE_BUFFERS}, - {"bug", YAFFS_TRACE_BUG}, - {"checkpt", YAFFS_TRACE_CHECKPOINT}, - {"deletion", YAFFS_TRACE_DELETION}, - {"erase", YAFFS_TRACE_ERASE}, - {"error", YAFFS_TRACE_ERROR}, - {"gc_detail", YAFFS_TRACE_GC_DETAIL}, - {"gc", YAFFS_TRACE_GC}, - {"lock", YAFFS_TRACE_LOCK}, - {"mtd", YAFFS_TRACE_MTD}, - {"nandaccess", YAFFS_TRACE_NANDACCESS}, - {"os", YAFFS_TRACE_OS}, - {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, - {"scan", YAFFS_TRACE_SCAN}, - {"tracing", YAFFS_TRACE_TRACING}, - {"sync", YAFFS_TRACE_SYNC}, - {"write", YAFFS_TRACE_WRITE}, - - {"verify", YAFFS_TRACE_VERIFY}, - {"verify_nand", YAFFS_TRACE_VERIFY_NAND}, - {"verify_full", YAFFS_TRACE_VERIFY_FULL}, - {"verify_all", YAFFS_TRACE_VERIFY_ALL}, - - {"all", 0xffffffff}, - {"none", 0}, - {NULL, 0}, -}; + { + "allocate", YAFFS_TRACE_ALLOCATE}, { + "always", YAFFS_TRACE_ALWAYS}, { + "background", YAFFS_TRACE_BACKGROUND}, { + "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, { + "buffers", YAFFS_TRACE_BUFFERS}, { + "bug", YAFFS_TRACE_BUG}, { + "checkpt", YAFFS_TRACE_CHECKPOINT}, { + "deletion", YAFFS_TRACE_DELETION}, { + "erase", YAFFS_TRACE_ERASE}, { + "error", YAFFS_TRACE_ERROR}, { + "gc_detail", YAFFS_TRACE_GC_DETAIL}, { + "gc", YAFFS_TRACE_GC}, { + "lock", YAFFS_TRACE_LOCK}, { + "mtd", YAFFS_TRACE_MTD}, { + "nandaccess", YAFFS_TRACE_NANDACCESS}, { + "os", YAFFS_TRACE_OS}, { + "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, { + "scan", YAFFS_TRACE_SCAN}, { + "tracing", YAFFS_TRACE_TRACING}, { + "sync", YAFFS_TRACE_SYNC}, { + "write", YAFFS_TRACE_WRITE}, { + "verify", YAFFS_TRACE_VERIFY}, { + "verify_nand", YAFFS_TRACE_VERIFY_NAND}, { + "verify_full", YAFFS_TRACE_VERIFY_FULL}, { + "verify_all", YAFFS_TRACE_VERIFY_ALL}, { + "all", 0xffffffff}, { + "none", 0}, { +NULL, 0},}; #define MAX_MASK_NAME_LENGTH 40 static int yaffs_proc_write_trace_options(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { unsigned rg = 0, mask_bitfield; char *end; @@ -3417,15 +3394,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, done = 0; } else { for (x = buf + pos, i = 0; - (*x == '_' || (*x >= 'a' && *x <= 'z')) && - i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) + (*x == '_' || (*x >= 'a' && *x <= 'z')) && + i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) substring[i] = *x; substring[i] = '\0'; for (i = 0; mask_flags[i].mask_name != NULL; i++) { - if (strcmp(substring, mask_flags[i].mask_name) == 0) { + if (strcmp(substring, mask_flags[i].mask_name) + == 0) { mask_name = mask_flags[i].mask_name; - mask_bitfield = mask_flags[i].mask_bitfield; + mask_bitfield = + mask_flags[i].mask_bitfield; done = 0; break; } @@ -3460,18 +3439,18 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, char flag; flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-'; - printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name); + printk(KERN_DEBUG "%c%s\n", flag, + mask_flags[i].mask_name); } } return count; } - static int yaffs_proc_write(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { - return yaffs_proc_write_trace_options(file, buf, count, data); + return yaffs_proc_write_trace_options(file, buf, count, data); } /* Stuff to handle installation of file systems */ @@ -3496,18 +3475,15 @@ static int __init init_yaffs_fs(void) #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED T(YAFFS_TRACE_ALWAYS, - (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); + (TSTR + (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); #endif - - - init_MUTEX(&yaffs_context_lock); /* Install the proc_fs entries */ my_proc_entry = create_proc_entry("yaffs", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (my_proc_entry) { my_proc_entry->write_proc = yaffs_proc_write; @@ -3517,8 +3493,7 @@ static int __init init_yaffs_fs(void) return -ENOMEM; debug_proc_entry = create_proc_entry("yaffs_stats", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (debug_proc_entry) { debug_proc_entry->write_proc = NULL; @@ -3560,7 +3535,7 @@ static void __exit exit_yaffs_fs(void) struct file_system_to_install *fsinst; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); + (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); remove_proc_entry("yaffs", YPROC_ROOT); remove_proc_entry("yaffs_stats", YPROC_ROOT); @@ -3577,8 +3552,8 @@ static void __exit exit_yaffs_fs(void) } module_init(init_yaffs_fs) -module_exit(exit_yaffs_fs) + module_exit(exit_yaffs_fs) -MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); + MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); MODULE_LICENSE("GPL"); diff --git a/yaffs_vfs_single.c b/yaffs_vfs_single.c index aa1c15e..176dea7 100644 --- a/yaffs_vfs_single.c +++ b/yaffs_vfs_single.c @@ -57,7 +57,6 @@ #include - #include #define UnlockPage(p) unlock_page(p) @@ -72,12 +71,11 @@ #define WRITE_SIZE_STR "writesize" #define WRITE_SIZE(mtd) ((mtd)->writesize) - static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) { uint64_t result = partition_size; do_div(result, block_size); - return (uint32_t)result; + return (uint32_t) result; } #include @@ -116,15 +114,14 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode) #define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info) - #define update_dir_time(dir) do {\ (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \ } while(0) - + static void yaffs_put_super(struct super_block *sb); static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos); + loff_t * pos); static ssize_t yaffs_hold_space(struct file *f); static void yaffs_release_space(struct file *f); @@ -137,16 +134,16 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n); + struct nameidata *n); static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry); + struct dentry *dentry); static int yaffs_unlink(struct inode *dir, struct dentry *dentry); static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname); + const char *symname); static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode); static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t dev); + dev_t dev); static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry); static int yaffs_setattr(struct dentry *dentry, struct iattr *attr); @@ -167,23 +164,22 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc); #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags); + const void *value, size_t size, int flags); ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size); + size_t size); int yaffs_removexattr(struct dentry *dentry, const char *name); ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size); #endif - static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata); + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata); static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata); + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata); -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen); +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen); void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias); static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); @@ -193,7 +189,6 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); static int yaffs_vfs_setattr(struct inode *, struct iattr *); - static struct address_space_operations yaffs_file_address_operations = { .readpage = yaffs_readpage, .writepage = yaffs_writepage, @@ -201,7 +196,6 @@ static struct address_space_operations yaffs_file_address_operations = { .write_end = yaffs_write_end, }; - static const struct file_operations yaffs_file_operations = { .read = do_sync_read, .write = do_sync_write, @@ -215,8 +209,6 @@ static const struct file_operations yaffs_file_operations = { .llseek = generic_file_llseek, }; - - static const struct inode_operations yaffs_file_inode_operations = { .setattr = yaffs_setattr, #ifdef CONFIG_YAFFS_XATTR @@ -277,16 +269,15 @@ static const struct super_operations yaffs_super_ops = { .write_super = yaffs_write_super, }; - -static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) +static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) { - setattr_copy(inode,attr); + setattr_copy(inode, attr); return 0; } -static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) +static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) { - truncate_setsize(inode,newsize); + truncate_setsize(inode, newsize); return 0; } @@ -294,7 +285,7 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev) { return yaffs_gc_control; } - + static void yaffs_gross_lock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); @@ -308,25 +299,27 @@ static void yaffs_gross_unlock(struct yaffs_dev *dev) up(&(yaffs_dev_to_lc(dev)->gross_lock)); } - - /* ExportFS support */ -static struct inode * -yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation) +static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, + uint32_t generation) { return Y_IGET(sb, ino); } -static struct dentry * -yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ; + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } -static struct dentry * - yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_parent(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode); + return generic_fh_to_parent(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } struct dentry *yaffs2_get_parent(struct dentry *dentry) @@ -366,12 +359,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) * using the default functions of exportfs. */ -static struct export_operations yaffs_export_ops = -{ +static struct export_operations yaffs_export_ops = { .fh_to_dentry = yaffs2_fh_to_dentry, .fh_to_parent = yaffs2_fh_to_parent, .get_parent = yaffs2_get_parent, -} ; +}; /*-----------------------------------------------------------------*/ /* Directory search context allows us to unlock access to yaffs during @@ -405,21 +397,22 @@ struct yaffs_search_context { * * Called at start of readdir. */ -static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir) +static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir) { struct yaffs_dev *dev = dir->my_dev; - struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context)); - if(sc){ + struct yaffs_search_context *sc = + YMALLOC(sizeof(struct yaffs_search_context)); + if (sc) { sc->dir_obj = dir; sc->dev = dev; - if( list_empty(&sc->dir_obj->variant.dir_variant.children)) + if (list_empty(&sc->dir_obj->variant.dir_variant.children)) sc->next_return = NULL; else - sc->next_return = list_entry( - dir->variant.dir_variant.children.next, - struct yaffs_obj,siblings); + sc->next_return = + list_entry(dir->variant.dir_variant.children.next, + struct yaffs_obj, siblings); INIT_LIST_HEAD(&sc->others); - list_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts)); + list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts)); } return sc; } @@ -427,9 +420,9 @@ static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir) /* * yaffs_search_end() disposes of a search context and cleans up. */ -static void yaffs_search_end(struct yaffs_search_context * sc) +static void yaffs_search_end(struct yaffs_search_context *sc) { - if(sc){ + if (sc) { list_del(&sc->others); YFREE(sc); } @@ -442,20 +435,21 @@ static void yaffs_search_end(struct yaffs_search_context * sc) */ static void yaffs_search_advance(struct yaffs_search_context *sc) { - if(!sc) - return; + if (!sc) + return; - if( sc->next_return == NULL || - list_empty(&sc->dir_obj->variant.dir_variant.children)) - sc->next_return = NULL; - else { - struct list_head *next = sc->next_return->siblings.next; + if (sc->next_return == NULL || + list_empty(&sc->dir_obj->variant.dir_variant.children)) + sc->next_return = NULL; + else { + struct list_head *next = sc->next_return->siblings.next; - if( next == &sc->dir_obj->variant.dir_variant.children) - sc->next_return = NULL; /* end of list */ - else - sc->next_return = list_entry(next,struct yaffs_obj,siblings); - } + if (next == &sc->dir_obj->variant.dir_variant.children) + sc->next_return = NULL; /* end of list */ + else + sc->next_return = + list_entry(next, struct yaffs_obj, siblings); + } } /* @@ -466,30 +460,29 @@ static void yaffs_search_advance(struct yaffs_search_context *sc) static void yaffs_remove_obj_callback(struct yaffs_obj *obj) { - struct list_head *i; - struct yaffs_search_context *sc; - struct list_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - + struct list_head *i; + struct yaffs_search_context *sc; + struct list_head *search_contexts = + &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - /* Iterate through the directory search contexts. - * If any are currently on the object being removed, then advance - * the search context to the next object to prevent a hanging pointer. - */ - list_for_each(i, search_contexts) { - if (i) { - sc = list_entry(i, struct yaffs_search_context,others); - if(sc->next_return == obj) - yaffs_search_advance(sc); - } + /* Iterate through the directory search contexts. + * If any are currently on the object being removed, then advance + * the search context to the next object to prevent a hanging pointer. + */ + list_for_each(i, search_contexts) { + if (i) { + sc = list_entry(i, struct yaffs_search_context, others); + if (sc->next_return == obj) + yaffs_search_advance(sc); + } } } - /*-----------------------------------------------------------------*/ -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen) +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen) { unsigned char *alias; int ret; @@ -532,57 +525,56 @@ out: return ret; } -void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { +void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) +{ kfree(alias); } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - struct yaffs_obj *obj); + struct yaffs_obj *obj); /* * Lookup is used to find objects in the fs */ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n) + struct nameidata *n) { struct yaffs_obj *obj; struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev; - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); + (TSTR("yaffs_lookup for %d:%s\n"), + yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); - obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), - dentry->d_name.name); + obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name); obj = yaffs_get_equivalent_obj(obj); /* in case it was a hardlink */ /* Can't hold gross lock when calling yaffs_get_inode() */ - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_unlock(dev); if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); if (inode) { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_loookup dentry \n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n"))); d_add(dentry, inode); /* return dentry; */ return NULL; } } else { - T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n"))); } @@ -591,7 +583,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, return NULL; } - #ifdef YAFFS_HAS_PUT_INODE /* For now put inode is just for debugging @@ -600,13 +591,12 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, static void yaffs_put_inode(struct inode *inode) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, - atomic_read(&inode->i_count))); + (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, + atomic_read(&inode->i_count))); } #endif - static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) { /* Clear the association between the inode and @@ -626,7 +616,7 @@ static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) * yaffs_clear_inode() and yaffs_delete_inode() * */ -static void yaffs_evict_inode( struct inode *inode) +static void yaffs_evict_inode(struct inode *inode) { struct yaffs_obj *obj; struct yaffs_dev *dev; @@ -635,16 +625,16 @@ static void yaffs_evict_inode( struct inode *inode) obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (!inode->i_nlink && !is_bad_inode(inode)) deleteme = 1; - truncate_inode_pages(&inode->i_data,0); + truncate_inode_pages(&inode->i_data, 0); end_writeback(inode); - if(deleteme && obj){ + if (deleteme && obj) { dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); @@ -653,14 +643,12 @@ static void yaffs_evict_inode( struct inode *inode) if (obj) { dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_unstitch_obj(inode,obj); + yaffs_unstitch_obj(inode, obj); yaffs_gross_unlock(dev); } - } - static int yaffs_file_flush(struct file *file, fl_owner_t id) { struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry); @@ -668,8 +656,8 @@ static int yaffs_file_flush(struct file *file, fl_owner_t id) struct yaffs_dev *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, - obj->dirty ? "dirty" : "clean")); + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, + obj->dirty ? "dirty" : "clean")); yaffs_gross_lock(dev); @@ -691,9 +679,9 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), - (unsigned)(pg->index << PAGE_CACHE_SHIFT), - (unsigned)PAGE_CACHE_SIZE)); + (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), + (unsigned)(pg->index << PAGE_CACHE_SHIFT), + (unsigned)PAGE_CACHE_SIZE)); obj = yaffs_dentry_to_obj(f->f_dentry); @@ -707,8 +695,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) yaffs_gross_lock(dev); ret = yaffs_file_rd(obj, pg_buf, - pg->index << PAGE_CACHE_SHIFT, - PAGE_CACHE_SIZE); + pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); yaffs_gross_unlock(dev); @@ -742,7 +729,7 @@ static int yaffs_readpage(struct file *f, struct page *pg) int ret; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n"))); - ret=yaffs_readpage_unlock(f, pg); + ret = yaffs_readpage_unlock(f, pg); T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n"))); return ret; } @@ -770,20 +757,21 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) end_index = i_size >> PAGE_CACHE_SHIFT; - if(page->index < end_index) + if (page->index < end_index) n_bytes = PAGE_CACHE_SIZE; else { - n_bytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE - 1); if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), - (unsigned)inode->i_size)); + (TSTR + ("yaffs_writepage at %08x, inode size = %08x!!!\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), + (unsigned)inode->i_size)); T(YAFFS_TRACE_OS, - (TSTR(" -> don't care!!\n"))); + (TSTR(" -> don't care!!\n"))); - zero_user_segment(page,0,PAGE_CACHE_SIZE); + zero_user_segment(page, 0, PAGE_CACHE_SIZE); set_page_writeback(page); unlock_page(page); end_page_writeback(page); @@ -791,8 +779,8 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) } } - if(n_bytes != PAGE_CACHE_SIZE) - zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); + if (n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE); get_page(page); @@ -803,20 +791,20 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); + (TSTR("yaffs_writepage at %08x, size %08x\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, - (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag0: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); n_written = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, n_bytes, 0); + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag1: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); yaffs_gross_unlock(dev); @@ -829,10 +817,9 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) return (n_written == n_bytes) ? 0 : -ENOSPC; } - static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata) + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata) { struct page *pg = NULL; pgoff_t index = pos >> PAGE_CACHE_SHIFT; @@ -845,12 +832,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, *pagep = pg; if (!pg) { - ret = -ENOMEM; + ret = -ENOMEM; goto out; } T(YAFFS_TRACE_OS, - (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), - (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0)); + (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), + (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0)); /* Get fs space */ space_held = yaffs_hold_space(filp); @@ -875,7 +862,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, out: T(YAFFS_TRACE_OS, - (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); + (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); if (space_held) yaffs_release_space(filp); if (pg) { @@ -885,10 +872,9 @@ out: return ret; } - static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata) + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata) { int ret = 0; void *addr, *kva; @@ -898,15 +884,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x n_bytes %d\n", - addr,(unsigned)pos, copied)); + ("yaffs_write_end addr %p pos %x n_bytes %d\n", + addr, (unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); if (ret != copied) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_write_end not same size ret %d copied %d\n"), - ret, copied)); + (TSTR("yaffs_write_end not same size ret %d copied %d\n"), + ret, copied)); SetPageError(pg); } else { /* Nothing */ @@ -920,12 +906,11 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, return ret; } - -static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, + struct yaffs_obj *obj) { if (inode && obj) { - /* Check mode against the variant type and attempt to repair if broken. */ u32 mode = obj->yst_mode; switch (obj->variant_type) { @@ -979,20 +964,21 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj inode->i_nlink = yaffs_get_obj_link_count(obj); T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), - inode->i_mode, inode->i_uid, inode->i_gid, - (int)inode->i_size, atomic_read(&inode->i_count))); + (TSTR + ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), + inode->i_mode, inode->i_uid, inode->i_gid, + (int)inode->i_size, atomic_read(&inode->i_count))); switch (obj->yst_mode & S_IFMT) { default: /* fifo, device or socket */ init_special_inode(inode, obj->yst_mode, - old_decode_dev(obj->yst_rdev)); + old_decode_dev(obj->yst_rdev)); break; case S_IFREG: /* file */ inode->i_op = &yaffs_file_inode_operations; inode->i_fop = &yaffs_file_operations; inode->i_mapping->a_ops = - &yaffs_file_address_operations; + &yaffs_file_address_operations; break; case S_IFDIR: /* directory */ inode->i_op = &yaffs_dir_inode_operations; @@ -1009,32 +995,32 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode invalid parameters\n"))); + (TSTR("yaffs_fill_inode invalid parameters\n"))); } } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - struct yaffs_obj *obj) + struct yaffs_obj *obj) { struct inode *inode; if (!sb) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL super_block!!\n"))); + (TSTR("yaffs_get_inode for NULL super_block!!\n"))); return NULL; } if (!obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL object!!\n"))); + (TSTR("yaffs_get_inode for NULL object!!\n"))); return NULL; } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) @@ -1048,7 +1034,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, } static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos) + loff_t * pos) { struct yaffs_obj *obj; int n_written, ipos; @@ -1070,20 +1056,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, if (!obj) T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: hey obj is null!\n"))); + (TSTR("yaffs_file_write: hey obj is null!\n"))); else T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write about to write writing %u(%x) bytes" + (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); + (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos)); n_written = yaffs_wr_file(obj, buf, ipos, n, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: %d(%x) bytes written\n"), - (unsigned )n,(unsigned)n)); + (TSTR("yaffs_file_write: %d(%x) bytes written\n"), + (unsigned)n, (unsigned)n)); if (n_written > 0) { ipos += n_written; @@ -1093,9 +1079,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, inode->i_blocks = (ipos + 511) >> 9; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write size updated to %d bytes, " - "%d blocks\n"), - ipos, (int)(inode->i_blocks))); + (TSTR("yaffs_file_write size updated to %d bytes, " + "%d blocks\n"), ipos, (int)(inode->i_blocks))); } } @@ -1114,7 +1099,6 @@ static ssize_t yaffs_hold_space(struct file *f) int n_free_chunks; - obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; @@ -1133,25 +1117,22 @@ static void yaffs_release_space(struct file *f) struct yaffs_obj *obj; struct yaffs_dev *dev; - obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_gross_unlock(dev); } - static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) { long long retval; lock_kernel(); - switch (origin){ + switch (origin) { case 2: offset += i_size_read(file->f_path.dentry->d_inode); break; @@ -1160,7 +1141,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) } retval = -EINVAL; - if (offset >= 0){ + if (offset >= 0) { if (offset != file->f_pos) file->f_pos = offset; @@ -1170,16 +1151,15 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) return retval; } - static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { struct yaffs_obj *obj; struct yaffs_dev *dev; - struct yaffs_search_context *sc; + struct yaffs_search_context *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; struct yaffs_obj *l; - int ret_val = 0; + int ret_val = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; @@ -1192,20 +1172,21 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) offset = f->f_pos; - sc = yaffs_new_search(obj); - if(!sc){ - ret_val = -ENOMEM; - goto out; - } + sc = yaffs_new_search(obj); + if (!sc) { + ret_val = -ENOMEM; + goto out; + } - T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); if (offset == 0) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry . ino %d \n"), - (int)inode->i_ino)); + (TSTR("yaffs_readdir: entry . ino %d \n"), + (int)inode->i_ino)); yaffs_gross_unlock(dev); - if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){ + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1215,11 +1196,12 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) } if (offset == 1) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry .. ino %d \n"), - (int)f->f_dentry->d_parent->d_inode->i_ino)); + (TSTR("yaffs_readdir: entry .. ino %d \n"), + (int)f->f_dentry->d_parent->d_inode->i_ino)); yaffs_gross_unlock(dev); if (filldir(dirent, "..", 2, offset, - f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){ + f->f_dentry->d_parent->d_inode->i_ino, + DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1238,37 +1220,34 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) f->f_version = inode->i_version; } - while(sc->next_return){ + while (sc->next_return) { curoffs++; - l = sc->next_return; + l = sc->next_return; if (curoffs >= offset) { - int this_inode = yaffs_get_obj_inode(l); - int this_type = yaffs_get_obj_type(l); + int this_inode = yaffs_get_obj_inode(l); + int this_type = yaffs_get_obj_type(l); - yaffs_get_obj_name(l, name, - YAFFS_MAX_NAME_LENGTH + 1); + yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1); T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: %s inode %d\n"), - name, yaffs_get_obj_inode(l))); + name, yaffs_get_obj_inode(l))); - yaffs_gross_unlock(dev); + yaffs_gross_unlock(dev); if (filldir(dirent, - name, - strlen(name), - offset, - this_inode, - this_type) < 0){ + name, + strlen(name), + offset, this_inode, this_type) < 0) { yaffs_gross_lock(dev); goto out; } - yaffs_gross_lock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } - yaffs_search_advance(sc); + yaffs_search_advance(sc); } out: @@ -1279,8 +1258,6 @@ out: return ret_val; } - - /* * File creation. Allocate an inode, and we're done.. */ @@ -1288,7 +1265,7 @@ out: #define YCRED(x) (x->cred) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t rdev) + dev_t rdev) { struct inode *inode; @@ -1299,24 +1276,25 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; if ((dir->i_mode & S_ISGID) && S_ISDIR(mode)) mode |= S_ISGID; if (parent) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->obj_id, parent->variant_type)); + (TSTR("yaffs_mknod: parent object %d type %d\n"), + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: could not get parent object\n"))); + (TSTR("yaffs_mknod: could not get parent object\n"))); return -EPERM; } T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, " - "mode %x dev %x\n"), - dentry->d_name.name, mode, rdev)); + "mode %x dev %x\n"), + dentry->d_name.name, mode, rdev)); dev = parent->my_dev; @@ -1326,19 +1304,19 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, default: /* Special (socket, fifo, device...) */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n"))); - obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, - gid, old_encode_dev(rdev)); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, old_encode_dev(rdev)); break; case S_IFREG: /* file */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n"))); obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid, - gid); + gid); break; case S_IFDIR: /* directory */ - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: making directory\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n"))); obj = yaffs_create_dir(parent, dentry->d_name.name, mode, - uid, gid); + uid, gid); break; case S_IFLNK: /* symlink */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n"))); @@ -1354,13 +1332,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, d_instantiate(dentry, inode); update_dir_time(dir); T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->obj_id, atomic_read(&inode->i_count))); + (TSTR("yaffs_mknod created object %d count = %d\n"), + obj->obj_id, atomic_read(&inode->i_count))); error = 0; - yaffs_fill_inode_from_obj(dir,parent); + yaffs_fill_inode_from_obj(dir, parent); } else { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod failed making object\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n"))); error = -ENOMEM; } @@ -1378,7 +1355,7 @@ static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode) static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n) { - T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n"))); return yaffs_mknod(dir, dentry, mode | S_IFREG, 0); } @@ -1390,9 +1367,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) struct yaffs_obj *obj; T(YAFFS_TRACE_OS, - (TSTR("yaffs_unlink %d:%s\n"), - (int)(dir->i_ino), - dentry->d_name.name)); + (TSTR("yaffs_unlink %d:%s\n"), + (int)(dir->i_ino), dentry->d_name.name)); obj = yaffs_inode_to_obj(dir); dev = obj->my_dev; @@ -1416,7 +1392,7 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) * Create a link... */ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry) + struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; struct yaffs_obj *obj = NULL; @@ -1430,23 +1406,24 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, yaffs_gross_lock(dev); - if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, - obj); + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ + link = + yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, + obj); if (link) { old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); d_instantiate(dentry, old_dentry->d_inode); atomic_inc(&old_dentry->d_inode->i_count); T(YAFFS_TRACE_OS, - (TSTR("yaffs_link link count %d i_count %d\n"), - old_dentry->d_inode->i_nlink, - atomic_read(&old_dentry->d_inode->i_count))); + (TSTR("yaffs_link link count %d i_count %d\n"), + old_dentry->d_inode->i_nlink, + atomic_read(&old_dentry->d_inode->i_count))); } yaffs_gross_unlock(dev); - if (link){ + if (link) { update_dir_time(dir); return 0; } @@ -1455,19 +1432,20 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, } static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname) + const char *symname) { struct yaffs_obj *obj; struct yaffs_dev *dev; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); dev = yaffs_inode_to_obj(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name, - S_IFLNK | S_IRWXUGO, uid, gid, symname); + S_IFLNK | S_IRWXUGO, uid, gid, symname); yaffs_gross_unlock(dev); if (obj) { @@ -1496,8 +1474,7 @@ static int yaffs_sync_object(struct file *file, int datasync) dev = obj->my_dev; - T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_object\n"))); + T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); yaffs_gross_lock(dev); yaffs_flush_file(obj, 1, datasync); yaffs_gross_unlock(dev); @@ -1523,12 +1500,10 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, /* Check if the target is an existing directory that is not empty. */ target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); - - + new_dentry->d_name.name); if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - !list_empty(&target->variant.dir_variant.children)) { + !list_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); @@ -1538,9 +1513,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n"))); ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir), - old_dentry->d_name.name, - yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); + old_dentry->d_name.name, + yaffs_inode_to_obj(new_dir), + new_dentry->d_name.name); } yaffs_gross_unlock(dev); @@ -1549,9 +1524,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, new_dentry->d_inode->i_nlink--; mark_inode_dirty(new_dentry->d_inode); } - + update_dir_time(old_dir); - if(old_dir != new_dir) + if (old_dir != new_dir) update_dir_time(new_dir); return 0; } else { @@ -1566,34 +1541,34 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr of object %d\n"), - yaffs_inode_to_obj(inode)->obj_id)); + (TSTR("yaffs_setattr of object %d\n"), + yaffs_inode_to_obj(inode)->obj_id)); - /* Fail if a requested resize >= 2GB */ - if (attr->ia_valid & ATTR_SIZE && - (attr->ia_size >> 31)) + /* Fail if a requested resize >= 2GB */ + if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31)) error = -EINVAL; if (error == 0) error = inode_change_ok(inode, attr); if (error == 0) { int result; - if (!error){ + if (!error) { error = yaffs_vfs_setattr(inode, attr); - T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n"))); - if (attr->ia_valid & ATTR_SIZE){ - yaffs_vfs_setsize(inode,attr->ia_size); - inode->i_blocks = (inode->i_size + 511) >> 9; + T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n"))); + if (attr->ia_valid & ATTR_SIZE) { + yaffs_vfs_setsize(inode, attr->ia_size); + inode->i_blocks = (inode->i_size + 511) >> 9; } } dev = yaffs_inode_to_obj(inode)->my_dev; - if (attr->ia_valid & ATTR_SIZE){ - T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), - (int)(attr->ia_size),(int)(attr->ia_size))); + if (attr->ia_valid & ATTR_SIZE) { + T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"), + (int)(attr->ia_size), + (int)(attr->ia_size))); } yaffs_gross_lock(dev); result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr); - if(result == YAFFS_OK) { + if (result == YAFFS_OK) { error = 0; } else { error = -EPERM; @@ -1602,47 +1577,41 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error)); return error; } #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags) + const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error = 0; struct yaffs_dev *dev; struct yaffs_obj *obj = yaffs_inode_to_obj(inode); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr of object %d\n"), - obj->obj_id)); - + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_set_xattrib(obj, name, value, size, flags); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error)); return error; } - -ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size) +ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff, + size_t size) { struct inode *inode = dentry->d_inode; int error = 0; @@ -1650,8 +1619,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->obj_id)); + (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -1660,8 +1628,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error)); return error; } @@ -1674,29 +1641,27 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_remove_xattrib(obj, name); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr done returning %d\n"),error)); + (TSTR("yaffs_removexattr done returning %d\n"), error)); return error; } -ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) +ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; @@ -1704,9 +1669,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -1715,15 +1678,13 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error)); return error; } #endif - static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; @@ -1743,14 +1704,17 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) uint64_t bytes_in_dev; uint64_t bytes_free; - bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * - ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); + bytes_in_dev = + ((uint64_t) + ((dev->param.end_block - dev->param.start_block + + 1))) * ((uint64_t) (dev->param.chunks_per_block * + dev->data_bytes_per_chunk)); - do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ + do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ buf->f_blocks = bytes_in_dev; - bytes_free = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * - ((uint64_t)(dev->data_bytes_per_chunk)); + bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) * + ((uint64_t) (dev->data_bytes_per_chunk)); do_div(bytes_free, sb->s_blocksize); @@ -1759,21 +1723,21 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block / - (sb->s_blocksize / dev->data_bytes_per_chunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = - yaffs_get_n_free_chunks(dev) / - (sb->s_blocksize / dev->data_bytes_per_chunk); + yaffs_get_n_free_chunks(dev) / + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block * - (dev->data_bytes_per_chunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = - yaffs_get_n_free_chunks(dev) * - (dev->data_bytes_per_chunk / sb->s_blocksize); + yaffs_get_n_free_chunks(dev) * + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; @@ -1784,61 +1748,57 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) return 0; } - - static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; struct yaffs_obj *obj; - - list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ + + list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) { obj = yaffs_inode_to_obj(iptr); - if(obj){ + if (obj) { T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->obj_id)); - yaffs_flush_file(obj,1,0); + obj->obj_id)); + yaffs_flush_file(obj, 1, 0); } } } - static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - struct yaffs_dev *dev = yaffs_super_to_dev(sb); - if(!dev) + struct yaffs_dev *dev = yaffs_super_to_dev(sb); + if (!dev) return; - + yaffs_flush_inodes(sb); yaffs_update_dirty_dirs(dev); yaffs_flush_whole_cache(dev); - if(do_checkpoint) + if (do_checkpoint) yaffs_checkpoint_save(dev); } - static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev) { - unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + unsigned erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - unsigned scattered = 0; /* Free chunks not in an erased block */ + unsigned scattered = 0; /* Free chunks not in an erased block */ - if(erased_chunks < dev->n_free_chunks) + if (erased_chunks < dev->n_free_chunks) scattered = (dev->n_free_chunks - erased_chunks); - if(!context->bg_running) + if (!context->bg_running) return 0; - else if(scattered < (dev->param.chunks_per_block * 2)) + else if (scattered < (dev->param.chunks_per_block * 2)) return 0; - else if(erased_chunks > dev->n_free_chunks/2) + else if (erased_chunks > dev->n_free_chunks / 2) return 0; - else if(erased_chunks > dev->n_free_chunks/4) + else if (erased_chunks > dev->n_free_chunks / 4) return 1; else return 2; } -static int yaffs_do_sync_fs(struct super_block *sb, - int request_checkpoint) +static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { struct yaffs_dev *dev = yaffs_super_to_dev(sb); @@ -1847,21 +1807,20 @@ static int yaffs_do_sync_fs(struct super_block *sb, int do_checkpoint; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), - gc_urgent, - sb->s_dirt ? "dirty" : "clean", - request_checkpoint ? "checkpoint requested" : "no checkpoint", - oneshot_checkpoint ? " one-shot" : "" )); + (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), + gc_urgent, + sb->s_dirt ? "dirty" : "clean", + request_checkpoint ? "checkpoint requested" : "no checkpoint", + oneshot_checkpoint ? " one-shot" : "")); yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || - oneshot_checkpoint) && - !dev->is_checkpointed; + oneshot_checkpoint) && !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; - if(oneshot_checkpoint) + if (oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; } yaffs_gross_unlock(dev); @@ -1881,7 +1840,6 @@ static int yaffs_do_sync_fs(struct super_block *sb, * The thread should not do any writing while the fs is in read only. */ - void yaffs_background_waker(unsigned long data) { wake_up_process((struct task_struct *)data); @@ -1901,58 +1859,56 @@ static int yaffs_bg_thread_fn(void *data) struct timer_list timer; T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background starting for dev %p\n"), - (void *)dev)); + (TSTR("yaffs_background starting for dev %p\n"), (void *)dev)); set_freezable(); - while(context->bg_running){ - T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background\n"))); + while (context->bg_running) { + T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n"))); - if(kthread_should_stop()) + if (kthread_should_stop()) break; - if(try_to_freeze()) + if (try_to_freeze()) continue; yaffs_gross_lock(dev); now = jiffies; - if(time_after(now, next_dir_update) && yaffs_bg_enable){ + if (time_after(now, next_dir_update) && yaffs_bg_enable) { yaffs_update_dirty_dirs(dev); next_dir_update = now + HZ; } - if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->is_checkpointed){ + if (time_after(now, next_gc) && yaffs_bg_enable) { + if (!dev->is_checkpointed) { urgency = yaffs_bg_gc_urgency(dev); gc_result = yaffs_bg_gc(dev, urgency); - if(urgency > 1) - next_gc = now + HZ/20+1; - else if(urgency > 0) - next_gc = now + HZ/10+1; + if (urgency > 1) + next_gc = now + HZ / 20 + 1; + else if (urgency > 0) + next_gc = now + HZ / 10 + 1; else next_gc = now + HZ * 2; - } else /* - * gc not running so set to next_dir_update - * to cut down on wake ups - */ + } else /* + * gc not running so set to next_dir_update + * to cut down on wake ups + */ next_gc = next_dir_update; } yaffs_gross_unlock(dev); expires = next_dir_update; - if (time_before(next_gc,expires)) + if (time_before(next_gc, expires)) expires = next_gc; - if(time_before(expires,now)) + if (time_before(expires, now)) expires = now + HZ; Y_INIT_TIMER(&timer); - timer.expires = expires+1; - timer.data = (unsigned long) current; + timer.expires = expires + 1; + timer.data = (unsigned long)current; timer.function = yaffs_background_waker; - set_current_state(TASK_INTERRUPTIBLE); + set_current_state(TASK_INTERRUPTIBLE); add_timer(&timer); schedule(); del_timer_sync(&timer); @@ -1966,15 +1922,16 @@ static int yaffs_bg_start(struct yaffs_dev *dev) int retval = 0; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - if(dev->read_only) + if (dev->read_only) return -1; context->bg_running = 1; context->bg_thread = kthread_run(yaffs_bg_thread_fn, - (void *)dev,"yaffs-bg-%d",context->mount_id); + (void *)dev, "yaffs-bg-%d", + context->mount_id); - if(IS_ERR(context->bg_thread)){ + if (IS_ERR(context->bg_thread)) { retval = PTR_ERR(context->bg_thread); context->bg_thread = NULL; context->bg_running = 0; @@ -1988,33 +1945,30 @@ static void yaffs_bg_stop(struct yaffs_dev *dev) ctxt->bg_running = 0; - if( ctxt->bg_thread){ + if (ctxt->bg_thread) { kthread_stop(ctxt->bg_thread); ctxt->bg_thread = NULL; } } - static void yaffs_write_super(struct super_block *sb) { unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_write_super%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_write_super%s\n"), + request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); } - static int yaffs_sync_fs(struct super_block *sb, int wait) { unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_fs%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2027,8 +1981,7 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) struct yaffs_obj *obj; struct yaffs_dev *dev = yaffs_super_to_dev(sb); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_iget for %lu\n"), ino)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); inode = iget_locked(sb, ino); if (!inode) @@ -2063,19 +2016,18 @@ static void yaffs_put_super(struct super_block *sb) T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("Shutting down yaffs background thread\n"))); + (TSTR("Shutting down yaffs background thread\n"))); yaffs_bg_stop(dev); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs background thread shut down\n"))); + (TSTR("yaffs background thread shut down\n"))); yaffs_gross_lock(dev); - yaffs_flush_super(sb,1); + yaffs_flush_super(sb, 1); if (yaffs_dev_to_lc(dev)->put_super_fn) yaffs_dev_to_lc(dev)->put_super_fn(sb); - yaffs_deinitialise(dev); yaffs_gross_unlock(dev); @@ -2092,7 +2044,6 @@ static void yaffs_put_super(struct super_block *sb) kfree(dev); } - static void yaffs_mtd_put_super(struct super_block *sb) { struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb)); @@ -2103,7 +2054,6 @@ static void yaffs_mtd_put_super(struct super_block *sb) put_mtd_device(mtd); } - static void yaffs_touch_super(struct yaffs_dev *dev) { struct super_block *sb = yaffs_dev_to_lc(dev)->super; @@ -2124,10 +2074,11 @@ struct yaffs_options { int lazy_loading_overridden; int empty_lost_and_found; int empty_lost_and_found_overridden; -} ; +}; #define MAX_OPT_LEN 30 -static int yaffs_parse_options(struct yaffs_options *options, const char *options_str) +static int yaffs_parse_options(struct yaffs_options *options, + const char *options_str) { char cur_opt[MAX_OPT_LEN + 1]; int p; @@ -2139,7 +2090,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option memset(cur_opt, 0, MAX_OPT_LEN + 1); p = 0; - while(*options_str == ',') + while (*options_str == ',') options_str++; while (*options_str && *options_str != ',') { @@ -2152,24 +2103,24 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option if (!strcmp(cur_opt, "inband-tags")) options->inband_tags = 1; - else if (!strcmp(cur_opt, "tags-ecc-off")){ + else if (!strcmp(cur_opt, "tags-ecc-off")) { options->tags_ecc_on = 0; - options->tags_ecc_overridden=1; - } else if (!strcmp(cur_opt, "tags-ecc-on")){ + options->tags_ecc_overridden = 1; + } else if (!strcmp(cur_opt, "tags-ecc-on")) { options->tags_ecc_on = 1; options->tags_ecc_overridden = 1; - } else if (!strcmp(cur_opt, "lazy-loading-off")){ + } else if (!strcmp(cur_opt, "lazy-loading-off")) { options->lazy_loading_enabled = 0; - options->lazy_loading_overridden=1; - } else if (!strcmp(cur_opt, "lazy-loading-on")){ + options->lazy_loading_overridden = 1; + } else if (!strcmp(cur_opt, "lazy-loading-on")) { options->lazy_loading_enabled = 1; options->lazy_loading_overridden = 1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){ + } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) { options->empty_lost_and_found = 0; - options->empty_lost_and_found_overridden=1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){ + options->empty_lost_and_found_overridden = 1; + } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) { options->empty_lost_and_found = 1; - options->empty_lost_and_found_overridden=1; + options->empty_lost_and_found_overridden = 1; } else if (!strcmp(cur_opt, "no-cache")) options->no_cache = 1; else if (!strcmp(cur_opt, "no-checkpoint-read")) @@ -2181,7 +2132,7 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option options->skip_checkpoint_write = 1; } else { printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n", - cur_opt); + cur_opt); error = 1; } } @@ -2190,8 +2141,8 @@ static int yaffs_parse_options(struct yaffs_options *options, const char *option } static struct super_block *yaffs_internal_read_super(int yaffs_version, - struct super_block *sb, - void *data, int silent) + struct super_block *sb, + void *data, int silent) { int n_blocks; struct inode *inode = NULL; @@ -2217,7 +2168,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - read_only =((sb->s_flags & MS_RDONLY) != 0); + read_only = ((sb->s_flags & MS_RDONLY) != 0); sb->s_export_op = &yaffs_export_ops; @@ -2230,8 +2181,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, else printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, - yaffs_devname(sb, devname_buf), - read_only ? "ro" : "rw"); + yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2245,20 +2195,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, return NULL; } - sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); + (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: block size %d\n"), - (int)(sb->s_blocksize))); + (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize))); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), - MAJOR(sb->s_dev), MINOR(sb->s_dev), - yaffs_devname(sb, devname_buf))); + (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), + MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf))); /* Check it's an mtd device..... */ if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) @@ -2268,15 +2215,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); if (!mtd) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), - MINOR(sb->s_dev))); + (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), + MINOR(sb->s_dev))); return NULL; } /* Check it's NAND */ if (mtd->type != MTD_NANDFLASH) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device is not NAND it's type %d\n"), - mtd->type)); + (TSTR("yaffs: MTD device is not NAND it's type %d\n"), + mtd->type)); return NULL; } @@ -2295,18 +2242,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_AUTO_YAFFS2 if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs2\n"))); + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n"))); yaffs_version = 2; } /* Added NCB 26/5/2006 for completeness */ - if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs1\n"))); + if (yaffs_version == 2 && !options.inband_tags + && WRITE_SIZE(mtd) == 512) { + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n"))); yaffs_version = 1; } - #endif if (yaffs_version == 2) { @@ -2315,31 +2260,29 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, !mtd->block_isbad || !mtd->block_markbad || !mtd->read || - !mtd->write || - !mtd->read_oob || !mtd->write_oob) { + !mtd->write || !mtd->read_oob || !mtd->write_oob) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE || - mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && !options.inband_tags) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } else { /* Check for V1 style functions */ if (!mtd->erase || !mtd->read || - !mtd->write || - !mtd->read_oob || !mtd->write_oob) { + !mtd->write || !mtd->read_oob || !mtd->write_oob) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } @@ -2347,7 +2290,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd->oobsize != YAFFS_BYTES_PER_SPARE) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } @@ -2357,19 +2300,20 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, * Set the struct yaffs_dev up for mtd */ - if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ + if (!read_only && !(mtd->flags & MTD_WRITEABLE)) { read_only = 1; - printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); + printk(KERN_INFO + "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL); - context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL); - - if(!dev || !context ){ - if(dev) + context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL); + + if (!dev || !context) { + if (dev) kfree(dev); - if(context) + if (context) kfree(context); dev = NULL; context = NULL; @@ -2379,13 +2323,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "struct yaffs_dev. \n"))); + "struct yaffs_dev. \n"))); return NULL; } memset(dev, 0, sizeof(struct yaffs_dev)); param = &(dev->param); - memset(context,0,sizeof(struct yaffs_linux_context)); + memset(context, 0, sizeof(struct yaffs_linux_context)); dev->os_context = context; INIT_LIST_HEAD(&(context->context_list)); context->dev = dev; @@ -2394,13 +2338,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, dev->read_only = read_only; sb->s_fs_info = dev; - + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ - n_blocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); + n_blocks = + YCALCBLOCKS(mtd->size, + (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); param->start_block = 0; param->end_block = n_blocks - 1; @@ -2416,7 +2362,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_XATTR param->enable_xattr = 1; #endif - if(options.lazy_loading_overridden) + if (options.lazy_loading_overridden) param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC @@ -2428,7 +2374,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->defered_dir_update = 1; #endif - if(options.tags_ecc_overridden) + if (options.tags_ecc_overridden) param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND @@ -2445,15 +2391,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->always_check_erased = 1; #endif - if(options.empty_lost_and_found_overridden) + if (options.empty_lost_and_found_overridden) param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ if (yaffs_version == 2) { - param->write_chunk_tags_fn = - nandmtd2_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd2_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd2_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd2_read_chunk_tags; param->bad_block_fn = nandmtd2_mark_block_bad; param->query_block_fn = nandmtd2_query_block; yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize); @@ -2466,10 +2410,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->end_block = n_blocks - 1; } else { /* use the MTD interface in yaffs_mtdif1.c */ - param->write_chunk_tags_fn = - nandmtd1_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd1_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd1_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd1_read_chunk_tags; param->bad_block_fn = nandmtd1_mark_block_bad; param->query_block_fn = nandmtd1_query_block; param->is_yaffs2 = 0; @@ -2483,8 +2425,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->sb_dirty_fn = yaffs_touch_super; param->gc_control = yaffs_gc_control_callback; - yaffs_dev_to_lc(dev)->super= sb; - + yaffs_dev_to_lc(dev)->super = sb; #ifndef CONFIG_YAFFS_DOES_ECC param->use_nand_ecc = 1; @@ -2500,22 +2441,25 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, down(&yaffs_context_lock); /* Get a mount id */ found = 0; - for(mount_id=0; ! found; mount_id++){ + for (mount_id = 0; !found; mount_id++) { found = 1; - list_for_each(l,&yaffs_context_list){ - context_iterator = list_entry(l,struct yaffs_linux_context,context_list); - if(context_iterator->mount_id == mount_id) + list_for_each(l, &yaffs_context_list) { + context_iterator = + list_entry(l, struct yaffs_linux_context, + context_list); + if (context_iterator->mount_id == mount_id) found = 0; } } context->mount_id = mount_id; - list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list); + list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), + &yaffs_context_list); up(&yaffs_context_lock); - /* Directory search handling...*/ - INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); - param->remove_obj_fn = yaffs_remove_obj_callback; + /* Directory search handling... */ + INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); + param->remove_obj_fn = yaffs_remove_obj_callback; init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock)); @@ -2526,21 +2470,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: guts initialised %s\n"), (err == YAFFS_OK) ? "OK" : "FAILED")); - - if(err == YAFFS_OK) + + if (err == YAFFS_OK) yaffs_bg_start(dev); - - if(!context->bg_thread) - param->defered_dir_update = 0; + if (!context->bg_thread) + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ yaffs_gross_unlock(dev); /* Create root inode */ if (err == YAFFS_OK) - inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_root(dev)); + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev)); if (!inode) return NULL; @@ -2561,14 +2503,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_root = root; sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: is_checkpointed %d\n"), - dev->is_checkpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; } - static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, int silent) { @@ -2592,7 +2533,6 @@ static struct file_system_type yaffs_fs_type = { .fs_flags = FS_REQUIRES_DEV, }; - #ifdef CONFIG_YAFFS_YAFFS2 static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, @@ -2602,11 +2542,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, } static int yaffs2_read_super(struct file_system_type *fs, - int flags, const char *dev_name, void *data, - struct vfsmount *mnt) + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) { return get_sb_bdev(fs, flags, dev_name, data, - yaffs2_internal_read_super_mtd, mnt); + yaffs2_internal_read_super_mtd, mnt); } static struct file_system_type yaffs2_fs_type = { @@ -2616,40 +2556,62 @@ static struct file_system_type yaffs2_fs_type = { .kill_sb = kill_block_super, .fs_flags = FS_REQUIRES_DEV, }; -#endif /* CONFIG_YAFFS_YAFFS2 */ +#endif /* CONFIG_YAFFS_YAFFS2 */ static struct proc_dir_entry *my_proc_entry; static struct proc_dir_entry *debug_proc_entry; -static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev * dev) -{ - buf += sprintf(buf, "start_block........... %d\n", dev->param.start_block); - buf += sprintf(buf, "end_block............. %d\n", dev->param.end_block); - buf += sprintf(buf, "total_bytes_per_chunk. %d\n", dev->param.total_bytes_per_chunk); - buf += sprintf(buf, "use_nand_ecc.......... %d\n", dev->param.use_nand_ecc); - buf += sprintf(buf, "no_tags_ecc........... %d\n", dev->param.no_tags_ecc); - buf += sprintf(buf, "is_yaffs2............. %d\n", dev->param.is_yaffs2); - buf += sprintf(buf, "inband_tags........... %d\n", dev->param.inband_tags); - buf += sprintf(buf, "empty_lost_n_found.... %d\n", dev->param.empty_lost_n_found); - buf += sprintf(buf, "disable_lazy_load..... %d\n", dev->param.disable_lazy_load); - buf += sprintf(buf, "refresh_period........ %d\n", dev->param.refresh_period); +static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev) +{ + buf += + sprintf(buf, "start_block........... %d\n", dev->param.start_block); + buf += + sprintf(buf, "end_block............. %d\n", dev->param.end_block); + buf += + sprintf(buf, "total_bytes_per_chunk. %d\n", + dev->param.total_bytes_per_chunk); + buf += + sprintf(buf, "use_nand_ecc.......... %d\n", + dev->param.use_nand_ecc); + buf += + sprintf(buf, "no_tags_ecc........... %d\n", dev->param.no_tags_ecc); + buf += + sprintf(buf, "is_yaffs2............. %d\n", dev->param.is_yaffs2); + buf += + sprintf(buf, "inband_tags........... %d\n", dev->param.inband_tags); + buf += + sprintf(buf, "empty_lost_n_found.... %d\n", + dev->param.empty_lost_n_found); + buf += + sprintf(buf, "disable_lazy_load..... %d\n", + dev->param.disable_lazy_load); + buf += + sprintf(buf, "refresh_period........ %d\n", + dev->param.refresh_period); buf += sprintf(buf, "n_caches.............. %d\n", dev->param.n_caches); - buf += sprintf(buf, "n_reserved_blocks..... %d\n", dev->param.n_reserved_blocks); - buf += sprintf(buf, "always_check_erased... %d\n", dev->param.always_check_erased); + buf += + sprintf(buf, "n_reserved_blocks..... %d\n", + dev->param.n_reserved_blocks); + buf += + sprintf(buf, "always_check_erased... %d\n", + dev->param.always_check_erased); buf += sprintf(buf, "\n"); return buf; } - -static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev) +static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "data_bytes_per_chunk.. %d\n", dev->data_bytes_per_chunk); + buf += + sprintf(buf, "data_bytes_per_chunk.. %d\n", + dev->data_bytes_per_chunk); buf += sprintf(buf, "chunk_grp_bits........ %d\n", dev->chunk_grp_bits); buf += sprintf(buf, "chunk_grp_size........ %d\n", dev->chunk_grp_size); - buf += sprintf(buf, "n_erased_blocks....... %d\n", dev->n_erased_blocks); - buf += sprintf(buf, "blocks_in_checkpt..... %d\n", dev->blocks_in_checkpt); + buf += + sprintf(buf, "n_erased_blocks....... %d\n", dev->n_erased_blocks); + buf += + sprintf(buf, "blocks_in_checkpt..... %d\n", dev->blocks_in_checkpt); buf += sprintf(buf, "\n"); buf += sprintf(buf, "n_tnodes.............. %d\n", dev->n_tnodes); buf += sprintf(buf, "n_obj................. %d\n", dev->n_obj); @@ -2660,19 +2622,29 @@ static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev) buf += sprintf(buf, "n_erasures............ %u\n", dev->n_erasures); buf += sprintf(buf, "n_gc_copies........... %u\n", dev->n_gc_copies); buf += sprintf(buf, "all_gcs............... %u\n", dev->all_gcs); - buf += sprintf(buf, "passive_gc_count...... %u\n", dev->passive_gc_count); - buf += sprintf(buf, "oldest_dirty_gc_count. %u\n", dev->oldest_dirty_gc_count); + buf += + sprintf(buf, "passive_gc_count...... %u\n", dev->passive_gc_count); + buf += + sprintf(buf, "oldest_dirty_gc_count. %u\n", + dev->oldest_dirty_gc_count); buf += sprintf(buf, "n_gc_blocks........... %u\n", dev->n_gc_blocks); buf += sprintf(buf, "bg_gcs................ %u\n", dev->bg_gcs); - buf += sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes); - buf += sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks); + buf += + sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes); + buf += + sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks); buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed); buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed); - buf += sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed); - buf += sprintf(buf, "n_tags_ecc_unfixed.... %u\n", dev->n_tags_ecc_unfixed); + buf += + sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed); + buf += + sprintf(buf, "n_tags_ecc_unfixed.... %u\n", + dev->n_tags_ecc_unfixed); buf += sprintf(buf, "cache_hits............ %u\n", dev->cache_hits); - buf += sprintf(buf, "n_deleted_files....... %u\n", dev->n_deleted_files); - buf += sprintf(buf, "n_unlinked_files...... %u\n", dev->n_unlinked_files); + buf += + sprintf(buf, "n_deleted_files....... %u\n", dev->n_deleted_files); + buf += + sprintf(buf, "n_unlinked_files...... %u\n", dev->n_unlinked_files); buf += sprintf(buf, "refresh_count......... %u\n", dev->refresh_count); buf += sprintf(buf, "n_bg_deletions........ %u\n", dev->n_bg_deletions); @@ -2698,29 +2670,33 @@ static int yaffs_proc_read(char *page, /* Print header first */ if (step == 0) - buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__"\n"); + buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__ "\n"); else if (step == 1) - buf += sprintf(buf,"\n"); + buf += sprintf(buf, "\n"); else { - step-=2; - + step -= 2; + down(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ list_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, + context_list); struct yaffs_dev *dev = dc->dev; if (n < (step & ~1)) { - n+=2; + n += 2; continue; } - if((step & 1)==0){ - buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name); + if ((step & 1) == 0) { + buf += + sprintf(buf, "\nDevice %d \"%s\"\n", n, + dev->param.name); buf = yaffs_dump_dev_part0(buf, dev); } else buf = yaffs_dump_dev_part1(buf, dev); - + break; } up(&yaffs_context_lock); @@ -2730,8 +2706,8 @@ static int yaffs_proc_read(char *page, } static int yaffs_stats_proc_read(char *page, - char **start, - off_t offset, int count, int *eof, void *data) + char **start, + off_t offset, int count, int *eof, void *data) { struct list_head *item; char *buf = page; @@ -2741,21 +2717,22 @@ static int yaffs_stats_proc_read(char *page, /* Locate and print the Nth entry. Order N-squared but N is small. */ list_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, context_list); struct yaffs_dev *dev = dc->dev; int erased_chunks; - erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - - buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->n_free_chunks, erased_chunks, - dev->bg_gcs, dev->oldest_dirty_gc_count, - dev->n_obj, dev->n_tnodes); + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; + + buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n", + n, dev->n_free_chunks, erased_chunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); } up(&yaffs_context_lock); - return buf - page < count ? buf - page : count; } @@ -2769,41 +2746,39 @@ static struct { char *mask_name; unsigned mask_bitfield; } mask_flags[] = { - {"allocate", YAFFS_TRACE_ALLOCATE}, - {"always", YAFFS_TRACE_ALWAYS}, - {"background", YAFFS_TRACE_BACKGROUND}, - {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, - {"buffers", YAFFS_TRACE_BUFFERS}, - {"bug", YAFFS_TRACE_BUG}, - {"checkpt", YAFFS_TRACE_CHECKPOINT}, - {"deletion", YAFFS_TRACE_DELETION}, - {"erase", YAFFS_TRACE_ERASE}, - {"error", YAFFS_TRACE_ERROR}, - {"gc_detail", YAFFS_TRACE_GC_DETAIL}, - {"gc", YAFFS_TRACE_GC}, - {"lock", YAFFS_TRACE_LOCK}, - {"mtd", YAFFS_TRACE_MTD}, - {"nandaccess", YAFFS_TRACE_NANDACCESS}, - {"os", YAFFS_TRACE_OS}, - {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, - {"scan", YAFFS_TRACE_SCAN}, - {"tracing", YAFFS_TRACE_TRACING}, - {"sync", YAFFS_TRACE_SYNC}, - {"write", YAFFS_TRACE_WRITE}, - - {"verify", YAFFS_TRACE_VERIFY}, - {"verify_nand", YAFFS_TRACE_VERIFY_NAND}, - {"verify_full", YAFFS_TRACE_VERIFY_FULL}, - {"verify_all", YAFFS_TRACE_VERIFY_ALL}, - - {"all", 0xffffffff}, - {"none", 0}, - {NULL, 0}, -}; + { + "allocate", YAFFS_TRACE_ALLOCATE}, { + "always", YAFFS_TRACE_ALWAYS}, { + "background", YAFFS_TRACE_BACKGROUND}, { + "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, { + "buffers", YAFFS_TRACE_BUFFERS}, { + "bug", YAFFS_TRACE_BUG}, { + "checkpt", YAFFS_TRACE_CHECKPOINT}, { + "deletion", YAFFS_TRACE_DELETION}, { + "erase", YAFFS_TRACE_ERASE}, { + "error", YAFFS_TRACE_ERROR}, { + "gc_detail", YAFFS_TRACE_GC_DETAIL}, { + "gc", YAFFS_TRACE_GC}, { + "lock", YAFFS_TRACE_LOCK}, { + "mtd", YAFFS_TRACE_MTD}, { + "nandaccess", YAFFS_TRACE_NANDACCESS}, { + "os", YAFFS_TRACE_OS}, { + "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, { + "scan", YAFFS_TRACE_SCAN}, { + "tracing", YAFFS_TRACE_TRACING}, { + "sync", YAFFS_TRACE_SYNC}, { + "write", YAFFS_TRACE_WRITE}, { + "verify", YAFFS_TRACE_VERIFY}, { + "verify_nand", YAFFS_TRACE_VERIFY_NAND}, { + "verify_full", YAFFS_TRACE_VERIFY_FULL}, { + "verify_all", YAFFS_TRACE_VERIFY_ALL}, { + "all", 0xffffffff}, { + "none", 0}, { +NULL, 0},}; #define MAX_MASK_NAME_LENGTH 40 static int yaffs_proc_write_trace_options(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { unsigned rg = 0, mask_bitfield; char *end; @@ -2845,15 +2820,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, done = 0; } else { for (x = buf + pos, i = 0; - (*x == '_' || (*x >= 'a' && *x <= 'z')) && - i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) + (*x == '_' || (*x >= 'a' && *x <= 'z')) && + i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) substring[i] = *x; substring[i] = '\0'; for (i = 0; mask_flags[i].mask_name != NULL; i++) { - if (strcmp(substring, mask_flags[i].mask_name) == 0) { + if (strcmp(substring, mask_flags[i].mask_name) + == 0) { mask_name = mask_flags[i].mask_name; - mask_bitfield = mask_flags[i].mask_bitfield; + mask_bitfield = + mask_flags[i].mask_bitfield; done = 0; break; } @@ -2888,18 +2865,18 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, char flag; flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-'; - printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name); + printk(KERN_DEBUG "%c%s\n", flag, + mask_flags[i].mask_name); } } return count; } - static int yaffs_proc_write(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { - return yaffs_proc_write_trace_options(file, buf, count, data); + return yaffs_proc_write_trace_options(file, buf, count, data); } /* Stuff to handle installation of file systems */ @@ -2924,18 +2901,15 @@ static int __init init_yaffs_fs(void) #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED T(YAFFS_TRACE_ALWAYS, - (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); + (TSTR + (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); #endif - - - init_MUTEX(&yaffs_context_lock); /* Install the proc_fs entries */ my_proc_entry = create_proc_entry("yaffs", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (my_proc_entry) { my_proc_entry->write_proc = yaffs_proc_write; @@ -2945,8 +2919,7 @@ static int __init init_yaffs_fs(void) return -ENOMEM; debug_proc_entry = create_proc_entry("yaffs_stats", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (debug_proc_entry) { debug_proc_entry->write_proc = NULL; @@ -2988,7 +2961,7 @@ static void __exit exit_yaffs_fs(void) struct file_system_to_install *fsinst; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); + (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); remove_proc_entry("yaffs", YPROC_ROOT); remove_proc_entry("yaffs_stats", YPROC_ROOT); @@ -3005,8 +2978,8 @@ static void __exit exit_yaffs_fs(void) } module_init(init_yaffs_fs) -module_exit(exit_yaffs_fs) + module_exit(exit_yaffs_fs) -MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); + MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); MODULE_LICENSE("GPL"); diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c index 059d125..4ab0f22 100644 --- a/yaffs_yaffs1.c +++ b/yaffs_yaffs1.c @@ -40,11 +40,8 @@ int yaffs1_scan(struct yaffs_dev *dev) struct yaffs_shadow_fixer *shadow_fixers = NULL; - u8 *chunk_data; - - T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan starts intstartblk %d intendblk %d..." TENDSTR), dev->internal_start_block, dev->internal_end_block)); @@ -55,7 +52,8 @@ int yaffs1_scan(struct yaffs_dev *dev) /* Scan all the blocks to determine their state */ bi = dev->block_info; - for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { yaffs_clear_chunk_bits(dev, blk); bi->pages_in_use = 0; bi->soft_del_pages = 0; @@ -85,9 +83,8 @@ int yaffs1_scan(struct yaffs_dev *dev) } /* For each block.... */ - for (blk= dev->internal_start_block; - !alloc_failed && blk <= dev->internal_end_block; - blk++) { + for (blk = dev->internal_start_block; + !alloc_failed && blk <= dev->internal_end_block; blk++) { YYIELD(); @@ -96,18 +93,19 @@ int yaffs1_scan(struct yaffs_dev *dev) deleted = 0; - /* For each chunk in each block that needs scanning....*/ + /* For each chunk in each block that needs scanning.... */ for (c = 0; !alloc_failed && c < dev->param.chunks_per_block && state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { /* Read the tags and decide what to do */ chunk = blk * dev->param.chunks_per_block + c; result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, - &tags); + &tags); /* Let's have a good look at this chunk... */ - if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED || tags.is_deleted) { + if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED + || tags.is_deleted) { /* YAFFS1 only... * A deleted chunk */ @@ -138,7 +136,8 @@ int yaffs1_scan(struct yaffs_dev *dev) } - dev->n_free_chunks += (dev->param.chunks_per_block - c); + dev->n_free_chunks += + (dev->param.chunks_per_block - c); } else if (tags.chunk_id > 0) { /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; @@ -147,9 +146,8 @@ int yaffs1_scan(struct yaffs_dev *dev) bi->pages_in_use++; in = yaffs_find_or_create_by_number(dev, - tags. - obj_id, - YAFFS_OBJECT_TYPE_FILE); + tags.obj_id, + YAFFS_OBJECT_TYPE_FILE); /* PutChunkIntoFile checks for a clash (two data chunks with * the same chunk_id). */ @@ -158,24 +156,27 @@ int yaffs1_scan(struct yaffs_dev *dev) alloc_failed = 1; if (in) { - if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, 1)) + if (!yaffs_put_chunk_in_file + (in, tags.chunk_id, chunk, 1)) alloc_failed = 1; } endpos = - (tags.chunk_id - 1) * dev->data_bytes_per_chunk + + (tags.chunk_id - + 1) * dev->data_bytes_per_chunk + tags.n_bytes; - if (in && - in->variant_type == YAFFS_OBJECT_TYPE_FILE + if (in + && in->variant_type == + YAFFS_OBJECT_TYPE_FILE && in->variant.file_variant.scanned_size < endpos) { - in->variant.file_variant. - scanned_size = endpos; + in->variant.file_variant.scanned_size = + endpos; if (!dev->param.use_header_file_size) { - in->variant.file_variant. - file_size = - in->variant.file_variant. - scanned_size; + in->variant. + file_variant.file_size = + in->variant. + file_variant.scanned_size; } } @@ -188,13 +189,12 @@ int yaffs1_scan(struct yaffs_dev *dev) bi->pages_in_use++; result = yaffs_rd_chunk_tags_nand(dev, chunk, - chunk_data, - NULL); + chunk_data, + NULL); - oh = (struct yaffs_obj_hdr *) chunk_data; + oh = (struct yaffs_obj_hdr *)chunk_data; - in = yaffs_find_by_number(dev, - tags.obj_id); + in = yaffs_find_by_number(dev, tags.obj_id); if (in && in->variant_type != oh->type) { /* This should not happen, but somehow * Wev'e ended up with an obj_id that has been reused but not yet @@ -207,9 +207,8 @@ int yaffs1_scan(struct yaffs_dev *dev) } in = yaffs_find_or_create_by_number(dev, - tags. - obj_id, - oh->type); + tags.obj_id, + oh->type); if (!in) alloc_failed = 1; @@ -217,16 +216,21 @@ int yaffs1_scan(struct yaffs_dev *dev) if (in && oh->shadows_obj > 0) { struct yaffs_shadow_fixer *fixer; - fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer)); + fixer = + YMALLOC(sizeof + (struct + yaffs_shadow_fixer)); if (fixer) { fixer->next = shadow_fixers; shadow_fixers = fixer; fixer->obj_id = tags.obj_id; - fixer->shadowed_id = oh->shadows_obj; + fixer->shadowed_id = + oh->shadows_obj; T(YAFFS_TRACE_SCAN, (TSTR - (" Shadow fixer: %d shadows %d" TENDSTR), - fixer->obj_id, fixer->shadowed_id)); + (" Shadow fixer: %d shadows %d" + TENDSTR), fixer->obj_id, + fixer->shadowed_id)); } @@ -236,24 +240,27 @@ int yaffs1_scan(struct yaffs_dev *dev) /* We have already filled this one. We have a duplicate and need to resolve it. */ unsigned existing_serial = in->serial; - unsigned new_serial = tags.serial_number; + unsigned new_serial = + tags.serial_number; - if (((existing_serial + 1) & 3) == new_serial) { + if (((existing_serial + 1) & 3) == + new_serial) { /* Use new one - destroy the exisiting one */ yaffs_chunk_del(dev, - in->hdr_chunk, - 1, __LINE__); + in->hdr_chunk, + 1, __LINE__); in->valid = 0; } else { /* Use existing - destroy this one. */ yaffs_chunk_del(dev, chunk, 1, - __LINE__); + __LINE__); } } if (in && !in->valid && (tags.obj_id == YAFFS_OBJECTID_ROOT || - tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) { + tags.obj_id == + YAFFS_OBJECTID_LOSTNFOUND)) { /* We only load some info, don't fiddle with directory structure */ in->valid = 1; in->variant_type = oh->type; @@ -291,12 +298,13 @@ int yaffs1_scan(struct yaffs_dev *dev) YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ parent->variant_type = - YAFFS_OBJECT_TYPE_DIRECTORY; - INIT_LIST_HEAD(&parent->variant. - dir_variant. - children); - } else if (!parent || parent->variant_type != - YAFFS_OBJECT_TYPE_DIRECTORY) { + YAFFS_OBJECT_TYPE_DIRECTORY; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) + { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory */ @@ -311,7 +319,8 @@ int yaffs1_scan(struct yaffs_dev *dev) yaffs_add_obj_to_dir(parent, in); if (0 && (parent == dev->del_dir || - parent == dev->unlinked_dir)) { + parent == + dev->unlinked_dir)) { in->deleted = 1; /* If it is unlinked at start up then it wants deleting */ dev->n_deleted_files++; } @@ -327,20 +336,21 @@ int yaffs1_scan(struct yaffs_dev *dev) /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (dev->param.use_header_file_size) + if (dev->param. + use_header_file_size) - in->variant.file_variant. - file_size = - oh->file_size; + in->variant. + file_variant.file_size + = oh->file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardlink_variant. - equiv_id = - oh->equiv_id; + in->variant. + hardlink_variant.equiv_id = + oh->equiv_id; in->hard_links.next = - (struct list_head *) - hard_list; + (struct list_head *) + hard_list; hard_list = in; break; case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -350,9 +360,11 @@ int yaffs1_scan(struct yaffs_dev *dev) /* Do nothing */ break; case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symlink_variant.alias = + in->variant.symlink_variant. + alias = yaffs_clone_str(oh->alias); - if (!in->variant.symlink_variant.alias) + if (!in->variant. + symlink_variant.alias) alloc_failed = 1; break; } @@ -362,12 +374,12 @@ int yaffs1_scan(struct yaffs_dev *dev) } if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - /* If we got this far while scanning, then the block is fully allocated.*/ + /* If we got this far while scanning, then the block is fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; } if (state == YAFFS_BLOCK_STATE_ALLOCATING) { - /* If the block was partially allocated then treat it as fully allocated.*/ + /* If the block was partially allocated then treat it as fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; dev->alloc_block = -1; } @@ -383,7 +395,6 @@ int yaffs1_scan(struct yaffs_dev *dev) } - /* Ok, we've done all the scanning. * Fix up the hard link chains. * We should now have scanned all the objects, now it's time to add these @@ -423,7 +434,5 @@ int yaffs1_scan(struct yaffs_dev *dev) T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR))); - return YAFFS_OK; } - diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c index debb56d..97dac45 100644 --- a/yaffs_yaffs2.c +++ b/yaffs_yaffs2.c @@ -11,7 +11,6 @@ * published by the Free Software Foundation. */ - #include "yaffs_guts.h" #include "yaffs_trace.h" #include "yaffs_yaffs2.h" @@ -32,11 +31,10 @@ #define YAFFS_SMALL_HOLE_THRESHOLD 4 - /* * Oldest Dirty Sequence Number handling. */ - + /* yaffs_calc_oldest_dirty_seq() * yaffs2_find_oldest_dirty_seq() * Calculate the oldest dirty sequence number if we don't know it. @@ -48,7 +46,7 @@ void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev) unsigned block_no = 0; struct yaffs_block_info *b; - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; /* Find the oldest dirty sequence number. */ @@ -56,28 +54,27 @@ void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev) b = dev->block_info; for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { if (b->block_state == YAFFS_BLOCK_STATE_FULL && - (b->pages_in_use - b->soft_del_pages) < dev->param.chunks_per_block && - b->seq_number < seq) { + (b->pages_in_use - b->soft_del_pages) < + dev->param.chunks_per_block && b->seq_number < seq) { seq = b->seq_number; block_no = i; } b++; } - if(block_no){ + if (block_no) { dev->oldest_dirty_seq = seq; dev->oldest_dirty_block = block_no; } } - void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev) { - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; - if(!dev->oldest_dirty_seq) + if (!dev->oldest_dirty_seq) yaffs_calc_oldest_dirty_seq(dev); } @@ -87,13 +84,14 @@ void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev) * becomes invalid). If the value matches the oldest then we clear * dev->oldest_dirty_seq to force its recomputation. */ -void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *bi) +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; - if(!bi || bi->seq_number == dev->oldest_dirty_seq){ + if (!bi || bi->seq_number == dev->oldest_dirty_seq) { dev->oldest_dirty_seq = 0; dev->oldest_dirty_block = 0; } @@ -104,21 +102,21 @@ void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_inf * Update the oldest dirty sequence number whenever we dirty a block. * Only do this if the oldest_dirty_seq is actually being tracked. */ -void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi) +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi) { - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; - if(dev->oldest_dirty_seq){ - if(dev->oldest_dirty_seq > bi->seq_number){ + if (dev->oldest_dirty_seq) { + if (dev->oldest_dirty_seq > bi->seq_number) { dev->oldest_dirty_seq = bi->seq_number; dev->oldest_dirty_block = block_no; } } } -int yaffs_block_ok_for_gc(struct yaffs_dev *dev, - struct yaffs_block_info *bi) +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi) { if (!dev->param.is_yaffs2) @@ -140,32 +138,32 @@ int yaffs_block_ok_for_gc(struct yaffs_dev *dev, * periodically finds the oldest full block by sequence number for refreshing. * Only for yaffs2. */ -u32 yaffs2_find_refresh_block(struct yaffs_dev *dev) +u32 yaffs2_find_refresh_block(struct yaffs_dev * dev) { - u32 b ; + u32 b; u32 oldest = 0; u32 oldest_seq = 0; struct yaffs_block_info *bi; - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return oldest; /* * If refresh period < 10 then refreshing is disabled. */ - if(dev->param.refresh_period < 10) - return oldest; + if (dev->param.refresh_period < 10) + return oldest; - /* - * Fix broken values. - */ - if(dev->refresh_skip > dev->param.refresh_period) - dev->refresh_skip = dev->param.refresh_period; + /* + * Fix broken values. + */ + if (dev->refresh_skip > dev->param.refresh_period) + dev->refresh_skip = dev->param.refresh_period; - if(dev->refresh_skip > 0) - return oldest; + if (dev->refresh_skip > 0) + return oldest; /* * Refresh skip is now zero. @@ -175,23 +173,23 @@ u32 yaffs2_find_refresh_block(struct yaffs_dev *dev) dev->refresh_skip = dev->param.refresh_period; dev->refresh_count++; bi = dev->block_info; - for (b = dev->internal_start_block; b <=dev->internal_end_block; b++){ + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { - if (bi->block_state == YAFFS_BLOCK_STATE_FULL){ + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) { - if(oldest < 1 || - bi->seq_number < oldest_seq){ - oldest = b; - oldest_seq = bi->seq_number; - } + if (oldest < 1 || bi->seq_number < oldest_seq) { + oldest = b; + oldest_seq = bi->seq_number; + } } bi++; } if (oldest > 0) { T(YAFFS_TRACE_GC, - (TSTR("GC refresh count %d selected block %d with seq_number %d" TENDSTR), - dev->refresh_count, oldest, oldest_seq)); + (TSTR + ("GC refresh count %d selected block %d with seq_number %d" + TENDSTR), dev->refresh_count, oldest, oldest_seq)); } return oldest; @@ -200,56 +198,59 @@ u32 yaffs2_find_refresh_block(struct yaffs_dev *dev) int yaffs2_checkpt_required(struct yaffs_dev *dev) { int nblocks; - - if(!dev->param.is_yaffs2) + + if (!dev->param.is_yaffs2) return 0; - - nblocks = dev->internal_end_block - dev->internal_start_block + 1 ; - return !dev->param.skip_checkpt_wr && - !dev->read_only && - (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); + nblocks = dev->internal_end_block - dev->internal_start_block + 1; + + return !dev->param.skip_checkpt_wr && + !dev->read_only && (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); } int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev) { int retval; - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return 0; - if (!dev->checkpoint_blocks_required && - yaffs2_checkpt_required(dev)){ + if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)) { /* Not a valid value so recalculate */ int n_bytes = 0; int n_blocks; - int dev_blocks = (dev->param.end_block - dev->param.start_block + 1); + int dev_blocks = + (dev->param.end_block - dev->param.start_block + 1); n_bytes += sizeof(struct yaffs_checkpt_validity); n_bytes += sizeof(struct yaffs_checkpt_dev); n_bytes += dev_blocks * sizeof(struct yaffs_block_info); n_bytes += dev_blocks * dev->chunk_bit_stride; - n_bytes += (sizeof(struct yaffs_checkpt_obj) + sizeof(u32)) * (dev->n_obj); + n_bytes += + (sizeof(struct yaffs_checkpt_obj) + + sizeof(u32)) * (dev->n_obj); n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes); n_bytes += sizeof(struct yaffs_checkpt_validity); - n_bytes += sizeof(u32); /* checksum*/ + n_bytes += sizeof(u32); /* checksum */ /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */ - n_blocks = (n_bytes/(dev->data_bytes_per_chunk * dev->param.chunks_per_block)) + 3; + n_blocks = + (n_bytes / + (dev->data_bytes_per_chunk * + dev->param.chunks_per_block)) + 3; dev->checkpoint_blocks_required = n_blocks; } retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt; - if(retval < 0) + if (retval < 0) retval = 0; return retval; } /*--------------------- Checkpointing --------------------*/ - static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head) { struct yaffs_checkpt_validity cp; @@ -261,8 +262,7 @@ static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head) cp.version = YAFFS_CHECKPOINT_VERSION; cp.head = (head) ? 1 : 0; - return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? - 1 : 0; + return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? 1 : 0; } static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head) @@ -274,14 +274,14 @@ static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head) if (ok) ok = (cp.struct_type == sizeof(cp)) && - (cp.magic == YAFFS_MAGIC) && - (cp.version == YAFFS_CHECKPOINT_VERSION) && - (cp.head == ((head) ? 1 : 0)); + (cp.magic == YAFFS_MAGIC) && + (cp.version == YAFFS_CHECKPOINT_VERSION) && + (cp.head == ((head) ? 1 : 0)); return ok ? 1 : 0; } static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp, - struct yaffs_dev *dev) + struct yaffs_dev *dev) { cp->n_erased_blocks = dev->n_erased_blocks; cp->alloc_block = dev->alloc_block; @@ -296,7 +296,7 @@ static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp, } static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev, - struct yaffs_checkpt_dev *cp) + struct yaffs_checkpt_dev *cp) { dev->n_erased_blocks = cp->n_erased_blocks; dev->alloc_block = cp->alloc_block; @@ -309,16 +309,16 @@ static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev, dev->seq_number = cp->seq_number; } - static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev) { struct yaffs_checkpt_dev cp; u32 n_bytes; - u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1); + u32 n_blocks = + (dev->internal_end_block - dev->internal_start_block + 1); int ok; - /* Write device runtime values*/ + /* Write device runtime values */ yaffs2_dev_to_checkpt_dev(&cp, dev); cp.struct_type = sizeof(cp); @@ -327,15 +327,17 @@ static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev) /* Write block info */ if (ok) { n_bytes = n_blocks * sizeof(struct yaffs_block_info); - ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes); + ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == + n_bytes); } /* Write chunk bits */ if (ok) { n_bytes = n_blocks * dev->chunk_bit_stride; - ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == n_bytes); + ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == + n_bytes); } - return ok ? 1 : 0; + return ok ? 1 : 0; } @@ -343,7 +345,8 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev) { struct yaffs_checkpt_dev cp; u32 n_bytes; - u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1); + u32 n_blocks = + (dev->internal_end_block - dev->internal_start_block + 1); int ok; @@ -354,7 +357,6 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev) if (cp.struct_type != sizeof(cp)) return 0; - yaffs_checkpt_dev_to_dev(dev, &cp); n_bytes = n_blocks * sizeof(struct yaffs_block_info); @@ -371,7 +373,7 @@ static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev) } static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp, - struct yaffs_obj *obj) + struct yaffs_obj *obj) { cp->obj_id = obj->obj_id; @@ -393,36 +395,40 @@ static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp, cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id; } -static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt_obj *cp) +static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, + struct yaffs_checkpt_obj *cp) { struct yaffs_obj *parent; if (obj->variant_type != cp->variant_type) { T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d " - TCONT("chunk %d does not match existing object type %d") - TENDSTR), cp->obj_id, cp->variant_type, cp->hdr_chunk, - obj->variant_type)); + TCONT + ("chunk %d does not match existing object type %d") + TENDSTR), cp->obj_id, + cp->variant_type, cp->hdr_chunk, + obj->variant_type)); return 0; } obj->obj_id = cp->obj_id; if (cp->parent_id) - parent = yaffs_find_or_create_by_number( - obj->my_dev, - cp->parent_id, - YAFFS_OBJECT_TYPE_DIRECTORY); + parent = yaffs_find_or_create_by_number(obj->my_dev, + cp->parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); else parent = NULL; if (parent) { if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d" - TCONT(" chunk %d Parent type, %d, not directory") - TENDSTR), - cp->obj_id, cp->parent_id, cp->variant_type, - cp->hdr_chunk, parent->variant_type)); + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("Checkpoint read object %d parent %d type %d" + TCONT(" chunk %d Parent type, %d, not directory") + TENDSTR), cp->obj_id, cp->parent_id, + cp->variant_type, cp->hdr_chunk, + parent->variant_type)); return 0; } yaffs_add_obj_to_dir(parent, obj); @@ -449,10 +455,9 @@ static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt return 1; } - - -static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, - u32 level, int chunk_offset) +static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, + struct yaffs_tnode *tn, u32 level, + int chunk_offset) { int i; struct yaffs_dev *dev = in->my_dev; @@ -464,17 +469,27 @@ static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { if (tn->internal[i]) { ok = yaffs2_checkpt_tnode_worker(in, - tn->internal[i], - level - 1, - (chunk_offset< + internal + [i], + level - + 1, + (chunk_offset + << + YAFFS_TNODES_INTERNAL_BITS) + + i); } } } else if (level == 0) { - u32 base_offset = chunk_offset << YAFFS_TNODES_LEVEL0_BITS; - ok = (yaffs2_checkpt_wr(dev, &base_offset, sizeof(base_offset)) == - sizeof(base_offset)); + u32 base_offset = + chunk_offset << YAFFS_TNODES_LEVEL0_BITS; + ok = (yaffs2_checkpt_wr + (dev, &base_offset, + sizeof(base_offset)) == sizeof(base_offset)); if (ok) - ok = (yaffs2_checkpt_wr(dev, tn, dev->tnode_size) == dev->tnode_size); + ok = (yaffs2_checkpt_wr + (dev, tn, + dev->tnode_size) == dev->tnode_size); } } @@ -489,12 +504,13 @@ static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj) if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ok = yaffs2_checkpt_tnode_worker(obj, - obj->variant.file_variant.top, - obj->variant.file_variant.top_level, - 0); + obj->variant.file_variant.top, + obj->variant.file_variant. + top_level, 0); if (ok) - ok = (yaffs2_checkpt_wr(obj->my_dev, &end_marker, sizeof(end_marker)) == - sizeof(end_marker)); + ok = (yaffs2_checkpt_wr + (obj->my_dev, &end_marker, + sizeof(end_marker)) == sizeof(end_marker)); } return ok ? 1 : 0; @@ -509,38 +525,39 @@ static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj) struct yaffs_tnode *tn; int nread = 0; - ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk)); + ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == + sizeof(base_chunk)); while (ok && (~base_chunk)) { nread++; /* Read level 0 tnode */ - tn = yaffs_get_tnode(dev); - if (tn){ - ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == dev->tnode_size); + if (tn) { + ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == + dev->tnode_size); } else ok = 0; if (tn && ok) ok = yaffs_add_find_tnode_0(dev, - file_stuct_ptr, - base_chunk, - tn) ? 1 : 0; + file_stuct_ptr, + base_chunk, tn) ? 1 : 0; if (ok) - ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk)); + ok = (yaffs2_checkpt_rd + (dev, &base_chunk, + sizeof(base_chunk)) == sizeof(base_chunk)); } - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), - nread, base_chunk, ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), + nread, base_chunk, ok)); return ok ? 1 : 0; } - static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev) { struct yaffs_obj *obj; @@ -549,27 +566,34 @@ static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev) int ok = 1; struct list_head *lh; - /* Iterate through the objects in each hash entry, * dumping them to the checkpointing stream. */ - for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { list_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = list_entry(lh, struct yaffs_obj, hash_link); + obj = + list_entry(lh, struct yaffs_obj, hash_link); if (!obj->defered_free) { yaffs2_obj_checkpt_obj(&cp, obj); cp.struct_type = sizeof(cp); - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR), - cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk, obj)); - - ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); - - if (ok && obj->variant_type == YAFFS_OBJECT_TYPE_FILE) - ok = yaffs2_wr_checkpt_tnodes(obj); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" + TENDSTR), cp.obj_id, cp.parent_id, + cp.variant_type, cp.hdr_chunk, obj)); + + ok = (yaffs2_checkpt_wr + (dev, &cp, + sizeof(cp)) == sizeof(cp)); + + if (ok + && obj->variant_type == + YAFFS_OBJECT_TYPE_FILE) + ok = yaffs2_wr_checkpt_tnodes + (obj); } } } @@ -596,27 +620,34 @@ static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev) while (ok && !done) { ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); if (cp.struct_type != sizeof(cp)) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR), - cp.struct_type, (int)sizeof(cp), ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("struct size %d instead of %d ok %d" TENDSTR), + cp.struct_type, (int)sizeof(cp), ok)); ok = 0; } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR), - cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("Checkpoint read object %d parent %d type %d chunk %d " + TENDSTR), cp.obj_id, cp.parent_id, cp.variant_type, + cp.hdr_chunk)); if (ok && cp.obj_id == ~0) done = 1; else if (ok) { - obj = yaffs_find_or_create_by_number(dev, cp.obj_id, cp.variant_type); + obj = + yaffs_find_or_create_by_number(dev, cp.obj_id, + cp.variant_type); if (obj) { ok = taffs2_checkpt_obj_to_obj(obj, &cp); if (!ok) break; if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ok = yaffs2_rd_checkpt_tnodes(obj); - } else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + } else if (obj->variant_type == + YAFFS_OBJECT_TYPE_HARDLINK) { obj->hard_links.next = - (struct list_head *) hard_list; + (struct list_head *)hard_list; hard_list = obj; } } else @@ -637,7 +668,8 @@ static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev) yaffs2_get_checkpt_sum(dev, &checkpt_sum); - ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == sizeof(checkpt_sum)); + ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == + sizeof(checkpt_sum)); if (!ok) return 0; @@ -653,7 +685,8 @@ static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev) yaffs2_get_checkpt_sum(dev, &checkpt_sum0); - ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == sizeof(checkpt_sum1)); + ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == + sizeof(checkpt_sum1)); if (!ok) return 0; @@ -664,13 +697,13 @@ static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev) return 1; } - static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev) { int ok = 1; if (!yaffs2_checkpt_required(dev)) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("skipping checkpoint write" TENDSTR))); ok = 0; } @@ -678,19 +711,23 @@ static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev) ok = yaffs2_checkpt_open(dev, 1); if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint validity" TENDSTR))); ok = yaffs2_wr_checkpt_validity_marker(dev, 1); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint device" TENDSTR))); ok = yaffs2_wr_checkpt_dev(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint objects" TENDSTR))); ok = yaffs2_wr_checkpt_objs(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint validity" TENDSTR))); ok = yaffs2_wr_checkpt_validity_marker(dev, 0); } @@ -711,38 +748,44 @@ static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev) static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev) { int ok = 1; - - if(!dev->param.is_yaffs2) + + if (!dev->param.is_yaffs2) ok = 0; if (ok && dev->param.skip_checkpt_rd) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("skipping checkpoint read" TENDSTR))); ok = 0; } if (ok) - ok = yaffs2_checkpt_open(dev, 0); /* open for read */ + ok = yaffs2_checkpt_open(dev, 0); /* open for read */ if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint validity" TENDSTR))); ok = yaffs2_rd_checkpt_validity_marker(dev, 1); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint device" TENDSTR))); ok = yaffs2_rd_checkpt_dev(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint objects" TENDSTR))); ok = yaffs2_rd_checkpt_objs(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint validity" TENDSTR))); ok = yaffs2_rd_checkpt_validity_marker(dev, 0); } if (ok) { ok = yaffs2_rd_checkpt_sum(dev); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint checksum %d" TENDSTR), ok)); } if (!yaffs_checkpt_close(dev)) @@ -759,8 +802,7 @@ static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev) void yaffs2_checkpt_invalidate(struct yaffs_dev *dev) { - if (dev->is_checkpointed || - dev->blocks_in_checkpt > 0) { + if (dev->is_checkpointed || dev->blocks_in_checkpt > 0) { dev->is_checkpointed = 0; yaffs2_checkpt_invalidate_stream(dev); } @@ -768,11 +810,12 @@ void yaffs2_checkpt_invalidate(struct yaffs_dev *dev) dev->param.sb_dirty_fn(dev); } - int yaffs_checkpoint_save(struct yaffs_dev *dev) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("save entry: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); yaffs_verify_objects(dev); yaffs_verify_blocks(dev); @@ -783,7 +826,9 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev) yaffs2_wr_checkpt_data(dev); } - T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_ALWAYS, + (TSTR("save exit: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); return dev->is_checkpointed; } @@ -791,7 +836,9 @@ int yaffs_checkpoint_save(struct yaffs_dev *dev) int yaffs2_checkpt_restore(struct yaffs_dev *dev) { int retval; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("restore entry: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); retval = yaffs2_rd_checkpt_data(dev); @@ -801,7 +848,9 @@ int yaffs2_checkpt_restore(struct yaffs_dev *dev) yaffs_verify_free_chunks(dev); } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("restore exit: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); return retval; } @@ -812,28 +861,27 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size) * We're going to be writing a hole. * If the hole is small then write zeros otherwise write a start of hole marker. */ - loff_t old_file_size; int increase; - int small_hole ; + int small_hole; int result = YAFFS_OK; struct yaffs_dev *dev = NULL; u8 *local_buffer = NULL; - + int small_increase_ok = 0; - - if(!obj) + + if (!obj) return YAFFS_FAIL; - if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE) + if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - + dev = obj->my_dev; - + /* Bail out if not yaffs2 mode */ - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return YAFFS_OK; old_file_size = obj->variant.file_variant.file_size; @@ -843,46 +891,48 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size) increase = new_size - old_file_size; - if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && - yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) + if (increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && + yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) small_hole = 1; else small_hole = 0; - if(small_hole) - local_buffer= yaffs_get_temp_buffer(dev, __LINE__); - - if(local_buffer){ + if (small_hole) + local_buffer = yaffs_get_temp_buffer(dev, __LINE__); + + if (local_buffer) { /* fill hole with zero bytes */ int pos = old_file_size; int this_write; int written; - memset(local_buffer,0,dev->data_bytes_per_chunk); + memset(local_buffer, 0, dev->data_bytes_per_chunk); small_increase_ok = 1; - while(increase > 0 && small_increase_ok){ + while (increase > 0 && small_increase_ok) { this_write = increase; - if(this_write > dev->data_bytes_per_chunk) + if (this_write > dev->data_bytes_per_chunk) this_write = dev->data_bytes_per_chunk; - written = yaffs_do_file_wr(obj,local_buffer,pos,this_write,0); - if(written == this_write){ + written = + yaffs_do_file_wr(obj, local_buffer, pos, this_write, + 0); + if (written == this_write) { pos += this_write; increase -= this_write; } else small_increase_ok = 0; } - yaffs_release_temp_buffer(dev,local_buffer,__LINE__); + yaffs_release_temp_buffer(dev, local_buffer, __LINE__); - /* If we were out of space then reverse any chunks we've added */ - if(!small_increase_ok) + /* If we were out of space then reverse any chunks we've added */ + if (!small_increase_ok) yaffs_resize_file_down(obj, old_file_size); } - + if (!small_increase_ok && - obj->parent && - obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && - obj->parent->obj_id != YAFFS_OBJECTID_DELETED){ + obj->parent && + obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + obj->parent->obj_id != YAFFS_OBJECTID_DELETED) { /* Write a hole start header with the old file size */ yaffs_update_oh(obj, NULL, 0, 1, 0, NULL); } @@ -891,13 +941,11 @@ int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size) } - -struct yaffs_block_index{ +struct yaffs_block_index { int seq; int block; }; - static int yaffs2_ybicmp(const void *a, const void *b) { int aseq = ((struct yaffs_block_index *)a)->seq; @@ -940,7 +988,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) int equiv_id; int alloc_failed = 0; - struct yaffs_block_index *block_index = NULL; int alt_block_index = 0; @@ -949,19 +996,21 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) ("yaffs2_scan_backwards starts intstartblk %d intendblk %d..." TENDSTR), dev->internal_start_block, dev->internal_end_block)); - dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index)); if (!block_index) { - block_index = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index)); + block_index = + YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index)); alt_block_index = 1; } if (!block_index) { T(YAFFS_TRACE_SCAN, - (TSTR("yaffs2_scan_backwards() could not allocate block index!" TENDSTR))); + (TSTR + ("yaffs2_scan_backwards() could not allocate block index!" + TENDSTR))); return YAFFS_FAIL; } @@ -971,7 +1020,8 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) /* Scan all the blocks to determine their state */ bi = dev->block_info; - for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { yaffs_clear_chunk_bits(dev, blk); bi->pages_in_use = 0; bi->soft_del_pages = 0; @@ -990,7 +1040,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, state, seq_number)); - if (state == YAFFS_BLOCK_STATE_CHECKPOINT) { dev->blocks_in_checkpt++; @@ -1028,14 +1077,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) } T(YAFFS_TRACE_SCAN, - (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan)); - - + (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan)); YYIELD(); - /* Sort the blocks by sequence number*/ - yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), yaffs2_ybicmp); + /* Sort the blocks by sequence number */ + yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), + yaffs2_ybicmp); YYIELD(); @@ -1049,7 +1097,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) /* For each block.... backwards */ for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter; - block_iter--) { + block_iter--) { /* Cooperative multitasking! This loop can run for so long that watchdog timers expire. */ YYIELD(); @@ -1059,7 +1107,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) bi = yaffs_get_block_info(dev, blk); - state = bi->block_state; deleted = 0; @@ -1077,7 +1124,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) chunk = blk * dev->param.chunks_per_block + c; result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, - &tags); + &tags); /* Let's have a good look at this chunk... */ @@ -1098,9 +1145,12 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) state = YAFFS_BLOCK_STATE_EMPTY; dev->n_erased_blocks++; } else { - if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - state == YAFFS_BLOCK_STATE_ALLOCATING) { - if (dev->seq_number == bi->seq_number) { + if (state == + YAFFS_BLOCK_STATE_NEEDS_SCANNING + || state == + YAFFS_BLOCK_STATE_ALLOCATING) { + if (dev->seq_number == + bi->seq_number) { /* this is the block being allocated from */ T(YAFFS_TRACE_SCAN, @@ -1108,18 +1158,22 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) (" Allocating from %d %d" TENDSTR), blk, c)); - state = YAFFS_BLOCK_STATE_ALLOCATING; + state = + YAFFS_BLOCK_STATE_ALLOCATING; dev->alloc_block = blk; dev->alloc_page = c; - dev->alloc_block_finder = blk; + dev-> + alloc_block_finder = + blk; } else { /* This is a partially written block that is not * the current allocation block. */ - T(YAFFS_TRACE_SCAN, - (TSTR("Partially written block %d detected" TENDSTR), - blk)); + T(YAFFS_TRACE_SCAN, + (TSTR + ("Partially written block %d detected" + TENDSTR), blk)); } } } @@ -1128,37 +1182,40 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) { T(YAFFS_TRACE_SCAN, - (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR), - blk, c)); + (TSTR + (" Unfixed ECC in chunk(%d:%d), chunk ignored" + TENDSTR), blk, c)); - dev->n_free_chunks++; + dev->n_free_chunks++; } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID || - tags.chunk_id > YAFFS_MAX_CHUNK_ID || - (tags.chunk_id > 0 && tags.n_bytes > dev->data_bytes_per_chunk) || - tags.seq_number != bi->seq_number ) { + tags.chunk_id > YAFFS_MAX_CHUNK_ID || + (tags.chunk_id > 0 + && tags.n_bytes > dev->data_bytes_per_chunk) + || tags.seq_number != bi->seq_number) { T(YAFFS_TRACE_SCAN, - (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored"TENDSTR), - blk, c,tags.obj_id, tags.chunk_id, tags.n_bytes)); + (TSTR + ("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored" + TENDSTR), blk, c, tags.obj_id, + tags.chunk_id, tags.n_bytes)); - dev->n_free_chunks++; + dev->n_free_chunks++; } else if (tags.chunk_id > 0) { /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; u32 chunk_base = - (tags.chunk_id - 1) * dev->data_bytes_per_chunk; + (tags.chunk_id - + 1) * dev->data_bytes_per_chunk; found_chunks = 1; - yaffs_set_chunk_bit(dev, blk, c); bi->pages_in_use++; in = yaffs_find_or_create_by_number(dev, - tags. - obj_id, - YAFFS_OBJECT_TYPE_FILE); + tags.obj_id, + YAFFS_OBJECT_TYPE_FILE); if (!in) { /* Out of memory */ alloc_failed = 1; @@ -1166,9 +1223,11 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) if (in && in->variant_type == YAFFS_OBJECT_TYPE_FILE - && chunk_base < in->variant.file_variant.shrink_size) { + && chunk_base < + in->variant.file_variant.shrink_size) { /* This has not been invalidated by a resize */ - if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, -1)) { + if (!yaffs_put_chunk_in_file + (in, tags.chunk_id, chunk, -1)) { alloc_failed = 1; } @@ -1178,15 +1237,19 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) endpos = chunk_base + tags.n_bytes; if (!in->valid && /* have not got an object header yet */ - in->variant.file_variant.scanned_size < endpos) { - in->variant.file_variant.scanned_size = endpos; - in->variant.file_variant.file_size = endpos; + in->variant.file_variant. + scanned_size < endpos) { + in->variant.file_variant. + scanned_size = endpos; + in->variant.file_variant. + file_size = endpos; } } else if (in) { /* This chunk has been invalidated by a resize, or a past file deletion * so delete the chunk*/ - yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } } else { @@ -1203,18 +1266,23 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) if (tags.extra_available) { in = yaffs_find_or_create_by_number(dev, - tags.obj_id, - tags.extra_obj_type); + tags. + obj_id, + tags. + extra_obj_type); if (!in) alloc_failed = 1; } if (!in || - (!in->valid && dev->param.disable_lazy_load) || - tags.extra_shadows || - (!in->valid && - (tags.obj_id == YAFFS_OBJECTID_ROOT || - tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND))) { + (!in->valid && dev->param.disable_lazy_load) + || tags.extra_shadows || (!in->valid + && (tags.obj_id == + YAFFS_OBJECTID_ROOT + || tags. + obj_id == + YAFFS_OBJECTID_LOSTNFOUND))) + { /* If we don't have valid info then we need to read the chunk * TODO In future we can probably defer reading the chunk and @@ -1222,16 +1290,18 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) */ result = yaffs_rd_chunk_tags_nand(dev, - chunk, - chunk_data, - NULL); + chunk, + chunk_data, + NULL); - oh = (struct yaffs_obj_hdr *) chunk_data; + oh = (struct yaffs_obj_hdr *)chunk_data; if (dev->param.inband_tags) { /* Fix up the header if they got corrupted by inband tags */ - oh->shadows_obj = oh->inband_shadowed_obj_id; - oh->is_shrink = oh->inband_is_shrink; + oh->shadows_obj = + oh->inband_shadowed_obj_id; + oh->is_shrink = + oh->inband_is_shrink; } if (!in) { @@ -1257,23 +1327,34 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) * we first have to suck out resize info if it is a file. */ - if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) && - ((oh && - oh->type == YAFFS_OBJECT_TYPE_FILE) || - (tags.extra_available && - tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) { + if ((in->variant_type == + YAFFS_OBJECT_TYPE_FILE) && ((oh + && + oh-> + type + == + YAFFS_OBJECT_TYPE_FILE) + || + (tags. + extra_available + && + tags. + extra_obj_type + == + YAFFS_OBJECT_TYPE_FILE))) + { u32 this_size = - (oh) ? oh->file_size : tags. - extra_length; - u32 parent_obj_id = (oh) ? oh-> - parent_obj_id : tags. - extra_parent_id; - + file_size : + tags.extra_length; + u32 parent_obj_id = + (oh) ? oh->parent_obj_id : + tags.extra_parent_id; is_shrink = - (oh) ? oh->is_shrink : tags. - extra_is_shrink; + (oh) ? oh-> + is_shrink : + tags.extra_is_shrink; /* If it is deleted (unlinked at start also means deleted) * we treat the file size as being zeroed at this point. @@ -1286,28 +1367,36 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) is_shrink = 1; } - if (is_shrink && in->variant.file_variant.shrink_size > this_size) - in->variant.file_variant.shrink_size = this_size; + if (is_shrink + && in->variant.file_variant. + shrink_size > this_size) + in->variant. + file_variant. + shrink_size = + this_size; if (is_shrink) bi->has_shrink_hdr = 1; } /* Use existing - destroy this one. */ - yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } if (!in->valid && in->variant_type != (oh ? oh->type : tags.extra_obj_type)) - T(YAFFS_TRACE_ERROR, ( - TSTR("yaffs tragedy: Bad object type, " - TCONT("%d != %d, for object %d at chunk ") + T(YAFFS_TRACE_ERROR, + (TSTR + ("yaffs tragedy: Bad object type, " + TCONT + ("%d != %d, for object %d at chunk ") TCONT("%d during scan") - TENDSTR), oh ? - oh->type : tags.extra_obj_type, - in->variant_type, tags.obj_id, - chunk)); + TENDSTR), oh ? + oh->type : tags.extra_obj_type, + in->variant_type, tags.obj_id, + chunk)); if (!in->valid && (tags.obj_id == YAFFS_OBJECTID_ROOT || @@ -1339,32 +1428,33 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) yaffs_load_attribs(in, oh); if (oh->shadows_obj > 0) - yaffs_handle_shadowed_obj(dev, - oh-> - shadows_obj, - 1); - - + yaffs_handle_shadowed_obj + (dev, + oh->shadows_obj, + 1); - yaffs_set_obj_name_from_oh(in, oh); + yaffs_set_obj_name_from_oh(in, + oh); parent = yaffs_find_or_create_by_number - (dev, oh->parent_obj_id, - YAFFS_OBJECT_TYPE_DIRECTORY); + (dev, oh->parent_obj_id, + YAFFS_OBJECT_TYPE_DIRECTORY); - file_size = oh->file_size; - is_shrink = oh->is_shrink; - equiv_id = oh->equiv_id; + file_size = oh->file_size; + is_shrink = oh->is_shrink; + equiv_id = oh->equiv_id; } else { - in->variant_type = tags.extra_obj_type; + in->variant_type = + tags.extra_obj_type; parent = yaffs_find_or_create_by_number - (dev, tags.extra_parent_id, - YAFFS_OBJECT_TYPE_DIRECTORY); - file_size = tags.extra_length; - is_shrink = tags.extra_is_shrink; - equiv_id = tags.extra_equiv_id; + (dev, tags.extra_parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); + file_size = tags.extra_length; + is_shrink = + tags.extra_is_shrink; + equiv_id = tags.extra_equiv_id; in->lazy_loaded = 1; } @@ -1381,12 +1471,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ parent->variant_type = - YAFFS_OBJECT_TYPE_DIRECTORY; - INIT_LIST_HEAD(&parent->variant. - dir_variant. - children); - } else if (!parent || parent->variant_type != - YAFFS_OBJECT_TYPE_DIRECTORY) { + YAFFS_OBJECT_TYPE_DIRECTORY; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) + { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory */ @@ -1400,8 +1491,8 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) yaffs_add_obj_to_dir(parent, in); - is_unlinked = (parent == dev->del_dir) || - (parent == dev->unlinked_dir); + is_unlinked = (parent == dev->del_dir) + || (parent == dev->unlinked_dir); if (is_shrink) { /* Mark the block as having a shrink header */ @@ -1421,28 +1512,40 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) break; case YAFFS_OBJECT_TYPE_FILE: - if (in->variant.file_variant. - scanned_size < file_size) { + if (in->variant. + file_variant.scanned_size < + file_size) { /* This covers the case where the file size is greater * than where the data is * This will happen if the file is resized to be larger * than its current data extents. */ - in->variant.file_variant.file_size = file_size; - in->variant.file_variant.scanned_size = file_size; + in->variant. + file_variant. + file_size = + file_size; + in->variant. + file_variant. + scanned_size = + file_size; } - if (in->variant.file_variant.shrink_size > file_size) - in->variant.file_variant.shrink_size = file_size; - + if (in->variant.file_variant. + shrink_size > file_size) + in->variant. + file_variant. + shrink_size = + file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: if (!is_unlinked) { - in->variant.hardlink_variant.equiv_id = - equiv_id; + in->variant. + hardlink_variant. + equiv_id = equiv_id; in->hard_links.next = - (struct list_head *) hard_list; + (struct list_head *) + hard_list; hard_list = in; } break; @@ -1454,10 +1557,16 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) break; case YAFFS_OBJECT_TYPE_SYMLINK: if (oh) { - in->variant.symlink_variant.alias = - yaffs_clone_str(oh->alias); - if (!in->variant.symlink_variant.alias) - alloc_failed = 1; + in->variant. + symlink_variant. + alias = + yaffs_clone_str(oh-> + alias); + if (!in->variant. + symlink_variant. + alias) + alloc_failed = + 1; } break; } @@ -1466,14 +1575,13 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) } - } /* End of scanning for each chunk */ + } /* End of scanning for each chunk */ if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { /* If we got this far while scanning, then the block is fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; } - bi->block_state = state; /* Now let's see if it was dirty */ @@ -1484,7 +1592,7 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) } } - + yaffs_skip_rest_of_block(dev); if (alt_block_index) @@ -1499,7 +1607,6 @@ int yaffs2_scan_backwards(struct yaffs_dev *dev) */ yaffs_link_fixup(dev, hard_list); - yaffs_release_temp_buffer(dev, chunk_data, __LINE__); if (alloc_failed) diff --git a/yaffs_yaffs2.h b/yaffs_yaffs2.h index ceece88..e1a9287 100644 --- a/yaffs_yaffs2.h +++ b/yaffs_yaffs2.h @@ -20,14 +20,15 @@ void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev); void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev); -void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *bi); -void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi); +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi); +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi); int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi); u32 yaffs2_find_refresh_block(struct yaffs_dev *dev); int yaffs2_checkpt_required(struct yaffs_dev *dev); int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev); - void yaffs2_checkpt_invalidate(struct yaffs_dev *dev); int yaffs2_checkpt_save(struct yaffs_dev *dev); int yaffs2_checkpt_restore(struct yaffs_dev *dev); diff --git a/yportenv_multi.h b/yportenv_multi.h index 3295ca0..ec43fd5 100644 --- a/yportenv_multi.h +++ b/yportenv_multi.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YPORTENV_H__ #define __YPORTENV_H__ @@ -67,7 +66,6 @@ #define yaffs_toupper(a) toupper(a) #define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL) - #define Y_INLINE __inline__ #define YAFFS_LOSTNFOUND_NAME "lost+found" @@ -120,7 +118,6 @@ #include "stdio.h" #include "string.h" - #define YMALLOC(x) malloc(x) #define YFREE(x) free(x) #define YMALLOC_ALT(x) malloc(x) @@ -177,7 +174,7 @@ #define O_RDWR 02 #endif -#ifndef O_CREAT +#ifndef O_CREAT #define O_CREAT 0100 #endif @@ -229,7 +226,7 @@ #define EACCES 13 #endif -#ifndef EXDEV +#ifndef EXDEV #define EXDEV 18 #endif @@ -273,7 +270,6 @@ #define EISDIR 21 #endif - // Mode flags #ifndef S_IFMT @@ -292,7 +288,7 @@ #define S_IFREG 0100000 #endif -#ifndef S_IREAD +#ifndef S_IREAD #define S_IREAD 0000400 #endif @@ -340,5 +336,4 @@ } while (0) #endif - #endif diff --git a/yportenv_single.h b/yportenv_single.h index 42892b8..2eae429 100644 --- a/yportenv_single.h +++ b/yportenv_single.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YPORTENV_LINUX_H__ #define __YPORTENV_LINUX_H__ @@ -61,10 +60,9 @@ #define YAFFS_ROOT_MODE 0755 #define YAFFS_LOSTNFOUND_MODE 0700 - #define Y_CURRENT_TIME CURRENT_TIME.tv_sec #define Y_TIME_CONVERT(x) (x).tv_sec - + #define yaffs_sum_cmp(x, y) ((x) == (y)) #define yaffs_strcmp(a, b) strcmp(a, b) @@ -76,8 +74,6 @@ #define compile_time_assertion(assertion) \ ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; }) - - #ifndef Y_DUMP_STACK #define Y_DUMP_STACK() do { } while (0) #endif @@ -91,5 +87,4 @@ } while (0) #endif - #endif -- 2.30.2