X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_guts.c;h=b83fa6388a22f7861cc00d89001678d927568584;hp=72555d53ed08a6ec7864ddb5c598768fb140eda8;hb=9d9b662225f9b3684bb4ebd3646216f3ab190ed9;hpb=21b2dedaa32ab309f6d1daec966528b7586bd207 diff --git a/yaffs_guts.c b/yaffs_guts.c index 72555d5..b83fa63 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -1,8 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2011 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering + * Copyright (C) 2002-2018 Aleph One Ltd. * * Created by Charles Manning * @@ -15,6 +14,8 @@ #include "yaffs_trace.h" #include "yaffs_guts.h" + +#include "yaffs_cache.h" #include "yaffs_endian.h" #include "yaffs_getblockinfo.h" #include "yaffs_tagscompat.h" @@ -39,9 +40,6 @@ /* Forward declarations */ -static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, - const u8 *buffer, int n_bytes, int use_reserve); - static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size); @@ -165,6 +163,8 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev) } +/* Frees all the temp_buffer objects in the yaffs_dev instance +*/ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer) { int i; @@ -303,7 +303,8 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags); - if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR) + if (result == YAFFS_FAIL || + tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR) retval = YAFFS_FAIL; if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || @@ -330,7 +331,8 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev, int result; result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags); - if (memcmp(buffer, data, dev->data_bytes_per_chunk) || + if (result == YAFFS_FAIL || + 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) @@ -358,7 +360,7 @@ int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks) static int yaffs_find_alloc_block(struct yaffs_dev *dev) { - int i; + u32 i; struct yaffs_block_info *bi; if (dev->n_erased_blocks < 1) { @@ -375,8 +377,8 @@ static int yaffs_find_alloc_block(struct yaffs_dev *dev) for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { dev->alloc_block_finder++; - if (dev->alloc_block_finder < dev->internal_start_block - || dev->alloc_block_finder > dev->internal_end_block) { + if (dev->alloc_block_finder < (int)dev->internal_start_block + || dev->alloc_block_finder > (int)dev->internal_end_block) { dev->alloc_block_finder = dev->internal_start_block; } @@ -419,7 +421,7 @@ static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, return -1; } - if (dev->n_erased_blocks < dev->param.n_reserved_blocks + if (dev->n_erased_blocks < (int)dev->param.n_reserved_blocks && dev->alloc_page == 0) yaffs_trace(YAFFS_TRACE_ALLOCATE, "Allocating reserve"); @@ -488,7 +490,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev, const u8 *data, struct yaffs_ext_tags *tags, int use_reserver) { - int attempts = 0; + u32 attempts = 0; int write_ok = 0; int chunk; @@ -569,7 +571,7 @@ 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; @@ -1019,8 +1021,8 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, int chunk_obj) { - return (tags->chunk_id == chunk_obj && - tags->obj_id == obj_id && + return (tags->chunk_id == (u32)chunk_obj && + tags->obj_id == (u32)obj_id && !tags->is_deleted) ? 1 : 0; } @@ -1421,237 +1423,6 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj, return YAFFS_FAIL; } -/*------------------------ 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 - * provides write buffering. - * - * There are a small number (~10) of cache chunks per device so that we don't - * need a very intelligent search. - */ - -static int yaffs_obj_cache_dirty(struct yaffs_obj *obj) -{ - struct yaffs_dev *dev = obj->my_dev; - int i; - struct yaffs_cache *cache; - int n_caches = obj->my_dev->param.n_caches; - - for (i = 0; i < n_caches; i++) { - cache = &dev->cache[i]; - if (cache->object == obj && cache->dirty) - return 1; - } - - return 0; -} - -static void yaffs_flush_single_cache(struct yaffs_cache *cache, int discard) -{ - - if (!cache || cache->locked) - return; - - /* Write it out and free it up if need be.*/ - if (cache->dirty) { - yaffs_wr_data_obj(cache->object, - cache->chunk_id, - cache->data, - cache->n_bytes, - 1); - - cache->dirty = 0; - } - - if (discard) - cache->object = NULL; -} - -static void yaffs_flush_file_cache(struct yaffs_obj *obj, int discard) -{ - struct yaffs_dev *dev = obj->my_dev; - int i; - struct yaffs_cache *cache; - int n_caches = obj->my_dev->param.n_caches; - - if (n_caches < 1) - return; - - - /* Find the chunks for this object and flush them. */ - for (i = 0; i < n_caches; i++) { - cache = &dev->cache[i]; - if (cache->object == obj) - yaffs_flush_single_cache(cache, discard); - } - -} - - -void yaffs_flush_whole_cache(struct yaffs_dev *dev, int discard) -{ - struct yaffs_obj *obj; - int n_caches = dev->param.n_caches; - int i; - - /* Find a dirty object in the cache and flush it... - * until there are no further dirty objects. - */ - do { - obj = NULL; - 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, discard); - } while (obj); - -} - -/* Grab us an unused cache chunk for use. - * First look for an empty one. - * Then look for the least recently used non-dirty one. - * Then look for the least recently used dirty one...., flush and look again. - */ -static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev) -{ - int i; - - if (dev->param.n_caches > 0) { - for (i = 0; i < dev->param.n_caches; i++) { - if (!dev->cache[i].object) - return &dev->cache[i]; - } - } - - return NULL; -} - -static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) -{ - struct yaffs_cache *cache; - int usage; - int i; - - if (dev->param.n_caches < 1) - return NULL; - - /* First look for an unused cache */ - - cache = yaffs_grab_chunk_worker(dev); - - if (cache) - return cache; - - /* - * Thery were all in use. - * Find the LRU cache and flush it if it is dirty. - */ - - usage = -1; - cache = NULL; - - 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)) { - usage = dev->cache[i].last_use; - cache = &dev->cache[i]; - } - } - -#if 1 - yaffs_flush_single_cache(cache, 1); -#else - yaffs_flush_file_cache(cache->object, 1); - cache = yaffs_grab_chunk_worker(dev); -#endif - - return cache; -} - -/* Find a cached chunk */ -static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, - int chunk_id) -{ - struct yaffs_dev *dev = obj->my_dev; - int i; - - if (dev->param.n_caches < 1) - return NULL; - - for (i = 0; i < dev->param.n_caches; i++) { - if (dev->cache[i].object == obj && - dev->cache[i].chunk_id == chunk_id) { - dev->cache_hits++; - - return &dev->cache[i]; - } - } - return NULL; -} - -/* 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 i; - - if (dev->param.n_caches < 1) - return; - - if (dev->cache_last_use < 0 || - dev->cache_last_use > 100000000) { - /* Reset the cache usages */ - for (i = 1; i < dev->param.n_caches; i++) - dev->cache[i].last_use = 0; - - dev->cache_last_use = 0; - } - dev->cache_last_use++; - cache->last_use = dev->cache_last_use; - - if (is_write) - cache->dirty = 1; -} - -/* Invalidate a single cache page. - * Do this when a whole page gets written, - * ie the short cache for this page is no longer valid. - */ -static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id) -{ - struct yaffs_cache *cache; - - if (object->my_dev->param.n_caches > 0) { - cache = yaffs_find_chunk_cache(object, chunk_id); - - if (cache) - cache->object = NULL; - } -} - -/* Invalidate all the cache pages associated with this object - * Do this whenever ther file is deleted or resized. - */ -static void yaffs_invalidate_whole_cache(struct yaffs_obj *in) -{ - int i; - struct yaffs_dev *dev = in->my_dev; - - if (dev->param.n_caches > 0) { - /* Invalidate it. */ - for (i = 0; i < dev->param.n_caches; i++) { - if (dev->cache[i].object == in) - dev->cache[i].object = NULL; - } - } -} static void yaffs_unhash_obj(struct yaffs_obj *obj) { @@ -1707,7 +1478,7 @@ void yaffs_handle_defered_free(struct yaffs_obj *obj) static int yaffs_generic_obj_del(struct yaffs_obj *in) { /* Iinvalidate the file's data in the cache, without flushing. */ - yaffs_invalidate_whole_cache(in); + yaffs_invalidate_file_cache(in); if (in->my_dev->param.is_yaffs2 && in->parent != in->my_dev->del_dir) { /* Move to unlinked directory so we have a deletion record */ @@ -2364,7 +2135,7 @@ 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; - int i; + u32 i; /* If the block is still healthy erase it and mark as clean. * If the block has had a data failure, then retire it. @@ -2380,12 +2151,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 */ - if (block_no == dev->gc_block) + if (block_no == (int)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 == (int)dev->gc_dirtiest) { dev->gc_dirtiest = 0; dev->gc_pages_in_use = 0; } @@ -2589,7 +2360,7 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) { int old_chunk; int ret_val = YAFFS_OK; - int i; + u32 i; int is_checkpt_block; int max_copies; int chunks_before = yaffs_get_erased_chunks(dev); @@ -2694,13 +2465,15 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, int aggressive, int background) { - int i; - int iterations; - unsigned selected = 0; + u32 i; + u32 iterations; + u32 selected = 0; int prioritised = 0; int prioritised_exist = 0; struct yaffs_block_info *bi; - int threshold; + u32 threshold = dev->param.chunks_per_block; + + (void) prioritised; /* First let's see if we need to grab a prioritised block */ if (dev->has_pending_prioritised_gc && !aggressive) { @@ -2741,14 +2514,14 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, */ if (!selected) { - int pages_used; + u32 pages_used; 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; + u32 max_threshold; if (background) max_threshold = dev->param.chunks_per_block / 2; @@ -2934,14 +2707,14 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background) gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive); } - if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && + if (dev->n_erased_blocks < (int)dev->param.n_reserved_blocks && dev->gc_block > 0) { yaffs_trace(YAFFS_TRACE_GC, "yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d", dev->n_erased_blocks, max_tries, dev->gc_block); } - } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && + } while ((dev->n_erased_blocks < (int)dev->param.n_reserved_blocks) && (dev->gc_block > 0) && (max_tries < 2)); return aggressive ? gc_ok : YAFFS_OK; @@ -2956,6 +2729,7 @@ int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency) { int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + (void) urgency; yaffs_trace(YAFFS_TRACE_BACKGROUND, "Background gc %u", urgency); yaffs_check_gc(dev, 1); @@ -2990,6 +2764,7 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, struct yaffs_ext_tags tags; struct yaffs_block_info *bi; + (void) lyn; if (chunk_id <= 0) return; @@ -3040,8 +2815,8 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, } } -static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, - const u8 *buffer, int n_bytes, int use_reserve) +int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, + 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. @@ -3075,7 +2850,7 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, (prev_chunk_id > 0) ? prev_tags.serial_number + 1 : 1; new_tags.n_bytes = n_bytes; - if (n_bytes < 1 || n_bytes > dev->data_bytes_per_chunk) { + if (n_bytes < 1 || n_bytes > (int)dev->data_bytes_per_chunk) { yaffs_trace(YAFFS_TRACE_ERROR, "Writing %d bytes to chunk!!!!!!!!!", n_bytes); @@ -3235,30 +3010,32 @@ static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) struct yaffs_dev *dev; struct yaffs_ext_tags tags; int result; - int alloc_failed = 0; if (!in || !in->lazy_loaded || in->hdr_chunk < 1) return; dev = in->my_dev; - in->lazy_loaded = 0; buf = yaffs_get_temp_buffer(dev); result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, buf, &tags); + + if (result == YAFFS_FAIL) { + yaffs_release_temp_buffer(dev, buf); + return; + } + oh = (struct yaffs_obj_hdr *)buf; yaffs_do_endian_oh(dev, oh); + in->lazy_loaded = 0; in->yst_mode = oh->yst_mode; yaffs_load_attribs(in, oh); yaffs_set_obj_name_from_oh(in, oh); - if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) in->variant.symlink_variant.alias = yaffs_clone_str(oh->alias); - if (!in->variant.symlink_variant.alias) - alloc_failed = 1; /* Not returned */ - } yaffs_release_temp_buffer(dev, buf); } @@ -3311,15 +3088,16 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, /* Access the old obj header just to read the name. */ result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id, buffer, &old_tags); - - yaffs_verify_oh(in, oh, &old_tags, 0); - memcpy(old_name, oh->name, sizeof(oh->name)); - - /* - * NB We only wipe the object header area because the rest of - * the buffer might contain xattribs. - */ - memset(oh, 0xff, sizeof(*oh)); + if (result == YAFFS_OK) { + yaffs_verify_oh(in, oh, &old_tags, 0); + memcpy(old_name, oh->name, sizeof(oh->name)); + + /* + * NB We only wipe the object header area because the rest of + * the buffer might contain xattribs. + */ + memset(oh, 0xff, sizeof(*oh)); + } } else { memset(buffer, 0xff, dev->data_bytes_per_chunk); } @@ -3427,7 +3205,6 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, bi->has_shrink_hdr = 1; } - return new_chunk_id; } @@ -3471,7 +3248,7 @@ int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) * 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 || + if (cache || n_copy != (int)dev->data_bytes_per_chunk || dev->param.inband_tags) { if (dev->param.n_caches > 0) { @@ -3546,7 +3323,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, start >= dev->data_bytes_per_chunk) { yaffs_trace(YAFFS_TRACE_ERROR, "AddrToChunk of offset %lld gives chunk %d start %d", - offset, chunk, start); + (long long)offset, chunk, start); } chunk++; /* File pos to chunk in file offset */ @@ -3581,7 +3358,7 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, (start + n)) ? n_bytes_read : (start + n); if (n_writeback < 0 || - n_writeback > dev->data_bytes_per_chunk) + n_writeback > (int)dev->data_bytes_per_chunk) BUG(); } else { @@ -3589,7 +3366,7 @@ 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 || + if (n_copy != (int)dev->data_bytes_per_chunk || !dev->param.cache_bypass_aligned || dev->param.inband_tags) { /* An incomplete start or end chunk (or maybe both @@ -3737,9 +3514,9 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, loff_t new_size) if (chunk_id < 1) continue; - if (chunk_id < + if ((u32)chunk_id < (dev->internal_start_block * dev->param.chunks_per_block) || - chunk_id >= + (u32)chunk_id >= ((dev->internal_end_block + 1) * dev->param.chunks_per_block)) { yaffs_trace(YAFFS_TRACE_ALWAYS, @@ -3789,7 +3566,7 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) loff_t old_size = in->variant.file_variant.file_size; yaffs_flush_file_cache(in, 1); - yaffs_invalidate_whole_cache(in); + yaffs_invalidate_file_cache(in); yaffs_check_gc(dev, 0); @@ -4532,12 +4309,11 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size) if (obj->hdr_chunk > 0) { result = yaffs_rd_chunk_tags_nand(obj->my_dev, - obj->hdr_chunk, - buffer, NULL); + obj->hdr_chunk, buffer, NULL); + if (result == YAFFS_OK) + 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); } @@ -4768,18 +4544,23 @@ int yaffs_guts_ll_init(struct yaffs_dev *dev) return YAFFS_FAIL; } + if (!yaffs_init_tmp_buffers(dev)) + return YAFFS_FAIL; + if (yaffs_init_nand(dev) != YAFFS_OK) { yaffs_trace(YAFFS_TRACE_ALWAYS, "InitialiseNAND failed"); return YAFFS_FAIL; } + dev->ll_init = 1; + return YAFFS_OK; } int yaffs_guts_format_dev(struct yaffs_dev *dev) { - int i; + u32 i; enum yaffs_block_state state; u32 dummy; @@ -4798,12 +4579,24 @@ int yaffs_guts_format_dev(struct yaffs_dev *dev) return YAFFS_OK; } +/* + * If the dev is mounted r/w then the cleanup will happen during + * yaffs_guts_initialise. However if the dev is mounted ro then + * the cleanup will be dfered until yaffs is remounted r/w. + */ +void yaffs_guts_cleanup(struct yaffs_dev *dev) +{ + yaffs_strip_deleted_objs(dev); + yaffs_fix_hanging_objs(dev); + if (dev->param.empty_lost_n_found) + yaffs_empty_l_n_f(dev); +} int yaffs_guts_initialise(struct yaffs_dev *dev) { int init_failed = 0; - unsigned x; - int bits; + u32 x; + u32 bits; if(yaffs_guts_ll_init(dev) != YAFFS_OK) return YAFFS_FAIL; @@ -4907,41 +4700,11 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) yaffs_endian_config(dev); - /* Initialise temporary buffers and caches. */ - if (!yaffs_init_tmp_buffers(dev)) - init_failed = 1; - - dev->cache = NULL; + /* Initialise temporary caches. */ dev->gc_cleanup_list = NULL; - if (!init_failed && dev->param.n_caches > 0) { - int i; - void *buf; - 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 = kmalloc(cache_bytes, GFP_NOFS); - - buf = (u8 *) dev->cache; - - if (dev->cache) - memset(dev->cache, 0, cache_bytes); - - for (i = 0; i < dev->param.n_caches && buf; i++) { - dev->cache[i].object = NULL; - dev->cache[i].last_use = 0; - dev->cache[i].dirty = 0; - dev->cache[i].data = buf = - kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS); - } - if (!buf) - init_failed = 1; - - dev->cache_last_use = 0; - } + if (!init_failed) + init_failed = yaffs_cache_init(dev) < 0; dev->cache_hits = 0; @@ -5011,10 +4774,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) init_failed = 1; } - yaffs_strip_deleted_objs(dev); - yaffs_fix_hanging_objs(dev); - if (dev->param.empty_lost_n_found) - yaffs_empty_l_n_f(dev); + yaffs_guts_cleanup(dev); } if (init_failed) { @@ -5050,22 +4810,12 @@ int yaffs_guts_initialise(struct yaffs_dev *dev) void yaffs_deinitialise(struct yaffs_dev *dev) { if (dev->is_mounted) { - int i; + u32 i; yaffs_deinit_blocks(dev); yaffs_deinit_tnodes_and_objs(dev); yaffs_summary_deinit(dev); - - if (dev->param.n_caches > 0 && dev->cache) { - - for (i = 0; i < dev->param.n_caches; i++) { - kfree(dev->cache[i].data); - dev->cache[i].data = NULL; - } - - kfree(dev->cache); - dev->cache = NULL; - } + yaffs_cache_deinit(dev); kfree(dev->gc_cleanup_list); @@ -5079,6 +4829,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev) kfree(dev->checkpt_block_list); dev->checkpt_block_list = NULL; + dev->ll_init = 0; dev->is_mounted = 0; yaffs_deinit_nand(dev); @@ -5088,7 +4839,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev) int yaffs_count_free_chunks(struct yaffs_dev *dev) { int n_free = 0; - int b; + u32 b; struct yaffs_block_info *blk; blk = dev->block_info; @@ -5116,18 +4867,12 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev) int n_free; int n_dirty_caches; int blocks_for_checkpt; - int i; n_free = dev->n_free_chunks; n_free += dev->n_deleted_files; /* 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) - n_dirty_caches++; - } - + n_dirty_caches = yaffs_count_dirty_caches(dev); n_free -= n_dirty_caches; n_free -= @@ -5144,6 +4889,85 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev) return n_free; } +/* + * Marshalling functions to get the appropriate time values saved + * and restored to/from obj headers. + * + * Note that the WinCE time fields are used to store the 32-bit values. + */ + +static void yaffs_oh_time_load(u32 *yst_time, u32 *win_time, YTIME_T timeval) +{ + u32 upper; + u32 lower; + + lower = timeval & 0xffffffff; + /* we have to use #defines here insted of an if statement + otherwise the compiler throws an error saying that + right shift count >= width of type when we are using 32 bit time. + */ + #ifdef CONFIG_YAFFS_USE_32_BIT_TIME_T + upper = 0; + #else + upper = (timeval >> 32) & 0xffffffff; + #endif + + *yst_time = lower; + win_time[0] = lower; + win_time[1] = upper; +} + +static YTIME_T yaffs_oh_time_fetch(const u32 *yst_time, const u32 *win_time) +{ + u32 upper; + u32 lower; + + if (win_time[1] == 0xffffffff) { + upper = 0; + lower = *yst_time; + } else { + upper = win_time[1]; + lower = win_time[0]; + } + if (sizeof(YTIME_T) > sizeof(u32)) { + u64 ret; + ret = (((u64)upper) << 32) | lower; + return (YTIME_T) ret; + + } else + return (YTIME_T) lower; +} + +YTIME_T yaffs_oh_ctime_fetch(struct yaffs_obj_hdr *oh) +{ + return yaffs_oh_time_fetch(&oh->yst_ctime, oh->win_ctime); +} + +YTIME_T yaffs_oh_mtime_fetch(struct yaffs_obj_hdr *oh) +{ + return yaffs_oh_time_fetch(&oh->yst_mtime, oh->win_mtime); +} + +YTIME_T yaffs_oh_atime_fetch(struct yaffs_obj_hdr *oh) +{ + return yaffs_oh_time_fetch(&oh->yst_atime, oh->win_atime); +} + +void yaffs_oh_ctime_load(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + yaffs_oh_time_load(&oh->yst_ctime, oh->win_ctime, obj->yst_ctime); +} + +void yaffs_oh_mtime_load(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + yaffs_oh_time_load(&oh->yst_mtime, oh->win_mtime, obj->yst_mtime); +} + +void yaffs_oh_atime_load(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + yaffs_oh_time_load(&oh->yst_atime, oh->win_atime, obj->yst_atime); +} + /* * Marshalling functions to get loff_t file sizes into and out of @@ -5154,8 +4978,9 @@ void yaffs_oh_size_load(struct yaffs_dev *dev, loff_t fsize, int do_endian) { - oh->file_size_low = (fsize & 0xFFFFFFFF); - oh->file_size_high = ((fsize >> 32) & 0xFFFFFFFF); + oh->file_size_low = FSIZE_LOW(fsize); + + oh->file_size_high = FSIZE_HIGH(fsize); if (do_endian) { yaffs_do_endian_u32(dev, &oh->file_size_low); @@ -5177,8 +5002,7 @@ loff_t yaffs_oh_to_size(struct yaffs_dev *dev, struct yaffs_obj_hdr *oh, yaffs_do_endian_u32 (dev, &low); yaffs_do_endian_u32 (dev, &high); } - retval = (((loff_t) high) << 32) | - (((loff_t) low) & 0xFFFFFFFF); + retval = FSIZE_COMBINE(high, low); } else { u32 low = oh->file_size_low; @@ -5193,7 +5017,7 @@ loff_t yaffs_oh_to_size(struct yaffs_dev *dev, struct yaffs_obj_hdr *oh, void yaffs_count_blocks_by_state(struct yaffs_dev *dev, int bs[10]) { - int i; + u32 i; struct yaffs_block_info *bi; int s;