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