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