| /* |
| * This file is part of UBIFS. |
| * |
| * Copyright (C) 2008 Nokia Corporation. |
| * Copyright (C) 2008 University of Szeged, Hungary |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 as published by |
| * the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| * You should have received a copy of the GNU General Public License along with |
| * this program; if not, write to the Free Software Foundation, Inc., 51 |
| * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| * Authors: Artem Bityutskiy |
| * Adrian Hunter |
| * Zoltan Sogor |
| */ |
| |
| #ifndef __UBIFS_H__ |
| #define __UBIFS_H__ |
| |
| /* Maximum logical eraseblock size in bytes */ |
| #define UBIFS_MAX_LEB_SZ (2*1024*1024) |
| |
| /* Minimum amount of data UBIFS writes to the flash */ |
| #define MIN_WRITE_SZ (UBIFS_DATA_NODE_SZ + 8) |
| |
| /* Largest key size supported in this implementation */ |
| #define CUR_MAX_KEY_LEN UBIFS_SK_LEN |
| |
| /* |
| * There is no notion of truncation key because truncation nodes do not exist |
| * in TNC. However, when replaying, it is handy to introduce fake "truncation" |
| * keys for truncation nodes because the code becomes simpler. So we define |
| * %UBIFS_TRUN_KEY type. |
| */ |
| #define UBIFS_TRUN_KEY UBIFS_KEY_TYPES_CNT |
| |
| /* The below union makes it easier to deal with keys */ |
| union ubifs_key |
| { |
| uint8_t u8[CUR_MAX_KEY_LEN]; |
| uint32_t u32[CUR_MAX_KEY_LEN/4]; |
| uint64_t u64[CUR_MAX_KEY_LEN/8]; |
| __le32 j32[CUR_MAX_KEY_LEN/4]; |
| }; |
| |
| /* |
| * LEB properties flags. |
| * |
| * LPROPS_UNCAT: not categorized |
| * LPROPS_DIRTY: dirty > 0, not index |
| * LPROPS_DIRTY_IDX: dirty + free > UBIFS_CH_SZ and index |
| * LPROPS_FREE: free > 0, not empty, not index |
| * LPROPS_HEAP_CNT: number of heaps used for storing categorized LEBs |
| * LPROPS_EMPTY: LEB is empty, not taken |
| * LPROPS_FREEABLE: free + dirty == leb_size, not index, not taken |
| * LPROPS_FRDI_IDX: free + dirty == leb_size and index, may be taken |
| * LPROPS_CAT_MASK: mask for the LEB categories above |
| * LPROPS_TAKEN: LEB was taken (this flag is not saved on the media) |
| * LPROPS_INDEX: LEB contains indexing nodes (this flag also exists on flash) |
| */ |
| enum { |
| LPROPS_UNCAT = 0, |
| LPROPS_DIRTY = 1, |
| LPROPS_DIRTY_IDX = 2, |
| LPROPS_FREE = 3, |
| LPROPS_HEAP_CNT = 3, |
| LPROPS_EMPTY = 4, |
| LPROPS_FREEABLE = 5, |
| LPROPS_FRDI_IDX = 6, |
| LPROPS_CAT_MASK = 15, |
| LPROPS_TAKEN = 16, |
| LPROPS_INDEX = 32, |
| }; |
| |
| /** |
| * struct ubifs_lprops - logical eraseblock properties. |
| * @free: amount of free space in bytes |
| * @dirty: amount of dirty space in bytes |
| * @flags: LEB properties flags (see above) |
| */ |
| struct ubifs_lprops |
| { |
| int free; |
| int dirty; |
| int flags; |
| }; |
| |
| /** |
| * struct ubifs_lpt_lprops - LPT logical eraseblock properties. |
| * @free: amount of free space in bytes |
| * @dirty: amount of dirty space in bytes |
| */ |
| struct ubifs_lpt_lprops |
| { |
| int free; |
| int dirty; |
| }; |
| |
| struct ubifs_nnode; |
| |
| /** |
| * struct ubifs_cnode - LEB Properties Tree common node. |
| * @parent: parent nnode |
| * @cnext: next cnode to commit |
| * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE) |
| * @iip: index in parent |
| * @level: level in the tree (zero for pnodes, greater than zero for nnodes) |
| * @num: node number |
| */ |
| struct ubifs_cnode |
| { |
| struct ubifs_nnode *parent; |
| struct ubifs_cnode *cnext; |
| unsigned long flags; |
| int iip; |
| int level; |
| int num; |
| }; |
| |
| /** |
| * struct ubifs_pnode - LEB Properties Tree leaf node. |
| * @parent: parent nnode |
| * @cnext: next cnode to commit |
| * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE) |
| * @iip: index in parent |
| * @level: level in the tree (always zero for pnodes) |
| * @num: node number |
| * @lprops: LEB properties array |
| */ |
| struct ubifs_pnode |
| { |
| struct ubifs_nnode *parent; |
| struct ubifs_cnode *cnext; |
| unsigned long flags; |
| int iip; |
| int level; |
| int num; |
| struct ubifs_lprops lprops[UBIFS_LPT_FANOUT]; |
| }; |
| |
| /** |
| * struct ubifs_nbranch - LEB Properties Tree internal node branch. |
| * @lnum: LEB number of child |
| * @offs: offset of child |
| * @nnode: nnode child |
| * @pnode: pnode child |
| * @cnode: cnode child |
| */ |
| struct ubifs_nbranch |
| { |
| int lnum; |
| int offs; |
| union |
| { |
| struct ubifs_nnode *nnode; |
| struct ubifs_pnode *pnode; |
| struct ubifs_cnode *cnode; |
| }; |
| }; |
| |
| /** |
| * struct ubifs_nnode - LEB Properties Tree internal node. |
| * @parent: parent nnode |
| * @cnext: next cnode to commit |
| * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE) |
| * @iip: index in parent |
| * @level: level in the tree (always greater than zero for nnodes) |
| * @num: node number |
| * @nbranch: branches to child nodes |
| */ |
| struct ubifs_nnode |
| { |
| struct ubifs_nnode *parent; |
| struct ubifs_cnode *cnext; |
| unsigned long flags; |
| int iip; |
| int level; |
| int num; |
| struct ubifs_nbranch nbranch[UBIFS_LPT_FANOUT]; |
| }; |
| |
| /** |
| * struct ubifs_lp_stats - statistics of eraseblocks in the main area. |
| * @empty_lebs: number of empty LEBs |
| * @taken_empty_lebs: number of taken LEBs |
| * @idx_lebs: number of indexing LEBs |
| * @total_free: total free space in bytes |
| * @total_dirty: total dirty space in bytes |
| * @total_used: total used space in bytes (includes only data LEBs) |
| * @total_dead: total dead space in bytes (includes only data LEBs) |
| * @total_dark: total dark space in bytes (includes only data LEBs) |
| */ |
| struct ubifs_lp_stats { |
| int empty_lebs; |
| int taken_empty_lebs; |
| int idx_lebs; |
| long long total_free; |
| long long total_dirty; |
| long long total_used; |
| long long total_dead; |
| long long total_dark; |
| }; |
| |
| /** |
| * struct ubifs_zbranch - key/coordinate/length branch stored in znodes. |
| * @key: key |
| * @znode: znode address in memory |
| * @lnum: LEB number of the indexing node |
| * @offs: offset of the indexing node within @lnum |
| * @len: target node length |
| */ |
| struct ubifs_zbranch |
| { |
| union ubifs_key key; |
| struct ubifs_znode *znode; |
| int lnum; |
| int offs; |
| int len; |
| }; |
| |
| /** |
| * struct ubifs_znode - in-memory representation of an indexing node. |
| * @parent: parent znode or NULL if it is the root |
| * @cnext: next znode to commit |
| * @flags: flags |
| * @time: last access time (seconds) |
| * @level: level of the entry in the TNC tree |
| * @child_cnt: count of child znodes |
| * @iip: index in parent's zbranch array |
| * @alt: lower bound of key range has altered i.e. child inserted at slot 0 |
| * @zbranch: array of znode branches (@c->fanout elements) |
| */ |
| struct ubifs_znode |
| { |
| struct ubifs_znode *parent; |
| struct ubifs_znode *cnext; |
| unsigned long flags; |
| unsigned long time; |
| int level; |
| int child_cnt; |
| int iip; |
| int alt; |
| #ifdef CONFIG_UBIFS_FS_DEBUG |
| int lnum, offs, len; |
| #endif |
| struct ubifs_zbranch zbranch[]; |
| }; |
| |
| /** |
| * struct ubifs_info - UBIFS file-system description data structure |
| * (per-superblock). |
| * |
| * @highest_inum: highest used inode number |
| * @max_sqnum: current global sequence number |
| * |
| * @jhead_cnt: count of journal heads |
| * @max_bud_bytes: maximum number of bytes allowed in buds |
| * |
| * @zroot: zbranch which points to the root index node and znode |
| * @ihead_lnum: LEB number of index head |
| * @ihead_offs: offset of index head |
| * |
| * @log_lebs: number of logical eraseblocks in the log |
| * @lpt_lebs: number of LEBs used for lprops table |
| * @lpt_first: first LEB of the lprops table area |
| * @lpt_last: last LEB of the lprops table area |
| * @main_lebs: count of LEBs in the main area |
| * @main_first: first LEB of the main area |
| * @default_compr: default compression type |
| * @favor_lzo: favor LZO compression method |
| * @favor_percent: lzo vs. zlib threshold used in case favor LZO |
| * |
| * @key_hash_type: type of the key hash |
| * @key_hash: direntry key hash function |
| * @key_fmt: key format |
| * @key_len: key length |
| * @fanout: fanout of the index tree (number of links per indexing node) |
| * |
| * @min_io_size: minimal input/output unit size |
| * @leb_size: logical eraseblock size in bytes |
| * @leb_cnt: count of logical eraseblocks |
| * @max_leb_cnt: maximum count of logical eraseblocks |
| * |
| * @old_idx_sz: size of index on flash |
| * @lst: lprops statistics |
| * |
| * @dead_wm: LEB dead space watermark |
| * @dark_wm: LEB dark space watermark |
| * |
| * @di: UBI device information |
| * @vi: UBI volume information |
| * |
| * @gc_lnum: LEB number used for garbage collection |
| * @rp_size: reserved pool size |
| * |
| * @space_bits: number of bits needed to record free or dirty space |
| * @lpt_lnum_bits: number of bits needed to record a LEB number in the LPT |
| * @lpt_offs_bits: number of bits needed to record an offset in the LPT |
| * @lpt_spc_bits: number of bits needed to space in the LPT |
| * @pcnt_bits: number of bits needed to record pnode or nnode number |
| * @lnum_bits: number of bits needed to record LEB number |
| * @nnode_sz: size of on-flash nnode |
| * @pnode_sz: size of on-flash pnode |
| * @ltab_sz: size of on-flash LPT lprops table |
| * @lsave_sz: size of on-flash LPT save table |
| * @pnode_cnt: number of pnodes |
| * @nnode_cnt: number of nnodes |
| * @lpt_hght: height of the LPT |
| * |
| * @lpt_lnum: LEB number of the root nnode of the LPT |
| * @lpt_offs: offset of the root nnode of the LPT |
| * @nhead_lnum: LEB number of LPT head |
| * @nhead_offs: offset of LPT head |
| * @big_lpt: flag that LPT is too big to write whole during commit |
| * @space_fixup: flag indicating that free space in LEBs needs to be cleaned up |
| * @lpt_sz: LPT size |
| * |
| * @ltab_lnum: LEB number of LPT's own lprops table |
| * @ltab_offs: offset of LPT's own lprops table |
| * @lpt: lprops table |
| * @ltab: LPT's own lprops table |
| * @lsave_cnt: number of LEB numbers in LPT's save table |
| * @lsave_lnum: LEB number of LPT's save table |
| * @lsave_offs: offset of LPT's save table |
| * @lsave: LPT's save table |
| * @lscan_lnum: LEB number of last LPT scan |
| */ |
| struct ubifs_info |
| { |
| ino_t highest_inum; |
| unsigned long long max_sqnum; |
| |
| int jhead_cnt; |
| long long max_bud_bytes; |
| |
| struct ubifs_zbranch zroot; |
| int ihead_lnum; |
| int ihead_offs; |
| |
| int log_lebs; |
| int lpt_lebs; |
| int lpt_first; |
| int lpt_last; |
| int orph_lebs; |
| int main_lebs; |
| int main_first; |
| int default_compr; |
| int favor_lzo; |
| int favor_percent; |
| |
| uint8_t key_hash_type; |
| uint32_t (*key_hash)(const char *str, int len); |
| int key_fmt; |
| int key_len; |
| int fanout; |
| |
| int min_io_size; |
| int leb_size; |
| int leb_cnt; |
| int max_leb_cnt; |
| |
| unsigned long long old_idx_sz; |
| struct ubifs_lp_stats lst; |
| |
| int dead_wm; |
| int dark_wm; |
| |
| struct ubi_dev_info di; |
| struct ubi_vol_info vi; |
| |
| int gc_lnum; |
| long long rp_size; |
| |
| int space_bits; |
| int lpt_lnum_bits; |
| int lpt_offs_bits; |
| int lpt_spc_bits; |
| int pcnt_bits; |
| int lnum_bits; |
| int nnode_sz; |
| int pnode_sz; |
| int ltab_sz; |
| int lsave_sz; |
| int pnode_cnt; |
| int nnode_cnt; |
| int lpt_hght; |
| |
| int lpt_lnum; |
| int lpt_offs; |
| int nhead_lnum; |
| int nhead_offs; |
| int big_lpt; |
| int space_fixup; |
| long long lpt_sz; |
| |
| int ltab_lnum; |
| int ltab_offs; |
| struct ubifs_lprops *lpt; |
| struct ubifs_lpt_lprops *ltab; |
| int lsave_cnt; |
| int lsave_lnum; |
| int lsave_offs; |
| int *lsave; |
| int lscan_lnum; |
| |
| }; |
| |
| /** |
| * ubifs_idx_node_sz - return index node size. |
| * @c: the UBIFS file-system description object |
| * @child_cnt: number of children of this index node |
| */ |
| static inline int ubifs_idx_node_sz(const struct ubifs_info *c, int child_cnt) |
| { |
| return UBIFS_IDX_NODE_SZ + (UBIFS_BRANCH_SZ + c->key_len) * child_cnt; |
| } |
| |
| /** |
| * ubifs_idx_branch - return pointer to an index branch. |
| * @c: the UBIFS file-system description object |
| * @idx: index node |
| * @bnum: branch number |
| */ |
| static inline |
| struct ubifs_branch *ubifs_idx_branch(const struct ubifs_info *c, |
| const struct ubifs_idx_node *idx, |
| int bnum) |
| { |
| return (struct ubifs_branch *)((void *)idx->branches + |
| (UBIFS_BRANCH_SZ + c->key_len) * bnum); |
| } |
| |
| #endif /* __UBIFS_H__ */ |
