yaffs_yaffs2.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_guts.h"
  16 #include "yaffs_trace.h"
  17 #include "yaffs_yaffs2.h"
  18 #include "yaffs_checkptrw.h"
  19 #include "yaffs_bitmap.h"
  20 #include "yaffs_qsort.h"
  21 #include "yaffs_nand.h"
  22 #include "yaffs_getblockinfo.h"
  23
  24 /*
  25  * Checkpoints are really no benefit on very small partitions.
  26  *
  27  * To save space on small partitions don't bother with checkpoints unless
  28  * the partition is at least this big.
  29  */
  30 #define YAFFS_CHECKPOINT_MIN_BLOCKS 60
  31
  32 #define YAFFS_SMALL_HOLE_THRESHOLD 4
  33
  34
  35 /*
  36  * Oldest Dirty Sequence Number handling.
  37  */
  38
  39 /* yaffs2_CalcOldestDirtySequence()
  40  * yaffs2_FindOldestDirtySequence()
  41  * Calculate the oldest dirty sequence number if we don't know it.
  42  */
  43 void yaffs2_CalcOldestDirtySequence(yaffs_Device *dev)
  44 {
  45         int i;
  46         unsigned seq;
  47         unsigned blockNo = 0;
  48         yaffs_BlockInfo *b;
  49
  50         if(!dev->param.isYaffs2)
  51                 return;
  52
  53         /* Find the oldest dirty sequence number. */
  54         seq = dev->sequenceNumber + 1;
  55         b = dev->blockInfo;
  56         for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
  57                 if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
  58                         (b->pagesInUse - b->softDeletions) < dev->param.nChunksPerBlock &&
  59                         b->sequenceNumber < seq) {
  60                         seq = b->sequenceNumber;
  61                         blockNo = i;
  62                 }
  63                 b++;
  64         }
  65
  66         if(blockNo){
  67                 dev->oldestDirtySequence = seq;
  68                 dev->oldestDirtyBlock = blockNo;
  69         }
  70
  71 }
  72
  73
  74 void yaffs2_FindOldestDirtySequence(yaffs_Device *dev)
  75 {
  76         if(!dev->param.isYaffs2)
  77                 return;
  78
  79         if(!dev->oldestDirtySequence)
  80                 yaffs2_CalcOldestDirtySequence(dev);
  81 }
  82
  83 /*
  84  * yaffs_ClearOldestDirtySequence()
  85  * Called when a block is erased or marked bad. (ie. when its sequenceNumber
  86  * becomes invalid). If the value matches the oldest then we clear
  87  * dev->oldestDirtySequence to force its recomputation.
  88  */
  89 void yaffs2_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi)
  90 {
  91
  92         if(!dev->param.isYaffs2)
  93                 return;
  94
  95         if(!bi || bi->sequenceNumber == dev->oldestDirtySequence){
  96                 dev->oldestDirtySequence = 0;
  97                 dev->oldestDirtyBlock = 0;
  98         }
  99 }
 100
 101 /*
 102  * yaffs2_UpdateOldestDirtySequence()
 103  * Update the oldest dirty sequence number whenever we dirty a block.
 104  * Only do this if the oldestDirtySequence is actually being tracked.
 105  */
 106 void yaffs2_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi)
 107 {
 108         if(!dev->param.isYaffs2)
 109                 return;
 110
 111         if(dev->oldestDirtySequence){
 112                 if(dev->oldestDirtySequence > bi->sequenceNumber){
 113                         dev->oldestDirtySequence = bi->sequenceNumber;
 114                         dev->oldestDirtyBlock = blockNo;
 115                 }
 116         }
 117 }
 118
 119 int yaffs2_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
 120                                         yaffs_BlockInfo *bi)
 121 {
 122
 123         if (!dev->param.isYaffs2)
 124                 return 1;       /* disqualification only applies to yaffs2. */
 125
 126         if (!bi->hasShrinkHeader)
 127                 return 1;       /* can gc */
 128
 129         yaffs2_FindOldestDirtySequence(dev);
 130
 131         /* Can't do gc of this block if there are any blocks older than this one that have
 132          * discarded pages.
 133          */
 134         return (bi->sequenceNumber <= dev->oldestDirtySequence);
 135 }
 136
 137 /*
 138  * yaffs2_FindRefreshBlock()
 139  * periodically finds the oldest full block by sequence number for refreshing.
 140  * Only for yaffs2.
 141  */
 142 __u32 yaffs2_FindRefreshBlock(yaffs_Device *dev)
 143 {
 144         __u32 b ;
 145
 146         __u32 oldest = 0;
 147         __u32 oldestSequence = 0;
 148
 149         yaffs_BlockInfo *bi;
 150
 151         if(!dev->param.isYaffs2)
 152                 return oldest;
 153
 154         /*
 155          * If refresh period < 10 then refreshing is disabled.
 156          */
 157         if(dev->param.refreshPeriod < 10)
 158                 return oldest;
 159
 160         /*
 161          * Fix broken values.
 162          */
 163         if(dev->refreshSkip > dev->param.refreshPeriod)
 164                 dev->refreshSkip = dev->param.refreshPeriod;
 165
 166         if(dev->refreshSkip > 0)
 167                 return oldest;
 168
 169         /*
 170          * Refresh skip is now zero.
 171          * We'll do a refresh this time around....
 172          * Update the refresh skip and find the oldest block.
 173          */
 174         dev->refreshSkip = dev->param.refreshPeriod;
 175         dev->refreshCount++;
 176         bi = dev->blockInfo;
 177         for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){
 178
 179                 if (bi->blockState == YAFFS_BLOCK_STATE_FULL){
 180
 181                         if(oldest < 1 ||
 182                                 bi->sequenceNumber < oldestSequence){
 183                                 oldest = b;
 184                                 oldestSequence = bi->sequenceNumber;
 185                         }
 186                 }
 187                 bi++;
 188         }
 189
 190         if (oldest > 0) {
 191                 T(YAFFS_TRACE_GC,
 192                   (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR),
 193                    dev->refreshCount, oldest, oldestSequence));
 194         }
 195
 196         return oldest;
 197 }
 198
 199 int yaffs2_CheckpointRequired(yaffs_Device *dev)
 200 {
 201         int nblocks;
 202
 203         if(!dev->param.isYaffs2)
 204                 return 0;
 205
 206         nblocks = dev->internalEndBlock - dev->internalStartBlock + 1 ;
 207
 208         return  !dev->param.skipCheckpointWrite &&
 209                 (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);
 210 }
 211
 212 int yaffs2_CalcCheckpointBlocksRequired(yaffs_Device *dev)
 213 {
 214         int retval;
 215
 216         if(!dev->param.isYaffs2)
 217                 return 0;
 218
 219         if (!dev->nCheckpointBlocksRequired &&
 220                 yaffs2_CheckpointRequired(dev)){
 221                 /* Not a valid value so recalculate */
 222                 int nBytes = 0;
 223                 int nBlocks;
 224                 int devBlocks = (dev->param.endBlock - dev->param.startBlock + 1);
 225
 226                 nBytes += sizeof(yaffs_CheckpointValidity);
 227                 nBytes += sizeof(yaffs_CheckpointDevice);
 228                 nBytes += devBlocks * sizeof(yaffs_BlockInfo);
 229                 nBytes += devBlocks * dev->chunkBitmapStride;
 230                 nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjects);
 231                 nBytes += (dev->tnodeSize + sizeof(__u32)) * (dev->nTnodes);
 232                 nBytes += sizeof(yaffs_CheckpointValidity);
 233                 nBytes += sizeof(__u32); /* checksum*/
 234
 235                 /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
 236
 237                 nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->param.nChunksPerBlock)) + 3;
 238
 239                 dev->nCheckpointBlocksRequired = nBlocks;
 240         }
 241
 242         retval = dev->nCheckpointBlocksRequired - dev->blocksInCheckpoint;
 243         if(retval < 0)
 244                 retval = 0;
 245         return retval;
 246 }
 247
 248 /*--------------------- Checkpointing --------------------*/
 249
 250
 251 static int yaffs2_WriteCheckpointValidityMarker(yaffs_Device *dev, int head)
 252 {
 253         yaffs_CheckpointValidity cp;
 254
 255         memset(&cp, 0, sizeof(cp));
 256
 257         cp.structType = sizeof(cp);
 258         cp.magic = YAFFS_MAGIC;
 259         cp.version = YAFFS_CHECKPOINT_VERSION;
 260         cp.head = (head) ? 1 : 0;
 261
 262         return (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)) ?
 263                 1 : 0;
 264 }
 265
 266 static int yaffs2_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
 267 {
 268         yaffs_CheckpointValidity cp;
 269         int ok;
 270
 271         ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
 272
 273         if (ok)
 274                 ok = (cp.structType == sizeof(cp)) &&
 275                      (cp.magic == YAFFS_MAGIC) &&
 276                      (cp.version == YAFFS_CHECKPOINT_VERSION) &&
 277                      (cp.head == ((head) ? 1 : 0));
 278         return ok ? 1 : 0;
 279 }
 280
 281 static void yaffs2_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
 282                                            yaffs_Device *dev)
 283 {
 284         cp->nErasedBlocks = dev->nErasedBlocks;
 285         cp->allocationBlock = dev->allocationBlock;
 286         cp->allocationPage = dev->allocationPage;
 287         cp->nFreeChunks = dev->nFreeChunks;
 288
 289         cp->nDeletedFiles = dev->nDeletedFiles;
 290         cp->nUnlinkedFiles = dev->nUnlinkedFiles;
 291         cp->nBackgroundDeletions = dev->nBackgroundDeletions;
 292         cp->sequenceNumber = dev->sequenceNumber;
 293
 294 }
 295
 296 static void yaffs2_CheckpointDeviceToDevice(yaffs_Device *dev,
 297                                            yaffs_CheckpointDevice *cp)
 298 {
 299         dev->nErasedBlocks = cp->nErasedBlocks;
 300         dev->allocationBlock = cp->allocationBlock;
 301         dev->allocationPage = cp->allocationPage;
 302         dev->nFreeChunks = cp->nFreeChunks;
 303
 304         dev->nDeletedFiles = cp->nDeletedFiles;
 305         dev->nUnlinkedFiles = cp->nUnlinkedFiles;
 306         dev->nBackgroundDeletions = cp->nBackgroundDeletions;
 307         dev->sequenceNumber = cp->sequenceNumber;
 308 }
 309
 310
 311 static int yaffs2_WriteCheckpointDevice(yaffs_Device *dev)
 312 {
 313         yaffs_CheckpointDevice cp;
 314         __u32 nBytes;
 315         __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 316
 317         int ok;
 318
 319         /* Write device runtime values*/
 320         yaffs2_DeviceToCheckpointDevice(&cp, dev);
 321         cp.structType = sizeof(cp);
 322
 323         ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
 324
 325         /* Write block info */
 326         if (ok) {
 327                 nBytes = nBlocks * sizeof(yaffs_BlockInfo);
 328                 ok = (yaffs2_CheckpointWrite(dev, dev->blockInfo, nBytes) == nBytes);
 329         }
 330
 331         /* Write chunk bits */
 332         if (ok) {
 333                 nBytes = nBlocks * dev->chunkBitmapStride;
 334                 ok = (yaffs2_CheckpointWrite(dev, dev->chunkBits, nBytes) == nBytes);
 335         }
 336         return   ok ? 1 : 0;
 337
 338 }
 339
 340 static int yaffs2_ReadCheckpointDevice(yaffs_Device *dev)
 341 {
 342         yaffs_CheckpointDevice cp;
 343         __u32 nBytes;
 344         __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 345
 346         int ok;
 347
 348         ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
 349         if (!ok)
 350                 return 0;
 351
 352         if (cp.structType != sizeof(cp))
 353                 return 0;
 354
 355
 356         yaffs2_CheckpointDeviceToDevice(dev, &cp);
 357
 358         nBytes = nBlocks * sizeof(yaffs_BlockInfo);
 359
 360         ok = (yaffs2_CheckpointRead(dev, dev->blockInfo, nBytes) == nBytes);
 361
 362         if (!ok)
 363                 return 0;
 364         nBytes = nBlocks * dev->chunkBitmapStride;
 365
 366         ok = (yaffs2_CheckpointRead(dev, dev->chunkBits, nBytes) == nBytes);
 367
 368         return ok ? 1 : 0;
 369 }
 370
 371 static void yaffs2_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
 372                                            yaffs_Object *obj)
 373 {
 374
 375         cp->objectId = obj->objectId;
 376         cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
 377         cp->hdrChunk = obj->hdrChunk;
 378         cp->variantType = obj->variantType;
 379         cp->deleted = obj->deleted;
 380         cp->softDeleted = obj->softDeleted;
 381         cp->unlinked = obj->unlinked;
 382         cp->fake = obj->fake;
 383         cp->renameAllowed = obj->renameAllowed;
 384         cp->unlinkAllowed = obj->unlinkAllowed;
 385         cp->serial = obj->serial;
 386         cp->nDataChunks = obj->nDataChunks;
 387
 388         if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
 389                 cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
 390         else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
 391                 cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId;
 392 }
 393
 394 static int yaffs2_CheckpointObjectToObject(yaffs_Object *obj, yaffs_CheckpointObject *cp)
 395 {
 396
 397         yaffs_Object *parent;
 398
 399         if (obj->variantType != cp->variantType) {
 400                 T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "
 401                         TCONT("chunk %d does not match existing object type %d")
 402                         TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk,
 403                         obj->variantType));
 404                 return 0;
 405         }
 406
 407         obj->objectId = cp->objectId;
 408
 409         if (cp->parentId)
 410                 parent = yaffs_FindOrCreateObjectByNumber(
 411                                         obj->myDev,
 412                                         cp->parentId,
 413                                         YAFFS_OBJECT_TYPE_DIRECTORY);
 414         else
 415                 parent = NULL;
 416
 417         if (parent) {
 418                 if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
 419                         T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d"
 420                                 TCONT(" chunk %d Parent type, %d, not directory")
 421                                 TENDSTR),
 422                                 cp->objectId, cp->parentId, cp->variantType,
 423                                 cp->hdrChunk, parent->variantType));
 424                         return 0;
 425                 }
 426                 yaffs_AddObjectToDirectory(parent, obj);
 427         }
 428
 429         obj->hdrChunk = cp->hdrChunk;
 430         obj->variantType = cp->variantType;
 431         obj->deleted = cp->deleted;
 432         obj->softDeleted = cp->softDeleted;
 433         obj->unlinked = cp->unlinked;
 434         obj->fake = cp->fake;
 435         obj->renameAllowed = cp->renameAllowed;
 436         obj->unlinkAllowed = cp->unlinkAllowed;
 437         obj->serial = cp->serial;
 438         obj->nDataChunks = cp->nDataChunks;
 439
 440         if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
 441                 obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
 442         else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
 443                 obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
 444
 445         if (obj->hdrChunk > 0)
 446                 obj->lazyLoaded = 1;
 447         return 1;
 448 }
 449
 450
 451
 452 static int yaffs2_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn,
 453                                         __u32 level, int chunkOffset)
 454 {
 455         int i;
 456         yaffs_Device *dev = in->myDev;
 457         int ok = 1;
 458
 459         if (tn) {
 460                 if (level > 0) {
 461
 462                         for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
 463                                 if (tn->internal[i]) {
 464                                         ok = yaffs2_CheckpointTnodeWorker(in,
 465                                                         tn->internal[i],
 466                                                         level - 1,
 467                                                         (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
 468                                 }
 469                         }
 470                 } else if (level == 0) {
 471                         __u32 baseOffset = chunkOffset <<  YAFFS_TNODES_LEVEL0_BITS;
 472                         ok = (yaffs2_CheckpointWrite(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset));
 473                         if (ok)
 474                                 ok = (yaffs2_CheckpointWrite(dev, tn, dev->tnodeSize) == dev->tnodeSize);
 475                 }
 476         }
 477
 478         return ok;
 479
 480 }
 481
 482 static int yaffs2_WriteCheckpointTnodes(yaffs_Object *obj)
 483 {
 484         __u32 endMarker = ~0;
 485         int ok = 1;
 486
 487         if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
 488                 ok = yaffs2_CheckpointTnodeWorker(obj,
 489                                             obj->variant.fileVariant.top,
 490                                             obj->variant.fileVariant.topLevel,
 491                                             0);
 492                 if (ok)
 493                         ok = (yaffs2_CheckpointWrite(obj->myDev, &endMarker, sizeof(endMarker)) ==
 494                                 sizeof(endMarker));
 495         }
 496
 497         return ok ? 1 : 0;
 498 }
 499
 500 static int yaffs2_ReadCheckpointTnodes(yaffs_Object *obj)
 501 {
 502         __u32 baseChunk;
 503         int ok = 1;
 504         yaffs_Device *dev = obj->myDev;
 505         yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
 506         yaffs_Tnode *tn;
 507         int nread = 0;
 508
 509         ok = (yaffs2_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
 510
 511         while (ok && (~baseChunk)) {
 512                 nread++;
 513                 /* Read level 0 tnode */
 514
 515
 516                 tn = yaffs_GetTnode(dev);
 517                 if (tn){
 518                         ok = (yaffs2_CheckpointRead(dev, tn, dev->tnodeSize) == dev->tnodeSize);
 519                 } else
 520                         ok = 0;
 521
 522                 if (tn && ok)
 523                         ok = yaffs_AddOrFindLevel0Tnode(dev,
 524                                                         fileStructPtr,
 525                                                         baseChunk,
 526                                                         tn) ? 1 : 0;
 527
 528                 if (ok)
 529                         ok = (yaffs2_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
 530
 531         }
 532
 533         T(YAFFS_TRACE_CHECKPOINT, (
 534                 TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
 535                 nread, baseChunk, ok));
 536
 537         return ok ? 1 : 0;
 538 }
 539
 540
 541 static int yaffs2_WriteCheckpointObjects(yaffs_Device *dev)
 542 {
 543         yaffs_Object *obj;
 544         yaffs_CheckpointObject cp;
 545         int i;
 546         int ok = 1;
 547         struct ylist_head *lh;
 548
 549
 550         /* Iterate through the objects in each hash entry,
 551          * dumping them to the checkpointing stream.
 552          */
 553
 554         for (i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++) {
 555                 ylist_for_each(lh, &dev->objectBucket[i].list) {
 556                         if (lh) {
 557                                 obj = ylist_entry(lh, yaffs_Object, hashLink);
 558                                 if (!obj->deferedFree) {
 559                                         yaffs2_ObjectToCheckpointObject(&cp, obj);
 560                                         cp.structType = sizeof(cp);
 561
 562                                         T(YAFFS_TRACE_CHECKPOINT, (
 563                                                 TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR),
 564                                                 cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, obj));
 565
 566                                         ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
 567
 568                                         if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE)
 569                                                 ok = yaffs2_WriteCheckpointTnodes(obj);
 570                                 }
 571                         }
 572                 }
 573         }
 574
 575         /* Dump end of list */
 576         memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject));
 577         cp.structType = sizeof(cp);
 578
 579         if (ok)
 580                 ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
 581
 582         return ok ? 1 : 0;
 583 }
 584
 585 static int yaffs2_ReadCheckpointObjects(yaffs_Device *dev)
 586 {
 587         yaffs_Object *obj;
 588         yaffs_CheckpointObject cp;
 589         int ok = 1;
 590         int done = 0;
 591         yaffs_Object *hardList = NULL;
 592
 593         while (ok && !done) {
 594                 ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
 595                 if (cp.structType != sizeof(cp)) {
 596                         T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR),
 597                                 cp.structType, (int)sizeof(cp), ok));
 598                         ok = 0;
 599                 }
 600
 601                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
 602                         cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk));
 603
 604                 if (ok && cp.objectId == ~0)
 605                         done = 1;
 606                 else if (ok) {
 607                         obj = yaffs_FindOrCreateObjectByNumber(dev, cp.objectId, cp.variantType);
 608                         if (obj) {
 609                                 ok = yaffs2_CheckpointObjectToObject(obj, &cp);
 610                                 if (!ok)
 611                                         break;
 612                                 if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
 613                                         ok = yaffs2_ReadCheckpointTnodes(obj);
 614                                 } else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
 615                                         obj->hardLinks.next =
 616                                                 (struct ylist_head *) hardList;
 617                                         hardList = obj;
 618                                 }
 619                         } else
 620                                 ok = 0;
 621                 }
 622         }
 623
 624         if (ok)
 625                 yaffs_HardlinkFixup(dev, hardList);
 626
 627         return ok ? 1 : 0;
 628 }
 629
 630 static int yaffs2_WriteCheckpointSum(yaffs_Device *dev)
 631 {
 632         __u32 checkpointSum;
 633         int ok;
 634
 635         yaffs2_GetCheckpointSum(dev, &checkpointSum);
 636
 637         ok = (yaffs2_CheckpointWrite(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum));
 638
 639         if (!ok)
 640                 return 0;
 641
 642         return 1;
 643 }
 644
 645 static int yaffs2_ReadCheckpointSum(yaffs_Device *dev)
 646 {
 647         __u32 checkpointSum0;
 648         __u32 checkpointSum1;
 649         int ok;
 650
 651         yaffs2_GetCheckpointSum(dev, &checkpointSum0);
 652
 653         ok = (yaffs2_CheckpointRead(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1));
 654
 655         if (!ok)
 656                 return 0;
 657
 658         if (checkpointSum0 != checkpointSum1)
 659                 return 0;
 660
 661         return 1;
 662 }
 663
 664
 665 static int yaffs2_WriteCheckpointData(yaffs_Device *dev)
 666 {
 667         int ok = 1;
 668
 669         if (!yaffs2_CheckpointRequired(dev)) {
 670                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR)));
 671                 ok = 0;
 672         }
 673
 674         if (ok)
 675                 ok = yaffs2_CheckpointOpen(dev, 1);
 676
 677         if (ok) {
 678                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
 679                 ok = yaffs2_WriteCheckpointValidityMarker(dev, 1);
 680         }
 681         if (ok) {
 682                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR)));
 683                 ok = yaffs2_WriteCheckpointDevice(dev);
 684         }
 685         if (ok) {
 686                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR)));
 687                 ok = yaffs2_WriteCheckpointObjects(dev);
 688         }
 689         if (ok) {
 690                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
 691                 ok = yaffs2_WriteCheckpointValidityMarker(dev, 0);
 692         }
 693
 694         if (ok)
 695                 ok = yaffs2_WriteCheckpointSum(dev);
 696
 697         if (!yaffs2_CheckpointClose(dev))
 698                 ok = 0;
 699
 700         if (ok)
 701                 dev->isCheckpointed = 1;
 702         else
 703                 dev->isCheckpointed = 0;
 704
 705         return dev->isCheckpointed;
 706 }
 707
 708 static int yaffs2_ReadCheckpointData(yaffs_Device *dev)
 709 {
 710         int ok = 1;
 711
 712         if(!dev->param.isYaffs2)
 713                 ok = 0;
 714
 715         if (ok && dev->param.skipCheckpointRead) {
 716                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR)));
 717                 ok = 0;
 718         }
 719
 720         if (ok)
 721                 ok = yaffs2_CheckpointOpen(dev, 0); /* open for read */
 722
 723         if (ok) {
 724                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
 725                 ok = yaffs2_ReadCheckpointValidityMarker(dev, 1);
 726         }
 727         if (ok) {
 728                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR)));
 729                 ok = yaffs2_ReadCheckpointDevice(dev);
 730         }
 731         if (ok) {
 732                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR)));
 733                 ok = yaffs2_ReadCheckpointObjects(dev);
 734         }
 735         if (ok) {
 736                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
 737                 ok = yaffs2_ReadCheckpointValidityMarker(dev, 0);
 738         }
 739
 740         if (ok) {
 741                 ok = yaffs2_ReadCheckpointSum(dev);
 742                 T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok));
 743         }
 744
 745         if (!yaffs2_CheckpointClose(dev))
 746                 ok = 0;
 747
 748         if (ok)
 749                 dev->isCheckpointed = 1;
 750         else
 751                 dev->isCheckpointed = 0;
 752
 753         return ok ? 1 : 0;
 754
 755 }
 756
 757 void yaffs2_InvalidateCheckpoint(yaffs_Device *dev)
 758 {
 759         if (dev->isCheckpointed ||
 760                         dev->blocksInCheckpoint > 0) {
 761                 dev->isCheckpointed = 0;
 762                 yaffs2_CheckpointInvalidateStream(dev);
 763         }
 764         if (dev->param.markSuperBlockDirty)
 765                 dev->param.markSuperBlockDirty(dev);
 766 }
 767
 768
 769 int yaffs_CheckpointSave(yaffs_Device *dev)
 770 {
 771
 772         T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
 773
 774         yaffs_VerifyObjects(dev);
 775         yaffs_VerifyBlocks(dev);
 776         yaffs_VerifyFreeChunks(dev);
 777
 778         if (!dev->isCheckpointed) {
 779                 yaffs2_InvalidateCheckpoint(dev);
 780                 yaffs2_WriteCheckpointData(dev);
 781         }
 782
 783         T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
 784
 785         return dev->isCheckpointed;
 786 }
 787
 788 int yaffs2_CheckpointRestore(yaffs_Device *dev)
 789 {
 790         int retval;
 791         T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
 792
 793         retval = yaffs2_ReadCheckpointData(dev);
 794
 795         if (dev->isCheckpointed) {
 796                 yaffs_VerifyObjects(dev);
 797                 yaffs_VerifyBlocks(dev);
 798                 yaffs_VerifyFreeChunks(dev);
 799         }
 800
 801         T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
 802
 803         return retval;
 804 }
 805
 806 int yaffs2_HandleHole(yaffs_Object *obj, loff_t newSize)
 807 {
 808         /* if newsSize > oldFileSize.
 809          * We're going to be writing a hole.
 810          * If the hole is small then write zeros otherwise write a start of hole marker.
 811          */
 812
 813
 814         loff_t oldFileSize;
 815         int increase;
 816         int smallHole   ;
 817         int result = YAFFS_OK;
 818         yaffs_Device *dev = NULL;
 819
 820         __u8 *localBuffer = NULL;
 821
 822         int smallIncreaseOk = 0;
 823
 824         if(!obj)
 825                 return YAFFS_FAIL;
 826
 827         if(obj->variantType != YAFFS_OBJECT_TYPE_FILE)
 828                 return YAFFS_FAIL;
 829
 830         dev = obj->myDev;
 831
 832         /* Bail out if not yaffs2 mode */
 833         if(!dev->param.isYaffs2)
 834                 return YAFFS_OK;
 835
 836         oldFileSize = obj->variant.fileVariant.fileSize;
 837
 838         if (newSize <= oldFileSize)
 839                 return YAFFS_OK;
 840
 841         increase = newSize - oldFileSize;
 842
 843         if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->nDataBytesPerChunk &&
 844                 yaffs_CheckSpaceForAllocation(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1))
 845                 smallHole = 1;
 846         else
 847                 smallHole = 0;
 848
 849         if(smallHole)
 850                 localBuffer= yaffs_GetTempBuffer(dev, __LINE__);
 851
 852         if(localBuffer){
 853                 /* fill hole with zero bytes */
 854                 int pos = oldFileSize;
 855                 int thisWrite;
 856                 int written;
 857                 memset(localBuffer,0,dev->nDataBytesPerChunk);
 858                 smallIncreaseOk = 1;
 859
 860                 while(increase > 0 && smallIncreaseOk){
 861                         thisWrite = increase;
 862                         if(thisWrite > dev->nDataBytesPerChunk)
 863                                 thisWrite = dev->nDataBytesPerChunk;
 864                         written = yaffs_DoWriteDataToFile(obj,localBuffer,pos,thisWrite,0);
 865                         if(written == thisWrite){
 866                                 pos += thisWrite;
 867                                 increase -= thisWrite;
 868                         } else
 869                                 smallIncreaseOk = 0;
 870                 }
 871
 872                 yaffs_ReleaseTempBuffer(dev,localBuffer,__LINE__);
 873
 874                 /* If we were out of space then reverse any chunks we've added */
 875                 if(!smallIncreaseOk)
 876                         yaffs_ResizeDown(obj, oldFileSize);
 877         }
 878
 879         if (!smallIncreaseOk &&
 880                 obj->parent &&
 881                 obj->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
 882                 obj->parent->objectId != YAFFS_OBJECTID_DELETED){
 883                 /* Write a hole start header with the old file size */
 884                 yaffs_UpdateObjectHeader(obj, NULL, 0, 1, 0, NULL);
 885         }
 886
 887         return result;
 888
 889 }
 890
 891
 892 typedef struct {
 893         int seq;
 894         int block;
 895 } yaffs_BlockIndex;
 896
 897
 898 static int yaffs2_ybicmp(const void *a, const void *b)
 899 {
 900         register int aseq = ((yaffs_BlockIndex *)a)->seq;
 901         register int bseq = ((yaffs_BlockIndex *)b)->seq;
 902         register int ablock = ((yaffs_BlockIndex *)a)->block;
 903         register int bblock = ((yaffs_BlockIndex *)b)->block;
 904         if (aseq == bseq)
 905                 return ablock - bblock;
 906         else
 907                 return aseq - bseq;
 908 }
 909
 910 int yaffs2_ScanBackwards(yaffs_Device *dev)
 911 {
 912         yaffs_ExtendedTags tags;
 913         int blk;
 914         int blockIterator;
 915         int startIterator;
 916         int endIterator;
 917         int nBlocksToScan = 0;
 918
 919         int chunk;
 920         int result;
 921         int c;
 922         int deleted;
 923         yaffs_BlockState state;
 924         yaffs_Object *hardList = NULL;
 925         yaffs_BlockInfo *bi;
 926         __u32 sequenceNumber;
 927         yaffs_ObjectHeader *oh;
 928         yaffs_Object *in;
 929         yaffs_Object *parent;
 930         int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
 931         int itsUnlinked;
 932         __u8 *chunkData;
 933
 934         int fileSize;
 935         int isShrink;
 936         int foundChunksInBlock;
 937         int equivalentObjectId;
 938         int alloc_failed = 0;
 939
 940
 941         yaffs_BlockIndex *blockIndex = NULL;
 942         int altBlockIndex = 0;
 943
 944         T(YAFFS_TRACE_SCAN,
 945           (TSTR
 946            ("yaffs2_ScanBackwards starts  intstartblk %d intendblk %d..."
 947             TENDSTR), dev->internalStartBlock, dev->internalEndBlock));
 948
 949
 950         dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
 951
 952         blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
 953
 954         if (!blockIndex) {
 955                 blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
 956                 altBlockIndex = 1;
 957         }
 958
 959         if (!blockIndex) {
 960                 T(YAFFS_TRACE_SCAN,
 961                   (TSTR("yaffs2_ScanBackwards() could not allocate block index!" TENDSTR)));
 962                 return YAFFS_FAIL;
 963         }
 964
 965         dev->blocksInCheckpoint = 0;
 966
 967         chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 968
 969         /* Scan all the blocks to determine their state */
 970         bi = dev->blockInfo;
 971         for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
 972                 yaffs_ClearChunkBits(dev, blk);
 973                 bi->pagesInUse = 0;
 974                 bi->softDeletions = 0;
 975
 976                 yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber);
 977
 978                 bi->blockState = state;
 979                 bi->sequenceNumber = sequenceNumber;
 980
 981                 if (bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
 982                         bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
 983                 if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
 984                         bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
 985
 986                 T(YAFFS_TRACE_SCAN_DEBUG,
 987                   (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
 988                    state, sequenceNumber));
 989
 990
 991                 if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
 992                         dev->blocksInCheckpoint++;
 993
 994                 } else if (state == YAFFS_BLOCK_STATE_DEAD) {
 995                         T(YAFFS_TRACE_BAD_BLOCKS,
 996                           (TSTR("block %d is bad" TENDSTR), blk));
 997                 } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
 998                         T(YAFFS_TRACE_SCAN_DEBUG,
 999                           (TSTR("Block empty " TENDSTR)));
