#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 */
/* 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;
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)
"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
}
-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;
/*
* 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;
*/
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;
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");
}
}
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);
* 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--) {
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;
}
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;
static int yaffs_find_alloc_block(struct yaffs_dev *dev)
{
int i;
-
struct yaffs_block_info *bi;
if (dev->n_erased_blocks < 1) {
* 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;
}
}
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;
}
return ret_val;
}
- yaffs_trace(YAFFS_TRACE_ERROR, "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" );
+ yaffs_trace(YAFFS_TRACE_ERROR,
+ "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!");
return -1;
}
}
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;
* 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.
*/
/*---------------- 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))) {
{
#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');
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++;
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));
}
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,
int i;
int l;
struct yaffs_tnode *tn;
-
u32 x;
/* Check sane level and page Id */
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;
}
}
} 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]) {
}
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;
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;
}
int the_chunk = -1;
struct yaffs_ext_tags local_tags;
int ret_val = -1;
-
struct yaffs_dev *dev = in->my_dev;
if (!tags) {
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;
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) {
yaffs_trace(YAFFS_TRACE_ERROR,
"yaffs tragedy:attempt to put data chunk into a non-file"
);
- YBUG();
+ BUG();
}
yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
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) {
}
- /* 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) {
((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;
}
}
-/* 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,
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)
yaffs_trace(YAFFS_TRACE_ALWAYS,
"tragedy: Trying to add an object to a null pointer directory"
);
- YBUG();
+ BUG();
return;
}
if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
yaffs_trace(YAFFS_TRACE_ALWAYS,
"tragedy: Trying to add an object to a non-directory"
);
- YBUG();
+ BUG();
}
if (obj->siblings.prev == NULL) {
/* Not initialised */
- YBUG();
+ BUG();
}
yaffs_verify_dir(directory);
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)
yaffs_trace(YAFFS_TRACE_ALWAYS,
"tragedy: yaffs_change_obj_name: new_dir is not a directory"
);
- YBUG();
+ BUG();
}
/* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
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 ||
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.
*/
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) {
if (cache && !cache->locked) {
/* Write it out and free it up */
-
chunk_written =
yaffs_wr_data_obj(cache->object,
cache->chunk_id,
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)
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);
}
return &dev->cache[i];
}
}
-
return NULL;
}
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;
yaffs_flush_file_cache(the_obj);
cache = yaffs_grab_chunk_worker(dev);
}
-
}
return cache;
} else {
return NULL;
- }
+ }
}
/* Find a cached chunk */
{
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 &&
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++)
dev->cache_last_use = 0;
}
-
dev->cache_last_use++;
-
cache->last_use = dev->cache_last_use;
if (is_write)
/* FreeObject frees up a Object and puts it back on the free list */
static void yaffs_free_obj(struct yaffs_obj *obj)
{
- struct yaffs_dev *dev = obj->my_dev;
+ struct yaffs_dev *dev;
+ if (!obj) {
+ BUG();
+ return;
+ }
+ dev = obj->my_dev;
yaffs_trace(YAFFS_TRACE_OS, "FreeObject %p inode %p",
obj, obj->my_inode);
-
- if (!obj)
- YBUG();
if (obj->parent)
- YBUG();
+ BUG();
if (!list_empty(&obj->siblings))
- YBUG();
+ BUG();
if (obj->my_inode) {
/* We're still hooked up to a cached inode.
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);
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])
yaffs_free_tnode(dev, tn);
tn = NULL;
}
-
}
-
return tn;
-
}
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)
}
}
}
-
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);
lowest = dev->obj_bucket[dev->bucket_finder].count;
l = dev->bucket_finder;
}
-
}
return l;
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;
}
}
}
-
return n;
}
/* 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;
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;
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;
}
dev->n_obj = 0;
dev->n_tnodes = 0;
-
yaffs_init_raw_tnodes_and_objs(dev);
for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
}
-YCHAR *yaffs_clone_str(const YCHAR * str)
+YCHAR *yaffs_clone_str(const YCHAR *str)
{
YCHAR *new_str = NULL;
int len;
static void yaffs_update_parent(struct yaffs_obj *obj)
{
struct yaffs_dev *dev;
+
if (!obj)
return;
dev = obj->my_dev;
} else {
yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
- }
+ }
}
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;
in = yaffs_new_obj(dev, -1, type);
if (!in) {
- if (str)
- kfree(str);
+ kfree(str);
return NULL;
}
}
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;
}
}
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,
}
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,
}
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);
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)
{
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 */
dev->block_info_alt = 1;
} else {
dev->block_info_alt = 0;
- }
+ }
if (dev->block_info) {
/* Set up dynamic blockinfo stuff. Round up bytes. */
dev->chunk_bits_alt = 1;
} else {
dev->chunk_bits_alt = 0;
- }
+ }
}
if (dev->block_info && dev->chunk_bits) {
{
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;
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;
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.
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;
}
}
+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,
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 {
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);
/* 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",
}
}
-
chunks_after = yaffs_get_erased_chunks(dev);
if (chunks_before >= chunks_after)
yaffs_trace(YAFFS_TRACE_GC,
}
/*
- * FindBlockForgarbageCollection is used to select the dirtiest block (or close enough)
+ * find_gc_block() selects the dirtiest block (or close enough)
* for garbage collection.
*/
/*
* 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 &&
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.
*/
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)
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;
}
}
/*
- * 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.
*/
bi->pages_in_use - bi->soft_del_pages;
} else {
dev->gc_not_done = 0;
- }
+ }
}
if (selected) {
* 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.
}
/* 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 {
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);
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 {
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 &&
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.
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);
yaffs_trace(YAFFS_TRACE_ERROR,
"Writing %d bytes to chunk!!!!!!!!!",
n_bytes);
- YBUG();
+ BUG();
}
new_chunk_id =
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;
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)
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;
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)
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) {
}
} 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
}
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) {
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"));
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;
memcpy(oh->name, old_name, sizeof(oh->name));
} else {
memset(oh->name, 0, sizeof(oh->name));
- }
+ }
oh->is_shrink = is_shrink;
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;
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 */
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 /
chunks_per_block);
bi->has_shrink_hdr = 1;
}
-
}
-
ret_val = new_chunk_id;
-
}
if (buffer)
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++;
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 =
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)
{
int chunk_written = 0;
u32 n_bytes_read;
u32 chunk_start;
-
struct yaffs_dev *dev;
dev = in->my_dev;
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);
(n_bytes_read >
(start + n)) ? n_bytes_read : (start + n);
- if (n_writeback < 0
- || n_writeback > dev->data_bytes_per_chunk)
- YBUG();
+ if (n_writeback < 0 ||
+ n_writeback > dev->data_bytes_per_chunk)
+ BUG();
} else {
n_copy = dev->data_bytes_per_chunk - start;
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
!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;
}
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 =
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);
}
buffer += n_copy;
n_done += n_copy;
}
-
}
/* Update file object */
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);
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.
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);
}
}
}
-
}
void yaffs_resize_file_down(struct yaffs_obj *obj, 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 */
} else {
ret_val = YAFFS_OK;
}
-
return ret_val;
-
}
*/
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;
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)
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)
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);
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);
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);
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;
* 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
*/
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;
/* 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;
int result;
struct yaffs_dev *dev;
- if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
- YBUG();
- if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
- YBUG();
+ if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+ BUG();
+ return YAFFS_FAIL;
+ }
+ if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+ BUG();
+ return YAFFS_FAIL;
+ }
dev = old_dir->my_dev;
* 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
/* 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;
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 =
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)
*/
hl->variant.hardlink_variant.equiv_obj = NULL;
INIT_LIST_HEAD(&hl->hard_links);
-
}
}
}
/* Soft delete all the unlinked files */
list_for_each_safe(i, n,
&dev->unlinked_dir->variant.dir_variant.children) {
- if (i) {
- l = list_entry(i, struct yaffs_obj, siblings);
- yaffs_del_obj(l);
- }
+ l = list_entry(i, struct yaffs_obj, siblings);
+ yaffs_del_obj(l);
}
list_for_each_safe(i, n, &dev->del_dir->variant.dir_variant.children) {
- if (i) {
- l = list_entry(i, struct yaffs_obj, siblings);
- yaffs_del_obj(l);
- }
+ l = list_entry(i, struct yaffs_obj, siblings);
+ yaffs_del_obj(l);
}
-
}
/*
* - 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)
for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
list_for_each_safe(lh, n, &dev->obj_bucket[i].list) {
- if (lh) {
- obj =
- list_entry(lh, struct yaffs_obj, hash_link);
- parent = obj->parent;
-
- if (yaffs_has_null_parent(dev, obj)) {
- /* These directories are not hanging */
- hanging = 0;
- } else if (!parent
- || parent->variant_type !=
- YAFFS_OBJECT_TYPE_DIRECTORY) {
- hanging = 1;
- } else if (yaffs_has_null_parent(dev, parent)) {
- hanging = 0;
- } else {
- /*
- * Need to follow the parent chain to see if it is hanging.
- */
- hanging = 0;
- depth_limit = 100;
-
- while (parent != dev->root_dir &&
- parent->parent &&
- parent->parent->variant_type ==
- YAFFS_OBJECT_TYPE_DIRECTORY
- && depth_limit > 0) {
- parent = parent->parent;
- depth_limit--;
- }
- if (parent != dev->root_dir)
- hanging = 1;
- }
- if (hanging) {
- yaffs_trace(YAFFS_TRACE_SCAN,
- "Hanging object %d moved to lost and found",
- obj->obj_id);
- yaffs_add_obj_to_dir(dev->lost_n_found,
- obj);
+ obj = list_entry(lh, struct yaffs_obj, hash_link);
+ parent = obj->parent;
+
+ if (yaffs_has_null_parent(dev, obj)) {
+ /* These directories are not hanging */
+ hanging = 0;
+ } else if (!parent ||
+ parent->variant_type !=
+ YAFFS_OBJECT_TYPE_DIRECTORY) {
+ hanging = 1;
+ } else if (yaffs_has_null_parent(dev, parent)) {
+ hanging = 0;
+ } else {
+ /*
+ * Need to follow the parent chain to
+ * see if it is hanging.
+ */
+ hanging = 0;
+ depth_limit = 100;
+
+ while (parent != dev->root_dir &&
+ parent->parent &&
+ parent->parent->variant_type ==
+ YAFFS_OBJECT_TYPE_DIRECTORY &&
+ depth_limit > 0) {
+ parent = parent->parent;
+ depth_limit--;
}
+ if (parent != dev->root_dir)
+ hanging = 1;
+ }
+ if (hanging) {
+ yaffs_trace(YAFFS_TRACE_SCAN,
+ "Hanging object %d moved to lost and found",
+ obj->obj_id);
+ yaffs_add_obj_to_dir(dev->lost_n_found, obj);
}
}
}
struct list_head *n;
if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
- YBUG();
+ BUG();
list_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
- if (lh) {
- obj = list_entry(lh, struct yaffs_obj, siblings);
- if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
- 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);
- }
+ 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);
+ yaffs_unlink_obj(obj);
}
-
}
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)
yaffs_trace(YAFFS_TRACE_ALWAYS,
"tragedy: yaffs_find_by_name: null pointer directory"
);
- YBUG();
+ BUG();
return NULL;
}
if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
yaffs_trace(YAFFS_TRACE_ALWAYS,
"tragedy: yaffs_find_by_name: non-directory"
);
- YBUG();
+ BUG();
}
sum = yaffs_calc_name_sum(name);
l = list_entry(i, struct yaffs_obj, siblings);
if (l->parent != directory)
- YBUG();
+ BUG();
yaffs_check_obj_details_loaded(l);
return l;
}
}
-
return NULL;
}
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);
}
* 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. */
}
}
-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;
return DT_BLK;
if (S_ISSOCK(obj->yst_mode))
return DT_SOCK;
+ return DT_REG;
+ break;
default:
return DT_REG;
break;
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;
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);
yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found);
return YAFFS_OK;
}
-
return YAFFS_FAIL;
}
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 */
(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 */
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;
dev->tnode_width = bits;
} else {
dev->tnode_width = 16;
- }
+ }
dev->tnode_mask = (1 << dev->tnode_width) - 1;
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;
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;
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);
}
} else if (!yaffs1_scan(dev)) {
init_failed = 1;
- }
+ }
yaffs_strip_deleted_objs(dev);
yaffs_fix_hanging_objs(dev);
yaffs_trace(YAFFS_TRACE_TRACING,
"yaffs: yaffs_guts_initialise() done.");
return YAFFS_OK;
-
}
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;
}
{
int n_free = 0;
int b;
-
struct yaffs_block_info *blk;
blk = dev->block_info;
}
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;
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)
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);
n_free = 0;
return n_free;
-
}