ubifs.h 58 KB

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