Mercurial > yaffs-ecoscentric
annotate yaffs_guts.h @ 215:b08276bd7b2d
Clean up some yaffs1 mode issues.
| author | charles |
|---|---|
| date | Wed, 02 Jul 2008 21:17:41 +0100 |
| parents | fad21fd1971d |
| children | 6dbe40ae9e54 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 215 | 2 * YAFFS: Yet another Flash File System . A NAND-flash specific file system. |
| 0 | 3 * |
| 174 | 4 * Copyright (C) 2002-2007 Aleph One Ltd. |
| 0 | 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 Lesser General Public License version 2.1 as | |
| 11 * published by the Free Software Foundation. | |
| 12 * | |
| 13 * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. | |
| 14 */ | |
| 15 | |
| 16 #ifndef __YAFFS_GUTS_H__ | |
| 17 #define __YAFFS_GUTS_H__ | |
| 18 | |
| 19 #include "devextras.h" | |
| 20 #include "yportenv.h" | |
| 21 | |
| 22 #define YAFFS_OK 1 | |
| 23 #define YAFFS_FAIL 0 | |
| 24 | |
| 215 | 25 /* Give us a Y=0x59, |
| 26 * Give us an A=0x41, | |
| 27 * Give us an FF=0xFF | |
| 81 | 28 * Give us an S=0x53 |
| 215 | 29 * And what have we got... |
| 81 | 30 */ |
| 77 | 31 #define YAFFS_MAGIC 0x5941FF53 |
| 0 | 32 |
| 33 #define YAFFS_NTNODES_LEVEL0 16 | |
| 34 #define YAFFS_TNODES_LEVEL0_BITS 4 | |
| 35 #define YAFFS_TNODES_LEVEL0_MASK 0xf | |
| 36 | |
| 37 #define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2) | |
| 38 #define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1) | |
| 39 #define YAFFS_TNODES_INTERNAL_MASK 0x7 | |
| 40 #define YAFFS_TNODES_MAX_LEVEL 6 | |
| 41 | |
| 42 #ifndef CONFIG_YAFFS_NO_YAFFS1 | |
| 43 #define YAFFS_BYTES_PER_SPARE 16 | |
| 44 #define YAFFS_BYTES_PER_CHUNK 512 | |
| 45 #define YAFFS_CHUNK_SIZE_SHIFT 9 | |
| 46 #define YAFFS_CHUNKS_PER_BLOCK 32 | |
| 47 #define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK) | |
| 48 #endif | |
| 49 | |
| 7 | 50 #define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 |
| 51 #define YAFFS_MIN_YAFFS2_SPARE_SIZE 32 | |
| 52 | |
| 77 | 53 #define YAFFS_MAX_CHUNK_ID 0x000FFFFF |
| 0 | 54 |
| 55 #define YAFFS_UNUSED_OBJECT_ID 0x0003FFFF | |
| 56 | |
| 57 #define YAFFS_ALLOCATION_NOBJECTS 100 | |
| 58 #define YAFFS_ALLOCATION_NTNODES 100 | |
| 59 #define YAFFS_ALLOCATION_NLINKS 100 | |
| 60 | |
| 61 #define YAFFS_NOBJECT_BUCKETS 256 | |
| 62 | |
| 131 | 63 |
| 77 | 64 #define YAFFS_OBJECT_SPACE 0x40000 |
| 0 | 65 |
| 182 | 66 #define YAFFS_CHECKPOINT_VERSION 3 |
| 153 | 67 |
| 0 | 68 #ifdef CONFIG_YAFFS_UNICODE |
| 69 #define YAFFS_MAX_NAME_LENGTH 127 | |
| 70 #define YAFFS_MAX_ALIAS_LENGTH 79 | |
| 71 #else | |
| 72 #define YAFFS_MAX_NAME_LENGTH 255 | |
| 73 #define YAFFS_MAX_ALIAS_LENGTH 159 | |
| 74 #endif | |
| 75 | |
| 76 #define YAFFS_SHORT_NAME_LENGTH 15 | |
| 77 | |
| 131 | 78 /* Some special object ids for pseudo objects */ |
| 77 | 79 #define YAFFS_OBJECTID_ROOT 1 |
| 0 | 80 #define YAFFS_OBJECTID_LOSTNFOUND 2 |
| 81 #define YAFFS_OBJECTID_UNLINKED 3 | |
| 82 #define YAFFS_OBJECTID_DELETED 4 | |
| 83 | |
| 131 | 84 /* Sseudo object ids for checkpointing */ |
| 85 #define YAFFS_OBJECTID_SB_HEADER 0x10 | |
| 86 #define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 | |
| 134 | 87 #define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 |
| 131 | 88 |
| 89 /* */ | |
| 90 | |
| 0 | 91 #define YAFFS_MAX_SHORT_OP_CACHES 20 |
| 92 | |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
93 #define YAFFS_N_TEMP_BUFFERS 6 |
| 0 | 94 |
| 185 | 95 /* We limit the number attempts at sucessfully saving a chunk of data. |
| 96 * Small-page devices have 32 pages per block; large-page devices have 64. | |
| 97 * Default to something in the order of 5 to 10 blocks worth of chunks. | |
| 98 */ | |
| 99 #define YAFFS_WR_ATTEMPTS (5*64) | |
| 100 | |
| 81 | 101 /* Sequence numbers are used in YAFFS2 to determine block allocation order. |
| 102 * The range is limited slightly to help distinguish bad numbers from good. | |
| 103 * This also allows us to perhaps in the future use special numbers for | |
| 104 * special purposes. | |
| 215 | 105 * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years, |
| 81 | 106 * and is a larger number than the lifetime of a 2GB device. |
| 107 */ | |
| 0 | 108 #define YAFFS_LOWEST_SEQUENCE_NUMBER 0x00001000 |
| 109 #define YAFFS_HIGHEST_SEQUENCE_NUMBER 0xEFFFFF00 | |
| 110 | |
| 81 | 111 /* ChunkCache is used for short read/write operations.*/ |
| 77 | 112 typedef struct { |
| 0 | 113 struct yaffs_ObjectStruct *object; |
| 114 int chunkId; | |
| 115 int lastUse; | |
| 77 | 116 int dirty; |
| 81 | 117 int nBytes; /* Only valid if the cache is dirty */ |
| 118 int locked; /* Can't push out or flush while locked. */ | |
| 4 | 119 #ifdef CONFIG_YAFFS_YAFFS2 |
| 0 | 120 __u8 *data; |
| 121 #else | |
| 122 __u8 data[YAFFS_BYTES_PER_CHUNK]; | |
| 123 #endif | |
| 124 } yaffs_ChunkCache; | |
| 125 | |
| 81 | 126 |
| 127 | |
| 128 /* Tags structures in RAM | |
| 129 * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise | |
| 130 * the structure size will get blown out. | |
| 131 */ | |
| 132 | |
| 0 | 133 #ifndef CONFIG_YAFFS_NO_YAFFS1 |
| 77 | 134 typedef struct { |
| 0 | 135 unsigned chunkId:20; |
| 77 | 136 unsigned serialNumber:2; |
| 137 unsigned byteCount:10; | |
| 138 unsigned objectId:18; | |
| 139 unsigned ecc:12; | |
| 140 unsigned unusedStuff:2; | |
| 0 | 141 |
| 142 } yaffs_Tags; | |
| 143 | |
| 77 | 144 typedef union { |
| 145 yaffs_Tags asTags; | |
| 146 __u8 asBytes[8]; | |
| 0 | 147 } yaffs_TagsUnion; |
| 148 | |
| 149 #endif | |
| 150 | |
| 81 | 151 /* Stuff used for extended tags in YAFFS2 */ |
| 152 | |
| 77 | 153 typedef enum { |
| 0 | 154 YAFFS_ECC_RESULT_UNKNOWN, |
| 155 YAFFS_ECC_RESULT_NO_ERROR, | |
| 156 YAFFS_ECC_RESULT_FIXED, | |
| 157 YAFFS_ECC_RESULT_UNFIXED | |
| 158 } yaffs_ECCResult; | |
| 159 | |
| 77 | 160 typedef enum { |
| 15 | 161 YAFFS_OBJECT_TYPE_UNKNOWN, |
| 162 YAFFS_OBJECT_TYPE_FILE, | |
| 163 YAFFS_OBJECT_TYPE_SYMLINK, | |
| 164 YAFFS_OBJECT_TYPE_DIRECTORY, | |
| 165 YAFFS_OBJECT_TYPE_HARDLINK, | |
| 166 YAFFS_OBJECT_TYPE_SPECIAL | |
| 167 } yaffs_ObjectType; | |
| 168 | |
| 182 | 169 #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL |
| 170 | |
| 77 | 171 typedef struct { |
| 0 | 172 |
| 173 unsigned validMarker0; | |
| 81 | 174 unsigned chunkUsed; /* Status of the chunk: used or unused */ |
| 175 unsigned objectId; /* If 0 then this is not part of an object (unused) */ | |
| 176 unsigned chunkId; /* If 0 then this is a header, else a data chunk */ | |
| 177 unsigned byteCount; /* Only valid for data chunks */ | |
| 77 | 178 |
| 81 | 179 /* The following stuff only has meaning when we read */ |
| 180 yaffs_ECCResult eccResult; | |
| 215 | 181 unsigned blockBad; |
| 0 | 182 |
| 81 | 183 /* YAFFS 1 stuff */ |
| 184 unsigned chunkDeleted; /* The chunk is marked deleted */ | |
| 185 unsigned serialNumber; /* Yaffs1 2-bit serial number */ | |
| 77 | 186 |
| 81 | 187 /* YAFFS2 stuff */ |
| 188 unsigned sequenceNumber; /* The sequence number of this block */ | |
| 0 | 189 |
| 81 | 190 /* Extra info if this is an object header (YAFFS2 only) */ |
| 77 | 191 |
| 81 | 192 unsigned extraHeaderInfoAvailable; /* There is extra info available if this is not zero */ |
| 193 unsigned extraParentObjectId; /* The parent object */ | |
| 194 unsigned extraIsShrinkHeader; /* Is it a shrink header? */ | |
| 195 unsigned extraShadows; /* Does this shadow another object? */ | |
| 15 | 196 |
| 81 | 197 yaffs_ObjectType extraObjectType; /* What object type? */ |
| 15 | 198 |
| 81 | 199 unsigned extraFileLength; /* Length if it is a file */ |
| 200 unsigned extraEquivalentObjectId; /* Equivalent object Id if it is a hard link */ | |
| 77 | 201 |
| 202 unsigned validMarker1; | |
| 203 | |
| 0 | 204 } yaffs_ExtendedTags; |
| 205 | |
| 81 | 206 /* Spare structure for YAFFS1 */ |
| 77 | 207 typedef struct { |
| 208 __u8 tagByte0; | |
| 209 __u8 tagByte1; | |
| 210 __u8 tagByte2; | |
| 211 __u8 tagByte3; | |
| 81 | 212 __u8 pageStatus; /* set to 0 to delete the chunk */ |
| 77 | 213 __u8 blockStatus; |
| 214 __u8 tagByte4; | |
| 215 __u8 tagByte5; | |
| 216 __u8 ecc1[3]; | |
| 217 __u8 tagByte6; | |
| 218 __u8 tagByte7; | |
| 219 __u8 ecc2[3]; | |
| 0 | 220 } yaffs_Spare; |
| 221 | |
| 81 | 222 /*Special structure for passing through to mtd */ |
| 0 | 223 struct yaffs_NANDSpare { |
| 77 | 224 yaffs_Spare spare; |
| 225 int eccres1; | |
| 226 int eccres2; | |
| 0 | 227 }; |
| 228 | |
| 81 | 229 /* Block data in RAM */ |
| 0 | 230 |
| 231 typedef enum { | |
| 77 | 232 YAFFS_BLOCK_STATE_UNKNOWN = 0, |
| 4 | 233 |
| 0 | 234 YAFFS_BLOCK_STATE_SCANNING, |
| 77 | 235 YAFFS_BLOCK_STATE_NEEDS_SCANNING, |
| 81 | 236 /* The block might have something on it (ie it is allocating or full, perhaps empty) |
| 237 * but it needs to be scanned to determine its true state. | |
| 238 * This state is only valid during yaffs_Scan. | |
| 239 * NB We tolerate empty because the pre-scanner might be incapable of deciding | |
| 240 * However, if this state is returned on a YAFFS2 device, then we expect a sequence number | |
| 241 */ | |
| 77 | 242 |
| 243 YAFFS_BLOCK_STATE_EMPTY, | |
| 81 | 244 /* This block is empty */ |
| 0 | 245 |
| 77 | 246 YAFFS_BLOCK_STATE_ALLOCATING, |
| 215 | 247 /* This block is partially allocated. |
| 134 | 248 * At least one page holds valid data. |
| 81 | 249 * This is the one currently being used for page |
| 250 * allocation. Should never be more than one of these | |
| 251 */ | |
| 77 | 252 |
| 215 | 253 YAFFS_BLOCK_STATE_FULL, |
| 81 | 254 /* All the pages in this block have been allocated. |
| 255 */ | |
| 0 | 256 |
| 77 | 257 YAFFS_BLOCK_STATE_DIRTY, |
| 215 | 258 /* All pages have been allocated and deleted. |
| 81 | 259 * Erase me, reuse me. |
| 260 */ | |
| 77 | 261 |
| 215 | 262 YAFFS_BLOCK_STATE_CHECKPOINT, |
| 134 | 263 /* This block is assigned to holding checkpoint data. |
| 264 */ | |
| 265 | |
| 215 | 266 YAFFS_BLOCK_STATE_COLLECTING, |
| 81 | 267 /* This block is being garbage collected */ |
| 77 | 268 |
| 215 | 269 YAFFS_BLOCK_STATE_DEAD |
| 81 | 270 /* This block has failed and is not in use */ |
| 0 | 271 } yaffs_BlockState; |
| 272 | |
| 182 | 273 #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) |
| 274 | |
| 275 | |
| 77 | 276 typedef struct { |
| 0 | 277 |
| 153 | 278 int softDeletions:10; /* number of soft deleted pages */ |
| 279 int pagesInUse:10; /* number of pages in use */ | |
| 185 | 280 unsigned blockState:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ |
| 81 | 281 __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */ |
| 282 /* and retire the block. */ | |
| 148 | 283 __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */ |
| 215 | 284 __u32 gcPrioritise: 1; /* An ECC check or blank check has failed on this block. |
| 148 | 285 It should be prioritised for GC */ |
| 153 | 286 __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ |
| 148 | 287 |
| 4 | 288 #ifdef CONFIG_YAFFS_YAFFS2 |
| 81 | 289 __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */ |
| 290 __u32 sequenceNumber; /* block sequence number for yaffs2 */ | |
| 0 | 291 #endif |
| 292 | |
| 293 } yaffs_BlockInfo; | |
| 294 | |
| 81 | 295 /* -------------------------- Object structure -------------------------------*/ |
| 296 /* This is the object structure as stored on NAND */ | |
| 0 | 297 |
| 77 | 298 typedef struct { |
| 0 | 299 yaffs_ObjectType type; |
| 300 | |
| 81 | 301 /* Apply to everything */ |
| 77 | 302 int parentObjectId; |
| 215 | 303 __u16 sum__NoLongerUsed; /* checksum of name. No longer used */ |
| 304 YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; | |
| 0 | 305 |
| 215 | 306 /* The following apply to directories, files, symlinks - not hard links */ |
| 307 __u32 yst_mode; /* protection */ | |
| 0 | 308 |
| 309 #ifdef CONFIG_YAFFS_WINCE | |
| 310 __u32 notForWinCE[5]; | |
| 311 #else | |
| 81 | 312 __u32 yst_uid; |
| 313 __u32 yst_gid; | |
| 314 __u32 yst_atime; | |
| 315 __u32 yst_mtime; | |
| 316 __u32 yst_ctime; | |
| 0 | 317 #endif |
| 318 | |
| 81 | 319 /* File size applies to files only */ |
| 77 | 320 int fileSize; |
| 321 | |
| 81 | 322 /* Equivalent object id applies to hard links only. */ |
| 77 | 323 int equivalentObjectId; |
| 324 | |
| 81 | 325 /* Alias is for symlinks only. */ |
| 0 | 326 YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; |
| 77 | 327 |
| 81 | 328 __u32 yst_rdev; /* device stuff for block and char devices (major/min) */ |
| 77 | 329 |
| 0 | 330 #ifdef CONFIG_YAFFS_WINCE |
| 331 __u32 win_ctime[2]; | |
| 332 __u32 win_atime[2]; | |
| 333 __u32 win_mtime[2]; | |
| 334 #else | |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
335 __u32 roomToGrow[6]; |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
336 |
| 0 | 337 #endif |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
338 __u32 inbandShadowsObject; |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
339 __u32 inbandIsShrink; |
| 0 | 340 |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
341 __u32 reservedSpace[2]; |
| 81 | 342 int shadowsObject; /* This object header shadows the specified object if > 0 */ |
| 48 | 343 |
| 81 | 344 /* isShrink applies to object headers written when we shrink the file (ie resize) */ |
| 0 | 345 __u32 isShrink; |
| 77 | 346 |
| 0 | 347 } yaffs_ObjectHeader; |
| 348 | |
| 81 | 349 /*--------------------------- Tnode -------------------------- */ |
| 0 | 350 |
| 77 | 351 union yaffs_Tnode_union { |
| 0 | 352 #ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG |
| 77 | 353 union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL + 1]; |
| 0 | 354 #else |
| 355 union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL]; | |
| 356 #endif | |
| 105 | 357 /* __u16 level0[YAFFS_NTNODES_LEVEL0]; */ |
| 77 | 358 |
| 0 | 359 }; |
| 360 | |
| 361 typedef union yaffs_Tnode_union yaffs_Tnode; | |
| 362 | |
| 77 | 363 struct yaffs_TnodeList_struct { |
| 0 | 364 struct yaffs_TnodeList_struct *next; |
| 365 yaffs_Tnode *tnodes; | |
| 366 }; | |
| 367 | |
| 368 typedef struct yaffs_TnodeList_struct yaffs_TnodeList; | |
| 369 | |
| 81 | 370 /*------------------------ Object -----------------------------*/ |
| 371 /* An object can be one of: | |
| 372 * - a directory (no data, has children links | |
| 373 * - a regular file (data.... not prunes :->). | |
| 374 * - a symlink [symbolic link] (the alias). | |
| 375 * - a hard link | |
| 376 */ | |
| 0 | 377 |
| 77 | 378 typedef struct { |
| 0 | 379 __u32 fileSize; |
| 380 __u32 scannedFileSize; | |
| 15 | 381 __u32 shrinkSize; |
| 77 | 382 int topLevel; |
| 0 | 383 yaffs_Tnode *top; |
| 384 } yaffs_FileStructure; | |
| 385 | |
| 77 | 386 typedef struct { |
| 215 | 387 struct ylist_head children; /* list of child links */ |
| 0 | 388 } yaffs_DirectoryStructure; |
| 389 | |
| 77 | 390 typedef struct { |
| 0 | 391 YCHAR *alias; |
| 392 } yaffs_SymLinkStructure; | |
| 393 | |
| 77 | 394 typedef struct { |
| 0 | 395 struct yaffs_ObjectStruct *equivalentObject; |
| 77 | 396 __u32 equivalentObjectId; |
| 0 | 397 } yaffs_HardLinkStructure; |
| 398 | |
| 77 | 399 typedef union { |
| 0 | 400 yaffs_FileStructure fileVariant; |
| 401 yaffs_DirectoryStructure directoryVariant; | |
| 402 yaffs_SymLinkStructure symLinkVariant; | |
| 403 yaffs_HardLinkStructure hardLinkVariant; | |
| 404 } yaffs_ObjectVariant; | |
| 405 | |
| 77 | 406 struct yaffs_ObjectStruct { |
| 81 | 407 __u8 deleted:1; /* This should only apply to unlinked files. */ |
| 408 __u8 softDeleted:1; /* it has also been soft deleted */ | |
| 409 __u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory.*/ | |
| 410 __u8 fake:1; /* A fake object has no presence on NAND. */ | |
| 411 __u8 renameAllowed:1; /* Some objects are not allowed to be renamed. */ | |
| 77 | 412 __u8 unlinkAllowed:1; |
| 81 | 413 __u8 dirty:1; /* the object needs to be written to flash */ |
| 215 | 414 __u8 valid:1; /* When the file system is being loaded up, this |
| 81 | 415 * object might be created before the data |
| 416 * is available (ie. file data records appear before the header). | |
| 417 */ | |
| 124 | 418 __u8 lazyLoaded:1; /* This object has been lazy loaded and is missing some detail */ |
| 0 | 419 |
| 81 | 420 __u8 deferedFree:1; /* For Linux kernel. Object is removed from NAND, but is |
| 421 * still in the inode cache. Free of object is defered. | |
| 422 * until the inode is released. | |
| 423 */ | |
| 4 | 424 |
| 124 | 425 __u8 serial; /* serial number of chunk in NAND. Cached here */ |
| 81 | 426 __u16 sum; /* sum of the name to speed searching */ |
| 427 | |
| 215 | 428 struct yaffs_DeviceStruct *myDev; /* The device I'm on */ |
| 77 | 429 |
| 215 | 430 struct ylist_head hashLink; /* list of objects in this hash bucket */ |
| 4 | 431 |
| 215 | 432 struct ylist_head hardLinks; /* all the equivalent hard linked objects */ |
| 0 | 433 |
| 215 | 434 /* directory structure stuff */ |
| 435 /* also used for linking up the free list */ | |
| 436 struct yaffs_ObjectStruct *parent; | |
| 437 struct ylist_head siblings; | |
| 77 | 438 |
| 215 | 439 /* Where's my object header in NAND? */ |
| 440 int chunkId; | |
| 0 | 441 |
| 81 | 442 int nDataChunks; /* Number of data chunks attached to the file. */ |
| 77 | 443 |
| 81 | 444 __u32 objectId; /* the object id value */ |
| 77 | 445 |
| 81 | 446 __u32 yst_mode; |
| 0 | 447 |
| 448 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM | |
| 77 | 449 YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1]; |
| 0 | 450 #endif |
| 451 | |
| 452 #ifndef __KERNEL__ | |
| 453 __u32 inUse; | |
| 454 #endif | |
| 455 | |
| 456 #ifdef CONFIG_YAFFS_WINCE | |
| 457 __u32 win_ctime[2]; | |
| 458 __u32 win_mtime[2]; | |
| 459 __u32 win_atime[2]; | |
| 460 #else | |
| 81 | 461 __u32 yst_uid; |
| 462 __u32 yst_gid; | |
| 463 __u32 yst_atime; | |
| 464 __u32 yst_mtime; | |
| 465 __u32 yst_ctime; | |
| 0 | 466 #endif |
| 467 | |
| 81 | 468 __u32 yst_rdev; |
| 0 | 469 |
| 470 #ifdef __KERNEL__ | |
| 471 struct inode *myInode; | |
| 4 | 472 |
| 0 | 473 #endif |
| 474 | |
| 77 | 475 yaffs_ObjectType variantType; |
| 0 | 476 |
| 477 yaffs_ObjectVariant variant; | |
| 77 | 478 |
| 0 | 479 }; |
| 480 | |
| 481 typedef struct yaffs_ObjectStruct yaffs_Object; | |
| 482 | |
| 77 | 483 struct yaffs_ObjectList_struct { |
| 0 | 484 yaffs_Object *objects; |
| 485 struct yaffs_ObjectList_struct *next; | |
| 486 }; | |
| 487 | |
| 488 typedef struct yaffs_ObjectList_struct yaffs_ObjectList; | |
| 489 | |
| 77 | 490 typedef struct { |
| 215 | 491 struct ylist_head list; |
| 492 int count; | |
| 0 | 493 } yaffs_ObjectBucket; |
| 494 | |
| 131 | 495 |
| 215 | 496 /* yaffs_CheckpointObject holds the definition of an object as dumped |
| 131 | 497 * by checkpointing. |
| 498 */ | |
| 499 | |
| 500 typedef struct { | |
| 501 int structType; | |
| 215 | 502 __u32 objectId; |
| 131 | 503 __u32 parentId; |
| 504 int chunkId; | |
| 215 | 505 |
| 131 | 506 yaffs_ObjectType variantType:3; |
| 215 | 507 __u8 deleted:1; |
| 508 __u8 softDeleted:1; | |
| 509 __u8 unlinked:1; | |
| 510 __u8 fake:1; | |
| 131 | 511 __u8 renameAllowed:1; |
| 512 __u8 unlinkAllowed:1; | |
| 215 | 513 __u8 serial; |
| 514 | |
| 515 int nDataChunks; | |
| 131 | 516 __u32 fileSizeOrEquivalentObjectId; |
| 517 | |
| 518 }yaffs_CheckpointObject; | |
| 519 | |
| 81 | 520 /*--------------------- Temporary buffers ---------------- |
| 521 * | |
| 522 * These are chunk-sized working buffers. Each device has a few | |
| 523 */ | |
| 0 | 524 |
| 525 typedef struct { | |
| 526 __u8 *buffer; | |
| 81 | 527 int line; /* track from whence this buffer was allocated */ |
| 0 | 528 int maxLine; |
| 529 } yaffs_TempBuffer; | |
| 530 | |
| 81 | 531 /*----------------- Device ---------------------------------*/ |
| 0 | 532 |
| 77 | 533 struct yaffs_DeviceStruct { |
| 215 | 534 struct ylist_head devList; |
| 535 const char *name; | |
| 29 | 536 |
| 215 | 537 /* Entry parameters set up way early. Yaffs sets up the rest.*/ |
| 538 int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */ | |
| 539 int nChunksPerBlock; /* does not need to be a power of 2 */ | |
| 540 int spareBytesPerChunk;/* spare area size */ | |
| 541 int startBlock; /* Start block we're allowed to use */ | |
| 542 int endBlock; /* End block we're allowed to use */ | |
| 543 int nReservedBlocks; /* We want this tuneable so that we can reduce */ | |
| 81 | 544 /* reserved blocks on NOR and RAM. */ |
| 215 | 545 |
| 546 | |
| 134 | 547 /* Stuff used by the shared space checkpointing mechanism */ |
| 548 /* If this value is zero, then this mechanism is disabled */ | |
| 215 | 549 |
|
203
88a05fb266f0
Change checkpoint to calculate number of blocks required instead of using a hardcoded value
charles
parents:
185
diff
changeset
|
550 // int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */ |
| 131 | 551 |
| 215 | 552 |
| 131 | 553 |
| 0 | 554 |
| 81 | 555 int nShortOpCaches; /* If <= 0, then short op caching is disabled, else |
| 556 * the number of short op caches (don't use too many) | |
| 557 */ | |
| 77 | 558 |
| 81 | 559 int useHeaderFileSize; /* Flag to determine if we should use file sizes from the header */ |
| 77 | 560 |
| 81 | 561 int useNANDECC; /* Flag to decide whether or not to use NANDECC */ |
| 77 | 562 |
| 81 | 563 void *genericDevice; /* Pointer to device context |
| 564 * On an mtd this holds the mtd pointer. | |
| 565 */ | |
| 134 | 566 void *superBlock; |
| 215 | 567 |
| 81 | 568 /* NAND access functions (Must be set before calling YAFFS)*/ |
| 4 | 569 |
| 77 | 570 int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev, |
| 571 int chunkInNAND, const __u8 * data, | |
| 572 const yaffs_Spare * spare); | |
| 573 int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev, | |
| 574 int chunkInNAND, __u8 * data, | |
| 575 yaffs_Spare * spare); | |
| 576 int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev, | |
| 577 int blockInNAND); | |
| 578 int (*initialiseNAND) (struct yaffs_DeviceStruct * dev); | |
| 4 | 579 |
| 580 #ifdef CONFIG_YAFFS_YAFFS2 | |
| 77 | 581 int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev, |
| 582 int chunkInNAND, const __u8 * data, | |
| 583 const yaffs_ExtendedTags * tags); | |
| 584 int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev, | |
| 585 int chunkInNAND, __u8 * data, | |
| 586 yaffs_ExtendedTags * tags); | |
| 587 int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo); | |
| 588 int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo, | |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
589 yaffs_BlockState * state, __u32 *sequenceNumber); |
| 0 | 590 #endif |
| 591 | |
| 592 int isYaffs2; | |
| 215 | 593 |
| 594 /* The removeObjectCallback function must be supplied by OS flavours that | |
| 84 | 595 * need it. The Linux kernel does not use this, but yaffs direct does use |
| 596 * it to implement the faster readdir | |
| 597 */ | |
| 598 void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj); | |
| 215 | 599 |
| 134 | 600 /* Callback to mark the superblock dirsty */ |
| 601 void (*markSuperBlockDirty)(void * superblock); | |
| 215 | 602 |
| 105 | 603 int wideTnodesDisabled; /* Set to disable wide tnodes */ |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
604 |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
605 YCHAR *pathDividers; /* String of legal path dividers */ |
| 215 | 606 |
| 0 | 607 |
| 81 | 608 /* End of stuff that must be set before initialisation. */ |
| 215 | 609 |
| 182 | 610 /* Checkpoint control. Can be set before or after initialisation */ |
| 611 __u8 skipCheckpointRead; | |
| 612 __u8 skipCheckpointWrite; | |
| 77 | 613 |
| 81 | 614 /* Runtime parameters. Set up by YAFFS. */ |
| 77 | 615 |
| 81 | 616 __u16 chunkGroupBits; /* 0 for devices <= 32MB. else log2(nchunks) - 16 */ |
| 617 __u16 chunkGroupSize; /* == 2^^chunkGroupBits */ | |
| 215 | 618 |
| 105 | 619 /* Stuff to support wide tnodes */ |
| 620 __u32 tnodeWidth; | |
| 621 __u32 tnodeMask; | |
| 215 | 622 |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
623 /* Stuff for figuring out file offset to chunk conversions */ |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
624 __u32 chunkShift; /* Shift value */ |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
625 __u32 chunkDiv; /* Divisor after shifting: 1 for power-of-2 sizes */ |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
626 __u32 chunkMask; /* Mask to use for power-of-2 case */ |
|
205
f95fdc6123fb
Cleanup patch - Remove all trailing whitespace and fix a few typos.
wookey
parents:
203
diff
changeset
|
627 |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
628 /* Stuff to handle inband tags */ |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
629 int inbandTags; |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
630 __u32 totalBytesPerChunk; |
| 77 | 631 |
| 0 | 632 #ifdef __KERNEL__ |
| 633 | |
| 81 | 634 struct semaphore sem; /* Semaphore for waiting on erasure.*/ |
| 635 struct semaphore grossLock; /* Gross locking semaphore */ | |
| 215 | 636 __u8 *spareBuffer; /* For mtdif2 use. Don't know the size of the buffer |
| 81 | 637 * at compile time so we have to allocate it. |
| 638 */ | |
| 77 | 639 void (*putSuperFunc) (struct super_block * sb); |
| 0 | 640 #endif |
| 641 | |
| 642 int isMounted; | |
| 215 | 643 |
| 131 | 644 int isCheckpointed; |
| 77 | 645 |
|
152
3bc7020d669c
Add large NAND support and improve retirement handling
charles
parents:
148
diff
changeset
|
646 |
| 81 | 647 /* Stuff to support block offsetting to support start block zero */ |
| 21 | 648 int internalStartBlock; |
| 649 int internalEndBlock; | |
| 650 int blockOffset; | |
| 651 int chunkOffset; | |
| 215 | 652 |
| 77 | 653 |
| 131 | 654 /* Runtime checkpointing stuff */ |
| 134 | 655 int checkpointPageSequence; /* running sequence number of checkpoint pages */ |
| 131 | 656 int checkpointByteCount; |
| 657 int checkpointByteOffset; | |
| 658 __u8 *checkpointBuffer; | |
| 659 int checkpointOpenForWrite; | |
| 134 | 660 int blocksInCheckpoint; |
| 661 int checkpointCurrentChunk; | |
| 662 int checkpointCurrentBlock; | |
| 663 int checkpointNextBlock; | |
| 664 int *checkpointBlockList; | |
| 665 int checkpointMaxBlocks; | |
| 182 | 666 __u32 checkpointSum; |
| 667 __u32 checkpointXor; | |
| 215 | 668 |
|
203
88a05fb266f0
Change checkpoint to calculate number of blocks required instead of using a hardcoded value
charles
parents:
185
diff
changeset
|
669 int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */ |
| 215 | 670 |
| 81 | 671 /* Block Info */ |
| 0 | 672 yaffs_BlockInfo *blockInfo; |
| 81 | 673 __u8 *chunkBits; /* bitmap of chunks in use */ |
| 95 | 674 unsigned blockInfoAlt:1; /* was allocated using alternative strategy */ |
| 675 unsigned chunkBitsAlt:1; /* was allocated using alternative strategy */ | |
| 215 | 676 int chunkBitmapStride; /* Number of bytes of chunkBits per block. |
| 81 | 677 * Must be consistent with nChunksPerBlock. |
| 678 */ | |
| 0 | 679 |
| 77 | 680 int nErasedBlocks; |
| 81 | 681 int allocationBlock; /* Current block being allocated off */ |
| 0 | 682 __u32 allocationPage; |
| 81 | 683 int allocationBlockFinder; /* Used to search for next allocation block */ |
| 77 | 684 |
| 81 | 685 /* Runtime state */ |
| 77 | 686 int nTnodesCreated; |
| 0 | 687 yaffs_Tnode *freeTnodes; |
| 77 | 688 int nFreeTnodes; |
| 0 | 689 yaffs_TnodeList *allocatedTnodeList; |
| 690 | |
| 77 | 691 int isDoingGC; |
| 0 | 692 |
| 77 | 693 int nObjectsCreated; |
| 0 | 694 yaffs_Object *freeObjects; |
| 77 | 695 int nFreeObjects; |
| 0 | 696 |
| 697 yaffs_ObjectList *allocatedObjectList; | |
| 698 | |
| 699 yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; | |
| 700 | |
| 77 | 701 int nFreeChunks; |
| 702 | |
| 81 | 703 int currentDirtyChecker; /* Used to find current dirtiest block */ |
| 77 | 704 |
| 81 | 705 __u32 *gcCleanupList; /* objects to delete at the end of a GC. */ |
| 185 | 706 int nonAggressiveSkip; /* GC state/mode */ |
| 77 | 707 |
| 81 | 708 /* Statistcs */ |
| 0 | 709 int nPageWrites; |
| 710 int nPageReads; | |
| 711 int nBlockErasures; | |
| 712 int nErasureFailures; | |
| 713 int nGCCopies; | |
| 714 int garbageCollections; | |
| 715 int passiveGarbageCollections; | |
| 716 int nRetriedWrites; | |
| 717 int nRetiredBlocks; | |
| 718 int eccFixed; | |
| 719 int eccUnfixed; | |
| 720 int tagsEccFixed; | |
| 721 int tagsEccUnfixed; | |
| 722 int nDeletions; | |
| 723 int nUnmarkedDeletions; | |
| 215 | 724 |
|
152
3bc7020d669c
Add large NAND support and improve retirement handling
charles
parents:
148
diff
changeset
|
725 int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */ |
| 77 | 726 |
| 81 | 727 /* Special directories */ |
| 0 | 728 yaffs_Object *rootDir; |
| 729 yaffs_Object *lostNFoundDir; | |
| 77 | 730 |
| 81 | 731 /* Buffer areas for storing data to recover from write failures TODO |
| 732 * __u8 bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; | |
| 733 * yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK]; | |
| 734 */ | |
| 215 | 735 |
| 81 | 736 int bufferedBlock; /* Which block is buffered here? */ |
| 0 | 737 int doingBufferedBlockRewrite; |
| 738 | |
| 739 yaffs_ChunkCache *srCache; | |
| 740 int srLastUse; | |
| 741 | |
| 742 int cacheHits; | |
| 743 | |
| 81 | 744 /* Stuff for background deletion and unlinked files.*/ |
| 745 yaffs_Object *unlinkedDir; /* Directory where unlinked and deleted files live. */ | |
| 746 yaffs_Object *deletedDir; /* Directory where deleted objects are sent to disappear. */ | |
| 747 yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/ | |
| 748 int nDeletedFiles; /* Count of files awaiting deletion;*/ | |
| 749 int nUnlinkedFiles; /* Count of unlinked files. */ | |
| 750 int nBackgroundDeletions; /* Count of background deletions. */ | |
| 77 | 751 |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
752 |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
753 /* Temporary buffer management */ |
| 0 | 754 yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS]; |
| 755 int maxTemp; | |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
756 int tempInUse; |
| 0 | 757 int unmanagedTempAllocations; |
| 758 int unmanagedTempDeallocations; | |
| 77 | 759 |
| 81 | 760 /* yaffs2 runtime stuff */ |
| 761 unsigned sequenceNumber; /* Sequence number of currently allocating block */ | |
| 0 | 762 unsigned oldestDirtySequence; |
| 77 | 763 |
| 0 | 764 }; |
| 765 | |
| 766 typedef struct yaffs_DeviceStruct yaffs_Device; | |
| 767 | |
|
205
f95fdc6123fb
Cleanup patch - Remove all trailing whitespace and fix a few typos.
wookey
parents:
203
diff
changeset
|
768 /* The static layout of block usage etc is stored in the super block header */ |
| 131 | 769 typedef struct { |
| 770 int StructType; | |
| 215 | 771 int version; |
| 131 | 772 int checkpointStartBlock; |
| 773 int checkpointEndBlock; | |
| 774 int startBlock; | |
| 775 int endBlock; | |
| 776 int rfu[100]; | |
| 777 } yaffs_SuperBlockHeader; | |
| 215 | 778 |
| 131 | 779 /* The CheckpointDevice structure holds the device information that changes at runtime and |
| 780 * must be preserved over unmount/mount cycles. | |
| 781 */ | |
| 782 typedef struct { | |
| 783 int structType; | |
| 784 int nErasedBlocks; | |
| 785 int allocationBlock; /* Current block being allocated off */ | |
| 786 __u32 allocationPage; | |
| 787 int nFreeChunks; | |
| 788 | |
| 789 int nDeletedFiles; /* Count of files awaiting deletion;*/ | |
| 790 int nUnlinkedFiles; /* Count of unlinked files. */ | |
| 791 int nBackgroundDeletions; /* Count of background deletions. */ | |
| 792 | |
| 793 /* yaffs2 runtime stuff */ | |
| 794 unsigned sequenceNumber; /* Sequence number of currently allocating block */ | |
| 795 unsigned oldestDirtySequence; | |
| 796 | |
| 797 } yaffs_CheckpointDevice; | |
| 798 | |
| 799 | |
| 800 typedef struct { | |
| 801 int structType; | |
| 802 __u32 magic; | |
| 803 __u32 version; | |
| 804 __u32 head; | |
| 805 } yaffs_CheckpointValidity; | |
| 806 | |
| 0 | 807 |
| 81 | 808 /*----------------------- YAFFS Functions -----------------------*/ |
| 0 | 809 |
| 77 | 810 int yaffs_GutsInitialise(yaffs_Device * dev); |
| 811 void yaffs_Deinitialise(yaffs_Device * dev); | |
| 0 | 812 |
| 77 | 813 int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev); |
| 0 | 814 |
| 77 | 815 int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName, |
| 816 yaffs_Object * newDir, const YCHAR * newName); | |
| 0 | 817 |
| 77 | 818 int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name); |
| 819 int yaffs_DeleteFile(yaffs_Object * obj); | |
| 0 | 820 |
| 77 | 821 int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize); |
| 822 int yaffs_GetObjectFileLength(yaffs_Object * obj); | |
| 823 int yaffs_GetObjectInode(yaffs_Object * obj); | |
| 824 unsigned yaffs_GetObjectType(yaffs_Object * obj); | |
| 825 int yaffs_GetObjectLinkCount(yaffs_Object * obj); | |
| 0 | 826 |
| 77 | 827 int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr); |
| 828 int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr); | |
| 0 | 829 |
| 81 | 830 /* File operations */ |
|
152
3bc7020d669c
Add large NAND support and improve retirement handling
charles
parents:
148
diff
changeset
|
831 int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset, |
| 215 | 832 int nBytes); |
|
152
3bc7020d669c
Add large NAND support and improve retirement handling
charles
parents:
148
diff
changeset
|
833 int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset, |
| 215 | 834 int nBytes, int writeThrough); |
|
152
3bc7020d669c
Add large NAND support and improve retirement handling
charles
parents:
148
diff
changeset
|
835 int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize); |
| 0 | 836 |
| 77 | 837 yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name, |
| 215 | 838 __u32 mode, __u32 uid, __u32 gid); |
| 77 | 839 int yaffs_FlushFile(yaffs_Object * obj, int updateTime); |
| 0 | 840 |
| 131 | 841 /* Flushing and checkpointing */ |
| 842 void yaffs_FlushEntireDeviceCache(yaffs_Device *dev); | |
| 843 | |
| 844 int yaffs_CheckpointSave(yaffs_Device *dev); | |
| 845 int yaffs_CheckpointRestore(yaffs_Device *dev); | |
| 846 | |
| 81 | 847 /* Directory operations */ |
| 77 | 848 yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name, |
| 849 __u32 mode, __u32 uid, __u32 gid); | |
| 850 yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name); | |
| 851 int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir, | |
| 852 int (*fn) (yaffs_Object *)); | |
| 0 | 853 |
| 77 | 854 yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number); |
| 0 | 855 |
| 81 | 856 /* Link operations */ |
| 77 | 857 yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name, |
| 858 yaffs_Object * equivalentObject); | |
| 0 | 859 |
| 77 | 860 yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj); |
| 0 | 861 |
| 81 | 862 /* Symlink operations */ |
| 77 | 863 yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name, |
| 864 __u32 mode, __u32 uid, __u32 gid, | |
| 865 const YCHAR * alias); | |
| 866 YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj); | |
| 0 | 867 |
| 81 | 868 /* Special inodes (fifos, sockets and devices) */ |
| 77 | 869 yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name, |
| 870 __u32 mode, __u32 uid, __u32 gid, __u32 rdev); | |
| 0 | 871 |
| 81 | 872 /* Special directories */ |
| 77 | 873 yaffs_Object *yaffs_Root(yaffs_Device * dev); |
| 874 yaffs_Object *yaffs_LostNFound(yaffs_Device * dev); | |
| 0 | 875 |
| 876 #ifdef CONFIG_YAFFS_WINCE | |
| 81 | 877 /* CONFIG_YAFFS_WINCE special stuff */ |
| 77 | 878 void yfsd_WinFileTimeNow(__u32 target[2]); |
| 0 | 879 #endif |
| 880 | |
| 4 | 881 #ifdef __KERNEL__ |
| 882 | |
| 77 | 883 void yaffs_HandleDeferedFree(yaffs_Object * obj); |
| 4 | 884 #endif |
| 885 | |
| 81 | 886 /* Debug dump */ |
| 77 | 887 int yaffs_DumpObject(yaffs_Object * obj); |
| 0 | 888 |
| 77 | 889 void yaffs_GutsTest(yaffs_Device * dev); |
| 0 | 890 |
| 84 | 891 /* A few useful functions */ |
| 77 | 892 void yaffs_InitialiseTags(yaffs_ExtendedTags * tags); |
| 893 void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn); | |
| 894 int yaffs_CheckFF(__u8 * buffer, int nBytes); | |
| 153 | 895 void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi); |
| 0 | 896 |
|
211
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
897 __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo); |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
898 void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer, int lineNo); |
|
fad21fd1971d
Check in inband tags, some extra yaffs direct functions and some other changes
charles
parents:
205
diff
changeset
|
899 |
| 0 | 900 #endif |