#include "yaffs_getblockinfo.h"
#include "yaffs_nand.h"
-int yaffs_skip_verification(yaffs_dev_t *dev)
+int yaffs_skip_verification(struct yaffs_dev *dev)
{
dev=dev;
return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
}
-static int yaffs_skip_full_verification(yaffs_dev_t *dev)
+static int yaffs_skip_full_verification(struct yaffs_dev *dev)
{
dev=dev;
return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL));
}
-static int yaffs_skip_nand_verification(yaffs_dev_t *dev)
+static int yaffs_skip_nand_verification(struct yaffs_dev *dev)
{
dev=dev;
return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));
};
-void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
+void yaffs_verify_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n)
{
int actually_used;
int in_use;
-void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
+void yaffs_verify_collected_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n)
{
yaffs_verify_blk(dev, bi, n);
}
}
-void yaffs_verify_blocks(yaffs_dev_t *dev)
+void yaffs_verify_blocks(struct yaffs_dev *dev)
{
int i;
int state_count[YAFFS_NUMBER_OF_BLOCK_STATES];
* Verify the object header. oh must be valid, but obj and tags may be NULL in which
* case those tests will not be performed.
*/
-void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parent_check)
+void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check)
{
if (obj && yaffs_skip_verification(obj->my_dev))
return;
(TSTR("Obj %d header name is NULL"TENDSTR),
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) /* Trashed name */
T(YAFFS_TRACE_VERIFY,
(TSTR("Obj %d header name is 0xFF"TENDSTR),
obj->obj_id));
}
-#if 0
-/* Not being used, but don't want to throw away yet */
-int yaffs_verify_tnode_worker(yaffs_obj_t *obj, yaffs_tnode_t *tn,
- __u32 level, int chunk_offset)
-{
- int i;
- yaffs_dev_t *dev = obj->my_dev;
- int ok = 1;
-
- if (tn) {
- if (level > 0) {
-
- for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
- if (tn->internal[i]) {
- ok = yaffs_verify_tnode_worker(obj,
- tn->internal[i],
- level - 1,
- (chunk_offset<<YAFFS_TNODES_INTERNAL_BITS) + i);
- }
- }
- } else if (level == 0) {
- yaffs_ext_tags tags;
- __u32 obj_id = obj->obj_id;
-
- chunk_offset <<= YAFFS_TNODES_LEVEL0_BITS;
-
- for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) {
- __u32 the_chunk = yaffs_get_group_base(dev, tn, i);
-
- if (the_chunk > 0) {
- /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.obj_id,tags.chunk_id,the_chunk)); */
- yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags);
- if (tags.obj_id != obj_id || tags.chunk_id != chunk_offset) {
- T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
- obj_id, chunk_offset, the_chunk,
- tags.obj_id, tags.chunk_id));
- }
- }
- chunk_offset++;
- }
- }
- }
- return ok;
-
-}
-
-#endif
-
-void yaffs_verify_file(yaffs_obj_t *obj)
+void yaffs_verify_file(struct yaffs_obj *obj)
{
int required_depth;
int actual_depth;
- __u32 last_chunk;
- __u32 x;
- __u32 i;
- yaffs_dev_t *dev;
- yaffs_ext_tags tags;
+ u32 last_chunk;
+ u32 x;
+ u32 i;
+ struct yaffs_dev *dev;
+ struct yaffs_ext_tags tags;
yaffs_tnode_t *tn;
- __u32 obj_id;
+ u32 obj_id;
if (!obj)
return;
tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i);
if (tn) {
- __u32 the_chunk = yaffs_get_group_base(dev, tn, i);
+ u32 the_chunk = yaffs_get_group_base(dev, tn, i);
if (the_chunk > 0) {
/* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */
yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags);
}
-void yaffs_verify_link(yaffs_obj_t *obj)
+void yaffs_verify_link(struct yaffs_obj *obj)
{
if (obj && yaffs_skip_verification(obj->my_dev))
return;
/* Verify sane equivalent object */
}
-void yaffs_verify_symlink(yaffs_obj_t *obj)
+void yaffs_verify_symlink(struct yaffs_obj *obj)
{
if (obj && yaffs_skip_verification(obj->my_dev))
return;
/* Verify symlink string */
}
-void yaffs_verify_special(yaffs_obj_t *obj)
+void yaffs_verify_special(struct yaffs_obj *obj)
{
if (obj && yaffs_skip_verification(obj->my_dev))
return;
}
-void yaffs_verify_obj(yaffs_obj_t *obj)
+void yaffs_verify_obj(struct yaffs_obj *obj)
{
- yaffs_dev_t *dev;
+ struct yaffs_dev *dev;
- __u32 chunk_min;
- __u32 chunk_max;
+ u32 chunk_min;
+ u32 chunk_max;
- __u32 chunk_id_ok;
- __u32 chunk_in_range;
- __u32 chunk_wrongly_deleted;
- __u32 chunk_valid;
+ u32 chunk_id_ok;
+ u32 chunk_in_range;
+ u32 chunk_wrongly_deleted;
+ u32 chunk_valid;
if (!obj)
return;
}
if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
- yaffs_ext_tags tags;
- yaffs_obj_header *oh;
- __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+ struct yaffs_ext_tags tags;
+ struct yaffs_obj_hdr *oh;
+ u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
- oh = (yaffs_obj_header *)buffer;
+ oh = (struct yaffs_obj_hdr *)buffer;
yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer,
&tags);
}
}
-void yaffs_verify_objects(yaffs_dev_t *dev)
+void yaffs_verify_objects(struct yaffs_dev *dev)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int i;
struct ylist_head *lh;
for (i = 0; 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);
yaffs_verify_obj(obj);
}
}
}
-void yaffs_verify_obj_in_dir(yaffs_obj_t *obj)
+void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
{
struct ylist_head *lh;
- yaffs_obj_t *list_obj;
+ struct yaffs_obj *list_obj;
int count = 0;
ylist_for_each(lh, &obj->parent->variant.dir_variant.children) {
if (lh) {
- list_obj = ylist_entry(lh, yaffs_obj_t, siblings);
+ list_obj = ylist_entry(lh, struct yaffs_obj, siblings);
yaffs_verify_obj(list_obj);
if (obj == list_obj)
count++;
}
}
-void yaffs_verify_dir(yaffs_obj_t *directory)
+void yaffs_verify_dir(struct yaffs_obj *directory)
{
struct ylist_head *lh;
- yaffs_obj_t *list_obj;
+ struct yaffs_obj *list_obj;
if (!directory) {
YBUG();
ylist_for_each(lh, &directory->variant.dir_variant.children) {
if (lh) {
- list_obj = ylist_entry(lh, yaffs_obj_t, siblings);
+ list_obj = ylist_entry(lh, struct yaffs_obj, siblings);
if (list_obj->parent != directory) {
T(YAFFS_TRACE_ALWAYS, (
TSTR("Object in directory list has wrong parent %p" TENDSTR),
static int yaffs_free_verification_failures;
-void yaffs_verify_free_chunks(yaffs_dev_t *dev)
+void yaffs_verify_free_chunks(struct yaffs_dev *dev)
{
int counted;
int difference;
}
}
-int yaffs_verify_file_sane(yaffs_obj_t *in)
+int yaffs_verify_file_sane(struct yaffs_obj *in)
{
-#if 0
- int chunk;
- int n_chunks;
- int file_size;
- int failed = 0;
- int obj_id;
- yaffs_tnode_t *tn;
- yaffs_tags_t local_tags;
- yaffs_tags_t *tags = &local_tags;
- int the_chunk;
- int is_deleted;
-
- if (in->variant_type != YAFFS_OBJECT_TYPE_FILE)
- return YAFFS_FAIL;
-
- obj_id = in->obj_id;
- file_size = in->variant.file_variant.file_size;
- n_chunks =
- (file_size + in->my_dev->data_bytes_per_chunk - 1) / in->my_dev->data_bytes_per_chunk;
-
- for (chunk = 1; chunk <= n_chunks; chunk++) {
- tn = yaffs_find_tnode_0(in->my_dev, &in->variant.file_variant,
- chunk);
-
- if (tn) {
-
- the_chunk = yaffs_get_group_base(dev, tn, chunk);
-
- if (yaffs_check_chunk_bits
- (dev, the_chunk / dev->param.chunks_per_block,
- the_chunk % dev->param.chunks_per_block)) {
-
- yaffs_rd_chunk_tags_nand(in->my_dev, the_chunk,
- tags,
- &is_deleted);
- if (yaffs_tags_match
- (tags, in->obj_id, chunk, is_deleted)) {
- /* found it; */
-
- }
- } else {
-
- failed = 1;
- }
-
- } else {
- /* T(("No level 0 found for %d\n", chunk)); */
- }
- }
-
- return failed ? YAFFS_FAIL : YAFFS_OK;
-#else
in=in;
return YAFFS_OK;
-#endif
}
projects / yaffs2.git / blobdiff