From 7eb4607172623167d31ccbf932d7e9ae8c8f33a1 Mon Sep 17 00:00:00 2001 From: Artem Bityutskiy Date: Thu, 24 Apr 2008 17:58:20 +0300 Subject: UBIFS: add ubifs.txt to Documentation directory Signed-off-by: Artem Bityutskiy --- Documentation/filesystems/ubifs.txt | 113 ++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100644 Documentation/filesystems/ubifs.txt (limited to 'Documentation') diff --git a/Documentation/filesystems/ubifs.txt b/Documentation/filesystems/ubifs.txt new file mode 100644 index 000000000000..5e8aca7703cf --- /dev/null +++ b/Documentation/filesystems/ubifs.txt @@ -0,0 +1,113 @@ +Introduction +============= + +UBIFS file-system stands for UBI File System. UBI stands for "Unsorted +Block Images". UBIFS is a flash file system, which means it is designed +to work with flash devices. It is important to understand, that UBIFS +is completely different to any traditional file-system in Linux, like +Ext2, XFS, JFS, etc. UBIFS represents a separate class of file-systems +which work with MTD devices, not block devices. The other Linux +file-system of this class is JFFS2. + +To make it more clear, here is a small comparison of MTD devices and +block devices. + +1 MTD devices represent flash device and they consist of eraseblocks of + rather large size, typically about 128KiB. Block devices consist of + small blocks, typically 512 bytes. +2 MTD devices support 3 main operations - read from some offset withing + eraseblock, write to some offset within eraseblock, and erase whole + eraseblock. Block devices support 2 main operations - read whole + block and write whole block. +3 Whole eraseblock has to be erased before it becomes possible to + re-write its contents. Blocks may be just re-written. +4 Eraseblocks become worn out after some amount of erase cycles - + typically 100K-1G for SLC NAND and NOR flashes, and 1K-10K for MLC + NAND flashes. Blocks do not have the wear-out property. +5 Eraseblocks may become bad (only on NAND flashes) and software should + deal with this. Blocks on hard drives typically do not become bad, + because hardware has mechanisms to substitute bad blocks, at least in + modern LBA disks. + +I should be quite obvious why UBIFS is very different to traditional +file-systems. + +UBIFS works on top of UBI. UBI is a separate software layer which may be +found in drivers/mtd/ubi. UBI is basically a volume management and +wear-leveling layer. It provides so called UBI volumes which is higher +level abstraction than MTD device. The programming model of UBI devices +is very similar to MTD devices - they still consist of large eraseblocks, +they have read/write/erase operations, but UBI devices are devoid of +some limitations wear and bad blocks (items 4 and 5 in the above list). + +In a sense, UBIFS is a next generation of JFFS2 file-system, but it is +very different and incompatible to JFFS2. The following are the main +differences. + +* JFFS2 works on top of MTD devices, UBIFS depends on UBI and works on + top of UBI volumes. +* JFFS2 does not have on-media index and has to build it while mounting, + which requires full media scan. UBIFS maintains the FS indexing + information on the flash media and does not require full media scan, + so it mounts many times faster than JFFS2. +* JFFS2 is a write-through file-system, while UBIFS supports write-back, + which makes UBIFS much faster on writes. + +Similarly to JFFS2, UBIFS supports on-the-flight compression which makes +it possible to fit quite a lot of data to the flash. + +Similarly to JFFS2, UBIFS is tolerant to unclean reboots and power-cuts. +It does not need stuff like ckfs.ext2. UBIFS automatically replays its +journal and recovers form crashes, maintaining the on-flash data +structures consistent. + +UBIFS scales logarithmically (most of the data structures it uses are +trees), so the mount time and memory consumption do not linearly depend +on the flash size, like in case of JFFS2. This is because UBIFS +maintains the FS index on the flash media. However, UBIFS depends on +UBI, which scales linearly. So overall UBI/UBIFS stack scales linearly. +Nevertheless, UBI/UBIFS scales considerably better than JFFS2. + +The authors of UBIFS believe, that it is possible to develop UBI2 which +would scale logarithmically as well. UBI2 would be incompatible to UBI, +though. The nice side of this is that UBIFS would stay intact. + + +Mount options +============= + +(*) == default. + +norm_unmount (*) commit on unmount; the journal is committed + when the file-system is unmounted so that the + next mount does not have to replay the journal + and it becomes very fast; +fast_umount do not commit on unmount; this option makes + unmount faster, but the next mount slower + because of the need to replay the journal. + +Quick usage instructions +======================== + +The UBI volume to mount is specified using "ubiX_Y" or "ubiX:NAME" syntax, +where "X" is UBI device number, "Y" is UBI volume number, and "NAME" is +UBI volume name. + +Mount volume 0 on UBI device 0 to /mnt/ubifs: +$ mount -t ubifs ubi0_0 /mnt/ubifs + +Mount "rootfs" volume of UBI device 0 to /mnt/ubifs ("rootfs" is volume +name): +$ mount -t ubifs ubi0:rootfs /mnt/ubifs + +The following is an example of the kernel boot arguments to attach mtd0 +to UBI and mount volume "rootfs": +ubi.mtd=0 root=ubi0:rootfs rootfstype=ubifs + + +References +========== + +UBIFS documentation and FAQ/HOWTO at the MTD web site: +http://www.linux-mtd.infradead.org/doc/ubifs.html +http://www.linux-mtd.infradead.org/faq/ubifs.html -- cgit v1.2.3 From 273dd00a07688a15e3c8844816f896e1ac4e553d Mon Sep 17 00:00:00 2001 From: Adrian Hunter Date: Tue, 6 May 2008 11:12:57 +0300 Subject: UBIFS: add module params to documentation Signed-off-by: Adrian Hunter --- Documentation/filesystems/ubifs.txt | 85 +++++++++++++++++++++++++++++-------- 1 file changed, 68 insertions(+), 17 deletions(-) (limited to 'Documentation') diff --git a/Documentation/filesystems/ubifs.txt b/Documentation/filesystems/ubifs.txt index 5e8aca7703cf..d49cad28d2cb 100644 --- a/Documentation/filesystems/ubifs.txt +++ b/Documentation/filesystems/ubifs.txt @@ -12,16 +12,16 @@ file-system of this class is JFFS2. To make it more clear, here is a small comparison of MTD devices and block devices. -1 MTD devices represent flash device and they consist of eraseblocks of +1 MTD devices represent flash devices and they consist of eraseblocks of rather large size, typically about 128KiB. Block devices consist of small blocks, typically 512 bytes. -2 MTD devices support 3 main operations - read from some offset withing - eraseblock, write to some offset within eraseblock, and erase whole - eraseblock. Block devices support 2 main operations - read whole - block and write whole block. -3 Whole eraseblock has to be erased before it becomes possible to +2 MTD devices support 3 main operations - read from some offset within an + eraseblock, write to some offset within an eraseblock, and erase a whole + eraseblock. Block devices support 2 main operations - read a whole + block and write a whole block. +3 The whole eraseblock has to be erased before it becomes possible to re-write its contents. Blocks may be just re-written. -4 Eraseblocks become worn out after some amount of erase cycles - +4 Eraseblocks become worn out after some number of erase cycles - typically 100K-1G for SLC NAND and NOR flashes, and 1K-10K for MLC NAND flashes. Blocks do not have the wear-out property. 5 Eraseblocks may become bad (only on NAND flashes) and software should @@ -29,16 +29,16 @@ block devices. because hardware has mechanisms to substitute bad blocks, at least in modern LBA disks. -I should be quite obvious why UBIFS is very different to traditional +It should be quite obvious why UBIFS is very different to traditional file-systems. UBIFS works on top of UBI. UBI is a separate software layer which may be found in drivers/mtd/ubi. UBI is basically a volume management and -wear-leveling layer. It provides so called UBI volumes which is higher -level abstraction than MTD device. The programming model of UBI devices +wear-leveling layer. It provides so called UBI volumes which is a higher +level abstraction than a MTD device. The programming model of UBI devices is very similar to MTD devices - they still consist of large eraseblocks, they have read/write/erase operations, but UBI devices are devoid of -some limitations wear and bad blocks (items 4 and 5 in the above list). +limitations like wear and bad blocks (items 4 and 5 in the above list). In a sense, UBIFS is a next generation of JFFS2 file-system, but it is very different and incompatible to JFFS2. The following are the main @@ -56,10 +56,10 @@ differences. Similarly to JFFS2, UBIFS supports on-the-flight compression which makes it possible to fit quite a lot of data to the flash. -Similarly to JFFS2, UBIFS is tolerant to unclean reboots and power-cuts. +Similarly to JFFS2, UBIFS is tolerant of unclean reboots and power-cuts. It does not need stuff like ckfs.ext2. UBIFS automatically replays its -journal and recovers form crashes, maintaining the on-flash data -structures consistent. +journal and recovers from crashes, ensuring that the on-flash data +structures are consistent. UBIFS scales logarithmically (most of the data structures it uses are trees), so the mount time and memory consumption do not linearly depend @@ -69,8 +69,9 @@ UBI, which scales linearly. So overall UBI/UBIFS stack scales linearly. Nevertheless, UBI/UBIFS scales considerably better than JFFS2. The authors of UBIFS believe, that it is possible to develop UBI2 which -would scale logarithmically as well. UBI2 would be incompatible to UBI, -though. The nice side of this is that UBIFS would stay intact. +would scale logarithmically as well. UBI2 would support the same API as UBI, +but it would be binary incompatible to UBI. So UBIFS would not need to be +changed to use UBI2 Mount options @@ -82,10 +83,11 @@ norm_unmount (*) commit on unmount; the journal is committed when the file-system is unmounted so that the next mount does not have to replay the journal and it becomes very fast; -fast_umount do not commit on unmount; this option makes +fast_unmount do not commit on unmount; this option makes unmount faster, but the next mount slower because of the need to replay the journal. + Quick usage instructions ======================== @@ -105,6 +107,55 @@ to UBI and mount volume "rootfs": ubi.mtd=0 root=ubi0:rootfs rootfstype=ubifs +Module Parameters for Debugging +=============================== + +When UBIFS has been compiled with debugging enabled, there are 3 module +parameters that are available to control aspects of testing and debugging. +The parameters are unsigned integers where each bit controls an option. +The parameters are: + +debug_msgs Selects which debug messages to display, as follows: + + Message Type Flag value + + General messages 1 + Journal messages 2 + Mount messages 4 + Commit messages 8 + LEB search messages 16 + Budgeting messages 32 + Garbage collection messages 64 + Tree Node Cache (TNC) messages 128 + LEB properties (lprops) messages 256 + Input/output messages 512 + Log messages 1024 + Scan messages 2048 + Recovery messages 4096 + +debug_chks Selects extra checks that UBIFS can do while running: + + Check Flag value + + General checks 1 + Check Tree Node Cache (TNC) 2 + Check indexing tree size 4 + Check orphan area 8 + Check old indexing tree 16 + Check LEB properties (lprops) 32 + +debug_tsts Selects a mode of testing, as follows: + + Test mode Flag value + + Create memory pressure 1 + Force in-the-gaps method 2 + Failure mode for recovery testing 4 + +For example, set debug_msgs to 5 to display General messages and Mount +messages. + + References ========== -- cgit v1.2.3 From b7b71bea824aff36618b247a28a912462f6558cf Mon Sep 17 00:00:00 2001 From: Artem Bityutskiy Date: Tue, 6 May 2008 11:46:30 +0300 Subject: UBIFS: remove memleak and mempressure checks Signed-off-by: Artem Bityutskiy --- Documentation/filesystems/ubifs.txt | 1 - fs/ubifs/build.c | 4 - fs/ubifs/debug.c | 170 +----------------------------------- fs/ubifs/debug.h | 33 ------- fs/ubifs/file.c | 2 - fs/ubifs/tnc.c | 14 --- 6 files changed, 2 insertions(+), 222 deletions(-) (limited to 'Documentation') diff --git a/Documentation/filesystems/ubifs.txt b/Documentation/filesystems/ubifs.txt index d49cad28d2cb..ab653b46addc 100644 --- a/Documentation/filesystems/ubifs.txt +++ b/Documentation/filesystems/ubifs.txt @@ -148,7 +148,6 @@ debug_tsts Selects a mode of testing, as follows: Test mode Flag value - Create memory pressure 1 Force in-the-gaps method 2 Failure mode for recovery testing 4 diff --git a/fs/ubifs/build.c b/fs/ubifs/build.c index f50dc5b21cdf..b37ed6bcae78 100644 --- a/fs/ubifs/build.c +++ b/fs/ubifs/build.c @@ -1336,7 +1336,6 @@ static int __init ubifs_init(void) goto out_reg; register_shrinker(&ubifs_shrinker_info); - dbg_mempressure_init(); err = ubifs_compressors_init(); if (err) @@ -1345,7 +1344,6 @@ static int __init ubifs_init(void) return 0; out_compr: - dbg_mempressure_exit(); unregister_shrinker(&ubifs_shrinker_info); kmem_cache_destroy(ubifs_inode_slab); out_reg: @@ -1363,12 +1361,10 @@ static void __exit ubifs_exit(void) ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0); ubifs_compressors_exit(); - dbg_mempressure_exit(); unregister_shrinker(&ubifs_shrinker_info); kmem_cache_destroy(ubifs_inode_slab); unregister_filesystem(&ubifs_fs_type); bdi_destroy(&ubifs_backing_dev_info); - dbg_leak_report(); } module_exit(ubifs_exit); diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c index 0f5de620c8de..6af0e6631aff 100644 --- a/fs/ubifs/debug.c +++ b/fs/ubifs/debug.c @@ -27,7 +27,6 @@ * various local functions of those subsystems. */ -#define UBIFS_DBG_PRESERVE_KMALLOC #define UBIFS_DBG_PRESERVE_UBI #include "ubifs.h" @@ -41,9 +40,6 @@ DEFINE_SPINLOCK(dbg_lock); static char dbg_key_buf0[128]; static char dbg_key_buf1[128]; -static size_t km_alloc_cnt; -static size_t vm_alloc_cnt; - unsigned int ubifs_msg_flags = UBIFS_MSG_FLAGS_DEFAULT; unsigned int ubifs_chk_flags = UBIFS_CHK_FLAGS_DEFAULT; unsigned int ubifs_tst_flags; @@ -807,12 +803,12 @@ int dbg_check_dir_size(struct ubifs_info *c, const struct inode *dir) nm.name = dent->name; nm.len = le16_to_cpu(dent->nlen); size += CALC_DENT_SIZE(nm.len); - dbg_kfree(pdent); /* kfree via debug function */ + kfree(pdent); pdent = dent; key_read(c, &dent->key, &key); } - dbg_kfree(pdent); /* kfree via debug function */ + kfree(pdent); if (i_size_read(dir) != size) { ubifs_err("bad directory dir %lu size %llu, " @@ -1247,168 +1243,6 @@ int dbg_force_in_the_gaps(void) return !((invocation_cnt ++) & 0x7); } -void *dbg_kmalloc(size_t size, gfp_t flags) -{ - void *addr; - - addr = kmalloc(size, flags); - if (addr != NULL) { - spin_lock(&dbg_lock); - km_alloc_cnt += 1; - spin_unlock(&dbg_lock); - } - return addr; -} - -void *dbg_kzalloc(size_t size, gfp_t flags) -{ - void *addr; - - addr = kzalloc(size, flags); - if (addr != NULL) { - spin_lock(&dbg_lock); - km_alloc_cnt += 1; - spin_unlock(&dbg_lock); - } - return addr; -} - -void dbg_kfree(const void *addr) -{ - if (addr != NULL) { - spin_lock(&dbg_lock); - km_alloc_cnt -= 1; - spin_unlock(&dbg_lock); - kfree(addr); - } -} - -void *dbg_vmalloc(size_t size) -{ - void *addr; - - addr = vmalloc(size); - if (addr != NULL) { - spin_lock(&dbg_lock); - vm_alloc_cnt += 1; - spin_unlock(&dbg_lock); - } - return addr; -} - -void dbg_vfree(void *addr) -{ - if (addr != NULL) { - spin_lock(&dbg_lock); - vm_alloc_cnt -= 1; - spin_unlock(&dbg_lock); - vfree(addr); - } -} - -void dbg_leak_report(void) -{ - spin_lock(&dbg_lock); - if (km_alloc_cnt || vm_alloc_cnt) { - ubifs_err("kmalloc: leak count %zd", km_alloc_cnt); - ubifs_err("vmalloc: leak count %zd", vm_alloc_cnt); - } - spin_unlock(&dbg_lock); -} - -/* - * The below debugging stuff helps to make fake Linux memory pressure in order - * to make UBIFS shrinker be invoked. Useful for testing. - */ - -/* - * struct eaten_memory - memory object eaten by UBIFS to cause memory pressure. - * @list: link in the list of eaten memory objects - * @pad: just pads to memory page size - */ -struct eaten_memory { - struct list_head list; - uint8_t pad[PAGE_CACHE_SIZE - sizeof(struct list_head)]; -}; - -/* List of eaten memory pages */ -static LIST_HEAD(eaten_list); -/* Count of allocated 'struct eaten_memory' objects */ -static unsigned long eaten_cnt; -/* Protects 'eaten_list' and 'eaten_cnt' */ -static DEFINE_SPINLOCK(eaten_lock); - -void dbg_eat_memory(void) -{ - struct eaten_memory *em; - - if (!(ubifs_tst_flags & UBIFS_TST_MEMPRESS)) - return; - - em = kmalloc(sizeof(struct eaten_memory), GFP_NOFS); - if (!em) { - ubifs_err("cannot allocate eaten memory structure"); - return; - } - - spin_lock(&eaten_lock); - list_add_tail(&em->list, &eaten_list); - eaten_cnt += 1; - spin_unlock(&eaten_lock); -} - -static int return_eaten_memory(int nr) -{ - int free_all = 0, freed = 0; - struct eaten_memory *em; - - if (nr == 0) - return eaten_cnt; - - if (nr == -1) - free_all = 1; - - while (nr > 0 || free_all) { - spin_lock(&eaten_lock); - if (eaten_cnt == 0) { - spin_unlock(&eaten_lock); - break; - } - - em = list_entry(eaten_list.next, struct eaten_memory, list); - list_del(&em->list); - eaten_cnt -= 1; - spin_unlock(&eaten_lock); - - kfree(em); - nr -= 1; - freed += 1; - } - - return freed; -} - -static int dbg_shrinker(int nr, gfp_t gfp_mask) -{ - return return_eaten_memory(nr); -} - -static struct shrinker dbg_shrinker_info = { - .shrink = dbg_shrinker, - .seeks = DEFAULT_SEEKS, -}; - -void __init dbg_mempressure_init(void) -{ - register_shrinker(&dbg_shrinker_info); -} - -void dbg_mempressure_exit(void) -{ - unregister_shrinker(&dbg_shrinker_info); - return_eaten_memory(-1); -} - /* Failure mode for recovery testing */ #define chance(n, d) (simple_rand() <= (n) * 32768LL / (d)) diff --git a/fs/ubifs/debug.h b/fs/ubifs/debug.h index 7b4910bd5cda..49b43a61c196 100644 --- a/fs/ubifs/debug.h +++ b/fs/ubifs/debug.h @@ -179,12 +179,10 @@ enum { /* * Special testing flags (must match tst_names in debug.c). * - * UBIFS_TST_MEMPRESS: create memory pressure for shrinker testing * UBIFS_TST_FORCE_IN_THE_GAPS: force the use of in-the-gaps method * UBIFS_TST_RCVRY: failure mode for recovery testing */ enum { - UBIFS_TST_MEMPRESS = 0x1, UBIFS_TST_FORCE_IN_THE_GAPS = 0x2, UBIFS_TST_RCVRY = 0x4, }; @@ -232,25 +230,6 @@ void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode, struct ubifs_nnode *parent, int iip); void dbg_dump_tnc(struct ubifs_info *c); -/* Memory leak checking */ - -#ifndef UBIFS_DBG_PRESERVE_KMALLOC - -#define kmalloc dbg_kmalloc -#define kzalloc dbg_kzalloc -#define kfree dbg_kfree -#define vmalloc dbg_vmalloc -#define vfree dbg_vfree - -#endif - -void *dbg_kmalloc(size_t size, gfp_t flags); -void *dbg_kzalloc(size_t size, gfp_t flags); -void dbg_kfree(const void *addr); -void *dbg_vmalloc(size_t size); -void dbg_vfree(void *addr); -void dbg_leak_report(void); - /* Checking helper functions */ typedef int (*dbg_leaf_callback)(struct ubifs_info *c, @@ -287,12 +266,6 @@ int dbg_check_lprops(struct ubifs_info *c); int dbg_check_lpt_nodes(struct ubifs_info *c, struct ubifs_cnode *cnode, int row, int col); -/* Create memory pressure for shrinker testing */ - -void dbg_eat_memory(void); -void __init dbg_mempressure_init(void); -void dbg_mempressure_exit(void); - /* Force the use of in-the-gaps method for testing */ #define dbg_force_in_the_gaps_enabled \ @@ -386,8 +359,6 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum, #define dbg_dump_pnode(c, pnode, parent, iip) ({}) #define dbg_dump_tnc(c) ({}) -#define dbg_leak_report() ({}) - #define dbg_walk_index(c, leaf_cb, znode_cb, priv) 0 #define dbg_read_leaf_nolock(c, zbr, node) 0 @@ -409,10 +380,6 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum, #define dbg_check_lprops(c) 0 #define dbg_check_lpt_nodes(c, cnode, row, col) 0 -#define dbg_eat_memory() ({}) -#define dbg_mempressure_init() ({}) -#define dbg_mempressure_exit() ({}) - #define dbg_force_in_the_gaps_enabled 0 #define dbg_force_in_the_gaps() 0 diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c index 0255d104e56d..a9a4b9279898 100644 --- a/fs/ubifs/file.c +++ b/fs/ubifs/file.c @@ -157,7 +157,6 @@ static int ubifs_write_begin(struct file *file, struct address_space *mapping, struct page *page; ubifs_assert(!(inode->i_sb->s_flags & MS_RDONLY)); - dbg_eat_memory(); if (unlikely(c->ro_media)) return -EROFS; @@ -772,7 +771,6 @@ static int ubifs_vm_page_mkwrite(struct vm_area_struct *vma,struct page *page) dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, page->index, i_size_read(inode)); ubifs_assert(!(inode->i_sb->s_flags & MS_RDONLY)); - dbg_eat_memory(); if (unlikely(c->ro_media)) return -EROFS; diff --git a/fs/ubifs/tnc.c b/fs/ubifs/tnc.c index 9fa51cacba7e..881614c25c66 100644 --- a/fs/ubifs/tnc.c +++ b/fs/ubifs/tnc.c @@ -1399,13 +1399,6 @@ static int lookup_level0(struct ubifs_info *c, const union ubifs_key *key, while (1) { struct ubifs_zbranch *zbr; - /* - * The below is a debugging hack to make UBIFS eat RAM and - * cause fake memory pressure. It is compiled out if it is not - * enabled in kernel configuration. - */ - dbg_eat_memory(); - exact = ubifs_search_zbranch(c, znode, key, n); if (znode->level == 0) @@ -1545,13 +1538,6 @@ static int lookup_level0_dirty(struct ubifs_info *c, const union ubifs_key *key, while (1) { struct ubifs_zbranch *zbr; - /* - * The below is a debugging hack to make UBIFS eat RAM and - * cause fake memory pressure. It is compiled out if it is not - * enabled in kernel configuration. - */ - dbg_eat_memory(); - exact = ubifs_search_zbranch(c, znode, key, n); if (znode->level == 0) -- cgit v1.2.3 From 4a1261c868fc9b36696670d1fdb32a40853f1952 Mon Sep 17 00:00:00 2001 From: Adrian Hunter Date: Tue, 17 Jun 2008 13:19:13 +0300 Subject: UBIFS: add fs check to documentation Signed-off-by: Adrian Hunter --- Documentation/filesystems/ubifs.txt | 1 + 1 file changed, 1 insertion(+) (limited to 'Documentation') diff --git a/Documentation/filesystems/ubifs.txt b/Documentation/filesystems/ubifs.txt index ab653b46addc..540e9e7f59c5 100644 --- a/Documentation/filesystems/ubifs.txt +++ b/Documentation/filesystems/ubifs.txt @@ -143,6 +143,7 @@ debug_chks Selects extra checks that UBIFS can do while running: Check orphan area 8 Check old indexing tree 16 Check LEB properties (lprops) 32 + Check leaf nodes and inodes 64 debug_tsts Selects a mode of testing, as follows: -- cgit v1.2.3