X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_guts.c;h=47607bf54065d30fd8c29b981cccec4fbe773413;hp=486b7e05d0713fd2831a22b705f1df907883c42d;hb=46eb953ecab322d3385ccf84c75d969de8542317;hpb=05f5305b2d17b0e2889338724b864cf80f309437 diff --git a/yaffs_guts.c b/yaffs_guts.c index 486b7e0..47607bf 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -17,22 +17,16 @@ #include "yaffs_guts.h" #include "yaffs_tagsvalidity.h" #include "yaffs_getblockinfo.h" - #include "yaffs_tagscompat.h" - #include "yaffs_nand.h" - #include "yaffs_yaffs1.h" #include "yaffs_yaffs2.h" #include "yaffs_bitmap.h" #include "yaffs_verify.h" - #include "yaffs_nand.h" #include "yaffs_packedtags2.h" - #include "yaffs_nameval.h" #include "yaffs_allocator.h" - #include "yaffs_attribs.h" /* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */ @@ -44,14 +38,14 @@ /* Forward declarations */ 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); /* 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) + int *chunk_out, u32 *offset_out) { int chunk; u32 offset; @@ -144,7 +138,8 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev) u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no) { - int i, j; + int i; + int j; dev->temp_in_use++; if (dev->temp_in_use > dev->max_temp) @@ -168,7 +163,8 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no) "Out of temp buffers at line %d, other held by lines:", line_no); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - yaffs_trace(YAFFS_TRACE_BUFFERS," %d", dev->temp_buffer[i].line); + yaffs_trace(YAFFS_TRACE_BUFFERS, + " %d", dev->temp_buffer[i].line); /* * If we got here then we have to allocate an unmanaged one @@ -180,7 +176,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; @@ -207,7 +203,7 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no) /* * 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; @@ -235,7 +231,7 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer) */ static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, - const u8 * data, + const u8 *data, const struct yaffs_ext_tags *tags) { dev = dev; @@ -261,8 +257,9 @@ void yaffs_handle_chunk_error(struct yaffs_dev *dev, bi->chunk_error_strikes++; if (bi->chunk_error_strikes > 3) { - bi->needs_retiring = 1; /* Too many stikes, so retire this */ - yaffs_trace(YAFFS_TRACE_ALWAYS, "yaffs: Block struck out"); + bi->needs_retiring = 1; /* Too many stikes, so retire */ + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs: Block struck out"); } } @@ -277,7 +274,8 @@ static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, yaffs_handle_chunk_error(dev, bi); if (erased_ok) { - /* Was an actual write failure, so mark the block for retirement */ + /* Was an actual write failure, + * so mark the block for retirement.*/ bi->needs_retiring = 1; yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, "**>> Block %d needs retiring", flash_block); @@ -321,7 +319,7 @@ struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev) * 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--) { @@ -346,7 +344,8 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || tags.chunk_used) { - yaffs_trace(YAFFS_TRACE_NANDACCESS, "Chunk %d not erased", nand_chunk); + yaffs_trace(YAFFS_TRACE_NANDACCESS, + "Chunk %d not erased", nand_chunk); retval = YAFFS_FAIL; } @@ -358,7 +357,7 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) static int yaffs_verify_chunk_written(struct yaffs_dev *dev, int nand_chunk, - const u8 * data, + const u8 *data, struct yaffs_ext_tags *tags) { int retval = YAFFS_OK; @@ -396,7 +395,6 @@ int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks) static int yaffs_find_alloc_block(struct yaffs_dev *dev) { int i; - struct yaffs_block_info *bi; if (dev->n_erased_blocks < 1) { @@ -404,7 +402,7 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev) * Can't get space to gc */ yaffs_trace(YAFFS_TRACE_ERROR, - "yaffs tragedy: no more erased blocks" ); + "yaffs tragedy: no more erased blocks"); return -1; } @@ -453,7 +451,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, } if (!use_reserver && !yaffs_check_alloc_available(dev, 1)) { - /* Not enough space to allocate unless we're allowed to use the reserve. */ + /* No space unless we're allowed to use the reserve. */ return -1; } @@ -486,7 +484,8 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, return ret_val; } - yaffs_trace(YAFFS_TRACE_ERROR, "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" ); + yaffs_trace(YAFFS_TRACE_ERROR, + "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!"); return -1; } @@ -521,7 +520,7 @@ void yaffs_skip_rest_of_block(struct yaffs_dev *dev) } static int yaffs_write_new_chunk(struct yaffs_dev *dev, - const u8 * data, + const u8 *data, struct yaffs_ext_tags *tags, int use_reserver) { int attempts = 0; @@ -560,7 +559,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev, * lot of checks that are most likely not needed. * * Mods to the above - * If an erase check fails or the write fails we skip the + * If an erase check fails or the write fails we skip the * rest of the block. */ @@ -668,12 +667,12 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) /*---------------- 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; + if (bname) { while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH / 2))) { @@ -690,9 +689,9 @@ void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name) { #ifndef CONFIG_YAFFS_NO_SHORT_NAMES memset(obj->short_name, 0, sizeof(obj->short_name)); - if (name && - strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <= - YAFFS_SHORT_NAME_LENGTH) + if (name && + strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <= + YAFFS_SHORT_NAME_LENGTH) strcpy(obj->short_name, name); else obj->short_name[0] = _Y('\0'); @@ -724,6 +723,7 @@ void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev) { struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev); + if (tn) { memset(tn, 0, dev->tnode_size); dev->n_tnodes++; @@ -774,7 +774,7 @@ void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, bit_in_word = (32 - bit_in_word); word_in_map++;; mask = - dev->tnode_mask >> ( /*dev->tnode_width - */ bit_in_word); + dev->tnode_mask >> bit_in_word; map[word_in_map] &= ~mask; map[word_in_map] |= (mask & (val >> bit_in_word)); } @@ -860,15 +860,16 @@ struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, return tn; } -/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree. +/* add_find_tnode_0 finds the level 0 tnode if it exists, + * otherwise first expands the tree. * This happens in two steps: * 1. If the tree isn't tall enough, then make it taller. * 2. Scan down the tree towards the level 0 tnode adding tnodes if required. * * Used when modifying the tree. * - * If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will - * be plugged into the ttree. + * If the tn argument is NULL, then a fresh tnode will be added otherwise the + * specified tn will be plugged into the ttree. */ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, @@ -880,7 +881,6 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, int i; int l; struct yaffs_tnode *tn; - u32 x; /* Check sane level and page Id */ @@ -911,7 +911,8 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, file_struct->top = tn; file_struct->top_level++; } else { - yaffs_trace(YAFFS_TRACE_ERROR, "yaffs: no more tnodes"); + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs: no more tnodes"); return NULL; } } @@ -937,11 +938,10 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, } 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, release it */ if (tn->internal[x]) yaffs_free_tnode(dev, - tn-> - internal[x]); + tn->internal[x]); tn->internal[x] = passed_tn; } else if (!tn->internal[x]) { @@ -976,8 +976,8 @@ static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, } 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; @@ -991,7 +991,8 @@ static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk, else { yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, tags); - if (yaffs_tags_match(tags, obj_id, inode_chunk)) { + if (yaffs_tags_match(tags, + obj_id, inode_chunk)) { /* found it; */ return the_chunk; } @@ -1010,7 +1011,6 @@ static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, int the_chunk = -1; struct yaffs_ext_tags local_tags; int ret_val = -1; - struct yaffs_dev *dev = in->my_dev; if (!tags) { @@ -1037,7 +1037,6 @@ static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, struct yaffs_tnode *tn; int the_chunk = -1; struct yaffs_ext_tags local_tags; - struct yaffs_dev *dev = in->my_dev; int ret_val = -1; @@ -1082,7 +1081,8 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, unsigned existing_serial, new_serial; if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) { - /* Just ignore an attempt at putting a chunk into a non-file during scanning + /* Just ignore an attempt at putting a chunk into a non-file + * during scanning. * If it is not during Scanning then something went wrong! */ if (!in_scan) { @@ -1110,23 +1110,29 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, if (in_scan != 0) { /* If we're scanning then we need to test for duplicates - * NB This does not need to be efficient since it should only ever + * NB This does not need to be efficient since it should only * happen when the power fails during a write, then only one * chunk should ever be affected. * - * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO - * Update: For backward scanning we don't need to re-read tags so this is quite cheap. + * Correction for YAFFS2: This could happen quite a lot and we + * need to think about efficiency! TODO + * Update: For backward scanning we don't need to re-read tags + * so this is quite cheap. */ if (existing_cunk > 0) { - /* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1 - * thus we have to do a FindChunkInFile to get the real chunk id. + /* NB Right now existing chunk will not be real + * chunk_id if the chunk group size > 1 + * thus we have to do a FindChunkInFile to get the + * real chunk id. * - * We have a duplicate now we need to decide which one to use: + * We have a duplicate now we need to decide which + * one to use: * - * Backwards scanning YAFFS2: The old one is what we use, dump the new one. - * Forward scanning YAFFS2: The new one is what we use, dump the old one. - * YAFFS1: Get both sets of tags and compare serial numbers. + * Backwards scanning YAFFS2: The old one is what + * we use, dump the new one. + * YAFFS1: Get both sets of tags and compare serial + * numbers. */ if (in_scan > 0) { @@ -1150,8 +1156,8 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, } - /* NB The deleted flags should be false, otherwise the chunks will - * not be loaded during a scan + /* NB The deleted flags should be false, otherwise + * the chunks will not be loaded during a scan */ if (in_scan > 0) { @@ -1164,14 +1170,16 @@ int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, ((existing_serial + 1) & 3) == new_serial)) { /* Forward scanning. * Use new - * Delete the old one and drop through to update the tnode + * Delete the old one and drop through to + * update the tnode */ yaffs_chunk_del(dev, existing_cunk, 1, __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 + /* Backward scanning or we want to use the + * existing one + * Delete the new one and return early so that + * the tnode isn't changed */ yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; @@ -1204,10 +1212,12 @@ static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) } } -/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file. - * All soft deleting does is increment the block's softdelete count and pulls the chunk out - * of the tnode. - * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted. +/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all + * the chunks in the file. + * All soft deleting does is increment the block's softdelete count and pulls + * the chunk out of the tnode. + * Thus, essentially this is the same as DeleteWorker except that the chunks + * are soft deleted. */ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, @@ -1220,52 +1230,39 @@ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, if (tn) { if (level > 0) { - - for (i = YAFFS_NTNODES_INTERNAL - 1; all_done && i >= 0; - i--) { + for (i = YAFFS_NTNODES_INTERNAL - 1; + all_done && i >= 0; + i--) { 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? */ + /* Can this happen? */ } } } return (all_done) ? 1 : 0; } else if (level == 0) { - for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) { the_chunk = yaffs_get_group_base(dev, tn, i); if (the_chunk) { - /* Note this does not find the real chunk, only the chunk group. - * We make an assumption that a chunk group is not larger than - * a block. - */ yaffs_soft_del_chunk(dev, the_chunk); yaffs_load_tnode_0(dev, tn, i, 0); } - } return 1; - } - } - return 1; - } static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj) @@ -1329,11 +1326,10 @@ void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj) static int yaffs_change_obj_name(struct yaffs_obj *obj, struct yaffs_obj *new_dir, - const YCHAR * new_name, int force, int shadows) + const YCHAR *new_name, int force, int shadows) { int unlink_op; int del_op; - struct yaffs_obj *existing_target; if (new_dir == NULL) @@ -1358,8 +1354,8 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, existing_target = yaffs_find_by_name(new_dir, new_name); /* If the object is a file going into the unlinked directory, - * then it is OK to just stuff it in since duplicate names are allowed. - * else only proceed if the new name does not exist and if we're putting + * then it is OK to just stuff it in since duplicate names are OK. + * else only proceed if the new name does not exist and we're putting * it into a directory. */ if ((unlink_op || @@ -1376,25 +1372,24 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, if (unlink_op) obj->unlinked = 1; - /* If it is a deletion then we mark it as a shrink for gc purposes. */ + /* If it is a deletion then we mark it as a shrink for gc */ if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= 0) return YAFFS_OK; } - return YAFFS_FAIL; } -/*------------------------ Short Operations Cache ---------------------------------------- +/*------------------------ Short Operations Cache ------------------------------ * In many situations where there is no high level buffering a lot of * reads might be short sequential reads, and a lot of writes may be short * sequential writes. eg. scanning/writing a jpeg file. * In these cases, a short read/write cache can provide a huge perfomance * benefit with dumb-as-a-rock code. - * In Linux, the page cache provides read buffering and the short op cache + * In Linux, the page cache provides read buffering and the short op cache * provides write buffering. * - * There are a limited number (~10) of cache chunks per device so that we don't + * There are a small number (~10) of cache chunks per device so that we don't * need a very intelligent search. */ @@ -1427,7 +1422,7 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj) do { cache = NULL; - /* Find the dirty cache for this object with the lowest chunk id. */ + /* Find the lowest dirty chunk for this object */ for (i = 0; i < n_caches; i++) { if (dev->cache[i].object == obj && dev->cache[i].dirty) { @@ -1442,7 +1437,6 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj) if (cache && !cache->locked) { /* Write it out and free it up */ - chunk_written = yaffs_wr_data_obj(cache->object, cache->chunk_id, @@ -1451,16 +1445,13 @@ static void yaffs_flush_file_cache(struct yaffs_obj *obj) cache->dirty = 0; cache->object = NULL; } - } while (cache && chunk_written > 0); if (cache) /* Hoosterman, disk full while writing cache out. */ yaffs_trace(YAFFS_TRACE_ERROR, "yaffs tragedy: no space during cache write"); - } - } /*yaffs_flush_whole_cache(dev) @@ -1482,11 +1473,9 @@ void yaffs_flush_whole_cache(struct yaffs_dev *dev) for (i = 0; i < n_caches && !obj; i++) { if (dev->cache[i].object && dev->cache[i].dirty) obj = dev->cache[i].object; - } if (obj) yaffs_flush_file_cache(obj); - } while (obj); } @@ -1506,7 +1495,6 @@ static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev) return &dev->cache[i]; } } - return NULL; } @@ -1524,13 +1512,14 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) cache = yaffs_grab_chunk_worker(dev); if (!cache) { - /* They were all dirty, find the last recently used object and flush + /* They were all dirty, find the LRU object and flush * its cache, then find again. - * NB what's here is not very accurate, we actually flush the object - * the last recently used page. + * NB what's here is not very accurate, + * we actually flush the object with the LRU chunk. */ - /* With locking we can't assume we can use entry zero */ + /* With locking we can't assume we can use entry zero, + * Set the_obj to a valid pointer for Coverity. */ the_obj = dev->cache[0].object; usage = -1; @@ -1554,12 +1543,11 @@ static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) yaffs_flush_file_cache(the_obj); cache = yaffs_grab_chunk_worker(dev); } - } return cache; } else { return NULL; - } + } } /* Find a cached chunk */ @@ -1568,6 +1556,7 @@ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, { struct yaffs_dev *dev = obj->my_dev; int i; + if (dev->param.n_caches > 0) { for (i = 0; i < dev->param.n_caches; i++) { if (dev->cache[i].object == obj && @@ -1585,9 +1574,9 @@ static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, int is_write) { - if (dev->param.n_caches > 0) { - if (dev->cache_last_use < 0 || dev->cache_last_use > 100000000) { + if (dev->cache_last_use < 0 || + dev->cache_last_use > 100000000) { /* Reset the cache usages */ int i; for (i = 1; i < dev->param.n_caches; i++) @@ -1595,9 +1584,7 @@ static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, dev->cache_last_use = 0; } - dev->cache_last_use++; - cache->last_use = dev->cache_last_use; if (is_write) @@ -1688,15 +1675,13 @@ void yaffs_handle_defered_free(struct yaffs_obj *obj) static int yaffs_generic_obj_del(struct yaffs_obj *in) { - - /* First off, invalidate the file's data in the cache, without flushing. */ + /* Iinvalidate the file's data in the cache, without flushing. */ yaffs_invalidate_whole_cache(in); - if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) { - /* Move to the unlinked directory so we have a record that it was deleted. */ + if (in->my_dev->param.is_yaffs2 && in->parent != in->my_dev->del_dir) { + /* Move to unlinked directory so we have a deletion record */ yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0); - } yaffs_remove_obj_from_dir(in); @@ -1762,10 +1747,9 @@ static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, if (tn->internal[i]) { tn->internal[i] = yaffs_prune_worker(dev, - tn->internal[i], - level - 1, - (i == - 0) ? del0 : 1); + tn->internal[i], + level - 1, + (i == 0) ? del0 : 1); } if (tn->internal[i]) @@ -1787,11 +1771,8 @@ static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, yaffs_free_tnode(dev, tn); tn = NULL; } - } - return tn; - } static int yaffs_prune_tree(struct yaffs_dev *dev, @@ -1807,8 +1788,8 @@ static int yaffs_prune_tree(struct yaffs_dev *dev, yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0); - /* Now we have a tree with all the non-zero branches NULL but the height - * is the same as it was. + /* Now we have a tree with all the non-zero branches NULL but + * the height is the same as it was. * Let's see if we can trim internal tnodes to shorten the tree. * We can do this if only the 0th element in the tnode is in use * (ie all the non-zero are NULL) @@ -1832,13 +1813,12 @@ static int yaffs_prune_tree(struct yaffs_dev *dev, } } } - return YAFFS_OK; } /*-------------------- End of File Structure functions.-------------------*/ -/* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ +/* alloc_empty_obj gets us a clean Object.*/ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) { struct yaffs_obj *obj = yaffs_alloc_raw_obj(dev); @@ -1897,7 +1877,6 @@ static int yaffs_find_nice_bucket(struct yaffs_dev *dev) lowest = dev->obj_bucket[dev->bucket_finder].count; l = dev->bucket_finder; } - } return l; @@ -1906,17 +1885,13 @@ static int yaffs_find_nice_bucket(struct yaffs_dev *dev) static int yaffs_new_obj_id(struct yaffs_dev *dev) { int bucket = yaffs_find_nice_bucket(dev); - - /* Now find an object value that has not already been taken - * by scanning the list. - */ - int found = 0; struct list_head *i; - u32 n = (u32) bucket; - /* yaffs_check_obj_hash_sane(); */ + /* Now find an object value that has not already been taken + * by scanning the list. + */ while (!found) { found = 1; @@ -1931,7 +1906,6 @@ static int yaffs_new_obj_id(struct yaffs_dev *dev) } } } - return n; } @@ -1954,7 +1928,7 @@ struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number) /* Look if it is in the list */ in = list_entry(i, struct yaffs_obj, hash_link); if (in->obj_id == number) { - /* Don't tell the VFS about this one if it is defered free */ + /* Don't show if it is defered free */ if (in->defered_free) return NULL; return in; @@ -1999,7 +1973,8 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, 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; @@ -2027,17 +2002,17 @@ static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, 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->rename_allowed = 0; /* ... and we're not allowed to rename it... */ - obj->unlink_allowed = 0; /* ... or unlink it */ + obj->fake = 1; /* it is fake so it might not use NAND */ + obj->rename_allowed = 0; + obj->unlink_allowed = 0; obj->deleted = 0; obj->unlinked = 0; obj->yst_mode = mode; obj->my_dev = dev; obj->hdr_chunk = 0; /* Not a valid chunk. */ } - return obj; } @@ -2049,7 +2024,6 @@ static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev) dev->n_obj = 0; dev->n_tnodes = 0; - yaffs_init_raw_tnodes_and_objs(dev); for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { @@ -2074,7 +2048,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; @@ -2110,6 +2084,7 @@ YCHAR *yaffs_clone_str(const YCHAR * str) static void yaffs_update_parent(struct yaffs_obj *obj) { struct yaffs_dev *dev; + if (!obj) return; dev = obj->my_dev; @@ -2127,7 +2102,7 @@ static void yaffs_update_parent(struct yaffs_obj *obj) } else { yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); - } + } } void yaffs_update_dirty_dirs(struct yaffs_dev *dev) @@ -2164,19 +2139,19 @@ void yaffs_update_dirty_dirs(struct yaffs_dev *dev) static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, struct yaffs_obj *parent, - const YCHAR * name, + const YCHAR *name, u32 mode, u32 uid, u32 gid, struct yaffs_obj *equiv_obj, - const YCHAR * alias_str, u32 rdev) + 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; @@ -2189,8 +2164,7 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, in = yaffs_new_obj(dev, -1, type); if (!in) { - if (str) - kfree(str); + kfree(str); return NULL; } @@ -2231,7 +2205,7 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, } if (yaffs_update_oh(in, name, 0, 0, 0, NULL) < 0) { - /* Could not create the object header, fail the creation */ + /* Could not create the object header, fail */ yaffs_del_obj(in); in = NULL; } @@ -2243,14 +2217,14 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, } struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, - const YCHAR * name, u32 mode, u32 uid, + 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, +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, @@ -2258,7 +2232,7 @@ struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, } struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, - const YCHAR * name, u32 mode, u32 uid, + const YCHAR *name, u32 mode, u32 uid, u32 gid, u32 rdev) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, @@ -2266,8 +2240,8 @@ struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, } struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, - const YCHAR * name, u32 mode, u32 uid, - u32 gid, const YCHAR * alias) + 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); @@ -2277,22 +2251,21 @@ struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, 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 */ + /* Get the real object in case we were fed a hard link obj */ equiv_obj = yaffs_get_equivalent_obj(equiv_obj); if (yaffs_create_obj (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0, - equiv_obj, NULL, 0)) { + equiv_obj, NULL, 0)) return equiv_obj; - } else { + else return NULL; - } } -/*------------------------- Block Management and Page Allocation ----------------*/ +/*---------------------- Block Management and Page Allocation -------------*/ static int yaffs_init_blocks(struct yaffs_dev *dev) { @@ -2300,7 +2273,6 @@ static int yaffs_init_blocks(struct yaffs_dev *dev) dev->block_info = NULL; dev->chunk_bits = NULL; - dev->alloc_block = -1; /* force it to get a new one */ /* If the first allocation strategy fails, thry the alternate one */ @@ -2312,7 +2284,7 @@ static int yaffs_init_blocks(struct yaffs_dev *dev) dev->block_info_alt = 1; } else { dev->block_info_alt = 0; - } + } if (dev->block_info) { /* Set up dynamic blockinfo stuff. Round up bytes. */ @@ -2325,7 +2297,7 @@ static int yaffs_init_blocks(struct yaffs_dev *dev) dev->chunk_bits_alt = 1; } else { dev->chunk_bits_alt = 0; - } + } } if (dev->block_info && dev->chunk_bits) { @@ -2342,7 +2314,7 @@ static void yaffs_deinit_blocks(struct yaffs_dev *dev) { if (dev->block_info_alt && dev->block_info) vfree(dev->block_info); - else if (dev->block_info) + else kfree(dev->block_info); dev->block_info_alt = 0; @@ -2351,7 +2323,7 @@ static void yaffs_deinit_blocks(struct yaffs_dev *dev) if (dev->chunk_bits_alt && dev->chunk_bits) vfree(dev->chunk_bits); - else if (dev->chunk_bits) + else kfree(dev->chunk_bits); dev->chunk_bits_alt = 0; dev->chunk_bits = NULL; @@ -2360,7 +2332,6 @@ static void yaffs_deinit_blocks(struct yaffs_dev *dev) void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) { struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no); - int erased_ok = 0; /* If the block is still healthy erase it and mark as clean. @@ -2376,11 +2347,12 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) bi->block_state = YAFFS_BLOCK_STATE_DIRTY; - /* If this is the block being garbage collected then stop gc'ing this block */ + /* If this is the block being garbage collected then stop gc'ing */ 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 this block is currently the best candidate for gc + * then drop as a candidate */ if (block_no == dev->gc_dirtiest) { dev->gc_dirtiest = 0; dev->gc_pages_in_use = 0; @@ -2433,28 +2405,160 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) } } +static int yaffs_gc_process_chunk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, + int old_chunk, u8 *buffer) +{ + int new_chunk; + int mark_flash = 1; + struct yaffs_ext_tags tags; + struct yaffs_obj *object; + int matching_chunk; + int ret_val = YAFFS_OK; + + yaffs_init_tags(&tags); + yaffs_rd_chunk_tags_nand(dev, old_chunk, + buffer, &tags); + object = yaffs_find_by_number(dev, tags.obj_id); + + yaffs_trace(YAFFS_TRACE_GC_DETAIL, + "Collecting chunk in block %d, %d %d %d ", + 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; + else if (object->soft_del) + /* Defeat the test */ + matching_chunk = old_chunk; + else + matching_chunk = + yaffs_find_chunk_in_file + (object, tags.chunk_id, + NULL); + + if (old_chunk != matching_chunk) + yaffs_trace(YAFFS_TRACE_ERROR, + "gc: page in gc mismatch: %d %d %d %d", + old_chunk, + matching_chunk, + tags.obj_id, + tags.chunk_id); + } + + if (!object) { + yaffs_trace(YAFFS_TRACE_ERROR, + "page %d in gc has no object: %d %d %d ", + old_chunk, + tags.obj_id, tags.chunk_id, + tags.n_bytes); + } + + if (object && + object->deleted && + 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. We have to decrement free + * chunks so this works out properly. + */ + dev->n_free_chunks--; + bi->soft_del_pages--; + + object->n_data_chunks--; + if (object->n_data_chunks <= 0) { + /* remeber to clean up obj */ + dev->gc_cleanup_list[dev->n_clean_ups] = tags.obj_id; + dev->n_clean_ups++; + } + mark_flash = 0; + } else if (object) { + /* It's either a data chunk in a live + * file or an ObjectHeader, so we're + * interested in it. + * NB Need to keep the ObjectHeaders of + * deleted files until the whole file + * has been deleted off + */ + tags.serial_number++; + dev->n_gc_copies++; + + if (tags.chunk_id == 0) { + /* It is an object Id, + * We need to nuke the + * shrinkheader flags since its + * work is done. + * Also need to clean up + * shadowing. + */ + struct yaffs_obj_hdr *oh; + oh = (struct yaffs_obj_hdr *) buffer; + + oh->is_shrink = 0; + tags.extra_is_shrink = 0; + oh->shadows_obj = 0; + oh->inband_shadowed_obj_id = 0; + 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; + } + + yaffs_verify_oh(object, oh, &tags, 1); + new_chunk = + yaffs_write_new_chunk(dev, (u8 *) oh, &tags, 1); + } else { + new_chunk = + yaffs_write_new_chunk(dev, buffer, &tags, 1); + } + + if (new_chunk < 0) { + ret_val = YAFFS_FAIL; + } else { + + /* Now fix up the Tnodes etc. */ + if (tags.chunk_id == 0) { + /* It's a header */ + object->hdr_chunk = new_chunk; + object->serial = tags.serial_number; + } else { + /* It's a data chunk */ + 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__); + return ret_val; +} static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) { int old_chunk; - int new_chunk; - int mark_flash; int ret_val = YAFFS_OK; int i; int is_checkpt_block; - int matching_chunk; int max_copies; - int chunks_before = yaffs_get_erased_chunks(dev); int chunks_after; - - struct yaffs_ext_tags tags; - struct yaffs_block_info *bi = yaffs_get_block_info(dev, block); - struct yaffs_obj *object; - is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); yaffs_trace(YAFFS_TRACE_TRACING, @@ -2474,7 +2578,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) { yaffs_trace(YAFFS_TRACE_TRACING, "Collecting block %d that has no chunks in use", - block); + block); yaffs_block_became_dirty(dev, block); } else { @@ -2485,186 +2589,20 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_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 */ - + /* Page is in use and might need to be copied */ max_copies--; - - mark_flash = 1; - - yaffs_init_tags(&tags); - - yaffs_rd_chunk_tags_nand(dev, old_chunk, - buffer, &tags); - - object = yaffs_find_by_number(dev, tags.obj_id); - - yaffs_trace(YAFFS_TRACE_GC_DETAIL, - "Collecting chunk in block %d, %d %d %d ", - 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; - else if (object->soft_del) - matching_chunk = old_chunk; /* Defeat the test */ - else - matching_chunk = - yaffs_find_chunk_in_file - (object, tags.chunk_id, - NULL); - - if (old_chunk != matching_chunk) - yaffs_trace(YAFFS_TRACE_ERROR, - "gc: page in gc mismatch: %d %d %d %d", - old_chunk, - matching_chunk, - tags.obj_id, - tags.chunk_id); - - } - - if (!object) { - yaffs_trace(YAFFS_TRACE_ERROR, - "page %d in gc has no object: %d %d %d ", - old_chunk, - tags.obj_id, tags.chunk_id, - tags.n_bytes); - } - - if (object && - object->deleted && - 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. - * We have to decrement free chunks so this works out properly. - */ - dev->n_free_chunks--; - bi->soft_del_pages--; - - object->n_data_chunks--; - - if (object->n_data_chunks <= 0) { - /* remeber to clean up the object */ - dev->gc_cleanup_list[dev-> - n_clean_ups] - = tags.obj_id; - dev->n_clean_ups++; - } - mark_flash = 0; - } else if (0) { - /* Todo object && object->deleted && object->n_data_chunks == 0 */ - /* Deleted object header with no data chunks. - * Can be discarded and the file deleted. - */ - object->hdr_chunk = 0; - yaffs_free_tnode(object->my_dev, - object-> - variant.file_variant. - top); - object->variant.file_variant.top = NULL; - yaffs_generic_obj_del(object); - - } else if (object) { - /* It's either a data chunk in a live file or - * an ObjectHeader, so we're interested in it. - * NB Need to keep the ObjectHeaders of deleted files - * until the whole file has been deleted off - */ - tags.serial_number++; - - dev->n_gc_copies++; - - if (tags.chunk_id == 0) { - /* It is an object Id, - * We need to nuke the shrinkheader flags first - * Also need to clean up shadowing. - * We no longer want the shrink_header flag since its work is done - * and if it is left in place it will mess up scanning. - */ - - struct yaffs_obj_hdr *oh; - oh = (struct yaffs_obj_hdr *) - buffer; - - oh->is_shrink = 0; - tags.extra_is_shrink = 0; - - oh->shadows_obj = 0; - oh->inband_shadowed_obj_id = 0; - 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; - } - - yaffs_verify_oh(object, oh, - &tags, 1); - new_chunk = - yaffs_write_new_chunk(dev, - (u8 *) - oh, - &tags, - 1); - } else { - new_chunk = - yaffs_write_new_chunk(dev, - buffer, - &tags, - 1); - } - - if (new_chunk < 0) { - ret_val = YAFFS_FAIL; - } else { - - /* Ok, now fix up the Tnodes etc. */ - - if (tags.chunk_id == 0) { - /* It's a header */ - 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); - } - } - } - - if (ret_val == YAFFS_OK) - yaffs_chunk_del(dev, old_chunk, - mark_flash, __LINE__); - + ret_val = yaffs_gc_process_chunk(dev, bi, + old_chunk, buffer); } } - yaffs_release_temp_buffer(dev, buffer, __LINE__); - } yaffs_verify_collected_blk(dev, bi, block); @@ -2680,12 +2618,11 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) /* Do any required cleanups */ for (i = 0; i < dev->n_clean_ups; i++) { /* Time to delete the file too */ - object = + struct yaffs_obj *object = 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; yaffs_trace(YAFFS_TRACE_GC, "yaffs: About to finally delete object %d", @@ -2695,7 +2632,6 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) } } - chunks_after = yaffs_get_erased_chunks(dev); if (chunks_before >= chunks_after) yaffs_trace(YAFFS_TRACE_GC, @@ -2712,7 +2648,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) } /* - * FindBlockForgarbageCollection is used to select the dirtiest block (or close enough) + * find_gc_block() selects the dirtiest block (or close enough) * for garbage collection. */ @@ -2747,8 +2683,8 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, /* * If there is a prioritised block and none was selected then - * this happened because there is at least one old dirty block gumming - * up the works. Let's gc the oldest dirty block. + * this happened because there is at least one old dirty block + * gumming up the works. Let's gc the oldest dirty block. */ if (prioritised_exist && @@ -2759,9 +2695,9 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, dev->has_pending_prioritised_gc = 0; } - /* If we're doing aggressive GC then we are happy to take a less-dirty block, and - * search harder. - * else (we're doing a leasurely gc), then we only bother to do this if the + /* If we're doing aggressive GC then we are happy to take a less-dirty + * block, and search harder. + * else (leasurely gc), then we only bother to do this if the * block has only a few pages in use. */ @@ -2797,7 +2733,8 @@ 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++) { + 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) @@ -2810,9 +2747,9 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, 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)) { + (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; } @@ -2823,7 +2760,7 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, } /* - * If nothing has been selected for a while, try selecting the oldest dirty + * If nothing has been selected for a while, try the oldest dirty * because that's gumming up the works. */ @@ -2839,7 +2776,7 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, bi->pages_in_use - bi->soft_del_pages; } else { dev->gc_not_done = 0; - } + } } if (selected) { @@ -2874,7 +2811,7 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, * If we're very low on erased blocks then we do aggressive garbage collection * otherwise we do "leasurely" garbage collection. * Aggressive gc looks further (whole array) and will accept less dirty blocks. - * Passive gc only inspects smaller areas and will only accept more dirty blocks. + * Passive gc only inspects smaller areas and only accepts more dirty blocks. * * The idea is to help clear out space in a more spread-out manner. * Dunno if it really does anything useful. @@ -2897,7 +2834,7 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background) } /* This loop should pass the first time. - * We'll only see looping here if the collection does not increase space. + * Only loops here if the collection does not increase space. */ do { @@ -2931,7 +2868,8 @@ 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); @@ -3036,9 +2974,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) { yaffs_init_tags(&tags); - tags.is_deleted = 1; - yaffs_wr_chunk_tags_nand(dev, chunk_id, NULL, &tags); yaffs_handle_chunk_update(dev, chunk_id, &tags); } else { @@ -3053,9 +2989,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { dev->n_free_chunks++; - yaffs_clear_chunk_bit(dev, block, page); - bi->pages_in_use--; if (bi->pages_in_use == 0 && @@ -3064,13 +2998,11 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, bi->block_state != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { yaffs_block_became_dirty(dev, block); } - } - } 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. @@ -3079,10 +3011,8 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, int prev_chunk_id; struct yaffs_ext_tags prev_tags; - int new_chunk_id; struct yaffs_ext_tags new_tags; - struct yaffs_dev *dev = in->my_dev; yaffs_check_gc(dev, 0); @@ -3130,11 +3060,10 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, - const YCHAR * name, const void *value, int size, + const YCHAR *name, const void *value, int size, int flags) { struct yaffs_xattr_mod xmod; - int result; xmod.set = set; @@ -3159,7 +3088,6 @@ static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, 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; if (xmod->set) @@ -3171,13 +3099,12 @@ static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, obj->has_xattr = nval_hasvalues(x_buffer, x_size); obj->xattr_known = 1; - xmod->result = retval; return retval; } -static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name, +static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, void *value, int size) { char *buffer = NULL; @@ -3186,9 +3113,7 @@ static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name, struct yaffs_dev *dev = obj->my_dev; int x_offs = sizeof(struct yaffs_obj_hdr); int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char *x_buffer; - int retval = 0; if (obj->hdr_chunk < 1) @@ -3283,15 +3208,15 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) in->variant.symlink_variant.alias = yaffs_clone_str(oh->alias); if (!in->variant.symlink_variant.alias) - alloc_failed = 1; /* Not returned to caller */ + alloc_failed = 1; /* Not returned */ } yaffs_release_temp_buffer(dev, chunk_data, __LINE__); } } -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) { @@ -3308,17 +3233,17 @@ static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, } } else { strncpy(name, oh_name + 1, buff_size - 1); - } + } } else { #else - { + { #endif 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 @@ -3338,7 +3263,7 @@ static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, } if (is_ascii) { - /* It is an ASCII name, so do a unicode to ascii conversion */ + /* It is an ASCII name, so convert unicode to ascii */ char *ascii_oh_name = (char *)oh_name; int n = YAFFS_MAX_NAME_LENGTH - 1; while (n > 0 && *name) { @@ -3348,43 +3273,37 @@ static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, n--; } } else { - /* It is a unicode name, so save starting at the second YCHAR */ + /* Unicode name, so save starting at the second YCHAR */ *oh_name = 0; strncpy(oh_name + 1, name, - YAFFS_MAX_NAME_LENGTH - 2); + YAFFS_MAX_NAME_LENGTH - 2); } } else { #else - { + { #endif strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1); - } - + } } /* 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 yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, int is_shrink, int shadows, struct yaffs_xattr_mod *xmod) { struct yaffs_block_info *bi; - struct yaffs_dev *dev = in->my_dev; - int prev_chunk_id; int ret_val = 0; int result = 0; - int new_chunk_id; struct yaffs_ext_tags new_tags; struct yaffs_ext_tags old_tags; const YCHAR *alias = NULL; - u8 *buffer = NULL; YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1]; - struct yaffs_obj_hdr *oh = NULL; strcpy(old_name, _Y("silly old name")); @@ -3410,7 +3329,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, memset(buffer, 0xFF, sizeof(struct yaffs_obj_hdr)); } else { memset(buffer, 0xFF, dev->data_bytes_per_chunk); - } + } oh->type = in->variant_type; oh->yst_mode = in->yst_mode; @@ -3430,7 +3349,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, memcpy(oh->name, old_name, sizeof(oh->name)); } else { memset(oh->name, 0, sizeof(oh->name)); - } + } oh->is_shrink = is_shrink; @@ -3475,7 +3394,6 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, new_tags.serial_number = in->serial; /* Add extra info for file header */ - new_tags.extra_available = 1; new_tags.extra_parent_id = oh->parent_obj_id; new_tags.extra_length = oh->file_size; @@ -3483,7 +3401,6 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, new_tags.extra_equiv_id = oh->equiv_id; new_tags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0; new_tags.extra_obj_type = in->variant_type; - yaffs_verify_oh(in, oh, &new_tags, 1); /* Create new chunk in NAND */ @@ -3503,7 +3420,8 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, if (!yaffs_obj_cache_dirty(in)) in->dirty = 0; - /* If this was a shrink, then mark the block that the chunk lives on */ + /* 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 / @@ -3511,11 +3429,8 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, chunks_per_block); bi->has_shrink_hdr = 1; } - } - ret_val = new_chunk_id; - } if (buffer) @@ -3536,21 +3451,17 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) { - int chunk; u32 start; int n_copy; int n = n_bytes; int n_done = 0; struct yaffs_cache *cache; - struct yaffs_dev *dev; dev = in->my_dev; while (n > 0) { - /* chunk = offset / dev->data_bytes_per_chunk + 1; */ - /* start = offset % dev->data_bytes_per_chunk; */ yaffs_addr_to_chunk(dev, offset, &chunk, &start); chunk++; @@ -3564,15 +3475,16 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) cache = yaffs_find_chunk_cache(in, chunk); - /* If the chunk is already in the cache or it is less than a whole chunk - * or we're using inband tags then use the cache (if there is caching) - * else bypass the cache. + /* If the chunk is already in the cache or it is less than + * a whole chunk 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 (dev->param.n_caches > 0) { - /* If we can't find the data in the cache, then load it up. */ + /* If we can't find the data in the cache, + * then load it up. */ if (!cache) { cache = @@ -3605,25 +3517,19 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) yaffs_release_temp_buffer(dev, local_buffer, __LINE__); } - } else { - - /* A full chunk. Read directly into the supplied buffer. */ + /* A full chunk. Read directly into the buffer. */ yaffs_rd_data_obj(in, chunk, buffer); - } - n -= n_copy; offset += n_copy; buffer += n_copy; n_done += n_copy; - } - return n_done; } -int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, int n_bytes, int write_trhrough) { @@ -3637,7 +3543,6 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, int chunk_written = 0; u32 n_bytes_read; u32 chunk_start; - struct yaffs_dev *dev; dev = in->my_dev; @@ -3660,9 +3565,10 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, if ((start + n) < dev->data_bytes_per_chunk) { n_copy = n; - /* Now folks, to calculate how many bytes to write back.... - * If we're overwriting and not writing to then end of file then - * we need to write back as much as was there before. + /* Now calculate how many bytes to write back.... + * If we're overwriting and not writing to then end of + * file then we need to write back as much as was there + * before. */ chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk); @@ -3681,8 +3587,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 { @@ -3690,14 +3596,17 @@ 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) { - /* 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. + 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. */ if (dev->param.n_caches > 0) { struct yaffs_cache *cache; - /* If we can't find the data in the cache, then load the cache */ + + /* If we can't find the data in the cache, then + * load the cache */ cache = yaffs_find_chunk_cache(in, chunk); if (!cache @@ -3713,8 +3622,9 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, !cache->dirty && !yaffs_check_alloc_available(dev, 1)) { - /* Drop the cache if it was a read cache item and - * no space check has been made for it. + /* Drop the cache if it was a read cache + * item and no space check has been made + * for it. */ cache = NULL; } @@ -3738,20 +3648,19 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, cache->n_bytes, 1); cache->dirty = 0; } - } else { - chunk_written = -1; /* fail the write */ + chunk_written = -1; /* fail write */ } } else { - /* An incomplete start or end chunk (or maybe both start and end chunk) - * Read into the local buffer then copy, then copy over and write back. + /* An incomplete start or end chunk (or maybe + * both start and end chunk). Read into the + * local buffer then copy over and write back. */ u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); yaffs_rd_data_obj(in, chunk, local_buffer); - memcpy(&local_buffer[start], buffer, n_copy); chunk_written = @@ -3761,17 +3670,16 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, yaffs_release_temp_buffer(dev, local_buffer, __LINE__); - } - } else { - /* A full chunk. Write directly from the supplied buffer. */ + /* A full chunk. Write directly from the buffer. */ chunk_written = yaffs_wr_data_obj(in, chunk, buffer, dev->data_bytes_per_chunk, 0); - /* Since we've overwritten the cached data, we better invalidate it. */ + /* Since we've overwritten the cached data, + * we better invalidate it. */ yaffs_invalidate_chunk_cache(in, chunk); } @@ -3781,7 +3689,6 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, buffer += n_copy; n_done += n_copy; } - } /* Update file object */ @@ -3790,11 +3697,10 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, in->variant.file_variant.file_size = (start_write + n_done); in->dirty = 1; - return n_done; } -int yaffs_wr_file(struct yaffs_obj *in, const u8 * buffer, loff_t offset, +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); @@ -3808,13 +3714,12 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) struct yaffs_dev *dev = in->my_dev; int old_size = in->variant.file_variant.file_size; - + int i; + int chunk_id; int last_del = 1 + (old_size - 1) / dev->data_bytes_per_chunk; - int start_del = 1 + (new_size + dev->data_bytes_per_chunk - 1) / dev->data_bytes_per_chunk; - int i; - int chunk_id; + /* Delete backwards so that we don't end up with holes if * power is lost part-way through the operation. @@ -3829,10 +3734,10 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) if (chunk_id > 0) { if (chunk_id < (dev->internal_start_block * - dev->param.chunks_per_block) - || chunk_id >= - ((dev->internal_end_block + - 1) * dev->param.chunks_per_block)) { + dev->param.chunks_per_block) || + chunk_id >= + ((dev->internal_end_block + 1) * + dev->param.chunks_per_block)) { yaffs_trace(YAFFS_TRACE_ALWAYS, "Found daft chunk_id %d for %d", chunk_id, i); @@ -3842,7 +3747,6 @@ 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) @@ -3916,6 +3820,7 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) 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 */ @@ -3930,9 +3835,7 @@ int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync) } else { ret_val = YAFFS_OK; } - return ret_val; - } @@ -3942,7 +3845,6 @@ int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync) */ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) { - int ret_val; int del_now = 0; struct yaffs_dev *dev = in->my_dev; @@ -3967,14 +3869,13 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) yaffs_change_obj_name(in, in->my_dev->unlinked_dir, _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) @@ -4009,8 +3910,8 @@ int yaffs_del_file(struct yaffs_obj *in) int yaffs_is_non_empty_dir(struct yaffs_obj *obj) { return (obj && - obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && - !(list_empty(&obj->variant.dir_variant.children)); + obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && + !(list_empty(&obj->variant.dir_variant.children)); } static int yaffs_del_dir(struct yaffs_obj *obj) @@ -4024,8 +3925,7 @@ static int yaffs_del_dir(struct yaffs_obj *obj) static int yaffs_del_symlink(struct yaffs_obj *in) { - if (in->variant.symlink_variant.alias) - kfree(in->variant.symlink_variant.alias); + kfree(in->variant.symlink_variant.alias); in->variant.symlink_variant.alias = NULL; return yaffs_generic_obj_del(in); @@ -4033,7 +3933,7 @@ static int yaffs_del_symlink(struct yaffs_obj *in) static int yaffs_del_link(struct yaffs_obj *in) { - /* remove this hardlink from the list assocaited with the equivalent + /* remove this hardlink from the list associated with the equivalent * object */ list_del_init(&in->hard_links); @@ -4043,6 +3943,7 @@ static int yaffs_del_link(struct yaffs_obj *in) int yaffs_del_obj(struct yaffs_obj *obj) { int ret_val = -1; + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: ret_val = yaffs_del_file(obj); @@ -4069,17 +3970,15 @@ int yaffs_del_obj(struct yaffs_obj *obj) ret_val = 0; break; /* should not happen. */ } - return ret_val; } static int yaffs_unlink_worker(struct yaffs_obj *obj) { - int del_now = 0; - if(!obj) - return YAFFS_FAIL; + if (!obj) + return YAFFS_FAIL; if (!obj->my_inode) del_now = 1; @@ -4098,7 +3997,7 @@ static int yaffs_unlink_worker(struct yaffs_obj *obj) * Instead, we do the following: * - Select a hardlink. * - Unhook it from the hard links - * - Move it from its parent directory (so that the rename can work) + * - Move it from its parent directory so that the rename works. * - Rename the object to the hardlink's name. * - Delete the hardlink */ @@ -4149,21 +4048,19 @@ static int yaffs_unlink_worker(struct yaffs_obj *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) { - if (obj && obj->unlink_allowed) return yaffs_unlink_worker(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; @@ -4174,8 +4071,8 @@ int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name) /* Note: * If old_name is NULL then we take old_dir as the object to be renamed. */ -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; @@ -4195,8 +4092,8 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, * 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 && - old_name && new_name && + if (old_dir == new_dir && + old_name && new_name && strcmp(old_name, new_name) == 0) force = 1; #endif @@ -4206,26 +4103,24 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, /* ENAMETOOLONG */ return YAFFS_FAIL; - if(old_name) + if (old_name) obj = yaffs_find_by_name(old_dir, old_name); else{ obj = old_dir; old_dir = obj->parent; } - if (obj && obj->rename_allowed) { - - /* Now do the handling for an existing target, if there is one */ - + /* Now handle an existing target, if there is one */ existing_target = yaffs_find_by_name(new_dir, new_name); - if (yaffs_is_non_empty_dir(existing_target)){ + if (yaffs_is_non_empty_dir(existing_target)) { return YAFFS_FAIL; /* ENOTEMPTY */ } else if (existing_target && existing_target != obj) { /* Nuke the target first, using shadowing, * but only if it isn't the same object. * - * Note we must disable gc otherwise it can mess up the shadowing. + * Note we must disable gc here otherwise it can mess + * up the shadowing. * */ dev->gc_disable = 1; @@ -4268,7 +4163,8 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, return; } - /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc. + /* Let's create it (if it does not exist) assuming it is a file so that + * it can do shrinking etc. * We put it in unlinked dir to be cleaned up after the scanning */ obj = @@ -4278,8 +4174,7 @@ void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, obj->is_shadowed = 1; yaffs_add_obj_to_dir(dev->unlinked_dir, obj); obj->variant.file_variant.shrink_size = 0; - obj->valid = 1; /* So that we don't read any other info for this file */ - + obj->valid = 1; /* So that we don't read any other info. */ } void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) @@ -4305,7 +4200,6 @@ void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) */ hl->variant.hardlink_variant.equiv_obj = NULL; INIT_LIST_HEAD(&hl->hard_links); - } } } @@ -4337,7 +4231,6 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) yaffs_del_obj(l); } } - } /* @@ -4348,13 +4241,14 @@ static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) * - Directly or indirectly under root. * * Note: - * This code assumes that we don't ever change the current relationships between - * directories: + * This code assumes that we don't ever change the current relationships + * between directories: * root_dir->parent == unlinked_dir->parent == del_dir->parent == NULL * lost-n-found->parent == root_dir * - * This fixes the problem where directories might have inadvertently been deleted - * leaving the object "hanging" without being rooted in the directory tree. + * This fixes the problem where directories might have inadvertently been + * deleted leaving the object "hanging" without being rooted in the + * directory tree. */ static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj) @@ -4399,7 +4293,8 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) hanging = 0; } else { /* - * Need to follow the parent chain to see if it is hanging. + * Need to follow the parent chain to + * see if it is hanging. */ hanging = 0; depth_limit = 100; @@ -4407,8 +4302,8 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) while (parent != dev->root_dir && parent->parent && parent->parent->variant_type == - YAFFS_OBJECT_TYPE_DIRECTORY - && depth_limit > 0) { + YAFFS_OBJECT_TYPE_DIRECTORY && + depth_limit > 0) { parent = parent->parent; depth_limit--; } @@ -4444,18 +4339,12 @@ static void yaffs_del_dir_contents(struct yaffs_obj *dir) obj = list_entry(lh, struct yaffs_obj, siblings); if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) yaffs_del_dir_contents(obj); - yaffs_trace(YAFFS_TRACE_SCAN, "Deleting lost_found object %d", obj->obj_id); - - /* Need to use UnlinkObject since Delete would not handle - * hardlinked objects correctly. - */ yaffs_unlink_obj(obj); } } - } static void yaffs_empty_l_n_f(struct yaffs_dev *dev) @@ -4465,13 +4354,11 @@ static void yaffs_empty_l_n_f(struct yaffs_dev *dev) struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, - const YCHAR * name) + const YCHAR *name) { int sum; - struct list_head *i; YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1]; - struct yaffs_obj *l; if (!name) @@ -4516,7 +4403,6 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, return l; } } - return NULL; } @@ -4527,7 +4413,6 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj) { if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { - /* We want the object id of the equivalent object, not this one */ obj = obj->variant.hardlink_variant.equiv_obj; yaffs_check_obj_details_loaded(obj); } @@ -4547,13 +4432,13 @@ struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj) * system to share files. * * These automatic unicode are stored slightly differently... - * - If the name can fit in the ASCII character space then they are saved as + * - If the name can fit in the ASCII character space then they are saved as * ascii names as per above. * - If the name needs Unicode then the name is saved in Unicode * starting at oh->name[1]. */ -static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name, +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. */ @@ -4575,19 +4460,15 @@ static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name, } } -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) { + if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); - } #ifndef CONFIG_YAFFS_NO_SHORT_NAMES - else if (obj->short_name[0]) { + else if (obj->short_name[0]) strcpy(name, obj->short_name); - } #endif else if (obj->hdr_chunk > 0) { int result; @@ -4697,7 +4578,6 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj) static int yaffs_check_dev_fns(const struct yaffs_dev *dev) { - /* Common functions, gotta have */ if (!dev->param.erase_fn || !dev->param.initialise_flash_fn) return 0; @@ -4727,17 +4607,13 @@ static int yaffs_check_dev_fns(const struct yaffs_dev *dev) static int yaffs_create_initial_dir(struct yaffs_dev *dev) { - /* Initialise the unlinked, deleted, root and lost and found directories */ - + /* Initialise the unlinked, deleted, root and lost+found directories */ dev->lost_n_found = dev->root_dir = NULL; dev->unlinked_dir = dev->del_dir = NULL; - dev->unlinked_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); - dev->del_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); - dev->root_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, YAFFS_ROOT_MODE | S_IFDIR); @@ -4750,7 +4626,6 @@ static int yaffs_create_initial_dir(struct yaffs_dev *dev) yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); return YAFFS_OK; } - return YAFFS_FAIL; } @@ -4760,7 +4635,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) unsigned x; int bits; - yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise()" ); + yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise()"); /* Check stuff that must be set */ @@ -4795,9 +4670,9 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) (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 <= 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 */ @@ -4836,7 +4711,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) return YAFFS_FAIL; } - /* Finished with most checks. One or two more checks happen later on too. */ + /* Finished with most checks. Further checks happen later on too. */ dev->is_mounted = 1; @@ -4873,7 +4748,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) dev->tnode_width = bits; } else { dev->tnode_width = 16; - } + } dev->tnode_mask = (1 << dev->tnode_width) - 1; @@ -4904,7 +4779,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) return YAFFS_FAIL; } - /* OK, we've finished verifying the device, lets continue with initialisation */ + /* Finished verifying the device, continue with initialisation */ /* More device initialisation */ dev->all_gcs = 0; @@ -4924,7 +4799,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) 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->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; @@ -4991,13 +4867,14 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) if (dev->param.is_yaffs2) { if (yaffs2_checkpt_restore(dev)) { yaffs_check_obj_details_loaded(dev->root_dir); - yaffs_trace(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT, + yaffs_trace(YAFFS_TRACE_CHECKPOINT | + YAFFS_TRACE_MOUNT, "yaffs: restored from checkpoint" ); } else { - /* Clean up the mess caused by an aborted checkpoint load - * and scan backwards. + /* Clean up the mess caused by an aborted + * checkpoint load then scan backwards. */ yaffs_deinit_blocks(dev); @@ -5025,7 +4902,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) } } else if (!yaffs1_scan(dev)) { init_failed = 1; - } + } yaffs_strip_deleted_objs(dev); yaffs_fix_hanging_objs(dev); @@ -5061,7 +4938,6 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise() done."); return YAFFS_OK; - } void yaffs_deinitialise(struct yaffs_dev *dev) @@ -5074,8 +4950,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev) if (dev->param.n_caches > 0 && dev->cache) { for (i = 0; i < dev->param.n_caches; i++) { - if (dev->cache[i].data) - kfree(dev->cache[i].data); + kfree(dev->cache[i].data); dev->cache[i].data = NULL; } @@ -5099,7 +4974,6 @@ int yaffs_count_free_chunks(struct yaffs_dev *dev) { int n_free = 0; int b; - struct yaffs_block_info *blk; blk = dev->block_info; @@ -5118,14 +4992,12 @@ int yaffs_count_free_chunks(struct yaffs_dev *dev) } blk++; } - return n_free; } int yaffs_get_n_free_chunks(struct yaffs_dev *dev) { /* This is what we report to the outside world */ - int n_free; int n_dirty_caches; int blocks_for_checkpt; @@ -5134,7 +5006,7 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev) n_free = dev->n_free_chunks; n_free += dev->n_deleted_files; - /* Now count the number of dirty chunks in the cache and subtract those */ + /* Now count and subtract the number of dirty chunks in the cache. */ for (n_dirty_caches = 0, i = 0; i < dev->param.n_caches; i++) { if (dev->cache[i].dirty) @@ -5146,7 +5018,7 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev) 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... */ + /* Now figure checkpoint space and report that... */ blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev); n_free -= (blocks_for_checkpt * dev->param.chunks_per_block); @@ -5155,5 +5027,4 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev) n_free = 0; return n_free; - }