]>
Commit | Line | Data |
---|---|---|
0e8cc8bd | 1 | /* |
4b070809 | 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. |
0e8cc8bd | 3 | * |
753ac610 | 4 | * Copyright (C) 2002-2011 Aleph One Ltd. |
0e8cc8bd WJ |
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 | ||
0e8cc8bd WJ |
19 | #include "yportenv.h" |
20 | ||
21 | #define YAFFS_OK 1 | |
22 | #define YAFFS_FAIL 0 | |
23 | ||
4b070809 WD |
24 | /* Give us a Y=0x59, |
25 | * Give us an A=0x41, | |
753ac610 | 26 | * Give us an FF=0xff |
0e8cc8bd | 27 | * Give us an S=0x53 |
4b070809 | 28 | * And what have we got... |
0e8cc8bd | 29 | */ |
753ac610 | 30 | #define YAFFS_MAGIC 0x5941ff53 |
0e8cc8bd | 31 | |
753ac610 CM |
32 | /* |
33 | * Tnodes form a tree with the tnodes in "levels" | |
34 | * Levels greater than 0 hold 8 slots which point to other tnodes. | |
35 | * Those at level 0 hold 16 slots which point to chunks in NAND. | |
36 | * | |
37 | * A maximum level of 8 thust supports files of size up to: | |
38 | * | |
39 | * 2^(3*MAX_LEVEL+4) | |
40 | * | |
41 | * Thus a max level of 8 supports files with up to 2^^28 chunks which gives | |
42 | * a maximum file size of arounf 51Gbytees with 2k chunks. | |
43 | */ | |
44 | #define YAFFS_NTNODES_LEVEL0 16 | |
0e8cc8bd WJ |
45 | #define YAFFS_TNODES_LEVEL0_BITS 4 |
46 | #define YAFFS_TNODES_LEVEL0_MASK 0xf | |
47 | ||
753ac610 CM |
48 | #define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2) |
49 | #define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1) | |
0e8cc8bd | 50 | #define YAFFS_TNODES_INTERNAL_MASK 0x7 |
753ac610 CM |
51 | #define YAFFS_TNODES_MAX_LEVEL 8 |
52 | #define YAFFS_TNODES_MAX_BITS (YAFFS_TNODES_LEVEL0_BITS + \ | |
53 | YAFFS_TNODES_INTERNAL_BITS * \ | |
54 | YAFFS_TNODES_MAX_LEVEL) | |
55 | #define YAFFS_MAX_CHUNK_ID ((1 << YAFFS_TNODES_MAX_BITS) - 1) | |
0e8cc8bd | 56 | |
753ac610 | 57 | /* Constants for YAFFS1 mode */ |
0e8cc8bd WJ |
58 | #define YAFFS_BYTES_PER_SPARE 16 |
59 | #define YAFFS_BYTES_PER_CHUNK 512 | |
60 | #define YAFFS_CHUNK_SIZE_SHIFT 9 | |
61 | #define YAFFS_CHUNKS_PER_BLOCK 32 | |
753ac610 | 62 | #define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK) |
0e8cc8bd | 63 | |
753ac610 | 64 | #define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 |
0e8cc8bd WJ |
65 | #define YAFFS_MIN_YAFFS2_SPARE_SIZE 32 |
66 | ||
0e8cc8bd | 67 | |
0e8cc8bd WJ |
68 | |
69 | #define YAFFS_ALLOCATION_NOBJECTS 100 | |
70 | #define YAFFS_ALLOCATION_NTNODES 100 | |
71 | #define YAFFS_ALLOCATION_NLINKS 100 | |
72 | ||
73 | #define YAFFS_NOBJECT_BUCKETS 256 | |
74 | ||
0e8cc8bd | 75 | #define YAFFS_OBJECT_SPACE 0x40000 |
753ac610 | 76 | #define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE - 1) |
0e8cc8bd | 77 | |
753ac610 CM |
78 | /* Binary data version stamps */ |
79 | #define YAFFS_SUMMARY_VERSION 1 | |
80 | #define YAFFS_CHECKPOINT_VERSION 6 | |
0e8cc8bd WJ |
81 | |
82 | #ifdef CONFIG_YAFFS_UNICODE | |
83 | #define YAFFS_MAX_NAME_LENGTH 127 | |
84 | #define YAFFS_MAX_ALIAS_LENGTH 79 | |
85 | #else | |
86 | #define YAFFS_MAX_NAME_LENGTH 255 | |
87 | #define YAFFS_MAX_ALIAS_LENGTH 159 | |
88 | #endif | |
89 | ||
90 | #define YAFFS_SHORT_NAME_LENGTH 15 | |
91 | ||
92 | /* Some special object ids for pseudo objects */ | |
93 | #define YAFFS_OBJECTID_ROOT 1 | |
94 | #define YAFFS_OBJECTID_LOSTNFOUND 2 | |
95 | #define YAFFS_OBJECTID_UNLINKED 3 | |
96 | #define YAFFS_OBJECTID_DELETED 4 | |
97 | ||
753ac610 CM |
98 | /* Fake object Id for summary data */ |
99 | #define YAFFS_OBJECTID_SUMMARY 0x10 | |
0e8cc8bd | 100 | |
753ac610 CM |
101 | /* Pseudo object ids for checkpointing */ |
102 | #define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 | |
103 | #define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 | |
0e8cc8bd WJ |
104 | |
105 | #define YAFFS_MAX_SHORT_OP_CACHES 20 | |
106 | ||
753ac610 | 107 | #define YAFFS_N_TEMP_BUFFERS 6 |
0e8cc8bd WJ |
108 | |
109 | /* We limit the number attempts at sucessfully saving a chunk of data. | |
110 | * Small-page devices have 32 pages per block; large-page devices have 64. | |
111 | * Default to something in the order of 5 to 10 blocks worth of chunks. | |
112 | */ | |
113 | #define YAFFS_WR_ATTEMPTS (5*64) | |
114 | ||
115 | /* Sequence numbers are used in YAFFS2 to determine block allocation order. | |
116 | * The range is limited slightly to help distinguish bad numbers from good. | |
117 | * This also allows us to perhaps in the future use special numbers for | |
118 | * special purposes. | |
753ac610 | 119 | * EFFFFF00 allows the allocation of 8 blocks/second (~1Mbytes) for 15 years, |
0e8cc8bd WJ |
120 | * and is a larger number than the lifetime of a 2GB device. |
121 | */ | |
122 | #define YAFFS_LOWEST_SEQUENCE_NUMBER 0x00001000 | |
753ac610 CM |
123 | #define YAFFS_HIGHEST_SEQUENCE_NUMBER 0xefffff00 |
124 | ||
125 | /* Special sequence number for bad block that failed to be marked bad */ | |
126 | #define YAFFS_SEQUENCE_BAD_BLOCK 0xffff0000 | |
0e8cc8bd WJ |
127 | |
128 | /* ChunkCache is used for short read/write operations.*/ | |
753ac610 CM |
129 | struct yaffs_cache { |
130 | struct yaffs_obj *object; | |
131 | int chunk_id; | |
132 | int last_use; | |
0e8cc8bd | 133 | int dirty; |
753ac610 | 134 | int n_bytes; /* Only valid if the cache is dirty */ |
0e8cc8bd | 135 | int locked; /* Can't push out or flush while locked. */ |
753ac610 CM |
136 | u8 *data; |
137 | }; | |
0e8cc8bd | 138 | |
753ac610 CM |
139 | /* yaffs1 tags structures in RAM |
140 | * NB This uses bitfield. Bitfields should not straddle a u32 boundary | |
141 | * otherwise the structure size will get blown out. | |
0e8cc8bd WJ |
142 | */ |
143 | ||
753ac610 CM |
144 | struct yaffs_tags { |
145 | unsigned chunk_id:20; | |
146 | unsigned serial_number:2; | |
147 | unsigned n_bytes_lsb:10; | |
148 | unsigned obj_id:18; | |
0e8cc8bd | 149 | unsigned ecc:12; |
753ac610 CM |
150 | unsigned n_bytes_msb:2; |
151 | }; | |
0e8cc8bd | 152 | |
753ac610 CM |
153 | union yaffs_tags_union { |
154 | struct yaffs_tags as_tags; | |
155 | u8 as_bytes[8]; | |
156 | }; | |
0e8cc8bd | 157 | |
0e8cc8bd WJ |
158 | |
159 | /* Stuff used for extended tags in YAFFS2 */ | |
160 | ||
753ac610 | 161 | enum yaffs_ecc_result { |
0e8cc8bd WJ |
162 | YAFFS_ECC_RESULT_UNKNOWN, |
163 | YAFFS_ECC_RESULT_NO_ERROR, | |
164 | YAFFS_ECC_RESULT_FIXED, | |
165 | YAFFS_ECC_RESULT_UNFIXED | |
753ac610 | 166 | }; |
0e8cc8bd | 167 | |
753ac610 | 168 | enum yaffs_obj_type { |
0e8cc8bd WJ |
169 | YAFFS_OBJECT_TYPE_UNKNOWN, |
170 | YAFFS_OBJECT_TYPE_FILE, | |
171 | YAFFS_OBJECT_TYPE_SYMLINK, | |
172 | YAFFS_OBJECT_TYPE_DIRECTORY, | |
173 | YAFFS_OBJECT_TYPE_HARDLINK, | |
174 | YAFFS_OBJECT_TYPE_SPECIAL | |
753ac610 | 175 | }; |
0e8cc8bd WJ |
176 | |
177 | #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL | |
178 | ||
753ac610 CM |
179 | struct yaffs_ext_tags { |
180 | unsigned chunk_used; /* Status of the chunk: used or unused */ | |
181 | unsigned obj_id; /* If 0 this is not used */ | |
182 | unsigned chunk_id; /* If 0 this is a header, else a data chunk */ | |
183 | unsigned n_bytes; /* Only valid for data chunks */ | |
0e8cc8bd WJ |
184 | |
185 | /* The following stuff only has meaning when we read */ | |
753ac610 CM |
186 | enum yaffs_ecc_result ecc_result; |
187 | unsigned block_bad; | |
0e8cc8bd WJ |
188 | |
189 | /* YAFFS 1 stuff */ | |
753ac610 CM |
190 | unsigned is_deleted; /* The chunk is marked deleted */ |
191 | unsigned serial_number; /* Yaffs1 2-bit serial number */ | |
0e8cc8bd WJ |
192 | |
193 | /* YAFFS2 stuff */ | |
753ac610 | 194 | unsigned seq_number; /* The sequence number of this block */ |
0e8cc8bd WJ |
195 | |
196 | /* Extra info if this is an object header (YAFFS2 only) */ | |
197 | ||
753ac610 CM |
198 | unsigned extra_available; /* Extra info available if not zero */ |
199 | unsigned extra_parent_id; /* The parent object */ | |
200 | unsigned extra_is_shrink; /* Is it a shrink header? */ | |
201 | unsigned extra_shadows; /* Does this shadow another object? */ | |
0e8cc8bd | 202 | |
753ac610 | 203 | enum yaffs_obj_type extra_obj_type; /* What object type? */ |
0e8cc8bd | 204 | |
753ac610 CM |
205 | loff_t extra_file_size; /* Length if it is a file */ |
206 | unsigned extra_equiv_id; /* Equivalent object for a hard link */ | |
207 | }; | |
0e8cc8bd WJ |
208 | |
209 | /* Spare structure for YAFFS1 */ | |
753ac610 CM |
210 | struct yaffs_spare { |
211 | u8 tb0; | |
212 | u8 tb1; | |
213 | u8 tb2; | |
214 | u8 tb3; | |
215 | u8 page_status; /* set to 0 to delete the chunk */ | |
216 | u8 block_status; | |
217 | u8 tb4; | |
218 | u8 tb5; | |
219 | u8 ecc1[3]; | |
220 | u8 tb6; | |
221 | u8 tb7; | |
222 | u8 ecc2[3]; | |
223 | }; | |
0e8cc8bd WJ |
224 | |
225 | /*Special structure for passing through to mtd */ | |
753ac610 CM |
226 | struct yaffs_nand_spare { |
227 | struct yaffs_spare spare; | |
0e8cc8bd WJ |
228 | int eccres1; |
229 | int eccres2; | |
230 | }; | |
231 | ||
232 | /* Block data in RAM */ | |
233 | ||
753ac610 | 234 | enum yaffs_block_state { |
0e8cc8bd WJ |
235 | YAFFS_BLOCK_STATE_UNKNOWN = 0, |
236 | ||
237 | YAFFS_BLOCK_STATE_SCANNING, | |
753ac610 CM |
238 | /* Being scanned */ |
239 | ||
240 | YAFFS_BLOCK_STATE_NEEDS_SCAN, | |
241 | /* The block might have something on it (ie it is allocating or full, | |
242 | * perhaps empty) but it needs to be scanned to determine its true | |
243 | * state. | |
244 | * This state is only valid during scanning. | |
245 | * NB We tolerate empty because the pre-scanner might be incapable of | |
246 | * deciding | |
247 | * However, if this state is returned on a YAFFS2 device, | |
248 | * then we expect a sequence number | |
0e8cc8bd WJ |
249 | */ |
250 | ||
251 | YAFFS_BLOCK_STATE_EMPTY, | |
252 | /* This block is empty */ | |
253 | ||
254 | YAFFS_BLOCK_STATE_ALLOCATING, | |
4b070809 | 255 | /* This block is partially allocated. |
0e8cc8bd WJ |
256 | * At least one page holds valid data. |
257 | * This is the one currently being used for page | |
753ac610 CM |
258 | * allocation. Should never be more than one of these. |
259 | * If a block is only partially allocated at mount it is treated as | |
260 | * full. | |
0e8cc8bd WJ |
261 | */ |
262 | ||
4b070809 | 263 | YAFFS_BLOCK_STATE_FULL, |
0e8cc8bd | 264 | /* All the pages in this block have been allocated. |
753ac610 CM |
265 | * If a block was only partially allocated when mounted we treat |
266 | * it as fully allocated. | |
0e8cc8bd WJ |
267 | */ |
268 | ||
269 | YAFFS_BLOCK_STATE_DIRTY, | |
753ac610 | 270 | /* The block was full and now all chunks have been deleted. |
0e8cc8bd WJ |
271 | * Erase me, reuse me. |
272 | */ | |
273 | ||
4b070809 | 274 | YAFFS_BLOCK_STATE_CHECKPOINT, |
753ac610 | 275 | /* This block is assigned to holding checkpoint data. */ |
0e8cc8bd | 276 | |
4b070809 | 277 | YAFFS_BLOCK_STATE_COLLECTING, |
0e8cc8bd WJ |
278 | /* This block is being garbage collected */ |
279 | ||
4b070809 | 280 | YAFFS_BLOCK_STATE_DEAD |
753ac610 CM |
281 | /* This block has failed and is not in use */ |
282 | }; | |
0e8cc8bd WJ |
283 | |
284 | #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) | |
285 | ||
753ac610 CM |
286 | struct yaffs_block_info { |
287 | ||
288 | int soft_del_pages:10; /* number of soft deleted pages */ | |
289 | int pages_in_use:10; /* number of pages in use */ | |
290 | unsigned block_state:4; /* One of the above block states. */ | |
291 | /* NB use unsigned because enum is sometimes | |
292 | * an int */ | |
293 | u32 needs_retiring:1; /* Data has failed on this block, */ | |
294 | /*need to get valid data off and retire*/ | |
295 | u32 skip_erased_check:1;/* Skip the erased check on this block */ | |
296 | u32 gc_prioritise:1; /* An ECC check or blank check has failed. | |
297 | Block should be prioritised for GC */ | |
298 | u32 chunk_error_strikes:3; /* How many times we've had ecc etc | |
299 | failures on this block and tried to reuse it */ | |
300 | u32 has_summary:1; /* The block has a summary */ | |
301 | ||
302 | u32 has_shrink_hdr:1; /* This block has at least one shrink header */ | |
303 | u32 seq_number; /* block sequence number for yaffs2 */ | |
0e8cc8bd | 304 | |
753ac610 | 305 | }; |
0e8cc8bd WJ |
306 | |
307 | /* -------------------------- Object structure -------------------------------*/ | |
308 | /* This is the object structure as stored on NAND */ | |
309 | ||
753ac610 CM |
310 | struct yaffs_obj_hdr { |
311 | enum yaffs_obj_type type; | |
0e8cc8bd WJ |
312 | |
313 | /* Apply to everything */ | |
753ac610 CM |
314 | int parent_obj_id; |
315 | u16 sum_no_longer_used; /* checksum of name. No longer used */ | |
0e8cc8bd WJ |
316 | YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; |
317 | ||
753ac610 CM |
318 | /* The following apply to all object types except for hard links */ |
319 | u32 yst_mode; /* protection */ | |
0e8cc8bd | 320 | |
753ac610 CM |
321 | u32 yst_uid; |
322 | u32 yst_gid; | |
323 | u32 yst_atime; | |
324 | u32 yst_mtime; | |
325 | u32 yst_ctime; | |
0e8cc8bd WJ |
326 | |
327 | /* File size applies to files only */ | |
753ac610 | 328 | u32 file_size_low; |
0e8cc8bd WJ |
329 | |
330 | /* Equivalent object id applies to hard links only. */ | |
753ac610 | 331 | int equiv_id; |
0e8cc8bd WJ |
332 | |
333 | /* Alias is for symlinks only. */ | |
334 | YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; | |
335 | ||
753ac610 | 336 | u32 yst_rdev; /* stuff for block and char devices (major/min) */ |
0e8cc8bd | 337 | |
753ac610 CM |
338 | u32 win_ctime[2]; |
339 | u32 win_atime[2]; | |
340 | u32 win_mtime[2]; | |
0e8cc8bd | 341 | |
753ac610 CM |
342 | u32 inband_shadowed_obj_id; |
343 | u32 inband_is_shrink; | |
0e8cc8bd | 344 | |
753ac610 CM |
345 | u32 file_size_high; |
346 | u32 reserved[1]; | |
347 | int shadows_obj; /* This object header shadows the | |
348 | specified object if > 0 */ | |
0e8cc8bd | 349 | |
753ac610 CM |
350 | /* is_shrink applies to object headers written when wemake a hole. */ |
351 | u32 is_shrink; | |
0e8cc8bd WJ |
352 | |
353 | }; | |
354 | ||
753ac610 | 355 | /*--------------------------- Tnode -------------------------- */ |
0e8cc8bd | 356 | |
753ac610 CM |
357 | struct yaffs_tnode { |
358 | struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL]; | |
0e8cc8bd WJ |
359 | }; |
360 | ||
0e8cc8bd WJ |
361 | /*------------------------ Object -----------------------------*/ |
362 | /* An object can be one of: | |
363 | * - a directory (no data, has children links | |
364 | * - a regular file (data.... not prunes :->). | |
365 | * - a symlink [symbolic link] (the alias). | |
366 | * - a hard link | |
367 | */ | |
368 | ||
753ac610 CM |
369 | struct yaffs_file_var { |
370 | loff_t file_size; | |
371 | loff_t scanned_size; | |
372 | loff_t shrink_size; | |
373 | int top_level; | |
374 | struct yaffs_tnode *top; | |
375 | }; | |
0e8cc8bd | 376 | |
753ac610 | 377 | struct yaffs_dir_var { |
0e8cc8bd | 378 | struct list_head children; /* list of child links */ |
753ac610 CM |
379 | struct list_head dirty; /* Entry for list of dirty directories */ |
380 | }; | |
0e8cc8bd | 381 | |
753ac610 | 382 | struct yaffs_symlink_var { |
0e8cc8bd | 383 | YCHAR *alias; |
753ac610 CM |
384 | }; |
385 | ||
386 | struct yaffs_hardlink_var { | |
387 | struct yaffs_obj *equiv_obj; | |
388 | u32 equiv_id; | |
389 | }; | |
390 | ||
391 | union yaffs_obj_var { | |
392 | struct yaffs_file_var file_variant; | |
393 | struct yaffs_dir_var dir_variant; | |
394 | struct yaffs_symlink_var symlink_variant; | |
395 | struct yaffs_hardlink_var hardlink_variant; | |
396 | }; | |
397 | ||
398 | struct yaffs_obj { | |
399 | u8 deleted:1; /* This should only apply to unlinked files. */ | |
400 | u8 soft_del:1; /* it has also been soft deleted */ | |
401 | u8 unlinked:1; /* An unlinked file.*/ | |
402 | u8 fake:1; /* A fake object has no presence on NAND. */ | |
403 | u8 rename_allowed:1; /* Some objects cannot be renamed. */ | |
404 | u8 unlink_allowed:1; | |
405 | u8 dirty:1; /* the object needs to be written to flash */ | |
406 | u8 valid:1; /* When the file system is being loaded up, this | |
0e8cc8bd | 407 | * object might be created before the data |
753ac610 CM |
408 | * is available |
409 | * ie. file data chunks encountered before | |
410 | * the header. | |
0e8cc8bd | 411 | */ |
753ac610 CM |
412 | u8 lazy_loaded:1; /* This object has been lazy loaded and |
413 | * is missing some detail */ | |
0e8cc8bd | 414 | |
753ac610 CM |
415 | u8 defered_free:1; /* Object is removed from NAND, but is |
416 | * still in the inode cache. | |
417 | * Free of object is defered. | |
0e8cc8bd WJ |
418 | * until the inode is released. |
419 | */ | |
753ac610 CM |
420 | u8 being_created:1; /* This object is still being created |
421 | * so skip some verification checks. */ | |
422 | u8 is_shadowed:1; /* This object is shadowed on the way | |
423 | * to being renamed. */ | |
0e8cc8bd | 424 | |
753ac610 CM |
425 | u8 xattr_known:1; /* We know if this has object has xattribs |
426 | * or not. */ | |
427 | u8 has_xattr:1; /* This object has xattribs. | |
428 | * Only valid if xattr_known. */ | |
0e8cc8bd | 429 | |
753ac610 CM |
430 | u8 serial; /* serial number of chunk in NAND.*/ |
431 | u16 sum; /* sum of the name to speed searching */ | |
0e8cc8bd | 432 | |
753ac610 | 433 | struct yaffs_dev *my_dev; /* The device I'm on */ |
0e8cc8bd | 434 | |
753ac610 CM |
435 | struct list_head hash_link; /* list of objects in hash bucket */ |
436 | ||
437 | struct list_head hard_links; /* hard linked object chain*/ | |
0e8cc8bd WJ |
438 | |
439 | /* directory structure stuff */ | |
440 | /* also used for linking up the free list */ | |
753ac610 | 441 | struct yaffs_obj *parent; |
0e8cc8bd WJ |
442 | struct list_head siblings; |
443 | ||
444 | /* Where's my object header in NAND? */ | |
753ac610 | 445 | int hdr_chunk; |
0e8cc8bd | 446 | |
753ac610 | 447 | int n_data_chunks; /* Number of data chunks for this file. */ |
0e8cc8bd | 448 | |
753ac610 | 449 | u32 obj_id; /* the object id value */ |
0e8cc8bd | 450 | |
753ac610 | 451 | u32 yst_mode; |
0e8cc8bd | 452 | |
753ac610 | 453 | YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; |
0e8cc8bd WJ |
454 | |
455 | #ifdef CONFIG_YAFFS_WINCE | |
753ac610 CM |
456 | u32 win_ctime[2]; |
457 | u32 win_mtime[2]; | |
458 | u32 win_atime[2]; | |
0e8cc8bd | 459 | #else |
753ac610 CM |
460 | u32 yst_uid; |
461 | u32 yst_gid; | |
462 | u32 yst_atime; | |
463 | u32 yst_mtime; | |
464 | u32 yst_ctime; | |
0e8cc8bd WJ |
465 | #endif |
466 | ||
753ac610 | 467 | u32 yst_rdev; |
0e8cc8bd | 468 | |
753ac610 | 469 | void *my_inode; |
0e8cc8bd | 470 | |
753ac610 | 471 | enum yaffs_obj_type variant_type; |
0e8cc8bd | 472 | |
753ac610 | 473 | union yaffs_obj_var variant; |
0e8cc8bd WJ |
474 | |
475 | }; | |
476 | ||
753ac610 | 477 | struct yaffs_obj_bucket { |
0e8cc8bd WJ |
478 | struct list_head list; |
479 | int count; | |
753ac610 | 480 | }; |
0e8cc8bd | 481 | |
753ac610 | 482 | /* yaffs_checkpt_obj holds the definition of an object as dumped |
0e8cc8bd WJ |
483 | * by checkpointing. |
484 | */ | |
485 | ||
753ac610 CM |
486 | struct yaffs_checkpt_obj { |
487 | int struct_type; | |
488 | u32 obj_id; | |
489 | u32 parent_id; | |
490 | int hdr_chunk; | |
491 | enum yaffs_obj_type variant_type:3; | |
492 | u8 deleted:1; | |
493 | u8 soft_del:1; | |
494 | u8 unlinked:1; | |
495 | u8 fake:1; | |
496 | u8 rename_allowed:1; | |
497 | u8 unlink_allowed:1; | |
498 | u8 serial; | |
499 | int n_data_chunks; | |
500 | loff_t size_or_equiv_obj; | |
501 | }; | |
0e8cc8bd WJ |
502 | |
503 | /*--------------------- Temporary buffers ---------------- | |
504 | * | |
753ac610 | 505 | * These are chunk-sized working buffers. Each device has a few. |
0e8cc8bd WJ |
506 | */ |
507 | ||
753ac610 CM |
508 | struct yaffs_buffer { |
509 | u8 *buffer; | |
510 | int in_use; | |
511 | }; | |
0e8cc8bd WJ |
512 | |
513 | /*----------------- Device ---------------------------------*/ | |
514 | ||
753ac610 CM |
515 | struct yaffs_param { |
516 | const YCHAR *name; | |
0e8cc8bd | 517 | |
753ac610 CM |
518 | /* |
519 | * Entry parameters set up way early. Yaffs sets up the rest. | |
520 | * The structure should be zeroed out before use so that unused | |
521 | * and defualt values are zero. | |
522 | */ | |
0e8cc8bd | 523 | |
753ac610 CM |
524 | int inband_tags; /* Use unband tags */ |
525 | u32 total_bytes_per_chunk; /* Should be >= 512, does not need to | |
526 | be a power of 2 */ | |
527 | int chunks_per_block; /* does not need to be a power of 2 */ | |
528 | int spare_bytes_per_chunk; /* spare area size */ | |
529 | int start_block; /* Start block we're allowed to use */ | |
530 | int end_block; /* End block we're allowed to use */ | |
531 | int n_reserved_blocks; /* Tuneable so that we can reduce | |
532 | * reserved blocks on NOR and RAM. */ | |
533 | ||
534 | int n_caches; /* If <= 0, then short op caching is disabled, | |
535 | * else the number of short op caches. | |
0e8cc8bd | 536 | */ |
753ac610 CM |
537 | int use_nand_ecc; /* Flag to decide whether or not to use |
538 | * NAND driver ECC on data (yaffs1) */ | |
539 | int tags_9bytes; /* Use 9 byte tags */ | |
540 | int no_tags_ecc; /* Flag to decide whether or not to do ECC | |
541 | * on packed tags (yaffs2) */ | |
0e8cc8bd | 542 | |
753ac610 | 543 | int is_yaffs2; /* Use yaffs2 mode on this device */ |
0e8cc8bd | 544 | |
753ac610 | 545 | int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ |
0e8cc8bd | 546 | |
753ac610 | 547 | int refresh_period; /* How often to check for a block refresh */ |
4b070809 | 548 | |
753ac610 CM |
549 | /* Checkpoint control. Can be set before or after initialisation */ |
550 | u8 skip_checkpt_rd; | |
551 | u8 skip_checkpt_wr; | |
552 | ||
553 | int enable_xattr; /* Enable xattribs */ | |
554 | ||
555 | /* NAND access functions (Must be set before calling YAFFS) */ | |
556 | ||
557 | int (*write_chunk_fn) (struct yaffs_dev *dev, | |
558 | int nand_chunk, const u8 *data, | |
559 | const struct yaffs_spare *spare); | |
560 | int (*read_chunk_fn) (struct yaffs_dev *dev, | |
561 | int nand_chunk, u8 *data, | |
562 | struct yaffs_spare *spare); | |
563 | int (*erase_fn) (struct yaffs_dev *dev, int flash_block); | |
564 | int (*initialise_flash_fn) (struct yaffs_dev *dev); | |
565 | int (*deinitialise_flash_fn) (struct yaffs_dev *dev); | |
566 | ||
567 | /* yaffs2 mode functions */ | |
568 | int (*write_chunk_tags_fn) (struct yaffs_dev *dev, | |
569 | int nand_chunk, const u8 *data, | |
570 | const struct yaffs_ext_tags *tags); | |
571 | int (*read_chunk_tags_fn) (struct yaffs_dev *dev, | |
572 | int nand_chunk, u8 *data, | |
573 | struct yaffs_ext_tags *tags); | |
574 | int (*bad_block_fn) (struct yaffs_dev *dev, int block_no); | |
575 | int (*query_block_fn) (struct yaffs_dev *dev, int block_no, | |
576 | enum yaffs_block_state *state, | |
577 | u32 *seq_number); | |
578 | ||
579 | /* The remove_obj_fn function must be supplied by OS flavours that | |
580 | * need it. | |
581 | * yaffs direct uses it to implement the faster readdir. | |
582 | * Linux uses it to protect the directory during unlocking. | |
0e8cc8bd | 583 | */ |
753ac610 | 584 | void (*remove_obj_fn) (struct yaffs_obj *obj); |
4b070809 | 585 | |
753ac610 CM |
586 | /* Callback to mark the superblock dirty */ |
587 | void (*sb_dirty_fn) (struct yaffs_dev *dev); | |
4b070809 | 588 | |
753ac610 CM |
589 | /* Callback to control garbage collection. */ |
590 | unsigned (*gc_control) (struct yaffs_dev *dev); | |
4b070809 | 591 | |
753ac610 CM |
592 | /* Debug control flags. Don't use unless you know what you're doing */ |
593 | int use_header_file_size; /* Flag to determine if we should use | |
594 | * file sizes from the header */ | |
595 | int disable_lazy_load; /* Disable lazy loading on this device */ | |
596 | int wide_tnodes_disabled; /* Set to disable wide tnodes */ | |
597 | int disable_soft_del; /* yaffs 1 only: Set to disable the use of | |
598 | * softdeletion. */ | |
0e8cc8bd | 599 | |
753ac610 | 600 | int defered_dir_update; /* Set to defer directory updates */ |
4b070809 | 601 | |
753ac610 CM |
602 | #ifdef CONFIG_YAFFS_AUTO_UNICODE |
603 | int auto_unicode; | |
604 | #endif | |
605 | int always_check_erased; /* Force chunk erased check always on */ | |
0e8cc8bd | 606 | |
753ac610 | 607 | int disable_summary; |
0e8cc8bd | 608 | |
753ac610 CM |
609 | int max_objects; /* |
610 | * Set to limit the number of objects created. | |
611 | * 0 = no limit. | |
612 | */ | |
613 | }; | |
4b070809 | 614 | |
753ac610 CM |
615 | struct yaffs_dev { |
616 | struct yaffs_param param; | |
4b070809 | 617 | |
753ac610 | 618 | /* Context storage. Holds extra OS specific data for this device */ |
4b070809 | 619 | |
753ac610 CM |
620 | void *os_context; |
621 | void *driver_context; | |
4b070809 | 622 | |
753ac610 | 623 | struct list_head dev_list; |
0e8cc8bd | 624 | |
753ac610 CM |
625 | /* Runtime parameters. Set up by YAFFS. */ |
626 | int data_bytes_per_chunk; | |
0e8cc8bd | 627 | |
753ac610 CM |
628 | /* Non-wide tnode stuff */ |
629 | u16 chunk_grp_bits; /* Number of bits that need to be resolved if | |
630 | * the tnodes are not wide enough. | |
0e8cc8bd | 631 | */ |
753ac610 | 632 | u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ |
0e8cc8bd | 633 | |
753ac610 CM |
634 | /* Stuff to support wide tnodes */ |
635 | u32 tnode_width; | |
636 | u32 tnode_mask; | |
637 | u32 tnode_size; | |
4b070809 | 638 | |
753ac610 CM |
639 | /* Stuff for figuring out file offset to chunk conversions */ |
640 | u32 chunk_shift; /* Shift value */ | |
641 | u32 chunk_div; /* Divisor after shifting: 1 for 2^n sizes */ | |
642 | u32 chunk_mask; /* Mask to use for power-of-2 case */ | |
0e8cc8bd | 643 | |
753ac610 CM |
644 | int is_mounted; |
645 | int read_only; | |
646 | int is_checkpointed; | |
0e8cc8bd WJ |
647 | |
648 | /* Stuff to support block offsetting to support start block zero */ | |
753ac610 CM |
649 | int internal_start_block; |
650 | int internal_end_block; | |
651 | int block_offset; | |
652 | int chunk_offset; | |
0e8cc8bd WJ |
653 | |
654 | /* Runtime checkpointing stuff */ | |
753ac610 CM |
655 | int checkpt_page_seq; /* running sequence number of checkpt pages */ |
656 | int checkpt_byte_count; | |
657 | int checkpt_byte_offs; | |
658 | u8 *checkpt_buffer; | |
659 | int checkpt_open_write; | |
660 | int blocks_in_checkpt; | |
661 | int checkpt_cur_chunk; | |
662 | int checkpt_cur_block; | |
663 | int checkpt_next_block; | |
664 | int *checkpt_block_list; | |
665 | int checkpt_max_blocks; | |
666 | u32 checkpt_sum; | |
667 | u32 checkpt_xor; | |
668 | ||
669 | int checkpoint_blocks_required; /* Number of blocks needed to store | |
670 | * current checkpoint set */ | |
4b070809 | 671 | |
0e8cc8bd | 672 | /* Block Info */ |
753ac610 CM |
673 | struct yaffs_block_info *block_info; |
674 | u8 *chunk_bits; /* bitmap of chunks in use */ | |
675 | unsigned block_info_alt:1; /* allocated using alternative alloc */ | |
676 | unsigned chunk_bits_alt:1; /* allocated using alternative alloc */ | |
677 | int chunk_bit_stride; /* Number of bytes of chunk_bits per block. | |
678 | * Must be consistent with chunks_per_block. | |
0e8cc8bd WJ |
679 | */ |
680 | ||
753ac610 CM |
681 | int n_erased_blocks; |
682 | int alloc_block; /* Current block being allocated off */ | |
683 | u32 alloc_page; | |
684 | int alloc_block_finder; /* Used to search for next allocation block */ | |
0e8cc8bd | 685 | |
753ac610 CM |
686 | /* Object and Tnode memory management */ |
687 | void *allocator; | |
688 | int n_obj; | |
689 | int n_tnodes; | |
0e8cc8bd | 690 | |
753ac610 | 691 | int n_hardlinks; |
0e8cc8bd | 692 | |
753ac610 CM |
693 | struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; |
694 | u32 bucket_finder; | |
0e8cc8bd | 695 | |
753ac610 | 696 | int n_free_chunks; |
0e8cc8bd | 697 | |
753ac610 CM |
698 | /* Garbage collection control */ |
699 | u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ | |
700 | u32 n_clean_ups; | |
0e8cc8bd | 701 | |
753ac610 CM |
702 | unsigned has_pending_prioritised_gc; /* We think this device might |
703 | have pending prioritised gcs */ | |
704 | unsigned gc_disable; | |
705 | unsigned gc_block_finder; | |
706 | unsigned gc_dirtiest; | |
707 | unsigned gc_pages_in_use; | |
708 | unsigned gc_not_done; | |
709 | unsigned gc_block; | |
710 | unsigned gc_chunk; | |
711 | unsigned gc_skip; | |
712 | struct yaffs_summary_tags *gc_sum_tags; | |
0e8cc8bd WJ |
713 | |
714 | /* Special directories */ | |
753ac610 CM |
715 | struct yaffs_obj *root_dir; |
716 | struct yaffs_obj *lost_n_found; | |
717 | ||
718 | int buffered_block; /* Which block is buffered here? */ | |
719 | int doing_buffered_block_rewrite; | |
720 | ||
721 | struct yaffs_cache *cache; | |
722 | int cache_last_use; | |
723 | ||
724 | /* Stuff for background deletion and unlinked files. */ | |
725 | struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted | |
726 | files live. */ | |
727 | struct yaffs_obj *del_dir; /* Directory where deleted objects are | |
728 | sent to disappear. */ | |
729 | struct yaffs_obj *unlinked_deletion; /* Current file being | |
730 | background deleted. */ | |
731 | int n_deleted_files; /* Count of files awaiting deletion; */ | |
732 | int n_unlinked_files; /* Count of unlinked files. */ | |
733 | int n_bg_deletions; /* Count of background deletions. */ | |
734 | ||
735 | /* Temporary buffer management */ | |
736 | struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS]; | |
737 | int max_temp; | |
738 | int temp_in_use; | |
739 | int unmanaged_buffer_allocs; | |
740 | int unmanaged_buffer_deallocs; | |
0e8cc8bd | 741 | |
753ac610 CM |
742 | /* yaffs2 runtime stuff */ |
743 | unsigned seq_number; /* Sequence number of currently | |
744 | allocating block */ | |
745 | unsigned oldest_dirty_seq; | |
746 | unsigned oldest_dirty_block; | |
747 | ||
748 | /* Block refreshing */ | |
749 | int refresh_skip; /* A skip down counter. | |
750 | * Refresh happens when this gets to zero. */ | |
751 | ||
752 | /* Dirty directory handling */ | |
753 | struct list_head dirty_dirs; /* List of dirty directories */ | |
754 | ||
755 | /* Summary */ | |
756 | int chunks_per_summary; | |
757 | struct yaffs_summary_tags *sum_tags; | |
758 | ||
759 | /* Statistics */ | |
760 | u32 n_page_writes; | |
761 | u32 n_page_reads; | |
762 | u32 n_erasures; | |
763 | u32 n_erase_failures; | |
764 | u32 n_gc_copies; | |
765 | u32 all_gcs; | |
766 | u32 passive_gc_count; | |
767 | u32 oldest_dirty_gc_count; | |
768 | u32 n_gc_blocks; | |
769 | u32 bg_gcs; | |
770 | u32 n_retried_writes; | |
771 | u32 n_retired_blocks; | |
772 | u32 n_ecc_fixed; | |
773 | u32 n_ecc_unfixed; | |
774 | u32 n_tags_ecc_fixed; | |
775 | u32 n_tags_ecc_unfixed; | |
776 | u32 n_deletions; | |
777 | u32 n_unmarked_deletions; | |
778 | u32 refresh_count; | |
779 | u32 cache_hits; | |
780 | u32 tags_used; | |
781 | u32 summary_used; | |
0e8cc8bd | 782 | |
753ac610 | 783 | }; |
0e8cc8bd | 784 | |
753ac610 CM |
785 | /* The CheckpointDevice structure holds the device information that changes |
786 | *at runtime and must be preserved over unmount/mount cycles. | |
787 | */ | |
788 | struct yaffs_checkpt_dev { | |
789 | int struct_type; | |
790 | int n_erased_blocks; | |
791 | int alloc_block; /* Current block being allocated off */ | |
792 | u32 alloc_page; | |
793 | int n_free_chunks; | |
0e8cc8bd | 794 | |
753ac610 CM |
795 | int n_deleted_files; /* Count of files awaiting deletion; */ |
796 | int n_unlinked_files; /* Count of unlinked files. */ | |
797 | int n_bg_deletions; /* Count of background deletions. */ | |
0e8cc8bd WJ |
798 | |
799 | /* yaffs2 runtime stuff */ | |
753ac610 CM |
800 | unsigned seq_number; /* Sequence number of currently |
801 | * allocating block */ | |
0e8cc8bd WJ |
802 | |
803 | }; | |
804 | ||
753ac610 CM |
805 | struct yaffs_checkpt_validity { |
806 | int struct_type; | |
807 | u32 magic; | |
808 | u32 version; | |
809 | u32 head; | |
810 | }; | |
0e8cc8bd | 811 | |
753ac610 CM |
812 | struct yaffs_shadow_fixer { |
813 | int obj_id; | |
814 | int shadowed_id; | |
815 | struct yaffs_shadow_fixer *next; | |
816 | }; | |
0e8cc8bd | 817 | |
753ac610 CM |
818 | /* Structure for doing xattr modifications */ |
819 | struct yaffs_xattr_mod { | |
820 | int set; /* If 0 then this is a deletion */ | |
821 | const YCHAR *name; | |
822 | const void *data; | |
823 | int size; | |
824 | int flags; | |
825 | int result; | |
826 | }; | |
0e8cc8bd WJ |
827 | |
828 | /*----------------------- YAFFS Functions -----------------------*/ | |
829 | ||
753ac610 CM |
830 | int yaffs_guts_initialise(struct yaffs_dev *dev); |
831 | void yaffs_deinitialise(struct yaffs_dev *dev); | |
0e8cc8bd | 832 | |
753ac610 | 833 | int yaffs_get_n_free_chunks(struct yaffs_dev *dev); |
0e8cc8bd | 834 | |
753ac610 CM |
835 | int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, |
836 | struct yaffs_obj *new_dir, const YCHAR * new_name); | |
0e8cc8bd | 837 | |
753ac610 CM |
838 | int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); |
839 | int yaffs_del_obj(struct yaffs_obj *obj); | |
0e8cc8bd | 840 | |
753ac610 CM |
841 | int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); |
842 | loff_t yaffs_get_obj_length(struct yaffs_obj *obj); | |
843 | int yaffs_get_obj_inode(struct yaffs_obj *obj); | |
844 | unsigned yaffs_get_obj_type(struct yaffs_obj *obj); | |
845 | int yaffs_get_obj_link_count(struct yaffs_obj *obj); | |
0e8cc8bd WJ |
846 | |
847 | /* File operations */ | |
753ac610 CM |
848 | int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, |
849 | int n_bytes); | |
850 | int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, | |
851 | int n_bytes, int write_trhrough); | |
852 | int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); | |
853 | ||
854 | struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, | |
855 | const YCHAR *name, u32 mode, u32 uid, | |
856 | u32 gid); | |
0e8cc8bd | 857 | |
753ac610 | 858 | int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync); |
0e8cc8bd WJ |
859 | |
860 | /* Flushing and checkpointing */ | |
753ac610 | 861 | void yaffs_flush_whole_cache(struct yaffs_dev *dev); |
0e8cc8bd | 862 | |
753ac610 CM |
863 | int yaffs_checkpoint_save(struct yaffs_dev *dev); |
864 | int yaffs_checkpoint_restore(struct yaffs_dev *dev); | |
0e8cc8bd WJ |
865 | |
866 | /* Directory operations */ | |
753ac610 CM |
867 | struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, |
868 | u32 mode, u32 uid, u32 gid); | |
869 | struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, | |
870 | const YCHAR *name); | |
871 | struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); | |
0e8cc8bd WJ |
872 | |
873 | /* Link operations */ | |
753ac610 CM |
874 | struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, |
875 | struct yaffs_obj *equiv_obj); | |
0e8cc8bd | 876 | |
753ac610 | 877 | struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); |
0e8cc8bd WJ |
878 | |
879 | /* Symlink operations */ | |
753ac610 CM |
880 | struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, |
881 | const YCHAR *name, u32 mode, u32 uid, | |
882 | u32 gid, const YCHAR *alias); | |
883 | YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); | |
0e8cc8bd WJ |
884 | |
885 | /* Special inodes (fifos, sockets and devices) */ | |
753ac610 CM |
886 | struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, |
887 | const YCHAR *name, u32 mode, u32 uid, | |
888 | u32 gid, u32 rdev); | |
889 | ||
890 | int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, | |
891 | const void *value, int size, int flags); | |
892 | int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, | |
893 | int size); | |
894 | int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); | |
895 | int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name); | |
0e8cc8bd WJ |
896 | |
897 | /* Special directories */ | |
753ac610 CM |
898 | struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); |
899 | struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev); | |
0e8cc8bd | 900 | |
753ac610 | 901 | void yaffs_handle_defered_free(struct yaffs_obj *obj); |
0e8cc8bd | 902 | |
753ac610 | 903 | void yaffs_update_dirty_dirs(struct yaffs_dev *dev); |
0e8cc8bd | 904 | |
753ac610 | 905 | int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency); |
0e8cc8bd | 906 | |
753ac610 CM |
907 | /* Debug dump */ |
908 | int yaffs_dump_obj(struct yaffs_obj *obj); | |
909 | ||
910 | void yaffs_guts_test(struct yaffs_dev *dev); | |
911 | ||
912 | /* A few useful functions to be used within the core files*/ | |
913 | void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, | |
914 | int lyn); | |
915 | int yaffs_check_ff(u8 *buffer, int n_bytes); | |
916 | void yaffs_handle_chunk_error(struct yaffs_dev *dev, | |
917 | struct yaffs_block_info *bi); | |
918 | ||
919 | u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev); | |
920 | void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer); | |
921 | ||
922 | struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, | |
923 | int number, | |
924 | enum yaffs_obj_type type); | |
925 | int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, | |
926 | int nand_chunk, int in_scan); | |
927 | void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name); | |
928 | void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, | |
929 | const struct yaffs_obj_hdr *oh); | |
930 | void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); | |
931 | YCHAR *yaffs_clone_str(const YCHAR *str); | |
932 | void yaffs_link_fixup(struct yaffs_dev *dev, struct list_head *hard_list); | |
933 | void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); | |
934 | int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, | |
935 | int force, int is_shrink, int shadows, | |
936 | struct yaffs_xattr_mod *xop); | |
937 | void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, | |
938 | int backward_scanning); | |
939 | int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); | |
940 | struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); | |
941 | struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, | |
942 | struct yaffs_file_var *file_struct, | |
943 | u32 chunk_id, | |
944 | struct yaffs_tnode *passed_tn); | |
945 | ||
946 | int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, | |
947 | int n_bytes, int write_trhrough); | |
948 | void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); | |
949 | void yaffs_skip_rest_of_block(struct yaffs_dev *dev); | |
950 | ||
951 | int yaffs_count_free_chunks(struct yaffs_dev *dev); | |
952 | ||
953 | struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, | |
954 | struct yaffs_file_var *file_struct, | |
955 | u32 chunk_id); | |
956 | ||
957 | u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, | |
958 | unsigned pos); | |
959 | ||
960 | int yaffs_is_non_empty_dir(struct yaffs_obj *obj); | |
961 | ||
962 | void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, | |
963 | int *chunk_out, u32 *offset_out); | |
964 | /* | |
965 | * Marshalling functions to get loff_t file sizes into aand out of | |
966 | * object headers. | |
967 | */ | |
968 | void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize); | |
969 | loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh); | |
970 | loff_t yaffs_max_file_size(struct yaffs_dev *dev); | |
0e8cc8bd | 971 | |
0e8cc8bd WJ |
972 | |
973 | #endif |