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