* yaffs2_find_oldest_dirty_seq()
* Calculate the oldest dirty sequence number if we don't know it.
*/
-void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev)
+void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
{
int i;
unsigned seq;
unsigned block_no = 0;
- yaffs_block_info_t *b;
+ struct yaffs_block_info *b;
if(!dev->param.is_yaffs2)
return;
}
-void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev)
+void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
{
if(!dev->param.is_yaffs2)
return;
* 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(yaffs_dev_t *dev, yaffs_block_info_t *bi)
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *bi)
{
if(!dev->param.is_yaffs2)
* Update the oldest dirty sequence number whenever we dirty a block.
* Only do this if the oldest_dirty_seq is actually being tracked.
*/
-void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi)
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi)
{
if(!dev->param.is_yaffs2)
return;
}
}
-int yaffs_block_ok_for_gc(yaffs_dev_t *dev,
- yaffs_block_info_t *bi)
+int yaffs_block_ok_for_gc(struct yaffs_dev *dev,
+ struct yaffs_block_info *bi)
{
if (!dev->param.is_yaffs2)
* periodically finds the oldest full block by sequence number for refreshing.
* Only for yaffs2.
*/
-__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev)
+u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
{
- __u32 b ;
+ u32 b ;
- __u32 oldest = 0;
- __u32 oldest_seq = 0;
+ u32 oldest = 0;
+ u32 oldest_seq = 0;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
if(!dev->param.is_yaffs2)
return oldest;
return oldest;
}
-int yaffs2_checkpt_required(yaffs_dev_t *dev)
+int yaffs2_checkpt_required(struct yaffs_dev *dev)
{
int nblocks;
(nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);
}
-int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev)
+int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev)
{
int retval;
int n_blocks;
int dev_blocks = (dev->param.end_block - dev->param.start_block + 1);
- n_bytes += sizeof(yaffs_checkpt_validty_t);
- n_bytes += sizeof(yaffs_checkpt_dev_t);
- n_bytes += dev_blocks * sizeof(yaffs_block_info_t);
+ n_bytes += sizeof(struct yaffs_checkpt_validity);
+ n_bytes += sizeof(struct yaffs_checkpt_dev);
+ n_bytes += dev_blocks * sizeof(struct yaffs_block_info);
n_bytes += dev_blocks * dev->chunk_bit_stride;
- n_bytes += (sizeof(yaffs_checkpt_obj_t) + sizeof(__u32)) * (dev->n_obj);
- n_bytes += (dev->tnode_size + sizeof(__u32)) * (dev->n_tnodes);
- n_bytes += sizeof(yaffs_checkpt_validty_t);
- n_bytes += sizeof(__u32); /* checksum*/
+ n_bytes += (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 */
/*--------------------- Checkpointing --------------------*/
-static int yaffs2_wr_checkpt_validity_marker(yaffs_dev_t *dev, int head)
+static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
{
- yaffs_checkpt_validty_t cp;
+ struct yaffs_checkpt_validity cp;
memset(&cp, 0, sizeof(cp));
1 : 0;
}
-static int yaffs2_rd_checkpt_validty_marker(yaffs_dev_t *dev, int head)
+static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head)
{
- yaffs_checkpt_validty_t cp;
+ struct yaffs_checkpt_validity cp;
int ok;
ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
return ok ? 1 : 0;
}
-static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp,
- yaffs_dev_t *dev)
+static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,
+ struct yaffs_dev *dev)
{
cp->n_erased_blocks = dev->n_erased_blocks;
cp->alloc_block = dev->alloc_block;
}
-static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev,
- yaffs_checkpt_dev_t *cp)
+static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
+ struct yaffs_checkpt_dev *cp)
{
dev->n_erased_blocks = cp->n_erased_blocks;
dev->alloc_block = cp->alloc_block;
}
-static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
{
- yaffs_checkpt_dev_t cp;
- __u32 n_bytes;
- __u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
+ struct yaffs_checkpt_dev cp;
+ u32 n_bytes;
+ u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
int ok;
/* Write block info */
if (ok) {
- n_bytes = n_blocks * sizeof(yaffs_block_info_t);
+ n_bytes = n_blocks * sizeof(struct yaffs_block_info);
ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes);
}
}
-static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
{
- yaffs_checkpt_dev_t cp;
- __u32 n_bytes;
- __u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
+ struct yaffs_checkpt_dev cp;
+ u32 n_bytes;
+ u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
int ok;
yaffs_checkpt_dev_to_dev(dev, &cp);
- n_bytes = n_blocks * sizeof(yaffs_block_info_t);
+ n_bytes = n_blocks * sizeof(struct yaffs_block_info);
ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes);
return ok ? 1 : 0;
}
-static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp,
- yaffs_obj_t *obj)
+static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
+ struct yaffs_obj *obj)
{
cp->obj_id = obj->obj_id;
cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
}
-static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp)
+static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt_obj *cp)
{
- yaffs_obj_t *parent;
+ struct yaffs_obj *parent;
if (obj->variant_type != cp->variant_type) {
T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "
-static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
- __u32 level, int chunk_offset)
+static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
+ u32 level, int chunk_offset)
{
int i;
- yaffs_dev_t *dev = in->my_dev;
+ struct yaffs_dev *dev = in->my_dev;
int ok = 1;
if (tn) {
}
}
} else if (level == 0) {
- __u32 base_offset = chunk_offset << YAFFS_TNODES_LEVEL0_BITS;
+ u32 base_offset = chunk_offset << YAFFS_TNODES_LEVEL0_BITS;
ok = (yaffs2_checkpt_wr(dev, &base_offset, sizeof(base_offset)) ==
sizeof(base_offset));
if (ok)
}
-static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj)
+static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj)
{
- __u32 end_marker = ~0;
+ u32 end_marker = ~0;
int ok = 1;
if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
return ok ? 1 : 0;
}
-static int yaffs2_rd_checkpt_tnodes(yaffs_obj_t *obj)
+static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj)
{
- __u32 base_chunk;
+ u32 base_chunk;
int ok = 1;
- yaffs_dev_t *dev = obj->my_dev;
- yaffs_file_s *file_stuct_ptr = &obj->variant.file_variant;
- yaffs_tnode_t *tn;
+ struct yaffs_dev *dev = obj->my_dev;
+ struct yaffs_file_var *file_stuct_ptr = &obj->variant.file_variant;
+ struct yaffs_tnode *tn;
int nread = 0;
ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk));
}
-static int yaffs2_wr_checkpt_objs(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
{
- yaffs_obj_t *obj;
- yaffs_checkpt_obj_t cp;
+ struct yaffs_obj *obj;
+ struct yaffs_checkpt_obj cp;
int i;
int ok = 1;
struct ylist_head *lh;
for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) {
ylist_for_each(lh, &dev->obj_bucket[i].list) {
if (lh) {
- obj = ylist_entry(lh, yaffs_obj_t, hash_link);
+ obj = ylist_entry(lh, struct yaffs_obj, hash_link);
if (!obj->defered_free) {
yaffs2_obj_checkpt_obj(&cp, obj);
cp.struct_type = sizeof(cp);
}
/* Dump end of list */
- memset(&cp, 0xFF, sizeof(yaffs_checkpt_obj_t));
+ memset(&cp, 0xFF, sizeof(struct yaffs_checkpt_obj));
cp.struct_type = sizeof(cp);
if (ok)
return ok ? 1 : 0;
}
-static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
{
- yaffs_obj_t *obj;
- yaffs_checkpt_obj_t cp;
+ struct yaffs_obj *obj;
+ struct yaffs_checkpt_obj cp;
int ok = 1;
int done = 0;
- yaffs_obj_t *hard_list = NULL;
+ struct yaffs_obj *hard_list = NULL;
while (ok && !done) {
ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
return ok ? 1 : 0;
}
-static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev)
{
- __u32 checkpt_sum;
+ u32 checkpt_sum;
int ok;
yaffs2_get_checkpt_sum(dev, &checkpt_sum);
return 1;
}
-static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev)
{
- __u32 checkpt_sum0;
- __u32 checkpt_sum1;
+ u32 checkpt_sum0;
+ u32 checkpt_sum1;
int ok;
yaffs2_get_checkpt_sum(dev, &checkpt_sum0);
}
-static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
{
int ok = 1;
return dev->is_checkpointed;
}
-static int yaffs2_rd_checkpt_data(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
{
int ok = 1;
if (ok) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
- ok = yaffs2_rd_checkpt_validty_marker(dev, 1);
+ ok = yaffs2_rd_checkpt_validity_marker(dev, 1);
}
if (ok) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR)));
}
if (ok) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
- ok = yaffs2_rd_checkpt_validty_marker(dev, 0);
+ ok = yaffs2_rd_checkpt_validity_marker(dev, 0);
}
if (ok) {
}
-void yaffs2_checkpt_invalidate(yaffs_dev_t *dev)
+void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
{
if (dev->is_checkpointed ||
dev->blocks_in_checkpt > 0) {
}
-int yaffs_checkpoint_save(yaffs_dev_t *dev)
+int yaffs_checkpoint_save(struct yaffs_dev *dev)
{
T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
return dev->is_checkpointed;
}
-int yaffs2_checkpt_restore(yaffs_dev_t *dev)
+int yaffs2_checkpt_restore(struct yaffs_dev *dev)
{
int retval;
T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
return retval;
}
-int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size)
+int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
{
/* if new_size > old_file_size.
* We're going to be writing a hole.
int increase;
int small_hole ;
int result = YAFFS_OK;
- yaffs_dev_t *dev = NULL;
+ struct yaffs_dev *dev = NULL;
- __u8 *local_buffer = NULL;
+ u8 *local_buffer = NULL;
int small_increase_ok = 0;
return aseq - bseq;
}
-int yaffs2_scan_backwards(yaffs_dev_t *dev)
+int yaffs2_scan_backwards(struct yaffs_dev *dev)
{
- yaffs_ext_tags tags;
+ struct yaffs_ext_tags tags;
int blk;
int block_iter;
int start_iter;
int result;
int c;
int deleted;
- yaffs_block_state_t state;
- yaffs_obj_t *hard_list = NULL;
- yaffs_block_info_t *bi;
- __u32 seq_number;
- yaffs_obj_header *oh;
- yaffs_obj_t *in;
- yaffs_obj_t *parent;
+ 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;
+ u8 *chunk_data;
int file_size;
int is_shrink;
} else if (tags.chunk_id > 0) {
/* chunk_id > 0 so it is a data chunk... */
unsigned int endpos;
- __u32 chunk_base =
+ u32 chunk_base =
(tags.chunk_id - 1) * dev->data_bytes_per_chunk;
found_chunks = 1;
chunk_data,
NULL);
- oh = (yaffs_obj_header *) chunk_data;
+ oh = (struct yaffs_obj_hdr *) chunk_data;
if (dev->param.inband_tags) {
/* Fix up the header if they got corrupted by inband tags */
oh->type == YAFFS_OBJECT_TYPE_FILE) ||
(tags.extra_available &&
tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) {
- __u32 this_size =
+ u32 this_size =
(oh) ? oh->file_size : tags.
extra_length;
- __u32 parent_obj_id =
+ u32 parent_obj_id =
(oh) ? oh->
parent_obj_id : tags.
extra_parent_id;
projects / yaffs2.git / blobdiff