#include "yaffs_yaffs2.h"
#include "yaffs_checkptrw.h"
#include "yaffs_bitmap.h"
-#include "yaffs_qsort.h"
#include "yaffs_nand.h"
#include "yaffs_getblockinfo.h"
#include "yaffs_verify.h"
int i;
unsigned seq;
unsigned block_no = 0;
- yaffs_block_info_t *b;
+ struct yaffs_block_info *b;
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(struct yaffs_dev *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(struct yaffs_dev *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(struct yaffs_dev *dev,
- yaffs_block_info_t *bi)
+ struct yaffs_block_info *bi)
{
if (!dev->param.is_yaffs2)
u32 oldest = 0;
u32 oldest_seq = 0;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
if(!dev->param.is_yaffs2)
return oldest;
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 += (sizeof(struct yaffs_checkpt_obj) + 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(struct yaffs_checkpt_validity);
n_bytes += sizeof(u32); /* checksum*/
/* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
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(struct yaffs_dev *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,
+static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,
struct yaffs_dev *dev)
{
cp->n_erased_blocks = dev->n_erased_blocks;
}
static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
- yaffs_checkpt_dev_t *cp)
+ 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(struct yaffs_dev *dev)
{
- yaffs_checkpt_dev_t cp;
+ struct yaffs_checkpt_dev cp;
u32 n_bytes;
u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
/* 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(struct yaffs_dev *dev)
{
- yaffs_checkpt_dev_t cp;
+ struct yaffs_checkpt_dev cp;
u32 n_bytes;
u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
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,
+static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
struct yaffs_obj *obj)
{
cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
}
-static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, yaffs_checkpt_obj_t *cp)
+static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt_obj *cp)
{
struct yaffs_obj *parent;
-static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, yaffs_tnode_t *tn,
+static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
u32 level, int chunk_offset)
{
int i;
u32 base_chunk;
int ok = 1;
struct yaffs_dev *dev = obj->my_dev;
- yaffs_file_s *file_stuct_ptr = &obj->variant.file_variant;
- yaffs_tnode_t *tn;
+ 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(struct yaffs_dev *dev)
{
struct yaffs_obj *obj;
- yaffs_checkpt_obj_t cp;
+ struct yaffs_checkpt_obj cp;
int i;
int ok = 1;
- struct ylist_head *lh;
+ struct list_head *lh;
/* Iterate through the objects in each hash entry,
*/
for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) {
- ylist_for_each(lh, &dev->obj_bucket[i].list) {
+ list_for_each(lh, &dev->obj_bucket[i].list) {
if (lh) {
- obj = ylist_entry(lh, struct yaffs_obj, hash_link);
+ obj = list_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)
static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
{
struct yaffs_obj *obj;
- yaffs_checkpt_obj_t cp;
+ struct yaffs_checkpt_obj cp;
int ok = 1;
int done = 0;
struct yaffs_obj *hard_list = NULL;
ok = yaffs2_rd_checkpt_tnodes(obj);
} else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) {
obj->hard_links.next =
- (struct ylist_head *) hard_list;
+ (struct list_head *) hard_list;
hard_list = obj;
}
} else
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) {
}
-typedef struct {
+struct yaffs_block_index{
int seq;
int block;
-} yaffs_block_index;
+};
static int yaffs2_ybicmp(const void *a, const void *b)
{
- register int aseq = ((yaffs_block_index *)a)->seq;
- register int bseq = ((yaffs_block_index *)b)->seq;
- register int ablock = ((yaffs_block_index *)a)->block;
- register int bblock = ((yaffs_block_index *)b)->block;
+ int aseq = ((struct yaffs_block_index *)a)->seq;
+ 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
int result;
int c;
int deleted;
- yaffs_block_state_t state;
+ enum yaffs_block_state state;
struct yaffs_obj *hard_list = NULL;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
u32 seq_number;
struct yaffs_obj_hdr *oh;
struct yaffs_obj *in;
int alloc_failed = 0;
- yaffs_block_index *block_index = NULL;
+ struct yaffs_block_index *block_index = NULL;
int alt_block_index = 0;
T(YAFFS_TRACE_SCAN,
dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER;
- block_index = YMALLOC(n_blocks * sizeof(yaffs_block_index));
+ block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index));
if (!block_index) {
- block_index = YMALLOC_ALT(n_blocks * sizeof(yaffs_block_index));
+ block_index = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index));
alt_block_index = 1;
}
YYIELD();
/* Sort the blocks by sequence number*/
- yaffs_qsort(block_index, n_to_scan, sizeof(yaffs_block_index), yaffs2_ybicmp);
+ yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), yaffs2_ybicmp);
YYIELD();
/* Set up as a directory */
parent->variant_type =
YAFFS_OBJECT_TYPE_DIRECTORY;
- YINIT_LIST_HEAD(&parent->variant.
+ INIT_LIST_HEAD(&parent->variant.
dir_variant.
children);
} else if (!parent || parent->variant_type !=
in->variant.hardlink_variant.equiv_id =
equiv_id;
in->hard_links.next =
- (struct ylist_head *) hard_list;
+ (struct list_head *) hard_list;
hard_list = in;
}
break;