1000                         dev->nErasedBlocks++;
1001                         dev->nFreeChunks += dev->param.nChunksPerBlock;
1002                 } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
1003
1004                         /* Determine the highest sequence number */
1005                         if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
1006                             sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
1007
1008                                 blockIndex[nBlocksToScan].seq = sequenceNumber;
1009                                 blockIndex[nBlocksToScan].block = blk;
1010
1011                                 nBlocksToScan++;
1012
1013                                 if (sequenceNumber >= dev->sequenceNumber)
1014                                         dev->sequenceNumber = sequenceNumber;
1015                         } else {
1016                                 /* TODO: Nasty sequence number! */
1017                                 T(YAFFS_TRACE_SCAN,
1018                                   (TSTR
1019                                    ("Block scanning block %d has bad sequence number %d"
1020                                     TENDSTR), blk, sequenceNumber));
1021
1022                         }
1023                 }
1024                 bi++;
1025         }
1026
1027         T(YAFFS_TRACE_SCAN,
1028         (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan));
1029
1030
1031
1032         YYIELD();
1033
1034         /* Sort the blocks by sequence number*/
1035         yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), yaffs2_ybicmp);
1036
1037         YYIELD();
1038
1039         T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
1040
1041         /* Now scan the blocks looking at the data. */
1042         startIterator = 0;
1043         endIterator = nBlocksToScan - 1;
1044         T(YAFFS_TRACE_SCAN_DEBUG,
1045           (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
1046
1047         /* For each block.... backwards */
1048         for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator;
1049                         blockIterator--) {
1050                 /* Cooperative multitasking! This loop can run for so
1051                    long that watchdog timers expire. */
1052                 YYIELD();
1053
1054                 /* get the block to scan in the correct order */
1055                 blk = blockIndex[blockIterator].block;
1056
1057                 bi = yaffs_GetBlockInfo(dev, blk);
1058
1059
1060                 state = bi->blockState;
1061
1062                 deleted = 0;
1063
1064                 /* For each chunk in each block that needs scanning.... */
1065                 foundChunksInBlock = 0;
1066                 for (c = dev->param.nChunksPerBlock - 1;
1067                      !alloc_failed && c >= 0 &&
1068                      (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
1069                       state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
1070                         /* Scan backwards...
1071                          * Read the tags and decide what to do
1072                          */
1073
1074                         chunk = blk * dev->param.nChunksPerBlock + c;
1075
1076                         result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
1077                                                         &tags);
1078
1079                         /* Let's have a good look at this chunk... */
1080
1081                         if (!tags.chunkUsed) {
1082                                 /* An unassigned chunk in the block.
1083                                  * If there are used chunks after this one, then
1084                                  * it is a chunk that was skipped due to failing the erased
1085                                  * check. Just skip it so that it can be deleted.
1086                                  * But, more typically, We get here when this is an unallocated
1087                                  * chunk and his means that either the block is empty or
1088                                  * this is the one being allocated from
1089                                  */
1090
1091                                 if (foundChunksInBlock) {
1092                                         /* This is a chunk that was skipped due to failing the erased check */
1093                                 } else if (c == 0) {
1094                                         /* We're looking at the first chunk in the block so the block is unused */
1095                                         state = YAFFS_BLOCK_STATE_EMPTY;
1096                                         dev->nErasedBlocks++;
1097                                 } else {
1098                                         if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
1099                                             state == YAFFS_BLOCK_STATE_ALLOCATING) {
1100                                                 if (dev->sequenceNumber == bi->sequenceNumber) {
1101                                                         /* this is the block being allocated from */
1102
1103                                                         T(YAFFS_TRACE_SCAN,
1104                                                           (TSTR
1105                                                            (" Allocating from %d %d"
1106                                                             TENDSTR), blk, c));
1107
1108                                                         state = YAFFS_BLOCK_STATE_ALLOCATING;
1109                                                         dev->allocationBlock = blk;
1110                                                         dev->allocationPage = c;
1111                                                         dev->allocationBlockFinder = blk;
1112                                                 } else {
1113                                                         /* This is a partially written block that is not
1114                                                          * the current allocation block.
1115                                                          */
1116
1117                                                          T(YAFFS_TRACE_SCAN,
1118                                                          (TSTR("Partially written block %d detected" TENDSTR),
1119                                                          blk));
1120                                                 }
1121                                         }
1122                                 }
1123
1124                                 dev->nFreeChunks++;
1125
1126                         } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) {
1127                                 T(YAFFS_TRACE_SCAN,
1128                                   (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR),
1129                                   blk, c));
1130
1131                                   dev->nFreeChunks++;
1132
1133                         } else if (tags.objectId > YAFFS_MAX_OBJECT_ID ||
1134                                 tags.chunkId > YAFFS_MAX_CHUNK_ID ||
1135                                 (tags.chunkId > 0 && tags.byteCount > dev->nDataBytesPerChunk)) {
1136                                 T(YAFFS_TRACE_SCAN,
1137                                   (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunkId = %d, byteCount = %d, ignored"TENDSTR),
1138                                   blk, c,tags.objectId, tags.chunkId, tags.byteCount));
1139
1140                                   dev->nFreeChunks++;
1141
1142                         } else if (tags.chunkId > 0) {
1143                                 /* chunkId > 0 so it is a data chunk... */
1144                                 unsigned int endpos;
1145                                 __u32 chunkBase =
1146                                     (tags.chunkId - 1) * dev->nDataBytesPerChunk;
1147
1148                                 foundChunksInBlock = 1;
1149
1150
1151                                 yaffs_SetChunkBit(dev, blk, c);
1152                                 bi->pagesInUse++;
1153
1154                                 in = yaffs_FindOrCreateObjectByNumber(dev,
1155                                                                       tags.
1156                                                                       objectId,
1157                                                                       YAFFS_OBJECT_TYPE_FILE);
1158                                 if (!in) {
1159                                         /* Out of memory */
1160                                         alloc_failed = 1;
1161                                 }
1162
1163                                 if (in &&
1164                                     in->variantType == YAFFS_OBJECT_TYPE_FILE
1165                                     && chunkBase < in->variant.fileVariant.shrinkSize) {
1166                                         /* This has not been invalidated by a resize */
1167                                         if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, -1)) {
1168                                                 alloc_failed = 1;
1169                                         }
1170
1171                                         /* File size is calculated by looking at the data chunks if we have not
1172                                          * seen an object header yet. Stop this practice once we find an object header.
1173                                          */
1174                                         endpos = chunkBase + tags.byteCount;
1175
1176                                         if (!in->valid &&       /* have not got an object header yet */
1177                                             in->variant.fileVariant.scannedFileSize < endpos) {
1178                                                 in->variant.fileVariant.scannedFileSize = endpos;
1179                                                 in->variant.fileVariant.fileSize = endpos;
1180                                         }
1181
1182                                 } else if (in) {
1183                                         /* This chunk has been invalidated by a resize, or a past file deletion
1184                                          * so delete the chunk*/
1185                                         yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
1186
1187                                 }
1188                         } else {
1189                                 /* chunkId == 0, so it is an ObjectHeader.
1190                                  * Thus, we read in the object header and make the object
1191                                  */
1192                                 foundChunksInBlock = 1;
1193
1194                                 yaffs_SetChunkBit(dev, blk, c);
1195                                 bi->pagesInUse++;
1196
1197                                 oh = NULL;
1198                                 in = NULL;
1199
1200                                 if (tags.extraHeaderInfoAvailable) {
1201                                         in = yaffs_FindOrCreateObjectByNumber(dev,
1202                                                 tags.objectId,
1203                                                 tags.extraObjectType);
1204                                         if (!in)
1205                                                 alloc_failed = 1;
1206                                 }
1207
1208                                 if (!in ||
1209                                     (!in->valid && dev->param.disableLazyLoad) ||
1210                                     tags.extraShadows ||
1211                                     (!in->valid &&
1212                                     (tags.objectId == YAFFS_OBJECTID_ROOT ||
1213                                      tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))) {
1214
1215                                         /* If we don't have  valid info then we need to read the chunk
1216                                          * TODO In future we can probably defer reading the chunk and
1217                                          * living with invalid data until needed.
1218                                          */
1219
1220                                         result = yaffs_ReadChunkWithTagsFromNAND(dev,
1221                                                                         chunk,
1222                                                                         chunkData,
1223                                                                         NULL);
1224
1225                                         oh = (yaffs_ObjectHeader *) chunkData;
1226
1227                                         if (dev->param.inbandTags) {
1228                                                 /* Fix up the header if they got corrupted by inband tags */
1229                                                 oh->shadowsObject = oh->inbandShadowsObject;
1230                                                 oh->isShrink = oh->inbandIsShrink;
1231                                         }
1232
1233                                         if (!in) {
1234                                                 in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
1235                                                 if (!in)
1236                                                         alloc_failed = 1;
1237                                         }
1238
1239                                 }
1240
1241                                 if (!in) {
1242                                         /* TODO Hoosterman we have a problem! */
1243                                         T(YAFFS_TRACE_ERROR,
1244                                           (TSTR
1245                                            ("yaffs tragedy: Could not make object for object  %d at chunk %d during scan"
1246                                             TENDSTR), tags.objectId, chunk));
1247                                         continue;
1248                                 }
1249
1250                                 if (in->valid) {
1251                                         /* We have already filled this one.
1252                                          * We have a duplicate that will be discarded, but
1253                                          * we first have to suck out resize info if it is a file.
1254                                          */
1255
1256                                         if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
1257                                              ((oh &&
1258                                                oh->type == YAFFS_OBJECT_TYPE_FILE) ||
1259                                               (tags.extraHeaderInfoAvailable  &&
1260                                                tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))) {
1261                                                 __u32 thisSize =
1262                                                     (oh) ? oh->fileSize : tags.
1263                                                     extraFileLength;
1264                                                 __u32 parentObjectId =
1265                                                     (oh) ? oh->
1266                                                     parentObjectId : tags.
1267                                                     extraParentObjectId;
1268
1269
1270                                                 isShrink =
1271                                                     (oh) ? oh->isShrink : tags.
1272                                                     extraIsShrinkHeader;
1273
1274                                                 /* If it is deleted (unlinked at start also means deleted)
1275                                                  * we treat the file size as being zeroed at this point.
1276                                                  */
1277                                                 if (parentObjectId ==
1278                                                     YAFFS_OBJECTID_DELETED
1279                                                     || parentObjectId ==
1280                                                     YAFFS_OBJECTID_UNLINKED) {
1281                                                         thisSize = 0;
1282                                                         isShrink = 1;
1283                                                 }
1284
1285                                                 if (isShrink && in->variant.fileVariant.shrinkSize > thisSize)
1286                                                         in->variant.fileVariant.shrinkSize = thisSize;
1287
1288                                                 if (isShrink)
1289                                                         bi->hasShrinkHeader = 1;
1290
1291                                         }
1292                                         /* Use existing - destroy this one. */
1293                                         yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
1294
1295                                 }
1296
1297                                 if (!in->valid && in->variantType !=
1298                                     (oh ? oh->type : tags.extraObjectType))
1299                                         T(YAFFS_TRACE_ERROR, (
1300                                                 TSTR("yaffs tragedy: Bad object type, "
1301                                             TCONT("%d != %d, for object %d at chunk ")
1302                                             TCONT("%d during scan")
1303                                                 TENDSTR), oh ?
1304                                             oh->type : tags.extraObjectType,
1305                                             in->variantType, tags.objectId,
1306                                             chunk));
1307
1308                                 if (!in->valid &&
1309                                     (tags.objectId == YAFFS_OBJECTID_ROOT ||
1310                                      tags.objectId ==
1311                                      YAFFS_OBJECTID_LOSTNFOUND)) {
1312                                         /* We only load some info, don't fiddle with directory structure */
1313                                         in->valid = 1;
1314
1315                                         if (oh) {
1316                                                 in->variantType = oh->type;
1317
1318                                                 in->yst_mode = oh->yst_mode;
1319 #ifdef CONFIG_YAFFS_WINCE
1320                                                 in->win_atime[0] = oh->win_atime[0];
1321                                                 in->win_ctime[0] = oh->win_ctime[0];
1322                                                 in->win_mtime[0] = oh->win_mtime[0];
1323                                                 in->win_atime[1] = oh->win_atime[1];
1324                                                 in->win_ctime[1] = oh->win_ctime[1];
1325                                                 in->win_mtime[1] = oh->win_mtime[1];
1326 #else
1327                                                 in->yst_uid = oh->yst_uid;
1328                                                 in->yst_gid = oh->yst_gid;
1329                                                 in->yst_atime = oh->yst_atime;
1330                                                 in->yst_mtime = oh->yst_mtime;
1331                                                 in->yst_ctime = oh->yst_ctime;
1332                                                 in->yst_rdev = oh->yst_rdev;
1333
1334 #endif
1335                                         } else {
1336                                                 in->variantType = tags.extraObjectType;
1337                                                 in->lazyLoaded = 1;
1338                                         }
1339
1340                                         in->hdrChunk = chunk;
1341
1342                                 } else if (!in->valid) {
1343                                         /* we need to load this info */
1344
1345                                         in->valid = 1;
1346                                         in->hdrChunk = chunk;
1347
1348                                         if (oh) {
1349                                                 in->variantType = oh->type;
1350
1351                                                 in->yst_mode = oh->yst_mode;
1352 #ifdef CONFIG_YAFFS_WINCE
1353                                                 in->win_atime[0] = oh->win_atime[0];
1354                                                 in->win_ctime[0] = oh->win_ctime[0];
1355                                                 in->win_mtime[0] = oh->win_mtime[0];
1356                                                 in->win_atime[1] = oh->win_atime[1];
1357                                                 in->win_ctime[1] = oh->win_ctime[1];
1358                                                 in->win_mtime[1] = oh->win_mtime[1];
1359 #else
1360                                                 in->yst_uid = oh->yst_uid;
1361                                                 in->yst_gid = oh->yst_gid;
1362                                                 in->yst_atime = oh->yst_atime;
1363                                                 in->yst_mtime = oh->yst_mtime;
1364                                                 in->yst_ctime = oh->yst_ctime;
1365                                                 in->yst_rdev = oh->yst_rdev;
1366 #endif
1367
1368                                                 if (oh->shadowsObject > 0)
1369                                                         yaffs_HandleShadowedObject(dev,
1370                                                                            oh->
1371                                                                            shadowsObject,
1372                                                                            1);
1373
1374
1375
1376                                                 yaffs_SetObjectNameFromOH(in, oh);
1377                                                 parent =
1378                                                     yaffs_FindOrCreateObjectByNumber
1379                                                         (dev, oh->parentObjectId,
1380                                                          YAFFS_OBJECT_TYPE_DIRECTORY);
1381
1382                                                  fileSize = oh->fileSize;
1383                                                  isShrink = oh->isShrink;
1384                                                  equivalentObjectId = oh->equivalentObjectId;
1385
1386                                         } else {
1387                                                 in->variantType = tags.extraObjectType;
1388                                                 parent =
1389                                                     yaffs_FindOrCreateObjectByNumber
1390                                                         (dev, tags.extraParentObjectId,
1391                                                          YAFFS_OBJECT_TYPE_DIRECTORY);
1392                                                  fileSize = tags.extraFileLength;
1393                                                  isShrink = tags.extraIsShrinkHeader;
1394                                                  equivalentObjectId = tags.extraEquivalentObjectId;
1395                                                 in->lazyLoaded = 1;
1396
1397                                         }
1398                                         in->dirty = 0;
1399
1400                                         if (!parent)
1401                                                 alloc_failed = 1;
1402
1403                                         /* directory stuff...
1404                                          * hook up to parent
1405                                          */
1406
1407                                         if (parent && parent->variantType ==
1408                                             YAFFS_OBJECT_TYPE_UNKNOWN) {
1409                                                 /* Set up as a directory */
1410                                                 parent->variantType =
1411                                                         YAFFS_OBJECT_TYPE_DIRECTORY;
1412                                                 YINIT_LIST_HEAD(&parent->variant.
1413                                                         directoryVariant.
1414                                                         children);
1415                                         } else if (!parent || parent->variantType !=
1416                                                    YAFFS_OBJECT_TYPE_DIRECTORY) {
1417                                                 /* Hoosterman, another problem....
1418                                                  * We're trying to use a non-directory as a directory
1419                                                  */
1420
1421                                                 T(YAFFS_TRACE_ERROR,
1422                                                   (TSTR
1423                                                    ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
1424                                                     TENDSTR)));
1425                                                 parent = dev->lostNFoundDir;
1426                                         }
1427
1428                                         yaffs_AddObjectToDirectory(parent, in);
1429
1430                                         itsUnlinked = (parent == dev->deletedDir) ||
1431                                                       (parent == dev->unlinkedDir);
1432
1433                                         if (isShrink) {
1434                                                 /* Mark the block as having a shrinkHeader */
1435                                                 bi->hasShrinkHeader = 1;
1436                                         }
1437
1438                                         /* Note re hardlinks.
1439                                          * Since we might scan a hardlink before its equivalent object is scanned
1440                                          * we put them all in a list.
1441                                          * After scanning is complete, we should have all the objects, so we run
1442                                          * through this list and fix up all the chains.
1443                                          */
1444
1445                                         switch (in->variantType) {
1446                                         case YAFFS_OBJECT_TYPE_UNKNOWN:
1447                                                 /* Todo got a problem */
1448                                                 break;
1449                                         case YAFFS_OBJECT_TYPE_FILE:
1450
1451                                                 if (in->variant.fileVariant.
1452                                                     scannedFileSize < fileSize) {
1453                                                         /* This covers the case where the file size is greater
1454                                                          * than where the data is
1455                                                          * This will happen if the file is resized to be larger
1456                                                          * than its current data extents.
1457                                                          */
1458                                                         in->variant.fileVariant.fileSize = fileSize;
1459                                                         in->variant.fileVariant.scannedFileSize = fileSize;
1460                                                 }
1461
1462                                                 if (in->variant.fileVariant.shrinkSize > fileSize)
1463                                                         in->variant.fileVariant.shrinkSize = fileSize;
1464
1465
1466                                                 break;
1467                                         case YAFFS_OBJECT_TYPE_HARDLINK:
1468                                                 if (!itsUnlinked) {
1469                                                         in->variant.hardLinkVariant.equivalentObjectId =
1470                                                                 equivalentObjectId;
1471                                                         in->hardLinks.next =
1472                                                                 (struct ylist_head *) hardList;
1473                                                         hardList = in;
1474                                                 }
1475                                                 break;
1476                                         case YAFFS_OBJECT_TYPE_DIRECTORY:
1477                                                 /* Do nothing */
1478                                                 break;
1479                                         case YAFFS_OBJECT_TYPE_SPECIAL:
1480                                                 /* Do nothing */
1481                                                 break;
1482                                         case YAFFS_OBJECT_TYPE_SYMLINK:
1483                                                 if (oh) {
1484                                                         in->variant.symLinkVariant.alias =
1485                                                                 yaffs_CloneString(oh->alias);
1486                                                         if (!in->variant.symLinkVariant.alias)
1487                                                                 alloc_failed = 1;
1488                                                 }
1489                                                 break;
1490                                         }
1491
1492                                 }
1493
1494                         }
1495
1496                 } /* End of scanning for each chunk */
1497
1498                 if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
1499                         /* If we got this far while scanning, then the block is fully allocated. */
1500                         state = YAFFS_BLOCK_STATE_FULL;
1501                 }
1502
1503
1504                 bi->blockState = state;
1505
1506                 /* Now let's see if it was dirty */
1507                 if (bi->pagesInUse == 0 &&
1508                     !bi->hasShrinkHeader &&
1509                     bi->blockState == YAFFS_BLOCK_STATE_FULL) {
1510                         yaffs_BlockBecameDirty(dev, blk);
1511                 }
1512
1513         }
1514
1515         yaffs_SkipRestOfBlock(dev);
1516
1517         if (altBlockIndex)
1518                 YFREE_ALT(blockIndex);
1519         else
1520                 YFREE(blockIndex);
1521
1522         /* Ok, we've done all the scanning.
1523          * Fix up the hard link chains.
1524          * We should now have scanned all the objects, now it's time to add these
1525          * hardlinks.
1526          */
1527         yaffs_HardlinkFixup(dev, hardList);
1528
1529
1530         yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
1531
1532         if (alloc_failed)
1533                 return YAFFS_FAIL;
1534
1535         T(YAFFS_TRACE_SCAN, (TSTR("yaffs2_ScanBackwards ends" TENDSTR)));
1536
1537         return YAFFS_OK;
1538 }