yaffs_guts.h

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  * yaffs_guts.h: Configuration etc for yaffs_guts
   4  *
   5  * Copyright (C) 2002 Aleph One Ltd.
   6  *   for Toby Churchill Ltd and Brightstar Engineering
   7  *
   8  * Created by Charles Manning <charles@aleph1.co.uk>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU Lesser General Public License version 2.1 as
  12  * published by the Free Software Foundation.
  13  *
  14  *
  15  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  16  *
  17  * $Id: yaffs_guts.h,v 1.10 2005-07-26 23:04:34 charles Exp $
  18  */
  19
  20 #ifndef __YAFFS_GUTS_H__
  21 #define __YAFFS_GUTS_H__
  22
  23 #include "devextras.h"
  24 #include "yportenv.h"
  25
  26 #define YAFFS_OK        1
  27 #define YAFFS_FAIL  0
  28
  29 // Give us a Y=0x59,
  30 // Give us an A=0x41,
  31 // Give us an FF=0xFF
  32 // Give us an S=0x53
  33 // And what have we got...
  34 #define YAFFS_MAGIC                                     0x5941FF53
  35
  36 #define YAFFS_NTNODES_LEVEL0            16
  37 #define YAFFS_TNODES_LEVEL0_BITS        4
  38 #define YAFFS_TNODES_LEVEL0_MASK        0xf
  39
  40 #define YAFFS_NTNODES_INTERNAL          (YAFFS_NTNODES_LEVEL0 / 2)
  41 #define YAFFS_TNODES_INTERNAL_BITS      (YAFFS_TNODES_LEVEL0_BITS - 1)
  42 #define YAFFS_TNODES_INTERNAL_MASK      0x7
  43 #define YAFFS_TNODES_MAX_LEVEL          6
  44
  45 #ifndef CONFIG_YAFFS_NO_YAFFS1
  46 #define YAFFS_BYTES_PER_SPARE           16
  47 #define YAFFS_BYTES_PER_CHUNK           512
  48 #define YAFFS_CHUNK_SIZE_SHIFT          9
  49 #define YAFFS_CHUNKS_PER_BLOCK          32
  50 #define YAFFS_BYTES_PER_BLOCK           (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK)
  51 #endif
  52
  53 #define YAFFS_MIN_YAFFS2_CHUNK_SIZE     1024
  54 #define YAFFS_MIN_YAFFS2_SPARE_SIZE     32
  55
  56 #define YAFFS_MAX_CHUNK_ID                      0x000FFFFF
  57
  58 #define YAFFS_UNUSED_OBJECT_ID          0x0003FFFF
  59
  60 #define YAFFS_ALLOCATION_NOBJECTS       100
  61 #define YAFFS_ALLOCATION_NTNODES        100
  62 #define YAFFS_ALLOCATION_NLINKS         100
  63
  64 #define YAFFS_NOBJECT_BUCKETS           256
  65
  66
  67 #define YAFFS_OBJECT_SPACE                      0x40000
  68
  69 #ifdef CONFIG_YAFFS_UNICODE
  70 #define YAFFS_MAX_NAME_LENGTH           127
  71 #define YAFFS_MAX_ALIAS_LENGTH          79
  72 #else
  73 #define YAFFS_MAX_NAME_LENGTH           255
  74 #define YAFFS_MAX_ALIAS_LENGTH          159
  75 #endif
  76
  77 #define YAFFS_SHORT_NAME_LENGTH         15
  78
  79
  80 #define YAFFS_OBJECTID_ROOT                     1
  81 #define YAFFS_OBJECTID_LOSTNFOUND       2
  82 #define YAFFS_OBJECTID_UNLINKED         3
  83 #define YAFFS_OBJECTID_DELETED          4
  84
  85 #define YAFFS_MAX_SHORT_OP_CACHES       20
  86
  87 #define YAFFS_N_TEMP_BUFFERS            4
  88
  89 // Sequence numbers are used in YAFFS2 to determine block allocation order.
  90 // The range is limited slightly to help distinguish bad numbers from good.
  91 // This also allows us to perhaps in the future use special numbers for
  92 // special purposes.
  93 // EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
  94 // and is a larger number than the lifetime of a 2GB device.
  95
  96 #define YAFFS_LOWEST_SEQUENCE_NUMBER    0x00001000
  97 #define YAFFS_HIGHEST_SEQUENCE_NUMBER   0xEFFFFF00
  98
  99
 100 // ChunkCache is used for short read/write operations.
 101 typedef struct
 102 {
 103         struct yaffs_ObjectStruct *object;
 104         int chunkId;
 105         int lastUse;
 106         int dirty;
 107         int nBytes;     // Only valid if the cache is dirty
 108         int locked; // Can't push out or flush while locked..
 109 #ifdef CONFIG_YAFFS_YAFFS2
 110         __u8 *data;
 111 #else
 112         __u8 data[YAFFS_BYTES_PER_CHUNK];
 113 #endif
 114 } yaffs_ChunkCache;
 115
 116
 117 #ifndef CONFIG_YAFFS_NO_YAFFS1
 118 // Tags structures in RAM
 119 // NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise
 120 // the structure size will get blown out.
 121
 122 typedef struct
 123 {
 124         unsigned chunkId:20;
 125     unsigned serialNumber:2;
 126     unsigned byteCount:10;
 127     unsigned objectId:18;
 128     unsigned ecc:12;
 129     unsigned unusedStuff:2;
 130
 131 } yaffs_Tags;
 132
 133 typedef union
 134 {
 135     yaffs_Tags asTags;
 136     __u8       asBytes[8];
 137 } yaffs_TagsUnion;
 138
 139 #endif
 140
 141 typedef enum
 142 {
 143         YAFFS_ECC_RESULT_UNKNOWN,
 144         YAFFS_ECC_RESULT_NO_ERROR,
 145         YAFFS_ECC_RESULT_FIXED,
 146         YAFFS_ECC_RESULT_UNFIXED
 147 } yaffs_ECCResult;
 148
 149 typedef enum
 150 {
 151         YAFFS_OBJECT_TYPE_UNKNOWN,
 152         YAFFS_OBJECT_TYPE_FILE,
 153         YAFFS_OBJECT_TYPE_SYMLINK,
 154         YAFFS_OBJECT_TYPE_DIRECTORY,
 155         YAFFS_OBJECT_TYPE_HARDLINK,
 156         YAFFS_OBJECT_TYPE_SPECIAL
 157 } yaffs_ObjectType;
 158
 159
 160 typedef struct
 161 {
 162
 163         unsigned validMarker0;
 164         unsigned chunkUsed;                 //  Status of the chunk: used or unused
 165         unsigned objectId;                      // If 0 then this is not part of an object (unused)
 166         unsigned chunkId;                       // If 0 then this is a header, else a data chunk
 167         unsigned byteCount;                 // Only valid for data chunks
 168
 169
 170         // The following stuff only has meaning when we read
 171         yaffs_ECCResult eccResult;  // Only valid when we read.
 172         unsigned blockBad;                      // Only valid on reading
 173
 174         // YAFFS 1 stuff
 175         unsigned chunkDeleted;          // The chunk is marked deleted
 176         unsigned serialNumber;          // Yaffs1 2-bit serial number
 177
 178         // YAFFS2 stuff
 179         unsigned sequenceNumber;        // The sequence number of this block
 180
 181         // Extra info if this is an object header (YAFFS2 only)
 182
 183         unsigned extraHeaderInfoAvailable; // There is extra info available if this is not zero
 184         unsigned extraParentObjectId;      // The parent object
 185         unsigned extraIsShrinkHeader;      // Is it a shrink header?
 186
 187         yaffs_ObjectType extraObjectType;  // What object type?
 188
 189         unsigned extraFileLength;          // Length if it is a file
 190         unsigned extraEquivalentObjectId;  // Equivalent object Id if it is a hard link
 191
 192         unsigned validMarker1;
 193
 194 } yaffs_ExtendedTags;
 195
 196 #ifndef CONFIG_YAFFS_NO_YAFFS1
 197 // Spare structure
 198 typedef struct
 199 {
 200     __u8  tagByte0;
 201     __u8  tagByte1;
 202     __u8  tagByte2;
 203     __u8  tagByte3;
 204     __u8  pageStatus;   // set to 0 to delete the chunk
 205     __u8  blockStatus;
 206     __u8  tagByte4;
 207     __u8  tagByte5;
 208     __u8  ecc1[3];
 209     __u8  tagByte6;
 210     __u8  tagByte7;
 211     __u8  ecc2[3];
 212 } yaffs_Spare;
 213
 214 //Special structure for passing through to mtd
 215 struct yaffs_NANDSpare {
 216         yaffs_Spare     spare;
 217         int             eccres1;
 218         int             eccres2;
 219 };
 220 #endif
 221
 222
 223 // Block data in RAM
 224
 225 typedef enum {
 226         YAFFS_BLOCK_STATE_UNKNOWN       = 0,
 227
 228         YAFFS_BLOCK_STATE_SCANNING,
 229         YAFFS_BLOCK_STATE_NEEDS_SCANNING,// The block might have something on it (ie it is allocating or full, perhaps empty)
 230                                                                         // but it needs to be scanned to determine its true state.
 231                                                                         // This state is only valid during yaffs_Scan.
 232                                                                         // NB We tolerate empty because the pre-scanner might be incapable of deciding
 233                                                                         // However, if this state is returned on a YAFFS2 device, then we expect a sequence number
 234
 235         YAFFS_BLOCK_STATE_EMPTY,                // This block is empty
 236
 237         YAFFS_BLOCK_STATE_ALLOCATING,   // This block is partially allocated.
 238                                                                         // This is the one currently being used for page
 239                                                                         // allocation. Should never be more than one of these
 240
 241
 242         YAFFS_BLOCK_STATE_FULL,                 // All the pages in this block have been allocated.
 243                                                                         // At least one page holds valid data.
 244
 245         YAFFS_BLOCK_STATE_DIRTY,                // All pages have been allocated and deleted.
 246                                                                         // Erase me, reuse me.
 247
 248         YAFFS_BLOCK_STATE_COLLECTING,   // This block is being garbage collected
 249
 250         YAFFS_BLOCK_STATE_DEAD                  // This block has failed and is not in use
 251
 252 } yaffs_BlockState;
 253
 254
 255
 256
 257 typedef struct
 258 {
 259
 260     int   softDeletions:12;  // number of soft deleted pages
 261     int   pagesInUse:12;        // number of pages in use
 262     yaffs_BlockState blockState:4;      // One of the above block states
 263     __u32 needsRetiring:1;      // Data has failed on this block, need to get valid data off
 264                                                 // and retire the block.
 265 #ifdef CONFIG_YAFFS_YAFFS2
 266         __u32 hasShrinkHeader:1;// This block has at least one object header that does a shrink
 267         __u32 sequenceNumber;   // block sequence number for yaffs2
 268 #endif
 269
 270 } yaffs_BlockInfo;
 271
 272
 273 //////////////////// Object structure ///////////////////////////
 274 // This is the object structure as stored on NAND
 275
 276 typedef struct
 277 {
 278         yaffs_ObjectType type;
 279
 280         // Apply to everything
 281         int   parentObjectId;
 282         __u16 sum__NoLongerUsed;        // checksum of name. Calc this off the name to prevent inconsistencies
 283         YCHAR  name[YAFFS_MAX_NAME_LENGTH + 1];
 284
 285         // Thes following apply to directories, files, symlinks - not hard links
 286         __u32 yst_mode;  // protection
 287
 288 #ifdef CONFIG_YAFFS_WINCE
 289         __u32 notForWinCE[5];
 290 #else
 291         __u32 yst_uid;   // user ID of owner
 292         __u32 yst_gid;    // group ID of owner
 293         __u32 yst_atime; // time of last access
 294         __u32 yst_mtime; // time of last modification
 295         __u32 yst_ctime; // time of last change
 296 #endif
 297
 298         // File size  applies to files only
 299         int fileSize;
 300
 301         // Equivalent object id applies to hard links only.
 302         int  equivalentObjectId;
 303
 304         // Alias is for symlinks only.
 305         YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1];
 306
 307         __u32 yst_rdev;  // device stuff for block and char devices (maj/min)
 308
 309 #ifdef CONFIG_YAFFS_WINCE
 310         __u32 win_ctime[2];
 311         __u32 win_atime[2];
 312         __u32 win_mtime[2];
 313         __u32 roomToGrow[5];
 314 #else
 315         __u32 roomToGrow[11];
 316 #endif
 317
 318         // isShrink applies to bject headers written when we shrink the file (ie resize)
 319         __u32 isShrink;
 320
 321 } yaffs_ObjectHeader;
 322
 323
 324
 325 ////////////////////  Tnode ///////////////////////////
 326
 327 union yaffs_Tnode_union
 328 {
 329 #ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
 330         union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL+1];
 331 #else
 332         union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL];
 333 #endif
 334         __u16 level0[YAFFS_NTNODES_LEVEL0];
 335
 336 };
 337
 338 typedef union yaffs_Tnode_union yaffs_Tnode;
 339
 340 struct yaffs_TnodeList_struct
 341 {
 342         struct yaffs_TnodeList_struct *next;
 343         yaffs_Tnode *tnodes;
 344 };
 345
 346 typedef struct yaffs_TnodeList_struct yaffs_TnodeList;
 347
 348
 349
 350 ///////////////////  Object ////////////////////////////////
 351 // An object can be one of:
 352 // - a directory (no data, has children links
 353 // - a regular file (data.... not prunes :->).
 354 // - a symlink [symbolic link] (the alias).
 355 // - a hard link
 356
 357
 358 typedef struct
 359 {
 360         __u32 fileSize;
 361         __u32 scannedFileSize;
 362         __u32 shrinkSize;
 363         int   topLevel;
 364         yaffs_Tnode *top;
 365 } yaffs_FileStructure;
 366
 367 typedef struct
 368 {
 369         struct list_head children; // list of child links
 370 } yaffs_DirectoryStructure;
 371
 372 typedef struct
 373 {
 374         YCHAR *alias;
 375 } yaffs_SymLinkStructure;
 376
 377 typedef struct
 378 {
 379         struct yaffs_ObjectStruct *equivalentObject;
 380         __u32   equivalentObjectId;
 381 } yaffs_HardLinkStructure;
 382
 383 typedef union
 384 {
 385         yaffs_FileStructure fileVariant;
 386         yaffs_DirectoryStructure directoryVariant;
 387         yaffs_SymLinkStructure symLinkVariant;
 388         yaffs_HardLinkStructure hardLinkVariant;
 389 } yaffs_ObjectVariant;
 390
 391
 392 struct  yaffs_ObjectStruct
 393 {
 394         __u8 deleted: 1;                // This should only apply to unlinked files.
 395         __u8 softDeleted: 1;    // it has also been soft deleted
 396         __u8 unlinked: 1;               // An unlinked file. The file should be in the unlinked pseudo directory.
 397         __u8 fake:1;                    // A fake object has no presence on NAND.
 398         __u8 renameAllowed:1;           // Some objects are not allowed to be renamed.
 399         __u8 unlinkAllowed:1;
 400         __u8 dirty:1;                   // the object needs to be written to flash
 401         __u8 valid:1;                   // When the file system is being loaded up, this
 402                                                         // object might be created before the data
 403                                                         // is available (ie. file data records appear before the header).
 404         __u8 serial;                    // serial number of chunk in NAND. Store here so we don't have to
 405
 406         __u8  deferedFree: 1;           // For Linux kernel. Object is removed from NAND, but still in the inode cache.
 407                                         // Free of object is defered.
 408
 409         __u8 lazyLoaded;                // Vital info has been loaded from tags. Not all info available.
 410                                         //
 411
 412                                         // read back the old one to update.
 413         __u16 sum;                      // sum of the name to speed searching
 414
 415         struct yaffs_DeviceStruct *myDev; // The device I'm on
 416
 417
 418         struct list_head hashLink;      // list of objects in this hash bucket
 419
 420
 421         struct list_head hardLinks; // all the equivalent hard linked objects
 422                                                                 // live on this list
 423         // directory structure stuff
 424         struct yaffs_ObjectStruct  *parent;     //my parent directory
 425         struct list_head siblings;      // siblings in a directory
 426                                                                 // also used for linking up the free list
 427
 428         // Where's my object header in NAND?
 429         int chunkId;            // where it lives
 430
 431         int nDataChunks;        // Number of data chunks attached to the file.
 432
 433         __u32 objectId;         // the object id value
 434
 435
 436         __u32 yst_mode;         // protection
 437
 438 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
 439         YCHAR shortName[YAFFS_SHORT_NAME_LENGTH+1];
 440 #endif
 441
 442 #ifndef __KERNEL__
 443         __u32 inUse;
 444 #endif
 445
 446 #ifdef CONFIG_YAFFS_WINCE
 447         __u32 win_ctime[2];
 448         __u32 win_mtime[2];
 449         __u32 win_atime[2];
 450 #else
 451         __u32 yst_uid;          // user ID of owner
 452         __u32 yst_gid;          // group ID of owner
 453         __u32 yst_atime;        // time of last access
 454         __u32 yst_mtime;        // time of last modification
 455         __u32 yst_ctime;        // time of last change
 456 #endif
 457
 458         __u32 yst_rdev;             // device stuff for block and char devices
 459
 460
 461
 462 #ifdef __KERNEL__
 463         struct inode *myInode;
 464
 465 #endif
 466
 467
 468
 469         yaffs_ObjectType variantType;
 470
 471         yaffs_ObjectVariant variant;
 472
 473 };
 474
 475
 476
 477 typedef struct yaffs_ObjectStruct yaffs_Object;
 478
 479
 480 struct yaffs_ObjectList_struct
 481 {
 482         yaffs_Object *objects;
 483         struct yaffs_ObjectList_struct *next;
 484 };
 485
 486 typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
 487
 488 typedef struct
 489 {
 490         struct list_head list;
 491         int count;
 492 } yaffs_ObjectBucket;
 493
 494 ///////////////////// Temporary buffers ////////////////////
 495 //
 496 // These are chunk-sized working buffers. Each device has a few
 497
 498 typedef struct {
 499         __u8 *buffer;
 500         int line; // track from whence this buffer was allocated
 501         int maxLine;
 502 } yaffs_TempBuffer;
 503
 504 //////////////////// Device ////////////////////////////////
 505
 506 struct yaffs_DeviceStruct
 507 {
 508         struct list_head devList;
 509         const char *name;
 510
 511         // Entry parameters set up way early. Yaffs sets up the rest.
 512         int   nBytesPerChunk;    // Should be a power of 2 >= 512
 513         int       nChunksPerBlock;       // does not need to be a power of 2
 514         int   nBytesPerSpare;    // spare area size
 515         int   startBlock;                // Start block we're allowed to use
 516         int   endBlock;                  // End block we're allowed to use
 517         int   nReservedBlocks;   // We want this tuneable so that we can reduce
 518                                                          // reserved blocks on NOR and RAM.
 519
 520         int   nShortOpCaches;   // If <= 0, then short op caching is disabled, else
 521                                                         // the number of short op caches (don't use too many).
 522
 523         int useHeaderFileSize; // Flag to determine if we should use file sizes from the header
 524
 525         int   useNANDECC;               // Flag to decide whether or not to use NANDECC
 526
 527
 528         void *genericDevice; // Pointer to device context
 529                                                  // On an mtd this holds the mtd pointer.
 530
 531         // NAND access functions (Must be set before calling YAFFS)
 532
 533
 534         int (*writeChunkToNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, const yaffs_Spare *spare);
 535         int (*readChunkFromNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare);
 536         int (*eraseBlockInNAND)(struct yaffs_DeviceStruct *dev,int blockInNAND);
 537         int (*initialiseNAND)(struct yaffs_DeviceStruct *dev);
 538
 539 #ifdef CONFIG_YAFFS_YAFFS2
 540         int (*writeChunkWithTagsToNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_ExtendedTags *tags);
 541         int (*readChunkWithTagsFromNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
 542         int (*markNANDBlockBad)(struct yaffs_DeviceStruct *dev, int blockNo);
 543         int (*queryNANDBlock)(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
 544 #endif
 545
 546         int isYaffs2;
 547
 548         // End of stuff that must be set before initialisation.
 549
 550         // Runtime parameters. Set up by YAFFS.
 551
 552         __u16 chunkGroupBits; // 0 for devices <= 32MB. else log2(nchunks) - 16
 553         __u16 chunkGroupSize; // == 2^^chunkGroupBits
 554
 555 #ifdef __KERNEL__
 556
 557         struct semaphore sem;// Semaphore for waiting on erasure.
 558         struct semaphore grossLock; // Gross locking semaphore
 559         __u8 * spareBuffer; // For mtdif2 use. Don't know the size of the buffer at compile time so we have to allocate it.
 560         void (*putSuperFunc)(struct super_block *sb);
 561 #endif
 562
 563         int isMounted;
 564
 565         // Stuff to support block offsetting to support start block zero
 566         int internalStartBlock;
 567         int internalEndBlock;
 568         int blockOffset;
 569         int chunkOffset;
 570
 571         // Block Info
 572         yaffs_BlockInfo *blockInfo;
 573         __u8 *chunkBits;   // bitmap of chunks in use
 574         int   chunkBitmapStride; // Number of bytes of chunkBits per block.
 575                                                          //     Must be consistent with nChunksPerBlock.
 576
 577
 578         int   nErasedBlocks;
 579         int   allocationBlock;                  // Current block being allocated off
 580         __u32 allocationPage;
 581         int   allocationBlockFinder;    // Used to search for next allocation block
 582
 583         // Runtime state
 584         int   nTnodesCreated;
 585         yaffs_Tnode *freeTnodes;
 586         int  nFreeTnodes;
 587         yaffs_TnodeList *allocatedTnodeList;
 588
 589         int   isDoingGC;
 590
 591         int   nObjectsCreated;
 592         yaffs_Object *freeObjects;
 593         int   nFreeObjects;
 594
 595         yaffs_ObjectList *allocatedObjectList;
 596
 597         yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS];
 598
 599         int       nFreeChunks;
 600
 601         int   currentDirtyChecker;      // Used to find current dirtiest block
 602
 603         __u32  *gcCleanupList; // objects to delete at the end of a GC.
 604
 605         // Operations since mount
 606         int nPageWrites;
 607         int nPageReads;
 608         int nBlockErasures;
 609         int nErasureFailures;
 610         int nGCCopies;
 611         int garbageCollections;
 612         int passiveGarbageCollections;
 613         int nRetriedWrites;
 614         int nRetiredBlocks;
 615         int eccFixed;
 616         int eccUnfixed;
 617         int tagsEccFixed;
 618         int tagsEccUnfixed;
 619         int nDeletions;
 620         int nUnmarkedDeletions;
 621
 622         yaffs_Object *rootDir;
 623         yaffs_Object *lostNFoundDir;
 624
 625         // Buffer areas for storing data to recover from write failures
 626 //      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
 627 //      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
 628         int bufferedBlock;      // Which block is buffered here?
 629         int doingBufferedBlockRewrite;
 630
 631         yaffs_ChunkCache *srCache;
 632         int srLastUse;
 633
 634         int cacheHits;
 635
 636         // Stuff for background deletion and unlinked files.
 637         yaffs_Object *unlinkedDir;              // Directory where unlinked and deleted files live.
 638         yaffs_Object *deletedDir;               // Directory where deleted objects are sent to disappear.
 639         yaffs_Object *unlinkedDeletion; // Current file being background deleted.
 640         int nDeletedFiles;                              // Count of files awaiting deletion;
 641         int nUnlinkedFiles;                             // Count of unlinked files.
 642         int nBackgroundDeletions;                       // Count of background deletions.
 643
 644         //__u8 *localBuffer;
 645
 646         yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
 647         int maxTemp;
 648         int unmanagedTempAllocations;
 649         int unmanagedTempDeallocations;
 650
 651         // yaffs2 runtime stuff
 652         unsigned sequenceNumber;                //Sequence number of currently allocating block
 653         unsigned oldestDirtySequence;
 654
 655 };
 656
 657 typedef struct yaffs_DeviceStruct yaffs_Device;
 658
 659
 660 // Function to manipulate block info
 661 static  Y_INLINE yaffs_BlockInfo* yaffs_GetBlockInfo(yaffs_Device *dev, int blk)
 662 {
 663         if(blk < dev->internalStartBlock || blk > dev->internalEndBlock)
 664         {
 665                 T(YAFFS_TRACE_ERROR,(TSTR("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),blk));
 666                 YBUG();
 667         }
 668         return &dev->blockInfo[blk - dev->internalStartBlock];
 669 }
 670
 671
 672 //////////// YAFFS Functions //////////////////
 673
 674 int yaffs_GutsInitialise(yaffs_Device *dev);
 675 void yaffs_Deinitialise(yaffs_Device *dev);
 676
 677 int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev);
 678
 679
 680 // Rename
 681 int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, yaffs_Object *newDir, const YCHAR *newName);
 682
 683 // generic Object functions
 684 int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name);
 685 int yaffs_DeleteFile(yaffs_Object *obj);
 686
 687 // Object access functions.
 688 int yaffs_GetObjectName(yaffs_Object *obj,YCHAR *name,int buffSize);
 689 int yaffs_GetObjectFileLength(yaffs_Object *obj);
 690 int yaffs_GetObjectInode(yaffs_Object *obj);
 691 unsigned yaffs_GetObjectType(yaffs_Object *obj);
 692 int yaffs_GetObjectLinkCount(yaffs_Object *obj);
 693
 694 // Change inode attributes
 695 int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr);
 696 int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr);
 697
 698 // File operations
 699 int yaffs_ReadDataFromFile(yaffs_Object *obj, __u8 *buffer, __u32 offset, int nBytes);
 700 int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, __u32 offset, int nBytes, int writeThrough);
 701 int yaffs_ResizeFile(yaffs_Object *obj, int newSize);
 702
 703 yaffs_Object *yaffs_MknodFile(yaffs_Object *parent,const YCHAR *name, __u32 mode, __u32 uid, __u32 gid);
 704 int yaffs_FlushFile(yaffs_Object *obj,int updateTime);
 705
 706
 707 // Directory operations
 708 yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent,const YCHAR *name, __u32 mode, __u32 uid, __u32 gid);
 709 yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir,const YCHAR *name);
 710 int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,int (*fn)(yaffs_Object *));
 711
 712 yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev,__u32 number);
 713
 714 // Link operations
 715 yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, yaffs_Object *equivalentObject);
 716
 717 yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj);
 718
 719 // Symlink operations
 720 yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name, __u32 mode,  __u32 uid, __u32 gid, const YCHAR *alias);
 721 YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj);
 722
 723 // Special inodes (fifos, sockets and devices)
 724 yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent,const YCHAR *name, __u32 mode, __u32 uid, __u32 gid,__u32 rdev);
 725
 726
 727 // Special directories
 728 yaffs_Object *yaffs_Root(yaffs_Device *dev);
 729 yaffs_Object *yaffs_LostNFound(yaffs_Device *dev);
 730
 731 #ifdef CONFIG_YAFFS_WINCE
 732 // CONFIG_YAFFS_WINCE special stuff
 733 void  yfsd_WinFileTimeNow(__u32 target[2]);
 734 #endif
 735
 736 #ifdef __KERNEL__
 737
 738 void yaffs_HandleDeferedFree(yaffs_Object *obj);
 739 #endif
 740
 741
 742
 743
 744 // Debug dump
 745 int yaffs_DumpObject(yaffs_Object *obj);
 746
 747
 748 void yaffs_GutsTest(yaffs_Device *dev);
 749
 750
 751 void yaffs_InitialiseTags(yaffs_ExtendedTags *tags);
 752 void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId,int markNAND,int lyn);
 753 int yaffs_CheckFF(__u8 *buffer,int nBytes);
 754
 755 #endif
 756