/* #define CONFIG_YAFFS_DOES_ECC */
/* Default: Selected */
-/* Meaning: Yaffs does its own ECC on tags for packed tags rather than use mtd */
+/* Meaning: Yaffs does ECC on tags for packed tags rather than use mtd */
#define CONFIG_YAFFS_DOES_TAGS_ECC
/* Default: Not selected */
#include "yportenv.h"
#ifdef CONFIG_YAFFS_KMALLOC_ALLOCATOR
+/* This is an alternative debug allocator. Don't use for production code. */
void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
{
struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
{
- return (struct yaffs_tnode *)kmalloc(dev->tnode_size, GFP_NOFS);
+ return kmalloc(dev->tnode_size, GFP_NOFS);
}
void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
{
dev = dev;
- return (struct yaffs_obj *)kmalloc(sizeof(struct yaffs_obj));
+ return kmalloc(sizeof(struct yaffs_obj));
}
void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
{
-
struct yaffs_allocator *allocator =
(struct yaffs_allocator *)dev->allocator;
-
struct yaffs_tnode_list *tmp;
if (!allocator) {
kfree(allocator->alloc_tnode_list->tnodes);
kfree(allocator->alloc_tnode_list);
allocator->alloc_tnode_list = tmp;
-
}
allocator->free_tnodes = NULL;
return YAFFS_OK;
/* make these things */
-
new_tnodes = kmalloc(n_tnodes * dev->tnode_size, GFP_NOFS);
mem = (u8 *) new_tnodes;
* NB If we can't add this to the management list it isn't fatal
* but it just means we can't free this bunch of tnodes later.
*/
-
tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS);
if (!tnl) {
yaffs_trace(YAFFS_TRACE_ERROR,
allocator->alloc_tnode_list = tnl;
}
- yaffs_trace(YAFFS_TRACE_ALLOCATE,"Tnodes added");
+ yaffs_trace(YAFFS_TRACE_ALLOCATE, "Tnodes added");
return YAFFS_OK;
}
static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
{
struct yaffs_allocator *allocator = dev->allocator;
-
int i;
struct yaffs_obj *new_objs;
struct yaffs_obj_list *list;
list = kmalloc(sizeof(struct yaffs_obj_list), GFP_NOFS);
if (!new_objs || !list) {
- if (new_objs) {
- kfree(new_objs);
- new_objs = NULL;
- }
- if (list) {
- kfree(list);
- list = NULL;
- }
+ kfree(new_objs);
+ new_objs = NULL;
+ kfree(list);
+ list = NULL;
yaffs_trace(YAFFS_TRACE_ALLOCATE,
"Could not allocate more objects");
return YAFFS_FAIL;
u8 *blk_bits = yaffs_block_bits(dev, blk);
yaffs_verify_chunk_bit_id(dev, blk, chunk);
-
blk_bits[chunk / 8] &= ~(1 << (chunk & 7));
}
u8 *blk_bits = yaffs_block_bits(dev, blk);
yaffs_verify_chunk_bit_id(dev, blk, chunk);
-
blk_bits[chunk / 8] |= (1 << (chunk & 7));
}
int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk)
{
u8 *blk_bits = yaffs_block_bits(dev, blk);
- yaffs_verify_chunk_bit_id(dev, blk, chunk);
+ yaffs_verify_chunk_bit_id(dev, blk, chunk);
return (blk_bits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
}
{
u8 *blk_bits = yaffs_block_bits(dev, blk);
int i;
+
for (i = 0; i < dev->chunk_bit_stride; i++) {
if (*blk_bits)
return 1;
if (dev->param.
erase_fn(dev,
- i - dev->block_offset /* realign */ )) {
+ i - dev->block_offset /* realign */)) {
bi->block_state = YAFFS_BLOCK_STATE_EMPTY;
dev->n_erased_blocks++;
dev->n_free_chunks +=
{
int i;
int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
+
yaffs_trace(YAFFS_TRACE_CHECKPOINT,
"allocating checkpt block: erased %d reserved %d avail %d next %d ",
dev->n_erased_blocks, dev->param.n_reserved_blocks,
int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
{
-
dev->checkpt_open_write = writing;
/* Got the functions we need? */
int i;
/* Set to a value that will kick off a read */
dev->checkpt_byte_offs = dev->data_bytes_per_chunk;
- /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
- * going to be way more than we need */
+ /* A checkpoint block list of 1 checkpoint block per 16 block is
+ * (hopefully) going to be way more than we need */
dev->blocks_in_checkpt = 0;
dev->checkpt_max_blocks =
(dev->internal_end_block - dev->internal_start_block) / 16 +
int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum)
{
u32 composite_sum;
+
composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
*sum = composite_sum;
return 1;
{
int chunk;
int realigned_chunk;
-
struct yaffs_ext_tags tags;
if (dev->checkpt_cur_block < 0) {
{
int i = 0;
int ok = 1;
-
u8 *data_bytes = (u8 *) data;
if (!dev->checkpt_buffer)
int i = 0;
int ok = 1;
struct yaffs_ext_tags tags;
-
int chunk;
int realigned_chunk;
-
u8 *data_bytes = (u8 *) data;
if (!dev->checkpt_buffer)
/* read in the next chunk */
dev->param.read_chunk_tags_fn(dev,
- realigned_chunk,
- dev->
- checkpt_buffer,
- &tags);
+ realigned_chunk,
+ dev->checkpt_buffer,
+ &tags);
if (tags.chunk_id != (dev->checkpt_page_seq + 1)
|| tags.ecc_result > YAFFS_ECC_RESULT_FIXED
int yaffs_checkpt_close(struct yaffs_dev *dev)
{
-
if (dev->checkpt_open_write) {
if (dev->checkpt_byte_offs != 0)
yaffs2_checkpt_flush_buffer(dev);
bi = yaffs_get_block_info(dev, blk);
if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY)
bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
- else {
- /* Todo this looks odd... */
- }
}
kfree(dev->checkpt_block_list);
dev->checkpt_block_list = NULL;
dev->blocks_in_checkpt * dev->param.chunks_per_block;
dev->n_erased_blocks -= dev->blocks_in_checkpt;
- yaffs_trace(YAFFS_TRACE_CHECKPOINT,"checkpoint byte count %d",
+ yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpoint byte count %d",
dev->checkpt_byte_count);
if (dev->checkpt_buffer) {
return 1;
} else {
return 0;
- }
+ }
}
int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
*
* The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
* The two unused bit are set to 1.
- * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
- * blocks are used on a 512-byte NAND page.
+ * The ECC can correct single bit errors in a 256-byte page of data. Thus, two
+ * such ECC blocks are used on a 512-byte NAND page.
*
*/
/* Table generated by gen-ecc.c
* Using a table means we do not have to calculate p1..p4 and p1'..p4'
* for each byte of data. These are instead provided in a table in bits7..2.
- * Bit 0 of each entry indicates whether the entry has an odd or even parity, and therefore
- * this bytes influence on the line parity.
+ * Bit 0 of each entry indicates whether the entry has an odd or even parity,
+ * and therefore this bytes influence on the line parity.
*/
#include "yportenv.h"
void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc)
{
unsigned int i;
-
unsigned char col_parity = 0;
unsigned char line_parity = 0;
unsigned char line_parity_prime = 0;
struct yaffs_ecc_other *ecc_other)
{
unsigned int i;
-
unsigned char col_parity = 0;
unsigned line_parity = 0;
unsigned line_parity_prime = 0;
*
* The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
* The two unused bit are set to 1.
- * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
- * blocks are used on a 512-byte NAND page.
+ * The ECC can correct single bit errors in a 256-byte page of data.
+ * Thus, two such ECC blocks are used on a 512-byte NAND page.
*
*/
#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) {
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)
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)
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)
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);
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)
+ if (n_writeback < 0 ||
+ n_writeback > dev->data_bytes_per_chunk)
YBUG();
} else {
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;
* 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);
-
}
}
}
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)
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;
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--;
}
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)
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)
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;
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;
-
}
*/
#define YAFFS_MAGIC 0x5941FF53
-#define YAFFS_NTNODES_LEVEL0 16
+#define YAFFS_NTNODES_LEVEL0 16
#define YAFFS_TNODES_LEVEL0_BITS 4
#define YAFFS_TNODES_LEVEL0_MASK 0xf
-#define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2)
-#define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1)
+#define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2)
+#define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1)
#define YAFFS_TNODES_INTERNAL_MASK 0x7
#define YAFFS_TNODES_MAX_LEVEL 6
#define YAFFS_BYTES_PER_CHUNK 512
#define YAFFS_CHUNK_SIZE_SHIFT 9
#define YAFFS_CHUNKS_PER_BLOCK 32
-#define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK)
+#define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK)
#endif
-#define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024
+#define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024
#define YAFFS_MIN_YAFFS2_SPARE_SIZE 32
#define YAFFS_MAX_CHUNK_ID 0x000FFFFF
#define YAFFS_NOBJECT_BUCKETS 256
#define YAFFS_OBJECT_SPACE 0x40000
-#define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE -1)
+#define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE - 1)
-#define YAFFS_CHECKPOINT_VERSION 4
+#define YAFFS_CHECKPOINT_VERSION 4
#ifdef CONFIG_YAFFS_UNICODE
#define YAFFS_MAX_NAME_LENGTH 127
* The range is limited slightly to help distinguish bad numbers from good.
* This also allows us to perhaps in the future use special numbers for
* special purposes.
- * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
+ * EFFFFF00 allows the allocation of 8 blocks/second (~1Mbytes) for 15 years,
* and is a larger number than the lifetime of a 2GB device.
*/
#define YAFFS_LOWEST_SEQUENCE_NUMBER 0x00001000
};
/* Tags structures in RAM
- * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise
- * the structure size will get blown out.
+ * NB This uses bitfield. Bitfields should not straddle a u32 boundary
+ * otherwise the structure size will get blown out.
*/
#ifndef CONFIG_YAFFS_NO_YAFFS1
unsigned validity0;
unsigned chunk_used; /* Status of the chunk: used or unused */
- unsigned obj_id; /* If 0 then this is not part of an object (unused) */
- unsigned chunk_id; /* If 0 then this is a header, else a data chunk */
+ unsigned obj_id; /* If 0 this is not used */
+ unsigned chunk_id; /* If 0 this is a header, else a data chunk */
unsigned n_bytes; /* Only valid for data chunks */
/* The following stuff only has meaning when we read */
/* Extra info if this is an object header (YAFFS2 only) */
- unsigned extra_available; /* There is extra info available if this is not zero */
+ unsigned extra_available; /* Extra info available if not zero */
unsigned extra_parent_id; /* The parent object */
unsigned extra_is_shrink; /* Is it a shrink header? */
unsigned extra_shadows; /* Does this shadow another object? */
enum yaffs_obj_type extra_obj_type; /* What object type? */
unsigned extra_length; /* Length if it is a file */
- unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */
+ unsigned extra_equiv_id; /* Equivalent object for a hard link */
unsigned validity1;
/* Being scanned */
YAFFS_BLOCK_STATE_NEEDS_SCANNING,
- /* The block might have something on it (ie it is allocating or full, perhaps empty)
- * but it needs to be scanned to determine its true state.
+ /* The block might have something on it (ie it is allocating or full,
+ * perhaps empty) but it needs to be scanned to determine its true
+ * state.
* This state is only valid during scanning.
- * NB We tolerate empty because the pre-scanner might be incapable of deciding
- * However, if this state is returned on a YAFFS2 device, then we expect a sequence number
+ * NB We tolerate empty because the pre-scanner might be incapable of
+ * deciding
+ * However, if this state is returned on a YAFFS2 device,
+ * then we expect a sequence number
*/
YAFFS_BLOCK_STATE_EMPTY,
* At least one page holds valid data.
* This is the one currently being used for page
* allocation. Should never be more than one of these.
- * If a block is only partially allocated at mount it is treated as full.
+ * If a block is only partially allocated at mount it is treated as
+ * full.
*/
YAFFS_BLOCK_STATE_FULL,
int soft_del_pages:10; /* number of soft deleted pages */
int pages_in_use:10; /* number of pages in use */
- unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */
- u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */
- /* and retire the block. */
- u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */
- u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block.
- It should be prioritised for GC */
- u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
+ unsigned block_state:4; /* One of the above block states. */
+ /* NB use unsigned because enum is sometimes
+ * an int */
+ u32 needs_retiring:1; /* Data has failed on this block, */
+ /*need to get valid data off and retire*/
+ u32 skip_erased_check:1;/* Skip the erased check on this block */
+ u32 gc_prioritise:1; /* An ECC check or blank check has failed.
+ Block should be prioritised for GC */
+ u32 chunk_error_strikes:3; /* How many times we've had ecc etc
+ failures on this block and tried to reuse it */
#ifdef CONFIG_YAFFS_YAFFS2
- u32 has_shrink_hdr:1; /* This block has at least one shrink object header */
+ u32 has_shrink_hdr:1; /* This block has at least one shrink header */
u32 seq_number; /* block sequence number for yaffs2 */
#endif
u16 sum_no_longer_used; /* checksum of name. No longer used */
YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
- /* The following apply to directories, files, symlinks - not hard links */
+ /* The following apply to all object types except for hard links */
u32 yst_mode; /* protection */
u32 yst_uid;
/* Alias is for symlinks only. */
YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1];
- u32 yst_rdev; /* device stuff for block and char devices (major/min) */
+ u32 yst_rdev; /* stuff for block and char devices (major/min) */
u32 win_ctime[2];
u32 win_atime[2];
u32 inband_is_shrink;
u32 reserved[2];
- int shadows_obj; /* This object header shadows the specified object if > 0 */
+ int shadows_obj; /* This object header shadows the
+ specified object if > 0 */
- /* is_shrink applies to object headers written when we shrink the file (ie resize) */
+ /* is_shrink applies to object headers written when wemake a hole. */
u32 is_shrink;
};
struct yaffs_obj {
u8 deleted:1; /* This should only apply to unlinked files. */
u8 soft_del:1; /* it has also been soft deleted */
- u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory. */
+ u8 unlinked:1; /* An unlinked file.*/
u8 fake:1; /* A fake object has no presence on NAND. */
- u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */
+ u8 rename_allowed:1; /* Some objects cannot be renamed. */
u8 unlink_allowed:1;
u8 dirty:1; /* the object needs to be written to flash */
u8 valid:1; /* When the file system is being loaded up, this
* object might be created before the data
- * is available (ie. file data records appear before the header).
+ * is available
+ * ie. file data chunks encountered before
+ * the header.
*/
- u8 lazy_loaded:1; /* This object has been lazy loaded and is missing some detail */
+ u8 lazy_loaded:1; /* This object has been lazy loaded and
+ * is missing some detail */
- u8 defered_free:1; /* For Linux kernel. Object is removed from NAND, but is
- * still in the inode cache. Free of object is defered.
+ u8 defered_free:1; /* Object is removed from NAND, but is
+ * still in the inode cache.
+ * Free of object is defered.
* until the inode is released.
*/
- u8 being_created:1; /* This object is still being created so skip some checks. */
- u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */
+ u8 being_created:1; /* This object is still being created
+ * so skip some verification checks. */
+ u8 is_shadowed:1; /* This object is shadowed on the way
+ * to being renamed. */
- u8 xattr_known:1; /* We know if this has object has xattribs or not. */
- u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */
+ u8 xattr_known:1; /* We know if this has object has xattribs
+ * or not. */
+ u8 has_xattr:1; /* This object has xattribs.
+ * Only valid if xattr_known. */
- u8 serial; /* serial number of chunk in NAND. Cached here */
+ u8 serial; /* serial number of chunk in NAND.*/
u16 sum; /* sum of the name to speed searching */
struct yaffs_dev *my_dev; /* The device I'm on */
- struct list_head hash_link; /* list of objects in this hash bucket */
+ struct list_head hash_link; /* list of objects in hash bucket */
- struct list_head hard_links; /* all the equivalent hard linked objects */
+ struct list_head hard_links; /* hard linked object chain*/
/* directory structure stuff */
/* also used for linking up the free list */
/* Where's my object header in NAND? */
int hdr_chunk;
- int n_data_chunks; /* Number of data chunks attached to the file. */
+ int n_data_chunks; /* Number of data chunks for this file. */
u32 obj_id; /* the object id value */
struct yaffs_buffer {
u8 *buffer;
- int line; /* track from whence this buffer was allocated */
+ int line; /* track from whence this buffer was allocated */
int max_line;
};
*/
int inband_tags; /* Use unband tags */
- u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */
+ u32 total_bytes_per_chunk; /* Should be >= 512, does not need to
+ be a power of 2 */
int chunks_per_block; /* does not need to be a power of 2 */
int spare_bytes_per_chunk; /* spare area size */
int start_block; /* Start block we're allowed to use */
int end_block; /* End block we're allowed to use */
- int n_reserved_blocks; /* We want this tuneable so that we can reduce */
- /* reserved blocks on NOR and RAM. */
+ int n_reserved_blocks; /* Tuneable so that we can reduce
+ * reserved blocks on NOR and RAM. */
- int n_caches; /* If <= 0, then short op caching is disabled, else
- * the number of short op caches (don't use too many).
- * 10 to 20 is a good bet.
+ int n_caches; /* If <= 0, then short op caching is disabled,
+ * else the number of short op caches.
*/
- int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */
- int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */
+ int use_nand_ecc; /* Flag to decide whether or not to use
+ * NAND driver ECC on data (yaffs1) */
+ int no_tags_ecc; /* Flag to decide whether or not to do ECC
+ * on packed tags (yaffs2) */
int is_yaffs2; /* Use yaffs2 mode on this device */
int empty_lost_n_found; /* Auto-empty lost+found directory on mount */
- int refresh_period; /* How often we should check to do a block refresh */
+ int refresh_period; /* How often to check for a block refresh */
/* Checkpoint control. Can be set before or after initialisation */
u8 skip_checkpt_rd;
/* NAND access functions (Must be set before calling YAFFS) */
- int (*write_chunk_fn) (struct yaffs_dev * dev,
- int nand_chunk, const u8 * data,
- const struct yaffs_spare * spare);
- int (*read_chunk_fn) (struct yaffs_dev * dev,
- int nand_chunk, u8 * data,
- struct yaffs_spare * spare);
- int (*erase_fn) (struct yaffs_dev * dev, int flash_block);
- int (*initialise_flash_fn) (struct yaffs_dev * dev);
- int (*deinitialise_flash_fn) (struct yaffs_dev * dev);
+ int (*write_chunk_fn) (struct yaffs_dev *dev,
+ int nand_chunk, const u8 *data,
+ const struct yaffs_spare *spare);
+ int (*read_chunk_fn) (struct yaffs_dev *dev,
+ int nand_chunk, u8 *data,
+ struct yaffs_spare *spare);
+ int (*erase_fn) (struct yaffs_dev *dev, int flash_block);
+ int (*initialise_flash_fn) (struct yaffs_dev *dev);
+ int (*deinitialise_flash_fn) (struct yaffs_dev *dev);
#ifdef CONFIG_YAFFS_YAFFS2
- int (*write_chunk_tags_fn) (struct yaffs_dev * dev,
- int nand_chunk, const u8 * data,
- const struct yaffs_ext_tags * tags);
- int (*read_chunk_tags_fn) (struct yaffs_dev * dev,
- int nand_chunk, u8 * data,
- struct yaffs_ext_tags * tags);
- int (*bad_block_fn) (struct yaffs_dev * dev, int block_no);
- int (*query_block_fn) (struct yaffs_dev * dev, int block_no,
- enum yaffs_block_state * state,
- u32 * seq_number);
+ int (*write_chunk_tags_fn) (struct yaffs_dev *dev,
+ int nand_chunk, const u8 *data,
+ const struct yaffs_ext_tags *tags);
+ int (*read_chunk_tags_fn) (struct yaffs_dev *dev,
+ int nand_chunk, u8 *data,
+ struct yaffs_ext_tags *tags);
+ int (*bad_block_fn) (struct yaffs_dev *dev, int block_no);
+ int (*query_block_fn) (struct yaffs_dev *dev, int block_no,
+ enum yaffs_block_state *state,
+ u32 *seq_number);
#endif
/* The remove_obj_fn function must be supplied by OS flavours that
* yaffs direct uses it to implement the faster readdir.
* Linux uses it to protect the directory during unlocking.
*/
- void (*remove_obj_fn) (struct yaffs_obj * obj);
+ void (*remove_obj_fn) (struct yaffs_obj *obj);
/* Callback to mark the superblock dirty */
- void (*sb_dirty_fn) (struct yaffs_dev * dev);
+ void (*sb_dirty_fn) (struct yaffs_dev *dev);
/* Callback to control garbage collection. */
- unsigned (*gc_control) (struct yaffs_dev * dev);
+ unsigned (*gc_control) (struct yaffs_dev *dev);
/* Debug control flags. Don't use unless you know what you're doing */
- int use_header_file_size; /* Flag to determine if we should use file sizes from the header */
+ int use_header_file_size; /* Flag to determine if we should use
+ * file sizes from the header */
int disable_lazy_load; /* Disable lazy loading on this device */
int wide_tnodes_disabled; /* Set to disable wide tnodes */
- int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */
+ int disable_soft_del; /* yaffs 1 only: Set to disable the use of
+ * softdeletion. */
int defered_dir_update; /* Set to defer directory updates */
/* Stuff for figuring out file offset to chunk conversions */
u32 chunk_shift; /* Shift value */
- u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */
+ u32 chunk_div; /* Divisor after shifting: 1 for 2^n sizes */
u32 chunk_mask; /* Mask to use for power-of-2 case */
int is_mounted;
int chunk_offset;
/* Runtime checkpointing stuff */
- int checkpt_page_seq; /* running sequence number of checkpoint pages */
+ int checkpt_page_seq; /* running sequence number of checkpt pages */
int checkpt_byte_count;
int checkpt_byte_offs;
u8 *checkpt_buffer;
u32 checkpt_sum;
u32 checkpt_xor;
- int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */
+ int checkpoint_blocks_required; /* Number of blocks needed to store
+ * current checkpoint set */
/* Block Info */
struct yaffs_block_info *block_info;
u8 *chunk_bits; /* bitmap of chunks in use */
- unsigned block_info_alt:1; /* was allocated using alternative strategy */
- unsigned chunk_bits_alt:1; /* was allocated using alternative strategy */
+ unsigned block_info_alt:1; /* allocated using alternative alloc */
+ unsigned chunk_bits_alt:1; /* allocated using alternative alloc */
int chunk_bit_stride; /* Number of bytes of chunk_bits per block.
* Must be consistent with chunks_per_block.
*/
u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */
u32 n_clean_ups;
- unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */
+ unsigned has_pending_prioritised_gc; /* We think this device might
+ have pending prioritised gcs */
unsigned gc_disable;
unsigned gc_block_finder;
unsigned gc_dirtiest;
struct yaffs_obj *root_dir;
struct yaffs_obj *lost_n_found;
- /* Buffer areas for storing data to recover from write failures TODO
- * u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
- * struct yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK];
- */
-
int buffered_block; /* Which block is buffered here? */
int doing_buffered_block_rewrite;
int cache_last_use;
/* Stuff for background deletion and unlinked files. */
- struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted files live. */
- struct yaffs_obj *del_dir; /* Directory where deleted objects are sent to disappear. */
- struct yaffs_obj *unlinked_deletion; /* Current file being background deleted. */
+ struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted
+ files live. */
+ struct yaffs_obj *del_dir; /* Directory where deleted objects are
+ sent to disappear. */
+ struct yaffs_obj *unlinked_deletion; /* Current file being
+ background deleted. */
int n_deleted_files; /* Count of files awaiting deletion; */
int n_unlinked_files; /* Count of unlinked files. */
int n_bg_deletions; /* Count of background deletions. */
int unmanaged_buffer_deallocs;
/* yaffs2 runtime stuff */
- unsigned seq_number; /* Sequence number of currently allocating block */
+ unsigned seq_number; /* Sequence number of currently
+ allocating block */
unsigned oldest_dirty_seq;
unsigned oldest_dirty_block;
/* Block refreshing */
- int refresh_skip; /* A skip down counter. Refresh happens when this gets to zero. */
+ int refresh_skip; /* A skip down counter.
+ * Refresh happens when this gets to zero. */
/* Dirty directory handling */
struct list_head dirty_dirs; /* List of dirty directories */
};
-/* The CheckpointDevice structure holds the device information that changes at runtime and
- * must be preserved over unmount/mount cycles.
+/* The CheckpointDevice structure holds the device information that changes
+ *at runtime and must be preserved over unmount/mount cycles.
*/
struct yaffs_checkpt_dev {
int struct_type;
int n_bg_deletions; /* Count of background deletions. */
/* yaffs2 runtime stuff */
- unsigned seq_number; /* Sequence number of currently allocating block */
+ unsigned seq_number; /* Sequence number of currently
+ * allocating block */
};
int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size);
struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent,
- const YCHAR * name, u32 mode, u32 uid,
+ const YCHAR *name, u32 mode, u32 uid,
u32 gid);
int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync);
int yaffs_checkpoint_restore(struct yaffs_dev *dev);
/* Directory operations */
-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);
struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir,
- const YCHAR * name);
+ const YCHAR *name);
struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number);
/* Link operations */
-struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name,
+struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name,
struct yaffs_obj *equiv_obj);
struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj);
/* Symlink operations */
struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent,
- const YCHAR * name, u32 mode, u32 uid,
- u32 gid, const YCHAR * alias);
+ const YCHAR *name, u32 mode, u32 uid,
+ u32 gid, const YCHAR *alias);
YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj);
/* Special inodes (fifos, sockets and devices) */
struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent,
- const YCHAR * name, u32 mode, u32 uid,
+ const YCHAR *name, u32 mode, u32 uid,
u32 gid, u32 rdev);
-int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
+int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name,
const void *value, int size, int flags);
-int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
+int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value,
int size);
int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size);
-int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name);
+int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name);
/* Special directories */
struct yaffs_obj *yaffs_root(struct yaffs_dev *dev);
/* A few useful functions to be used within the core files*/
void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
int lyn);
-int yaffs_check_ff(u8 * buffer, int n_bytes);
+int yaffs_check_ff(u8 *buffer, int n_bytes);
void yaffs_handle_chunk_error(struct yaffs_dev *dev,
struct yaffs_block_info *bi);
u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no);
-void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no);
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no);
struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
int number,
enum yaffs_obj_type type);
int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
int nand_chunk, int in_scan);
-void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name);
+void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name);
void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
const struct yaffs_obj_hdr *oh);
void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj);
-YCHAR *yaffs_clone_str(const YCHAR * str);
+YCHAR *yaffs_clone_str(const YCHAR *str);
void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list);
void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no);
-int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name,
+int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name,
int force, int is_shrink, int shadows,
struct yaffs_xattr_mod *xop);
void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
u32 chunk_id,
struct yaffs_tnode *passed_tn);
-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);
void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size);
void yaffs_skip_rest_of_block(struct yaffs_dev *dev);
struct task_struct *bg_thread; /* Background thread for this device */
int bg_running;
struct mutex gross_lock; /* Gross locking mutex*/
- u8 *spare_buffer; /* For mtdif2 use. Don't know the size of the buffer
+ u8 *spare_buffer; /* For mtdif2 use. Don't know the buffer size
* at compile time so we have to allocate it.
*/
struct list_head search_contexts;
- void (*put_super_fn) (struct super_block * sb);
+ void (*put_super_fn) (struct super_block *sb);
struct task_struct *readdir_process;
unsigned mount_id;
((loff_t) block_no) * dev->param.total_bytes_per_chunk
* dev->param.chunks_per_block;
struct erase_info ei;
-
int retval = 0;
ei.mtd = mtd;
#define __YAFFS_MTDIF1_H__
int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- const u8 * data,
+ const u8 *data,
const struct yaffs_ext_tags *tags);
int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- u8 * data, struct yaffs_ext_tags *tags);
+ u8 *data, struct yaffs_ext_tags *tags);
int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no);
int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
- enum yaffs_block_state *state, u32 * seq_number);
+ enum yaffs_block_state *state, u32 *seq_number);
#endif
.eccbytes = 6,
.eccpos = {8, 9, 10, 13, 14, 15},
.oobavail = 9,
- .oobfree = {{0, 4}, {6, 2}, {11, 2}, {4, 1}}
+ .oobfree = {{0, 4}, {6, 2}, {11, 2}, {4, 1} }
};
#endif
* Returns YAFFS_OK or YAFFS_FAIL.
*/
int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
- int nand_chunk, const u8 * data,
+ int nand_chunk, const u8 *data,
const struct yaffs_ext_tags *etags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
pt1.deleted = 0;
}
#else
- ((u8 *) & pt1)[8] = 0xff;
+ ((u8 *) &pt1)[8] = 0xff;
if (etags->is_deleted) {
memset(&pt1, 0xff, 8);
/* zero page_status byte to indicate deleted */
- ((u8 *) & pt1)[8] = 0;
+ ((u8 *) &pt1)[8] = 0;
}
#endif
ops.len = (data) ? chunk_bytes : 0;
ops.ooblen = YTAG1_SIZE;
ops.datbuf = (u8 *) data;
- ops.oobbuf = (u8 *) & pt1;
+ ops.oobbuf = (u8 *) &pt1;
retval = mtd->write_oob(mtd, addr, &ops);
if (retval) {
* Returns YAFFS_OK or YAFFS_FAIL.
*/
int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
- int nand_chunk, u8 * data,
+ int nand_chunk, u8 *data,
struct yaffs_ext_tags *etags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
ops.len = (data) ? chunk_bytes : 0;
ops.ooblen = YTAG1_SIZE;
ops.datbuf = data;
- ops.oobbuf = (u8 *) & pt1;
+ ops.oobbuf = (u8 *) &pt1;
#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20))
/* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
/* Check for a blank/erased chunk.
*/
- if (yaffs_check_ff((u8 *) & pt1, 8)) {
+ if (yaffs_check_ff((u8 *) &pt1, 8)) {
/* when blank, upper layers want ecc_result to be <= NO_ERROR */
return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
}
deleted = !pt1.deleted;
pt1.deleted = 1;
#else
- deleted = (hweight8(((u8 *) & pt1)[8]) < 7);
+ deleted = (hweight8(((u8 *) &pt1)[8]) < 7);
#endif
/* Check the packed tags mini-ECC and correct if necessary/possible.
#include "yaffs_packedtags1.h"
#include "yaffs_tagscompat.h" /* for yaffs_calc_tags_ecc */
#include "yaffs_linux.h"
-
#include "linux/kernel.h"
#include "linux/version.h"
#include "linux/types.h"
* Returns YAFFS_OK or YAFFS_FAIL.
*/
int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
- int nand_chunk, const u8 * data,
+ int nand_chunk, const u8 *data,
const struct yaffs_ext_tags *etags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
pt1.deleted = 0;
}
#else
- ((u8 *) & pt1)[8] = 0xff;
+ ((u8 *) &pt1)[8] = 0xff;
if (etags->is_deleted) {
memset(&pt1, 0xff, 8);
/* zero page_status byte to indicate deleted */
- ((u8 *) & pt1)[8] = 0;
+ ((u8 *) &pt1)[8] = 0;
}
#endif
ops.len = (data) ? chunk_bytes : 0;
ops.ooblen = YTAG1_SIZE;
ops.datbuf = (u8 *) data;
- ops.oobbuf = (u8 *) & pt1;
+ ops.oobbuf = (u8 *) &pt1;
retval = mtd->write_oob(mtd, addr, &ops);
if (retval) {
* Returns YAFFS_OK or YAFFS_FAIL.
*/
int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
- int nand_chunk, u8 * data,
+ int nand_chunk, u8 *data,
struct yaffs_ext_tags *etags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
ops.len = (data) ? chunk_bytes : 0;
ops.ooblen = YTAG1_SIZE;
ops.datbuf = data;
- ops.oobbuf = (u8 *) & pt1;
+ ops.oobbuf = (u8 *) &pt1;
/* Read page and oob using MTD.
* Check status and determine ECC result.
/* Check for a blank/erased chunk.
*/
- if (yaffs_check_ff((u8 *) & pt1, 8)) {
+ if (yaffs_check_ff((u8 *) &pt1, 8)) {
/* when blank, upper layers want ecc_result to be <= NO_ERROR */
return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
}
deleted = !pt1.deleted;
pt1.deleted = 1;
#else
- deleted = (hweight8(((u8 *) & pt1)[8]) < 7);
+ deleted = (hweight8(((u8 *) &pt1)[8]) < 7);
#endif
/* Check the packed tags mini-ECC and correct if necessary/possible.
#include "yaffs_guts.h"
int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- const u8 * data,
+ const u8 *data,
const struct yaffs_ext_tags *tags);
int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- u8 * data, struct yaffs_ext_tags *tags);
+ u8 *data, struct yaffs_ext_tags *tags);
int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no);
int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
- enum yaffs_block_state *state, u32 * seq_number);
+ enum yaffs_block_state *state, u32 *seq_number);
#endif
#include "yaffs_linux.h"
/* NB For use with inband tags....
- * We assume that the data buffer is of size total_bytes_per_chunk so that we can also
- * use it to load the tags.
+ * We assume that the data buffer is of size total_bytes_per_chunk so
+ * that we can also use it to load the tags.
*/
int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- const u8 * data,
+ const u8 *data,
const struct yaffs_ext_tags *tags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
struct yaffs_packed_tags2_tags_only *pt2tp;
pt2tp =
(struct yaffs_packed_tags2_tags_only *)(data +
- dev->
- data_bytes_per_chunk);
+ dev->
+ data_bytes_per_chunk);
yaffs_pack_tags2_tags_only(pt2tp, tags);
} else {
yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);
- }
+ }
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
ops.mode = MTD_OOB_AUTO;
}
int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- u8 * data, struct yaffs_ext_tags *tags)
+ u8 *data, struct yaffs_ext_tags *tags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
}
int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
- enum yaffs_block_state *state, u32 * seq_number)
+ enum yaffs_block_state *state, u32 *seq_number)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
int retval;
#include "yportenv.h"
#include "yaffs_trace.h"
-
#include "yaffs_mtdif2.h"
-
+#include "yaffs_packedtags2.h"
+#include "yaffs_linux.h"
#include "linux/mtd/mtd.h"
#include "linux/types.h"
#include "linux/time.h"
-#include "yaffs_packedtags2.h"
-
-#include "yaffs_linux.h"
/* NB For use with inband tags....
- * We assume that the data buffer is of size total_bytes_per_chunk so that we can also
- * use it to load the tags.
+ * We assume that the data buffer is of size total_bytes_per_chunk so that
+ * we can also use it to load the tags.
*/
int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- const u8 * data,
+ const u8 *data,
const struct yaffs_ext_tags *tags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
struct mtd_oob_ops ops;
int retval = 0;
-
loff_t addr;
-
struct yaffs_packed_tags2 pt;
-
int packed_tags_size =
dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
void *packed_tags_ptr =
BUG();
else if (dev->param.inband_tags) {
struct yaffs_packed_tags2_tags_only *pt2tp;
+
pt2tp =
(struct yaffs_packed_tags2_tags_only *)(data +
- dev->
- data_bytes_per_chunk);
+ dev->
+ data_bytes_per_chunk);
yaffs_pack_tags2_tags_only(pt2tp, tags);
} else {
yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);
- }
+ }
ops.mode = MTD_OOB_AUTO;
ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;
}
int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
- u8 * data, struct yaffs_ext_tags *tags)
+ u8 *data, struct yaffs_ext_tags *tags)
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
struct mtd_oob_ops ops;
-
size_t dummy;
int retval = 0;
int local_data = 0;
-
loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
-
struct yaffs_packed_tags2 pt;
-
int packed_tags_size =
dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
void *packed_tags_ptr =
local_data = 1;
data = yaffs_get_temp_buffer(dev, __LINE__);
}
-
}
if (dev->param.inband_tags || (data && !tags))
if (tags) {
struct yaffs_packed_tags2_tags_only *pt2tp;
pt2tp =
- (struct yaffs_packed_tags2_tags_only *)&data[dev->
- data_bytes_per_chunk];
+ (struct yaffs_packed_tags2_tags_only *)
+ &data[dev->data_bytes_per_chunk];
yaffs_unpack_tags2_tags_only(tags, pt2tp);
}
} else {
{
struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
int retval;
+
yaffs_trace(YAFFS_TRACE_MTD,
"nandmtd2_mark_block_bad %d", block_no);
return YAFFS_OK;
else
return YAFFS_FAIL;
-
}
int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
*/
/*
- * This simple implementation of a name-value store assumes a small number of values and fits
- * into a small finite buffer.
+ * This simple implementation of a name-value store assumes a small number of
+* values and fits into a small finite buffer.
*
* Each attribute is stored as a record:
* sizeof(int) bytes record size.
* strnlen+1 bytes name null terminated.
* nbytes value.
* ----------
- * total size stored in record size
+ * total size stored in record size
*
* This code has not been tested with unicode yet.
*/
#include "yportenv.h"
-static int nval_find(const char *xb, int xb_size, const YCHAR * name,
+static int nval_find(const char *xb, int xb_size, const YCHAR *name,
int *exist_size)
{
int pos = 0;
return pos;
}
-int nval_del(char *xb, int xb_size, const YCHAR * name)
+int nval_del(char *xb, int xb_size, const YCHAR *name)
{
int pos = nval_find(xb, xb_size, name, NULL);
int size;
if (pos >= 0 && pos < xb_size) {
- /* Find size, shift rest over this record, then zero out the rest of buffer */
+ /* Find size, shift rest over this record,
+ * then zero out the rest of buffer */
memcpy(&size, xb + pos, sizeof(int));
memcpy(xb + pos, xb + pos + size, xb_size - (pos + size));
memset(xb + (xb_size - size), 0, size);
return 0;
} else {
return -ENODATA;
- }
+ }
}
-int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
- int bsize, int flags)
+int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf,
+ int bsize, int flags)
{
int pos;
int namelen = strnlen(name, xb_size);
int filled = 0;
memcpy(&size, xb + pos, sizeof(int));
- while (size > sizeof(int) && size <= xb_size && (pos + size) < xb_size
- && !filled) {
+ while (size > sizeof(int) &&
+ size <= xb_size &&
+ (pos + size) < xb_size &&
+ !filled) {
pos += sizeof(int);
size -= sizeof(int);
name_len = strnlen((YCHAR *) (xb + pos), size);
ncopied += (name_len + 1);
} else {
filled = 1;
- }
+ }
pos += size;
if (pos < xb_size - sizeof(int))
memcpy(&size, xb + pos, sizeof(int));
#include "yaffs_getblockinfo.h"
int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
- u8 * buffer, struct yaffs_ext_tags *tags)
+ u8 *buffer, struct yaffs_ext_tags *tags)
{
int result;
struct yaffs_ext_tags local_tags;
-
int realigned_chunk = nand_chunk - dev->chunk_offset;
dev->n_page_reads++;
- /* If there are no tags provided, use local tags to get prioritised gc working */
+ /* If there are no tags provided use local tags. */
if (!tags)
tags = &local_tags;
dev->param.chunks_per_block);
yaffs_handle_chunk_error(dev, bi);
}
-
return result;
}
int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
- int nand_chunk,
- const u8 * buffer, struct yaffs_ext_tags *tags)
+ int nand_chunk,
+ const u8 *buffer, struct yaffs_ext_tags *tags)
{
-
dev->n_page_writes++;
-
nand_chunk -= dev->chunk_offset;
if (tags) {
tags->seq_number = dev->seq_number;
tags->chunk_used = 1;
if (!yaffs_validate_tags(tags)) {
- yaffs_trace(YAFFS_TRACE_ERROR, "Writing uninitialised tags");
+ yaffs_trace(YAFFS_TRACE_ERROR,
+ "Writing uninitialised tags");
YBUG();
}
yaffs_trace(YAFFS_TRACE_WRITE,
if (dev->param.write_chunk_tags_fn)
return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer,
- tags);
+ tags);
else
return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags);
}
int yaffs_mark_bad(struct yaffs_dev *dev, int block_no)
{
block_no -= dev->block_offset;
-
if (dev->param.bad_block_fn)
return dev->param.bad_block_fn(dev, block_no);
else
int yaffs_query_init_block_state(struct yaffs_dev *dev,
int block_no,
enum yaffs_block_state *state,
- u32 * seq_number)
+ u32 *seq_number)
{
block_no -= dev->block_offset;
-
if (dev->param.query_block_fn)
return dev->param.query_block_fn(dev, block_no, state,
seq_number);
int result;
flash_block -= dev->block_offset;
-
dev->n_erasures++;
-
result = dev->param.erase_fn(dev, flash_block);
-
return result;
}
#include "yaffs_guts.h"
int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
- u8 * buffer, struct yaffs_ext_tags *tags);
+ u8 *buffer, struct yaffs_ext_tags *tags);
int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
int nand_chunk,
- const u8 * buffer, struct yaffs_ext_tags *tags);
+ const u8 *buffer, struct yaffs_ext_tags *tags);
int yaffs_mark_bad(struct yaffs_dev *dev, int block_no);
pt->deleted = (t->is_deleted) ? 0 : 1;
pt->unused_stuff = 0;
pt->should_be_ff = 0xFFFFFFFF;
-
}
void yaffs_unpack_tags1(struct yaffs_ext_tags *t,
const struct yaffs_packed_tags1 *pt)
{
- static const u8 all_ff[] =
- { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff
+ static const u8 all_ff[12] = {
+ 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff
};
if (memcmp(all_ff, pt, sizeof(struct yaffs_packed_tags1))) {
#define EXTRA_OBJECT_TYPE_SHIFT (28)
#define EXTRA_OBJECT_TYPE_MASK ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
-static void yaffs_dump_packed_tags2_tags_only(const struct
- yaffs_packed_tags2_tags_only *ptt)
+static void yaffs_dump_packed_tags2_tags_only(
+ const struct yaffs_packed_tags2_tags_only *ptt)
{
yaffs_trace(YAFFS_TRACE_MTD,
"packed tags obj %d chunk %d byte %d seq %d",
void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t,
struct yaffs_packed_tags2_tags_only *ptt)
{
-
memset(t, 0, sizeof(struct yaffs_ext_tags));
-
yaffs_init_tags(t);
if (ptt->seq_number != 0xFFFFFFFF) {
t->seq_number = ptt->seq_number;
/* Do extra header info stuff */
-
if (ptt->chunk_id & EXTRA_HEADER_INFO_FLAG) {
t->chunk_id = 0;
t->n_bytes = 0;
t->extra_length = ptt->n_bytes;
}
}
-
yaffs_dump_packed_tags2_tags_only(ptt);
yaffs_dump_tags2(t);
-
}
void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt,
int tags_ecc)
{
-
enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
if (pt->t.seq_number != 0xFFFFFFFF && tags_ecc) {
struct yaffs_ecc_other ecc;
int result;
yaffs_ecc_calc_other((unsigned char *)&pt->t,
- sizeof(struct
- yaffs_packed_tags2_tags_only),
- &ecc);
+ sizeof(struct yaffs_packed_tags2_tags_only),
+ &ecc);
result =
yaffs_ecc_correct_other((unsigned char *)&pt->t,
- sizeof(struct
- yaffs_packed_tags2_tags_only),
- &pt->ecc, &ecc);
+ sizeof(struct yaffs_packed_tags2_tags_only),
+ &pt->ecc, &ecc);
switch (result) {
case 0:
ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
}
}
-
yaffs_unpack_tags2_tags_only(t, &pt->t);
t->ecc_result = ecc_result;
/********** Tags ECC calculations *********/
-void yaffs_calc_ecc(const u8 * data, struct yaffs_spare *spare)
+void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
{
yaffs_ecc_cacl(data, spare->ecc1);
yaffs_ecc_cacl(&data[256], spare->ecc2);
void yaffs_calc_tags_ecc(struct yaffs_tags *tags)
{
/* Calculate an ecc */
-
unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes;
unsigned i, j;
unsigned ecc = 0;
ecc ^= bit;
}
}
-
tags->ecc = ecc;
-
}
int yaffs_check_tags_ecc(struct yaffs_tags *tags)
/* TODO Need to do somethiong here */
return -1; /* unrecovered error */
}
-
return 0;
}
}
static int yaffs_wr_nand(struct yaffs_dev *dev,
- int nand_chunk, const u8 * data,
+ int nand_chunk, const u8 *data,
struct yaffs_spare *spare)
{
if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
int nand_chunk,
- u8 * data,
+ u8 *data,
struct yaffs_spare *spare,
enum yaffs_ecc_result *ecc_result,
int correct_errors)
int flash_block = nand_chunk / dev->param.chunks_per_block;
/* Mark the block for retirement */
- yaffs_get_block_info(dev,
- flash_block + dev->block_offset)->needs_retiring =
- 1;
+ yaffs_get_block_info(dev, flash_block + dev->block_offset)->
+ needs_retiring = 1;
yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
"**>>Block %d marked for retirement",
flash_block);
int yaffs_tags_compat_wr(struct yaffs_dev *dev,
int nand_chunk,
- const u8 * data, const struct yaffs_ext_tags *ext_tags)
+ const u8 *data, const struct yaffs_ext_tags *ext_tags)
{
struct yaffs_spare spare;
struct yaffs_tags tags;
yaffs_spare_init(&spare);
-
+
if (ext_tags->is_deleted)
spare.page_status = 0;
else {
int yaffs_tags_compat_rd(struct yaffs_dev *dev,
int nand_chunk,
- u8 * data, struct yaffs_ext_tags *ext_tags)
+ u8 *data, struct yaffs_ext_tags *ext_tags)
{
-
struct yaffs_spare spare;
struct yaffs_tags tags;
enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
-
static struct yaffs_spare spare_ff;
static int init;
init = 1;
}
- if (yaffs_rd_chunk_nand(dev, nand_chunk, data, &spare, &ecc_result, 1)) {
+ if (yaffs_rd_chunk_nand(dev, nand_chunk,
+ data, &spare, &ecc_result, 1)) {
/* ext_tags may be NULL */
if (ext_tags) {
int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block)
{
-
struct yaffs_spare spare;
memset(&spare, 0xff, sizeof(struct yaffs_spare));
NULL, &spare);
return YAFFS_OK;
-
}
int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
int block_no,
enum yaffs_block_state *state,
- u32 * seq_number)
+ u32 *seq_number)
{
-
struct yaffs_spare spare0, spare1;
static struct yaffs_spare spare_ff;
static int init;
#include "yaffs_guts.h"
int yaffs_tags_compat_wr(struct yaffs_dev *dev,
int nand_chunk,
- const u8 * data, const struct yaffs_ext_tags *tags);
+ const u8 *data, const struct yaffs_ext_tags *tags);
int yaffs_tags_compat_rd(struct yaffs_dev *dev,
int nand_chunk,
- u8 * data, struct yaffs_ext_tags *tags);
+ u8 *data, struct yaffs_ext_tags *tags);
int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no);
int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
int block_no,
enum yaffs_block_state *state,
- u32 * seq_number);
+ u32 *seq_number);
void yaffs_calc_tags_ecc(struct yaffs_tags *tags);
int yaffs_check_tags_ecc(struct yaffs_tags *tags);
int yaffs_validate_tags(struct yaffs_ext_tags *tags)
{
return (tags->validity0 == 0xAAAAAAAA && tags->validity1 == 0x55555555);
-
}
return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));
}
-static const char *block_state_name[] = {
+static const char * const block_state_name[] = {
"Unknown",
"Needs scanning",
"Scanning",
yaffs_trace(YAFFS_TRACE_VERIFY,
"Block %d has inconsistent values pages_in_use %d counted chunk bits %d",
n, bi->pages_in_use, in_use);
-
}
void yaffs_verify_collected_blk(struct yaffs_dev *dev,
"Obj %d header name is NULL",
obj->obj_id);
- if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff) /* Trashed name */
+ if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff) /* Junk name */
yaffs_trace(YAFFS_TRACE_VERIFY,
"Obj %d header name is 0xFF",
obj->obj_id);
yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL,
&tags);
if (tags.obj_id != obj_id || tags.chunk_id != i)
- yaffs_trace(YAFFS_TRACE_VERIFY,
- "Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)",
- obj_id, i, the_chunk,
- tags.obj_id, tags.chunk_id);
+ yaffs_trace(YAFFS_TRACE_VERIFY,
+ "Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)",
+ obj_id, i, the_chunk,
+ tags.obj_id, tags.chunk_id);
}
}
}
void yaffs_verify_obj(struct yaffs_obj *obj)
{
struct yaffs_dev *dev;
-
u32 chunk_min;
u32 chunk_max;
-
u32 chunk_id_ok;
u32 chunk_in_range;
u32 chunk_wrongly_deleted;
for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
list_for_each(lh, &dev->obj_bucket[i].list) {
- obj = list_entry(lh, struct yaffs_obj, hash_link);
+ obj = list_entry(lh, struct yaffs_obj, hash_link);
yaffs_verify_obj(obj);
}
}
{
struct list_head *lh;
struct yaffs_obj *list_obj;
-
int count = 0;
if (!obj) {
return;
if (!obj->parent) {
- yaffs_trace(YAFFS_TRACE_ALWAYS, "Object does not have parent" );
+ yaffs_trace(YAFFS_TRACE_ALWAYS, "Object does not have parent");
YBUG();
return;
}
if (difference) {
yaffs_trace(YAFFS_TRACE_ALWAYS,
- "Freechunks verification failure %d %d %d",
+ "Freechunks verification failure %d %d %d",
dev->n_free_chunks, counted, difference);
yaffs_free_verification_failures++;
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 10))
#define YAFFS_COMPILE_BACKGROUND
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6, 23))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23))
#define YAFFS_COMPILE_FREEZER
#endif
#endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28))
#define YAFFS_COMPILE_EXPORTFS
#endif
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
#define YAFFS_USE_SETATTR_COPY
#define YAFFS_USE_TRUNCATE_SETSIZE
#endif
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
#define YAFFS_HAS_EVICT_INODE
#endif
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
#define YAFFS_NEW_FOLLOW_LINK 1
#else
#define YAFFS_NEW_FOLLOW_LINK 0
#define YPROC_ROOT NULL
#endif
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26))
#define Y_INIT_TIMER(a) init_timer(a)
#else
#define Y_INIT_TIMER(a) init_timer_on_stack(a)
#define yaffs_inode_to_obj_lv(iptr) ((iptr)->u.generic_ip)
#endif
-#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
+#define yaffs_inode_to_obj(iptr) \
+ ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
#define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
#define update_dir_time(dir) do {\
(dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
- } while(0)
+ } while (0)
static void yaffs_put_super(struct super_block *sb);
static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
- loff_t * pos);
+ loff_t *pos);
static ssize_t yaffs_hold_space(struct file *f);
static void yaffs_release_space(struct file *f);
#ifdef CONFIG_YAFFS_XATTR
static int yaffs_setxattr(struct dentry *dentry, const char *name,
const void *value, size_t size, int flags);
-static ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
- size_t size);
+static ssize_t yaffs_getxattr(struct dentry *dentry, const char *name,
+ void *buff, size_t size);
static int yaffs_removexattr(struct dentry *dentry, const char *name);
static ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size);
#endif
};
#endif
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25))
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25))
static void zero_user_segment(struct page *page, unsigned start, unsigned end)
{
void *kaddr = kmap_atomic(page, KM_USER0);
static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr)
{
-#ifdef YAFFS_USE_SETATTR_COPY
+#ifdef YAFFS_USE_SETATTR_COPY
setattr_copy(inode, attr);
return 0;
#else
static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)
{
-#ifdef YAFFS_USE_TRUNCATE_SETSIZE
+#ifdef YAFFS_USE_TRUNCATE_SETSIZE
truncate_setsize(inode, newsize);
return 0;
#else
if (current != yaffs_dev_to_lc(dev)->readdir_process)
yaffs_gross_lock(dev);
- yaffs_trace(YAFFS_TRACE_OS,"yaffs_lookup for %d:%s",
+ yaffs_trace(YAFFS_TRACE_OS, "yaffs_lookup for %d:%s",
yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name);
obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);
* yaffs_bg_start() launches the background thread.
* yaffs_bg_stop() cleans up the background thread.
*
- * NB:
+ * NB:
* The thread should only run after the yaffs is initialised
* The thread should be stopped before yaffs is unmounted.
* The thread should not do any writing while the fs is in read only.
param->read_chunk_tags_fn = nandmtd2_read_chunk_tags;
param->bad_block_fn = nandmtd2_mark_block_bad;
param->query_block_fn = nandmtd2_query_block;
- yaffs_dev_to_lc(dev)->spare_buffer =
+ yaffs_dev_to_lc(dev)->spare_buffer =
kmalloc(mtd->oobsize, GFP_NOFS);
param->is_yaffs2 = 1;
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
err = yaffs_guts_initialise(dev);
- yaffs_trace(YAFFS_TRACE_OS,
+ yaffs_trace(YAFFS_TRACE_OS,
"yaffs_read_super: guts initialised %s",
(err == YAFFS_OK) ? "OK" : "FAILED");
* a single version and should not include any multi-version code.
*/
#include <linux/version.h>
-
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/freezer.h>
-
#include <asm/div64.h>
-
#include <linux/statfs.h>
-
-#define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf)
-
-#define YPROC_ROOT NULL
-
-#define Y_INIT_TIMER(a) init_timer_on_stack(a)
-
-#define WRITE_SIZE_STR "writesize"
-#define WRITE_SIZE(mtd) ((mtd)->writesize)
-
-static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
-{
- uint64_t result = partition_size;
- do_div(result, block_size);
- return (uint32_t) result;
-}
-
#include <linux/uaccess.h>
#include <linux/mtd/mtd.h>
#include "yaffs_trace.h"
#include "yaffs_guts.h"
#include "yaffs_attribs.h"
-
#include "yaffs_linux.h"
-
#include "yaffs_mtdif.h"
#include "yaffs_mtdif1.h"
#include "yaffs_mtdif2.h"
module_param(yaffs_gc_control, uint, 0644);
module_param(yaffs_bg_enable, uint, 0644);
+#define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf)
+
+static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
+{
+ uint64_t result = partition_size;
+
+ do_div(result, block_size);
+ return (uint32_t) result;
+}
#define yaffs_inode_to_obj_lv(iptr) ((iptr)->i_private)
-#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
+#define yaffs_inode_to_obj(iptr)\
+ ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
#define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info)
#define update_dir_time(dir) do {\
(dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \
- } while(0)
+ } while (0)
static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
yaffs_gross_lock(dev);
obj = yaffs_find_by_number(dev, inode->i_ino);
-
yaffs_fill_inode_from_obj(inode, obj);
yaffs_gross_unlock(dev);
dev_t rdev)
{
struct inode *inode;
-
struct yaffs_obj *obj = NULL;
struct yaffs_dev *dev;
-
struct yaffs_obj *parent = yaffs_inode_to_obj(dir);
-
int error = -ENOSPC;
uid_t uid = current->cred->fsuid;
gid_t gid =
{
struct yaffs_obj *obj;
struct inode *inode = NULL;
-
struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
if (current != yaffs_dev_to_lc(dev)->readdir_process)
static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
{
int ret_val;
-
struct yaffs_dev *dev;
struct yaffs_obj *obj;
}
yaffs_gross_lock(dev);
result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr);
- if (result == YAFFS_OK) {
+ if (result == YAFFS_OK)
error = 0;
- } else {
+ else
error = -EPERM;
- }
yaffs_gross_unlock(dev);
-
}
yaffs_trace(YAFFS_TRACE_OS, "yaffs_setattr done returning %d", error);
else if (result < 0)
error = result;
yaffs_gross_unlock(dev);
-
}
yaffs_trace(YAFFS_TRACE_OS, "yaffs_setxattr done returning %d", error);
return error;
}
-static ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff,
- size_t size)
+static ssize_t yaffs_getxattr(struct dentry *dentry, const char *name,
+ void *buff, size_t size)
{
struct inode *inode = dentry->d_inode;
int error = 0;
yaffs_gross_lock(dev);
error = yaffs_get_xattrib(obj, name, buff, size);
yaffs_gross_unlock(dev);
-
}
yaffs_trace(YAFFS_TRACE_OS, "yaffs_getxattr done returning %d", error);
else if (result < 0)
error = result;
yaffs_gross_unlock(dev);
-
}
yaffs_trace(YAFFS_TRACE_OS,
"yaffs_removexattr done returning %d", error);
return error;
}
-static ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size)
+static ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
{
struct inode *inode = dentry->d_inode;
int error = 0;
yaffs_gross_lock(dev);
error = yaffs_list_xattrib(obj, buff, size);
yaffs_gross_unlock(dev);
-
}
yaffs_trace(YAFFS_TRACE_OS,
"yaffs_listxattr done returning %d", error);
struct yaffs_dev *dev = dir->my_dev;
struct yaffs_search_context *sc =
kmalloc(sizeof(struct yaffs_search_context), GFP_NOFS);
+
if (sc) {
sc->dir_obj = dir;
sc->dev = dev;
unsigned long offset, curoffs;
struct yaffs_obj *l;
int ret_val = 0;
-
char name[YAFFS_MAX_NAME_LENGTH + 1];
obj = yaffs_dentry_to_obj(f->f_dentry);
static int yaffs_file_flush(struct file *file, fl_owner_t id)
{
struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);
-
struct yaffs_dev *dev = obj->my_dev;
yaffs_trace(YAFFS_TRACE_OS,
- "yaffs_file_flush object %d (%s)",
+ "yaffs_file_flush object %d (%s)",
obj->obj_id, obj->dirty ? "dirty" : "clean");
yaffs_gross_lock(dev);
}
}
}
-
return parent;
}
{
unsigned char *alias;
int ret;
-
struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
yaffs_gross_lock(dev);
struct yaffs_obj *obj;
unsigned char *pg_buf;
int ret;
-
struct yaffs_dev *dev;
yaffs_trace(YAFFS_TRACE_OS,
static int yaffs_readpage_unlock(struct file *f, struct page *pg)
{
int ret = yaffs_readpage_nolock(f, pg);
+
unlock_page(pg);
return ret;
}
return (n_written == n_bytes) ? 0 : -ENOSPC;
}
-/* Space holding and freeing is done to ensure we have space available for
+/* Space holding and freeing is done to ensure we have space available for
* write_begin/end.
* For now we just assume few parallel writes and check against a small
* number.
- * Todo: need to do this with a counter to handle parallel reads better.
+ * Todo: need to do this with a counter to handle parallel reads better
*/
static ssize_t yaffs_hold_space(struct file *f)
{
struct yaffs_obj *obj;
struct yaffs_dev *dev;
-
int n_free_chunks;
obj = yaffs_dentry_to_obj(f->f_dentry);
{
struct page *pg = NULL;
pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-
int ret = 0;
int space_held = 0;
}
static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
- loff_t * pos)
+ loff_t *pos)
{
struct yaffs_obj *obj;
int n_written, ipos;
obj = yaffs_dentry_to_obj(f->f_dentry);
if (!obj) {
- /* This should not happen */
+ /* This should not happen */
yaffs_trace(YAFFS_TRACE_OS,
"yaffs_file_write: hey obj is null!");
- return -ENINVAL;
- }
+ return -ENINVAL;
+ }
dev = obj->my_dev;
"yaffs_file_write size updated to %d bytes, %d blocks",
ipos, (int)(inode->i_blocks));
}
-
}
yaffs_gross_unlock(dev);
return (n_written == 0) && (n > 0) ? -ENOSPC : n_written;
1))) * ((uint64_t) (dev->param.chunks_per_block *
dev->data_bytes_per_chunk));
- do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */
+ do_div(bytes_in_dev, sb->s_blocksize);
+ /* bytes_in_dev becomes the number of blocks */
buf->f_blocks = bytes_in_dev;
bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) *
static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
{
struct yaffs_dev *dev = yaffs_super_to_dev(sb);
+
if (!dev)
return;
* yaffs_bg_start() launches the background thread.
* yaffs_bg_stop() cleans up the background thread.
*
- * NB:
+ * NB:
* The thread should only run after the yaffs is initialised
* The thread should be stopped before yaffs is unmounted.
* The thread should not do any writing while the fs is in read only.
unsigned long next_gc = now;
unsigned long expires;
unsigned int urgency;
-
int gc_result;
struct timer_list timer;
else
next_gc = now + HZ * 2;
} else {
- /*
+ /*
* gc not running so set to next_dir_update
* to cut down on wake ups
*/
next_gc = next_dir_update;
- }
+ }
}
yaffs_gross_unlock(dev);
expires = next_dir_update;
if (time_before(expires, now))
expires = now + HZ;
- Y_INIT_TIMER(&timer);
+ init_timer_on_stack(&timer);
timer.expires = expires + 1;
timer.data = (unsigned long)current;
timer.function = yaffs_background_waker;
return 0;
}
-
static LIST_HEAD(yaffs_context_list);
struct mutex yaffs_context_lock;
-
-
struct yaffs_options {
int inband_tags;
int skip_checkpoint_read;
#define MAX_OPT_LEN 30
static int yaffs_parse_options(struct yaffs_options *options,
- const char *options_str)
+ const char *options_str)
{
char cur_opt[MAX_OPT_LEN + 1];
int p;
error = 1;
}
}
-
return error;
}
-static struct address_space_operations yaffs_file_address_operations = {
+static const struct address_space_operations yaffs_file_address_operations = {
.readpage = yaffs_readpage,
.writepage = yaffs_writepage,
.write_begin = yaffs_write_begin,
struct yaffs_obj *obj)
{
if (inode && obj) {
-
- /* Check mode against the variant type and attempt to repair if broken. */
+ /* Check mode against the variant type
+ * and attempt to repair if broken. */
u32 mode = obj->yst_mode;
switch (obj->variant_type) {
case YAFFS_OBJECT_TYPE_FILE:
}
yaffs_inode_to_obj_lv(inode) = obj;
-
obj->my_inode = inode;
} else {
char *data_str = (char *)data;
struct yaffs_linux_context *context = NULL;
struct yaffs_param *param;
-
int read_only = 0;
-
struct yaffs_options options;
-
unsigned mount_id;
int found;
struct yaffs_linux_context *context_iterator;
if (!sb) {
printk(KERN_INFO "yaffs: sb is NULL\n");
return NULL;
- }
+ }
sb->s_magic = YAFFS_MAGIC;
sb->s_op = &yaffs_super_ops;
yaffs_trace(YAFFS_TRACE_OS, " writeoob %p", mtd->write_oob);
yaffs_trace(YAFFS_TRACE_OS, " block_isbad %p", mtd->block_isbad);
yaffs_trace(YAFFS_TRACE_OS, " block_markbad %p", mtd->block_markbad);
- yaffs_trace(YAFFS_TRACE_OS, " %s %d", WRITE_SIZE_STR, WRITE_SIZE(mtd));
+ yaffs_trace(YAFFS_TRACE_OS, " write_size %d", mtd->write_size);
yaffs_trace(YAFFS_TRACE_OS, " oobsize %d", mtd->oobsize);
yaffs_trace(YAFFS_TRACE_OS, " erasesize %d", mtd->erasesize);
yaffs_trace(YAFFS_TRACE_OS, " size %lld", mtd->size);
#ifdef CONFIG_YAFFS_AUTO_YAFFS2
- if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
+ if (yaffs_version == 1 && mtd->write_size >= 2048) {
yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs2");
yaffs_version = 2;
}
/* Added NCB 26/5/2006 for completeness */
- if (yaffs_version == 2 && !options.inband_tags
- && WRITE_SIZE(mtd) == 512) {
+ if (yaffs_version == 2 && !options.inband_tags &&
+ mtd->write_size == 512) {
yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs1");
yaffs_version = 1;
}
return NULL;
}
- if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
+ if ((mtd->write_size < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
!options.inband_tags) {
yaffs_trace(YAFFS_TRACE_ALWAYS,
return NULL;
}
- if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK ||
+ if (mtd->write_size < YAFFS_BYTES_PER_CHUNK ||
mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
yaffs_trace(YAFFS_TRACE_ALWAYS,
"MTD device does not support have the right page sizes");
context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL);
if (!dev || !context) {
- if (dev)
- kfree(dev);
- if (context)
- kfree(context);
+ kfree(dev);
+ kfree(context);
dev = NULL;
context = NULL;
}
param->read_chunk_tags_fn = nandmtd2_read_chunk_tags;
param->bad_block_fn = nandmtd2_mark_block_bad;
param->query_block_fn = nandmtd2_query_block;
- yaffs_dev_to_lc(dev)->spare_buffer =
- kmalloc(mtd->oobsize, GFP_NOFS);
+ yaffs_dev_to_lc(dev)->spare_buffer =
+ kmalloc(mtd->oobsize, GFP_NOFS);
param->is_yaffs2 = 1;
param->total_bytes_per_chunk = mtd->writesize;
param->chunks_per_block = mtd->erasesize / mtd->writesize;
found = 1;
list_for_each(l, &yaffs_context_list) {
context_iterator =
- list_entry(l, struct yaffs_linux_context,
- context_list);
+ list_entry(l, struct yaffs_linux_context,
+ context_list);
if (context_iterator->mount_id == mount_id)
found = 0;
}
static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
{
struct yaffs_param *param = &dev->param;
+
buf += sprintf(buf, "start_block........... %d\n", param->start_block);
buf += sprintf(buf, "end_block............. %d\n", param->end_block);
buf += sprintf(buf, "total_bytes_per_chunk. %d\n",
mutex_lock(&yaffs_context_lock);
- /* Locate and print the Nth entry. Order N-squared but N is small. */
+ /* Locate and print the Nth entry.
+ * Order N-squared but N is small. */
list_for_each(item, &yaffs_context_list) {
struct yaffs_linux_context *dc =
list_entry(item, struct yaffs_linux_context,
buf = yaffs_dump_dev_part0(buf, dev);
} else {
buf = yaffs_dump_dev_part1(buf, dev);
- }
+ }
break;
}
char *mask_name;
unsigned mask_bitfield;
} mask_flags[] = {
- {"allocate", YAFFS_TRACE_ALLOCATE},
+ {"allocate", YAFFS_TRACE_ALLOCATE},
{"always", YAFFS_TRACE_ALWAYS},
{"background", YAFFS_TRACE_BACKGROUND},
{"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
/* Install the proc_fs entries */
my_proc_entry = create_proc_entry("yaffs",
- S_IRUGO | S_IFREG, YPROC_ROOT);
+ S_IRUGO | S_IFREG, NULL);
if (my_proc_entry) {
my_proc_entry->write_proc = yaffs_proc_write;
my_proc_entry->data = NULL;
} else {
return -ENOMEM;
- }
+ }
/* Now add the file system entries */
yaffs_trace(YAFFS_TRACE_ALWAYS,
"yaffs built " __DATE__ " " __TIME__ " removing.");
- remove_proc_entry("yaffs", YPROC_ROOT);
+ remove_proc_entry("yaffs", NULL);
fsinst = fs_to_install;
}
module_init(init_yaffs_fs)
- module_exit(exit_yaffs_fs)
+module_exit(exit_yaffs_fs)
- MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
+MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010");
MODULE_LICENSE("GPL");
struct yaffs_ext_tags tags;
int blk;
int result;
-
int chunk;
int c;
int deleted;
struct yaffs_obj_hdr *oh;
struct yaffs_obj *in;
struct yaffs_obj *parent;
-
int alloc_failed = 0;
-
struct yaffs_shadow_fixer *shadow_fixers = NULL;
-
u8 *chunk_data;
yaffs_trace(YAFFS_TRACE_SCAN,
*/
if (c == 0) {
- /* We're looking at the first chunk in the block so the block is unused */
+ /* We're looking at the first chunk in
+ *the block so the block is unused */
state = YAFFS_BLOCK_STATE_EMPTY;
dev->n_erased_blocks++;
} else {
- /* this is the block being allocated from */
+ /* this is the block being allocated */
yaffs_trace(YAFFS_TRACE_SCAN,
" Allocating from %d %d",
blk, c);
dev->alloc_block = blk;
dev->alloc_page = c;
dev->alloc_block_finder = blk;
- /* Set block finder here to encourage the allocator to go forth from here. */
}
bi->pages_in_use++;
in = yaffs_find_or_create_by_number(dev,
- tags.obj_id,
- YAFFS_OBJECT_TYPE_FILE);
- /* PutChunkIntoFile checks for a clash (two data chunks with
- * the same chunk_id).
+ tags.obj_id,
+ YAFFS_OBJECT_TYPE_FILE);
+ /* PutChunkIntoFile checks for a clash
+ * (two data chunks with the same chunk_id).
*/
if (!in)
}
endpos =
- (tags.chunk_id -
- 1) * dev->data_bytes_per_chunk +
+ (tags.chunk_id - 1) *
+ dev->data_bytes_per_chunk +
tags.n_bytes;
- if (in
- && in->variant_type ==
- YAFFS_OBJECT_TYPE_FILE
- && in->variant.file_variant.scanned_size <
+ if (in &&
+ in->variant_type ==
+ YAFFS_OBJECT_TYPE_FILE &&
+ in->variant.file_variant.scanned_size <
endpos) {
in->variant.file_variant.scanned_size =
endpos;
}
} else {
/* chunk_id == 0, so it is an ObjectHeader.
- * Thus, we read in the object header and make the object
+ * Make the object
*/
yaffs_set_chunk_bit(dev, blk, c);
bi->pages_in_use++;
in = yaffs_find_by_number(dev, tags.obj_id);
if (in && in->variant_type != oh->type) {
/* This should not happen, but somehow
- * Wev'e ended up with an obj_id that has been reused but not yet
- * deleted, and worse still it has changed type. Delete the old object.
+ * Wev'e ended up with an obj_id that
+ * has been reused but not yet deleted,
+ * and worse still it has changed type.
+ * Delete the old object.
*/
yaffs_del_obj(in);
-
- in = 0;
+ in = NULL;
}
in = yaffs_find_or_create_by_number(dev,
- tags.obj_id,
- oh->type);
+ tags.obj_id,
+ oh->type);
if (!in)
alloc_failed = 1;
}
if (in && in->valid) {
- /* We have already filled this one. We have a duplicate and need to resolve it. */
+ /* We have already filled this one.
+ * We have a duplicate and need to
+ * resolve it. */
unsigned existing_serial = in->serial;
unsigned new_serial =
if (((existing_serial + 1) & 3) ==
new_serial) {
- /* Use new one - destroy the exisiting one */
+ /* Use new one - destroy the
+ * exisiting one */
yaffs_chunk_del(dev,
in->hdr_chunk,
1, __LINE__);
in->valid = 0;
} else {
- /* Use existing - destroy this one. */
+ /* Use existing - destroy
+ * this one. */
yaffs_chunk_del(dev, chunk, 1,
__LINE__);
}
(tags.obj_id == YAFFS_OBJECTID_ROOT ||
tags.obj_id ==
YAFFS_OBJECTID_LOSTNFOUND)) {
- /* We only load some info, don't fiddle with directory structure */
+ /* We only load some info, don't fiddle
+ * with directory structure */
in->valid = 1;
in->variant_type = oh->type;
parent->variant_type =
YAFFS_OBJECT_TYPE_DIRECTORY;
INIT_LIST_HEAD(&parent->
- variant.dir_variant.children);
- } else if (!parent
- || parent->variant_type !=
- YAFFS_OBJECT_TYPE_DIRECTORY) {
- /* Hoosterman, another problem....
- * We're trying to use a non-directory as a directory
+ variant.dir_variant.
+ children);
+ } else if (!parent ||
+ parent->variant_type !=
+ YAFFS_OBJECT_TYPE_DIRECTORY) {
+ /* Hoosterman, a problem....
+ * We're trying to use a
+ * non-directory as a directory
*/
yaffs_trace(YAFFS_TRACE_ERROR,
yaffs_add_obj_to_dir(parent, in);
- if (0 && (parent == dev->del_dir ||
- parent ==
- dev->unlinked_dir)) {
- in->deleted = 1; /* If it is unlinked at start up then it wants deleting */
- dev->n_deleted_files++;
- }
- /* Note re hardlinks.
- * Since we might scan a hardlink before its equivalent object is scanned
- * we put them all in a list.
- * After scanning is complete, we should have all the objects, so we run through this
- * list and fix up all the chains.
- */
-
switch (in->variant_type) {
case YAFFS_OBJECT_TYPE_UNKNOWN:
/* Todo got a problem */
use_header_file_size)
in->variant.
- file_variant.file_size
+ file_variant.file_size
= oh->file_size;
break;
alloc_failed = 1;
break;
}
-
}
}
}
if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
- /* If we got this far while scanning, then the block is fully allocated. */
+ /* If we got this far while scanning,
+ * then the block is fully allocated. */
state = YAFFS_BLOCK_STATE_FULL;
}
if (state == YAFFS_BLOCK_STATE_ALLOCATING) {
- /* If the block was partially allocated then treat it as fully allocated. */
+ /* If the block was partially allocated then
+ * treat it as fully allocated. */
state = YAFFS_BLOCK_STATE_FULL;
dev->alloc_block = -1;
}
bi->block_state == YAFFS_BLOCK_STATE_FULL) {
yaffs_block_became_dirty(dev, blk);
}
-
}
/* Ok, we've done all the scanning.
* Fix up the hard link chains.
- * We should now have scanned all the objects, now it's time to add these
- * hardlinks.
+ * We should now have scanned all the objects, now it's time to add
+ * these hardlinks.
*/
yaffs_link_fixup(dev, hard_list);
while (shadow_fixers) {
fixer = shadow_fixers;
shadow_fixers = fixer->next;
- /* Complete the rename transaction by deleting the shadowed object
- * then setting the object header to unshadowed.
+ /* Complete the rename transaction by deleting the
+ * shadowed object then setting the object header
+ to unshadowed.
*/
obj = yaffs_find_by_number(dev, fixer->shadowed_id);
if (obj)
* the partition is at least this big.
*/
#define YAFFS_CHECKPOINT_MIN_BLOCKS 60
-
#define YAFFS_SMALL_HOLE_THRESHOLD 4
/*
dev->oldest_dirty_seq = seq;
dev->oldest_dirty_block = block_no;
}
-
}
void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
/*
* yaffs_clear_oldest_dirty_seq()
* Called when a block is erased or marked bad. (ie. when its seq_number
- * becomes invalid). If the value matches the oldest then we clear
+ * becomes invalid). If the value matches the oldest then we clear
* dev->oldest_dirty_seq to force its recomputation.
*/
void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev,
yaffs2_find_oldest_dirty_seq(dev);
- /* Can't do gc of this block if there are any blocks older than this one that have
- * discarded pages.
+ /* Can't do gc of this block if there are any blocks older than this
+ * one that have discarded pages.
*/
return (bi->seq_number <= dev->oldest_dirty_seq);
}
* periodically finds the oldest full block by sequence number for refreshing.
* Only for yaffs2.
*/
-u32 yaffs2_find_refresh_block(struct yaffs_dev * dev)
+u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
{
u32 b;
-
u32 oldest = 0;
u32 oldest_seq = 0;
-
struct yaffs_block_info *bi;
if (!dev->param.is_yaffs2)
n_bytes += dev_blocks * sizeof(struct yaffs_block_info);
n_bytes += dev_blocks * dev->chunk_bit_stride;
n_bytes +=
- (sizeof(struct yaffs_checkpt_obj) +
- sizeof(u32)) * (dev->n_obj);
- n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes);
+ (sizeof(struct yaffs_checkpt_obj) + sizeof(u32)) *
+ dev->n_obj;
+ n_bytes += (dev->tnode_size + sizeof(u32)) * dev->n_tnodes;
n_bytes += sizeof(struct yaffs_checkpt_validity);
n_bytes += sizeof(u32); /* checksum */
- /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
+ /* Round up and add 2 blocks to allow for some bad blocks,
+ * so add 3 */
n_blocks =
(n_bytes /
u32 n_bytes;
u32 n_blocks =
(dev->internal_end_block - dev->internal_start_block + 1);
-
int ok;
/* Write device runtime values */
n_bytes);
}
return ok ? 1 : 0;
-
}
static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
u32 n_bytes;
u32 n_blocks =
(dev->internal_end_block - dev->internal_start_block + 1);
-
int ok;
ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
struct yaffs_obj *obj)
{
-
cp->obj_id = obj->obj_id;
cp->parent_id = (obj->parent) ? obj->parent->obj_id : 0;
cp->hdr_chunk = obj->hdr_chunk;
static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj,
struct yaffs_checkpt_obj *cp)
{
-
struct yaffs_obj *parent;
if (obj->variant_type != cp->variant_type) {
if (cp->parent_id)
parent = yaffs_find_or_create_by_number(obj->my_dev,
- cp->parent_id,
- YAFFS_OBJECT_TYPE_DIRECTORY);
+ cp->parent_id,
+ YAFFS_OBJECT_TYPE_DIRECTORY);
else
parent = NULL;
for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
if (tn->internal[i]) {
ok = yaffs2_checkpt_tnode_worker(in,
- tn->
- internal
- [i],
- level -
- 1,
- (chunk_offset
- <<
- YAFFS_TNODES_INTERNAL_BITS)
- + i);
+ tn->internal[i],
+ level - 1,
+ (chunk_offset <<
+ YAFFS_TNODES_INTERNAL_BITS)
+ + i);
}
}
} else if (level == 0) {
}
return ok;
-
}
static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj)
/* Read level 0 tnode */
tn = yaffs_get_tnode(dev);
- if (tn) {
+ if (tn)
ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) ==
- dev->tnode_size);
- } else {
+ dev->tnode_size);
+ else
ok = 0;
- }
if (tn && ok)
ok = yaffs_add_find_tnode_0(dev,
ok = (yaffs2_checkpt_rd
(dev, &base_chunk,
sizeof(base_chunk)) == sizeof(base_chunk));
-
}
yaffs_trace(YAFFS_TRACE_CHECKPOINT,
for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) {
list_for_each(lh, &dev->obj_bucket[i].list) {
obj = list_entry(lh, struct yaffs_obj, hash_link);
- if (!obj->defered_free) {
+ if (!obj->defered_free) {
yaffs2_obj_checkpt_obj(&cp, obj);
cp.struct_type = sizeof(cp);
cp.variant_type, cp.hdr_chunk, obj);
ok = (yaffs2_checkpt_wr(dev, &cp,
- sizeof(cp)) == sizeof(cp));
+ sizeof(cp)) == sizeof(cp));
if (ok &&
- obj->variant_type ==
- YAFFS_OBJECT_TYPE_FILE)
- ok = yaffs2_wr_checkpt_tnodes(obj);
+ obj->variant_type ==
+ YAFFS_OBJECT_TYPE_FILE)
+ ok = yaffs2_wr_checkpt_tnodes(obj);
}
}
}
ok = taffs2_checkpt_obj_to_obj(obj, &cp);
if (!ok)
break;
- if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
+ if (obj->variant_type ==
+ YAFFS_OBJECT_TYPE_FILE) {
ok = yaffs2_rd_checkpt_tnodes(obj);
} else if (obj->variant_type ==
- YAFFS_OBJECT_TYPE_HARDLINK) {
+ YAFFS_OBJECT_TYPE_HARDLINK) {
obj->hard_links.next =
(struct list_head *)hard_list;
hard_list = obj;
}
} else {
ok = 0;
- }
+ }
}
}
yaffs2_get_checkpt_sum(dev, &checkpt_sum);
ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) ==
- sizeof(checkpt_sum));
+ sizeof(checkpt_sum));
if (!ok)
return 0;
yaffs2_get_checkpt_sum(dev, &checkpt_sum0);
ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) ==
- sizeof(checkpt_sum1));
+ sizeof(checkpt_sum1));
if (!ok)
return 0;
dev->is_checkpointed = 0;
return ok ? 1 : 0;
-
}
void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
int yaffs_checkpoint_save(struct yaffs_dev *dev)
{
-
yaffs_trace(YAFFS_TRACE_CHECKPOINT,
"save entry: is_checkpointed %d",
dev->is_checkpointed);
int yaffs2_checkpt_restore(struct yaffs_dev *dev)
{
int retval;
+
yaffs_trace(YAFFS_TRACE_CHECKPOINT,
"restore entry: is_checkpointed %d",
dev->is_checkpointed);
{
/* if new_size > old_file_size.
* We're going to be writing a hole.
- * If the hole is small then write zeros otherwise write a start of hole marker.
+ * If the hole is small then write zeros otherwise write a start
+ * of hole marker.
*/
-
loff_t old_file_size;
int increase;
int small_hole;
int result = YAFFS_OK;
struct yaffs_dev *dev = NULL;
-
u8 *local_buffer = NULL;
-
int small_increase_ok = 0;
if (!obj)
increase -= this_write;
} else {
small_increase_ok = 0;
- }
+ }
}
yaffs_release_temp_buffer(dev, local_buffer, __LINE__);
- /* If we were out of space then reverse any chunks we've added */
+ /* If out of space then reverse any chunks we've added */
if (!small_increase_ok)
yaffs_resize_file_down(obj, old_file_size);
}
}
return result;
-
}
struct yaffs_block_index {
int bseq = ((struct yaffs_block_index *)b)->seq;
int ablock = ((struct yaffs_block_index *)a)->block;
int bblock = ((struct yaffs_block_index *)b)->block;
+
if (aseq == bseq)
return ablock - bblock;
else
return aseq - bseq;
}
-int yaffs2_scan_backwards(struct yaffs_dev *dev)
+static inline int yaffs2_scan_chunk(struct yaffs_dev *dev,
+ struct yaffs_block_info *bi,
+ int blk, int chunk_in_block,
+ int *found_chunks,
+ u8 *chunk_data,
+ struct yaffs_obj **hard_list)
{
+ struct yaffs_obj_hdr *oh;
+ struct yaffs_obj *in;
+ struct yaffs_obj *parent;
+ int equiv_id;
+ int file_size;
+ int is_shrink;
+ int is_unlinked;
struct yaffs_ext_tags tags;
+ int result;
+ int alloc_failed = 0;
+ int chunk = blk * dev->param.chunks_per_block + chunk_in_block;
+ struct yaffs_file_var *file_var;
+ struct yaffs_hardlink_var *hl_var;
+ struct yaffs_symlink_var *sl_var;
+
+ result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags);
+
+ /* Let's have a good look at this chunk... */
+
+ if (!tags.chunk_used) {
+ /* An unassigned chunk in the block.
+ * If there are used chunks after this one, then
+ * it is a chunk that was skipped due to failing
+ * the erased check. Just skip it so that it can
+ * be deleted.
+ * But, more typically, We get here when this is
+ * an unallocated chunk and his means that
+ * either the block is empty or this is the one
+ * being allocated from
+ */
+
+ if (*found_chunks) {
+ /* This is a chunk that was skipped due
+ * to failing the erased check */
+ } else if (chunk_in_block == 0) {
+ /* We're looking at the first chunk in
+ * the block so the block is unused */
+ bi->block_state = YAFFS_BLOCK_STATE_EMPTY;
+ dev->n_erased_blocks++;
+ } else {
+ if (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING
+ || bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) {
+ if (dev->seq_number == bi->seq_number) {
+ /* Allocating from this block*/
+ yaffs_trace(YAFFS_TRACE_SCAN,
+ " Allocating from %d %d",
+ blk, chunk_in_block);
+
+ bi->block_state =
+ YAFFS_BLOCK_STATE_ALLOCATING;
+ dev->alloc_block = blk;
+ dev->alloc_page = chunk_in_block;
+ dev->alloc_block_finder = blk;
+ } else {
+ /* This is a partially written block
+ * that is not the current
+ * allocation block.
+ */
+ yaffs_trace(YAFFS_TRACE_SCAN,
+ "Partially written block %d detected. gc will fix this.",
+ blk);
+ }
+ }
+ }
+
+ dev->n_free_chunks++;
+
+ } else if (tags.ecc_result ==
+ YAFFS_ECC_RESULT_UNFIXED) {
+ yaffs_trace(YAFFS_TRACE_SCAN,
+ " Unfixed ECC in chunk(%d:%d), chunk ignored",
+ blk, chunk_in_block);
+ dev->n_free_chunks++;
+ } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID ||
+ tags.chunk_id > YAFFS_MAX_CHUNK_ID ||
+ (tags.chunk_id > 0 &&
+ tags.n_bytes > dev->data_bytes_per_chunk) ||
+ tags.seq_number != bi->seq_number) {
+ yaffs_trace(YAFFS_TRACE_SCAN,
+ "Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored",
+ blk, chunk_in_block, tags.obj_id,
+ tags.chunk_id, tags.n_bytes);
+ dev->n_free_chunks++;
+ } else if (tags.chunk_id > 0) {
+ /* chunk_id > 0 so it is a data chunk... */
+ unsigned int endpos;
+ u32 chunk_base = (tags.chunk_id - 1) *
+ dev->data_bytes_per_chunk;
+
+ *found_chunks = 1;
+
+ yaffs_set_chunk_bit(dev, blk, chunk_in_block);
+ bi->pages_in_use++;
+
+ in = yaffs_find_or_create_by_number(dev,
+ tags.obj_id,
+ YAFFS_OBJECT_TYPE_FILE);
+ if (!in)
+ /* Out of memory */
+ alloc_failed = 1;
+
+ if (in &&
+ in->variant_type == YAFFS_OBJECT_TYPE_FILE &&
+ chunk_base < in->variant.file_variant.shrink_size) {
+ /* This has not been invalidated by
+ * a resize */
+ if (!yaffs_put_chunk_in_file(in, tags.chunk_id,
+ chunk, -1))
+ alloc_failed = 1;
+
+ /* File size is calculated by looking at
+ * the data chunks if we have not
+ * seen an object header yet.
+ * Stop this practice once we find an
+ * object header.
+ */
+ endpos = chunk_base + tags.n_bytes;
+
+ if (!in->valid &&
+ in->variant.file_variant.scanned_size < endpos) {
+ in->variant.file_variant.
+ scanned_size = endpos;
+ in->variant.file_variant.
+ file_size = endpos;
+ }
+ } else if (in) {
+ /* This chunk has been invalidated by a
+ * resize, or a past file deletion
+ * so delete the chunk*/
+ yaffs_chunk_del(dev, chunk, 1, __LINE__);
+ }
+ } else {
+ /* chunk_id == 0, so it is an ObjectHeader.
+ * Thus, we read in the object header and make
+ * the object
+ */
+ *found_chunks = 1;
+
+ yaffs_set_chunk_bit(dev, blk, chunk_in_block);
+ bi->pages_in_use++;
+
+ oh = NULL;
+ in = NULL;
+
+ if (tags.extra_available) {
+ in = yaffs_find_or_create_by_number(dev,
+ tags.obj_id,
+ tags.extra_obj_type);
+ if (!in)
+ alloc_failed = 1;
+ }
+
+ if (!in ||
+ (!in->valid && dev->param.disable_lazy_load)
+ || tags.extra_shadows ||
+ (!in->valid && (tags.obj_id ==
+ YAFFS_OBJECTID_ROOT
+ || tags.obj_id ==
+ YAFFS_OBJECTID_LOSTNFOUND))) {
+
+ /* If we don't have valid info then we
+ * need to read the chunk
+ * TODO In future we can probably defer
+ * reading the chunk and living with
+ * invalid data until needed.
+ */
+
+ result = yaffs_rd_chunk_tags_nand(dev,
+ chunk,
+ chunk_data,
+ NULL);
+
+ oh = (struct yaffs_obj_hdr *)chunk_data;
+
+ if (dev->param.inband_tags) {
+ /* Fix up the header if they got
+ * corrupted by inband tags */
+ oh->shadows_obj =
+ oh->inband_shadowed_obj_id;
+ oh->is_shrink =
+ oh->inband_is_shrink;
+ }
+
+ if (!in) {
+ in = yaffs_find_or_create_by_number(dev,
+ tags.obj_id, oh->type);
+ if (!in)
+ alloc_failed = 1;
+ }
+ }
+
+ if (!in) {
+ /* TODO Hoosterman we have a problem! */
+ yaffs_trace(YAFFS_TRACE_ERROR,
+ "yaffs tragedy: Could not make object for object %d at chunk %d during scan",
+ tags.obj_id, chunk);
+ return YAFFS_FAIL;
+ }
+
+ if (in->valid) {
+ /* We have already filled this one.
+ * We have a duplicate that will be
+ * discarded, but we first have to suck
+ * out resize info if it is a file.
+ */
+ if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) &&
+ ((oh && oh->type == YAFFS_OBJECT_TYPE_FILE) ||
+ (tags.extra_available &&
+ tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE)
+ )) {
+ u32 this_size = (oh) ?
+ oh->file_size :
+ tags.extra_length;
+ u32 parent_obj_id = (oh) ?
+ oh->parent_obj_id :
+ tags.extra_parent_id;
+
+ is_shrink = (oh) ?
+ oh->is_shrink :
+ tags.extra_is_shrink;
+
+ /* If it is deleted (unlinked
+ * at start also means deleted)
+ * we treat the file size as
+ * being zeroed at this point.
+ */
+ if (parent_obj_id == YAFFS_OBJECTID_DELETED ||
+ parent_obj_id == YAFFS_OBJECTID_UNLINKED) {
+ this_size = 0;
+ is_shrink = 1;
+ }
+
+ if (is_shrink &&
+ in->variant.file_variant.shrink_size >
+ this_size)
+ in->variant.file_variant.shrink_size =
+ this_size;
+
+ if (is_shrink)
+ bi->has_shrink_hdr = 1;
+ }
+ /* Use existing - destroy this one. */
+ yaffs_chunk_del(dev, chunk, 1, __LINE__);
+ }
+
+ if (!in->valid && in->variant_type !=
+ (oh ? oh->type : tags.extra_obj_type))
+ yaffs_trace(YAFFS_TRACE_ERROR,
+ "yaffs tragedy: Bad object type, %d != %d, for object %d at chunk %d during scan",
+ oh ? oh->type : tags.extra_obj_type,
+ in->variant_type, tags.obj_id,
+ chunk);
+
+ if (!in->valid &&
+ (tags.obj_id == YAFFS_OBJECTID_ROOT ||
+ tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) {
+ /* We only load some info, don't fiddle
+ * with directory structure */
+ in->valid = 1;
+
+ if (oh) {
+ in->yst_mode = oh->yst_mode;
+ yaffs_load_attribs(in, oh);
+ in->lazy_loaded = 0;
+ } else {
+ in->lazy_loaded = 1;
+ }
+ in->hdr_chunk = chunk;
+
+ } else if (!in->valid) {
+ /* we need to load this info */
+ in->valid = 1;
+ in->hdr_chunk = chunk;
+ if (oh) {
+ in->variant_type = oh->type;
+ in->yst_mode = oh->yst_mode;
+ yaffs_load_attribs(in, oh);
+
+ if (oh->shadows_obj > 0)
+ yaffs_handle_shadowed_obj(dev,
+ oh->shadows_obj, 1);
+
+ yaffs_set_obj_name_from_oh(in, oh);
+ parent = yaffs_find_or_create_by_number(dev,
+ oh->parent_obj_id,
+ YAFFS_OBJECT_TYPE_DIRECTORY);
+ file_size = oh->file_size;
+ is_shrink = oh->is_shrink;
+ equiv_id = oh->equiv_id;
+ } else {
+ in->variant_type = tags.extra_obj_type;
+ parent = yaffs_find_or_create_by_number(dev,
+ tags.extra_parent_id,
+ YAFFS_OBJECT_TYPE_DIRECTORY);
+ file_size = tags.extra_length;
+ is_shrink = tags.extra_is_shrink;
+ equiv_id = tags.extra_equiv_id;
+ in->lazy_loaded = 1;
+ }
+ in->dirty = 0;
+
+ if (!parent)
+ alloc_failed = 1;
+
+ /* directory stuff...
+ * hook up to parent
+ */
+
+ if (parent &&
+ parent->variant_type == YAFFS_OBJECT_TYPE_UNKNOWN) {
+ /* Set up as a directory */
+ parent->variant_type =
+ YAFFS_OBJECT_TYPE_DIRECTORY;
+ INIT_LIST_HEAD(&parent->
+ variant.dir_variant.children);
+ } else if (!parent ||
+ parent->variant_type !=
+ YAFFS_OBJECT_TYPE_DIRECTORY) {
+ /* Hoosterman, another problem....
+ * Trying to use a non-directory as a directory
+ */
+
+ yaffs_trace(YAFFS_TRACE_ERROR,
+ "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
+ );
+ parent = dev->lost_n_found;
+ }
+ yaffs_add_obj_to_dir(parent, in);
+
+ is_unlinked = (parent == dev->del_dir) ||
+ (parent == dev->unlinked_dir);
+
+ if (is_shrink)
+ /* Mark the block */
+ bi->has_shrink_hdr = 1;
+
+ /* Note re hardlinks.
+ * Since we might scan a hardlink before its equivalent
+ * object is scanned we put them all in a list.
+ * After scanning is complete, we should have all the
+ * objects, so we run through this list and fix up all
+ * the chains.
+ */
+
+ switch (in->variant_type) {
+ case YAFFS_OBJECT_TYPE_UNKNOWN:
+ /* Todo got a problem */
+ break;
+ case YAFFS_OBJECT_TYPE_FILE:
+ file_var = &in->variant.file_variant;
+ if (file_var->scanned_size < file_size) {
+ /* This covers the case where the file
+ * size is greater than the data held.
+ * This will happen if the file is
+ * resized to be larger than its
+ * current data extents.
+ */
+ file_var->file_size = file_size;
+ file_var->scanned_size = file_size;
+ }
+
+ if (file_var->shrink_size > file_size)
+ file_var->shrink_size = file_size;
+
+ break;
+ case YAFFS_OBJECT_TYPE_HARDLINK:
+ hl_var = &in->variant.hardlink_variant;
+ if (!is_unlinked) {
+ hl_var->equiv_id = equiv_id;
+ in->hard_links.next =
+ (struct list_head *) *hard_list;
+ *hard_list = in;
+ }
+ break;
+ case YAFFS_OBJECT_TYPE_DIRECTORY:
+ /* Do nothing */
+ break;
+ case YAFFS_OBJECT_TYPE_SPECIAL:
+ /* Do nothing */
+ break;
+ case YAFFS_OBJECT_TYPE_SYMLINK:
+ sl_var = &in->variant.symlink_variant;
+ if (oh) {
+ sl_var->alias =
+ yaffs_clone_str(oh->alias);
+ if (!sl_var->alias)
+ alloc_failed = 1;
+ }
+ break;
+ }
+ }
+ }
+ return alloc_failed ? YAFFS_FAIL : YAFFS_OK;
+}
+
+int yaffs2_scan_backwards(struct yaffs_dev *dev)
+{
int blk;
int block_iter;
int start_iter;
int end_iter;
int n_to_scan = 0;
-
- int chunk;
- int result;
+ enum yaffs_block_state state;
int c;
int deleted;
- enum yaffs_block_state state;
struct yaffs_obj *hard_list = NULL;
struct yaffs_block_info *bi;
u32 seq_number;
- struct yaffs_obj_hdr *oh;
- struct yaffs_obj *in;
- struct yaffs_obj *parent;
int n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
- int is_unlinked;
u8 *chunk_data;
-
- int file_size;
- int is_shrink;
int found_chunks;
- int equiv_id;
int alloc_failed = 0;
-
struct yaffs_block_index *block_index = NULL;
int alt_block_index = 0;
bi->seq_number = seq_number;
if (bi->seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA)
- bi->block_state = state = YAFFS_BLOCK_STATE_CHECKPOINT;
+ bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK)
- bi->block_state = state = YAFFS_BLOCK_STATE_DEAD;
+ bi->block_state = YAFFS_BLOCK_STATE_DEAD;
yaffs_trace(YAFFS_TRACE_SCAN_DEBUG,
"Block scanning block %d state %d seq %d",
- blk, state, seq_number);
+ blk, bi->block_state, seq_number);
- if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
+ if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) {
dev->blocks_in_checkpt++;
- } else if (state == YAFFS_BLOCK_STATE_DEAD) {
+ } else if (bi->block_state == YAFFS_BLOCK_STATE_DEAD) {
yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
"block %d is bad", blk);
- } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
+ } else if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty ");
dev->n_erased_blocks++;
dev->n_free_chunks += dev->param.chunks_per_block;
- } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
-
+ } else if (bi->block_state ==
+ YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
/* Determine the highest sequence number */
if (seq_number >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
seq_number < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
-
block_index[n_to_scan].seq = seq_number;
block_index[n_to_scan].block = blk;
-
n_to_scan++;
-
if (seq_number >= dev->seq_number)
dev->seq_number = seq_number;
} else {
yaffs_trace(YAFFS_TRACE_SCAN,
"Block scanning block %d has bad sequence number %d",
blk, seq_number);
-
}
}
bi++;
/* get the block to scan in the correct order */
blk = block_index[block_iter].block;
-
bi = yaffs_get_block_info(dev, blk);
-
- state = bi->block_state;
-
deleted = 0;
/* For each chunk in each block that needs scanning.... */
found_chunks = 0;
for (c = dev->param.chunks_per_block - 1;
!alloc_failed && c >= 0 &&
- (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
- state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
+ (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
+ bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
/* Scan backwards...
* Read the tags and decide what to do
*/
-
- chunk = blk * dev->param.chunks_per_block + c;
-
- result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL,
- &tags);
-
- /* Let's have a good look at this chunk... */
-
- if (!tags.chunk_used) {
- /* An unassigned chunk in the block.
- * If there are used chunks after this one, then
- * it is a chunk that was skipped due to failing the erased
- * check. Just skip it so that it can be deleted.
- * But, more typically, We get here when this is an unallocated
- * chunk and his means that either the block is empty or
- * this is the one being allocated from
- */
-
- if (found_chunks) {
- /* This is a chunk that was skipped due to failing the erased check */
- } else if (c == 0) {
- /* We're looking at the first chunk in the block so the block is unused */
- state = YAFFS_BLOCK_STATE_EMPTY;
- dev->n_erased_blocks++;
- } else {
- if (state ==
- YAFFS_BLOCK_STATE_NEEDS_SCANNING
- || state ==
- YAFFS_BLOCK_STATE_ALLOCATING) {
- if (dev->seq_number ==
- bi->seq_number) {
- /* this is the block being allocated from */
-
- yaffs_trace(YAFFS_TRACE_SCAN,
- " Allocating from %d %d",
- blk, c);
-
- state =
- YAFFS_BLOCK_STATE_ALLOCATING;
- dev->alloc_block = blk;
- dev->alloc_page = c;
- dev->
- alloc_block_finder =
- blk;
- } else {
- /* This is a partially written block that is not
- * the current allocation block.
- */
-
- yaffs_trace(YAFFS_TRACE_SCAN,
- "Partially written block %d detected",
- blk);
- }
- }
- }
-
- dev->n_free_chunks++;
-
- } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) {
- yaffs_trace(YAFFS_TRACE_SCAN,
- " Unfixed ECC in chunk(%d:%d), chunk ignored",
- blk, c);
-
- dev->n_free_chunks++;
-
- } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID ||
- tags.chunk_id > YAFFS_MAX_CHUNK_ID ||
- (tags.chunk_id > 0
- && tags.n_bytes > dev->data_bytes_per_chunk)
- || tags.seq_number != bi->seq_number) {
- yaffs_trace(YAFFS_TRACE_SCAN,
- "Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored",
- blk, c, tags.obj_id,
- tags.chunk_id, tags.n_bytes);
-
- dev->n_free_chunks++;
-
- } else if (tags.chunk_id > 0) {
- /* chunk_id > 0 so it is a data chunk... */
- unsigned int endpos;
- u32 chunk_base =
- (tags.chunk_id -
- 1) * dev->data_bytes_per_chunk;
-
- found_chunks = 1;
-
- yaffs_set_chunk_bit(dev, blk, c);
- bi->pages_in_use++;
-
- in = yaffs_find_or_create_by_number(dev,
- tags.obj_id,
- YAFFS_OBJECT_TYPE_FILE);
- if (!in) {
- /* Out of memory */
- alloc_failed = 1;
- }
-
- if (in &&
- in->variant_type == YAFFS_OBJECT_TYPE_FILE
- && chunk_base <
- in->variant.file_variant.shrink_size) {
- /* This has not been invalidated by a resize */
- if (!yaffs_put_chunk_in_file
- (in, tags.chunk_id, chunk, -1)) {
- alloc_failed = 1;
- }
-
- /* File size is calculated by looking at the data chunks if we have not
- * seen an object header yet. Stop this practice once we find an object header.
- */
- endpos = chunk_base + tags.n_bytes;
-
- if (!in->valid && /* have not got an object header yet */
- in->variant.file_variant.
- scanned_size < endpos) {
- in->variant.file_variant.
- scanned_size = endpos;
- in->variant.file_variant.
- file_size = endpos;
- }
-
- } else if (in) {
- /* This chunk has been invalidated by a resize, or a past file deletion
- * so delete the chunk*/
- yaffs_chunk_del(dev, chunk, 1,
- __LINE__);
-
- }
- } else {
- /* chunk_id == 0, so it is an ObjectHeader.
- * Thus, we read in the object header and make the object
- */
- found_chunks = 1;
-
- yaffs_set_chunk_bit(dev, blk, c);
- bi->pages_in_use++;
-
- oh = NULL;
- in = NULL;
-
- if (tags.extra_available) {
- in = yaffs_find_or_create_by_number(dev,
- tags.
- obj_id,
- tags.
- extra_obj_type);
- if (!in)
- alloc_failed = 1;
- }
-
- if (!in ||
- (!in->valid && dev->param.disable_lazy_load)
- || tags.extra_shadows || (!in->valid
- && (tags.obj_id ==
- YAFFS_OBJECTID_ROOT
- || tags.
- obj_id ==
- YAFFS_OBJECTID_LOSTNFOUND)))
- {
-
- /* If we don't have valid info then we need to read the chunk
- * TODO In future we can probably defer reading the chunk and
- * living with invalid data until needed.
- */
-
- result = yaffs_rd_chunk_tags_nand(dev,
- chunk,
- chunk_data,
- NULL);
-
- oh = (struct yaffs_obj_hdr *)chunk_data;
-
- if (dev->param.inband_tags) {
- /* Fix up the header if they got corrupted by inband tags */
- oh->shadows_obj =
- oh->inband_shadowed_obj_id;
- oh->is_shrink =
- oh->inband_is_shrink;
- }
-
- if (!in) {
- in = yaffs_find_or_create_by_number(dev, tags.obj_id, oh->type);
- if (!in)
- alloc_failed = 1;
- }
-
- }
-
- if (!in) {
- /* TODO Hoosterman we have a problem! */
- yaffs_trace(YAFFS_TRACE_ERROR,
- "yaffs tragedy: Could not make object for object %d at chunk %d during scan",
- tags.obj_id, chunk);
- continue;
- }
-
- if (in->valid) {
- /* We have already filled this one.
- * We have a duplicate that will be discarded, but
- * we first have to suck out resize info if it is a file.
- */
-
- if ((in->variant_type ==
- YAFFS_OBJECT_TYPE_FILE) && ((oh
- &&
- oh->
- type
- ==
- YAFFS_OBJECT_TYPE_FILE)
- ||
- (tags.
- extra_available
- &&
- tags.
- extra_obj_type
- ==
- YAFFS_OBJECT_TYPE_FILE)))
- {
- u32 this_size =
- (oh) ? oh->
- file_size :
- tags.extra_length;
- u32 parent_obj_id =
- (oh) ? oh->parent_obj_id :
- tags.extra_parent_id;
-
- is_shrink =
- (oh) ? oh->
- is_shrink :
- tags.extra_is_shrink;
-
- /* If it is deleted (unlinked at start also means deleted)
- * we treat the file size as being zeroed at this point.
- */
- if (parent_obj_id ==
- YAFFS_OBJECTID_DELETED
- || parent_obj_id ==
- YAFFS_OBJECTID_UNLINKED) {
- this_size = 0;
- is_shrink = 1;
- }
-
- if (is_shrink
- && in->variant.file_variant.
- shrink_size > this_size)
- in->variant.
- file_variant.
- shrink_size =
- this_size;
-
- if (is_shrink)
- bi->has_shrink_hdr = 1;
-
- }
- /* Use existing - destroy this one. */
- yaffs_chunk_del(dev, chunk, 1,
- __LINE__);
-
- }
-
- if (!in->valid && in->variant_type !=
- (oh ? oh->type : tags.extra_obj_type))
- yaffs_trace(YAFFS_TRACE_ERROR,
- "yaffs tragedy: Bad object type, %d != %d, for object %d at chunk %d during scan",
- oh ?
- oh->type : tags.extra_obj_type,
- in->variant_type, tags.obj_id,
- chunk);
-
- if (!in->valid &&
- (tags.obj_id == YAFFS_OBJECTID_ROOT ||
- tags.obj_id ==
- YAFFS_OBJECTID_LOSTNFOUND)) {
- /* We only load some info, don't fiddle with directory structure */
- in->valid = 1;
-
- if (oh) {
-
- in->yst_mode = oh->yst_mode;
- yaffs_load_attribs(in, oh);
- in->lazy_loaded = 0;
- } else {
- in->lazy_loaded = 1;
- }
- in->hdr_chunk = chunk;
-
- } else if (!in->valid) {
- /* we need to load this info */
-
- in->valid = 1;
- in->hdr_chunk = chunk;
-
- if (oh) {
- in->variant_type = oh->type;
-
- in->yst_mode = oh->yst_mode;
- yaffs_load_attribs(in, oh);
-
- if (oh->shadows_obj > 0)
- yaffs_handle_shadowed_obj
- (dev,
- oh->shadows_obj,
- 1);
-
- yaffs_set_obj_name_from_oh(in,
- oh);
- parent =
- yaffs_find_or_create_by_number
- (dev, oh->parent_obj_id,
- YAFFS_OBJECT_TYPE_DIRECTORY);
-
- file_size = oh->file_size;
- is_shrink = oh->is_shrink;
- equiv_id = oh->equiv_id;
-
- } else {
- in->variant_type =
- tags.extra_obj_type;
- parent =
- yaffs_find_or_create_by_number
- (dev, tags.extra_parent_id,
- YAFFS_OBJECT_TYPE_DIRECTORY);
- file_size = tags.extra_length;
- is_shrink =
- tags.extra_is_shrink;
- equiv_id = tags.extra_equiv_id;
- in->lazy_loaded = 1;
-
- }
- in->dirty = 0;
-
- if (!parent)
- alloc_failed = 1;
-
- /* directory stuff...
- * hook up to parent
- */
-
- if (parent && parent->variant_type ==
- YAFFS_OBJECT_TYPE_UNKNOWN) {
- /* Set up as a directory */
- parent->variant_type =
- YAFFS_OBJECT_TYPE_DIRECTORY;
- INIT_LIST_HEAD(&parent->
- variant.dir_variant.children);
- } else if (!parent
- || parent->variant_type !=
- YAFFS_OBJECT_TYPE_DIRECTORY) {
- /* Hoosterman, another problem....
- * We're trying to use a non-directory as a directory
- */
-
- yaffs_trace(YAFFS_TRACE_ERROR,
- "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
- );
- parent = dev->lost_n_found;
- }
-
- yaffs_add_obj_to_dir(parent, in);
-
- is_unlinked = (parent == dev->del_dir)
- || (parent == dev->unlinked_dir);
-
- if (is_shrink) {
- /* Mark the block as having a shrink header */
- bi->has_shrink_hdr = 1;
- }
-
- /* Note re hardlinks.
- * Since we might scan a hardlink before its equivalent object is scanned
- * we put them all in a list.
- * After scanning is complete, we should have all the objects, so we run
- * through this list and fix up all the chains.
- */
-
- switch (in->variant_type) {
- case YAFFS_OBJECT_TYPE_UNKNOWN:
- /* Todo got a problem */
- break;
- case YAFFS_OBJECT_TYPE_FILE:
-
- if (in->variant.
- file_variant.scanned_size <
- file_size) {
- /* This covers the case where the file size is greater
- * than where the data is
- * This will happen if the file is resized to be larger
- * than its current data extents.
- */
- in->variant.
- file_variant.
- file_size =
- file_size;
- in->variant.
- file_variant.
- scanned_size =
- file_size;
- }
-
- if (in->variant.file_variant.
- shrink_size > file_size)
- in->variant.
- file_variant.
- shrink_size =
- file_size;
-
- break;
- case YAFFS_OBJECT_TYPE_HARDLINK:
- if (!is_unlinked) {
- in->variant.
- hardlink_variant.
- equiv_id = equiv_id;
- in->hard_links.next =
- (struct list_head *)
- hard_list;
- hard_list = in;
- }
- break;
- case YAFFS_OBJECT_TYPE_DIRECTORY:
- /* Do nothing */
- break;
- case YAFFS_OBJECT_TYPE_SPECIAL:
- /* Do nothing */
- break;
- case YAFFS_OBJECT_TYPE_SYMLINK:
- if (oh) {
- in->variant.
- symlink_variant.
- alias =
- yaffs_clone_str(oh->
- alias);
- if (!in->variant.
- symlink_variant.
- alias)
- alloc_failed =
- 1;
- }
- break;
- }
-
- }
-
- }
-
- } /* End of scanning for each chunk */
-
- if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
- /* If we got this far while scanning, then the block is fully allocated. */
- state = YAFFS_BLOCK_STATE_FULL;
+ if (yaffs2_scan_chunk(dev, bi, blk, c,
+ &found_chunks, chunk_data,
+ &hard_list) ==
+ YAFFS_FAIL)
+ alloc_failed = 1;
}
- bi->block_state = state;
+ if (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
+ /* If we got this far while scanning, then the block
+ * is fully allocated. */
+ bi->block_state = YAFFS_BLOCK_STATE_FULL;
+ }
/* Now let's see if it was dirty */
if (bi->pages_in_use == 0 &&
bi->block_state == YAFFS_BLOCK_STATE_FULL) {
yaffs_block_became_dirty(dev, blk);
}
-
}
yaffs_skip_rest_of_block(dev);
/* Ok, we've done all the scanning.
* Fix up the hard link chains.
- * We should now have scanned all the objects, now it's time to add these
+ * We have scanned all the objects, now it's time to add these
* hardlinks.
*/
yaffs_link_fixup(dev, hard_list);
#endif
#define yaffs_trace(msk, fmt, ...) do { \
- if(yaffs_trace_mask & (msk)) \
+ if (yaffs_trace_mask & (msk)) \
printk(KERN_DEBUG "yaffs: " fmt "\n", ##__VA_ARGS__); \
-} while(0)
+} while (0)
#ifndef YBUG
#define YBUG() do {\
#endif
#define yaffs_trace(msk, fmt, ...) do { \
- if(yaffs_trace_mask & (msk)) \
+ if (yaffs_trace_mask & (msk)) \
printk(KERN_DEBUG "yaffs: " fmt "\n", ##__VA_ARGS__); \
-} while(0)
+} while (0)
#ifndef YBUG
#define YBUG() do {\
projects / yaffs2.git / commitdiff