Commit | Line | Data |
---|---|---|
1e51764a AB |
1 | /* |
2 | * This file is part of UBIFS. | |
3 | * | |
4 | * Copyright (C) 2006-2008 Nokia Corporation | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU General Public License version 2 as published by | |
8 | * the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License along with | |
16 | * this program; if not, write to the Free Software Foundation, Inc., 51 | |
17 | * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
18 | * | |
19 | * Authors: Artem Bityutskiy (Битюцкий Артём) | |
20 | * Adrian Hunter | |
21 | */ | |
22 | ||
23 | /* Implementation version 0.7 */ | |
24 | ||
25 | #ifndef __UBIFS_H__ | |
26 | #define __UBIFS_H__ | |
27 | ||
28 | #include <asm/div64.h> | |
29 | #include <linux/statfs.h> | |
30 | #include <linux/fs.h> | |
31 | #include <linux/err.h> | |
32 | #include <linux/sched.h> | |
33 | #include <linux/vmalloc.h> | |
34 | #include <linux/spinlock.h> | |
35 | #include <linux/mutex.h> | |
36 | #include <linux/rwsem.h> | |
37 | #include <linux/mtd/ubi.h> | |
38 | #include <linux/pagemap.h> | |
39 | #include <linux/backing-dev.h> | |
40 | #include "ubifs-media.h" | |
41 | ||
42 | /* Version of this UBIFS implementation */ | |
43 | #define UBIFS_VERSION 1 | |
44 | ||
45 | /* Normal UBIFS messages */ | |
46 | #define ubifs_msg(fmt, ...) \ | |
47 | printk(KERN_NOTICE "UBIFS: " fmt "\n", ##__VA_ARGS__) | |
48 | /* UBIFS error messages */ | |
49 | #define ubifs_err(fmt, ...) \ | |
50 | printk(KERN_ERR "UBIFS error (pid %d): %s: " fmt "\n", current->pid, \ | |
51 | __func__, ##__VA_ARGS__) | |
52 | /* UBIFS warning messages */ | |
53 | #define ubifs_warn(fmt, ...) \ | |
54 | printk(KERN_WARNING "UBIFS warning (pid %d): %s: " fmt "\n", \ | |
55 | current->pid, __func__, ##__VA_ARGS__) | |
56 | ||
57 | /* UBIFS file system VFS magic number */ | |
58 | #define UBIFS_SUPER_MAGIC 0x24051905 | |
59 | ||
60 | /* Number of UBIFS blocks per VFS page */ | |
61 | #define UBIFS_BLOCKS_PER_PAGE (PAGE_CACHE_SIZE / UBIFS_BLOCK_SIZE) | |
62 | #define UBIFS_BLOCKS_PER_PAGE_SHIFT (PAGE_CACHE_SHIFT - UBIFS_BLOCK_SHIFT) | |
63 | ||
64 | /* "File system end of life" sequence number watermark */ | |
65 | #define SQNUM_WARN_WATERMARK 0xFFFFFFFF00000000ULL | |
66 | #define SQNUM_WATERMARK 0xFFFFFFFFFF000000ULL | |
67 | ||
68 | /* Minimum amount of data UBIFS writes to the flash */ | |
69 | #define MIN_WRITE_SZ (UBIFS_DATA_NODE_SZ + 8) | |
70 | ||
71 | /* | |
72 | * Currently we do not support inode number overlapping and re-using, so this | |
73 | * watermark defines dangerous inode number level. This should be fixed later, | |
74 | * although it is difficult to exceed current limit. Another option is to use | |
75 | * 64-bit inode numbers, but this means more overhead. | |
76 | */ | |
77 | #define INUM_WARN_WATERMARK 0xFFF00000 | |
78 | #define INUM_WATERMARK 0xFFFFFF00 | |
79 | ||
80 | /* Largest key size supported in this implementation */ | |
81 | #define CUR_MAX_KEY_LEN UBIFS_SK_LEN | |
82 | ||
83 | /* Maximum number of entries in each LPT (LEB category) heap */ | |
84 | #define LPT_HEAP_SZ 256 | |
85 | ||
86 | /* | |
87 | * Background thread name pattern. The numbers are UBI device and volume | |
88 | * numbers. | |
89 | */ | |
90 | #define BGT_NAME_PATTERN "ubifs_bgt%d_%d" | |
91 | ||
92 | /* Default write-buffer synchronization timeout (5 secs) */ | |
93 | #define DEFAULT_WBUF_TIMEOUT (5 * HZ) | |
94 | ||
95 | /* Maximum possible inode number (only 32-bit inodes are supported now) */ | |
96 | #define MAX_INUM 0xFFFFFFFF | |
97 | ||
98 | /* Number of non-data journal heads */ | |
99 | #define NONDATA_JHEADS_CNT 2 | |
100 | ||
101 | /* Garbage collector head */ | |
102 | #define GCHD 0 | |
103 | /* Base journal head number */ | |
104 | #define BASEHD 1 | |
105 | /* First "general purpose" journal head */ | |
106 | #define DATAHD 2 | |
107 | ||
108 | /* 'No change' value for 'ubifs_change_lp()' */ | |
109 | #define LPROPS_NC 0x80000001 | |
110 | ||
111 | /* | |
112 | * There is no notion of truncation key because truncation nodes do not exist | |
113 | * in TNC. However, when replaying, it is handy to introduce fake "truncation" | |
114 | * keys for truncation nodes because the code becomes simpler. So we define | |
115 | * %UBIFS_TRUN_KEY type. | |
116 | */ | |
117 | #define UBIFS_TRUN_KEY UBIFS_KEY_TYPES_CNT | |
118 | ||
119 | /* | |
120 | * How much a directory entry/extended attribute entry adds to the parent/host | |
121 | * inode. | |
122 | */ | |
123 | #define CALC_DENT_SIZE(name_len) ALIGN(UBIFS_DENT_NODE_SZ + (name_len) + 1, 8) | |
124 | ||
125 | /* How much an extended attribute adds to the host inode */ | |
126 | #define CALC_XATTR_BYTES(data_len) ALIGN(UBIFS_INO_NODE_SZ + (data_len) + 1, 8) | |
127 | ||
128 | /* | |
129 | * Znodes which were not touched for 'OLD_ZNODE_AGE' seconds are considered | |
130 | * "old", and znode which were touched last 'YOUNG_ZNODE_AGE' seconds ago are | |
131 | * considered "young". This is used by shrinker when selecting znode to trim | |
132 | * off. | |
133 | */ | |
134 | #define OLD_ZNODE_AGE 20 | |
135 | #define YOUNG_ZNODE_AGE 5 | |
136 | ||
137 | /* | |
138 | * Some compressors, like LZO, may end up with more data then the input buffer. | |
139 | * So UBIFS always allocates larger output buffer, to be sure the compressor | |
140 | * will not corrupt memory in case of worst case compression. | |
141 | */ | |
142 | #define WORST_COMPR_FACTOR 2 | |
143 | ||
144 | /* Maximum expected tree height for use by bottom_up_buf */ | |
145 | #define BOTTOM_UP_HEIGHT 64 | |
146 | ||
147 | /* | |
148 | * Lockdep classes for UBIFS inode @ui_mutex. | |
149 | */ | |
150 | enum { | |
151 | WB_MUTEX_1 = 0, | |
152 | WB_MUTEX_2 = 1, | |
153 | WB_MUTEX_3 = 2, | |
154 | }; | |
155 | ||
156 | /* | |
157 | * Znode flags (actually, bit numbers which store the flags). | |
158 | * | |
159 | * DIRTY_ZNODE: znode is dirty | |
160 | * COW_ZNODE: znode is being committed and a new instance of this znode has to | |
161 | * be created before changing this znode | |
162 | * OBSOLETE_ZNODE: znode is obsolete, which means it was deleted, but it is | |
163 | * still in the commit list and the ongoing commit operation | |
164 | * will commit it, and delete this znode after it is done | |
165 | */ | |
166 | enum { | |
167 | DIRTY_ZNODE = 0, | |
168 | COW_ZNODE = 1, | |
169 | OBSOLETE_ZNODE = 2, | |
170 | }; | |
171 | ||
172 | /* | |
173 | * Commit states. | |
174 | * | |
175 | * COMMIT_RESTING: commit is not wanted | |
176 | * COMMIT_BACKGROUND: background commit has been requested | |
177 | * COMMIT_REQUIRED: commit is required | |
178 | * COMMIT_RUNNING_BACKGROUND: background commit is running | |
179 | * COMMIT_RUNNING_REQUIRED: commit is running and it is required | |
180 | * COMMIT_BROKEN: commit failed | |
181 | */ | |
182 | enum { | |
183 | COMMIT_RESTING = 0, | |
184 | COMMIT_BACKGROUND, | |
185 | COMMIT_REQUIRED, | |
186 | COMMIT_RUNNING_BACKGROUND, | |
187 | COMMIT_RUNNING_REQUIRED, | |
188 | COMMIT_BROKEN, | |
189 | }; | |
190 | ||
191 | /* | |
192 | * 'ubifs_scan_a_node()' return values. | |
193 | * | |
194 | * SCANNED_GARBAGE: scanned garbage | |
195 | * SCANNED_EMPTY_SPACE: scanned empty space | |
196 | * SCANNED_A_NODE: scanned a valid node | |
197 | * SCANNED_A_CORRUPT_NODE: scanned a corrupted node | |
198 | * SCANNED_A_BAD_PAD_NODE: scanned a padding node with invalid pad length | |
199 | * | |
200 | * Greater than zero means: 'scanned that number of padding bytes' | |
201 | */ | |
202 | enum { | |
203 | SCANNED_GARBAGE = 0, | |
204 | SCANNED_EMPTY_SPACE = -1, | |
205 | SCANNED_A_NODE = -2, | |
206 | SCANNED_A_CORRUPT_NODE = -3, | |
207 | SCANNED_A_BAD_PAD_NODE = -4, | |
208 | }; | |
209 | ||
210 | /* | |
211 | * LPT cnode flag bits. | |
212 | * | |
213 | * DIRTY_CNODE: cnode is dirty | |
214 | * COW_CNODE: cnode is being committed and must be copied before writing | |
215 | * OBSOLETE_CNODE: cnode is being committed and has been copied (or deleted), | |
216 | * so it can (and must) be freed when the commit is finished | |
217 | */ | |
218 | enum { | |
219 | DIRTY_CNODE = 0, | |
220 | COW_CNODE = 1, | |
221 | OBSOLETE_CNODE = 2, | |
222 | }; | |
223 | ||
224 | /* | |
225 | * Dirty flag bits (lpt_drty_flgs) for LPT special nodes. | |
226 | * | |
227 | * LTAB_DIRTY: ltab node is dirty | |
228 | * LSAVE_DIRTY: lsave node is dirty | |
229 | */ | |
230 | enum { | |
231 | LTAB_DIRTY = 1, | |
232 | LSAVE_DIRTY = 2, | |
233 | }; | |
234 | ||
235 | /* | |
236 | * Return codes used by the garbage collector. | |
237 | * @LEB_FREED: the logical eraseblock was freed and is ready to use | |
238 | * @LEB_FREED_IDX: indexing LEB was freed and can be used only after the commit | |
239 | * @LEB_RETAINED: the logical eraseblock was freed and retained for GC purposes | |
240 | */ | |
241 | enum { | |
242 | LEB_FREED, | |
243 | LEB_FREED_IDX, | |
244 | LEB_RETAINED, | |
245 | }; | |
246 | ||
247 | /** | |
248 | * struct ubifs_old_idx - index node obsoleted since last commit start. | |
249 | * @rb: rb-tree node | |
250 | * @lnum: LEB number of obsoleted index node | |
251 | * @offs: offset of obsoleted index node | |
252 | */ | |
253 | struct ubifs_old_idx { | |
254 | struct rb_node rb; | |
255 | int lnum; | |
256 | int offs; | |
257 | }; | |
258 | ||
259 | /* The below union makes it easier to deal with keys */ | |
260 | union ubifs_key { | |
261 | uint8_t u8[CUR_MAX_KEY_LEN]; | |
262 | uint32_t u32[CUR_MAX_KEY_LEN/4]; | |
263 | uint64_t u64[CUR_MAX_KEY_LEN/8]; | |
264 | __le32 j32[CUR_MAX_KEY_LEN/4]; | |
265 | }; | |
266 | ||
267 | /** | |
268 | * struct ubifs_scan_node - UBIFS scanned node information. | |
269 | * @list: list of scanned nodes | |
270 | * @key: key of node scanned (if it has one) | |
271 | * @sqnum: sequence number | |
272 | * @type: type of node scanned | |
273 | * @offs: offset with LEB of node scanned | |
274 | * @len: length of node scanned | |
275 | * @node: raw node | |
276 | */ | |
277 | struct ubifs_scan_node { | |
278 | struct list_head list; | |
279 | union ubifs_key key; | |
280 | unsigned long long sqnum; | |
281 | int type; | |
282 | int offs; | |
283 | int len; | |
284 | void *node; | |
285 | }; | |
286 | ||
287 | /** | |
288 | * struct ubifs_scan_leb - UBIFS scanned LEB information. | |
289 | * @lnum: logical eraseblock number | |
290 | * @nodes_cnt: number of nodes scanned | |
291 | * @nodes: list of struct ubifs_scan_node | |
292 | * @endpt: end point (and therefore the start of empty space) | |
293 | * @ecc: read returned -EBADMSG | |
294 | * @buf: buffer containing entire LEB scanned | |
295 | */ | |
296 | struct ubifs_scan_leb { | |
297 | int lnum; | |
298 | int nodes_cnt; | |
299 | struct list_head nodes; | |
300 | int endpt; | |
301 | int ecc; | |
302 | void *buf; | |
303 | }; | |
304 | ||
305 | /** | |
306 | * struct ubifs_gced_idx_leb - garbage-collected indexing LEB. | |
307 | * @list: list | |
308 | * @lnum: LEB number | |
309 | * @unmap: OK to unmap this LEB | |
310 | * | |
311 | * This data structure is used to temporary store garbage-collected indexing | |
312 | * LEBs - they are not released immediately, but only after the next commit. | |
313 | * This is needed to guarantee recoverability. | |
314 | */ | |
315 | struct ubifs_gced_idx_leb { | |
316 | struct list_head list; | |
317 | int lnum; | |
318 | int unmap; | |
319 | }; | |
320 | ||
321 | /** | |
322 | * struct ubifs_inode - UBIFS in-memory inode description. | |
323 | * @vfs_inode: VFS inode description object | |
324 | * @creat_sqnum: sequence number at time of creation | |
de94eb55 AB |
325 | * @del_cmtno: commit number corresponding to the time the inode was deleted, |
326 | * protected by @c->commit_sem; | |
1e51764a AB |
327 | * @xattr_size: summarized size of all extended attributes in bytes |
328 | * @xattr_cnt: count of extended attributes this inode has | |
329 | * @xattr_names: sum of lengths of all extended attribute names belonging to | |
330 | * this inode | |
331 | * @dirty: non-zero if the inode is dirty | |
332 | * @xattr: non-zero if this is an extended attribute inode | |
333 | * @ui_mutex: serializes inode write-back with the rest of VFS operations, | |
334 | * serializes "clean <-> dirty" state changes, protects @dirty, | |
335 | * @ui_size, and @xattr_size | |
336 | * @ui_lock: protects @synced_i_size | |
337 | * @synced_i_size: synchronized size of inode, i.e. the value of inode size | |
338 | * currently stored on the flash; used only for regular file | |
339 | * inodes | |
340 | * @ui_size: inode size used by UBIFS when writing to flash | |
341 | * @flags: inode flags (@UBIFS_COMPR_FL, etc) | |
342 | * @compr_type: default compression type used for this inode | |
343 | * @data_len: length of the data attached to the inode | |
344 | * @data: inode's data | |
345 | * | |
346 | * @ui_mutex exists for two main reasons. At first it prevents inodes from | |
347 | * being written back while UBIFS changing them, being in the middle of an VFS | |
348 | * operation. This way UBIFS makes sure the inode fields are consistent. For | |
349 | * example, in 'ubifs_rename()' we change 3 inodes simultaneously, and | |
350 | * write-back must not write any of them before we have finished. | |
351 | * | |
352 | * The second reason is budgeting - UBIFS has to budget all operations. If an | |
353 | * operation is going to mark an inode dirty, it has to allocate budget for | |
354 | * this. It cannot just mark it dirty because there is no guarantee there will | |
355 | * be enough flash space to write the inode back later. This means UBIFS has | |
356 | * to have full control over inode "clean <-> dirty" transitions (and pages | |
357 | * actually). But unfortunately, VFS marks inodes dirty in many places, and it | |
358 | * does not ask the file-system if it is allowed to do so (there is a notifier, | |
359 | * but it is not enough), i.e., there is no mechanism to synchronize with this. | |
360 | * So UBIFS has its own inode dirty flag and its own mutex to serialize | |
361 | * "clean <-> dirty" transitions. | |
362 | * | |
363 | * The @synced_i_size field is used to make sure we never write pages which are | |
364 | * beyond last synchronized inode size. See 'ubifs_writepage()' for more | |
365 | * information. | |
366 | * | |
367 | * The @ui_size is a "shadow" variable for @inode->i_size and UBIFS uses | |
368 | * @ui_size instead of @inode->i_size. The reason for this is that UBIFS cannot | |
369 | * make sure @inode->i_size is always changed under @ui_mutex, because it | |
370 | * cannot call 'vmtruncate()' with @ui_mutex locked, because it would deadlock | |
371 | * with 'ubifs_writepage()' (see file.c). All the other inode fields are | |
372 | * changed under @ui_mutex, so they do not need "shadow" fields. Note, one | |
373 | * could consider to rework locking and base it on "shadow" fields. | |
374 | */ | |
375 | struct ubifs_inode { | |
376 | struct inode vfs_inode; | |
bc813355 AH |
377 | unsigned long long creat_sqnum; |
378 | unsigned long long del_cmtno; | |
1e51764a AB |
379 | unsigned int xattr_size; |
380 | unsigned int xattr_cnt; | |
381 | unsigned int xattr_names; | |
382 | unsigned int dirty:1; | |
383 | unsigned int xattr:1; | |
384 | struct mutex ui_mutex; | |
385 | spinlock_t ui_lock; | |
386 | loff_t synced_i_size; | |
387 | loff_t ui_size; | |
388 | int flags; | |
389 | int compr_type; | |
390 | int data_len; | |
391 | void *data; | |
392 | }; | |
393 | ||
394 | /** | |
395 | * struct ubifs_unclean_leb - records a LEB recovered under read-only mode. | |
396 | * @list: list | |
397 | * @lnum: LEB number of recovered LEB | |
398 | * @endpt: offset where recovery ended | |
399 | * | |
400 | * This structure records a LEB identified during recovery that needs to be | |
401 | * cleaned but was not because UBIFS was mounted read-only. The information | |
402 | * is used to clean the LEB when remounting to read-write mode. | |
403 | */ | |
404 | struct ubifs_unclean_leb { | |
405 | struct list_head list; | |
406 | int lnum; | |
407 | int endpt; | |
408 | }; | |
409 | ||
410 | /* | |
411 | * LEB properties flags. | |
412 | * | |
413 | * LPROPS_UNCAT: not categorized | |
414 | * LPROPS_DIRTY: dirty > 0, not index | |
415 | * LPROPS_DIRTY_IDX: dirty + free > UBIFS_CH_SZ and index | |
416 | * LPROPS_FREE: free > 0, not empty, not index | |
417 | * LPROPS_HEAP_CNT: number of heaps used for storing categorized LEBs | |
418 | * LPROPS_EMPTY: LEB is empty, not taken | |
419 | * LPROPS_FREEABLE: free + dirty == leb_size, not index, not taken | |
420 | * LPROPS_FRDI_IDX: free + dirty == leb_size and index, may be taken | |
421 | * LPROPS_CAT_MASK: mask for the LEB categories above | |
422 | * LPROPS_TAKEN: LEB was taken (this flag is not saved on the media) | |
423 | * LPROPS_INDEX: LEB contains indexing nodes (this flag also exists on flash) | |
424 | */ | |
425 | enum { | |
426 | LPROPS_UNCAT = 0, | |
427 | LPROPS_DIRTY = 1, | |
428 | LPROPS_DIRTY_IDX = 2, | |
429 | LPROPS_FREE = 3, | |
430 | LPROPS_HEAP_CNT = 3, | |
431 | LPROPS_EMPTY = 4, | |
432 | LPROPS_FREEABLE = 5, | |
433 | LPROPS_FRDI_IDX = 6, | |
434 | LPROPS_CAT_MASK = 15, | |
435 | LPROPS_TAKEN = 16, | |
436 | LPROPS_INDEX = 32, | |
437 | }; | |
438 | ||
439 | /** | |
440 | * struct ubifs_lprops - logical eraseblock properties. | |
441 | * @free: amount of free space in bytes | |
442 | * @dirty: amount of dirty space in bytes | |
443 | * @flags: LEB properties flags (see above) | |
444 | * @lnum: LEB number | |
445 | * @list: list of same-category lprops (for LPROPS_EMPTY and LPROPS_FREEABLE) | |
446 | * @hpos: heap position in heap of same-category lprops (other categories) | |
447 | */ | |
448 | struct ubifs_lprops { | |
449 | int free; | |
450 | int dirty; | |
451 | int flags; | |
452 | int lnum; | |
453 | union { | |
454 | struct list_head list; | |
455 | int hpos; | |
456 | }; | |
457 | }; | |
458 | ||
459 | /** | |
460 | * struct ubifs_lpt_lprops - LPT logical eraseblock properties. | |
461 | * @free: amount of free space in bytes | |
462 | * @dirty: amount of dirty space in bytes | |
463 | * @tgc: trivial GC flag (1 => unmap after commit end) | |
464 | * @cmt: commit flag (1 => reserved for commit) | |
465 | */ | |
466 | struct ubifs_lpt_lprops { | |
467 | int free; | |
468 | int dirty; | |
469 | unsigned tgc : 1; | |
470 | unsigned cmt : 1; | |
471 | }; | |
472 | ||
473 | /** | |
474 | * struct ubifs_lp_stats - statistics of eraseblocks in the main area. | |
475 | * @empty_lebs: number of empty LEBs | |
476 | * @taken_empty_lebs: number of taken LEBs | |
477 | * @idx_lebs: number of indexing LEBs | |
478 | * @total_free: total free space in bytes | |
479 | * @total_dirty: total dirty space in bytes | |
480 | * @total_used: total used space in bytes (includes only data LEBs) | |
481 | * @total_dead: total dead space in bytes (includes only data LEBs) | |
482 | * @total_dark: total dark space in bytes (includes only data LEBs) | |
483 | * | |
484 | * N.B. total_dirty and total_used are different to other total_* fields, | |
485 | * because they account _all_ LEBs, not just data LEBs. | |
486 | * | |
487 | * 'taken_empty_lebs' counts the LEBs that are in the transient state of having | |
488 | * been 'taken' for use but not yet written to. 'taken_empty_lebs' is needed | |
489 | * to account correctly for gc_lnum, otherwise 'empty_lebs' could be used | |
490 | * by itself (in which case 'unused_lebs' would be a better name). In the case | |
491 | * of gc_lnum, it is 'taken' at mount time or whenever a LEB is retained by GC, | |
492 | * but unlike other empty LEBs that are 'taken', it may not be written straight | |
493 | * away (i.e. before the next commit start or unmount), so either gc_lnum must | |
494 | * be specially accounted for, or the current approach followed i.e. count it | |
495 | * under 'taken_empty_lebs'. | |
496 | */ | |
497 | struct ubifs_lp_stats { | |
498 | int empty_lebs; | |
499 | int taken_empty_lebs; | |
500 | int idx_lebs; | |
501 | long long total_free; | |
502 | long long total_dirty; | |
503 | long long total_used; | |
504 | long long total_dead; | |
505 | long long total_dark; | |
506 | }; | |
507 | ||
508 | struct ubifs_nnode; | |
509 | ||
510 | /** | |
511 | * struct ubifs_cnode - LEB Properties Tree common node. | |
512 | * @parent: parent nnode | |
513 | * @cnext: next cnode to commit | |
514 | * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE) | |
515 | * @iip: index in parent | |
516 | * @level: level in the tree (zero for pnodes, greater than zero for nnodes) | |
517 | * @num: node number | |
518 | */ | |
519 | struct ubifs_cnode { | |
520 | struct ubifs_nnode *parent; | |
521 | struct ubifs_cnode *cnext; | |
522 | unsigned long flags; | |
523 | int iip; | |
524 | int level; | |
525 | int num; | |
526 | }; | |
527 | ||
528 | /** | |
529 | * struct ubifs_pnode - LEB Properties Tree leaf node. | |
530 | * @parent: parent nnode | |
531 | * @cnext: next cnode to commit | |
532 | * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE) | |
533 | * @iip: index in parent | |
534 | * @level: level in the tree (always zero for pnodes) | |
535 | * @num: node number | |
536 | * @lprops: LEB properties array | |
537 | */ | |
538 | struct ubifs_pnode { | |
539 | struct ubifs_nnode *parent; | |
540 | struct ubifs_cnode *cnext; | |
541 | unsigned long flags; | |
542 | int iip; | |
543 | int level; | |
544 | int num; | |
545 | struct ubifs_lprops lprops[UBIFS_LPT_FANOUT]; | |
546 | }; | |
547 | ||
548 | /** | |
549 | * struct ubifs_nbranch - LEB Properties Tree internal node branch. | |
550 | * @lnum: LEB number of child | |
551 | * @offs: offset of child | |
552 | * @nnode: nnode child | |
553 | * @pnode: pnode child | |
554 | * @cnode: cnode child | |
555 | */ | |
556 | struct ubifs_nbranch { | |
557 | int lnum; | |
558 | int offs; | |
559 | union { | |
560 | struct ubifs_nnode *nnode; | |
561 | struct ubifs_pnode *pnode; | |
562 | struct ubifs_cnode *cnode; | |
563 | }; | |
564 | }; | |
565 | ||
566 | /** | |
567 | * struct ubifs_nnode - LEB Properties Tree internal node. | |
568 | * @parent: parent nnode | |
569 | * @cnext: next cnode to commit | |
570 | * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE) | |
571 | * @iip: index in parent | |
572 | * @level: level in the tree (always greater than zero for nnodes) | |
573 | * @num: node number | |
574 | * @nbranch: branches to child nodes | |
575 | */ | |
576 | struct ubifs_nnode { | |
577 | struct ubifs_nnode *parent; | |
578 | struct ubifs_cnode *cnext; | |
579 | unsigned long flags; | |
580 | int iip; | |
581 | int level; | |
582 | int num; | |
583 | struct ubifs_nbranch nbranch[UBIFS_LPT_FANOUT]; | |
584 | }; | |
585 | ||
586 | /** | |
587 | * struct ubifs_lpt_heap - heap of categorized lprops. | |
588 | * @arr: heap array | |
589 | * @cnt: number in heap | |
590 | * @max_cnt: maximum number allowed in heap | |
591 | * | |
592 | * There are %LPROPS_HEAP_CNT heaps. | |
593 | */ | |
594 | struct ubifs_lpt_heap { | |
595 | struct ubifs_lprops **arr; | |
596 | int cnt; | |
597 | int max_cnt; | |
598 | }; | |
599 | ||
600 | /* | |
601 | * Return codes for LPT scan callback function. | |
602 | * | |
603 | * LPT_SCAN_CONTINUE: continue scanning | |
604 | * LPT_SCAN_ADD: add the LEB properties scanned to the tree in memory | |
605 | * LPT_SCAN_STOP: stop scanning | |
606 | */ | |
607 | enum { | |
608 | LPT_SCAN_CONTINUE = 0, | |
609 | LPT_SCAN_ADD = 1, | |
610 | LPT_SCAN_STOP = 2, | |
611 | }; | |
612 | ||
613 | struct ubifs_info; | |
614 | ||
615 | /* Callback used by the 'ubifs_lpt_scan_nolock()' function */ | |
616 | typedef int (*ubifs_lpt_scan_callback)(struct ubifs_info *c, | |
617 | const struct ubifs_lprops *lprops, | |
618 | int in_tree, void *data); | |
619 | ||
620 | /** | |
621 | * struct ubifs_wbuf - UBIFS write-buffer. | |
622 | * @c: UBIFS file-system description object | |
623 | * @buf: write-buffer (of min. flash I/O unit size) | |
624 | * @lnum: logical eraseblock number the write-buffer points to | |
625 | * @offs: write-buffer offset in this logical eraseblock | |
626 | * @avail: number of bytes available in the write-buffer | |
627 | * @used: number of used bytes in the write-buffer | |
628 | * @dtype: type of data stored in this LEB (%UBI_LONGTERM, %UBI_SHORTTERM, | |
629 | * %UBI_UNKNOWN) | |
630 | * @jhead: journal head the mutex belongs to (note, needed only to shut lockdep | |
631 | * up by 'mutex_lock_nested()). | |
632 | * @sync_callback: write-buffer synchronization callback | |
633 | * @io_mutex: serializes write-buffer I/O | |
634 | * @lock: serializes @buf, @lnum, @offs, @avail, @used, @next_ino and @inodes | |
635 | * fields | |
636 | * @timer: write-buffer timer | |
637 | * @timeout: timer expire interval in jiffies | |
638 | * @need_sync: it is set if its timer expired and needs sync | |
639 | * @next_ino: points to the next position of the following inode number | |
640 | * @inodes: stores the inode numbers of the nodes which are in wbuf | |
641 | * | |
642 | * The write-buffer synchronization callback is called when the write-buffer is | |
643 | * synchronized in order to notify how much space was wasted due to | |
644 | * write-buffer padding and how much free space is left in the LEB. | |
645 | * | |
646 | * Note: the fields @buf, @lnum, @offs, @avail and @used can be read under | |
647 | * spin-lock or mutex because they are written under both mutex and spin-lock. | |
648 | * @buf is appended to under mutex but overwritten under both mutex and | |
649 | * spin-lock. Thus the data between @buf and @buf + @used can be read under | |
650 | * spinlock. | |
651 | */ | |
652 | struct ubifs_wbuf { | |
653 | struct ubifs_info *c; | |
654 | void *buf; | |
655 | int lnum; | |
656 | int offs; | |
657 | int avail; | |
658 | int used; | |
659 | int dtype; | |
660 | int jhead; | |
661 | int (*sync_callback)(struct ubifs_info *c, int lnum, int free, int pad); | |
662 | struct mutex io_mutex; | |
663 | spinlock_t lock; | |
664 | struct timer_list timer; | |
665 | int timeout; | |
666 | int need_sync; | |
667 | int next_ino; | |
668 | ino_t *inodes; | |
669 | }; | |
670 | ||
671 | /** | |
672 | * struct ubifs_bud - bud logical eraseblock. | |
673 | * @lnum: logical eraseblock number | |
674 | * @start: where the (uncommitted) bud data starts | |
675 | * @jhead: journal head number this bud belongs to | |
676 | * @list: link in the list buds belonging to the same journal head | |
677 | * @rb: link in the tree of all buds | |
678 | */ | |
679 | struct ubifs_bud { | |
680 | int lnum; | |
681 | int start; | |
682 | int jhead; | |
683 | struct list_head list; | |
684 | struct rb_node rb; | |
685 | }; | |
686 | ||
687 | /** | |
688 | * struct ubifs_jhead - journal head. | |
689 | * @wbuf: head's write-buffer | |
690 | * @buds_list: list of bud LEBs belonging to this journal head | |
691 | * | |
692 | * Note, the @buds list is protected by the @c->buds_lock. | |
693 | */ | |
694 | struct ubifs_jhead { | |
695 | struct ubifs_wbuf wbuf; | |
696 | struct list_head buds_list; | |
697 | }; | |
698 | ||
699 | /** | |
700 | * struct ubifs_zbranch - key/coordinate/length branch stored in znodes. | |
701 | * @key: key | |
702 | * @znode: znode address in memory | |
703 | * @lnum: LEB number of the indexing node | |
704 | * @offs: offset of the indexing node within @lnum | |
705 | * @len: target node length | |
706 | */ | |
707 | struct ubifs_zbranch { | |
708 | union ubifs_key key; | |
709 | union { | |
710 | struct ubifs_znode *znode; | |
711 | void *leaf; | |
712 | }; | |
713 | int lnum; | |
714 | int offs; | |
715 | int len; | |
716 | }; | |
717 | ||
718 | /** | |
719 | * struct ubifs_znode - in-memory representation of an indexing node. | |
720 | * @parent: parent znode or NULL if it is the root | |
721 | * @cnext: next znode to commit | |
722 | * @flags: znode flags (%DIRTY_ZNODE, %COW_ZNODE or %OBSOLETE_ZNODE) | |
723 | * @time: last access time (seconds) | |
724 | * @level: level of the entry in the TNC tree | |
725 | * @child_cnt: count of child znodes | |
726 | * @iip: index in parent's zbranch array | |
727 | * @alt: lower bound of key range has altered i.e. child inserted at slot 0 | |
728 | * @lnum: LEB number of the corresponding indexing node | |
729 | * @offs: offset of the corresponding indexing node | |
730 | * @len: length of the corresponding indexing node | |
731 | * @zbranch: array of znode branches (@c->fanout elements) | |
732 | */ | |
733 | struct ubifs_znode { | |
734 | struct ubifs_znode *parent; | |
735 | struct ubifs_znode *cnext; | |
736 | unsigned long flags; | |
737 | unsigned long time; | |
738 | int level; | |
739 | int child_cnt; | |
740 | int iip; | |
741 | int alt; | |
742 | #ifdef CONFIG_UBIFS_FS_DEBUG | |
743 | int lnum, offs, len; | |
744 | #endif | |
745 | struct ubifs_zbranch zbranch[]; | |
746 | }; | |
747 | ||
748 | /** | |
749 | * struct ubifs_node_range - node length range description data structure. | |
750 | * @len: fixed node length | |
751 | * @min_len: minimum possible node length | |
752 | * @max_len: maximum possible node length | |
753 | * | |
754 | * If @max_len is %0, the node has fixed length @len. | |
755 | */ | |
756 | struct ubifs_node_range { | |
757 | union { | |
758 | int len; | |
759 | int min_len; | |
760 | }; | |
761 | int max_len; | |
762 | }; | |
763 | ||
764 | /** | |
765 | * struct ubifs_compressor - UBIFS compressor description structure. | |
766 | * @compr_type: compressor type (%UBIFS_COMPR_LZO, etc) | |
767 | * @cc: cryptoapi compressor handle | |
768 | * @comp_mutex: mutex used during compression | |
769 | * @decomp_mutex: mutex used during decompression | |
770 | * @name: compressor name | |
771 | * @capi_name: cryptoapi compressor name | |
772 | */ | |
773 | struct ubifs_compressor { | |
774 | int compr_type; | |
775 | struct crypto_comp *cc; | |
776 | struct mutex *comp_mutex; | |
777 | struct mutex *decomp_mutex; | |
778 | const char *name; | |
779 | const char *capi_name; | |
780 | }; | |
781 | ||
782 | /** | |
783 | * struct ubifs_budget_req - budget requirements of an operation. | |
784 | * | |
de94eb55 | 785 | * @fast: non-zero if the budgeting should try to acquire budget quickly and |
1e51764a AB |
786 | * should not try to call write-back |
787 | * @recalculate: non-zero if @idx_growth, @data_growth, and @dd_growth fields | |
788 | * have to be re-calculated | |
789 | * @new_page: non-zero if the operation adds a new page | |
790 | * @dirtied_page: non-zero if the operation makes a page dirty | |
791 | * @new_dent: non-zero if the operation adds a new directory entry | |
792 | * @mod_dent: non-zero if the operation removes or modifies an existing | |
793 | * directory entry | |
794 | * @new_ino: non-zero if the operation adds a new inode | |
795 | * @new_ino_d: now much data newly created inode contains | |
796 | * @dirtied_ino: how many inodes the operation makes dirty | |
797 | * @dirtied_ino_d: now much data dirtied inode contains | |
798 | * @idx_growth: how much the index will supposedly grow | |
799 | * @data_growth: how much new data the operation will supposedly add | |
800 | * @dd_growth: how much data that makes other data dirty the operation will | |
801 | * supposedly add | |
802 | * | |
803 | * @idx_growth, @data_growth and @dd_growth are not used in budget request. The | |
804 | * budgeting subsystem caches index and data growth values there to avoid | |
805 | * re-calculating them when the budget is released. However, if @idx_growth is | |
806 | * %-1, it is calculated by the release function using other fields. | |
807 | * | |
808 | * An inode may contain 4KiB of data at max., thus the widths of @new_ino_d | |
809 | * is 13 bits, and @dirtied_ino_d - 15, because up to 4 inodes may be made | |
810 | * dirty by the re-name operation. | |
811 | */ | |
812 | struct ubifs_budget_req { | |
813 | unsigned int fast:1; | |
814 | unsigned int recalculate:1; | |
547000da | 815 | #ifndef UBIFS_DEBUG |
1e51764a AB |
816 | unsigned int new_page:1; |
817 | unsigned int dirtied_page:1; | |
818 | unsigned int new_dent:1; | |
819 | unsigned int mod_dent:1; | |
820 | unsigned int new_ino:1; | |
821 | unsigned int new_ino_d:13; | |
1e51764a AB |
822 | unsigned int dirtied_ino:4; |
823 | unsigned int dirtied_ino_d:15; | |
824 | #else | |
825 | /* Not bit-fields to check for overflows */ | |
547000da AB |
826 | unsigned int new_page; |
827 | unsigned int dirtied_page; | |
828 | unsigned int new_dent; | |
829 | unsigned int mod_dent; | |
830 | unsigned int new_ino; | |
831 | unsigned int new_ino_d; | |
1e51764a AB |
832 | unsigned int dirtied_ino; |
833 | unsigned int dirtied_ino_d; | |
834 | #endif | |
835 | int idx_growth; | |
836 | int data_growth; | |
837 | int dd_growth; | |
838 | }; | |
839 | ||
840 | /** | |
841 | * struct ubifs_orphan - stores the inode number of an orphan. | |
842 | * @rb: rb-tree node of rb-tree of orphans sorted by inode number | |
843 | * @list: list head of list of orphans in order added | |
844 | * @new_list: list head of list of orphans added since the last commit | |
845 | * @cnext: next orphan to commit | |
846 | * @dnext: next orphan to delete | |
847 | * @inum: inode number | |
848 | * @new: %1 => added since the last commit, otherwise %0 | |
849 | */ | |
850 | struct ubifs_orphan { | |
851 | struct rb_node rb; | |
852 | struct list_head list; | |
853 | struct list_head new_list; | |
854 | struct ubifs_orphan *cnext; | |
855 | struct ubifs_orphan *dnext; | |
856 | ino_t inum; | |
857 | int new; | |
858 | }; | |
859 | ||
860 | /** | |
861 | * struct ubifs_mount_opts - UBIFS-specific mount options information. | |
862 | * @unmount_mode: selected unmount mode (%0 default, %1 normal, %2 fast) | |
863 | */ | |
864 | struct ubifs_mount_opts { | |
865 | unsigned int unmount_mode:2; | |
866 | }; | |
867 | ||
868 | /** | |
869 | * struct ubifs_info - UBIFS file-system description data structure | |
870 | * (per-superblock). | |
871 | * @vfs_sb: VFS @struct super_block object | |
de94eb55 | 872 | * @bdi: backing device info object to make VFS happy and disable read-ahead |
1e51764a AB |
873 | * |
874 | * @highest_inum: highest used inode number | |
875 | * @vfs_gen: VFS inode generation counter | |
876 | * @max_sqnum: current global sequence number | |
014eb04b AB |
877 | * @cmt_no: commit number of the last successfully completed commit, protected |
878 | * by @commit_sem | |
1e51764a AB |
879 | * @cnt_lock: protects @highest_inum, @vfs_gen, and @max_sqnum counters |
880 | * @fmt_version: UBIFS on-flash format version | |
881 | * @uuid: UUID from super block | |
882 | * | |
883 | * @lhead_lnum: log head logical eraseblock number | |
884 | * @lhead_offs: log head offset | |
885 | * @ltail_lnum: log tail logical eraseblock number (offset is always 0) | |
886 | * @log_mutex: protects the log, @lhead_lnum, @lhead_offs, @ltail_lnum, and | |
887 | * @bud_bytes | |
888 | * @min_log_bytes: minimum required number of bytes in the log | |
889 | * @cmt_bud_bytes: used during commit to temporarily amount of bytes in | |
890 | * committed buds | |
891 | * | |
892 | * @buds: tree of all buds indexed by bud LEB number | |
893 | * @bud_bytes: how many bytes of flash is used by buds | |
894 | * @buds_lock: protects the @buds tree, @bud_bytes, and per-journal head bud | |
895 | * lists | |
896 | * @jhead_cnt: count of journal heads | |
897 | * @jheads: journal heads (head zero is base head) | |
898 | * @max_bud_bytes: maximum number of bytes allowed in buds | |
899 | * @bg_bud_bytes: number of bud bytes when background commit is initiated | |
900 | * @old_buds: buds to be released after commit ends | |
901 | * @max_bud_cnt: maximum number of buds | |
902 | * | |
903 | * @commit_sem: synchronizes committer with other processes | |
904 | * @cmt_state: commit state | |
905 | * @cs_lock: commit state lock | |
906 | * @cmt_wq: wait queue to sleep on if the log is full and a commit is running | |
907 | * @fast_unmount: do not run journal commit before un-mounting | |
908 | * @big_lpt: flag that LPT is too big to write whole during commit | |
909 | * @check_lpt_free: flag that indicates LPT GC may be needed | |
910 | * @nospace: non-zero if the file-system does not have flash space (used as | |
911 | * optimization) | |
912 | * @nospace_rp: the same as @nospace, but additionally means that even reserved | |
913 | * pool is full | |
914 | * | |
915 | * @tnc_mutex: protects the Tree Node Cache (TNC), @zroot, @cnext, @enext, and | |
916 | * @calc_idx_sz | |
917 | * @zroot: zbranch which points to the root index node and znode | |
918 | * @cnext: next znode to commit | |
919 | * @enext: next znode to commit to empty space | |
920 | * @gap_lebs: array of LEBs used by the in-gaps commit method | |
921 | * @cbuf: commit buffer | |
922 | * @ileb_buf: buffer for commit in-the-gaps method | |
923 | * @ileb_len: length of data in ileb_buf | |
924 | * @ihead_lnum: LEB number of index head | |
925 | * @ihead_offs: offset of index head | |
926 | * @ilebs: pre-allocated index LEBs | |
927 | * @ileb_cnt: number of pre-allocated index LEBs | |
928 | * @ileb_nxt: next pre-allocated index LEBs | |
929 | * @old_idx: tree of index nodes obsoleted since the last commit start | |
930 | * @bottom_up_buf: a buffer which is used by 'dirty_cow_bottom_up()' in tnc.c | |
931 | * @new_ihead_lnum: used by debugging to check ihead_lnum | |
932 | * @new_ihead_offs: used by debugging to check ihead_offs | |
933 | * | |
934 | * @mst_node: master node | |
935 | * @mst_offs: offset of valid master node | |
936 | * @mst_mutex: protects the master node area, @mst_node, and @mst_offs | |
937 | * | |
938 | * @log_lebs: number of logical eraseblocks in the log | |
939 | * @log_bytes: log size in bytes | |
940 | * @log_last: last LEB of the log | |
941 | * @lpt_lebs: number of LEBs used for lprops table | |
942 | * @lpt_first: first LEB of the lprops table area | |
943 | * @lpt_last: last LEB of the lprops table area | |
944 | * @orph_lebs: number of LEBs used for the orphan area | |
945 | * @orph_first: first LEB of the orphan area | |
946 | * @orph_last: last LEB of the orphan area | |
947 | * @main_lebs: count of LEBs in the main area | |
948 | * @main_first: first LEB of the main area | |
949 | * @main_bytes: main area size in bytes | |
950 | * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc) | |
951 | * | |
952 | * @key_hash_type: type of the key hash | |
953 | * @key_hash: direntry key hash function | |
954 | * @key_fmt: key format | |
955 | * @key_len: key length | |
956 | * @fanout: fanout of the index tree (number of links per indexing node) | |
957 | * | |
958 | * @min_io_size: minimal input/output unit size | |
959 | * @min_io_shift: number of bits in @min_io_size minus one | |
960 | * @leb_size: logical eraseblock size in bytes | |
961 | * @half_leb_size: half LEB size | |
962 | * @leb_cnt: count of logical eraseblocks | |
963 | * @max_leb_cnt: maximum count of logical eraseblocks | |
964 | * @old_leb_cnt: count of logical eraseblocks before re-size | |
965 | * @ro_media: the underlying UBI volume is read-only | |
966 | * | |
967 | * @dirty_pg_cnt: number of dirty pages (not used) | |
968 | * @dirty_zn_cnt: number of dirty znodes | |
969 | * @clean_zn_cnt: number of clean znodes | |
970 | * | |
971 | * @budg_idx_growth: amount of bytes budgeted for index growth | |
972 | * @budg_data_growth: amount of bytes budgeted for cached data | |
973 | * @budg_dd_growth: amount of bytes budgeted for cached data that will make | |
974 | * other data dirty | |
975 | * @budg_uncommitted_idx: amount of bytes were budgeted for growth of the index, | |
976 | * but which still have to be taken into account because | |
977 | * the index has not been committed so far | |
978 | * @space_lock: protects @budg_idx_growth, @budg_data_growth, @budg_dd_growth, | |
979 | * @budg_uncommited_idx, @min_idx_lebs, @old_idx_sz, and @lst; | |
980 | * @min_idx_lebs: minimum number of LEBs required for the index | |
981 | * @old_idx_sz: size of index on flash | |
982 | * @calc_idx_sz: temporary variable which is used to calculate new index size | |
983 | * (contains accurate new index size at end of TNC commit start) | |
984 | * @lst: lprops statistics | |
985 | * | |
986 | * @page_budget: budget for a page | |
987 | * @inode_budget: budget for an inode | |
988 | * @dent_budget: budget for a directory entry | |
989 | * | |
990 | * @ref_node_alsz: size of the LEB reference node aligned to the min. flash | |
991 | * I/O unit | |
992 | * @mst_node_alsz: master node aligned size | |
993 | * @min_idx_node_sz: minimum indexing node aligned on 8-bytes boundary | |
994 | * @max_idx_node_sz: maximum indexing node aligned on 8-bytes boundary | |
995 | * @max_inode_sz: maximum possible inode size in bytes | |
996 | * @max_znode_sz: size of znode in bytes | |
997 | * @dead_wm: LEB dead space watermark | |
998 | * @dark_wm: LEB dark space watermark | |
999 | * @block_cnt: count of 4KiB blocks on the FS | |
1000 | * | |
1001 | * @ranges: UBIFS node length ranges | |
1002 | * @ubi: UBI volume descriptor | |
1003 | * @di: UBI device information | |
1004 | * @vi: UBI volume information | |
1005 | * | |
1006 | * @orph_tree: rb-tree of orphan inode numbers | |
1007 | * @orph_list: list of orphan inode numbers in order added | |
1008 | * @orph_new: list of orphan inode numbers added since last commit | |
1009 | * @orph_cnext: next orphan to commit | |
1010 | * @orph_dnext: next orphan to delete | |
1011 | * @orphan_lock: lock for orph_tree and orph_new | |
1012 | * @orph_buf: buffer for orphan nodes | |
1013 | * @new_orphans: number of orphans since last commit | |
1014 | * @cmt_orphans: number of orphans being committed | |
1015 | * @tot_orphans: number of orphans in the rb_tree | |
1016 | * @max_orphans: maximum number of orphans allowed | |
1017 | * @ohead_lnum: orphan head LEB number | |
1018 | * @ohead_offs: orphan head offset | |
1019 | * @no_orphs: non-zero if there are no orphans | |
1020 | * | |
1021 | * @bgt: UBIFS background thread | |
1022 | * @bgt_name: background thread name | |
1023 | * @need_bgt: if background thread should run | |
1024 | * @need_wbuf_sync: if write-buffers have to be synchronized | |
1025 | * | |
1026 | * @gc_lnum: LEB number used for garbage collection | |
1027 | * @sbuf: a buffer of LEB size used by GC and replay for scanning | |
1028 | * @idx_gc: list of index LEBs that have been garbage collected | |
1029 | * @idx_gc_cnt: number of elements on the idx_gc list | |
1030 | * | |
1031 | * @infos_list: links all 'ubifs_info' objects | |
1032 | * @umount_mutex: serializes shrinker and un-mount | |
1033 | * @shrinker_run_no: shrinker run number | |
1034 | * | |
1035 | * @space_bits: number of bits needed to record free or dirty space | |
1036 | * @lpt_lnum_bits: number of bits needed to record a LEB number in the LPT | |
1037 | * @lpt_offs_bits: number of bits needed to record an offset in the LPT | |
1038 | * @lpt_spc_bits: number of bits needed to space in the LPT | |
1039 | * @pcnt_bits: number of bits needed to record pnode or nnode number | |
1040 | * @lnum_bits: number of bits needed to record LEB number | |
1041 | * @nnode_sz: size of on-flash nnode | |
1042 | * @pnode_sz: size of on-flash pnode | |
1043 | * @ltab_sz: size of on-flash LPT lprops table | |
1044 | * @lsave_sz: size of on-flash LPT save table | |
1045 | * @pnode_cnt: number of pnodes | |
1046 | * @nnode_cnt: number of nnodes | |
1047 | * @lpt_hght: height of the LPT | |
1048 | * @pnodes_have: number of pnodes in memory | |
1049 | * | |
1050 | * @lp_mutex: protects lprops table and all the other lprops-related fields | |
1051 | * @lpt_lnum: LEB number of the root nnode of the LPT | |
1052 | * @lpt_offs: offset of the root nnode of the LPT | |
1053 | * @nhead_lnum: LEB number of LPT head | |
1054 | * @nhead_offs: offset of LPT head | |
1055 | * @lpt_drty_flgs: dirty flags for LPT special nodes e.g. ltab | |
1056 | * @dirty_nn_cnt: number of dirty nnodes | |
1057 | * @dirty_pn_cnt: number of dirty pnodes | |
1058 | * @lpt_sz: LPT size | |
1059 | * @lpt_nod_buf: buffer for an on-flash nnode or pnode | |
1060 | * @lpt_buf: buffer of LEB size used by LPT | |
1061 | * @nroot: address in memory of the root nnode of the LPT | |
1062 | * @lpt_cnext: next LPT node to commit | |
1063 | * @lpt_heap: array of heaps of categorized lprops | |
1064 | * @dirty_idx: a (reverse sorted) copy of the LPROPS_DIRTY_IDX heap as at | |
1065 | * previous commit start | |
1066 | * @uncat_list: list of un-categorized LEBs | |
1067 | * @empty_list: list of empty LEBs | |
1068 | * @freeable_list: list of freeable non-index LEBs (free + dirty == leb_size) | |
1069 | * @frdi_idx_list: list of freeable index LEBs (free + dirty == leb_size) | |
1070 | * @freeable_cnt: number of freeable LEBs in @freeable_list | |
1071 | * | |
1072 | * @ltab_lnum: LEB number of LPT's own lprops table | |
1073 | * @ltab_offs: offset of LPT's own lprops table | |
1074 | * @ltab: LPT's own lprops table | |
1075 | * @ltab_cmt: LPT's own lprops table (commit copy) | |
1076 | * @lsave_cnt: number of LEB numbers in LPT's save table | |
1077 | * @lsave_lnum: LEB number of LPT's save table | |
1078 | * @lsave_offs: offset of LPT's save table | |
1079 | * @lsave: LPT's save table | |
1080 | * @lscan_lnum: LEB number of last LPT scan | |
1081 | * | |
1082 | * @rp_size: size of the reserved pool in bytes | |
1083 | * @report_rp_size: size of the reserved pool reported to user-space | |
1084 | * @rp_uid: reserved pool user ID | |
1085 | * @rp_gid: reserved pool group ID | |
1086 | * | |
1087 | * @empty: if the UBI device is empty | |
1088 | * @replay_tree: temporary tree used during journal replay | |
1089 | * @replay_list: temporary list used during journal replay | |
1090 | * @replay_buds: list of buds to replay | |
1091 | * @cs_sqnum: sequence number of first node in the log (commit start node) | |
1092 | * @replay_sqnum: sequence number of node currently being replayed | |
1093 | * @need_recovery: file-system needs recovery | |
1094 | * @replaying: set to %1 during journal replay | |
1095 | * @unclean_leb_list: LEBs to recover when mounting ro to rw | |
1096 | * @rcvrd_mst_node: recovered master node to write when mounting ro to rw | |
1097 | * @size_tree: inode size information for recovery | |
1098 | * @remounting_rw: set while remounting from ro to rw (sb flags have MS_RDONLY) | |
1099 | * @mount_opts: UBIFS-specific mount options | |
1100 | * | |
1101 | * @dbg_buf: a buffer of LEB size used for debugging purposes | |
1102 | * @old_zroot: old index root - used by 'dbg_check_old_index()' | |
1103 | * @old_zroot_level: old index root level - used by 'dbg_check_old_index()' | |
1104 | * @old_zroot_sqnum: old index root sqnum - used by 'dbg_check_old_index()' | |
1105 | * @failure_mode: failure mode for recovery testing | |
1106 | * @fail_delay: 0=>don't delay, 1=>delay a time, 2=>delay a number of calls | |
1107 | * @fail_timeout: time in jiffies when delay of failure mode expires | |
1108 | * @fail_cnt: current number of calls to failure mode I/O functions | |
1109 | * @fail_cnt_max: number of calls by which to delay failure mode | |
1110 | */ | |
1111 | struct ubifs_info { | |
1112 | struct super_block *vfs_sb; | |
1113 | struct backing_dev_info bdi; | |
1114 | ||
1115 | ino_t highest_inum; | |
1116 | unsigned int vfs_gen; | |
1117 | unsigned long long max_sqnum; | |
1118 | unsigned long long cmt_no; | |
1119 | spinlock_t cnt_lock; | |
1120 | int fmt_version; | |
1121 | unsigned char uuid[16]; | |
1122 | ||
1123 | int lhead_lnum; | |
1124 | int lhead_offs; | |
1125 | int ltail_lnum; | |
1126 | struct mutex log_mutex; | |
1127 | int min_log_bytes; | |
1128 | long long cmt_bud_bytes; | |
1129 | ||
1130 | struct rb_root buds; | |
1131 | long long bud_bytes; | |
1132 | spinlock_t buds_lock; | |
1133 | int jhead_cnt; | |
1134 | struct ubifs_jhead *jheads; | |
1135 | long long max_bud_bytes; | |
1136 | long long bg_bud_bytes; | |
1137 | struct list_head old_buds; | |
1138 | int max_bud_cnt; | |
1139 | ||
1140 | struct rw_semaphore commit_sem; | |
1141 | int cmt_state; | |
1142 | spinlock_t cs_lock; | |
1143 | wait_queue_head_t cmt_wq; | |
1144 | unsigned int fast_unmount:1; | |
1145 | unsigned int big_lpt:1; | |
1146 | unsigned int check_lpt_free:1; | |
1147 | unsigned int nospace:1; | |
1148 | unsigned int nospace_rp:1; | |
1149 | ||
1150 | struct mutex tnc_mutex; | |
1151 | struct ubifs_zbranch zroot; | |
1152 | struct ubifs_znode *cnext; | |
1153 | struct ubifs_znode *enext; | |
1154 | int *gap_lebs; | |
1155 | void *cbuf; | |
1156 | void *ileb_buf; | |
1157 | int ileb_len; | |
1158 | int ihead_lnum; | |
1159 | int ihead_offs; | |
1160 | int *ilebs; | |
1161 | int ileb_cnt; | |
1162 | int ileb_nxt; | |
1163 | struct rb_root old_idx; | |
1164 | int *bottom_up_buf; | |
1165 | #ifdef CONFIG_UBIFS_FS_DEBUG | |
1166 | int new_ihead_lnum; | |
1167 | int new_ihead_offs; | |
1168 | #endif | |
1169 | ||
1170 | struct ubifs_mst_node *mst_node; | |
1171 | int mst_offs; | |
1172 | struct mutex mst_mutex; | |
1173 | ||
1174 | int log_lebs; | |
1175 | long long log_bytes; | |
1176 | int log_last; | |
1177 | int lpt_lebs; | |
1178 | int lpt_first; | |
1179 | int lpt_last; | |
1180 | int orph_lebs; | |
1181 | int orph_first; | |
1182 | int orph_last; | |
1183 | int main_lebs; | |
1184 | int main_first; | |
1185 | long long main_bytes; | |
1186 | int default_compr; | |
1187 | ||
1188 | uint8_t key_hash_type; | |
1189 | uint32_t (*key_hash)(const char *str, int len); | |
1190 | int key_fmt; | |
1191 | int key_len; | |
1192 | int fanout; | |
1193 | ||
1194 | int min_io_size; | |
1195 | int min_io_shift; | |
1196 | int leb_size; | |
1197 | int half_leb_size; | |
1198 | int leb_cnt; | |
1199 | int max_leb_cnt; | |
1200 | int old_leb_cnt; | |
1201 | int ro_media; | |
1202 | ||
1203 | atomic_long_t dirty_pg_cnt; | |
1204 | atomic_long_t dirty_zn_cnt; | |
1205 | atomic_long_t clean_zn_cnt; | |
1206 | ||
1207 | long long budg_idx_growth; | |
1208 | long long budg_data_growth; | |
1209 | long long budg_dd_growth; | |
1210 | long long budg_uncommitted_idx; | |
1211 | spinlock_t space_lock; | |
1212 | int min_idx_lebs; | |
1213 | unsigned long long old_idx_sz; | |
1214 | unsigned long long calc_idx_sz; | |
1215 | struct ubifs_lp_stats lst; | |
1216 | ||
1217 | int page_budget; | |
1218 | int inode_budget; | |
1219 | int dent_budget; | |
1220 | ||
1221 | int ref_node_alsz; | |
1222 | int mst_node_alsz; | |
1223 | int min_idx_node_sz; | |
1224 | int max_idx_node_sz; | |
1225 | long long max_inode_sz; | |
1226 | int max_znode_sz; | |
1227 | int dead_wm; | |
1228 | int dark_wm; | |
1229 | int block_cnt; | |
1230 | ||
1231 | struct ubifs_node_range ranges[UBIFS_NODE_TYPES_CNT]; | |
1232 | struct ubi_volume_desc *ubi; | |
1233 | struct ubi_device_info di; | |
1234 | struct ubi_volume_info vi; | |
1235 | ||
1236 | struct rb_root orph_tree; | |
1237 | struct list_head orph_list; | |
1238 | struct list_head orph_new; | |
1239 | struct ubifs_orphan *orph_cnext; | |
1240 | struct ubifs_orphan *orph_dnext; | |
1241 | spinlock_t orphan_lock; | |
1242 | void *orph_buf; | |
1243 | int new_orphans; | |
1244 | int cmt_orphans; | |
1245 | int tot_orphans; | |
1246 | int max_orphans; | |
1247 | int ohead_lnum; | |
1248 | int ohead_offs; | |
1249 | int no_orphs; | |
1250 | ||
1251 | struct task_struct *bgt; | |
1252 | char bgt_name[sizeof(BGT_NAME_PATTERN) + 9]; | |
1253 | int need_bgt; | |
1254 | int need_wbuf_sync; | |
1255 | ||
1256 | int gc_lnum; | |
1257 | void *sbuf; | |
1258 | struct list_head idx_gc; | |
1259 | int idx_gc_cnt; | |
1260 | ||
1261 | struct list_head infos_list; | |
1262 | struct mutex umount_mutex; | |
1263 | unsigned int shrinker_run_no; | |
1264 | ||
1265 | int space_bits; | |
1266 | int lpt_lnum_bits; | |
1267 | int lpt_offs_bits; | |
1268 | int lpt_spc_bits; | |
1269 | int pcnt_bits; | |
1270 | int lnum_bits; | |
1271 | int nnode_sz; | |
1272 | int pnode_sz; | |
1273 | int ltab_sz; | |
1274 | int lsave_sz; | |
1275 | int pnode_cnt; | |
1276 | int nnode_cnt; | |
1277 | int lpt_hght; | |
1278 | int pnodes_have; | |
1279 | ||
1280 | struct mutex lp_mutex; | |
1281 | int lpt_lnum; | |
1282 | int lpt_offs; | |
1283 | int nhead_lnum; | |
1284 | int nhead_offs; | |
1285 | int lpt_drty_flgs; | |
1286 | int dirty_nn_cnt; | |
1287 | int dirty_pn_cnt; | |
1288 | long long lpt_sz; | |
1289 | void *lpt_nod_buf; | |
1290 | void *lpt_buf; | |
1291 | struct ubifs_nnode *nroot; | |
1292 | struct ubifs_cnode *lpt_cnext; | |
1293 | struct ubifs_lpt_heap lpt_heap[LPROPS_HEAP_CNT]; | |
1294 | struct ubifs_lpt_heap dirty_idx; | |
1295 | struct list_head uncat_list; | |
1296 | struct list_head empty_list; | |
1297 | struct list_head freeable_list; | |
1298 | struct list_head frdi_idx_list; | |
1299 | int freeable_cnt; | |
1300 | ||
1301 | int ltab_lnum; | |
1302 | int ltab_offs; | |
1303 | struct ubifs_lpt_lprops *ltab; | |
1304 | struct ubifs_lpt_lprops *ltab_cmt; | |
1305 | int lsave_cnt; | |
1306 | int lsave_lnum; | |
1307 | int lsave_offs; | |
1308 | int *lsave; | |
1309 | int lscan_lnum; | |
1310 | ||
1311 | long long rp_size; | |
1312 | long long report_rp_size; | |
1313 | uid_t rp_uid; | |
1314 | gid_t rp_gid; | |
1315 | ||
1316 | /* The below fields are used only during mounting and re-mounting */ | |
1317 | int empty; | |
1318 | struct rb_root replay_tree; | |
1319 | struct list_head replay_list; | |
1320 | struct list_head replay_buds; | |
1321 | unsigned long long cs_sqnum; | |
1322 | unsigned long long replay_sqnum; | |
1323 | int need_recovery; | |
1324 | int replaying; | |
1325 | struct list_head unclean_leb_list; | |
1326 | struct ubifs_mst_node *rcvrd_mst_node; | |
1327 | struct rb_root size_tree; | |
1328 | int remounting_rw; | |
1329 | struct ubifs_mount_opts mount_opts; | |
1330 | ||
1331 | #ifdef CONFIG_UBIFS_FS_DEBUG | |
1332 | void *dbg_buf; | |
1333 | struct ubifs_zbranch old_zroot; | |
1334 | int old_zroot_level; | |
1335 | unsigned long long old_zroot_sqnum; | |
1336 | int failure_mode; | |
1337 | int fail_delay; | |
1338 | unsigned long fail_timeout; | |
1339 | unsigned int fail_cnt; | |
1340 | unsigned int fail_cnt_max; | |
1341 | #endif | |
1342 | }; | |
1343 | ||
1344 | extern struct list_head ubifs_infos; | |
1345 | extern spinlock_t ubifs_infos_lock; | |
1346 | extern atomic_long_t ubifs_clean_zn_cnt; | |
1347 | extern struct kmem_cache *ubifs_inode_slab; | |
1348 | extern struct super_operations ubifs_super_operations; | |
1349 | extern struct address_space_operations ubifs_file_address_operations; | |
1350 | extern struct file_operations ubifs_file_operations; | |
1351 | extern struct inode_operations ubifs_file_inode_operations; | |
1352 | extern struct file_operations ubifs_dir_operations; | |
1353 | extern struct inode_operations ubifs_dir_inode_operations; | |
1354 | extern struct inode_operations ubifs_symlink_inode_operations; | |
1355 | extern struct backing_dev_info ubifs_backing_dev_info; | |
1356 | extern struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT]; | |
1357 | ||
1358 | /* io.c */ | |
ff46d7b3 | 1359 | void ubifs_ro_mode(struct ubifs_info *c, int err); |
1e51764a AB |
1360 | int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len); |
1361 | int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs, | |
1362 | int dtype); | |
1363 | int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf); | |
1364 | int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len, | |
1365 | int lnum, int offs); | |
1366 | int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len, | |
1367 | int lnum, int offs); | |
1368 | int ubifs_write_node(struct ubifs_info *c, void *node, int len, int lnum, | |
1369 | int offs, int dtype); | |
1370 | int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum, | |
1371 | int offs, int quiet); | |
1372 | void ubifs_prepare_node(struct ubifs_info *c, void *buf, int len, int pad); | |
1373 | void ubifs_prep_grp_node(struct ubifs_info *c, void *node, int len, int last); | |
1374 | int ubifs_io_init(struct ubifs_info *c); | |
1375 | void ubifs_pad(const struct ubifs_info *c, void *buf, int pad); | |
1376 | int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf); | |
1377 | int ubifs_bg_wbufs_sync(struct ubifs_info *c); | |
1378 | void ubifs_wbuf_add_ino_nolock(struct ubifs_wbuf *wbuf, ino_t inum); | |
1379 | int ubifs_sync_wbufs_by_inode(struct ubifs_info *c, struct inode *inode); | |
1380 | ||
1381 | /* scan.c */ | |
1382 | struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum, | |
1383 | int offs, void *sbuf); | |
1384 | void ubifs_scan_destroy(struct ubifs_scan_leb *sleb); | |
1385 | int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum, | |
1386 | int offs, int quiet); | |
1387 | struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum, | |
1388 | int offs, void *sbuf); | |
1389 | void ubifs_end_scan(const struct ubifs_info *c, struct ubifs_scan_leb *sleb, | |
1390 | int lnum, int offs); | |
1391 | int ubifs_add_snod(const struct ubifs_info *c, struct ubifs_scan_leb *sleb, | |
1392 | void *buf, int offs); | |
1393 | void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs, | |
1394 | void *buf); | |
1395 | ||
1396 | /* log.c */ | |
1397 | void ubifs_add_bud(struct ubifs_info *c, struct ubifs_bud *bud); | |
1398 | void ubifs_create_buds_lists(struct ubifs_info *c); | |
1399 | int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs); | |
1400 | struct ubifs_bud *ubifs_search_bud(struct ubifs_info *c, int lnum); | |
1401 | struct ubifs_wbuf *ubifs_get_wbuf(struct ubifs_info *c, int lnum); | |
1402 | int ubifs_log_start_commit(struct ubifs_info *c, int *ltail_lnum); | |
1403 | int ubifs_log_end_commit(struct ubifs_info *c, int new_ltail_lnum); | |
1404 | int ubifs_log_post_commit(struct ubifs_info *c, int old_ltail_lnum); | |
1405 | int ubifs_consolidate_log(struct ubifs_info *c); | |
1406 | ||
1407 | /* journal.c */ | |
1408 | int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir, | |
1409 | const struct qstr *nm, const struct inode *inode, | |
1410 | int deletion, int xent); | |
1411 | int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode, | |
1412 | const union ubifs_key *key, const void *buf, int len); | |
1f28681a | 1413 | int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode); |
de94eb55 | 1414 | int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode); |
1e51764a AB |
1415 | int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir, |
1416 | const struct dentry *old_dentry, | |
1417 | const struct inode *new_dir, | |
1418 | const struct dentry *new_dentry, int sync); | |
1419 | int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode, | |
1420 | loff_t old_size, loff_t new_size); | |
1421 | int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host, | |
1422 | const struct inode *inode, const struct qstr *nm); | |
1423 | int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode1, | |
1424 | const struct inode *inode2); | |
1425 | ||
1426 | /* budget.c */ | |
1427 | int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req); | |
1428 | void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req); | |
1429 | void ubifs_release_dirty_inode_budget(struct ubifs_info *c, | |
1430 | struct ubifs_inode *ui); | |
1431 | int ubifs_budget_inode_op(struct ubifs_info *c, struct inode *inode, | |
1432 | struct ubifs_budget_req *req); | |
1433 | void ubifs_release_ino_dirty(struct ubifs_info *c, struct inode *inode, | |
1434 | struct ubifs_budget_req *req); | |
1435 | void ubifs_cancel_ino_op(struct ubifs_info *c, struct inode *inode, | |
1436 | struct ubifs_budget_req *req); | |
1437 | long long ubifs_budg_get_free_space(struct ubifs_info *c); | |
1438 | int ubifs_calc_min_idx_lebs(struct ubifs_info *c); | |
1439 | void ubifs_convert_page_budget(struct ubifs_info *c); | |
1440 | long long ubifs_calc_available(const struct ubifs_info *c, int min_idx_lebs); | |
1441 | ||
1442 | /* find.c */ | |
1443 | int ubifs_find_free_space(struct ubifs_info *c, int min_space, int *free, | |
1444 | int squeeze); | |
1445 | int ubifs_find_free_leb_for_idx(struct ubifs_info *c); | |
1446 | int ubifs_find_dirty_leb(struct ubifs_info *c, struct ubifs_lprops *ret_lp, | |
1447 | int min_space, int pick_free); | |
1448 | int ubifs_find_dirty_idx_leb(struct ubifs_info *c); | |
1449 | int ubifs_save_dirty_idx_lnums(struct ubifs_info *c); | |
1450 | ||
1451 | /* tnc.c */ | |
1452 | int ubifs_lookup_level0(struct ubifs_info *c, const union ubifs_key *key, | |
1453 | struct ubifs_znode **zn, int *n); | |
1454 | int ubifs_tnc_lookup(struct ubifs_info *c, const union ubifs_key *key, | |
1455 | void *node); | |
1456 | int ubifs_tnc_lookup_nm(struct ubifs_info *c, const union ubifs_key *key, | |
1457 | void *node, const struct qstr *nm); | |
1458 | int ubifs_tnc_locate(struct ubifs_info *c, const union ubifs_key *key, | |
1459 | void *node, int *lnum, int *offs); | |
1460 | int ubifs_tnc_add(struct ubifs_info *c, const union ubifs_key *key, int lnum, | |
1461 | int offs, int len); | |
1462 | int ubifs_tnc_replace(struct ubifs_info *c, const union ubifs_key *key, | |
1463 | int old_lnum, int old_offs, int lnum, int offs, int len); | |
1464 | int ubifs_tnc_add_nm(struct ubifs_info *c, const union ubifs_key *key, | |
1465 | int lnum, int offs, int len, const struct qstr *nm); | |
1466 | int ubifs_tnc_remove(struct ubifs_info *c, const union ubifs_key *key); | |
1467 | int ubifs_tnc_remove_nm(struct ubifs_info *c, const union ubifs_key *key, | |
1468 | const struct qstr *nm); | |
1469 | int ubifs_tnc_remove_range(struct ubifs_info *c, union ubifs_key *from_key, | |
1470 | union ubifs_key *to_key); | |
1471 | int ubifs_tnc_remove_ino(struct ubifs_info *c, ino_t inum); | |
1472 | struct ubifs_dent_node *ubifs_tnc_next_ent(struct ubifs_info *c, | |
1473 | union ubifs_key *key, | |
1474 | const struct qstr *nm); | |
1475 | void ubifs_tnc_close(struct ubifs_info *c); | |
1476 | int ubifs_tnc_has_node(struct ubifs_info *c, union ubifs_key *key, int level, | |
1477 | int lnum, int offs, int is_idx); | |
1478 | int ubifs_dirty_idx_node(struct ubifs_info *c, union ubifs_key *key, int level, | |
1479 | int lnum, int offs); | |
1480 | /* Shared by tnc.c for tnc_commit.c */ | |
1481 | void destroy_old_idx(struct ubifs_info *c); | |
1482 | int is_idx_node_in_tnc(struct ubifs_info *c, union ubifs_key *key, int level, | |
1483 | int lnum, int offs); | |
1484 | int insert_old_idx_znode(struct ubifs_info *c, struct ubifs_znode *znode); | |
1485 | ||
1486 | /* tnc_misc.c */ | |
1487 | struct ubifs_znode *ubifs_tnc_levelorder_next(struct ubifs_znode *zr, | |
1488 | struct ubifs_znode *znode); | |
1489 | int ubifs_search_zbranch(const struct ubifs_info *c, | |
1490 | const struct ubifs_znode *znode, | |
1491 | const union ubifs_key *key, int *n); | |
1492 | struct ubifs_znode *ubifs_tnc_postorder_first(struct ubifs_znode *znode); | |
1493 | struct ubifs_znode *ubifs_tnc_postorder_next(struct ubifs_znode *znode); | |
1494 | long ubifs_destroy_tnc_subtree(struct ubifs_znode *zr); | |
1495 | struct ubifs_znode *ubifs_load_znode(struct ubifs_info *c, | |
1496 | struct ubifs_zbranch *zbr, | |
1497 | struct ubifs_znode *parent, int iip); | |
1498 | int ubifs_tnc_read_node(struct ubifs_info *c, struct ubifs_zbranch *zbr, | |
1499 | void *node); | |
1500 | ||
1501 | /* tnc_commit.c */ | |
1502 | int ubifs_tnc_start_commit(struct ubifs_info *c, struct ubifs_zbranch *zroot); | |
1503 | int ubifs_tnc_end_commit(struct ubifs_info *c); | |
1504 | ||
1505 | /* shrinker.c */ | |
1506 | int ubifs_shrinker(int nr_to_scan, gfp_t gfp_mask); | |
1507 | ||
1508 | /* commit.c */ | |
1509 | int ubifs_bg_thread(void *info); | |
1510 | void ubifs_commit_required(struct ubifs_info *c); | |
1511 | void ubifs_request_bg_commit(struct ubifs_info *c); | |
1512 | int ubifs_run_commit(struct ubifs_info *c); | |
1513 | void ubifs_recovery_commit(struct ubifs_info *c); | |
1514 | int ubifs_gc_should_commit(struct ubifs_info *c); | |
1515 | void ubifs_wait_for_commit(struct ubifs_info *c); | |
1516 | ||
1517 | /* master.c */ | |
1518 | int ubifs_read_master(struct ubifs_info *c); | |
1519 | int ubifs_write_master(struct ubifs_info *c); | |
1520 | ||
1521 | /* sb.c */ | |
1522 | int ubifs_read_superblock(struct ubifs_info *c); | |
1523 | struct ubifs_sb_node *ubifs_read_sb_node(struct ubifs_info *c); | |
1524 | int ubifs_write_sb_node(struct ubifs_info *c, struct ubifs_sb_node *sup); | |
1525 | ||
1526 | /* replay.c */ | |
1527 | int ubifs_validate_entry(struct ubifs_info *c, | |
1528 | const struct ubifs_dent_node *dent); | |
1529 | int ubifs_replay_journal(struct ubifs_info *c); | |
1530 | ||
1531 | /* gc.c */ | |
1532 | int ubifs_garbage_collect(struct ubifs_info *c, int anyway); | |
1533 | int ubifs_gc_start_commit(struct ubifs_info *c); | |
1534 | int ubifs_gc_end_commit(struct ubifs_info *c); | |
1535 | void ubifs_destroy_idx_gc(struct ubifs_info *c); | |
1536 | int ubifs_get_idx_gc_leb(struct ubifs_info *c); | |
1537 | int ubifs_garbage_collect_leb(struct ubifs_info *c, struct ubifs_lprops *lp); | |
1538 | ||
1539 | /* orphan.c */ | |
1540 | int ubifs_add_orphan(struct ubifs_info *c, ino_t inum); | |
1541 | void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum); | |
1542 | int ubifs_orphan_start_commit(struct ubifs_info *c); | |
1543 | int ubifs_orphan_end_commit(struct ubifs_info *c); | |
1544 | int ubifs_mount_orphans(struct ubifs_info *c, int unclean, int read_only); | |
1545 | ||
1546 | /* lpt.c */ | |
1547 | int ubifs_calc_lpt_geom(struct ubifs_info *c); | |
1548 | int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first, | |
1549 | int *lpt_lebs, int *big_lpt); | |
1550 | int ubifs_lpt_init(struct ubifs_info *c, int rd, int wr); | |
1551 | struct ubifs_lprops *ubifs_lpt_lookup(struct ubifs_info *c, int lnum); | |
1552 | struct ubifs_lprops *ubifs_lpt_lookup_dirty(struct ubifs_info *c, int lnum); | |
1553 | int ubifs_lpt_scan_nolock(struct ubifs_info *c, int start_lnum, int end_lnum, | |
1554 | ubifs_lpt_scan_callback scan_cb, void *data); | |
1555 | ||
1556 | /* Shared by lpt.c for lpt_commit.c */ | |
1557 | void ubifs_pack_lsave(struct ubifs_info *c, void *buf, int *lsave); | |
1558 | void ubifs_pack_ltab(struct ubifs_info *c, void *buf, | |
1559 | struct ubifs_lpt_lprops *ltab); | |
1560 | void ubifs_pack_pnode(struct ubifs_info *c, void *buf, | |
1561 | struct ubifs_pnode *pnode); | |
1562 | void ubifs_pack_nnode(struct ubifs_info *c, void *buf, | |
1563 | struct ubifs_nnode *nnode); | |
1564 | struct ubifs_pnode *ubifs_get_pnode(struct ubifs_info *c, | |
1565 | struct ubifs_nnode *parent, int iip); | |
1566 | struct ubifs_nnode *ubifs_get_nnode(struct ubifs_info *c, | |
1567 | struct ubifs_nnode *parent, int iip); | |
1568 | int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip); | |
1569 | void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty); | |
1570 | void ubifs_add_nnode_dirt(struct ubifs_info *c, struct ubifs_nnode *nnode); | |
1571 | uint32_t ubifs_unpack_bits(uint8_t **addr, int *pos, int nrbits); | |
1572 | struct ubifs_nnode *ubifs_first_nnode(struct ubifs_info *c, int *hght); | |
1573 | ||
1574 | /* lpt_commit.c */ | |
1575 | int ubifs_lpt_start_commit(struct ubifs_info *c); | |
1576 | int ubifs_lpt_end_commit(struct ubifs_info *c); | |
1577 | int ubifs_lpt_post_commit(struct ubifs_info *c); | |
1578 | void ubifs_lpt_free(struct ubifs_info *c, int wr_only); | |
1579 | ||
1580 | /* lprops.c */ | |
1581 | void ubifs_get_lprops(struct ubifs_info *c); | |
1582 | const struct ubifs_lprops *ubifs_change_lp(struct ubifs_info *c, | |
1583 | const struct ubifs_lprops *lp, | |
1584 | int free, int dirty, int flags, | |
1585 | int idx_gc_cnt); | |
1586 | void ubifs_release_lprops(struct ubifs_info *c); | |
1587 | void ubifs_get_lp_stats(struct ubifs_info *c, struct ubifs_lp_stats *stats); | |
1588 | void ubifs_add_to_cat(struct ubifs_info *c, struct ubifs_lprops *lprops, | |
1589 | int cat); | |
1590 | void ubifs_replace_cat(struct ubifs_info *c, struct ubifs_lprops *old_lprops, | |
1591 | struct ubifs_lprops *new_lprops); | |
1592 | void ubifs_ensure_cat(struct ubifs_info *c, struct ubifs_lprops *lprops); | |
1593 | int ubifs_categorize_lprops(const struct ubifs_info *c, | |
1594 | const struct ubifs_lprops *lprops); | |
1595 | int ubifs_change_one_lp(struct ubifs_info *c, int lnum, int free, int dirty, | |
1596 | int flags_set, int flags_clean, int idx_gc_cnt); | |
1597 | int ubifs_update_one_lp(struct ubifs_info *c, int lnum, int free, int dirty, | |
1598 | int flags_set, int flags_clean); | |
1599 | int ubifs_read_one_lp(struct ubifs_info *c, int lnum, struct ubifs_lprops *lp); | |
1600 | const struct ubifs_lprops *ubifs_fast_find_free(struct ubifs_info *c); | |
1601 | const struct ubifs_lprops *ubifs_fast_find_empty(struct ubifs_info *c); | |
1602 | const struct ubifs_lprops *ubifs_fast_find_freeable(struct ubifs_info *c); | |
1603 | const struct ubifs_lprops *ubifs_fast_find_frdi_idx(struct ubifs_info *c); | |
1604 | ||
1605 | /* file.c */ | |
1606 | int ubifs_fsync(struct file *file, struct dentry *dentry, int datasync); | |
1607 | int ubifs_setattr(struct dentry *dentry, struct iattr *attr); | |
1608 | ||
1609 | /* dir.c */ | |
1610 | struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir, | |
1611 | int mode); | |
1612 | int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry, | |
1613 | struct kstat *stat); | |
1614 | ||
1615 | /* xattr.c */ | |
1616 | int ubifs_setxattr(struct dentry *dentry, const char *name, | |
1617 | const void *value, size_t size, int flags); | |
1618 | ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf, | |
1619 | size_t size); | |
1620 | ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size); | |
1621 | int ubifs_removexattr(struct dentry *dentry, const char *name); | |
1622 | ||
1623 | /* super.c */ | |
1624 | struct inode *ubifs_iget(struct super_block *sb, unsigned long inum); | |
1625 | ||
1626 | /* recovery.c */ | |
1627 | int ubifs_recover_master_node(struct ubifs_info *c); | |
1628 | int ubifs_write_rcvrd_mst_node(struct ubifs_info *c); | |
1629 | struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum, | |
1630 | int offs, void *sbuf, int grouped); | |
1631 | struct ubifs_scan_leb *ubifs_recover_log_leb(struct ubifs_info *c, int lnum, | |
1632 | int offs, void *sbuf); | |
1633 | int ubifs_recover_inl_heads(const struct ubifs_info *c, void *sbuf); | |
1634 | int ubifs_clean_lebs(const struct ubifs_info *c, void *sbuf); | |
1635 | int ubifs_rcvry_gc_commit(struct ubifs_info *c); | |
1636 | int ubifs_recover_size_accum(struct ubifs_info *c, union ubifs_key *key, | |
1637 | int deletion, loff_t new_size); | |
1638 | int ubifs_recover_size(struct ubifs_info *c); | |
1639 | void ubifs_destroy_size_tree(struct ubifs_info *c); | |
1640 | ||
1641 | /* ioctl.c */ | |
1642 | long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); | |
1643 | void ubifs_set_inode_flags(struct inode *inode); | |
1644 | #ifdef CONFIG_COMPAT | |
1645 | long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg); | |
1646 | #endif | |
1647 | ||
1648 | /* compressor.c */ | |
1649 | int __init ubifs_compressors_init(void); | |
1650 | void __exit ubifs_compressors_exit(void); | |
1651 | void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len, | |
1652 | int *compr_type); | |
1653 | int ubifs_decompress(const void *buf, int len, void *out, int *out_len, | |
1654 | int compr_type); | |
1655 | ||
1656 | #include "debug.h" | |
1657 | #include "misc.h" | |
1658 | #include "key.h" | |
1659 | ||
1660 | #endif /* !__UBIFS_H__ */ |