|
0
|
1 /* |
|
15
|
2 * YAFFS: Yet another FFS. A NAND-flash specific file system. |
|
0
|
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$ |
|
|
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 |
|
7
|
53 #define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 |
|
|
54 #define YAFFS_MIN_YAFFS2_SPARE_SIZE 32 |
|
|
55 |
|
0
|
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.. |
|
4
|
109 #ifdef CONFIG_YAFFS_YAFFS2 |
|
0
|
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 |
|
15
|
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 |
|
0
|
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) |
|
15
|
166 unsigned chunkId; // If 0 then this is a header, else a data chunk |
|
0
|
167 unsigned byteCount; // Only valid for data chunks |
|
15
|
168 |
|
|
169 |
|
0
|
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 |
|
15
|
181 // Extra info if this is an object header (YAFFS2 only) |
|
|
182 unsigned extraHeaderInfoAvailable; |
|
|
183 unsigned extraParentObjectId; |
|
|
184 unsigned extraIsShrinkHeader; |
|
|
185 |
|
|
186 yaffs_ObjectType extraObjectType; |
|
|
187 |
|
|
188 unsigned extraFileLength; |
|
|
189 unsigned extraEquivalentObjectId; |
|
|
190 |
|
0
|
191 unsigned validMarker1; |
|
|
192 |
|
|
193 } yaffs_ExtendedTags; |
|
|
194 |
|
|
195 #ifndef CONFIG_YAFFS_NO_YAFFS1 |
|
|
196 // Spare structure |
|
|
197 typedef struct |
|
|
198 { |
|
|
199 __u8 tagByte0; |
|
|
200 __u8 tagByte1; |
|
|
201 __u8 tagByte2; |
|
|
202 __u8 tagByte3; |
|
|
203 __u8 pageStatus; // set to 0 to delete the chunk |
|
|
204 __u8 blockStatus; |
|
|
205 __u8 tagByte4; |
|
|
206 __u8 tagByte5; |
|
|
207 __u8 ecc1[3]; |
|
|
208 __u8 tagByte6; |
|
|
209 __u8 tagByte7; |
|
|
210 __u8 ecc2[3]; |
|
|
211 } yaffs_Spare; |
|
|
212 |
|
|
213 //Special structure for passing through to mtd |
|
|
214 struct yaffs_NANDSpare { |
|
|
215 yaffs_Spare spare; |
|
|
216 int eccres1; |
|
|
217 int eccres2; |
|
|
218 }; |
|
|
219 #endif |
|
|
220 |
|
|
221 |
|
|
222 // Block data in RAM |
|
|
223 |
|
|
224 typedef enum { |
|
|
225 YAFFS_BLOCK_STATE_UNKNOWN = 0, |
|
4
|
226 |
|
0
|
227 YAFFS_BLOCK_STATE_SCANNING, |
|
|
228 YAFFS_BLOCK_STATE_NEEDS_SCANNING,// The block might have something on it (ie it is allocating or full, perhaps empty) |
|
|
229 // but it needs to be scanned to determine its true state. |
|
|
230 // This state is only valid during yaffs_Scan. |
|
|
231 // NB We tolerate empty because the pre-scanner might be incapable of deciding |
|
|
232 // However, if this state is returned on a YAFFS2 device, then we expect a sequence number |
|
|
233 |
|
|
234 YAFFS_BLOCK_STATE_EMPTY, // This block is empty |
|
|
235 |
|
|
236 YAFFS_BLOCK_STATE_ALLOCATING, // This block is partially allocated. |
|
|
237 // This is the one currently being used for page |
|
|
238 // allocation. Should never be more than one of these |
|
|
239 |
|
|
240 |
|
|
241 YAFFS_BLOCK_STATE_FULL, // All the pages in this block have been allocated. |
|
|
242 // At least one page holds valid data. |
|
|
243 |
|
|
244 YAFFS_BLOCK_STATE_DIRTY, // All pages have been allocated and deleted. |
|
|
245 // Erase me, reuse me. |
|
|
246 |
|
|
247 YAFFS_BLOCK_STATE_COLLECTING, // This block is being garbage collected |
|
|
248 |
|
|
249 YAFFS_BLOCK_STATE_DEAD // This block has failed and is not in use |
|
|
250 |
|
|
251 } yaffs_BlockState; |
|
|
252 |
|
|
253 |
|
|
254 |
|
|
255 |
|
|
256 typedef struct |
|
|
257 { |
|
|
258 |
|
15
|
259 int softDeletions:12; // number of soft deleted pages |
|
|
260 int pagesInUse:12; // number of pages in use |
|
|
261 yaffs_BlockState blockState:4; // One of the above block states |
|
0
|
262 __u32 needsRetiring:1; // Data has failed on this block, need to get valid data off |
|
|
263 // and retire the block. |
|
4
|
264 #ifdef CONFIG_YAFFS_YAFFS2 |
|
0
|
265 __u32 hasShrinkHeader:1;// This block has at least one object header that does a shrink |
|
|
266 __u32 sequenceNumber; // block sequence number for yaffs2 |
|
|
267 #endif |
|
|
268 |
|
|
269 } yaffs_BlockInfo; |
|
|
270 |
|
|
271 |
|
|
272 //////////////////// Object structure /////////////////////////// |
|
|
273 // This is the object structure as stored on NAND |
|
|
274 |
|
|
275 typedef struct |
|
|
276 { |
|
|
277 yaffs_ObjectType type; |
|
|
278 |
|
|
279 // Apply to everything |
|
|
280 int parentObjectId; |
|
|
281 __u16 sum__NoLongerUsed; // checksum of name. Calc this off the name to prevent inconsistencies |
|
|
282 YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; |
|
|
283 |
|
|
284 // Thes following apply to directories, files, symlinks - not hard links |
|
|
285 __u32 st_mode; // protection |
|
|
286 |
|
|
287 #ifdef CONFIG_YAFFS_WINCE |
|
|
288 __u32 notForWinCE[5]; |
|
|
289 #else |
|
|
290 __u32 st_uid; // user ID of owner |
|
|
291 __u32 st_gid; // group ID of owner |
|
|
292 __u32 st_atime; // time of last access |
|
|
293 __u32 st_mtime; // time of last modification |
|
|
294 __u32 st_ctime; // time of last change |
|
|
295 #endif |
|
|
296 |
|
|
297 // File size applies to files only |
|
|
298 int fileSize; |
|
|
299 |
|
|
300 // Equivalent object id applies to hard links only. |
|
|
301 int equivalentObjectId; |
|
|
302 |
|
|
303 // Alias is for symlinks only. |
|
|
304 YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; |
|
|
305 |
|
|
306 __u32 st_rdev; // device stuff for block and char devices (maj/min) |
|
|
307 |
|
|
308 #ifdef CONFIG_YAFFS_WINCE |
|
|
309 __u32 win_ctime[2]; |
|
|
310 __u32 win_atime[2]; |
|
|
311 __u32 win_mtime[2]; |
|
|
312 __u32 roomToGrow[5]; |
|
|
313 #else |
|
|
314 __u32 roomToGrow[11]; |
|
|
315 #endif |
|
|
316 |
|
|
317 // isShrink applies to bject headers written when we shrink the file (ie resize) |
|
|
318 __u32 isShrink; |
|
|
319 |
|
|
320 } yaffs_ObjectHeader; |
|
|
321 |
|
|
322 |
|
|
323 |
|
|
324 //////////////////// Tnode /////////////////////////// |
|
|
325 |
|
|
326 union yaffs_Tnode_union |
|
|
327 { |
|
|
328 #ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG |
|
|
329 union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL+1]; |
|
|
330 #else |
|
|
331 union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL]; |
|
|
332 #endif |
|
|
333 __u16 level0[YAFFS_NTNODES_LEVEL0]; |
|
|
334 |
|
|
335 }; |
|
|
336 |
|
|
337 typedef union yaffs_Tnode_union yaffs_Tnode; |
|
|
338 |
|
|
339 struct yaffs_TnodeList_struct |
|
|
340 { |
|
|
341 struct yaffs_TnodeList_struct *next; |
|
|
342 yaffs_Tnode *tnodes; |
|
|
343 }; |
|
|
344 |
|
|
345 typedef struct yaffs_TnodeList_struct yaffs_TnodeList; |
|
|
346 |
|
|
347 |
|
|
348 |
|
|
349 /////////////////// Object //////////////////////////////// |
|
|
350 // An object can be one of: |
|
|
351 // - a directory (no data, has children links |
|
|
352 // - a regular file (data.... not prunes :->). |
|
|
353 // - a symlink [symbolic link] (the alias). |
|
|
354 // - a hard link |
|
|
355 |
|
|
356 |
|
|
357 typedef struct |
|
|
358 { |
|
|
359 __u32 fileSize; |
|
|
360 __u32 scannedFileSize; |
|
15
|
361 __u32 shrinkSize; |
|
0
|
362 int topLevel; |
|
|
363 yaffs_Tnode *top; |
|
|
364 } yaffs_FileStructure; |
|
|
365 |
|
|
366 typedef struct |
|
|
367 { |
|
|
368 struct list_head children; // list of child links |
|
|
369 } yaffs_DirectoryStructure; |
|
|
370 |
|
|
371 typedef struct |
|
|
372 { |
|
|
373 YCHAR *alias; |
|
|
374 } yaffs_SymLinkStructure; |
|
|
375 |
|
|
376 typedef struct |
|
|
377 { |
|
|
378 struct yaffs_ObjectStruct *equivalentObject; |
|
|
379 __u32 equivalentObjectId; |
|
|
380 } yaffs_HardLinkStructure; |
|
|
381 |
|
|
382 typedef union |
|
|
383 { |
|
|
384 yaffs_FileStructure fileVariant; |
|
|
385 yaffs_DirectoryStructure directoryVariant; |
|
|
386 yaffs_SymLinkStructure symLinkVariant; |
|
|
387 yaffs_HardLinkStructure hardLinkVariant; |
|
|
388 } yaffs_ObjectVariant; |
|
|
389 |
|
|
390 |
|
|
391 struct yaffs_ObjectStruct |
|
|
392 { |
|
|
393 __u8 deleted: 1; // This should only apply to unlinked files. |
|
|
394 __u8 softDeleted: 1; // it has also been soft deleted |
|
|
395 __u8 unlinked: 1; // An unlinked file. The file should be in the unlinked pseudo directory. |
|
|
396 __u8 fake:1; // A fake object has no presence on NAND. |
|
15
|
397 __u8 renameAllowed:1; // Some objects are not allowed to be renamed. |
|
0
|
398 __u8 unlinkAllowed:1; |
|
|
399 __u8 dirty:1; // the object needs to be written to flash |
|
|
400 __u8 valid:1; // When the file system is being loaded up, this |
|
|
401 // object might be created before the data |
|
|
402 // is available (ie. file data records appear before the header). |
|
|
403 __u8 serial; // serial number of chunk in NAND. Store here so we don't have to |
|
4
|
404 |
|
|
405 __u8 deferedFree: 1; // For Linux kernel. Object is removed from NAND, but still in the inode cache. |
|
|
406 // Free of object is defered. |
|
15
|
407 |
|
|
408 __u8 lazyLoaded; // Vital info has been loaded from tags. Not all info available. |
|
|
409 // |
|
4
|
410 |
|
15
|
411 // read back the old one to update. |
|
|
412 __u16 sum; // sum of the name to speed searching |
|
0
|
413 |
|
|
414 struct yaffs_DeviceStruct *myDev; // The device I'm on |
|
|
415 |
|
|
416 |
|
|
417 struct list_head hashLink; // list of objects in this hash bucket |
|
|
418 |
|
|
419 |
|
|
420 struct list_head hardLinks; // all the equivalent hard linked objects |
|
|
421 // live on this list |
|
|
422 // directory structure stuff |
|
|
423 struct yaffs_ObjectStruct *parent; //my parent directory |
|
|
424 struct list_head siblings; // siblings in a directory |
|
|
425 // also used for linking up the free list |
|
|
426 |
|
20
|
427 // Where's my object header in NAND? |
|
0
|
428 int chunkId; // where it lives |
|
|
429 |
|
20
|
430 int nDataChunks; // Number of data chunks attached to the file. |
|
0
|
431 |
|
|
432 __u32 objectId; // the object id value |
|
|
433 |
|
|
434 |
|
|
435 __u32 st_mode; // protection |
|
|
436 |
|
|
437 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM |
|
|
438 YCHAR shortName[YAFFS_SHORT_NAME_LENGTH+1]; |
|
|
439 #endif |
|
|
440 |
|
|
441 #ifndef __KERNEL__ |
|
|
442 __u32 inUse; |
|
|
443 #endif |
|
|
444 |
|
|
445 #ifdef CONFIG_YAFFS_WINCE |
|
|
446 __u32 win_ctime[2]; |
|
|
447 __u32 win_mtime[2]; |
|
|
448 __u32 win_atime[2]; |
|
|
449 #else |
|
|
450 __u32 st_uid; // user ID of owner |
|
|
451 __u32 st_gid; // group ID of owner |
|
|
452 __u32 st_atime; // time of last access |
|
|
453 __u32 st_mtime; // time of last modification |
|
|
454 __u32 st_ctime; // time of last change |
|
|
455 #endif |
|
|
456 |
|
|
457 __u32 st_rdev; // device stuff for block and char devices |
|
|
458 |
|
|
459 |
|
|
460 |
|
|
461 #ifdef __KERNEL__ |
|
|
462 struct inode *myInode; |
|
4
|
463 |
|
0
|
464 #endif |
|
|
465 |
|
|
466 |
|
|
467 |
|
|
468 yaffs_ObjectType variantType; |
|
|
469 |
|
|
470 yaffs_ObjectVariant variant; |
|
|
471 |
|
|
472 }; |
|
|
473 |
|
|
474 |
|
|
475 |
|
|
476 typedef struct yaffs_ObjectStruct yaffs_Object; |
|
|
477 |
|
|
478 |
|
|
479 struct yaffs_ObjectList_struct |
|
|
480 { |
|
|
481 yaffs_Object *objects; |
|
|
482 struct yaffs_ObjectList_struct *next; |
|
|
483 }; |
|
|
484 |
|
|
485 typedef struct yaffs_ObjectList_struct yaffs_ObjectList; |
|
|
486 |
|
|
487 typedef struct |
|
|
488 { |
|
|
489 struct list_head list; |
|
|
490 int count; |
|
|
491 } yaffs_ObjectBucket; |
|
|
492 |
|
|
493 ///////////////////// Temporary buffers //////////////////// |
|
|
494 // |
|
|
495 // These are chunk-sized working buffers. Each device has a few |
|
|
496 |
|
|
497 typedef struct { |
|
|
498 __u8 *buffer; |
|
|
499 int line; // track from whence this buffer was allocated |
|
|
500 int maxLine; |
|
|
501 } yaffs_TempBuffer; |
|
|
502 |
|
|
503 //////////////////// Device //////////////////////////////// |
|
|
504 |
|
|
505 struct yaffs_DeviceStruct |
|
|
506 { |
|
|
507 // Entry parameters set up way early. Yaffs sets up the rest. |
|
|
508 int nBytesPerChunk; // Should be a power of 2 >= 512 |
|
|
509 int nChunksPerBlock; // does not need to be a power of 2 |
|
|
510 int nBytesPerSpare; // spare area size |
|
|
511 int startBlock; // Start block we're allowed to use |
|
|
512 int endBlock; // End block we're allowed to use |
|
|
513 int nReservedBlocks; // We want this tuneable so that we can reduce |
|
|
514 // reserved blocks on NOR and RAM. |
|
|
515 |
|
|
516 int nShortOpCaches; // If <= 0, then short op caching is disabled, else |
|
|
517 // the number of short op caches (don't use too many). |
|
|
518 |
|
|
519 int useHeaderFileSize; // Flag to determine if we should use file sizes from the header |
|
|
520 |
|
|
521 int useNANDECC; // Flag to decide whether or not to use NANDECC |
|
|
522 |
|
|
523 |
|
|
524 void *genericDevice; // Pointer to device context |
|
|
525 // On an mtd this holds the mtd pointer. |
|
|
526 |
|
|
527 // NAND access functions (Must be set before calling YAFFS) |
|
|
528 |
|
4
|
529 |
|
0
|
530 int (*writeChunkToNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, const yaffs_Spare *spare); |
|
|
531 int (*readChunkFromNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); |
|
4
|
532 int (*eraseBlockInNAND)(struct yaffs_DeviceStruct *dev,int blockInNAND); |
|
|
533 int (*initialiseNAND)(struct yaffs_DeviceStruct *dev); |
|
|
534 |
|
|
535 #ifdef CONFIG_YAFFS_YAFFS2 |
|
0
|
536 int (*writeChunkWithTagsToNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_ExtendedTags *tags); |
|
|
537 int (*readChunkWithTagsFromNAND)(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); |
|
|
538 int (*markNANDBlockBad)(struct yaffs_DeviceStruct *dev, int blockNo); |
|
|
539 int (*queryNANDBlock)(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber); |
|
|
540 #endif |
|
|
541 |
|
|
542 int isYaffs2; |
|
|
543 |
|
|
544 // End of stuff that must be set before initialisation. |
|
|
545 |
|
|
546 // Runtime parameters. Set up by YAFFS. |
|
|
547 |
|
|
548 __u16 chunkGroupBits; // 0 for devices <= 32MB. else log2(nchunks) - 16 |
|
|
549 __u16 chunkGroupSize; // == 2^^chunkGroupBits |
|
|
550 |
|
|
551 #ifdef __KERNEL__ |
|
|
552 |
|
|
553 struct semaphore sem;// Semaphore for waiting on erasure. |
|
|
554 struct semaphore grossLock; // Gross locking semaphore |
|
7
|
555 __u8 * spareBuffer; // For mtdif2 use. Don't know the size of the buffer at compile time so we have to allocate it. |
|
0
|
556 void (*putSuperFunc)(struct super_block *sb); |
|
|
557 #endif |
|
|
558 |
|
|
559 int isMounted; |
|
|
560 |
|
|
561 // Block Info |
|
|
562 yaffs_BlockInfo *blockInfo; |
|
|
563 __u8 *chunkBits; // bitmap of chunks in use |
|
|
564 int chunkBitmapStride; // Number of bytes of chunkBits per block. |
|
|
565 // Must be consistent with nChunksPerBlock. |
|
|
566 |
|
|
567 |
|
|
568 int nErasedBlocks; |
|
|
569 int allocationBlock; // Current block being allocated off |
|
|
570 __u32 allocationPage; |
|
|
571 int allocationBlockFinder; // Used to search for next allocation block |
|
|
572 |
|
|
573 // Runtime state |
|
|
574 int nTnodesCreated; |
|
|
575 yaffs_Tnode *freeTnodes; |
|
|
576 int nFreeTnodes; |
|
|
577 yaffs_TnodeList *allocatedTnodeList; |
|
|
578 |
|
|
579 |
|
|
580 int nObjectsCreated; |
|
|
581 yaffs_Object *freeObjects; |
|
|
582 int nFreeObjects; |
|
|
583 |
|
|
584 yaffs_ObjectList *allocatedObjectList; |
|
|
585 |
|
|
586 yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; |
|
|
587 |
|
|
588 int nFreeChunks; |
|
|
589 |
|
|
590 int currentDirtyChecker; // Used to find current dirtiest block |
|
|
591 |
|
|
592 __u32 *gcCleanupList; // objects to delete at the end of a GC. |
|
|
593 |
|
|
594 // Operations since mount |
|
|
595 int nPageWrites; |
|
|
596 int nPageReads; |
|
|
597 int nBlockErasures; |
|
|
598 int nErasureFailures; |
|
|
599 int nGCCopies; |
|
|
600 int garbageCollections; |
|
|
601 int passiveGarbageCollections; |
|
|
602 int nRetriedWrites; |
|
|
603 int nRetiredBlocks; |
|
|
604 int eccFixed; |
|
|
605 int eccUnfixed; |
|
|
606 int tagsEccFixed; |
|
|
607 int tagsEccUnfixed; |
|
|
608 int nDeletions; |
|
|
609 int nUnmarkedDeletions; |
|
|
610 |
|
|
611 yaffs_Object *rootDir; |
|
|
612 yaffs_Object *lostNFoundDir; |
|
|
613 |
|
|
614 // Buffer areas for storing data to recover from write failures |
|
|
615 // __u8 bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; |
|
|
616 // yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK]; |
|
|
617 int bufferedBlock; // Which block is buffered here? |
|
|
618 int doingBufferedBlockRewrite; |
|
|
619 |
|
|
620 yaffs_ChunkCache *srCache; |
|
|
621 int srLastUse; |
|
|
622 |
|
|
623 int cacheHits; |
|
|
624 |
|
|
625 // Stuff for background deletion and unlinked files. |
|
|
626 yaffs_Object *unlinkedDir; // Directory where unlinked and deleted files live. |
|
|
627 yaffs_Object *deletedDir; // Directory where deleted objects are sent to disappear. |
|
|
628 yaffs_Object *unlinkedDeletion; // Current file being background deleted. |
|
|
629 int nDeletedFiles; // Count of files awaiting deletion; |
|
|
630 int nUnlinkedFiles; // Count of unlinked files. |
|
|
631 int nBackgroundDeletions; // Count of background deletions. |
|
|
632 |
|
|
633 //__u8 *localBuffer; |
|
|
634 |
|
|
635 yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS]; |
|
|
636 int maxTemp; |
|
|
637 int unmanagedTempAllocations; |
|
|
638 int unmanagedTempDeallocations; |
|
|
639 |
|
|
640 // yaffs2 runtime stuff |
|
|
641 unsigned sequenceNumber; //Sequence number of currently allocating block |
|
|
642 unsigned oldestDirtySequence; |
|
|
643 |
|
|
644 }; |
|
|
645 |
|
|
646 typedef struct yaffs_DeviceStruct yaffs_Device; |
|
|
647 |
|
|
648 |
|
|
649 // Function to manipulate block info |
|
|
650 static Y_INLINE yaffs_BlockInfo* yaffs_GetBlockInfo(yaffs_Device *dev, int blk) |
|
|
651 { |
|
|
652 if(blk < dev->startBlock || blk > dev->endBlock) |
|
|
653 { |
|
|
654 T(YAFFS_TRACE_ERROR,(TSTR("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),blk)); |
|
|
655 YBUG(); |
|
|
656 } |
|
|
657 return &dev->blockInfo[blk - dev->startBlock]; |
|
|
658 } |
|
|
659 |
|
|
660 |
|
|
661 //////////// YAFFS Functions ////////////////// |
|
|
662 |
|
|
663 int yaffs_GutsInitialise(yaffs_Device *dev); |
|
|
664 void yaffs_Deinitialise(yaffs_Device *dev); |
|
|
665 |
|
|
666 int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev); |
|
|
667 |
|
|
668 |
|
|
669 // Rename |
|
|
670 int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, yaffs_Object *newDir, const YCHAR *newName); |
|
|
671 |
|
|
672 // generic Object functions |
|
|
673 int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name); |
|
|
674 int yaffs_DeleteFile(yaffs_Object *obj); |
|
|
675 |
|
|
676 // Object access functions. |
|
|
677 int yaffs_GetObjectName(yaffs_Object *obj,YCHAR *name,int buffSize); |
|
|
678 int yaffs_GetObjectFileLength(yaffs_Object *obj); |
|
|
679 int yaffs_GetObjectInode(yaffs_Object *obj); |
|
|
680 unsigned yaffs_GetObjectType(yaffs_Object *obj); |
|
|
681 int yaffs_GetObjectLinkCount(yaffs_Object *obj); |
|
|
682 |
|
|
683 // Change inode attributes |
|
|
684 int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr); |
|
|
685 int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr); |
|
|
686 |
|
|
687 // File operations |
|
|
688 int yaffs_ReadDataFromFile(yaffs_Object *obj, __u8 *buffer, __u32 offset, int nBytes); |
|
20
|
689 int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, __u32 offset, int nBytes, int writeThrough); |
|
0
|
690 int yaffs_ResizeFile(yaffs_Object *obj, int newSize); |
|
|
691 |
|
|
692 yaffs_Object *yaffs_MknodFile(yaffs_Object *parent,const YCHAR *name, __u32 mode, __u32 uid, __u32 gid); |
|
|
693 int yaffs_FlushFile(yaffs_Object *obj,int updateTime); |
|
|
694 |
|
|
695 |
|
|
696 // Directory operations |
|
|
697 yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent,const YCHAR *name, __u32 mode, __u32 uid, __u32 gid); |
|
|
698 yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir,const YCHAR *name); |
|
|
699 int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,int (*fn)(yaffs_Object *)); |
|
|
700 |
|
|
701 yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev,__u32 number); |
|
|
702 |
|
|
703 // Link operations |
|
|
704 yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, yaffs_Object *equivalentObject); |
|
|
705 |
|
|
706 yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj); |
|
|
707 |
|
|
708 // Symlink operations |
|
|
709 yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid, const YCHAR *alias); |
|
|
710 YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj); |
|
|
711 |
|
|
712 // Special inodes (fifos, sockets and devices) |
|
|
713 yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent,const YCHAR *name, __u32 mode, __u32 uid, __u32 gid,__u32 rdev); |
|
|
714 |
|
|
715 |
|
|
716 // Special directories |
|
|
717 yaffs_Object *yaffs_Root(yaffs_Device *dev); |
|
|
718 yaffs_Object *yaffs_LostNFound(yaffs_Device *dev); |
|
|
719 |
|
|
720 #ifdef CONFIG_YAFFS_WINCE |
|
|
721 // CONFIG_YAFFS_WINCE special stuff |
|
|
722 void yfsd_WinFileTimeNow(__u32 target[2]); |
|
|
723 #endif |
|
|
724 |
|
4
|
725 #ifdef __KERNEL__ |
|
|
726 |
|
|
727 void yaffs_HandleDeferedFree(yaffs_Object *obj); |
|
|
728 #endif |
|
|
729 |
|
|
730 |
|
|
731 |
|
0
|
732 |
|
|
733 // Debug dump |
|
|
734 int yaffs_DumpObject(yaffs_Object *obj); |
|
|
735 |
|
|
736 |
|
|
737 void yaffs_GutsTest(yaffs_Device *dev); |
|
|
738 |
|
|
739 |
|
|
740 void yaffs_InitialiseTags(yaffs_ExtendedTags *tags); |
|
|
741 void yaffs_DeleteChunk(yaffs_Device *dev,int chunkId,int markNAND,int lyn); |
|
|
742 int yaffs_CheckFF(__u8 *buffer,int nBytes); |
|
|
743 |
|
|
744 #endif |
|
|
745 |
