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