summaryrefslogtreecommitdiff
path: root/yaffs_guts.c
diff options
context:
space:
mode:
authorCharles Manning <cdhmanning@gmail.com>2011-01-13 13:21:47 +1300
committerCharles Manning <cdhmanning@gmail.com>2011-01-13 13:21:47 +1300
commit46eb953ecab322d3385ccf84c75d969de8542317 (patch)
treeef59001d4a8561827571c332a11fb51ed0d6d9bf /yaffs_guts.c
parent05f5305b2d17b0e2889338724b864cf80f309437 (diff)
yaffs: Reformatting to be kernel friendly.
Passes checkpatch.pl Signed-off-by: Charles Manning <cdhmanning@gmail.com>
Diffstat (limited to 'yaffs_guts.c')
-rw-r--r--yaffs_guts.c989
1 files changed, 430 insertions, 559 deletions
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;
-
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-03 06:59:37 +0000