Change enums to u32 for stored fields

[yaffs2.git] / yaffs_checkptrw.c

diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 8478eb88185fc4e1b271f161f31062e1f84bffb4..16ee1e0695c6b468941f4fcd0c6b983324e6d7db 100644 (file)
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -74,7 +74,7 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 {
        int i;
 
-       if (!dev->param.erase_fn)
+       if (!dev->drv.drv_erase_fn)
                return 0;
        yaffs_trace(YAFFS_TRACE_CHECKPOINT,
                "checking blocks %d to %d",
@@ -91,14 +91,14 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 
                        dev->n_erasures++;
 
-                       result = dev->param.erase_fn(dev, offset_i);
+                       result = dev->drv.drv_erase_fn(dev, offset_i);
                        if(result) {
                                bi->block_state = YAFFS_BLOCK_STATE_EMPTY;
                                dev->n_erased_blocks++;
                                dev->n_free_chunks +=
                                    dev->param.chunks_per_block;
                        } else {
-                               dev->param.bad_block_fn(dev, offset_i);
+                               dev->drv.drv_mark_bad_fn(dev, offset_i);
                                bi->block_state = YAFFS_BLOCK_STATE_DEAD;
                        }
                }
@@ -159,7 +159,7 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
                        enum yaffs_block_state state;
                        u32 seq;
 
-                       dev->param.read_chunk_tags_fn(dev,
+                       dev->tagger.read_chunk_tags_fn(dev,
                                        apply_chunk_offset(dev, chunk),
                                        NULL, &tags);
                        yaffs_trace(YAFFS_TRACE_CHECKPOINT,
@@ -171,7 +171,7 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
                        if (tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA)
                                continue;
 
-                       dev->param.query_block_fn(dev,
+                       dev->tagger.query_block_fn(dev,
                                                apply_block_offset(dev, i),
                                                &state, &seq);
                        if (state == YAFFS_BLOCK_STATE_DEAD)
@@ -200,9 +200,10 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
        dev->checkpt_open_write = writing;
 
        /* Got the functions we need? */
-       if (!dev->param.write_chunk_tags_fn ||
-           !dev->param.read_chunk_tags_fn ||
-           !dev->param.erase_fn || !dev->param.bad_block_fn)
+       if (!dev->tagger.write_chunk_tags_fn ||
+           !dev->tagger.read_chunk_tags_fn ||
+           !dev->drv.drv_erase_fn ||
+           !dev->drv.drv_mark_bad_fn)
                return 0;
 
        if (writing && !yaffs2_checkpt_space_ok(dev))
@@ -236,8 +237,9 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
        dev->blocks_in_checkpt = 0;
        dev->checkpt_max_blocks =
            (dev->internal_end_block - dev->internal_start_block) / 16 + 2;
-       dev->checkpt_block_list =
-           kmalloc(sizeof(int) * dev->checkpt_max_blocks, GFP_NOFS);
+       if (!dev->checkpt_block_list)
+               dev->checkpt_block_list =
+                     kmalloc(sizeof(int) * dev->checkpt_max_blocks, GFP_NOFS);
 
        if (!dev->checkpt_block_list)
                return 0;
@@ -298,7 +300,7 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
 
        dev->n_page_writes++;
 
-       dev->param.write_chunk_tags_fn(dev, offset_chunk,
+       dev->tagger.write_chunk_tags_fn(dev, offset_chunk,
                                       dev->checkpt_buffer, &tags);
        dev->checkpt_page_seq++;
        dev->checkpt_cur_chunk++;
@@ -347,7 +349,6 @@ int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
 int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 {
        int i = 0;
-       int ok = 1;
        struct yaffs_ext_tags tags;
        int chunk;
        int offset_chunk;
@@ -359,7 +360,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
        if (dev->checkpt_open_write)
                return -1;
 
-       while (i < n_bytes && ok) {
+       while (i < n_bytes) {
 
                if (dev->checkpt_byte_offs < 0 ||
                    dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) {
@@ -369,10 +370,9 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
                                dev->checkpt_cur_chunk = 0;
                        }
 
-                       if (dev->checkpt_cur_block < 0) {
-                               ok = 0;
+                       /* Bail out if we can't find a checpoint block */
+                       if (dev->checkpt_cur_block < 0)
                                break;
-                       }
 
                        chunk = dev->checkpt_cur_block *
                            dev->param.chunks_per_block +
@@ -381,22 +381,21 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
                        offset_chunk = apply_chunk_offset(dev, chunk);
                        dev->n_page_reads++;
 
-                       /* read in the next chunk */
-                       dev->param.read_chunk_tags_fn(dev,
+                       /* Read in the next chunk */
+                       dev->tagger.read_chunk_tags_fn(dev,
                                                offset_chunk,
                                                dev->checkpt_buffer,
                                                &tags);
 
+                       /* Bail out if the chunk is corrupted. */
                        if (tags.chunk_id != (dev->checkpt_page_seq + 1) ||
                            tags.ecc_result > YAFFS_ECC_RESULT_FIXED ||
-                           tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA) {
-                               ok = 0;
+                           tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA)
                                break;
-                       }
-                       if(!yaffs2_checkpt_check_chunk_hdr(dev)) {
-                               ok = 0;
+
+                       /* Bail out if it is not a checkpoint chunk. */
+                       if(!yaffs2_checkpt_check_chunk_hdr(dev))
                                break;
-                       }
 
                        dev->checkpt_page_seq++;
                        dev->checkpt_cur_chunk++;
@@ -416,7 +415,7 @@ int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
                dev->checkpt_byte_count++;
        }
 
-       return i;
+       return i; /* Number of bytes read */
 }
 
 int yaffs_checkpt_close(struct yaffs_dev *dev)
@@ -440,8 +439,6 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
                        if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY)
                                bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
                }
-               kfree(dev->checkpt_block_list);
-               dev->checkpt_block_list = NULL;
        }
 
        dev->n_free_chunks -=
@@ -451,14 +448,10 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
        yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpoint byte count %d",
                dev->checkpt_byte_count);
 
-       if (dev->checkpt_buffer) {
-               /* free the buffer */
-               kfree(dev->checkpt_buffer);
-               dev->checkpt_buffer = NULL;
+       if (dev->checkpt_buffer)
                return 1;
-       } else {
+       else
                return 0;
-       }
 }
 
 int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)