ubifs.h 71 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173
  1. /*
  2. * This file is part of UBIFS.
  3. *
  4. * Copyright (C) 2006-2008 Nokia Corporation
  5. *
  6. * (C) Copyright 2008-2009
  7. * Stefan Roese, DENX Software Engineering, sr@denx.de.
  8. *
  9. * This program is free software; you can redistribute it and/or modify it
  10. * under the terms of the GNU General Public License version 2 as published by
  11. * the Free Software Foundation.
  12. *
  13. * This program is distributed in the hope that it will be useful, but WITHOUT
  14. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  16. * more details.
  17. *
  18. * You should have received a copy of the GNU General Public License along with
  19. * this program; if not, write to the Free Software Foundation, Inc., 51
  20. * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21. *
  22. * Authors: Artem Bityutskiy (Битюцкий Артём)
  23. * Adrian Hunter
  24. */
  25. #ifndef __UBIFS_H__
  26. #define __UBIFS_H__
  27. #if 0 /* Enable for debugging output */
  28. #define CONFIG_UBIFS_FS_DEBUG
  29. #define CONFIG_UBIFS_FS_DEBUG_MSG_LVL 3
  30. #endif
  31. #include <ubi_uboot.h>
  32. #include <linux/ctype.h>
  33. #include <linux/time.h>
  34. #include <linux/math64.h>
  35. #include "ubifs-media.h"
  36. struct dentry;
  37. struct file;
  38. struct iattr;
  39. struct kstat;
  40. struct vfsmount;
  41. extern struct super_block *ubifs_sb;
  42. extern unsigned int ubifs_msg_flags;
  43. extern unsigned int ubifs_chk_flags;
  44. extern unsigned int ubifs_tst_flags;
  45. #define pgoff_t unsigned long
  46. /*
  47. * We "simulate" the Linux page struct much simpler here
  48. */
  49. struct page {
  50. pgoff_t index;
  51. void *addr;
  52. struct inode *inode;
  53. };
  54. void iput(struct inode *inode);
  55. /*
  56. * The atomic operations are used for budgeting etc which is not
  57. * needed for the read-only U-Boot implementation:
  58. */
  59. #define atomic_long_inc(a)
  60. #define atomic_long_dec(a)
  61. #define atomic_long_sub(a, b)
  62. /* linux/include/time.h */
  63. struct timespec {
  64. time_t tv_sec; /* seconds */
  65. long tv_nsec; /* nanoseconds */
  66. };
  67. /* linux/include/dcache.h */
  68. /*
  69. * "quick string" -- eases parameter passing, but more importantly
  70. * saves "metadata" about the string (ie length and the hash).
  71. *
  72. * hash comes first so it snuggles against d_parent in the
  73. * dentry.
  74. */
  75. struct qstr {
  76. unsigned int hash;
  77. unsigned int len;
  78. const char *name;
  79. };
  80. struct inode {
  81. struct hlist_node i_hash;
  82. struct list_head i_list;
  83. struct list_head i_sb_list;
  84. struct list_head i_dentry;
  85. unsigned long i_ino;
  86. unsigned int i_nlink;
  87. uid_t i_uid;
  88. gid_t i_gid;
  89. dev_t i_rdev;
  90. u64 i_version;
  91. loff_t i_size;
  92. #ifdef __NEED_I_SIZE_ORDERED
  93. seqcount_t i_size_seqcount;
  94. #endif
  95. struct timespec i_atime;
  96. struct timespec i_mtime;
  97. struct timespec i_ctime;
  98. unsigned int i_blkbits;
  99. unsigned short i_bytes;
  100. umode_t i_mode;
  101. spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
  102. struct mutex i_mutex;
  103. struct rw_semaphore i_alloc_sem;
  104. const struct inode_operations *i_op;
  105. const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
  106. struct super_block *i_sb;
  107. struct file_lock *i_flock;
  108. #ifdef CONFIG_QUOTA
  109. struct dquot *i_dquot[MAXQUOTAS];
  110. #endif
  111. struct list_head i_devices;
  112. int i_cindex;
  113. __u32 i_generation;
  114. #ifdef CONFIG_DNOTIFY
  115. unsigned long i_dnotify_mask; /* Directory notify events */
  116. struct dnotify_struct *i_dnotify; /* for directory notifications */
  117. #endif
  118. #ifdef CONFIG_INOTIFY
  119. struct list_head inotify_watches; /* watches on this inode */
  120. struct mutex inotify_mutex; /* protects the watches list */
  121. #endif
  122. unsigned long i_state;
  123. unsigned long dirtied_when; /* jiffies of first dirtying */
  124. unsigned int i_flags;
  125. #ifdef CONFIG_SECURITY
  126. void *i_security;
  127. #endif
  128. void *i_private; /* fs or device private pointer */
  129. };
  130. struct super_block {
  131. struct list_head s_list; /* Keep this first */
  132. dev_t s_dev; /* search index; _not_ kdev_t */
  133. unsigned long s_blocksize;
  134. unsigned char s_blocksize_bits;
  135. unsigned char s_dirt;
  136. unsigned long long s_maxbytes; /* Max file size */
  137. struct file_system_type *s_type;
  138. const struct super_operations *s_op;
  139. struct dquot_operations *dq_op;
  140. struct quotactl_ops *s_qcop;
  141. const struct export_operations *s_export_op;
  142. unsigned long s_flags;
  143. unsigned long s_magic;
  144. struct dentry *s_root;
  145. struct rw_semaphore s_umount;
  146. struct mutex s_lock;
  147. int s_count;
  148. int s_syncing;
  149. int s_need_sync_fs;
  150. #ifdef CONFIG_SECURITY
  151. void *s_security;
  152. #endif
  153. struct xattr_handler **s_xattr;
  154. struct list_head s_inodes; /* all inodes */
  155. struct list_head s_dirty; /* dirty inodes */
  156. struct list_head s_io; /* parked for writeback */
  157. struct list_head s_more_io; /* parked for more writeback */
  158. struct hlist_head s_anon; /* anonymous dentries for (nfs) exporting */
  159. struct list_head s_files;
  160. /* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
  161. struct list_head s_dentry_lru; /* unused dentry lru */
  162. int s_nr_dentry_unused; /* # of dentry on lru */
  163. struct block_device *s_bdev;
  164. struct mtd_info *s_mtd;
  165. struct list_head s_instances;
  166. int s_frozen;
  167. wait_queue_head_t s_wait_unfrozen;
  168. char s_id[32]; /* Informational name */
  169. void *s_fs_info; /* Filesystem private info */
  170. /*
  171. * The next field is for VFS *only*. No filesystems have any business
  172. * even looking at it. You had been warned.
  173. */
  174. struct mutex s_vfs_rename_mutex; /* Kludge */
  175. /* Granularity of c/m/atime in ns.
  176. Cannot be worse than a second */
  177. u32 s_time_gran;
  178. /*
  179. * Filesystem subtype. If non-empty the filesystem type field
  180. * in /proc/mounts will be "type.subtype"
  181. */
  182. char *s_subtype;
  183. /*
  184. * Saved mount options for lazy filesystems using
  185. * generic_show_options()
  186. */
  187. char *s_options;
  188. };
  189. struct file_system_type {
  190. const char *name;
  191. int fs_flags;
  192. int (*get_sb) (struct file_system_type *, int,
  193. const char *, void *, struct vfsmount *);
  194. void (*kill_sb) (struct super_block *);
  195. struct module *owner;
  196. struct file_system_type * next;
  197. struct list_head fs_supers;
  198. };
  199. struct vfsmount {
  200. struct list_head mnt_hash;
  201. struct vfsmount *mnt_parent; /* fs we are mounted on */
  202. struct dentry *mnt_mountpoint; /* dentry of mountpoint */
  203. struct dentry *mnt_root; /* root of the mounted tree */
  204. struct super_block *mnt_sb; /* pointer to superblock */
  205. struct list_head mnt_mounts; /* list of children, anchored here */
  206. struct list_head mnt_child; /* and going through their mnt_child */
  207. int mnt_flags;
  208. /* 4 bytes hole on 64bits arches */
  209. const char *mnt_devname; /* Name of device e.g. /dev/dsk/hda1 */
  210. struct list_head mnt_list;
  211. struct list_head mnt_expire; /* link in fs-specific expiry list */
  212. struct list_head mnt_share; /* circular list of shared mounts */
  213. struct list_head mnt_slave_list;/* list of slave mounts */
  214. struct list_head mnt_slave; /* slave list entry */
  215. struct vfsmount *mnt_master; /* slave is on master->mnt_slave_list */
  216. struct mnt_namespace *mnt_ns; /* containing namespace */
  217. int mnt_id; /* mount identifier */
  218. int mnt_group_id; /* peer group identifier */
  219. /*
  220. * We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
  221. * to let these frequently modified fields in a separate cache line
  222. * (so that reads of mnt_flags wont ping-pong on SMP machines)
  223. */
  224. int mnt_expiry_mark; /* true if marked for expiry */
  225. int mnt_pinned;
  226. int mnt_ghosts;
  227. /*
  228. * This value is not stable unless all of the mnt_writers[] spinlocks
  229. * are held, and all mnt_writer[]s on this mount have 0 as their ->count
  230. */
  231. };
  232. struct path {
  233. struct vfsmount *mnt;
  234. struct dentry *dentry;
  235. };
  236. struct file {
  237. struct path f_path;
  238. #define f_dentry f_path.dentry
  239. #define f_vfsmnt f_path.mnt
  240. const struct file_operations *f_op;
  241. unsigned int f_flags;
  242. loff_t f_pos;
  243. unsigned int f_uid, f_gid;
  244. u64 f_version;
  245. #ifdef CONFIG_SECURITY
  246. void *f_security;
  247. #endif
  248. /* needed for tty driver, and maybe others */
  249. void *private_data;
  250. #ifdef CONFIG_EPOLL
  251. /* Used by fs/eventpoll.c to link all the hooks to this file */
  252. struct list_head f_ep_links;
  253. spinlock_t f_ep_lock;
  254. #endif /* #ifdef CONFIG_EPOLL */
  255. #ifdef CONFIG_DEBUG_WRITECOUNT
  256. unsigned long f_mnt_write_state;
  257. #endif
  258. };
  259. /*
  260. * get_seconds() not really needed in the read-only implmentation
  261. */
  262. #define get_seconds() 0
  263. /* 4k page size */
  264. #define PAGE_CACHE_SHIFT 12
  265. #define PAGE_CACHE_SIZE (1 << PAGE_CACHE_SHIFT)
  266. /* Page cache limit. The filesystems should put that into their s_maxbytes
  267. limits, otherwise bad things can happen in VM. */
  268. #if BITS_PER_LONG==32
  269. #define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
  270. #elif BITS_PER_LONG==64
  271. #define MAX_LFS_FILESIZE 0x7fffffffffffffffUL
  272. #endif
  273. #define INT_MAX ((int)(~0U>>1))
  274. #define INT_MIN (-INT_MAX - 1)
  275. #define LLONG_MAX ((long long)(~0ULL>>1))
  276. /*
  277. * These are the fs-independent mount-flags: up to 32 flags are supported
  278. */
  279. #define MS_RDONLY 1 /* Mount read-only */
  280. #define MS_NOSUID 2 /* Ignore suid and sgid bits */
  281. #define MS_NODEV 4 /* Disallow access to device special files */
  282. #define MS_NOEXEC 8 /* Disallow program execution */
  283. #define MS_SYNCHRONOUS 16 /* Writes are synced at once */
  284. #define MS_REMOUNT 32 /* Alter flags of a mounted FS */
  285. #define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
  286. #define MS_DIRSYNC 128 /* Directory modifications are synchronous */
  287. #define MS_NOATIME 1024 /* Do not update access times. */
  288. #define MS_NODIRATIME 2048 /* Do not update directory access times */
  289. #define MS_BIND 4096
  290. #define MS_MOVE 8192
  291. #define MS_REC 16384
  292. #define MS_VERBOSE 32768 /* War is peace. Verbosity is silence.
  293. MS_VERBOSE is deprecated. */
  294. #define MS_SILENT 32768
  295. #define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
  296. #define MS_UNBINDABLE (1<<17) /* change to unbindable */
  297. #define MS_PRIVATE (1<<18) /* change to private */
  298. #define MS_SLAVE (1<<19) /* change to slave */
  299. #define MS_SHARED (1<<20) /* change to shared */
  300. #define MS_RELATIME (1<<21) /* Update atime relative to mtime/ctime. */
  301. #define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */
  302. #define MS_I_VERSION (1<<23) /* Update inode I_version field */
  303. #define MS_ACTIVE (1<<30)
  304. #define MS_NOUSER (1<<31)
  305. #define I_NEW 8
  306. /* Inode flags - they have nothing to superblock flags now */
  307. #define S_SYNC 1 /* Writes are synced at once */
  308. #define S_NOATIME 2 /* Do not update access times */
  309. #define S_APPEND 4 /* Append-only file */
  310. #define S_IMMUTABLE 8 /* Immutable file */
  311. #define S_DEAD 16 /* removed, but still open directory */
  312. #define S_NOQUOTA 32 /* Inode is not counted to quota */
  313. #define S_DIRSYNC 64 /* Directory modifications are synchronous */
  314. #define S_NOCMTIME 128 /* Do not update file c/mtime */
  315. #define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */
  316. #define S_PRIVATE 512 /* Inode is fs-internal */
  317. /* include/linux/stat.h */
  318. #define S_IFMT 00170000
  319. #define S_IFSOCK 0140000
  320. #define S_IFLNK 0120000
  321. #define S_IFREG 0100000
  322. #define S_IFBLK 0060000
  323. #define S_IFDIR 0040000
  324. #define S_IFCHR 0020000
  325. #define S_IFIFO 0010000
  326. #define S_ISUID 0004000
  327. #define S_ISGID 0002000
  328. #define S_ISVTX 0001000
  329. /* include/linux/fs.h */
  330. /*
  331. * File types
  332. *
  333. * NOTE! These match bits 12..15 of stat.st_mode
  334. * (ie "(i_mode >> 12) & 15").
  335. */
  336. #define DT_UNKNOWN 0
  337. #define DT_FIFO 1
  338. #define DT_CHR 2
  339. #define DT_DIR 4
  340. #define DT_BLK 6
  341. #define DT_REG 8
  342. #define DT_LNK 10
  343. #define DT_SOCK 12
  344. #define DT_WHT 14
  345. #define I_DIRTY_SYNC 1
  346. #define I_DIRTY_DATASYNC 2
  347. #define I_DIRTY_PAGES 4
  348. #define I_NEW 8
  349. #define I_WILL_FREE 16
  350. #define I_FREEING 32
  351. #define I_CLEAR 64
  352. #define __I_LOCK 7
  353. #define I_LOCK (1 << __I_LOCK)
  354. #define __I_SYNC 8
  355. #define I_SYNC (1 << __I_SYNC)
  356. #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
  357. /* linux/include/dcache.h */
  358. #define DNAME_INLINE_LEN_MIN 36
  359. struct dentry {
  360. unsigned int d_flags; /* protected by d_lock */
  361. spinlock_t d_lock; /* per dentry lock */
  362. struct inode *d_inode; /* Where the name belongs to - NULL is
  363. * negative */
  364. /*
  365. * The next three fields are touched by __d_lookup. Place them here
  366. * so they all fit in a cache line.
  367. */
  368. struct hlist_node d_hash; /* lookup hash list */
  369. struct dentry *d_parent; /* parent directory */
  370. struct qstr d_name;
  371. struct list_head d_lru; /* LRU list */
  372. /*
  373. * d_child and d_rcu can share memory
  374. */
  375. struct list_head d_subdirs; /* our children */
  376. struct list_head d_alias; /* inode alias list */
  377. unsigned long d_time; /* used by d_revalidate */
  378. struct super_block *d_sb; /* The root of the dentry tree */
  379. void *d_fsdata; /* fs-specific data */
  380. #ifdef CONFIG_PROFILING
  381. struct dcookie_struct *d_cookie; /* cookie, if any */
  382. #endif
  383. int d_mounted;
  384. unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */
  385. };
  386. static inline ino_t parent_ino(struct dentry *dentry)
  387. {
  388. ino_t res;
  389. spin_lock(&dentry->d_lock);
  390. res = dentry->d_parent->d_inode->i_ino;
  391. spin_unlock(&dentry->d_lock);
  392. return res;
  393. }
  394. /* linux/include/linux/bitops.h */
  395. #define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))
  396. #define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
  397. /* linux/include/asm-generic/bitops/non-atomic.h */
  398. /**
  399. * __set_bit - Set a bit in memory
  400. * @nr: the bit to set
  401. * @addr: the address to start counting from
  402. *
  403. * Unlike set_bit(), this function is non-atomic and may be reordered.
  404. * If it's called on the same region of memory simultaneously, the effect
  405. * may be that only one operation succeeds.
  406. */
  407. static inline void __set_bit(int nr, volatile unsigned long *addr)
  408. {
  409. unsigned long mask = BIT_MASK(nr);
  410. unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
  411. *p |= mask;
  412. }
  413. static inline void __clear_bit(int nr, volatile unsigned long *addr)
  414. {
  415. unsigned long mask = BIT_MASK(nr);
  416. unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
  417. *p &= ~mask;
  418. }
  419. /* debug.c */
  420. #define DEFINE_SPINLOCK(...)
  421. #define module_param_named(...)
  422. /* misc.h */
  423. #define mutex_lock_nested(...)
  424. #define mutex_unlock_nested(...)
  425. #define mutex_is_locked(...) 0
  426. /* Version of this UBIFS implementation */
  427. #define UBIFS_VERSION 1
  428. /* Normal UBIFS messages */
  429. #define ubifs_msg(fmt, ...) \
  430. printk(KERN_NOTICE "UBIFS: " fmt "\n", ##__VA_ARGS__)
  431. /* UBIFS error messages */
  432. #define ubifs_err(fmt, ...) \
  433. printk(KERN_ERR "UBIFS error (pid %d): %s: " fmt "\n", 0, \
  434. __func__, ##__VA_ARGS__)
  435. /* UBIFS warning messages */
  436. #define ubifs_warn(fmt, ...) \
  437. printk(KERN_WARNING "UBIFS warning (pid %d): %s: " fmt "\n", \
  438. 0, __func__, ##__VA_ARGS__)
  439. /* UBIFS file system VFS magic number */
  440. #define UBIFS_SUPER_MAGIC 0x24051905
  441. /* Number of UBIFS blocks per VFS page */
  442. #define UBIFS_BLOCKS_PER_PAGE (PAGE_CACHE_SIZE / UBIFS_BLOCK_SIZE)
  443. #define UBIFS_BLOCKS_PER_PAGE_SHIFT (PAGE_CACHE_SHIFT - UBIFS_BLOCK_SHIFT)
  444. /* "File system end of life" sequence number watermark */
  445. #define SQNUM_WARN_WATERMARK 0xFFFFFFFF00000000ULL
  446. #define SQNUM_WATERMARK 0xFFFFFFFFFF000000ULL
  447. /*
  448. * Minimum amount of LEBs reserved for the index. At present the index needs at
  449. * least 2 LEBs: one for the index head and one for in-the-gaps method (which
  450. * currently does not cater for the index head and so excludes it from
  451. * consideration).
  452. */
  453. #define MIN_INDEX_LEBS 2
  454. /* Minimum amount of data UBIFS writes to the flash */
  455. #define MIN_WRITE_SZ (UBIFS_DATA_NODE_SZ + 8)
  456. /*
  457. * Currently we do not support inode number overlapping and re-using, so this
  458. * watermark defines dangerous inode number level. This should be fixed later,
  459. * although it is difficult to exceed current limit. Another option is to use
  460. * 64-bit inode numbers, but this means more overhead.
  461. */
  462. #define INUM_WARN_WATERMARK 0xFFF00000
  463. #define INUM_WATERMARK 0xFFFFFF00
  464. /* Largest key size supported in this implementation */
  465. #define CUR_MAX_KEY_LEN UBIFS_SK_LEN
  466. /* Maximum number of entries in each LPT (LEB category) heap */
  467. #define LPT_HEAP_SZ 256
  468. /*
  469. * Background thread name pattern. The numbers are UBI device and volume
  470. * numbers.
  471. */
  472. #define BGT_NAME_PATTERN "ubifs_bgt%d_%d"
  473. /* Default write-buffer synchronization timeout (5 secs) */
  474. #define DEFAULT_WBUF_TIMEOUT (5 * HZ)
  475. /* Maximum possible inode number (only 32-bit inodes are supported now) */
  476. #define MAX_INUM 0xFFFFFFFF
  477. /* Number of non-data journal heads */
  478. #define NONDATA_JHEADS_CNT 2
  479. /* Garbage collector head */
  480. #define GCHD 0
  481. /* Base journal head number */
  482. #define BASEHD 1
  483. /* First "general purpose" journal head */
  484. #define DATAHD 2
  485. /* 'No change' value for 'ubifs_change_lp()' */
  486. #define LPROPS_NC 0x80000001
  487. /*
  488. * There is no notion of truncation key because truncation nodes do not exist
  489. * in TNC. However, when replaying, it is handy to introduce fake "truncation"
  490. * keys for truncation nodes because the code becomes simpler. So we define
  491. * %UBIFS_TRUN_KEY type.
  492. */
  493. #define UBIFS_TRUN_KEY UBIFS_KEY_TYPES_CNT
  494. /*
  495. * How much a directory entry/extended attribute entry adds to the parent/host
  496. * inode.
  497. */
  498. #define CALC_DENT_SIZE(name_len) ALIGN(UBIFS_DENT_NODE_SZ + (name_len) + 1, 8)
  499. /* How much an extended attribute adds to the host inode */
  500. #define CALC_XATTR_BYTES(data_len) ALIGN(UBIFS_INO_NODE_SZ + (data_len) + 1, 8)
  501. /*
  502. * Znodes which were not touched for 'OLD_ZNODE_AGE' seconds are considered
  503. * "old", and znode which were touched last 'YOUNG_ZNODE_AGE' seconds ago are
  504. * considered "young". This is used by shrinker when selecting znode to trim
  505. * off.
  506. */
  507. #define OLD_ZNODE_AGE 20
  508. #define YOUNG_ZNODE_AGE 5
  509. /*
  510. * Some compressors, like LZO, may end up with more data then the input buffer.
  511. * So UBIFS always allocates larger output buffer, to be sure the compressor
  512. * will not corrupt memory in case of worst case compression.
  513. */
  514. #define WORST_COMPR_FACTOR 2
  515. /* Maximum expected tree height for use by bottom_up_buf */
  516. #define BOTTOM_UP_HEIGHT 64
  517. /* Maximum number of data nodes to bulk-read */
  518. #define UBIFS_MAX_BULK_READ 32
  519. /*
  520. * Lockdep classes for UBIFS inode @ui_mutex.
  521. */
  522. enum {
  523. WB_MUTEX_1 = 0,
  524. WB_MUTEX_2 = 1,
  525. WB_MUTEX_3 = 2,
  526. };
  527. /*
  528. * Znode flags (actually, bit numbers which store the flags).
  529. *
  530. * DIRTY_ZNODE: znode is dirty
  531. * COW_ZNODE: znode is being committed and a new instance of this znode has to
  532. * be created before changing this znode
  533. * OBSOLETE_ZNODE: znode is obsolete, which means it was deleted, but it is
  534. * still in the commit list and the ongoing commit operation
  535. * will commit it, and delete this znode after it is done
  536. */
  537. enum {
  538. DIRTY_ZNODE = 0,
  539. COW_ZNODE = 1,
  540. OBSOLETE_ZNODE = 2,
  541. };
  542. /*
  543. * Commit states.
  544. *
  545. * COMMIT_RESTING: commit is not wanted
  546. * COMMIT_BACKGROUND: background commit has been requested
  547. * COMMIT_REQUIRED: commit is required
  548. * COMMIT_RUNNING_BACKGROUND: background commit is running
  549. * COMMIT_RUNNING_REQUIRED: commit is running and it is required
  550. * COMMIT_BROKEN: commit failed
  551. */
  552. enum {
  553. COMMIT_RESTING = 0,
  554. COMMIT_BACKGROUND,
  555. COMMIT_REQUIRED,
  556. COMMIT_RUNNING_BACKGROUND,
  557. COMMIT_RUNNING_REQUIRED,
  558. COMMIT_BROKEN,
  559. };
  560. /*
  561. * 'ubifs_scan_a_node()' return values.
  562. *
  563. * SCANNED_GARBAGE: scanned garbage
  564. * SCANNED_EMPTY_SPACE: scanned empty space
  565. * SCANNED_A_NODE: scanned a valid node
  566. * SCANNED_A_CORRUPT_NODE: scanned a corrupted node
  567. * SCANNED_A_BAD_PAD_NODE: scanned a padding node with invalid pad length
  568. *
  569. * Greater than zero means: 'scanned that number of padding bytes'
  570. */
  571. enum {
  572. SCANNED_GARBAGE = 0,
  573. SCANNED_EMPTY_SPACE = -1,
  574. SCANNED_A_NODE = -2,
  575. SCANNED_A_CORRUPT_NODE = -3,
  576. SCANNED_A_BAD_PAD_NODE = -4,
  577. };
  578. /*
  579. * LPT cnode flag bits.
  580. *
  581. * DIRTY_CNODE: cnode is dirty
  582. * COW_CNODE: cnode is being committed and must be copied before writing
  583. * OBSOLETE_CNODE: cnode is being committed and has been copied (or deleted),
  584. * so it can (and must) be freed when the commit is finished
  585. */
  586. enum {
  587. DIRTY_CNODE = 0,
  588. COW_CNODE = 1,
  589. OBSOLETE_CNODE = 2,
  590. };
  591. /*
  592. * Dirty flag bits (lpt_drty_flgs) for LPT special nodes.
  593. *
  594. * LTAB_DIRTY: ltab node is dirty
  595. * LSAVE_DIRTY: lsave node is dirty
  596. */
  597. enum {
  598. LTAB_DIRTY = 1,
  599. LSAVE_DIRTY = 2,
  600. };
  601. /*
  602. * Return codes used by the garbage collector.
  603. * @LEB_FREED: the logical eraseblock was freed and is ready to use
  604. * @LEB_FREED_IDX: indexing LEB was freed and can be used only after the commit
  605. * @LEB_RETAINED: the logical eraseblock was freed and retained for GC purposes
  606. */
  607. enum {
  608. LEB_FREED,
  609. LEB_FREED_IDX,
  610. LEB_RETAINED,
  611. };
  612. /**
  613. * struct ubifs_old_idx - index node obsoleted since last commit start.
  614. * @rb: rb-tree node
  615. * @lnum: LEB number of obsoleted index node
  616. * @offs: offset of obsoleted index node
  617. */
  618. struct ubifs_old_idx {
  619. struct rb_node rb;
  620. int lnum;
  621. int offs;
  622. };
  623. /* The below union makes it easier to deal with keys */
  624. union ubifs_key {
  625. uint8_t u8[CUR_MAX_KEY_LEN];
  626. uint32_t u32[CUR_MAX_KEY_LEN/4];
  627. uint64_t u64[CUR_MAX_KEY_LEN/8];
  628. __le32 j32[CUR_MAX_KEY_LEN/4];
  629. };
  630. /**
  631. * struct ubifs_scan_node - UBIFS scanned node information.
  632. * @list: list of scanned nodes
  633. * @key: key of node scanned (if it has one)
  634. * @sqnum: sequence number
  635. * @type: type of node scanned
  636. * @offs: offset with LEB of node scanned
  637. * @len: length of node scanned
  638. * @node: raw node
  639. */
  640. struct ubifs_scan_node {
  641. struct list_head list;
  642. union ubifs_key key;
  643. unsigned long long sqnum;
  644. int type;
  645. int offs;
  646. int len;
  647. void *node;
  648. };
  649. /**
  650. * struct ubifs_scan_leb - UBIFS scanned LEB information.
  651. * @lnum: logical eraseblock number
  652. * @nodes_cnt: number of nodes scanned
  653. * @nodes: list of struct ubifs_scan_node
  654. * @endpt: end point (and therefore the start of empty space)
  655. * @ecc: read returned -EBADMSG
  656. * @buf: buffer containing entire LEB scanned
  657. */
  658. struct ubifs_scan_leb {
  659. int lnum;
  660. int nodes_cnt;
  661. struct list_head nodes;
  662. int endpt;
  663. int ecc;
  664. void *buf;
  665. };
  666. /**
  667. * struct ubifs_gced_idx_leb - garbage-collected indexing LEB.
  668. * @list: list
  669. * @lnum: LEB number
  670. * @unmap: OK to unmap this LEB
  671. *
  672. * This data structure is used to temporary store garbage-collected indexing
  673. * LEBs - they are not released immediately, but only after the next commit.
  674. * This is needed to guarantee recoverability.
  675. */
  676. struct ubifs_gced_idx_leb {
  677. struct list_head list;
  678. int lnum;
  679. int unmap;
  680. };
  681. /**
  682. * struct ubifs_inode - UBIFS in-memory inode description.
  683. * @vfs_inode: VFS inode description object
  684. * @creat_sqnum: sequence number at time of creation
  685. * @del_cmtno: commit number corresponding to the time the inode was deleted,
  686. * protected by @c->commit_sem;
  687. * @xattr_size: summarized size of all extended attributes in bytes
  688. * @xattr_cnt: count of extended attributes this inode has
  689. * @xattr_names: sum of lengths of all extended attribute names belonging to
  690. * this inode
  691. * @dirty: non-zero if the inode is dirty
  692. * @xattr: non-zero if this is an extended attribute inode
  693. * @bulk_read: non-zero if bulk-read should be used
  694. * @ui_mutex: serializes inode write-back with the rest of VFS operations,
  695. * serializes "clean <-> dirty" state changes, serializes bulk-read,
  696. * protects @dirty, @bulk_read, @ui_size, and @xattr_size
  697. * @ui_lock: protects @synced_i_size
  698. * @synced_i_size: synchronized size of inode, i.e. the value of inode size
  699. * currently stored on the flash; used only for regular file
  700. * inodes
  701. * @ui_size: inode size used by UBIFS when writing to flash
  702. * @flags: inode flags (@UBIFS_COMPR_FL, etc)
  703. * @compr_type: default compression type used for this inode
  704. * @last_page_read: page number of last page read (for bulk read)
  705. * @read_in_a_row: number of consecutive pages read in a row (for bulk read)
  706. * @data_len: length of the data attached to the inode
  707. * @data: inode's data
  708. *
  709. * @ui_mutex exists for two main reasons. At first it prevents inodes from
  710. * being written back while UBIFS changing them, being in the middle of an VFS
  711. * operation. This way UBIFS makes sure the inode fields are consistent. For
  712. * example, in 'ubifs_rename()' we change 3 inodes simultaneously, and
  713. * write-back must not write any of them before we have finished.
  714. *
  715. * The second reason is budgeting - UBIFS has to budget all operations. If an
  716. * operation is going to mark an inode dirty, it has to allocate budget for
  717. * this. It cannot just mark it dirty because there is no guarantee there will
  718. * be enough flash space to write the inode back later. This means UBIFS has
  719. * to have full control over inode "clean <-> dirty" transitions (and pages
  720. * actually). But unfortunately, VFS marks inodes dirty in many places, and it
  721. * does not ask the file-system if it is allowed to do so (there is a notifier,
  722. * but it is not enough), i.e., there is no mechanism to synchronize with this.
  723. * So UBIFS has its own inode dirty flag and its own mutex to serialize
  724. * "clean <-> dirty" transitions.
  725. *
  726. * The @synced_i_size field is used to make sure we never write pages which are
  727. * beyond last synchronized inode size. See 'ubifs_writepage()' for more
  728. * information.
  729. *
  730. * The @ui_size is a "shadow" variable for @inode->i_size and UBIFS uses
  731. * @ui_size instead of @inode->i_size. The reason for this is that UBIFS cannot
  732. * make sure @inode->i_size is always changed under @ui_mutex, because it
  733. * cannot call 'vmtruncate()' with @ui_mutex locked, because it would deadlock
  734. * with 'ubifs_writepage()' (see file.c). All the other inode fields are
  735. * changed under @ui_mutex, so they do not need "shadow" fields. Note, one
  736. * could consider to rework locking and base it on "shadow" fields.
  737. */
  738. struct ubifs_inode {
  739. struct inode vfs_inode;
  740. unsigned long long creat_sqnum;
  741. unsigned long long del_cmtno;
  742. unsigned int xattr_size;
  743. unsigned int xattr_cnt;
  744. unsigned int xattr_names;
  745. unsigned int dirty:1;
  746. unsigned int xattr:1;
  747. unsigned int bulk_read:1;
  748. unsigned int compr_type:2;
  749. struct mutex ui_mutex;
  750. spinlock_t ui_lock;
  751. loff_t synced_i_size;
  752. loff_t ui_size;
  753. int flags;
  754. pgoff_t last_page_read;
  755. pgoff_t read_in_a_row;
  756. int data_len;
  757. void *data;
  758. };
  759. /**
  760. * struct ubifs_unclean_leb - records a LEB recovered under read-only mode.
  761. * @list: list
  762. * @lnum: LEB number of recovered LEB
  763. * @endpt: offset where recovery ended
  764. *
  765. * This structure records a LEB identified during recovery that needs to be
  766. * cleaned but was not because UBIFS was mounted read-only. The information
  767. * is used to clean the LEB when remounting to read-write mode.
  768. */
  769. struct ubifs_unclean_leb {
  770. struct list_head list;
  771. int lnum;
  772. int endpt;
  773. };
  774. /*
  775. * LEB properties flags.
  776. *
  777. * LPROPS_UNCAT: not categorized
  778. * LPROPS_DIRTY: dirty > free, dirty >= @c->dead_wm, not index
  779. * LPROPS_DIRTY_IDX: dirty + free > @c->min_idx_node_sze and index
  780. * LPROPS_FREE: free > 0, dirty < @c->dead_wm, not empty, not index
  781. * LPROPS_HEAP_CNT: number of heaps used for storing categorized LEBs
  782. * LPROPS_EMPTY: LEB is empty, not taken
  783. * LPROPS_FREEABLE: free + dirty == leb_size, not index, not taken
  784. * LPROPS_FRDI_IDX: free + dirty == leb_size and index, may be taken
  785. * LPROPS_CAT_MASK: mask for the LEB categories above
  786. * LPROPS_TAKEN: LEB was taken (this flag is not saved on the media)
  787. * LPROPS_INDEX: LEB contains indexing nodes (this flag also exists on flash)
  788. */
  789. enum {
  790. LPROPS_UNCAT = 0,
  791. LPROPS_DIRTY = 1,
  792. LPROPS_DIRTY_IDX = 2,
  793. LPROPS_FREE = 3,
  794. LPROPS_HEAP_CNT = 3,
  795. LPROPS_EMPTY = 4,
  796. LPROPS_FREEABLE = 5,
  797. LPROPS_FRDI_IDX = 6,
  798. LPROPS_CAT_MASK = 15,
  799. LPROPS_TAKEN = 16,
  800. LPROPS_INDEX = 32,
  801. };
  802. /**
  803. * struct ubifs_lprops - logical eraseblock properties.
  804. * @free: amount of free space in bytes
  805. * @dirty: amount of dirty space in bytes
  806. * @flags: LEB properties flags (see above)
  807. * @lnum: LEB number
  808. * @list: list of same-category lprops (for LPROPS_EMPTY and LPROPS_FREEABLE)
  809. * @hpos: heap position in heap of same-category lprops (other categories)
  810. */
  811. struct ubifs_lprops {
  812. int free;
  813. int dirty;
  814. int flags;
  815. int lnum;
  816. union {
  817. struct list_head list;
  818. int hpos;
  819. };
  820. };
  821. /**
  822. * struct ubifs_lpt_lprops - LPT logical eraseblock properties.
  823. * @free: amount of free space in bytes
  824. * @dirty: amount of dirty space in bytes
  825. * @tgc: trivial GC flag (1 => unmap after commit end)
  826. * @cmt: commit flag (1 => reserved for commit)
  827. */
  828. struct ubifs_lpt_lprops {
  829. int free;
  830. int dirty;
  831. unsigned tgc:1;
  832. unsigned cmt:1;
  833. };
  834. /**
  835. * struct ubifs_lp_stats - statistics of eraseblocks in the main area.
  836. * @empty_lebs: number of empty LEBs
  837. * @taken_empty_lebs: number of taken LEBs
  838. * @idx_lebs: number of indexing LEBs
  839. * @total_free: total free space in bytes (includes all LEBs)
  840. * @total_dirty: total dirty space in bytes (includes all LEBs)
  841. * @total_used: total used space in bytes (does not include index LEBs)
  842. * @total_dead: total dead space in bytes (does not include index LEBs)
  843. * @total_dark: total dark space in bytes (does not include index LEBs)
  844. *
  845. * The @taken_empty_lebs field counts the LEBs that are in the transient state
  846. * of having been "taken" for use but not yet written to. @taken_empty_lebs is
  847. * needed to account correctly for @gc_lnum, otherwise @empty_lebs could be
  848. * used by itself (in which case 'unused_lebs' would be a better name). In the
  849. * case of @gc_lnum, it is "taken" at mount time or whenever a LEB is retained
  850. * by GC, but unlike other empty LEBs that are "taken", it may not be written
  851. * straight away (i.e. before the next commit start or unmount), so either
  852. * @gc_lnum must be specially accounted for, or the current approach followed
  853. * i.e. count it under @taken_empty_lebs.
  854. *
  855. * @empty_lebs includes @taken_empty_lebs.
  856. *
  857. * @total_used, @total_dead and @total_dark fields do not account indexing
  858. * LEBs.
  859. */
  860. struct ubifs_lp_stats {
  861. int empty_lebs;
  862. int taken_empty_lebs;
  863. int idx_lebs;
  864. long long total_free;
  865. long long total_dirty;
  866. long long total_used;
  867. long long total_dead;
  868. long long total_dark;
  869. };
  870. struct ubifs_nnode;
  871. /**
  872. * struct ubifs_cnode - LEB Properties Tree common node.
  873. * @parent: parent nnode
  874. * @cnext: next cnode to commit
  875. * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE)
  876. * @iip: index in parent
  877. * @level: level in the tree (zero for pnodes, greater than zero for nnodes)
  878. * @num: node number
  879. */
  880. struct ubifs_cnode {
  881. struct ubifs_nnode *parent;
  882. struct ubifs_cnode *cnext;
  883. unsigned long flags;
  884. int iip;
  885. int level;
  886. int num;
  887. };
  888. /**
  889. * struct ubifs_pnode - LEB Properties Tree leaf node.
  890. * @parent: parent nnode
  891. * @cnext: next cnode to commit
  892. * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE)
  893. * @iip: index in parent
  894. * @level: level in the tree (always zero for pnodes)
  895. * @num: node number
  896. * @lprops: LEB properties array
  897. */
  898. struct ubifs_pnode {
  899. struct ubifs_nnode *parent;
  900. struct ubifs_cnode *cnext;
  901. unsigned long flags;
  902. int iip;
  903. int level;
  904. int num;
  905. struct ubifs_lprops lprops[UBIFS_LPT_FANOUT];
  906. };
  907. /**
  908. * struct ubifs_nbranch - LEB Properties Tree internal node branch.
  909. * @lnum: LEB number of child
  910. * @offs: offset of child
  911. * @nnode: nnode child
  912. * @pnode: pnode child
  913. * @cnode: cnode child
  914. */
  915. struct ubifs_nbranch {
  916. int lnum;
  917. int offs;
  918. union {
  919. struct ubifs_nnode *nnode;
  920. struct ubifs_pnode *pnode;
  921. struct ubifs_cnode *cnode;
  922. };
  923. };
  924. /**
  925. * struct ubifs_nnode - LEB Properties Tree internal node.
  926. * @parent: parent nnode
  927. * @cnext: next cnode to commit
  928. * @flags: flags (%DIRTY_LPT_NODE or %OBSOLETE_LPT_NODE)
  929. * @iip: index in parent
  930. * @level: level in the tree (always greater than zero for nnodes)
  931. * @num: node number
  932. * @nbranch: branches to child nodes
  933. */
  934. struct ubifs_nnode {
  935. struct ubifs_nnode *parent;
  936. struct ubifs_cnode *cnext;
  937. unsigned long flags;
  938. int iip;
  939. int level;
  940. int num;
  941. struct ubifs_nbranch nbranch[UBIFS_LPT_FANOUT];
  942. };
  943. /**
  944. * struct ubifs_lpt_heap - heap of categorized lprops.
  945. * @arr: heap array
  946. * @cnt: number in heap
  947. * @max_cnt: maximum number allowed in heap
  948. *
  949. * There are %LPROPS_HEAP_CNT heaps.
  950. */
  951. struct ubifs_lpt_heap {
  952. struct ubifs_lprops **arr;
  953. int cnt;
  954. int max_cnt;
  955. };
  956. /*
  957. * Return codes for LPT scan callback function.
  958. *
  959. * LPT_SCAN_CONTINUE: continue scanning
  960. * LPT_SCAN_ADD: add the LEB properties scanned to the tree in memory
  961. * LPT_SCAN_STOP: stop scanning
  962. */
  963. enum {
  964. LPT_SCAN_CONTINUE = 0,
  965. LPT_SCAN_ADD = 1,
  966. LPT_SCAN_STOP = 2,
  967. };
  968. struct ubifs_info;
  969. /* Callback used by the 'ubifs_lpt_scan_nolock()' function */
  970. typedef int (*ubifs_lpt_scan_callback)(struct ubifs_info *c,
  971. const struct ubifs_lprops *lprops,
  972. int in_tree, void *data);
  973. /**
  974. * struct ubifs_wbuf - UBIFS write-buffer.
  975. * @c: UBIFS file-system description object
  976. * @buf: write-buffer (of min. flash I/O unit size)
  977. * @lnum: logical eraseblock number the write-buffer points to
  978. * @offs: write-buffer offset in this logical eraseblock
  979. * @avail: number of bytes available in the write-buffer
  980. * @used: number of used bytes in the write-buffer
  981. * @dtype: type of data stored in this LEB (%UBI_LONGTERM, %UBI_SHORTTERM,
  982. * %UBI_UNKNOWN)
  983. * @jhead: journal head the mutex belongs to (note, needed only to shut lockdep
  984. * up by 'mutex_lock_nested()).
  985. * @sync_callback: write-buffer synchronization callback
  986. * @io_mutex: serializes write-buffer I/O
  987. * @lock: serializes @buf, @lnum, @offs, @avail, @used, @next_ino and @inodes
  988. * fields
  989. * @timer: write-buffer timer
  990. * @timeout: timer expire interval in jiffies
  991. * @need_sync: it is set if its timer expired and needs sync
  992. * @next_ino: points to the next position of the following inode number
  993. * @inodes: stores the inode numbers of the nodes which are in wbuf
  994. *
  995. * The write-buffer synchronization callback is called when the write-buffer is
  996. * synchronized in order to notify how much space was wasted due to
  997. * write-buffer padding and how much free space is left in the LEB.
  998. *
  999. * Note: the fields @buf, @lnum, @offs, @avail and @used can be read under
  1000. * spin-lock or mutex because they are written under both mutex and spin-lock.
  1001. * @buf is appended to under mutex but overwritten under both mutex and
  1002. * spin-lock. Thus the data between @buf and @buf + @used can be read under
  1003. * spinlock.
  1004. */
  1005. struct ubifs_wbuf {
  1006. struct ubifs_info *c;
  1007. void *buf;
  1008. int lnum;
  1009. int offs;
  1010. int avail;
  1011. int used;
  1012. int dtype;
  1013. int jhead;
  1014. int (*sync_callback)(struct ubifs_info *c, int lnum, int free, int pad);
  1015. struct mutex io_mutex;
  1016. spinlock_t lock;
  1017. int timeout;
  1018. int need_sync;
  1019. int next_ino;
  1020. ino_t *inodes;
  1021. };
  1022. /**
  1023. * struct ubifs_bud - bud logical eraseblock.
  1024. * @lnum: logical eraseblock number
  1025. * @start: where the (uncommitted) bud data starts
  1026. * @jhead: journal head number this bud belongs to
  1027. * @list: link in the list buds belonging to the same journal head
  1028. * @rb: link in the tree of all buds
  1029. */
  1030. struct ubifs_bud {
  1031. int lnum;
  1032. int start;
  1033. int jhead;
  1034. struct list_head list;
  1035. struct rb_node rb;
  1036. };
  1037. /**
  1038. * struct ubifs_jhead - journal head.
  1039. * @wbuf: head's write-buffer
  1040. * @buds_list: list of bud LEBs belonging to this journal head
  1041. *
  1042. * Note, the @buds list is protected by the @c->buds_lock.
  1043. */
  1044. struct ubifs_jhead {
  1045. struct ubifs_wbuf wbuf;
  1046. struct list_head buds_list;
  1047. };
  1048. /**
  1049. * struct ubifs_zbranch - key/coordinate/length branch stored in znodes.
  1050. * @key: key
  1051. * @znode: znode address in memory
  1052. * @lnum: LEB number of the target node (indexing node or data node)
  1053. * @offs: target node offset within @lnum
  1054. * @len: target node length
  1055. */
  1056. struct ubifs_zbranch {
  1057. union ubifs_key key;
  1058. union {
  1059. struct ubifs_znode *znode;
  1060. void *leaf;
  1061. };
  1062. int lnum;
  1063. int offs;
  1064. int len;
  1065. };
  1066. /**
  1067. * struct ubifs_znode - in-memory representation of an indexing node.
  1068. * @parent: parent znode or NULL if it is the root
  1069. * @cnext: next znode to commit
  1070. * @flags: znode flags (%DIRTY_ZNODE, %COW_ZNODE or %OBSOLETE_ZNODE)
  1071. * @time: last access time (seconds)
  1072. * @level: level of the entry in the TNC tree
  1073. * @child_cnt: count of child znodes
  1074. * @iip: index in parent's zbranch array
  1075. * @alt: lower bound of key range has altered i.e. child inserted at slot 0
  1076. * @lnum: LEB number of the corresponding indexing node
  1077. * @offs: offset of the corresponding indexing node
  1078. * @len: length of the corresponding indexing node
  1079. * @zbranch: array of znode branches (@c->fanout elements)
  1080. */
  1081. struct ubifs_znode {
  1082. struct ubifs_znode *parent;
  1083. struct ubifs_znode *cnext;
  1084. unsigned long flags;
  1085. unsigned long time;
  1086. int level;
  1087. int child_cnt;
  1088. int iip;
  1089. int alt;
  1090. #ifdef CONFIG_UBIFS_FS_DEBUG
  1091. int lnum, offs, len;
  1092. #endif
  1093. struct ubifs_zbranch zbranch[];
  1094. };
  1095. /**
  1096. * struct bu_info - bulk-read information.
  1097. * @key: first data node key
  1098. * @zbranch: zbranches of data nodes to bulk read
  1099. * @buf: buffer to read into
  1100. * @buf_len: buffer length
  1101. * @gc_seq: GC sequence number to detect races with GC
  1102. * @cnt: number of data nodes for bulk read
  1103. * @blk_cnt: number of data blocks including holes
  1104. * @oef: end of file reached
  1105. */
  1106. struct bu_info {
  1107. union ubifs_key key;
  1108. struct ubifs_zbranch zbranch[UBIFS_MAX_BULK_READ];
  1109. void *buf;
  1110. int buf_len;
  1111. int gc_seq;
  1112. int cnt;
  1113. int blk_cnt;
  1114. int eof;
  1115. };
  1116. /**
  1117. * struct ubifs_node_range - node length range description data structure.
  1118. * @len: fixed node length
  1119. * @min_len: minimum possible node length
  1120. * @max_len: maximum possible node length
  1121. *
  1122. * If @max_len is %0, the node has fixed length @len.
  1123. */
  1124. struct ubifs_node_range {
  1125. union {
  1126. int len;
  1127. int min_len;
  1128. };
  1129. int max_len;
  1130. };
  1131. /**
  1132. * struct ubifs_compressor - UBIFS compressor description structure.
  1133. * @compr_type: compressor type (%UBIFS_COMPR_LZO, etc)
  1134. * @cc: cryptoapi compressor handle
  1135. * @comp_mutex: mutex used during compression
  1136. * @decomp_mutex: mutex used during decompression
  1137. * @name: compressor name
  1138. * @capi_name: cryptoapi compressor name
  1139. */
  1140. struct ubifs_compressor {
  1141. int compr_type;
  1142. char *name;
  1143. char *capi_name;
  1144. int (*decompress)(const unsigned char *in, size_t in_len,
  1145. unsigned char *out, size_t *out_len);
  1146. };
  1147. /**
  1148. * struct ubifs_budget_req - budget requirements of an operation.
  1149. *
  1150. * @fast: non-zero if the budgeting should try to acquire budget quickly and
  1151. * should not try to call write-back
  1152. * @recalculate: non-zero if @idx_growth, @data_growth, and @dd_growth fields
  1153. * have to be re-calculated
  1154. * @new_page: non-zero if the operation adds a new page
  1155. * @dirtied_page: non-zero if the operation makes a page dirty
  1156. * @new_dent: non-zero if the operation adds a new directory entry
  1157. * @mod_dent: non-zero if the operation removes or modifies an existing
  1158. * directory entry
  1159. * @new_ino: non-zero if the operation adds a new inode
  1160. * @new_ino_d: now much data newly created inode contains
  1161. * @dirtied_ino: how many inodes the operation makes dirty
  1162. * @dirtied_ino_d: now much data dirtied inode contains
  1163. * @idx_growth: how much the index will supposedly grow
  1164. * @data_growth: how much new data the operation will supposedly add
  1165. * @dd_growth: how much data that makes other data dirty the operation will
  1166. * supposedly add
  1167. *
  1168. * @idx_growth, @data_growth and @dd_growth are not used in budget request. The
  1169. * budgeting subsystem caches index and data growth values there to avoid
  1170. * re-calculating them when the budget is released. However, if @idx_growth is
  1171. * %-1, it is calculated by the release function using other fields.
  1172. *
  1173. * An inode may contain 4KiB of data at max., thus the widths of @new_ino_d
  1174. * is 13 bits, and @dirtied_ino_d - 15, because up to 4 inodes may be made
  1175. * dirty by the re-name operation.
  1176. *
  1177. * Note, UBIFS aligns node lengths to 8-bytes boundary, so the requester has to
  1178. * make sure the amount of inode data which contribute to @new_ino_d and
  1179. * @dirtied_ino_d fields are aligned.
  1180. */
  1181. struct ubifs_budget_req {
  1182. unsigned int fast:1;
  1183. unsigned int recalculate:1;
  1184. #ifndef UBIFS_DEBUG
  1185. unsigned int new_page:1;
  1186. unsigned int dirtied_page:1;
  1187. unsigned int new_dent:1;
  1188. unsigned int mod_dent:1;
  1189. unsigned int new_ino:1;
  1190. unsigned int new_ino_d:13;
  1191. unsigned int dirtied_ino:4;
  1192. unsigned int dirtied_ino_d:15;
  1193. #else
  1194. /* Not bit-fields to check for overflows */
  1195. unsigned int new_page;
  1196. unsigned int dirtied_page;
  1197. unsigned int new_dent;
  1198. unsigned int mod_dent;
  1199. unsigned int new_ino;
  1200. unsigned int new_ino_d;
  1201. unsigned int dirtied_ino;
  1202. unsigned int dirtied_ino_d;
  1203. #endif
  1204. int idx_growth;
  1205. int data_growth;
  1206. int dd_growth;
  1207. };
  1208. /**
  1209. * struct ubifs_orphan - stores the inode number of an orphan.
  1210. * @rb: rb-tree node of rb-tree of orphans sorted by inode number
  1211. * @list: list head of list of orphans in order added
  1212. * @new_list: list head of list of orphans added since the last commit
  1213. * @cnext: next orphan to commit
  1214. * @dnext: next orphan to delete
  1215. * @inum: inode number
  1216. * @new: %1 => added since the last commit, otherwise %0
  1217. */
  1218. struct ubifs_orphan {
  1219. struct rb_node rb;
  1220. struct list_head list;
  1221. struct list_head new_list;
  1222. struct ubifs_orphan *cnext;
  1223. struct ubifs_orphan *dnext;
  1224. ino_t inum;
  1225. int new;
  1226. };
  1227. /**
  1228. * struct ubifs_mount_opts - UBIFS-specific mount options information.
  1229. * @unmount_mode: selected unmount mode (%0 default, %1 normal, %2 fast)
  1230. * @bulk_read: enable/disable bulk-reads (%0 default, %1 disabe, %2 enable)
  1231. * @chk_data_crc: enable/disable CRC data checking when reading data nodes
  1232. * (%0 default, %1 disabe, %2 enable)
  1233. * @override_compr: override default compressor (%0 - do not override and use
  1234. * superblock compressor, %1 - override and use compressor
  1235. * specified in @compr_type)
  1236. * @compr_type: compressor type to override the superblock compressor with
  1237. * (%UBIFS_COMPR_NONE, etc)
  1238. */
  1239. struct ubifs_mount_opts {
  1240. unsigned int unmount_mode:2;
  1241. unsigned int bulk_read:2;
  1242. unsigned int chk_data_crc:2;
  1243. unsigned int override_compr:1;
  1244. unsigned int compr_type:2;
  1245. };
  1246. struct ubifs_debug_info;
  1247. /**
  1248. * struct ubifs_info - UBIFS file-system description data structure
  1249. * (per-superblock).
  1250. * @vfs_sb: VFS @struct super_block object
  1251. * @bdi: backing device info object to make VFS happy and disable read-ahead
  1252. *
  1253. * @highest_inum: highest used inode number
  1254. * @max_sqnum: current global sequence number
  1255. * @cmt_no: commit number of the last successfully completed commit, protected
  1256. * by @commit_sem
  1257. * @cnt_lock: protects @highest_inum and @max_sqnum counters
  1258. * @fmt_version: UBIFS on-flash format version
  1259. * @uuid: UUID from super block
  1260. *
  1261. * @lhead_lnum: log head logical eraseblock number
  1262. * @lhead_offs: log head offset
  1263. * @ltail_lnum: log tail logical eraseblock number (offset is always 0)
  1264. * @log_mutex: protects the log, @lhead_lnum, @lhead_offs, @ltail_lnum, and
  1265. * @bud_bytes
  1266. * @min_log_bytes: minimum required number of bytes in the log
  1267. * @cmt_bud_bytes: used during commit to temporarily amount of bytes in
  1268. * committed buds
  1269. *
  1270. * @buds: tree of all buds indexed by bud LEB number
  1271. * @bud_bytes: how many bytes of flash is used by buds
  1272. * @buds_lock: protects the @buds tree, @bud_bytes, and per-journal head bud
  1273. * lists
  1274. * @jhead_cnt: count of journal heads
  1275. * @jheads: journal heads (head zero is base head)
  1276. * @max_bud_bytes: maximum number of bytes allowed in buds
  1277. * @bg_bud_bytes: number of bud bytes when background commit is initiated
  1278. * @old_buds: buds to be released after commit ends
  1279. * @max_bud_cnt: maximum number of buds
  1280. *
  1281. * @commit_sem: synchronizes committer with other processes
  1282. * @cmt_state: commit state
  1283. * @cs_lock: commit state lock
  1284. * @cmt_wq: wait queue to sleep on if the log is full and a commit is running
  1285. *
  1286. * @big_lpt: flag that LPT is too big to write whole during commit
  1287. * @no_chk_data_crc: do not check CRCs when reading data nodes (except during
  1288. * recovery)
  1289. * @bulk_read: enable bulk-reads
  1290. * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc)
  1291. *
  1292. * @tnc_mutex: protects the Tree Node Cache (TNC), @zroot, @cnext, @enext, and
  1293. * @calc_idx_sz
  1294. * @zroot: zbranch which points to the root index node and znode
  1295. * @cnext: next znode to commit
  1296. * @enext: next znode to commit to empty space
  1297. * @gap_lebs: array of LEBs used by the in-gaps commit method
  1298. * @cbuf: commit buffer
  1299. * @ileb_buf: buffer for commit in-the-gaps method
  1300. * @ileb_len: length of data in ileb_buf
  1301. * @ihead_lnum: LEB number of index head
  1302. * @ihead_offs: offset of index head
  1303. * @ilebs: pre-allocated index LEBs
  1304. * @ileb_cnt: number of pre-allocated index LEBs
  1305. * @ileb_nxt: next pre-allocated index LEBs
  1306. * @old_idx: tree of index nodes obsoleted since the last commit start
  1307. * @bottom_up_buf: a buffer which is used by 'dirty_cow_bottom_up()' in tnc.c
  1308. *
  1309. * @mst_node: master node
  1310. * @mst_offs: offset of valid master node
  1311. * @mst_mutex: protects the master node area, @mst_node, and @mst_offs
  1312. *
  1313. * @max_bu_buf_len: maximum bulk-read buffer length
  1314. * @bu_mutex: protects the pre-allocated bulk-read buffer and @c->bu
  1315. * @bu: pre-allocated bulk-read information
  1316. *
  1317. * @log_lebs: number of logical eraseblocks in the log
  1318. * @log_bytes: log size in bytes
  1319. * @log_last: last LEB of the log
  1320. * @lpt_lebs: number of LEBs used for lprops table
  1321. * @lpt_first: first LEB of the lprops table area
  1322. * @lpt_last: last LEB of the lprops table area
  1323. * @orph_lebs: number of LEBs used for the orphan area
  1324. * @orph_first: first LEB of the orphan area
  1325. * @orph_last: last LEB of the orphan area
  1326. * @main_lebs: count of LEBs in the main area
  1327. * @main_first: first LEB of the main area
  1328. * @main_bytes: main area size in bytes
  1329. *
  1330. * @key_hash_type: type of the key hash
  1331. * @key_hash: direntry key hash function
  1332. * @key_fmt: key format
  1333. * @key_len: key length
  1334. * @fanout: fanout of the index tree (number of links per indexing node)
  1335. *
  1336. * @min_io_size: minimal input/output unit size
  1337. * @min_io_shift: number of bits in @min_io_size minus one
  1338. * @leb_size: logical eraseblock size in bytes
  1339. * @half_leb_size: half LEB size
  1340. * @leb_cnt: count of logical eraseblocks
  1341. * @max_leb_cnt: maximum count of logical eraseblocks
  1342. * @old_leb_cnt: count of logical eraseblocks before re-size
  1343. * @ro_media: the underlying UBI volume is read-only
  1344. *
  1345. * @dirty_pg_cnt: number of dirty pages (not used)
  1346. * @dirty_zn_cnt: number of dirty znodes
  1347. * @clean_zn_cnt: number of clean znodes
  1348. *
  1349. * @budg_idx_growth: amount of bytes budgeted for index growth
  1350. * @budg_data_growth: amount of bytes budgeted for cached data
  1351. * @budg_dd_growth: amount of bytes budgeted for cached data that will make
  1352. * other data dirty
  1353. * @budg_uncommitted_idx: amount of bytes were budgeted for growth of the index,
  1354. * but which still have to be taken into account because
  1355. * the index has not been committed so far
  1356. * @space_lock: protects @budg_idx_growth, @budg_data_growth, @budg_dd_growth,
  1357. * @budg_uncommited_idx, @min_idx_lebs, @old_idx_sz, @lst,
  1358. * @nospace, and @nospace_rp;
  1359. * @min_idx_lebs: minimum number of LEBs required for the index
  1360. * @old_idx_sz: size of index on flash
  1361. * @calc_idx_sz: temporary variable which is used to calculate new index size
  1362. * (contains accurate new index size at end of TNC commit start)
  1363. * @lst: lprops statistics
  1364. * @nospace: non-zero if the file-system does not have flash space (used as
  1365. * optimization)
  1366. * @nospace_rp: the same as @nospace, but additionally means that even reserved
  1367. * pool is full
  1368. *
  1369. * @page_budget: budget for a page
  1370. * @inode_budget: budget for an inode
  1371. * @dent_budget: budget for a directory entry
  1372. *
  1373. * @ref_node_alsz: size of the LEB reference node aligned to the min. flash
  1374. * I/O unit
  1375. * @mst_node_alsz: master node aligned size
  1376. * @min_idx_node_sz: minimum indexing node aligned on 8-bytes boundary
  1377. * @max_idx_node_sz: maximum indexing node aligned on 8-bytes boundary
  1378. * @max_inode_sz: maximum possible inode size in bytes
  1379. * @max_znode_sz: size of znode in bytes
  1380. *
  1381. * @leb_overhead: how many bytes are wasted in an LEB when it is filled with
  1382. * data nodes of maximum size - used in free space reporting
  1383. * @dead_wm: LEB dead space watermark
  1384. * @dark_wm: LEB dark space watermark
  1385. * @block_cnt: count of 4KiB blocks on the FS
  1386. *
  1387. * @ranges: UBIFS node length ranges
  1388. * @ubi: UBI volume descriptor
  1389. * @di: UBI device information
  1390. * @vi: UBI volume information
  1391. *
  1392. * @orph_tree: rb-tree of orphan inode numbers
  1393. * @orph_list: list of orphan inode numbers in order added
  1394. * @orph_new: list of orphan inode numbers added since last commit
  1395. * @orph_cnext: next orphan to commit
  1396. * @orph_dnext: next orphan to delete
  1397. * @orphan_lock: lock for orph_tree and orph_new
  1398. * @orph_buf: buffer for orphan nodes
  1399. * @new_orphans: number of orphans since last commit
  1400. * @cmt_orphans: number of orphans being committed
  1401. * @tot_orphans: number of orphans in the rb_tree
  1402. * @max_orphans: maximum number of orphans allowed
  1403. * @ohead_lnum: orphan head LEB number
  1404. * @ohead_offs: orphan head offset
  1405. * @no_orphs: non-zero if there are no orphans
  1406. *
  1407. * @bgt: UBIFS background thread
  1408. * @bgt_name: background thread name
  1409. * @need_bgt: if background thread should run
  1410. * @need_wbuf_sync: if write-buffers have to be synchronized
  1411. *
  1412. * @gc_lnum: LEB number used for garbage collection
  1413. * @sbuf: a buffer of LEB size used by GC and replay for scanning
  1414. * @idx_gc: list of index LEBs that have been garbage collected
  1415. * @idx_gc_cnt: number of elements on the idx_gc list
  1416. * @gc_seq: incremented for every non-index LEB garbage collected
  1417. * @gced_lnum: last non-index LEB that was garbage collected
  1418. *
  1419. * @infos_list: links all 'ubifs_info' objects
  1420. * @umount_mutex: serializes shrinker and un-mount
  1421. * @shrinker_run_no: shrinker run number
  1422. *
  1423. * @space_bits: number of bits needed to record free or dirty space
  1424. * @lpt_lnum_bits: number of bits needed to record a LEB number in the LPT
  1425. * @lpt_offs_bits: number of bits needed to record an offset in the LPT
  1426. * @lpt_spc_bits: number of bits needed to space in the LPT
  1427. * @pcnt_bits: number of bits needed to record pnode or nnode number
  1428. * @lnum_bits: number of bits needed to record LEB number
  1429. * @nnode_sz: size of on-flash nnode
  1430. * @pnode_sz: size of on-flash pnode
  1431. * @ltab_sz: size of on-flash LPT lprops table
  1432. * @lsave_sz: size of on-flash LPT save table
  1433. * @pnode_cnt: number of pnodes
  1434. * @nnode_cnt: number of nnodes
  1435. * @lpt_hght: height of the LPT
  1436. * @pnodes_have: number of pnodes in memory
  1437. *
  1438. * @lp_mutex: protects lprops table and all the other lprops-related fields
  1439. * @lpt_lnum: LEB number of the root nnode of the LPT
  1440. * @lpt_offs: offset of the root nnode of the LPT
  1441. * @nhead_lnum: LEB number of LPT head
  1442. * @nhead_offs: offset of LPT head
  1443. * @lpt_drty_flgs: dirty flags for LPT special nodes e.g. ltab
  1444. * @dirty_nn_cnt: number of dirty nnodes
  1445. * @dirty_pn_cnt: number of dirty pnodes
  1446. * @check_lpt_free: flag that indicates LPT GC may be needed
  1447. * @lpt_sz: LPT size
  1448. * @lpt_nod_buf: buffer for an on-flash nnode or pnode
  1449. * @lpt_buf: buffer of LEB size used by LPT
  1450. * @nroot: address in memory of the root nnode of the LPT
  1451. * @lpt_cnext: next LPT node to commit
  1452. * @lpt_heap: array of heaps of categorized lprops
  1453. * @dirty_idx: a (reverse sorted) copy of the LPROPS_DIRTY_IDX heap as at
  1454. * previous commit start
  1455. * @uncat_list: list of un-categorized LEBs
  1456. * @empty_list: list of empty LEBs
  1457. * @freeable_list: list of freeable non-index LEBs (free + dirty == leb_size)
  1458. * @frdi_idx_list: list of freeable index LEBs (free + dirty == leb_size)
  1459. * @freeable_cnt: number of freeable LEBs in @freeable_list
  1460. *
  1461. * @ltab_lnum: LEB number of LPT's own lprops table
  1462. * @ltab_offs: offset of LPT's own lprops table
  1463. * @ltab: LPT's own lprops table
  1464. * @ltab_cmt: LPT's own lprops table (commit copy)
  1465. * @lsave_cnt: number of LEB numbers in LPT's save table
  1466. * @lsave_lnum: LEB number of LPT's save table
  1467. * @lsave_offs: offset of LPT's save table
  1468. * @lsave: LPT's save table
  1469. * @lscan_lnum: LEB number of last LPT scan
  1470. *
  1471. * @rp_size: size of the reserved pool in bytes
  1472. * @report_rp_size: size of the reserved pool reported to user-space
  1473. * @rp_uid: reserved pool user ID
  1474. * @rp_gid: reserved pool group ID
  1475. *
  1476. * @empty: if the UBI device is empty
  1477. * @replay_tree: temporary tree used during journal replay
  1478. * @replay_list: temporary list used during journal replay
  1479. * @replay_buds: list of buds to replay
  1480. * @cs_sqnum: sequence number of first node in the log (commit start node)
  1481. * @replay_sqnum: sequence number of node currently being replayed
  1482. * @need_recovery: file-system needs recovery
  1483. * @replaying: set to %1 during journal replay
  1484. * @unclean_leb_list: LEBs to recover when mounting ro to rw
  1485. * @rcvrd_mst_node: recovered master node to write when mounting ro to rw
  1486. * @size_tree: inode size information for recovery
  1487. * @remounting_rw: set while remounting from ro to rw (sb flags have MS_RDONLY)
  1488. * @always_chk_crc: always check CRCs (while mounting and remounting rw)
  1489. * @mount_opts: UBIFS-specific mount options
  1490. *
  1491. * @dbg: debugging-related information
  1492. */
  1493. struct ubifs_info {
  1494. struct super_block *vfs_sb;
  1495. ino_t highest_inum;
  1496. unsigned long long max_sqnum;
  1497. unsigned long long cmt_no;
  1498. spinlock_t cnt_lock;
  1499. int fmt_version;
  1500. unsigned char uuid[16];
  1501. int lhead_lnum;
  1502. int lhead_offs;
  1503. int ltail_lnum;
  1504. struct mutex log_mutex;
  1505. int min_log_bytes;
  1506. long long cmt_bud_bytes;
  1507. struct rb_root buds;
  1508. long long bud_bytes;
  1509. spinlock_t buds_lock;
  1510. int jhead_cnt;
  1511. struct ubifs_jhead *jheads;
  1512. long long max_bud_bytes;
  1513. long long bg_bud_bytes;
  1514. struct list_head old_buds;
  1515. int max_bud_cnt;
  1516. struct rw_semaphore commit_sem;
  1517. int cmt_state;
  1518. spinlock_t cs_lock;
  1519. wait_queue_head_t cmt_wq;
  1520. unsigned int big_lpt:1;
  1521. unsigned int no_chk_data_crc:1;
  1522. unsigned int bulk_read:1;
  1523. unsigned int default_compr:2;
  1524. struct mutex tnc_mutex;
  1525. struct ubifs_zbranch zroot;
  1526. struct ubifs_znode *cnext;
  1527. struct ubifs_znode *enext;
  1528. int *gap_lebs;
  1529. void *cbuf;
  1530. void *ileb_buf;
  1531. int ileb_len;
  1532. int ihead_lnum;
  1533. int ihead_offs;
  1534. int *ilebs;
  1535. int ileb_cnt;
  1536. int ileb_nxt;
  1537. struct rb_root old_idx;
  1538. int *bottom_up_buf;
  1539. struct ubifs_mst_node *mst_node;
  1540. int mst_offs;
  1541. struct mutex mst_mutex;
  1542. int max_bu_buf_len;
  1543. struct mutex bu_mutex;
  1544. struct bu_info bu;
  1545. int log_lebs;
  1546. long long log_bytes;
  1547. int log_last;
  1548. int lpt_lebs;
  1549. int lpt_first;
  1550. int lpt_last;
  1551. int orph_lebs;
  1552. int orph_first;
  1553. int orph_last;
  1554. int main_lebs;
  1555. int main_first;
  1556. long long main_bytes;
  1557. uint8_t key_hash_type;
  1558. uint32_t (*key_hash)(const char *str, int len);
  1559. int key_fmt;
  1560. int key_len;
  1561. int fanout;
  1562. int min_io_size;
  1563. int min_io_shift;
  1564. int leb_size;
  1565. int half_leb_size;
  1566. int leb_cnt;
  1567. int max_leb_cnt;
  1568. int old_leb_cnt;
  1569. int ro_media;
  1570. long long budg_idx_growth;
  1571. long long budg_data_growth;
  1572. long long budg_dd_growth;
  1573. long long budg_uncommitted_idx;
  1574. spinlock_t space_lock;
  1575. int min_idx_lebs;
  1576. unsigned long long old_idx_sz;
  1577. unsigned long long calc_idx_sz;
  1578. struct ubifs_lp_stats lst;
  1579. unsigned int nospace:1;
  1580. unsigned int nospace_rp:1;
  1581. int page_budget;
  1582. int inode_budget;
  1583. int dent_budget;
  1584. int ref_node_alsz;
  1585. int mst_node_alsz;
  1586. int min_idx_node_sz;
  1587. int max_idx_node_sz;
  1588. long long max_inode_sz;
  1589. int max_znode_sz;
  1590. int leb_overhead;
  1591. int dead_wm;
  1592. int dark_wm;
  1593. int block_cnt;
  1594. struct ubifs_node_range ranges[UBIFS_NODE_TYPES_CNT];
  1595. struct ubi_volume_desc *ubi;
  1596. struct ubi_device_info di;
  1597. struct ubi_volume_info vi;
  1598. struct rb_root orph_tree;
  1599. struct list_head orph_list;
  1600. struct list_head orph_new;
  1601. struct ubifs_orphan *orph_cnext;
  1602. struct ubifs_orphan *orph_dnext;
  1603. spinlock_t orphan_lock;
  1604. void *orph_buf;
  1605. int new_orphans;
  1606. int cmt_orphans;
  1607. int tot_orphans;
  1608. int max_orphans;
  1609. int ohead_lnum;
  1610. int ohead_offs;
  1611. int no_orphs;
  1612. struct task_struct *bgt;
  1613. char bgt_name[sizeof(BGT_NAME_PATTERN) + 9];
  1614. int need_bgt;
  1615. int need_wbuf_sync;
  1616. int gc_lnum;
  1617. void *sbuf;
  1618. struct list_head idx_gc;
  1619. int idx_gc_cnt;
  1620. int gc_seq;
  1621. int gced_lnum;
  1622. struct list_head infos_list;
  1623. struct mutex umount_mutex;
  1624. unsigned int shrinker_run_no;
  1625. int space_bits;
  1626. int lpt_lnum_bits;
  1627. int lpt_offs_bits;
  1628. int lpt_spc_bits;
  1629. int pcnt_bits;
  1630. int lnum_bits;
  1631. int nnode_sz;
  1632. int pnode_sz;
  1633. int ltab_sz;
  1634. int lsave_sz;
  1635. int pnode_cnt;
  1636. int nnode_cnt;
  1637. int lpt_hght;
  1638. int pnodes_have;
  1639. struct mutex lp_mutex;
  1640. int lpt_lnum;
  1641. int lpt_offs;
  1642. int nhead_lnum;
  1643. int nhead_offs;
  1644. int lpt_drty_flgs;
  1645. int dirty_nn_cnt;
  1646. int dirty_pn_cnt;
  1647. int check_lpt_free;
  1648. long long lpt_sz;
  1649. void *lpt_nod_buf;
  1650. void *lpt_buf;
  1651. struct ubifs_nnode *nroot;
  1652. struct ubifs_cnode *lpt_cnext;
  1653. struct ubifs_lpt_heap lpt_heap[LPROPS_HEAP_CNT];
  1654. struct ubifs_lpt_heap dirty_idx;
  1655. struct list_head uncat_list;
  1656. struct list_head empty_list;
  1657. struct list_head freeable_list;
  1658. struct list_head frdi_idx_list;
  1659. int freeable_cnt;
  1660. int ltab_lnum;
  1661. int ltab_offs;
  1662. struct ubifs_lpt_lprops *ltab;
  1663. struct ubifs_lpt_lprops *ltab_cmt;
  1664. int lsave_cnt;
  1665. int lsave_lnum;
  1666. int lsave_offs;
  1667. int *lsave;
  1668. int lscan_lnum;
  1669. long long rp_size;
  1670. long long report_rp_size;
  1671. uid_t rp_uid;
  1672. gid_t rp_gid;
  1673. /* The below fields are used only during mounting and re-mounting */
  1674. int empty;
  1675. struct rb_root replay_tree;
  1676. struct list_head replay_list;
  1677. struct list_head replay_buds;
  1678. unsigned long long cs_sqnum;
  1679. unsigned long long replay_sqnum;
  1680. int need_recovery;
  1681. int replaying;
  1682. struct list_head unclean_leb_list;
  1683. struct ubifs_mst_node *rcvrd_mst_node;
  1684. struct rb_root size_tree;
  1685. int remounting_rw;
  1686. int always_chk_crc;
  1687. struct ubifs_mount_opts mount_opts;
  1688. #ifdef CONFIG_UBIFS_FS_DEBUG
  1689. struct ubifs_debug_info *dbg;
  1690. #endif
  1691. };
  1692. extern spinlock_t ubifs_infos_lock;
  1693. extern struct kmem_cache *ubifs_inode_slab;
  1694. extern const struct super_operations ubifs_super_operations;
  1695. extern const struct address_space_operations ubifs_file_address_operations;
  1696. extern const struct file_operations ubifs_file_operations;
  1697. extern const struct inode_operations ubifs_file_inode_operations;
  1698. extern const struct file_operations ubifs_dir_operations;
  1699. extern const struct inode_operations ubifs_dir_inode_operations;
  1700. extern const struct inode_operations ubifs_symlink_inode_operations;
  1701. extern struct backing_dev_info ubifs_backing_dev_info;
  1702. extern struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
  1703. /* io.c */
  1704. void ubifs_ro_mode(struct ubifs_info *c, int err);
  1705. int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len);
  1706. int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs,
  1707. int dtype);
  1708. int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf);
  1709. int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len,
  1710. int lnum, int offs);
  1711. int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,
  1712. int lnum, int offs);
  1713. int ubifs_write_node(struct ubifs_info *c, void *node, int len, int lnum,
  1714. int offs, int dtype);
  1715. int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
  1716. int offs, int quiet, int must_chk_crc);
  1717. void ubifs_prepare_node(struct ubifs_info *c, void *buf, int len, int pad);
  1718. void ubifs_prep_grp_node(struct ubifs_info *c, void *node, int len, int last);
  1719. int ubifs_io_init(struct ubifs_info *c);
  1720. void ubifs_pad(const struct ubifs_info *c, void *buf, int pad);
  1721. int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf);
  1722. int ubifs_bg_wbufs_sync(struct ubifs_info *c);
  1723. void ubifs_wbuf_add_ino_nolock(struct ubifs_wbuf *wbuf, ino_t inum);
  1724. int ubifs_sync_wbufs_by_inode(struct ubifs_info *c, struct inode *inode);
  1725. /* scan.c */
  1726. struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
  1727. int offs, void *sbuf);
  1728. void ubifs_scan_destroy(struct ubifs_scan_leb *sleb);
  1729. int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,
  1730. int offs, int quiet);
  1731. struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum,
  1732. int offs, void *sbuf);
  1733. void ubifs_end_scan(const struct ubifs_info *c, struct ubifs_scan_leb *sleb,
  1734. int lnum, int offs);
  1735. int ubifs_add_snod(const struct ubifs_info *c, struct ubifs_scan_leb *sleb,
  1736. void *buf, int offs);
  1737. void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs,
  1738. void *buf);
  1739. /* log.c */
  1740. void ubifs_add_bud(struct ubifs_info *c, struct ubifs_bud *bud);
  1741. void ubifs_create_buds_lists(struct ubifs_info *c);
  1742. int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs);
  1743. struct ubifs_bud *ubifs_search_bud(struct ubifs_info *c, int lnum);
  1744. struct ubifs_wbuf *ubifs_get_wbuf(struct ubifs_info *c, int lnum);
  1745. int ubifs_log_start_commit(struct ubifs_info *c, int *ltail_lnum);
  1746. int ubifs_log_end_commit(struct ubifs_info *c, int new_ltail_lnum);
  1747. int ubifs_log_post_commit(struct ubifs_info *c, int old_ltail_lnum);
  1748. int ubifs_consolidate_log(struct ubifs_info *c);
  1749. /* journal.c */
  1750. int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,
  1751. const struct qstr *nm, const struct inode *inode,
  1752. int deletion, int xent);
  1753. int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
  1754. const union ubifs_key *key, const void *buf, int len);
  1755. int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode);
  1756. int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode);
  1757. int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
  1758. const struct dentry *old_dentry,
  1759. const struct inode *new_dir,
  1760. const struct dentry *new_dentry, int sync);
  1761. int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
  1762. loff_t old_size, loff_t new_size);
  1763. int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
  1764. const struct inode *inode, const struct qstr *nm);
  1765. int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode1,
  1766. const struct inode *inode2);
  1767. /* budget.c */
  1768. int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req);
  1769. void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req);
  1770. void ubifs_release_dirty_inode_budget(struct ubifs_info *c,
  1771. struct ubifs_inode *ui);
  1772. int ubifs_budget_inode_op(struct ubifs_info *c, struct inode *inode,
  1773. struct ubifs_budget_req *req);
  1774. void ubifs_release_ino_dirty(struct ubifs_info *c, struct inode *inode,
  1775. struct ubifs_budget_req *req);
  1776. void ubifs_cancel_ino_op(struct ubifs_info *c, struct inode *inode,
  1777. struct ubifs_budget_req *req);
  1778. long long ubifs_get_free_space(struct ubifs_info *c);
  1779. long long ubifs_get_free_space_nolock(struct ubifs_info *c);
  1780. int ubifs_calc_min_idx_lebs(struct ubifs_info *c);
  1781. void ubifs_convert_page_budget(struct ubifs_info *c);
  1782. long long ubifs_reported_space(const struct ubifs_info *c, long long free);
  1783. long long ubifs_calc_available(const struct ubifs_info *c, int min_idx_lebs);
  1784. /* find.c */
  1785. int ubifs_find_free_space(struct ubifs_info *c, int min_space, int *free,
  1786. int squeeze);
  1787. int ubifs_find_free_leb_for_idx(struct ubifs_info *c);
  1788. int ubifs_find_dirty_leb(struct ubifs_info *c, struct ubifs_lprops *ret_lp,
  1789. int min_space, int pick_free);
  1790. int ubifs_find_dirty_idx_leb(struct ubifs_info *c);
  1791. int ubifs_save_dirty_idx_lnums(struct ubifs_info *c);
  1792. /* tnc.c */
  1793. int ubifs_lookup_level0(struct ubifs_info *c, const union ubifs_key *key,
  1794. struct ubifs_znode **zn, int *n);
  1795. int ubifs_tnc_lookup_nm(struct ubifs_info *c, const union ubifs_key *key,
  1796. void *node, const struct qstr *nm);
  1797. int ubifs_tnc_locate(struct ubifs_info *c, const union ubifs_key *key,
  1798. void *node, int *lnum, int *offs);
  1799. int ubifs_tnc_add(struct ubifs_info *c, const union ubifs_key *key, int lnum,
  1800. int offs, int len);
  1801. int ubifs_tnc_replace(struct ubifs_info *c, const union ubifs_key *key,
  1802. int old_lnum, int old_offs, int lnum, int offs, int len);
  1803. int ubifs_tnc_add_nm(struct ubifs_info *c, const union ubifs_key *key,
  1804. int lnum, int offs, int len, const struct qstr *nm);
  1805. int ubifs_tnc_remove(struct ubifs_info *c, const union ubifs_key *key);
  1806. int ubifs_tnc_remove_nm(struct ubifs_info *c, const union ubifs_key *key,
  1807. const struct qstr *nm);
  1808. int ubifs_tnc_remove_range(struct ubifs_info *c, union ubifs_key *from_key,
  1809. union ubifs_key *to_key);
  1810. int ubifs_tnc_remove_ino(struct ubifs_info *c, ino_t inum);
  1811. struct ubifs_dent_node *ubifs_tnc_next_ent(struct ubifs_info *c,
  1812. union ubifs_key *key,
  1813. const struct qstr *nm);
  1814. void ubifs_tnc_close(struct ubifs_info *c);
  1815. int ubifs_tnc_has_node(struct ubifs_info *c, union ubifs_key *key, int level,
  1816. int lnum, int offs, int is_idx);
  1817. int ubifs_dirty_idx_node(struct ubifs_info *c, union ubifs_key *key, int level,
  1818. int lnum, int offs);
  1819. /* Shared by tnc.c for tnc_commit.c */
  1820. void destroy_old_idx(struct ubifs_info *c);
  1821. int is_idx_node_in_tnc(struct ubifs_info *c, union ubifs_key *key, int level,
  1822. int lnum, int offs);
  1823. int insert_old_idx_znode(struct ubifs_info *c, struct ubifs_znode *znode);
  1824. int ubifs_tnc_get_bu_keys(struct ubifs_info *c, struct bu_info *bu);
  1825. int ubifs_tnc_bulk_read(struct ubifs_info *c, struct bu_info *bu);
  1826. /* tnc_misc.c */
  1827. struct ubifs_znode *ubifs_tnc_levelorder_next(struct ubifs_znode *zr,
  1828. struct ubifs_znode *znode);
  1829. int ubifs_search_zbranch(const struct ubifs_info *c,
  1830. const struct ubifs_znode *znode,
  1831. const union ubifs_key *key, int *n);
  1832. struct ubifs_znode *ubifs_tnc_postorder_first(struct ubifs_znode *znode);
  1833. struct ubifs_znode *ubifs_tnc_postorder_next(struct ubifs_znode *znode);
  1834. long ubifs_destroy_tnc_subtree(struct ubifs_znode *zr);
  1835. struct ubifs_znode *ubifs_load_znode(struct ubifs_info *c,
  1836. struct ubifs_zbranch *zbr,
  1837. struct ubifs_znode *parent, int iip);
  1838. int ubifs_tnc_read_node(struct ubifs_info *c, struct ubifs_zbranch *zbr,
  1839. void *node);
  1840. /* tnc_commit.c */
  1841. int ubifs_tnc_start_commit(struct ubifs_info *c, struct ubifs_zbranch *zroot);
  1842. int ubifs_tnc_end_commit(struct ubifs_info *c);
  1843. /* shrinker.c */
  1844. int ubifs_shrinker(int nr_to_scan, gfp_t gfp_mask);
  1845. /* commit.c */
  1846. int ubifs_bg_thread(void *info);
  1847. void ubifs_commit_required(struct ubifs_info *c);
  1848. void ubifs_request_bg_commit(struct ubifs_info *c);
  1849. int ubifs_run_commit(struct ubifs_info *c);
  1850. void ubifs_recovery_commit(struct ubifs_info *c);
  1851. int ubifs_gc_should_commit(struct ubifs_info *c);
  1852. void ubifs_wait_for_commit(struct ubifs_info *c);
  1853. /* master.c */
  1854. int ubifs_read_master(struct ubifs_info *c);
  1855. int ubifs_write_master(struct ubifs_info *c);
  1856. /* sb.c */
  1857. int ubifs_read_superblock(struct ubifs_info *c);
  1858. struct ubifs_sb_node *ubifs_read_sb_node(struct ubifs_info *c);
  1859. int ubifs_write_sb_node(struct ubifs_info *c, struct ubifs_sb_node *sup);
  1860. /* replay.c */
  1861. int ubifs_validate_entry(struct ubifs_info *c,
  1862. const struct ubifs_dent_node *dent);
  1863. int ubifs_replay_journal(struct ubifs_info *c);
  1864. /* gc.c */
  1865. int ubifs_garbage_collect(struct ubifs_info *c, int anyway);
  1866. int ubifs_gc_start_commit(struct ubifs_info *c);
  1867. int ubifs_gc_end_commit(struct ubifs_info *c);
  1868. void ubifs_destroy_idx_gc(struct ubifs_info *c);
  1869. int ubifs_get_idx_gc_leb(struct ubifs_info *c);
  1870. int ubifs_garbage_collect_leb(struct ubifs_info *c, struct ubifs_lprops *lp);
  1871. /* orphan.c */
  1872. int ubifs_add_orphan(struct ubifs_info *c, ino_t inum);
  1873. void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum);
  1874. int ubifs_orphan_start_commit(struct ubifs_info *c);
  1875. int ubifs_orphan_end_commit(struct ubifs_info *c);
  1876. int ubifs_mount_orphans(struct ubifs_info *c, int unclean, int read_only);
  1877. int ubifs_clear_orphans(struct ubifs_info *c);
  1878. /* lpt.c */
  1879. int ubifs_calc_lpt_geom(struct ubifs_info *c);
  1880. int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,
  1881. int *lpt_lebs, int *big_lpt);
  1882. int ubifs_lpt_init(struct ubifs_info *c, int rd, int wr);
  1883. struct ubifs_lprops *ubifs_lpt_lookup(struct ubifs_info *c, int lnum);
  1884. struct ubifs_lprops *ubifs_lpt_lookup_dirty(struct ubifs_info *c, int lnum);
  1885. int ubifs_lpt_scan_nolock(struct ubifs_info *c, int start_lnum, int end_lnum,
  1886. ubifs_lpt_scan_callback scan_cb, void *data);
  1887. /* Shared by lpt.c for lpt_commit.c */
  1888. void ubifs_pack_lsave(struct ubifs_info *c, void *buf, int *lsave);
  1889. void ubifs_pack_ltab(struct ubifs_info *c, void *buf,
  1890. struct ubifs_lpt_lprops *ltab);
  1891. void ubifs_pack_pnode(struct ubifs_info *c, void *buf,
  1892. struct ubifs_pnode *pnode);
  1893. void ubifs_pack_nnode(struct ubifs_info *c, void *buf,
  1894. struct ubifs_nnode *nnode);
  1895. struct ubifs_pnode *ubifs_get_pnode(struct ubifs_info *c,
  1896. struct ubifs_nnode *parent, int iip);
  1897. struct ubifs_nnode *ubifs_get_nnode(struct ubifs_info *c,
  1898. struct ubifs_nnode *parent, int iip);
  1899. int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip);
  1900. void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty);
  1901. void ubifs_add_nnode_dirt(struct ubifs_info *c, struct ubifs_nnode *nnode);
  1902. uint32_t ubifs_unpack_bits(uint8_t **addr, int *pos, int nrbits);
  1903. struct ubifs_nnode *ubifs_first_nnode(struct ubifs_info *c, int *hght);
  1904. /* Needed only in debugging code in lpt_commit.c */
  1905. int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
  1906. struct ubifs_nnode *nnode);
  1907. /* lpt_commit.c */
  1908. int ubifs_lpt_start_commit(struct ubifs_info *c);
  1909. int ubifs_lpt_end_commit(struct ubifs_info *c);
  1910. int ubifs_lpt_post_commit(struct ubifs_info *c);
  1911. void ubifs_lpt_free(struct ubifs_info *c, int wr_only);
  1912. /* lprops.c */
  1913. const struct ubifs_lprops *ubifs_change_lp(struct ubifs_info *c,
  1914. const struct ubifs_lprops *lp,
  1915. int free, int dirty, int flags,
  1916. int idx_gc_cnt);
  1917. void ubifs_get_lp_stats(struct ubifs_info *c, struct ubifs_lp_stats *lst);
  1918. void ubifs_add_to_cat(struct ubifs_info *c, struct ubifs_lprops *lprops,
  1919. int cat);
  1920. void ubifs_replace_cat(struct ubifs_info *c, struct ubifs_lprops *old_lprops,
  1921. struct ubifs_lprops *new_lprops);
  1922. void ubifs_ensure_cat(struct ubifs_info *c, struct ubifs_lprops *lprops);
  1923. int ubifs_categorize_lprops(const struct ubifs_info *c,
  1924. const struct ubifs_lprops *lprops);
  1925. int ubifs_change_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,
  1926. int flags_set, int flags_clean, int idx_gc_cnt);
  1927. int ubifs_update_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,
  1928. int flags_set, int flags_clean);
  1929. int ubifs_read_one_lp(struct ubifs_info *c, int lnum, struct ubifs_lprops *lp);
  1930. const struct ubifs_lprops *ubifs_fast_find_free(struct ubifs_info *c);
  1931. const struct ubifs_lprops *ubifs_fast_find_empty(struct ubifs_info *c);
  1932. const struct ubifs_lprops *ubifs_fast_find_freeable(struct ubifs_info *c);
  1933. const struct ubifs_lprops *ubifs_fast_find_frdi_idx(struct ubifs_info *c);
  1934. /* file.c */
  1935. int ubifs_fsync(struct file *file, struct dentry *dentry, int datasync);
  1936. int ubifs_setattr(struct dentry *dentry, struct iattr *attr);
  1937. /* dir.c */
  1938. struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
  1939. int mode);
  1940. int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
  1941. struct kstat *stat);
  1942. /* xattr.c */
  1943. int ubifs_setxattr(struct dentry *dentry, const char *name,
  1944. const void *value, size_t size, int flags);
  1945. ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
  1946. size_t size);
  1947. ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size);
  1948. int ubifs_removexattr(struct dentry *dentry, const char *name);
  1949. /* super.c */
  1950. struct inode *ubifs_iget(struct super_block *sb, unsigned long inum);
  1951. int ubifs_iput(struct inode *inode);
  1952. /* recovery.c */
  1953. int ubifs_recover_master_node(struct ubifs_info *c);
  1954. int ubifs_write_rcvrd_mst_node(struct ubifs_info *c);
  1955. struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum,
  1956. int offs, void *sbuf, int grouped);
  1957. struct ubifs_scan_leb *ubifs_recover_log_leb(struct ubifs_info *c, int lnum,
  1958. int offs, void *sbuf);
  1959. int ubifs_recover_inl_heads(const struct ubifs_info *c, void *sbuf);
  1960. int ubifs_clean_lebs(const struct ubifs_info *c, void *sbuf);
  1961. int ubifs_rcvry_gc_commit(struct ubifs_info *c);
  1962. int ubifs_recover_size_accum(struct ubifs_info *c, union ubifs_key *key,
  1963. int deletion, loff_t new_size);
  1964. int ubifs_recover_size(struct ubifs_info *c);
  1965. void ubifs_destroy_size_tree(struct ubifs_info *c);
  1966. /* ioctl.c */
  1967. long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  1968. void ubifs_set_inode_flags(struct inode *inode);
  1969. #ifdef CONFIG_COMPAT
  1970. long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  1971. #endif
  1972. /* compressor.c */
  1973. int __init ubifs_compressors_init(void);
  1974. void __exit ubifs_compressors_exit(void);
  1975. void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len,
  1976. int *compr_type);
  1977. int ubifs_decompress(const void *buf, int len, void *out, int *out_len,
  1978. int compr_type);
  1979. #include "debug.h"
  1980. #include "misc.h"
  1981. #include "key.h"
  1982. /* todo: Move these to a common U-Boot header */
  1983. int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
  1984. unsigned char *out, size_t *out_len);
  1985. int gunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp);
  1986. #endif /* !__UBIFS_H__ */