yaffs_verify.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2010 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   6  *
   7  * Created by Charles Manning <charles@aleph1.co.uk>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14
  15 #include "yaffs_verify.h"
  16 #include "yaffs_trace.h"
  17 #include "yaffs_bitmap.h"
  18 #include "yaffs_getblockinfo.h"
  19 #include "yaffs_nand.h"
  20
  21 int yaffs_skip_verification(yaffs_dev_t *dev)
  22 {
  23         dev=dev;
  24         return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
  25 }
  26
  27 static int yaffs_skip_full_verification(yaffs_dev_t *dev)
  28 {
  29         dev=dev;
  30         return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL));
  31 }
  32
  33 static int yaffs_skip_nand_verification(yaffs_dev_t *dev)
  34 {
  35         dev=dev;
  36         return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));
  37 }
  38
  39
  40 static const char *block_state_name[] = {
  41 "Unknown",
  42 "Needs scanning",
  43 "Scanning",
  44 "Empty",
  45 "Allocating",
  46 "Full",
  47 "Dirty",
  48 "Checkpoint",
  49 "Collecting",
  50 "Dead"
  51 };
  52
  53
  54 void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
  55 {
  56         int actually_used;
  57         int in_use;
  58
  59         if (yaffs_skip_verification(dev))
  60                 return;
  61
  62         /* Report illegal runtime states */
  63         if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES)
  64                 T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->block_state));
  65
  66         switch (bi->block_state) {
  67         case YAFFS_BLOCK_STATE_UNKNOWN:
  68         case YAFFS_BLOCK_STATE_SCANNING:
  69         case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
  70                 T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR),
  71                 n, block_state_name[bi->block_state]));
  72         }
  73
  74         /* Check pages in use and soft deletions are legal */
  75
  76         actually_used = bi->pages_in_use - bi->soft_del_pages;
  77
  78         if (bi->pages_in_use < 0 || bi->pages_in_use > dev->param.chunks_per_block ||
  79            bi->soft_del_pages < 0 || bi->soft_del_pages > dev->param.chunks_per_block ||
  80            actually_used < 0 || actually_used > dev->param.chunks_per_block)
  81                 T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pages_in_used %d soft_del_pages %d"TENDSTR),
  82                 n, bi->pages_in_use, bi->soft_del_pages));
  83
  84
  85         /* Check chunk bitmap legal */
  86         in_use = yaffs_count_chunk_bits(dev, n);
  87         if (in_use != bi->pages_in_use)
  88                 T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"TENDSTR),
  89                         n, bi->pages_in_use, in_use));
  90
  91 }
  92
  93
  94
  95 void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
  96 {
  97         yaffs_verify_blk(dev, bi, n);
  98
  99         /* After collection the block should be in the erased state */
 100
 101         if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING &&
 102                         bi->block_state != YAFFS_BLOCK_STATE_EMPTY) {
 103                 T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
 104                         n, bi->block_state));
 105         }
 106 }
 107
 108 void yaffs_verify_blocks(yaffs_dev_t *dev)
 109 {
 110         int i;
 111         int state_count[YAFFS_NUMBER_OF_BLOCK_STATES];
 112         int illegal_states = 0;
 113
 114         if (yaffs_skip_verification(dev))
 115                 return;
 116
 117         memset(state_count, 0, sizeof(state_count));
 118
 119         for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
 120                 yaffs_block_info_t *bi = yaffs_get_block_info(dev, i);
 121                 yaffs_verify_blk(dev, bi, i);
 122
 123                 if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES)
 124                         state_count[bi->block_state]++;
 125                 else
 126                         illegal_states++;
 127         }
 128
 129         T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
 130         T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR)));
 131
 132         T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), illegal_states));
 133         if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
 134                 T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR)));
 135
 136         for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
 137                 T(YAFFS_TRACE_VERIFY,
 138                   (TSTR("%s %d blocks"TENDSTR),
 139                   block_state_name[i], state_count[i]));
 140
 141         if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT])
 142                 T(YAFFS_TRACE_VERIFY,
 143                  (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
 144                  dev->blocks_in_checkpt, state_count[YAFFS_BLOCK_STATE_CHECKPOINT]));
 145
 146         if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY])
 147                 T(YAFFS_TRACE_VERIFY,
 148                  (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
 149                  dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY]));
 150
 151         if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1)
 152                 T(YAFFS_TRACE_VERIFY,
 153                  (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
 154                  state_count[YAFFS_BLOCK_STATE_COLLECTING]));
 155
 156         T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
 157
 158 }
 159
 160 /*
 161  * Verify the object header. oh must be valid, but obj and tags may be NULL in which
 162  * case those tests will not be performed.
 163  */
 164 void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parent_check)
 165 {
 166         if (obj && yaffs_skip_verification(obj->my_dev))
 167                 return;
 168
 169         if (!(tags && obj && oh)) {
 170                 T(YAFFS_TRACE_VERIFY,
 171                                 (TSTR("Verifying object header tags %p obj %p oh %p"TENDSTR),
 172                                 tags, obj, oh));
 173                 return;
 174         }
 175
 176         if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
 177                         oh->type > YAFFS_OBJECT_TYPE_MAX)
 178                 T(YAFFS_TRACE_VERIFY,
 179                         (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
 180                         tags->obj_id, oh->type));
 181
 182         if (tags->obj_id != obj->obj_id)
 183                 T(YAFFS_TRACE_VERIFY,
 184                         (TSTR("Obj %d header mismatch obj_id %d"TENDSTR),
 185                         tags->obj_id, obj->obj_id));
 186
 187
 188         /*
 189          * Check that the object's parent ids match if parent_check requested.
 190          *
 191          * Tests do not apply to the root object.
 192          */
 193
 194         if (parent_check && tags->obj_id > 1 && !obj->parent)
 195                 T(YAFFS_TRACE_VERIFY,
 196                         (TSTR("Obj %d header mismatch parent_id %d obj->parent is NULL"TENDSTR),
 197                         tags->obj_id, oh->parent_obj_id));
 198
 199         if (parent_check && obj->parent &&
 200                         oh->parent_obj_id != obj->parent->obj_id &&
 201                         (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED ||
 202                         obj->parent->obj_id != YAFFS_OBJECTID_DELETED))
 203                 T(YAFFS_TRACE_VERIFY,
 204                         (TSTR("Obj %d header mismatch parent_id %d parent_obj_id %d"TENDSTR),
 205                         tags->obj_id, oh->parent_obj_id, obj->parent->obj_id));
 206
 207         if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */
 208                 T(YAFFS_TRACE_VERIFY,
 209                         (TSTR("Obj %d header name is NULL"TENDSTR),
 210                         obj->obj_id));
 211
 212         if (tags->obj_id > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
 213                 T(YAFFS_TRACE_VERIFY,
 214                         (TSTR("Obj %d header name is 0xFF"TENDSTR),
 215                         obj->obj_id));
 216 }
 217
 218
 219 #if 0
 220 /* Not being used, but don't want to throw away yet */
 221 int yaffs_verify_tnode_worker(yaffs_obj_t *obj, yaffs_tnode_t *tn,
 222                                         __u32 level, int chunk_offset)
 223 {
 224         int i;
 225         yaffs_dev_t *dev = obj->my_dev;
 226         int ok = 1;
 227
 228         if (tn) {
 229                 if (level > 0) {
 230
 231                         for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
 232                                 if (tn->internal[i]) {
 233                                         ok = yaffs_verify_tnode_worker(obj,
 234                                                         tn->internal[i],
 235                                                         level - 1,
 236                                                         (chunk_offset<<YAFFS_TNODES_INTERNAL_BITS) + i);
 237                                 }
 238                         }
 239                 } else if (level == 0) {
 240                         yaffs_ext_tags tags;
 241                         __u32 obj_id = obj->obj_id;
 242
 243                         chunk_offset <<=  YAFFS_TNODES_LEVEL0_BITS;
 244
 245                         for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) {
 246                                 __u32 the_chunk = yaffs_get_group_base(dev, tn, i);
 247
 248                                 if (the_chunk > 0) {
 249                                         /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.obj_id,tags.chunk_id,the_chunk)); */
 250                                         yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags);
 251                                         if (tags.obj_id != obj_id || tags.chunk_id != chunk_offset) {
 252                                                 T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
 253                                                         obj_id, chunk_offset, the_chunk,
 254                                                         tags.obj_id, tags.chunk_id));
 255                                         }
 256                                 }
 257                                 chunk_offset++;
 258                         }
 259                 }
 260         }
 261
 262         return ok;
 263
 264 }
 265
 266 #endif
 267
 268 void yaffs_verify_file(yaffs_obj_t *obj)
 269 {
 270         int required_depth;
 271         int actual_depth;
 272         __u32 last_chunk;
 273         __u32 x;
 274         __u32 i;
 275         yaffs_dev_t *dev;
 276         yaffs_ext_tags tags;
 277         yaffs_tnode_t *tn;
 278         __u32 obj_id;
 279
 280         if (!obj)
 281                 return;
 282
 283         if (yaffs_skip_verification(obj->my_dev))
 284                 return;
 285
 286         dev = obj->my_dev;
 287         obj_id = obj->obj_id;
 288
 289         /* Check file size is consistent with tnode depth */
 290         last_chunk =  obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1;
 291         x = last_chunk >> YAFFS_TNODES_LEVEL0_BITS;
 292         required_depth = 0;
 293         while (x > 0) {
 294                 x >>= YAFFS_TNODES_INTERNAL_BITS;
 295                 required_depth++;
 296         }
 297
 298         actual_depth = obj->variant.file_variant.top_level;
 299
 300         /* Check that the chunks in the tnode tree are all correct.
 301          * We do this by scanning through the tnode tree and
 302          * checking the tags for every chunk match.
 303          */
 304
 305         if (yaffs_skip_nand_verification(dev))
 306                 return;
 307
 308         for (i = 1; i <= last_chunk; i++) {
 309                 tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i);
 310
 311                 if (tn) {
 312                         __u32 the_chunk = yaffs_get_group_base(dev, tn, i);
 313                         if (the_chunk > 0) {
 314                                 /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */
 315                                 yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags);
 316                                 if (tags.obj_id != obj_id || tags.chunk_id != i) {
 317                                         T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
 318                                                 obj_id, i, the_chunk,
 319                                                 tags.obj_id, tags.chunk_id));
 320                                 }
 321                         }
 322                 }
 323         }
 324 }
 325
 326
 327 void yaffs_verify_link(yaffs_obj_t *obj)
 328 {
 329         if (obj && yaffs_skip_verification(obj->my_dev))
 330                 return;
 331
 332         /* Verify sane equivalent object */
 333 }
 334
 335 void yaffs_verify_symlink(yaffs_obj_t *obj)
 336 {
 337         if (obj && yaffs_skip_verification(obj->my_dev))
 338                 return;
 339
 340         /* Verify symlink string */
 341 }
 342
 343 void yaffs_verify_special(yaffs_obj_t *obj)
 344 {
 345         if (obj && yaffs_skip_verification(obj->my_dev))
 346                 return;
 347 }
 348
 349 void yaffs_verify_obj(yaffs_obj_t *obj)
 350 {
 351         yaffs_dev_t *dev;
 352
 353         __u32 chunk_min;
 354         __u32 chunk_max;
 355
 356         __u32 chunk_id_ok;
 357         __u32 chunk_in_range;
 358         __u32 chunk_wrongly_deleted;
 359         __u32 chunk_valid;
 360
 361         if (!obj)
 362                 return;
 363
 364         if (obj->being_created)
 365                 return;
 366
 367         dev = obj->my_dev;
 368
 369         if (yaffs_skip_verification(dev))
 370                 return;
 371
 372         /* Check sane object header chunk */
 373
 374         chunk_min = dev->internal_start_block * dev->param.chunks_per_block;
 375         chunk_max = (dev->internal_end_block+1) * dev->param.chunks_per_block - 1;
 376
 377         chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min &&
 378                         ((unsigned)(obj->hdr_chunk)) <= chunk_max);
 379         chunk_id_ok = chunk_in_range || (obj->hdr_chunk == 0);
 380         chunk_valid = chunk_in_range &&
 381                         yaffs_check_chunk_bit(dev,
 382                                         obj->hdr_chunk / dev->param.chunks_per_block,
 383                                         obj->hdr_chunk % dev->param.chunks_per_block);
 384         chunk_wrongly_deleted = chunk_in_range && !chunk_valid;
 385
 386         if (!obj->fake &&
 387                         (!chunk_id_ok || chunk_wrongly_deleted)) {
 388                 T(YAFFS_TRACE_VERIFY,
 389                         (TSTR("Obj %d has chunk_id %d %s %s"TENDSTR),
 390                         obj->obj_id, obj->hdr_chunk,
 391                         chunk_id_ok ? "" : ",out of range",
 392                         chunk_wrongly_deleted ? ",marked as deleted" : ""));
 393         }
 394
 395         if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
 396                 yaffs_ext_tags tags;
 397                 yaffs_obj_header *oh;
 398                 __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
 399
 400                 oh = (yaffs_obj_header *)buffer;
 401
 402                 yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer,
 403                                 &tags);
 404
 405                 yaffs_verify_oh(obj, oh, &tags, 1);
 406
 407                 yaffs_release_temp_buffer(dev, buffer, __LINE__);
 408         }
 409
 410         /* Verify it has a parent */
 411         if (obj && !obj->fake &&
 412                         (!obj->parent || obj->parent->my_dev != dev)) {
 413                 T(YAFFS_TRACE_VERIFY,
 414                         (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
 415                         obj->obj_id, obj->parent));
 416         }
 417
 418         /* Verify parent is a directory */
 419         if (obj->parent && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
 420                 T(YAFFS_TRACE_VERIFY,
 421                         (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
 422                         obj->obj_id, obj->parent->variant_type));
 423         }
 424
 425         switch (obj->variant_type) {
 426         case YAFFS_OBJECT_TYPE_FILE:
 427                 yaffs_verify_file(obj);
 428                 break;
 429         case YAFFS_OBJECT_TYPE_SYMLINK:
 430                 yaffs_verify_symlink(obj);
 431                 break;
 432         case YAFFS_OBJECT_TYPE_DIRECTORY:
 433                 yaffs_verify_dir(obj);
 434                 break;
 435         case YAFFS_OBJECT_TYPE_HARDLINK:
 436                 yaffs_verify_link(obj);
 437                 break;
 438         case YAFFS_OBJECT_TYPE_SPECIAL:
 439                 yaffs_verify_special(obj);
 440                 break;
 441         case YAFFS_OBJECT_TYPE_UNKNOWN:
 442         default:
 443                 T(YAFFS_TRACE_VERIFY,
 444                 (TSTR("Obj %d has illegaltype %d"TENDSTR),
 445                 obj->obj_id, obj->variant_type));
 446                 break;
 447         }
 448 }
 449
 450 void yaffs_verify_objects(yaffs_dev_t *dev)
 451 {
 452         yaffs_obj_t *obj;
 453         int i;
 454         struct ylist_head *lh;
 455
 456         if (yaffs_skip_verification(dev))
 457                 return;
 458
 459         /* Iterate through the objects in each hash entry */
 460
 461         for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
 462                 ylist_for_each(lh, &dev->obj_bucket[i].list) {
 463                         if (lh) {
 464                                 obj = ylist_entry(lh, yaffs_obj_t, hash_link);
 465                                 yaffs_verify_obj(obj);
 466                         }
 467                 }
 468         }
 469 }
 470
 471
 472 void yaffs_verify_obj_in_dir(yaffs_obj_t *obj)
 473 {
 474         struct ylist_head *lh;
 475         yaffs_obj_t *list_obj;
 476
 477         int count = 0;
 478
 479         if (!obj) {
 480                 T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
 481                 YBUG();
 482                 return;
 483         }
 484
 485         if (yaffs_skip_verification(obj->my_dev))
 486                 return;
 487
 488         if (!obj->parent) {
 489                 T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR)));
 490                 YBUG();
 491                 return;
 492         }
 493
 494         if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
 495                 T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR)));
 496                 YBUG();
 497         }
 498
 499         /* Iterate through the objects in each hash entry */
 500
 501         ylist_for_each(lh, &obj->parent->variant.dir_variant.children) {
 502                 if (lh) {
 503                         list_obj = ylist_entry(lh, yaffs_obj_t, siblings);
 504                         yaffs_verify_obj(list_obj);
 505                         if (obj == list_obj)
 506                                 count++;
 507                 }
 508          }
 509
 510         if (count != 1) {
 511                 T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count));
 512                 YBUG();
 513         }
 514 }
 515
 516 void yaffs_verify_dir(yaffs_obj_t *directory)
 517 {
 518         struct ylist_head *lh;
 519         yaffs_obj_t *list_obj;
 520
 521         if (!directory) {
 522                 YBUG();
 523                 return;
 524         }
 525
 526         if (yaffs_skip_full_verification(directory->my_dev))
 527                 return;
 528
 529         if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
 530                 T(YAFFS_TRACE_ALWAYS,
 531                 (TSTR("Directory has wrong type: %d" TENDSTR),
 532                 directory->variant_type));
 533                 YBUG();
 534         }
 535
 536         /* Iterate through the objects in each hash entry */
 537
 538         ylist_for_each(lh, &directory->variant.dir_variant.children) {
 539                 if (lh) {
 540                         list_obj = ylist_entry(lh, yaffs_obj_t, siblings);
 541                         if (list_obj->parent != directory) {
 542                                 T(YAFFS_TRACE_ALWAYS, (
 543                                 TSTR("Object in directory list has wrong parent %p" TENDSTR),
 544                                 list_obj->parent));
 545                                 YBUG();
 546                         }
 547                         yaffs_verify_obj_in_dir(list_obj);
 548                 }
 549         }
 550 }
 551
 552 static int yaffs_free_verification_failures;
 553
 554 void yaffs_verify_free_chunks(yaffs_dev_t *dev)
 555 {
 556         int counted;
 557         int difference;
 558
 559         if (yaffs_skip_verification(dev))
 560                 return;
 561
 562         counted = yaffs_count_free_chunks(dev);
 563
 564         difference = dev->n_free_chunks - counted;
 565
 566         if (difference) {
 567                 T(YAFFS_TRACE_ALWAYS,
 568                   (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
 569                    dev->n_free_chunks, counted, difference));
 570                 yaffs_free_verification_failures++;
 571         }
 572 }
 573
 574 int yaffs_verify_file_sane(yaffs_obj_t *in)
 575 {
 576 #if 0
 577         int chunk;
 578         int n_chunks;
 579         int file_size;
 580         int failed = 0;
 581         int obj_id;
 582         yaffs_tnode_t *tn;
 583         yaffs_tags_t local_tags;
 584         yaffs_tags_t *tags = &local_tags;
 585         int the_chunk;
 586         int is_deleted;
 587
 588         if (in->variant_type != YAFFS_OBJECT_TYPE_FILE)
 589                 return YAFFS_FAIL;
 590
 591         obj_id = in->obj_id;
 592         file_size = in->variant.file_variant.file_size;
 593         n_chunks =
 594             (file_size + in->my_dev->data_bytes_per_chunk - 1) / in->my_dev->data_bytes_per_chunk;
 595
 596         for (chunk = 1; chunk <= n_chunks; chunk++) {
 597                 tn = yaffs_find_tnode_0(in->my_dev, &in->variant.file_variant,
 598                                            chunk);
 599
 600                 if (tn) {
 601
 602                         the_chunk = yaffs_get_group_base(dev, tn, chunk);
 603
 604                         if (yaffs_check_chunk_bits
 605                             (dev, the_chunk / dev->param.chunks_per_block,
 606                              the_chunk % dev->param.chunks_per_block)) {
 607
 608                                 yaffs_rd_chunk_tags_nand(in->my_dev, the_chunk,
 609                                                             tags,
 610                                                             &is_deleted);
 611                                 if (yaffs_tags_match
 612                                     (tags, in->obj_id, chunk, is_deleted)) {
 613                                         /* found it; */
 614
 615                                 }
 616                         } else {
 617
 618                                 failed = 1;
 619                         }
 620
 621                 } else {
 622                         /* T(("No level 0 found for %d\n", chunk)); */
 623                 }
 624         }
 625
 626         return failed ? YAFFS_FAIL : YAFFS_OK;
 627 #else
 628         in=in;
 629         return YAFFS_OK;
 630 #endif
 631 }