ubifs.h 56 KB

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