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