2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation
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.
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
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
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
26 #include <asm/div64.h>
27 #include <linux/statfs.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 <linux/security.h>
40 #include <linux/xattr.h>
41 #include <linux/random.h>
42 #include <crypto/hash_info.h>
43 #include <crypto/hash.h>
44 #include <crypto/algapi.h>
46 #include <linux/fscrypt.h>
48 #include "ubifs-media.h"
50 /* Version of this UBIFS implementation */
51 #define UBIFS_VERSION 1
53 /* UBIFS file system VFS magic number */
54 #define UBIFS_SUPER_MAGIC 0x24051905
56 /* Number of UBIFS blocks per VFS page */
57 #define UBIFS_BLOCKS_PER_PAGE (PAGE_SIZE / UBIFS_BLOCK_SIZE)
58 #define UBIFS_BLOCKS_PER_PAGE_SHIFT (PAGE_SHIFT - UBIFS_BLOCK_SHIFT)
60 /* "File system end of life" sequence number watermark */
61 #define SQNUM_WARN_WATERMARK 0xFFFFFFFF00000000ULL
62 #define SQNUM_WATERMARK 0xFFFFFFFFFF000000ULL
65 * Minimum amount of LEBs reserved for the index. At present the index needs at
66 * least 2 LEBs: one for the index head and one for in-the-gaps method (which
67 * currently does not cater for the index head and so excludes it from
70 #define MIN_INDEX_LEBS 2
72 /* Minimum amount of data UBIFS writes to the flash */
73 #define MIN_WRITE_SZ (UBIFS_DATA_NODE_SZ + 8)
76 * Currently we do not support inode number overlapping and re-using, so this
77 * watermark defines dangerous inode number level. This should be fixed later,
78 * although it is difficult to exceed current limit. Another option is to use
79 * 64-bit inode numbers, but this means more overhead.
81 #define INUM_WARN_WATERMARK 0xFFF00000
82 #define INUM_WATERMARK 0xFFFFFF00
84 /* Maximum number of entries in each LPT (LEB category) heap */
85 #define LPT_HEAP_SZ 256
88 * Background thread name pattern. The numbers are UBI device and volume
91 #define BGT_NAME_PATTERN "ubifs_bgt%d_%d"
93 /* Maximum possible inode number (only 32-bit inodes are supported now) */
94 #define MAX_INUM 0xFFFFFFFF
96 /* Number of non-data journal heads */
97 #define NONDATA_JHEADS_CNT 2
99 /* Shorter names for journal head numbers for internal usage */
100 #define GCHD UBIFS_GC_HEAD
101 #define BASEHD UBIFS_BASE_HEAD
102 #define DATAHD UBIFS_DATA_HEAD
104 /* 'No change' value for 'ubifs_change_lp()' */
105 #define LPROPS_NC 0x80000001
108 * There is no notion of truncation key because truncation nodes do not exist
109 * in TNC. However, when replaying, it is handy to introduce fake "truncation"
110 * keys for truncation nodes because the code becomes simpler. So we define
111 * %UBIFS_TRUN_KEY type.
113 * But otherwise, out of the journal reply scope, the truncation keys are
116 #define UBIFS_TRUN_KEY UBIFS_KEY_TYPES_CNT
117 #define UBIFS_INVALID_KEY UBIFS_KEY_TYPES_CNT
120 * How much a directory entry/extended attribute entry adds to the parent/host
123 #define CALC_DENT_SIZE(name_len) ALIGN(UBIFS_DENT_NODE_SZ + (name_len) + 1, 8)
125 /* How much an extended attribute adds to the host inode */
126 #define CALC_XATTR_BYTES(data_len) ALIGN(UBIFS_INO_NODE_SZ + (data_len) + 1, 8)
129 * Znodes which were not touched for 'OLD_ZNODE_AGE' seconds are considered
130 * "old", and znode which were touched last 'YOUNG_ZNODE_AGE' seconds ago are
131 * considered "young". This is used by shrinker when selecting znode to trim
134 #define OLD_ZNODE_AGE 20
135 #define YOUNG_ZNODE_AGE 5
138 * Some compressors, like LZO, may end up with more data then the input buffer.
139 * So UBIFS always allocates larger output buffer, to be sure the compressor
140 * will not corrupt memory in case of worst case compression.
142 #define WORST_COMPR_FACTOR 2
144 #ifdef CONFIG_FS_ENCRYPTION
145 #define UBIFS_CIPHER_BLOCK_SIZE FS_CRYPTO_BLOCK_SIZE
147 #define UBIFS_CIPHER_BLOCK_SIZE 0
151 * How much memory is needed for a buffer where we compress a data node.
153 #define COMPRESSED_DATA_NODE_BUF_SZ \
154 (UBIFS_DATA_NODE_SZ + UBIFS_BLOCK_SIZE * WORST_COMPR_FACTOR)
156 /* Maximum expected tree height for use by bottom_up_buf */
157 #define BOTTOM_UP_HEIGHT 64
159 /* Maximum number of data nodes to bulk-read */
160 #define UBIFS_MAX_BULK_READ 32
162 #ifdef CONFIG_UBIFS_FS_AUTHENTICATION
163 #define UBIFS_HASH_ARR_SZ UBIFS_MAX_HASH_LEN
164 #define UBIFS_HMAC_ARR_SZ UBIFS_MAX_HMAC_LEN
166 #define UBIFS_HASH_ARR_SZ 0
167 #define UBIFS_HMAC_ARR_SZ 0
171 * Lockdep classes for UBIFS inode @ui_mutex.
181 * Znode flags (actually, bit numbers which store the flags).
183 * DIRTY_ZNODE: znode is dirty
184 * COW_ZNODE: znode is being committed and a new instance of this znode has to
185 * be created before changing this znode
186 * OBSOLETE_ZNODE: znode is obsolete, which means it was deleted, but it is
187 * still in the commit list and the ongoing commit operation
188 * will commit it, and delete this znode after it is done
199 * COMMIT_RESTING: commit is not wanted
200 * COMMIT_BACKGROUND: background commit has been requested
201 * COMMIT_REQUIRED: commit is required
202 * COMMIT_RUNNING_BACKGROUND: background commit is running
203 * COMMIT_RUNNING_REQUIRED: commit is running and it is required
204 * COMMIT_BROKEN: commit failed
210 COMMIT_RUNNING_BACKGROUND
,
211 COMMIT_RUNNING_REQUIRED
,
216 * 'ubifs_scan_a_node()' return values.
218 * SCANNED_GARBAGE: scanned garbage
219 * SCANNED_EMPTY_SPACE: scanned empty space
220 * SCANNED_A_NODE: scanned a valid node
221 * SCANNED_A_CORRUPT_NODE: scanned a corrupted node
222 * SCANNED_A_BAD_PAD_NODE: scanned a padding node with invalid pad length
224 * Greater than zero means: 'scanned that number of padding bytes'
228 SCANNED_EMPTY_SPACE
= -1,
230 SCANNED_A_CORRUPT_NODE
= -3,
231 SCANNED_A_BAD_PAD_NODE
= -4,
235 * LPT cnode flag bits.
237 * DIRTY_CNODE: cnode is dirty
238 * OBSOLETE_CNODE: cnode is being committed and has been copied (or deleted),
239 * so it can (and must) be freed when the commit is finished
240 * COW_CNODE: cnode is being committed and must be copied before writing
249 * Dirty flag bits (lpt_drty_flgs) for LPT special nodes.
251 * LTAB_DIRTY: ltab node is dirty
252 * LSAVE_DIRTY: lsave node is dirty
260 * Return codes used by the garbage collector.
261 * @LEB_FREED: the logical eraseblock was freed and is ready to use
262 * @LEB_FREED_IDX: indexing LEB was freed and can be used only after the commit
263 * @LEB_RETAINED: the logical eraseblock was freed and retained for GC purposes
272 * Action taken upon a failed ubifs_assert().
273 * @ASSACT_REPORT: just report the failed assertion
274 * @ASSACT_RO: switch to read-only mode
275 * @ASSACT_PANIC: call BUG() and possible panic the kernel
284 * struct ubifs_old_idx - index node obsoleted since last commit start.
286 * @lnum: LEB number of obsoleted index node
287 * @offs: offset of obsoleted index node
289 struct ubifs_old_idx
{
295 /* The below union makes it easier to deal with keys */
297 uint8_t u8
[UBIFS_SK_LEN
];
298 uint32_t u32
[UBIFS_SK_LEN
/4];
299 uint64_t u64
[UBIFS_SK_LEN
/8];
300 __le32 j32
[UBIFS_SK_LEN
/4];
304 * struct ubifs_scan_node - UBIFS scanned node information.
305 * @list: list of scanned nodes
306 * @key: key of node scanned (if it has one)
307 * @sqnum: sequence number
308 * @type: type of node scanned
309 * @offs: offset with LEB of node scanned
310 * @len: length of node scanned
313 struct ubifs_scan_node
{
314 struct list_head list
;
316 unsigned long long sqnum
;
324 * struct ubifs_scan_leb - UBIFS scanned LEB information.
325 * @lnum: logical eraseblock number
326 * @nodes_cnt: number of nodes scanned
327 * @nodes: list of struct ubifs_scan_node
328 * @endpt: end point (and therefore the start of empty space)
329 * @buf: buffer containing entire LEB scanned
331 struct ubifs_scan_leb
{
334 struct list_head nodes
;
340 * struct ubifs_gced_idx_leb - garbage-collected indexing LEB.
343 * @unmap: OK to unmap this LEB
345 * This data structure is used to temporary store garbage-collected indexing
346 * LEBs - they are not released immediately, but only after the next commit.
347 * This is needed to guarantee recoverability.
349 struct ubifs_gced_idx_leb
{
350 struct list_head list
;
356 * struct ubifs_inode - UBIFS in-memory inode description.
357 * @vfs_inode: VFS inode description object
358 * @creat_sqnum: sequence number at time of creation
359 * @del_cmtno: commit number corresponding to the time the inode was deleted,
360 * protected by @c->commit_sem;
361 * @xattr_size: summarized size of all extended attributes in bytes
362 * @xattr_cnt: count of extended attributes this inode has
363 * @xattr_names: sum of lengths of all extended attribute names belonging to
365 * @dirty: non-zero if the inode is dirty
366 * @xattr: non-zero if this is an extended attribute inode
367 * @bulk_read: non-zero if bulk-read should be used
368 * @ui_mutex: serializes inode write-back with the rest of VFS operations,
369 * serializes "clean <-> dirty" state changes, serializes bulk-read,
370 * protects @dirty, @bulk_read, @ui_size, and @xattr_size
371 * @ui_lock: protects @synced_i_size
372 * @synced_i_size: synchronized size of inode, i.e. the value of inode size
373 * currently stored on the flash; used only for regular file
375 * @ui_size: inode size used by UBIFS when writing to flash
376 * @flags: inode flags (@UBIFS_COMPR_FL, etc)
377 * @compr_type: default compression type used for this inode
378 * @last_page_read: page number of last page read (for bulk read)
379 * @read_in_a_row: number of consecutive pages read in a row (for bulk read)
380 * @data_len: length of the data attached to the inode
381 * @data: inode's data
383 * @ui_mutex exists for two main reasons. At first it prevents inodes from
384 * being written back while UBIFS changing them, being in the middle of an VFS
385 * operation. This way UBIFS makes sure the inode fields are consistent. For
386 * example, in 'ubifs_rename()' we change 3 inodes simultaneously, and
387 * write-back must not write any of them before we have finished.
389 * The second reason is budgeting - UBIFS has to budget all operations. If an
390 * operation is going to mark an inode dirty, it has to allocate budget for
391 * this. It cannot just mark it dirty because there is no guarantee there will
392 * be enough flash space to write the inode back later. This means UBIFS has
393 * to have full control over inode "clean <-> dirty" transitions (and pages
394 * actually). But unfortunately, VFS marks inodes dirty in many places, and it
395 * does not ask the file-system if it is allowed to do so (there is a notifier,
396 * but it is not enough), i.e., there is no mechanism to synchronize with this.
397 * So UBIFS has its own inode dirty flag and its own mutex to serialize
398 * "clean <-> dirty" transitions.
400 * The @synced_i_size field is used to make sure we never write pages which are
401 * beyond last synchronized inode size. See 'ubifs_writepage()' for more
404 * The @ui_size is a "shadow" variable for @inode->i_size and UBIFS uses
405 * @ui_size instead of @inode->i_size. The reason for this is that UBIFS cannot
406 * make sure @inode->i_size is always changed under @ui_mutex, because it
407 * cannot call 'truncate_setsize()' with @ui_mutex locked, because it would
408 * deadlock with 'ubifs_writepage()' (see file.c). All the other inode fields
409 * are changed under @ui_mutex, so they do not need "shadow" fields. Note, one
410 * could consider to rework locking and base it on "shadow" fields.
413 struct inode vfs_inode
;
414 unsigned long long creat_sqnum
;
415 unsigned long long del_cmtno
;
416 unsigned int xattr_size
;
417 unsigned int xattr_cnt
;
418 unsigned int xattr_names
;
419 unsigned int dirty
:1;
420 unsigned int xattr
:1;
421 unsigned int bulk_read
:1;
422 unsigned int compr_type
:2;
423 struct mutex ui_mutex
;
425 loff_t synced_i_size
;
428 pgoff_t last_page_read
;
429 pgoff_t read_in_a_row
;
435 * struct ubifs_unclean_leb - records a LEB recovered under read-only mode.
437 * @lnum: LEB number of recovered LEB
438 * @endpt: offset where recovery ended
440 * This structure records a LEB identified during recovery that needs to be
441 * cleaned but was not because UBIFS was mounted read-only. The information
442 * is used to clean the LEB when remounting to read-write mode.
444 struct ubifs_unclean_leb
{
445 struct list_head list
;
451 * LEB properties flags.
453 * LPROPS_UNCAT: not categorized
454 * LPROPS_DIRTY: dirty > free, dirty >= @c->dead_wm, not index
455 * LPROPS_DIRTY_IDX: dirty + free > @c->min_idx_node_sze and index
456 * LPROPS_FREE: free > 0, dirty < @c->dead_wm, not empty, not index
457 * LPROPS_HEAP_CNT: number of heaps used for storing categorized LEBs
458 * LPROPS_EMPTY: LEB is empty, not taken
459 * LPROPS_FREEABLE: free + dirty == leb_size, not index, not taken
460 * LPROPS_FRDI_IDX: free + dirty == leb_size and index, may be taken
461 * LPROPS_CAT_MASK: mask for the LEB categories above
462 * LPROPS_TAKEN: LEB was taken (this flag is not saved on the media)
463 * LPROPS_INDEX: LEB contains indexing nodes (this flag also exists on flash)
468 LPROPS_DIRTY_IDX
= 2,
474 LPROPS_CAT_MASK
= 15,
480 * struct ubifs_lprops - logical eraseblock properties.
481 * @free: amount of free space in bytes
482 * @dirty: amount of dirty space in bytes
483 * @flags: LEB properties flags (see above)
485 * @list: list of same-category lprops (for LPROPS_EMPTY and LPROPS_FREEABLE)
486 * @hpos: heap position in heap of same-category lprops (other categories)
488 struct ubifs_lprops
{
494 struct list_head list
;
500 * struct ubifs_lpt_lprops - LPT logical eraseblock properties.
501 * @free: amount of free space in bytes
502 * @dirty: amount of dirty space in bytes
503 * @tgc: trivial GC flag (1 => unmap after commit end)
504 * @cmt: commit flag (1 => reserved for commit)
506 struct ubifs_lpt_lprops
{
514 * struct ubifs_lp_stats - statistics of eraseblocks in the main area.
515 * @empty_lebs: number of empty LEBs
516 * @taken_empty_lebs: number of taken LEBs
517 * @idx_lebs: number of indexing LEBs
518 * @total_free: total free space in bytes (includes all LEBs)
519 * @total_dirty: total dirty space in bytes (includes all LEBs)
520 * @total_used: total used space in bytes (does not include index LEBs)
521 * @total_dead: total dead space in bytes (does not include index LEBs)
522 * @total_dark: total dark space in bytes (does not include index LEBs)
524 * The @taken_empty_lebs field counts the LEBs that are in the transient state
525 * of having been "taken" for use but not yet written to. @taken_empty_lebs is
526 * needed to account correctly for @gc_lnum, otherwise @empty_lebs could be
527 * used by itself (in which case 'unused_lebs' would be a better name). In the
528 * case of @gc_lnum, it is "taken" at mount time or whenever a LEB is retained
529 * by GC, but unlike other empty LEBs that are "taken", it may not be written
530 * straight away (i.e. before the next commit start or unmount), so either
531 * @gc_lnum must be specially accounted for, or the current approach followed
532 * i.e. count it under @taken_empty_lebs.
534 * @empty_lebs includes @taken_empty_lebs.
536 * @total_used, @total_dead and @total_dark fields do not account indexing
539 struct ubifs_lp_stats
{
541 int taken_empty_lebs
;
543 long long total_free
;
544 long long total_dirty
;
545 long long total_used
;
546 long long total_dead
;
547 long long total_dark
;
553 * struct ubifs_cnode - LEB Properties Tree common node.
554 * @parent: parent nnode
555 * @cnext: next cnode to commit
556 * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE)
557 * @iip: index in parent
558 * @level: level in the tree (zero for pnodes, greater than zero for nnodes)
562 struct ubifs_nnode
*parent
;
563 struct ubifs_cnode
*cnext
;
571 * struct ubifs_pnode - LEB Properties Tree leaf node.
572 * @parent: parent nnode
573 * @cnext: next cnode to commit
574 * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE)
575 * @iip: index in parent
576 * @level: level in the tree (always zero for pnodes)
578 * @lprops: LEB properties array
581 struct ubifs_nnode
*parent
;
582 struct ubifs_cnode
*cnext
;
587 struct ubifs_lprops lprops
[UBIFS_LPT_FANOUT
];
591 * struct ubifs_nbranch - LEB Properties Tree internal node branch.
592 * @lnum: LEB number of child
593 * @offs: offset of child
594 * @nnode: nnode child
595 * @pnode: pnode child
596 * @cnode: cnode child
598 struct ubifs_nbranch
{
602 struct ubifs_nnode
*nnode
;
603 struct ubifs_pnode
*pnode
;
604 struct ubifs_cnode
*cnode
;
609 * struct ubifs_nnode - LEB Properties Tree internal node.
610 * @parent: parent nnode
611 * @cnext: next cnode to commit
612 * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE)
613 * @iip: index in parent
614 * @level: level in the tree (always greater than zero for nnodes)
616 * @nbranch: branches to child nodes
619 struct ubifs_nnode
*parent
;
620 struct ubifs_cnode
*cnext
;
625 struct ubifs_nbranch nbranch
[UBIFS_LPT_FANOUT
];
629 * struct ubifs_lpt_heap - heap of categorized lprops.
631 * @cnt: number in heap
632 * @max_cnt: maximum number allowed in heap
634 * There are %LPROPS_HEAP_CNT heaps.
636 struct ubifs_lpt_heap
{
637 struct ubifs_lprops
**arr
;
643 * Return codes for LPT scan callback function.
645 * LPT_SCAN_CONTINUE: continue scanning
646 * LPT_SCAN_ADD: add the LEB properties scanned to the tree in memory
647 * LPT_SCAN_STOP: stop scanning
650 LPT_SCAN_CONTINUE
= 0,
657 /* Callback used by the 'ubifs_lpt_scan_nolock()' function */
658 typedef int (*ubifs_lpt_scan_callback
)(struct ubifs_info
*c
,
659 const struct ubifs_lprops
*lprops
,
660 int in_tree
, void *data
);
663 * struct ubifs_wbuf - UBIFS write-buffer.
664 * @c: UBIFS file-system description object
665 * @buf: write-buffer (of min. flash I/O unit size)
666 * @lnum: logical eraseblock number the write-buffer points to
667 * @offs: write-buffer offset in this logical eraseblock
668 * @avail: number of bytes available in the write-buffer
669 * @used: number of used bytes in the write-buffer
670 * @size: write-buffer size (in [@c->min_io_size, @c->max_write_size] range)
671 * @jhead: journal head the mutex belongs to (note, needed only to shut lockdep
672 * up by 'mutex_lock_nested()).
673 * @sync_callback: write-buffer synchronization callback
674 * @io_mutex: serializes write-buffer I/O
675 * @lock: serializes @buf, @lnum, @offs, @avail, @used, @next_ino and @inodes
677 * @timer: write-buffer timer
678 * @no_timer: non-zero if this write-buffer does not have a timer
679 * @need_sync: non-zero if the timer expired and the wbuf needs sync'ing
680 * @next_ino: points to the next position of the following inode number
681 * @inodes: stores the inode numbers of the nodes which are in wbuf
683 * The write-buffer synchronization callback is called when the write-buffer is
684 * synchronized in order to notify how much space was wasted due to
685 * write-buffer padding and how much free space is left in the LEB.
687 * Note: the fields @buf, @lnum, @offs, @avail and @used can be read under
688 * spin-lock or mutex because they are written under both mutex and spin-lock.
689 * @buf is appended to under mutex but overwritten under both mutex and
690 * spin-lock. Thus the data between @buf and @buf + @used can be read under
694 struct ubifs_info
*c
;
702 int (*sync_callback
)(struct ubifs_info
*c
, int lnum
, int free
, int pad
);
703 struct mutex io_mutex
;
705 struct hrtimer timer
;
706 unsigned int no_timer
:1;
707 unsigned int need_sync
:1;
713 * struct ubifs_bud - bud logical eraseblock.
714 * @lnum: logical eraseblock number
715 * @start: where the (uncommitted) bud data starts
716 * @jhead: journal head number this bud belongs to
717 * @list: link in the list buds belonging to the same journal head
718 * @rb: link in the tree of all buds
719 * @log_hash: the log hash from the commit start node up to this bud
725 struct list_head list
;
727 struct shash_desc
*log_hash
;
731 * struct ubifs_jhead - journal head.
732 * @wbuf: head's write-buffer
733 * @buds_list: list of bud LEBs belonging to this journal head
734 * @grouped: non-zero if UBIFS groups nodes when writing to this journal head
735 * @log_hash: the log hash from the commit start node up to this journal head
737 * Note, the @buds list is protected by the @c->buds_lock.
740 struct ubifs_wbuf wbuf
;
741 struct list_head buds_list
;
742 unsigned int grouped
:1;
743 struct shash_desc
*log_hash
;
747 * struct ubifs_zbranch - key/coordinate/length branch stored in znodes.
749 * @znode: znode address in memory
750 * @lnum: LEB number of the target node (indexing node or data node)
751 * @offs: target node offset within @lnum
752 * @len: target node length
753 * @hash: the hash of the target node
755 struct ubifs_zbranch
{
758 struct ubifs_znode
*znode
;
764 u8 hash
[UBIFS_HASH_ARR_SZ
];
768 * struct ubifs_znode - in-memory representation of an indexing node.
769 * @parent: parent znode or NULL if it is the root
770 * @cnext: next znode to commit
771 * @cparent: parent node for this commit
772 * @ciip: index in cparent's zbranch array
773 * @flags: znode flags (%DIRTY_ZNODE, %COW_ZNODE or %OBSOLETE_ZNODE)
774 * @time: last access time (seconds)
775 * @level: level of the entry in the TNC tree
776 * @child_cnt: count of child znodes
777 * @iip: index in parent's zbranch array
778 * @alt: lower bound of key range has altered i.e. child inserted at slot 0
779 * @lnum: LEB number of the corresponding indexing node
780 * @offs: offset of the corresponding indexing node
781 * @len: length of the corresponding indexing node
782 * @zbranch: array of znode branches (@c->fanout elements)
784 * Note! The @lnum, @offs, and @len fields are not really needed - we have them
785 * only for internal consistency check. They could be removed to save some RAM.
788 struct ubifs_znode
*parent
;
789 struct ubifs_znode
*cnext
;
790 struct ubifs_znode
*cparent
;
801 struct ubifs_zbranch zbranch
[];
805 * struct bu_info - bulk-read information.
806 * @key: first data node key
807 * @zbranch: zbranches of data nodes to bulk read
808 * @buf: buffer to read into
809 * @buf_len: buffer length
810 * @gc_seq: GC sequence number to detect races with GC
811 * @cnt: number of data nodes for bulk read
812 * @blk_cnt: number of data blocks including holes
813 * @oef: end of file reached
817 struct ubifs_zbranch zbranch
[UBIFS_MAX_BULK_READ
];
827 * struct ubifs_node_range - node length range description data structure.
828 * @len: fixed node length
829 * @min_len: minimum possible node length
830 * @max_len: maximum possible node length
832 * If @max_len is %0, the node has fixed length @len.
834 struct ubifs_node_range
{
843 * struct ubifs_compressor - UBIFS compressor description structure.
844 * @compr_type: compressor type (%UBIFS_COMPR_LZO, etc)
845 * @cc: cryptoapi compressor handle
846 * @comp_mutex: mutex used during compression
847 * @decomp_mutex: mutex used during decompression
848 * @name: compressor name
849 * @capi_name: cryptoapi compressor name
851 struct ubifs_compressor
{
853 struct crypto_comp
*cc
;
854 struct mutex
*comp_mutex
;
855 struct mutex
*decomp_mutex
;
857 const char *capi_name
;
861 * struct ubifs_budget_req - budget requirements of an operation.
863 * @fast: non-zero if the budgeting should try to acquire budget quickly and
864 * should not try to call write-back
865 * @recalculate: non-zero if @idx_growth, @data_growth, and @dd_growth fields
866 * have to be re-calculated
867 * @new_page: non-zero if the operation adds a new page
868 * @dirtied_page: non-zero if the operation makes a page dirty
869 * @new_dent: non-zero if the operation adds a new directory entry
870 * @mod_dent: non-zero if the operation removes or modifies an existing
872 * @new_ino: non-zero if the operation adds a new inode
873 * @new_ino_d: how much data newly created inode contains
874 * @dirtied_ino: how many inodes the operation makes dirty
875 * @dirtied_ino_d: how much data dirtied inode contains
876 * @idx_growth: how much the index will supposedly grow
877 * @data_growth: how much new data the operation will supposedly add
878 * @dd_growth: how much data that makes other data dirty the operation will
881 * @idx_growth, @data_growth and @dd_growth are not used in budget request. The
882 * budgeting subsystem caches index and data growth values there to avoid
883 * re-calculating them when the budget is released. However, if @idx_growth is
884 * %-1, it is calculated by the release function using other fields.
886 * An inode may contain 4KiB of data at max., thus the widths of @new_ino_d
887 * is 13 bits, and @dirtied_ino_d - 15, because up to 4 inodes may be made
888 * dirty by the re-name operation.
890 * Note, UBIFS aligns node lengths to 8-bytes boundary, so the requester has to
891 * make sure the amount of inode data which contribute to @new_ino_d and
892 * @dirtied_ino_d fields are aligned.
894 struct ubifs_budget_req
{
896 unsigned int recalculate
:1;
898 unsigned int new_page
:1;
899 unsigned int dirtied_page
:1;
900 unsigned int new_dent
:1;
901 unsigned int mod_dent
:1;
902 unsigned int new_ino
:1;
903 unsigned int new_ino_d
:13;
904 unsigned int dirtied_ino
:4;
905 unsigned int dirtied_ino_d
:15;
907 /* Not bit-fields to check for overflows */
908 unsigned int new_page
;
909 unsigned int dirtied_page
;
910 unsigned int new_dent
;
911 unsigned int mod_dent
;
912 unsigned int new_ino
;
913 unsigned int new_ino_d
;
914 unsigned int dirtied_ino
;
915 unsigned int dirtied_ino_d
;
923 * struct ubifs_orphan - stores the inode number of an orphan.
924 * @rb: rb-tree node of rb-tree of orphans sorted by inode number
925 * @list: list head of list of orphans in order added
926 * @new_list: list head of list of orphans added since the last commit
927 * @child_list: list of xattr childs if this orphan hosts xattrs, list head
928 * if this orphan is a xattr, not used otherwise.
929 * @cnext: next orphan to commit
930 * @dnext: next orphan to delete
931 * @inum: inode number
932 * @new: %1 => added since the last commit, otherwise %0
933 * @cmt: %1 => commit pending, otherwise %0
934 * @del: %1 => delete pending, otherwise %0
936 struct ubifs_orphan
{
938 struct list_head list
;
939 struct list_head new_list
;
940 struct list_head child_list
;
941 struct ubifs_orphan
*cnext
;
942 struct ubifs_orphan
*dnext
;
950 * struct ubifs_mount_opts - UBIFS-specific mount options information.
951 * @unmount_mode: selected unmount mode (%0 default, %1 normal, %2 fast)
952 * @bulk_read: enable/disable bulk-reads (%0 default, %1 disable, %2 enable)
953 * @chk_data_crc: enable/disable CRC data checking when reading data nodes
954 * (%0 default, %1 disable, %2 enable)
955 * @override_compr: override default compressor (%0 - do not override and use
956 * superblock compressor, %1 - override and use compressor
957 * specified in @compr_type)
958 * @compr_type: compressor type to override the superblock compressor with
959 * (%UBIFS_COMPR_NONE, etc)
961 struct ubifs_mount_opts
{
962 unsigned int unmount_mode
:2;
963 unsigned int bulk_read
:2;
964 unsigned int chk_data_crc
:2;
965 unsigned int override_compr
:1;
966 unsigned int compr_type
:2;
970 * struct ubifs_budg_info - UBIFS budgeting information.
971 * @idx_growth: amount of bytes budgeted for index growth
972 * @data_growth: amount of bytes budgeted for cached data
973 * @dd_growth: amount of bytes budgeted for cached data that will make
975 * @uncommitted_idx: amount of bytes were budgeted for growth of the index, but
976 * which still have to be taken into account because the index
977 * has not been committed so far
978 * @old_idx_sz: size of index on flash
979 * @min_idx_lebs: minimum number of LEBs required for the index
980 * @nospace: non-zero if the file-system does not have flash space (used as
982 * @nospace_rp: the same as @nospace, but additionally means that even reserved
984 * @page_budget: budget for a page (constant, never changed after mount)
985 * @inode_budget: budget for an inode (constant, never changed after mount)
986 * @dent_budget: budget for a directory entry (constant, never changed after
989 struct ubifs_budg_info
{
990 long long idx_growth
;
991 long long data_growth
;
993 long long uncommitted_idx
;
994 unsigned long long old_idx_sz
;
996 unsigned int nospace
:1;
997 unsigned int nospace_rp
:1;
1003 struct ubifs_debug_info
;
1006 * struct ubifs_info - UBIFS file-system description data structure
1008 * @vfs_sb: VFS @struct super_block object
1009 * @sup_node: The super block node as read from the device
1011 * @highest_inum: highest used inode number
1012 * @max_sqnum: current global sequence number
1013 * @cmt_no: commit number of the last successfully completed commit, protected
1015 * @cnt_lock: protects @highest_inum and @max_sqnum counters
1016 * @fmt_version: UBIFS on-flash format version
1017 * @ro_compat_version: R/O compatibility version
1018 * @uuid: UUID from super block
1020 * @lhead_lnum: log head logical eraseblock number
1021 * @lhead_offs: log head offset
1022 * @ltail_lnum: log tail logical eraseblock number (offset is always 0)
1023 * @log_mutex: protects the log, @lhead_lnum, @lhead_offs, @ltail_lnum, and
1025 * @min_log_bytes: minimum required number of bytes in the log
1026 * @cmt_bud_bytes: used during commit to temporarily amount of bytes in
1029 * @buds: tree of all buds indexed by bud LEB number
1030 * @bud_bytes: how many bytes of flash is used by buds
1031 * @buds_lock: protects the @buds tree, @bud_bytes, and per-journal head bud
1033 * @jhead_cnt: count of journal heads
1034 * @jheads: journal heads (head zero is base head)
1035 * @max_bud_bytes: maximum number of bytes allowed in buds
1036 * @bg_bud_bytes: number of bud bytes when background commit is initiated
1037 * @old_buds: buds to be released after commit ends
1038 * @max_bud_cnt: maximum number of buds
1040 * @commit_sem: synchronizes committer with other processes
1041 * @cmt_state: commit state
1042 * @cs_lock: commit state lock
1043 * @cmt_wq: wait queue to sleep on if the log is full and a commit is running
1045 * @big_lpt: flag that LPT is too big to write whole during commit
1046 * @space_fixup: flag indicating that free space in LEBs needs to be cleaned up
1047 * @double_hash: flag indicating that we can do lookups by hash
1048 * @encrypted: flag indicating that this file system contains encrypted files
1049 * @no_chk_data_crc: do not check CRCs when reading data nodes (except during
1051 * @bulk_read: enable bulk-reads
1052 * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc)
1053 * @rw_incompat: the media is not R/W compatible
1054 * @assert_action: action to take when a ubifs_assert() fails
1055 * @authenticated: flag indigating the FS is mounted in authenticated mode
1057 * @tnc_mutex: protects the Tree Node Cache (TNC), @zroot, @cnext, @enext, and
1059 * @zroot: zbranch which points to the root index node and znode
1060 * @cnext: next znode to commit
1061 * @enext: next znode to commit to empty space
1062 * @gap_lebs: array of LEBs used by the in-gaps commit method
1063 * @cbuf: commit buffer
1064 * @ileb_buf: buffer for commit in-the-gaps method
1065 * @ileb_len: length of data in ileb_buf
1066 * @ihead_lnum: LEB number of index head
1067 * @ihead_offs: offset of index head
1068 * @ilebs: pre-allocated index LEBs
1069 * @ileb_cnt: number of pre-allocated index LEBs
1070 * @ileb_nxt: next pre-allocated index LEBs
1071 * @old_idx: tree of index nodes obsoleted since the last commit start
1072 * @bottom_up_buf: a buffer which is used by 'dirty_cow_bottom_up()' in tnc.c
1074 * @mst_node: master node
1075 * @mst_offs: offset of valid master node
1077 * @max_bu_buf_len: maximum bulk-read buffer length
1078 * @bu_mutex: protects the pre-allocated bulk-read buffer and @c->bu
1079 * @bu: pre-allocated bulk-read information
1081 * @write_reserve_mutex: protects @write_reserve_buf
1082 * @write_reserve_buf: on the write path we allocate memory, which might
1083 * sometimes be unavailable, in which case we use this
1084 * write reserve buffer
1086 * @log_lebs: number of logical eraseblocks in the log
1087 * @log_bytes: log size in bytes
1088 * @log_last: last LEB of the log
1089 * @lpt_lebs: number of LEBs used for lprops table
1090 * @lpt_first: first LEB of the lprops table area
1091 * @lpt_last: last LEB of the lprops table area
1092 * @orph_lebs: number of LEBs used for the orphan area
1093 * @orph_first: first LEB of the orphan area
1094 * @orph_last: last LEB of the orphan area
1095 * @main_lebs: count of LEBs in the main area
1096 * @main_first: first LEB of the main area
1097 * @main_bytes: main area size in bytes
1099 * @key_hash_type: type of the key hash
1100 * @key_hash: direntry key hash function
1101 * @key_fmt: key format
1102 * @key_len: key length
1103 * @hash_len: The length of the index node hashes
1104 * @fanout: fanout of the index tree (number of links per indexing node)
1106 * @min_io_size: minimal input/output unit size
1107 * @min_io_shift: number of bits in @min_io_size minus one
1108 * @max_write_size: maximum amount of bytes the underlying flash can write at a
1109 * time (MTD write buffer size)
1110 * @max_write_shift: number of bits in @max_write_size minus one
1111 * @leb_size: logical eraseblock size in bytes
1112 * @leb_start: starting offset of logical eraseblocks within physical
1114 * @half_leb_size: half LEB size
1115 * @idx_leb_size: how many bytes of an LEB are effectively available when it is
1116 * used to store indexing nodes (@leb_size - @max_idx_node_sz)
1117 * @leb_cnt: count of logical eraseblocks
1118 * @max_leb_cnt: maximum count of logical eraseblocks
1119 * @old_leb_cnt: count of logical eraseblocks before re-size
1120 * @ro_media: the underlying UBI volume is read-only
1121 * @ro_mount: the file-system was mounted as read-only
1122 * @ro_error: UBIFS switched to R/O mode because an error happened
1124 * @dirty_pg_cnt: number of dirty pages (not used)
1125 * @dirty_zn_cnt: number of dirty znodes
1126 * @clean_zn_cnt: number of clean znodes
1128 * @space_lock: protects @bi and @lst
1129 * @lst: lprops statistics
1130 * @bi: budgeting information
1131 * @calc_idx_sz: temporary variable which is used to calculate new index size
1132 * (contains accurate new index size at end of TNC commit start)
1134 * @ref_node_alsz: size of the LEB reference node aligned to the min. flash
1136 * @mst_node_alsz: master node aligned size
1137 * @min_idx_node_sz: minimum indexing node aligned on 8-bytes boundary
1138 * @max_idx_node_sz: maximum indexing node aligned on 8-bytes boundary
1139 * @max_inode_sz: maximum possible inode size in bytes
1140 * @max_znode_sz: size of znode in bytes
1142 * @leb_overhead: how many bytes are wasted in an LEB when it is filled with
1143 * data nodes of maximum size - used in free space reporting
1144 * @dead_wm: LEB dead space watermark
1145 * @dark_wm: LEB dark space watermark
1146 * @block_cnt: count of 4KiB blocks on the FS
1148 * @ranges: UBIFS node length ranges
1149 * @ubi: UBI volume descriptor
1150 * @di: UBI device information
1151 * @vi: UBI volume information
1153 * @orph_tree: rb-tree of orphan inode numbers
1154 * @orph_list: list of orphan inode numbers in order added
1155 * @orph_new: list of orphan inode numbers added since last commit
1156 * @orph_cnext: next orphan to commit
1157 * @orph_dnext: next orphan to delete
1158 * @orphan_lock: lock for orph_tree and orph_new
1159 * @orph_buf: buffer for orphan nodes
1160 * @new_orphans: number of orphans since last commit
1161 * @cmt_orphans: number of orphans being committed
1162 * @tot_orphans: number of orphans in the rb_tree
1163 * @max_orphans: maximum number of orphans allowed
1164 * @ohead_lnum: orphan head LEB number
1165 * @ohead_offs: orphan head offset
1166 * @no_orphs: non-zero if there are no orphans
1168 * @bgt: UBIFS background thread
1169 * @bgt_name: background thread name
1170 * @need_bgt: if background thread should run
1171 * @need_wbuf_sync: if write-buffers have to be synchronized
1173 * @gc_lnum: LEB number used for garbage collection
1174 * @sbuf: a buffer of LEB size used by GC and replay for scanning
1175 * @idx_gc: list of index LEBs that have been garbage collected
1176 * @idx_gc_cnt: number of elements on the idx_gc list
1177 * @gc_seq: incremented for every non-index LEB garbage collected
1178 * @gced_lnum: last non-index LEB that was garbage collected
1180 * @infos_list: links all 'ubifs_info' objects
1181 * @umount_mutex: serializes shrinker and un-mount
1182 * @shrinker_run_no: shrinker run number
1184 * @space_bits: number of bits needed to record free or dirty space
1185 * @lpt_lnum_bits: number of bits needed to record a LEB number in the LPT
1186 * @lpt_offs_bits: number of bits needed to record an offset in the LPT
1187 * @lpt_spc_bits: number of bits needed to space in the LPT
1188 * @pcnt_bits: number of bits needed to record pnode or nnode number
1189 * @lnum_bits: number of bits needed to record LEB number
1190 * @nnode_sz: size of on-flash nnode
1191 * @pnode_sz: size of on-flash pnode
1192 * @ltab_sz: size of on-flash LPT lprops table
1193 * @lsave_sz: size of on-flash LPT save table
1194 * @pnode_cnt: number of pnodes
1195 * @nnode_cnt: number of nnodes
1196 * @lpt_hght: height of the LPT
1197 * @pnodes_have: number of pnodes in memory
1199 * @lp_mutex: protects lprops table and all the other lprops-related fields
1200 * @lpt_lnum: LEB number of the root nnode of the LPT
1201 * @lpt_offs: offset of the root nnode of the LPT
1202 * @nhead_lnum: LEB number of LPT head
1203 * @nhead_offs: offset of LPT head
1204 * @lpt_drty_flgs: dirty flags for LPT special nodes e.g. ltab
1205 * @dirty_nn_cnt: number of dirty nnodes
1206 * @dirty_pn_cnt: number of dirty pnodes
1207 * @check_lpt_free: flag that indicates LPT GC may be needed
1209 * @lpt_nod_buf: buffer for an on-flash nnode or pnode
1210 * @lpt_buf: buffer of LEB size used by LPT
1211 * @nroot: address in memory of the root nnode of the LPT
1212 * @lpt_cnext: next LPT node to commit
1213 * @lpt_heap: array of heaps of categorized lprops
1214 * @dirty_idx: a (reverse sorted) copy of the LPROPS_DIRTY_IDX heap as at
1215 * previous commit start
1216 * @uncat_list: list of un-categorized LEBs
1217 * @empty_list: list of empty LEBs
1218 * @freeable_list: list of freeable non-index LEBs (free + dirty == @leb_size)
1219 * @frdi_idx_list: list of freeable index LEBs (free + dirty == @leb_size)
1220 * @freeable_cnt: number of freeable LEBs in @freeable_list
1221 * @in_a_category_cnt: count of lprops which are in a certain category, which
1222 * basically meants that they were loaded from the flash
1224 * @ltab_lnum: LEB number of LPT's own lprops table
1225 * @ltab_offs: offset of LPT's own lprops table
1226 * @ltab: LPT's own lprops table
1227 * @ltab_cmt: LPT's own lprops table (commit copy)
1228 * @lsave_cnt: number of LEB numbers in LPT's save table
1229 * @lsave_lnum: LEB number of LPT's save table
1230 * @lsave_offs: offset of LPT's save table
1231 * @lsave: LPT's save table
1232 * @lscan_lnum: LEB number of last LPT scan
1234 * @rp_size: size of the reserved pool in bytes
1235 * @report_rp_size: size of the reserved pool reported to user-space
1236 * @rp_uid: reserved pool user ID
1237 * @rp_gid: reserved pool group ID
1239 * @hash_tfm: the hash transformation used for hashing nodes
1240 * @hmac_tfm: the HMAC transformation for this filesystem
1241 * @hmac_desc_len: length of the HMAC used for authentication
1242 * @auth_key_name: the authentication key name
1243 * @auth_hash_name: the name of the hash algorithm used for authentication
1244 * @auth_hash_algo: the authentication hash used for this fs
1245 * @log_hash: the log hash from the commit start node up to the latest reference
1248 * @empty: %1 if the UBI device is empty
1249 * @need_recovery: %1 if the file-system needs recovery
1250 * @replaying: %1 during journal replay
1251 * @mounting: %1 while mounting
1252 * @probing: %1 while attempting to mount if SB_SILENT mount flag is set
1253 * @remounting_rw: %1 while re-mounting from R/O mode to R/W mode
1254 * @replay_list: temporary list used during journal replay
1255 * @replay_buds: list of buds to replay
1256 * @cs_sqnum: sequence number of first node in the log (commit start node)
1257 * @unclean_leb_list: LEBs to recover when re-mounting R/O mounted FS to R/W
1259 * @rcvrd_mst_node: recovered master node to write when re-mounting R/O mounted
1261 * @size_tree: inode size information for recovery
1262 * @mount_opts: UBIFS-specific mount options
1264 * @dbg: debugging-related information
1267 struct super_block
*vfs_sb
;
1268 struct ubifs_sb_node
*sup_node
;
1271 unsigned long long max_sqnum
;
1272 unsigned long long cmt_no
;
1273 spinlock_t cnt_lock
;
1275 int ro_compat_version
;
1276 unsigned char uuid
[16];
1281 struct mutex log_mutex
;
1283 long long cmt_bud_bytes
;
1285 struct rb_root buds
;
1286 long long bud_bytes
;
1287 spinlock_t buds_lock
;
1289 struct ubifs_jhead
*jheads
;
1290 long long max_bud_bytes
;
1291 long long bg_bud_bytes
;
1292 struct list_head old_buds
;
1295 struct rw_semaphore commit_sem
;
1298 wait_queue_head_t cmt_wq
;
1300 unsigned int big_lpt
:1;
1301 unsigned int space_fixup
:1;
1302 unsigned int double_hash
:1;
1303 unsigned int encrypted
:1;
1304 unsigned int no_chk_data_crc
:1;
1305 unsigned int bulk_read
:1;
1306 unsigned int default_compr
:2;
1307 unsigned int rw_incompat
:1;
1308 unsigned int assert_action
:2;
1309 unsigned int authenticated
:1;
1311 struct mutex tnc_mutex
;
1312 struct ubifs_zbranch zroot
;
1313 struct ubifs_znode
*cnext
;
1314 struct ubifs_znode
*enext
;
1324 struct rb_root old_idx
;
1327 struct ubifs_mst_node
*mst_node
;
1331 struct mutex bu_mutex
;
1334 struct mutex write_reserve_mutex
;
1335 void *write_reserve_buf
;
1338 long long log_bytes
;
1348 long long main_bytes
;
1350 uint8_t key_hash_type
;
1351 uint32_t (*key_hash
)(const char *str
, int len
);
1360 int max_write_shift
;
1368 unsigned int ro_media
:1;
1369 unsigned int ro_mount
:1;
1370 unsigned int ro_error
:1;
1372 atomic_long_t dirty_pg_cnt
;
1373 atomic_long_t dirty_zn_cnt
;
1374 atomic_long_t clean_zn_cnt
;
1376 spinlock_t space_lock
;
1377 struct ubifs_lp_stats lst
;
1378 struct ubifs_budg_info bi
;
1379 unsigned long long calc_idx_sz
;
1383 int min_idx_node_sz
;
1384 int max_idx_node_sz
;
1385 long long max_inode_sz
;
1393 struct ubifs_node_range ranges
[UBIFS_NODE_TYPES_CNT
];
1394 struct ubi_volume_desc
*ubi
;
1395 struct ubi_device_info di
;
1396 struct ubi_volume_info vi
;
1398 struct rb_root orph_tree
;
1399 struct list_head orph_list
;
1400 struct list_head orph_new
;
1401 struct ubifs_orphan
*orph_cnext
;
1402 struct ubifs_orphan
*orph_dnext
;
1403 spinlock_t orphan_lock
;
1413 struct task_struct
*bgt
;
1414 char bgt_name
[sizeof(BGT_NAME_PATTERN
) + 9];
1420 struct list_head idx_gc
;
1425 struct list_head infos_list
;
1426 struct mutex umount_mutex
;
1427 unsigned int shrinker_run_no
;
1444 struct mutex lp_mutex
;
1456 struct ubifs_nnode
*nroot
;
1457 struct ubifs_cnode
*lpt_cnext
;
1458 struct ubifs_lpt_heap lpt_heap
[LPROPS_HEAP_CNT
];
1459 struct ubifs_lpt_heap dirty_idx
;
1460 struct list_head uncat_list
;
1461 struct list_head empty_list
;
1462 struct list_head freeable_list
;
1463 struct list_head frdi_idx_list
;
1465 int in_a_category_cnt
;
1469 struct ubifs_lpt_lprops
*ltab
;
1470 struct ubifs_lpt_lprops
*ltab_cmt
;
1478 long long report_rp_size
;
1482 struct crypto_shash
*hash_tfm
;
1483 struct crypto_shash
*hmac_tfm
;
1485 char *auth_key_name
;
1486 char *auth_hash_name
;
1487 enum hash_algo auth_hash_algo
;
1489 struct shash_desc
*log_hash
;
1491 /* The below fields are used only during mounting and re-mounting */
1492 unsigned int empty
:1;
1493 unsigned int need_recovery
:1;
1494 unsigned int replaying
:1;
1495 unsigned int mounting
:1;
1496 unsigned int remounting_rw
:1;
1497 unsigned int probing
:1;
1498 struct list_head replay_list
;
1499 struct list_head replay_buds
;
1500 unsigned long long cs_sqnum
;
1501 struct list_head unclean_leb_list
;
1502 struct ubifs_mst_node
*rcvrd_mst_node
;
1503 struct rb_root size_tree
;
1504 struct ubifs_mount_opts mount_opts
;
1506 struct ubifs_debug_info
*dbg
;
1509 extern struct list_head ubifs_infos
;
1510 extern spinlock_t ubifs_infos_lock
;
1511 extern atomic_long_t ubifs_clean_zn_cnt
;
1512 extern const struct super_operations ubifs_super_operations
;
1513 extern const struct address_space_operations ubifs_file_address_operations
;
1514 extern const struct file_operations ubifs_file_operations
;
1515 extern const struct inode_operations ubifs_file_inode_operations
;
1516 extern const struct file_operations ubifs_dir_operations
;
1517 extern const struct inode_operations ubifs_dir_inode_operations
;
1518 extern const struct inode_operations ubifs_symlink_inode_operations
;
1519 extern struct ubifs_compressor
*ubifs_compressors
[UBIFS_COMPR_TYPES_CNT
];
1522 static inline int ubifs_authenticated(const struct ubifs_info
*c
)
1524 return (IS_ENABLED(CONFIG_UBIFS_FS_AUTHENTICATION
)) && c
->authenticated
;
1527 struct shash_desc
*__ubifs_hash_get_desc(const struct ubifs_info
*c
);
1528 static inline struct shash_desc
*ubifs_hash_get_desc(const struct ubifs_info
*c
)
1530 return ubifs_authenticated(c
) ? __ubifs_hash_get_desc(c
) : NULL
;
1533 static inline int ubifs_shash_init(const struct ubifs_info
*c
,
1534 struct shash_desc
*desc
)
1536 if (ubifs_authenticated(c
))
1537 return crypto_shash_init(desc
);
1542 static inline int ubifs_shash_update(const struct ubifs_info
*c
,
1543 struct shash_desc
*desc
, const void *buf
,
1548 if (ubifs_authenticated(c
)) {
1549 err
= crypto_shash_update(desc
, buf
, len
);
1557 static inline int ubifs_shash_final(const struct ubifs_info
*c
,
1558 struct shash_desc
*desc
, u8
*out
)
1560 return ubifs_authenticated(c
) ? crypto_shash_final(desc
, out
) : 0;
1563 int __ubifs_node_calc_hash(const struct ubifs_info
*c
, const void *buf
,
1565 static inline int ubifs_node_calc_hash(const struct ubifs_info
*c
,
1566 const void *buf
, u8
*hash
)
1568 if (ubifs_authenticated(c
))
1569 return __ubifs_node_calc_hash(c
, buf
, hash
);
1574 int ubifs_prepare_auth_node(struct ubifs_info
*c
, void *node
,
1575 struct shash_desc
*inhash
);
1578 * ubifs_check_hash - compare two hashes
1579 * @c: UBIFS file-system description object
1580 * @expected: first hash
1583 * Compare two hashes @expected and @got. Returns 0 when they are equal, a
1584 * negative error code otherwise.
1586 static inline int ubifs_check_hash(const struct ubifs_info
*c
,
1587 const u8
*expected
, const u8
*got
)
1589 return crypto_memneq(expected
, got
, c
->hash_len
);
1593 * ubifs_check_hmac - compare two HMACs
1594 * @c: UBIFS file-system description object
1595 * @expected: first HMAC
1598 * Compare two hashes @expected and @got. Returns 0 when they are equal, a
1599 * negative error code otherwise.
1601 static inline int ubifs_check_hmac(const struct ubifs_info
*c
,
1602 const u8
*expected
, const u8
*got
)
1604 return crypto_memneq(expected
, got
, c
->hmac_desc_len
);
1607 void ubifs_bad_hash(const struct ubifs_info
*c
, const void *node
,
1608 const u8
*hash
, int lnum
, int offs
);
1610 int __ubifs_node_check_hash(const struct ubifs_info
*c
, const void *buf
,
1611 const u8
*expected
);
1612 static inline int ubifs_node_check_hash(const struct ubifs_info
*c
,
1613 const void *buf
, const u8
*expected
)
1615 if (ubifs_authenticated(c
))
1616 return __ubifs_node_check_hash(c
, buf
, expected
);
1621 int ubifs_init_authentication(struct ubifs_info
*c
);
1622 void __ubifs_exit_authentication(struct ubifs_info
*c
);
1623 static inline void ubifs_exit_authentication(struct ubifs_info
*c
)
1625 if (ubifs_authenticated(c
))
1626 __ubifs_exit_authentication(c
);
1630 * ubifs_branch_hash - returns a pointer to the hash of a branch
1631 * @c: UBIFS file-system description object
1632 * @br: branch to get the hash from
1634 * This returns a pointer to the hash of a branch. Since the key already is a
1635 * dynamically sized object we cannot use a struct member here.
1637 static inline u8
*ubifs_branch_hash(struct ubifs_info
*c
,
1638 struct ubifs_branch
*br
)
1640 return (void *)br
+ sizeof(*br
) + c
->key_len
;
1644 * ubifs_copy_hash - copy a hash
1645 * @c: UBIFS file-system description object
1646 * @from: source hash
1647 * @to: destination hash
1649 * With authentication this copies a hash, otherwise does nothing.
1651 static inline void ubifs_copy_hash(const struct ubifs_info
*c
, const u8
*from
,
1654 if (ubifs_authenticated(c
))
1655 memcpy(to
, from
, c
->hash_len
);
1658 int __ubifs_node_insert_hmac(const struct ubifs_info
*c
, void *buf
,
1659 int len
, int ofs_hmac
);
1660 static inline int ubifs_node_insert_hmac(const struct ubifs_info
*c
, void *buf
,
1661 int len
, int ofs_hmac
)
1663 if (ubifs_authenticated(c
))
1664 return __ubifs_node_insert_hmac(c
, buf
, len
, ofs_hmac
);
1669 int __ubifs_node_verify_hmac(const struct ubifs_info
*c
, const void *buf
,
1670 int len
, int ofs_hmac
);
1671 static inline int ubifs_node_verify_hmac(const struct ubifs_info
*c
,
1672 const void *buf
, int len
, int ofs_hmac
)
1674 if (ubifs_authenticated(c
))
1675 return __ubifs_node_verify_hmac(c
, buf
, len
, ofs_hmac
);
1681 * ubifs_auth_node_sz - returns the size of an authentication node
1682 * @c: UBIFS file-system description object
1684 * This function returns the size of an authentication node which can
1685 * be 0 for unauthenticated filesystems or the real size of an auth node
1686 * authentication is enabled.
1688 static inline int ubifs_auth_node_sz(const struct ubifs_info
*c
)
1690 if (ubifs_authenticated(c
))
1691 return sizeof(struct ubifs_auth_node
) + c
->hmac_desc_len
;
1696 int ubifs_hmac_wkm(struct ubifs_info
*c
, u8
*hmac
);
1698 int __ubifs_shash_copy_state(const struct ubifs_info
*c
, struct shash_desc
*src
,
1699 struct shash_desc
*target
);
1700 static inline int ubifs_shash_copy_state(const struct ubifs_info
*c
,
1701 struct shash_desc
*src
,
1702 struct shash_desc
*target
)
1704 if (ubifs_authenticated(c
))
1705 return __ubifs_shash_copy_state(c
, src
, target
);
1711 void ubifs_ro_mode(struct ubifs_info
*c
, int err
);
1712 int ubifs_leb_read(const struct ubifs_info
*c
, int lnum
, void *buf
, int offs
,
1713 int len
, int even_ebadmsg
);
1714 int ubifs_leb_write(struct ubifs_info
*c
, int lnum
, const void *buf
, int offs
,
1716 int ubifs_leb_change(struct ubifs_info
*c
, int lnum
, const void *buf
, int len
);
1717 int ubifs_leb_unmap(struct ubifs_info
*c
, int lnum
);
1718 int ubifs_leb_map(struct ubifs_info
*c
, int lnum
);
1719 int ubifs_is_mapped(const struct ubifs_info
*c
, int lnum
);
1720 int ubifs_wbuf_write_nolock(struct ubifs_wbuf
*wbuf
, void *buf
, int len
);
1721 int ubifs_wbuf_seek_nolock(struct ubifs_wbuf
*wbuf
, int lnum
, int offs
);
1722 int ubifs_wbuf_init(struct ubifs_info
*c
, struct ubifs_wbuf
*wbuf
);
1723 int ubifs_read_node(const struct ubifs_info
*c
, void *buf
, int type
, int len
,
1724 int lnum
, int offs
);
1725 int ubifs_read_node_wbuf(struct ubifs_wbuf
*wbuf
, void *buf
, int type
, int len
,
1726 int lnum
, int offs
);
1727 int ubifs_write_node(struct ubifs_info
*c
, void *node
, int len
, int lnum
,
1729 int ubifs_write_node_hmac(struct ubifs_info
*c
, void *buf
, int len
, int lnum
,
1730 int offs
, int hmac_offs
);
1731 int ubifs_check_node(const struct ubifs_info
*c
, const void *buf
, int lnum
,
1732 int offs
, int quiet
, int must_chk_crc
);
1733 void ubifs_init_node(struct ubifs_info
*c
, void *buf
, int len
, int pad
);
1734 void ubifs_crc_node(struct ubifs_info
*c
, void *buf
, int len
);
1735 void ubifs_prepare_node(struct ubifs_info
*c
, void *buf
, int len
, int pad
);
1736 int ubifs_prepare_node_hmac(struct ubifs_info
*c
, void *node
, int len
,
1737 int hmac_offs
, int pad
);
1738 void ubifs_prep_grp_node(struct ubifs_info
*c
, void *node
, int len
, int last
);
1739 int ubifs_io_init(struct ubifs_info
*c
);
1740 void ubifs_pad(const struct ubifs_info
*c
, void *buf
, int pad
);
1741 int ubifs_wbuf_sync_nolock(struct ubifs_wbuf
*wbuf
);
1742 int ubifs_bg_wbufs_sync(struct ubifs_info
*c
);
1743 void ubifs_wbuf_add_ino_nolock(struct ubifs_wbuf
*wbuf
, ino_t inum
);
1744 int ubifs_sync_wbufs_by_inode(struct ubifs_info
*c
, struct inode
*inode
);
1747 struct ubifs_scan_leb
*ubifs_scan(const struct ubifs_info
*c
, int lnum
,
1748 int offs
, void *sbuf
, int quiet
);
1749 void ubifs_scan_destroy(struct ubifs_scan_leb
*sleb
);
1750 int ubifs_scan_a_node(const struct ubifs_info
*c
, void *buf
, int len
, int lnum
,
1751 int offs
, int quiet
);
1752 struct ubifs_scan_leb
*ubifs_start_scan(const struct ubifs_info
*c
, int lnum
,
1753 int offs
, void *sbuf
);
1754 void ubifs_end_scan(const struct ubifs_info
*c
, struct ubifs_scan_leb
*sleb
,
1755 int lnum
, int offs
);
1756 int ubifs_add_snod(const struct ubifs_info
*c
, struct ubifs_scan_leb
*sleb
,
1757 void *buf
, int offs
);
1758 void ubifs_scanned_corruption(const struct ubifs_info
*c
, int lnum
, int offs
,
1762 void ubifs_add_bud(struct ubifs_info
*c
, struct ubifs_bud
*bud
);
1763 void ubifs_create_buds_lists(struct ubifs_info
*c
);
1764 int ubifs_add_bud_to_log(struct ubifs_info
*c
, int jhead
, int lnum
, int offs
);
1765 struct ubifs_bud
*ubifs_search_bud(struct ubifs_info
*c
, int lnum
);
1766 struct ubifs_wbuf
*ubifs_get_wbuf(struct ubifs_info
*c
, int lnum
);
1767 int ubifs_log_start_commit(struct ubifs_info
*c
, int *ltail_lnum
);
1768 int ubifs_log_end_commit(struct ubifs_info
*c
, int new_ltail_lnum
);
1769 int ubifs_log_post_commit(struct ubifs_info
*c
, int old_ltail_lnum
);
1770 int ubifs_consolidate_log(struct ubifs_info
*c
);
1773 int ubifs_jnl_update(struct ubifs_info
*c
, const struct inode
*dir
,
1774 const struct fscrypt_name
*nm
, const struct inode
*inode
,
1775 int deletion
, int xent
);
1776 int ubifs_jnl_write_data(struct ubifs_info
*c
, const struct inode
*inode
,
1777 const union ubifs_key
*key
, const void *buf
, int len
);
1778 int ubifs_jnl_write_inode(struct ubifs_info
*c
, const struct inode
*inode
);
1779 int ubifs_jnl_delete_inode(struct ubifs_info
*c
, const struct inode
*inode
);
1780 int ubifs_jnl_xrename(struct ubifs_info
*c
, const struct inode
*fst_dir
,
1781 const struct inode
*fst_inode
,
1782 const struct fscrypt_name
*fst_nm
,
1783 const struct inode
*snd_dir
,
1784 const struct inode
*snd_inode
,
1785 const struct fscrypt_name
*snd_nm
, int sync
);
1786 int ubifs_jnl_rename(struct ubifs_info
*c
, const struct inode
*old_dir
,
1787 const struct inode
*old_inode
,
1788 const struct fscrypt_name
*old_nm
,
1789 const struct inode
*new_dir
,
1790 const struct inode
*new_inode
,
1791 const struct fscrypt_name
*new_nm
,
1792 const struct inode
*whiteout
, int sync
);
1793 int ubifs_jnl_truncate(struct ubifs_info
*c
, const struct inode
*inode
,
1794 loff_t old_size
, loff_t new_size
);
1795 int ubifs_jnl_delete_xattr(struct ubifs_info
*c
, const struct inode
*host
,
1796 const struct inode
*inode
, const struct fscrypt_name
*nm
);
1797 int ubifs_jnl_change_xattr(struct ubifs_info
*c
, const struct inode
*inode1
,
1798 const struct inode
*inode2
);
1801 int ubifs_budget_space(struct ubifs_info
*c
, struct ubifs_budget_req
*req
);
1802 void ubifs_release_budget(struct ubifs_info
*c
, struct ubifs_budget_req
*req
);
1803 void ubifs_release_dirty_inode_budget(struct ubifs_info
*c
,
1804 struct ubifs_inode
*ui
);
1805 int ubifs_budget_inode_op(struct ubifs_info
*c
, struct inode
*inode
,
1806 struct ubifs_budget_req
*req
);
1807 void ubifs_release_ino_dirty(struct ubifs_info
*c
, struct inode
*inode
,
1808 struct ubifs_budget_req
*req
);
1809 void ubifs_cancel_ino_op(struct ubifs_info
*c
, struct inode
*inode
,
1810 struct ubifs_budget_req
*req
);
1811 long long ubifs_get_free_space(struct ubifs_info
*c
);
1812 long long ubifs_get_free_space_nolock(struct ubifs_info
*c
);
1813 int ubifs_calc_min_idx_lebs(struct ubifs_info
*c
);
1814 void ubifs_convert_page_budget(struct ubifs_info
*c
);
1815 long long ubifs_reported_space(const struct ubifs_info
*c
, long long free
);
1816 long long ubifs_calc_available(const struct ubifs_info
*c
, int min_idx_lebs
);
1819 int ubifs_find_free_space(struct ubifs_info
*c
, int min_space
, int *offs
,
1821 int ubifs_find_free_leb_for_idx(struct ubifs_info
*c
);
1822 int ubifs_find_dirty_leb(struct ubifs_info
*c
, struct ubifs_lprops
*ret_lp
,
1823 int min_space
, int pick_free
);
1824 int ubifs_find_dirty_idx_leb(struct ubifs_info
*c
);
1825 int ubifs_save_dirty_idx_lnums(struct ubifs_info
*c
);
1828 int ubifs_lookup_level0(struct ubifs_info
*c
, const union ubifs_key
*key
,
1829 struct ubifs_znode
**zn
, int *n
);
1830 int ubifs_tnc_lookup_nm(struct ubifs_info
*c
, const union ubifs_key
*key
,
1831 void *node
, const struct fscrypt_name
*nm
);
1832 int ubifs_tnc_lookup_dh(struct ubifs_info
*c
, const union ubifs_key
*key
,
1833 void *node
, uint32_t secondary_hash
);
1834 int ubifs_tnc_locate(struct ubifs_info
*c
, const union ubifs_key
*key
,
1835 void *node
, int *lnum
, int *offs
);
1836 int ubifs_tnc_add(struct ubifs_info
*c
, const union ubifs_key
*key
, int lnum
,
1837 int offs
, int len
, const u8
*hash
);
1838 int ubifs_tnc_replace(struct ubifs_info
*c
, const union ubifs_key
*key
,
1839 int old_lnum
, int old_offs
, int lnum
, int offs
, int len
);
1840 int ubifs_tnc_add_nm(struct ubifs_info
*c
, const union ubifs_key
*key
,
1841 int lnum
, int offs
, int len
, const u8
*hash
,
1842 const struct fscrypt_name
*nm
);
1843 int ubifs_tnc_remove(struct ubifs_info
*c
, const union ubifs_key
*key
);
1844 int ubifs_tnc_remove_nm(struct ubifs_info
*c
, const union ubifs_key
*key
,
1845 const struct fscrypt_name
*nm
);
1846 int ubifs_tnc_remove_dh(struct ubifs_info
*c
, const union ubifs_key
*key
,
1848 int ubifs_tnc_remove_range(struct ubifs_info
*c
, union ubifs_key
*from_key
,
1849 union ubifs_key
*to_key
);
1850 int ubifs_tnc_remove_ino(struct ubifs_info
*c
, ino_t inum
);
1851 struct ubifs_dent_node
*ubifs_tnc_next_ent(struct ubifs_info
*c
,
1852 union ubifs_key
*key
,
1853 const struct fscrypt_name
*nm
);
1854 void ubifs_tnc_close(struct ubifs_info
*c
);
1855 int ubifs_tnc_has_node(struct ubifs_info
*c
, union ubifs_key
*key
, int level
,
1856 int lnum
, int offs
, int is_idx
);
1857 int ubifs_dirty_idx_node(struct ubifs_info
*c
, union ubifs_key
*key
, int level
,
1858 int lnum
, int offs
);
1859 /* Shared by tnc.c for tnc_commit.c */
1860 void destroy_old_idx(struct ubifs_info
*c
);
1861 int is_idx_node_in_tnc(struct ubifs_info
*c
, union ubifs_key
*key
, int level
,
1862 int lnum
, int offs
);
1863 int insert_old_idx_znode(struct ubifs_info
*c
, struct ubifs_znode
*znode
);
1864 int ubifs_tnc_get_bu_keys(struct ubifs_info
*c
, struct bu_info
*bu
);
1865 int ubifs_tnc_bulk_read(struct ubifs_info
*c
, struct bu_info
*bu
);
1868 struct ubifs_znode
*ubifs_tnc_levelorder_next(const struct ubifs_info
*c
,
1869 struct ubifs_znode
*zr
,
1870 struct ubifs_znode
*znode
);
1871 int ubifs_search_zbranch(const struct ubifs_info
*c
,
1872 const struct ubifs_znode
*znode
,
1873 const union ubifs_key
*key
, int *n
);
1874 struct ubifs_znode
*ubifs_tnc_postorder_first(struct ubifs_znode
*znode
);
1875 struct ubifs_znode
*ubifs_tnc_postorder_next(const struct ubifs_info
*c
,
1876 struct ubifs_znode
*znode
);
1877 long ubifs_destroy_tnc_subtree(const struct ubifs_info
*c
,
1878 struct ubifs_znode
*zr
);
1879 struct ubifs_znode
*ubifs_load_znode(struct ubifs_info
*c
,
1880 struct ubifs_zbranch
*zbr
,
1881 struct ubifs_znode
*parent
, int iip
);
1882 int ubifs_tnc_read_node(struct ubifs_info
*c
, struct ubifs_zbranch
*zbr
,
1886 int ubifs_tnc_start_commit(struct ubifs_info
*c
, struct ubifs_zbranch
*zroot
);
1887 int ubifs_tnc_end_commit(struct ubifs_info
*c
);
1890 unsigned long ubifs_shrink_scan(struct shrinker
*shrink
,
1891 struct shrink_control
*sc
);
1892 unsigned long ubifs_shrink_count(struct shrinker
*shrink
,
1893 struct shrink_control
*sc
);
1896 int ubifs_bg_thread(void *info
);
1897 void ubifs_commit_required(struct ubifs_info
*c
);
1898 void ubifs_request_bg_commit(struct ubifs_info
*c
);
1899 int ubifs_run_commit(struct ubifs_info
*c
);
1900 void ubifs_recovery_commit(struct ubifs_info
*c
);
1901 int ubifs_gc_should_commit(struct ubifs_info
*c
);
1902 void ubifs_wait_for_commit(struct ubifs_info
*c
);
1905 int ubifs_compare_master_node(struct ubifs_info
*c
, void *m1
, void *m2
);
1906 int ubifs_read_master(struct ubifs_info
*c
);
1907 int ubifs_write_master(struct ubifs_info
*c
);
1910 int ubifs_read_superblock(struct ubifs_info
*c
);
1911 int ubifs_write_sb_node(struct ubifs_info
*c
, struct ubifs_sb_node
*sup
);
1912 int ubifs_fixup_free_space(struct ubifs_info
*c
);
1913 int ubifs_enable_encryption(struct ubifs_info
*c
);
1916 int ubifs_validate_entry(struct ubifs_info
*c
,
1917 const struct ubifs_dent_node
*dent
);
1918 int ubifs_replay_journal(struct ubifs_info
*c
);
1921 int ubifs_garbage_collect(struct ubifs_info
*c
, int anyway
);
1922 int ubifs_gc_start_commit(struct ubifs_info
*c
);
1923 int ubifs_gc_end_commit(struct ubifs_info
*c
);
1924 void ubifs_destroy_idx_gc(struct ubifs_info
*c
);
1925 int ubifs_get_idx_gc_leb(struct ubifs_info
*c
);
1926 int ubifs_garbage_collect_leb(struct ubifs_info
*c
, struct ubifs_lprops
*lp
);
1929 int ubifs_add_orphan(struct ubifs_info
*c
, ino_t inum
);
1930 void ubifs_delete_orphan(struct ubifs_info
*c
, ino_t inum
);
1931 int ubifs_orphan_start_commit(struct ubifs_info
*c
);
1932 int ubifs_orphan_end_commit(struct ubifs_info
*c
);
1933 int ubifs_mount_orphans(struct ubifs_info
*c
, int unclean
, int read_only
);
1934 int ubifs_clear_orphans(struct ubifs_info
*c
);
1937 int ubifs_calc_lpt_geom(struct ubifs_info
*c
);
1938 int ubifs_create_dflt_lpt(struct ubifs_info
*c
, int *main_lebs
, int lpt_first
,
1939 int *lpt_lebs
, int *big_lpt
, u8
*hash
);
1940 int ubifs_lpt_init(struct ubifs_info
*c
, int rd
, int wr
);
1941 struct ubifs_lprops
*ubifs_lpt_lookup(struct ubifs_info
*c
, int lnum
);
1942 struct ubifs_lprops
*ubifs_lpt_lookup_dirty(struct ubifs_info
*c
, int lnum
);
1943 int ubifs_lpt_scan_nolock(struct ubifs_info
*c
, int start_lnum
, int end_lnum
,
1944 ubifs_lpt_scan_callback scan_cb
, void *data
);
1946 /* Shared by lpt.c for lpt_commit.c */
1947 void ubifs_pack_lsave(struct ubifs_info
*c
, void *buf
, int *lsave
);
1948 void ubifs_pack_ltab(struct ubifs_info
*c
, void *buf
,
1949 struct ubifs_lpt_lprops
*ltab
);
1950 void ubifs_pack_pnode(struct ubifs_info
*c
, void *buf
,
1951 struct ubifs_pnode
*pnode
);
1952 void ubifs_pack_nnode(struct ubifs_info
*c
, void *buf
,
1953 struct ubifs_nnode
*nnode
);
1954 struct ubifs_pnode
*ubifs_get_pnode(struct ubifs_info
*c
,
1955 struct ubifs_nnode
*parent
, int iip
);
1956 struct ubifs_nnode
*ubifs_get_nnode(struct ubifs_info
*c
,
1957 struct ubifs_nnode
*parent
, int iip
);
1958 struct ubifs_pnode
*ubifs_pnode_lookup(struct ubifs_info
*c
, int i
);
1959 int ubifs_read_nnode(struct ubifs_info
*c
, struct ubifs_nnode
*parent
, int iip
);
1960 void ubifs_add_lpt_dirt(struct ubifs_info
*c
, int lnum
, int dirty
);
1961 void ubifs_add_nnode_dirt(struct ubifs_info
*c
, struct ubifs_nnode
*nnode
);
1962 uint32_t ubifs_unpack_bits(const struct ubifs_info
*c
, uint8_t **addr
, int *pos
, int nrbits
);
1963 struct ubifs_nnode
*ubifs_first_nnode(struct ubifs_info
*c
, int *hght
);
1964 /* Needed only in debugging code in lpt_commit.c */
1965 int ubifs_unpack_nnode(const struct ubifs_info
*c
, void *buf
,
1966 struct ubifs_nnode
*nnode
);
1967 int ubifs_lpt_calc_hash(struct ubifs_info
*c
, u8
*hash
);
1970 int ubifs_lpt_start_commit(struct ubifs_info
*c
);
1971 int ubifs_lpt_end_commit(struct ubifs_info
*c
);
1972 int ubifs_lpt_post_commit(struct ubifs_info
*c
);
1973 void ubifs_lpt_free(struct ubifs_info
*c
, int wr_only
);
1976 const struct ubifs_lprops
*ubifs_change_lp(struct ubifs_info
*c
,
1977 const struct ubifs_lprops
*lp
,
1978 int free
, int dirty
, int flags
,
1980 void ubifs_get_lp_stats(struct ubifs_info
*c
, struct ubifs_lp_stats
*lst
);
1981 void ubifs_add_to_cat(struct ubifs_info
*c
, struct ubifs_lprops
*lprops
,
1983 void ubifs_replace_cat(struct ubifs_info
*c
, struct ubifs_lprops
*old_lprops
,
1984 struct ubifs_lprops
*new_lprops
);
1985 void ubifs_ensure_cat(struct ubifs_info
*c
, struct ubifs_lprops
*lprops
);
1986 int ubifs_categorize_lprops(const struct ubifs_info
*c
,
1987 const struct ubifs_lprops
*lprops
);
1988 int ubifs_change_one_lp(struct ubifs_info
*c
, int lnum
, int free
, int dirty
,
1989 int flags_set
, int flags_clean
, int idx_gc_cnt
);
1990 int ubifs_update_one_lp(struct ubifs_info
*c
, int lnum
, int free
, int dirty
,
1991 int flags_set
, int flags_clean
);
1992 int ubifs_read_one_lp(struct ubifs_info
*c
, int lnum
, struct ubifs_lprops
*lp
);
1993 const struct ubifs_lprops
*ubifs_fast_find_free(struct ubifs_info
*c
);
1994 const struct ubifs_lprops
*ubifs_fast_find_empty(struct ubifs_info
*c
);
1995 const struct ubifs_lprops
*ubifs_fast_find_freeable(struct ubifs_info
*c
);
1996 const struct ubifs_lprops
*ubifs_fast_find_frdi_idx(struct ubifs_info
*c
);
1997 int ubifs_calc_dark(const struct ubifs_info
*c
, int spc
);
2000 int ubifs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
);
2001 int ubifs_setattr(struct dentry
*dentry
, struct iattr
*attr
);
2002 int ubifs_update_time(struct inode
*inode
, struct timespec64
*time
, int flags
);
2005 struct inode
*ubifs_new_inode(struct ubifs_info
*c
, struct inode
*dir
,
2007 int ubifs_getattr(const struct path
*path
, struct kstat
*stat
,
2008 u32 request_mask
, unsigned int flags
);
2009 int ubifs_check_dir_empty(struct inode
*dir
);
2012 extern const struct xattr_handler
*ubifs_xattr_handlers
[];
2013 ssize_t
ubifs_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
);
2014 int ubifs_xattr_set(struct inode
*host
, const char *name
, const void *value
,
2015 size_t size
, int flags
, bool check_lock
);
2016 ssize_t
ubifs_xattr_get(struct inode
*host
, const char *name
, void *buf
,
2019 #ifdef CONFIG_UBIFS_FS_XATTR
2020 void ubifs_evict_xattr_inode(struct ubifs_info
*c
, ino_t xattr_inum
);
2021 int ubifs_purge_xattrs(struct inode
*host
);
2023 static inline void ubifs_evict_xattr_inode(struct ubifs_info
*c
,
2024 ino_t xattr_inum
) { }
2025 static inline int ubifs_purge_xattrs(struct inode
*host
)
2031 #ifdef CONFIG_UBIFS_FS_SECURITY
2032 extern int ubifs_init_security(struct inode
*dentry
, struct inode
*inode
,
2033 const struct qstr
*qstr
);
2035 static inline int ubifs_init_security(struct inode
*dentry
,
2036 struct inode
*inode
, const struct qstr
*qstr
)
2044 struct inode
*ubifs_iget(struct super_block
*sb
, unsigned long inum
);
2047 int ubifs_recover_master_node(struct ubifs_info
*c
);
2048 int ubifs_write_rcvrd_mst_node(struct ubifs_info
*c
);
2049 struct ubifs_scan_leb
*ubifs_recover_leb(struct ubifs_info
*c
, int lnum
,
2050 int offs
, void *sbuf
, int jhead
);
2051 struct ubifs_scan_leb
*ubifs_recover_log_leb(struct ubifs_info
*c
, int lnum
,
2052 int offs
, void *sbuf
);
2053 int ubifs_recover_inl_heads(struct ubifs_info
*c
, void *sbuf
);
2054 int ubifs_clean_lebs(struct ubifs_info
*c
, void *sbuf
);
2055 int ubifs_rcvry_gc_commit(struct ubifs_info
*c
);
2056 int ubifs_recover_size_accum(struct ubifs_info
*c
, union ubifs_key
*key
,
2057 int deletion
, loff_t new_size
);
2058 int ubifs_recover_size(struct ubifs_info
*c
, bool in_place
);
2059 void ubifs_destroy_size_tree(struct ubifs_info
*c
);
2062 long ubifs_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
);
2063 void ubifs_set_inode_flags(struct inode
*inode
);
2064 #ifdef CONFIG_COMPAT
2065 long ubifs_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
);
2069 int __init
ubifs_compressors_init(void);
2070 void ubifs_compressors_exit(void);
2071 void ubifs_compress(const struct ubifs_info
*c
, const void *in_buf
, int in_len
,
2072 void *out_buf
, int *out_len
, int *compr_type
);
2073 int ubifs_decompress(const struct ubifs_info
*c
, const void *buf
, int len
,
2074 void *out
, int *out_len
, int compr_type
);
2080 #ifndef CONFIG_FS_ENCRYPTION
2081 static inline int ubifs_encrypt(const struct inode
*inode
,
2082 struct ubifs_data_node
*dn
,
2083 unsigned int in_len
, unsigned int *out_len
,
2086 struct ubifs_info
*c
= inode
->i_sb
->s_fs_info
;
2090 static inline int ubifs_decrypt(const struct inode
*inode
,
2091 struct ubifs_data_node
*dn
,
2092 unsigned int *out_len
, int block
)
2094 struct ubifs_info
*c
= inode
->i_sb
->s_fs_info
;
2100 int ubifs_encrypt(const struct inode
*inode
, struct ubifs_data_node
*dn
,
2101 unsigned int in_len
, unsigned int *out_len
, int block
);
2102 int ubifs_decrypt(const struct inode
*inode
, struct ubifs_data_node
*dn
,
2103 unsigned int *out_len
, int block
);
2106 extern const struct fscrypt_operations ubifs_crypt_operations
;
2108 static inline bool ubifs_crypt_is_encrypted(const struct inode
*inode
)
2110 const struct ubifs_inode
*ui
= ubifs_inode(inode
);
2112 return ui
->flags
& UBIFS_CRYPT_FL
;
2115 /* Normal UBIFS messages */
2117 void ubifs_msg(const struct ubifs_info
*c
, const char *fmt
, ...);
2119 void ubifs_err(const struct ubifs_info
*c
, const char *fmt
, ...);
2121 void ubifs_warn(const struct ubifs_info
*c
, const char *fmt
, ...);
2123 * A conditional variant of 'ubifs_err()' which doesn't output anything
2124 * if probing (ie. SB_SILENT set).
2126 #define ubifs_errc(c, fmt, ...) \
2128 if (!(c)->probing) \
2129 ubifs_err(c, fmt, ##__VA_ARGS__); \
2132 #endif /* !__UBIFS_H__ */