1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+ 29eefe2a2SStefan Roese /* 39eefe2a2SStefan Roese * This file is part of UBIFS. 49eefe2a2SStefan Roese * 59eefe2a2SStefan Roese * Copyright (C) 2006-2008 Nokia Corporation. 69eefe2a2SStefan Roese * 79eefe2a2SStefan Roese * Authors: Artem Bityutskiy (Битюцкий Артём) 89eefe2a2SStefan Roese * Adrian Hunter 99eefe2a2SStefan Roese */ 109eefe2a2SStefan Roese 119eefe2a2SStefan Roese /* 129eefe2a2SStefan Roese * This file implements UBIFS initialization and VFS superblock operations. Some 139eefe2a2SStefan Roese * initialization stuff which is rather large and complex is placed at 149eefe2a2SStefan Roese * corresponding subsystems, but most of it is here. 159eefe2a2SStefan Roese */ 169eefe2a2SStefan Roese 17ff94bc40SHeiko Schocher #ifndef __UBOOT__ 18ff94bc40SHeiko Schocher #include <linux/init.h> 19ff94bc40SHeiko Schocher #include <linux/slab.h> 20ff94bc40SHeiko Schocher #include <linux/module.h> 21ff94bc40SHeiko Schocher #include <linux/ctype.h> 22ff94bc40SHeiko Schocher #include <linux/kthread.h> 23ff94bc40SHeiko Schocher #include <linux/parser.h> 24ff94bc40SHeiko Schocher #include <linux/seq_file.h> 25ff94bc40SHeiko Schocher #include <linux/mount.h> 269eefe2a2SStefan Roese #include <linux/math64.h> 27ff94bc40SHeiko Schocher #include <linux/writeback.h> 28ff94bc40SHeiko Schocher #else 29ff94bc40SHeiko Schocher 306e295186SSimon Glass #include <common.h> 316e295186SSimon Glass #include <malloc.h> 326e295186SSimon Glass #include <memalign.h> 3384b8bf6dSMasahiro Yamada #include <linux/bug.h> 34f8fdb81fSFabio Estevam #include <linux/log2.h> 35ff94bc40SHeiko Schocher #include <linux/stat.h> 36ff94bc40SHeiko Schocher #include <linux/err.h> 37ff94bc40SHeiko Schocher #include "ubifs.h" 38ff94bc40SHeiko Schocher #include <ubi_uboot.h> 39ff94bc40SHeiko Schocher #include <mtd/ubi-user.h> 40ff94bc40SHeiko Schocher 41ff94bc40SHeiko Schocher struct dentry; 42ff94bc40SHeiko Schocher struct file; 43ff94bc40SHeiko Schocher struct iattr; 44ff94bc40SHeiko Schocher struct kstat; 45ff94bc40SHeiko Schocher struct vfsmount; 469eefe2a2SStefan Roese 479eefe2a2SStefan Roese #define INODE_LOCKED_MAX 64 489eefe2a2SStefan Roese 499eefe2a2SStefan Roese struct super_block *ubifs_sb; 50ff94bc40SHeiko Schocher 519eefe2a2SStefan Roese static struct inode *inodes_locked_down[INODE_LOCKED_MAX]; 529eefe2a2SStefan Roese 53ff94bc40SHeiko Schocher int set_anon_super(struct super_block *s, void *data) 549eefe2a2SStefan Roese { 559eefe2a2SStefan Roese return 0; 569eefe2a2SStefan Roese } 579eefe2a2SStefan Roese 589eefe2a2SStefan Roese struct inode *iget_locked(struct super_block *sb, unsigned long ino) 599eefe2a2SStefan Roese { 609eefe2a2SStefan Roese struct inode *inode; 619eefe2a2SStefan Roese 624519668bSMarcel Ziswiler inode = (struct inode *)malloc_cache_aligned( 634519668bSMarcel Ziswiler sizeof(struct ubifs_inode)); 649eefe2a2SStefan Roese if (inode) { 659eefe2a2SStefan Roese inode->i_ino = ino; 669eefe2a2SStefan Roese inode->i_sb = sb; 679eefe2a2SStefan Roese list_add(&inode->i_sb_list, &sb->s_inodes); 689eefe2a2SStefan Roese inode->i_state = I_LOCK | I_NEW; 699eefe2a2SStefan Roese } 709eefe2a2SStefan Roese 719eefe2a2SStefan Roese return inode; 729eefe2a2SStefan Roese } 739eefe2a2SStefan Roese 74ff94bc40SHeiko Schocher void iget_failed(struct inode *inode) 75ff94bc40SHeiko Schocher { 76ff94bc40SHeiko Schocher } 77ff94bc40SHeiko Schocher 789eefe2a2SStefan Roese int ubifs_iput(struct inode *inode) 799eefe2a2SStefan Roese { 809eefe2a2SStefan Roese list_del_init(&inode->i_sb_list); 819eefe2a2SStefan Roese 829eefe2a2SStefan Roese free(inode); 839eefe2a2SStefan Roese return 0; 849eefe2a2SStefan Roese } 859eefe2a2SStefan Roese 869eefe2a2SStefan Roese /* 879eefe2a2SStefan Roese * Lock (save) inode in inode array for readback after recovery 889eefe2a2SStefan Roese */ 899eefe2a2SStefan Roese void iput(struct inode *inode) 909eefe2a2SStefan Roese { 919eefe2a2SStefan Roese int i; 929eefe2a2SStefan Roese struct inode *ino; 939eefe2a2SStefan Roese 949eefe2a2SStefan Roese /* 959eefe2a2SStefan Roese * Search end of list 969eefe2a2SStefan Roese */ 979eefe2a2SStefan Roese for (i = 0; i < INODE_LOCKED_MAX; i++) { 989eefe2a2SStefan Roese if (inodes_locked_down[i] == NULL) 999eefe2a2SStefan Roese break; 1009eefe2a2SStefan Roese } 1019eefe2a2SStefan Roese 1029eefe2a2SStefan Roese if (i >= INODE_LOCKED_MAX) { 1030195a7bbSHeiko Schocher dbg_gen("Error, can't lock (save) more inodes while recovery!!!"); 1049eefe2a2SStefan Roese return; 1059eefe2a2SStefan Roese } 1069eefe2a2SStefan Roese 1079eefe2a2SStefan Roese /* 1089eefe2a2SStefan Roese * Allocate and use new inode 1099eefe2a2SStefan Roese */ 1104519668bSMarcel Ziswiler ino = (struct inode *)malloc_cache_aligned(sizeof(struct ubifs_inode)); 1119eefe2a2SStefan Roese memcpy(ino, inode, sizeof(struct ubifs_inode)); 1129eefe2a2SStefan Roese 1139eefe2a2SStefan Roese /* 1149eefe2a2SStefan Roese * Finally save inode in array 1159eefe2a2SStefan Roese */ 1169eefe2a2SStefan Roese inodes_locked_down[i] = ino; 1179eefe2a2SStefan Roese } 1189eefe2a2SStefan Roese 119ff94bc40SHeiko Schocher /* from fs/inode.c */ 120ff94bc40SHeiko Schocher /** 121ff94bc40SHeiko Schocher * clear_nlink - directly zero an inode's link count 122ff94bc40SHeiko Schocher * @inode: inode 123ff94bc40SHeiko Schocher * 124ff94bc40SHeiko Schocher * This is a low-level filesystem helper to replace any 125ff94bc40SHeiko Schocher * direct filesystem manipulation of i_nlink. See 126ff94bc40SHeiko Schocher * drop_nlink() for why we care about i_nlink hitting zero. 127ff94bc40SHeiko Schocher */ 128ff94bc40SHeiko Schocher void clear_nlink(struct inode *inode) 129ff94bc40SHeiko Schocher { 130ff94bc40SHeiko Schocher if (inode->i_nlink) { 131ff94bc40SHeiko Schocher inode->__i_nlink = 0; 132ff94bc40SHeiko Schocher atomic_long_inc(&inode->i_sb->s_remove_count); 133ff94bc40SHeiko Schocher } 134ff94bc40SHeiko Schocher } 135ff94bc40SHeiko Schocher EXPORT_SYMBOL(clear_nlink); 136ff94bc40SHeiko Schocher 137ff94bc40SHeiko Schocher /** 138ff94bc40SHeiko Schocher * set_nlink - directly set an inode's link count 139ff94bc40SHeiko Schocher * @inode: inode 140ff94bc40SHeiko Schocher * @nlink: new nlink (should be non-zero) 141ff94bc40SHeiko Schocher * 142ff94bc40SHeiko Schocher * This is a low-level filesystem helper to replace any 143ff94bc40SHeiko Schocher * direct filesystem manipulation of i_nlink. 144ff94bc40SHeiko Schocher */ 145ff94bc40SHeiko Schocher void set_nlink(struct inode *inode, unsigned int nlink) 146ff94bc40SHeiko Schocher { 147ff94bc40SHeiko Schocher if (!nlink) { 148ff94bc40SHeiko Schocher clear_nlink(inode); 149ff94bc40SHeiko Schocher } else { 150ff94bc40SHeiko Schocher /* Yes, some filesystems do change nlink from zero to one */ 151ff94bc40SHeiko Schocher if (inode->i_nlink == 0) 152ff94bc40SHeiko Schocher atomic_long_dec(&inode->i_sb->s_remove_count); 153ff94bc40SHeiko Schocher 154ff94bc40SHeiko Schocher inode->__i_nlink = nlink; 155ff94bc40SHeiko Schocher } 156ff94bc40SHeiko Schocher } 157ff94bc40SHeiko Schocher EXPORT_SYMBOL(set_nlink); 158ff94bc40SHeiko Schocher 159ff94bc40SHeiko Schocher /* from include/linux/fs.h */ 160ff94bc40SHeiko Schocher static inline void i_uid_write(struct inode *inode, uid_t uid) 161ff94bc40SHeiko Schocher { 162ff94bc40SHeiko Schocher inode->i_uid.val = uid; 163ff94bc40SHeiko Schocher } 164ff94bc40SHeiko Schocher 165ff94bc40SHeiko Schocher static inline void i_gid_write(struct inode *inode, gid_t gid) 166ff94bc40SHeiko Schocher { 167ff94bc40SHeiko Schocher inode->i_gid.val = gid; 168ff94bc40SHeiko Schocher } 169ff94bc40SHeiko Schocher 170ff94bc40SHeiko Schocher void unlock_new_inode(struct inode *inode) 171ff94bc40SHeiko Schocher { 172ff94bc40SHeiko Schocher return; 173ff94bc40SHeiko Schocher } 174ff94bc40SHeiko Schocher #endif 175ff94bc40SHeiko Schocher 176ff94bc40SHeiko Schocher /* 177ff94bc40SHeiko Schocher * Maximum amount of memory we may 'kmalloc()' without worrying that we are 178ff94bc40SHeiko Schocher * allocating too much. 179ff94bc40SHeiko Schocher */ 180ff94bc40SHeiko Schocher #define UBIFS_KMALLOC_OK (128*1024) 181ff94bc40SHeiko Schocher 182ff94bc40SHeiko Schocher /* Slab cache for UBIFS inodes */ 183ff94bc40SHeiko Schocher struct kmem_cache *ubifs_inode_slab; 184ff94bc40SHeiko Schocher 185ff94bc40SHeiko Schocher #ifndef __UBOOT__ 186ff94bc40SHeiko Schocher /* UBIFS TNC shrinker description */ 187ff94bc40SHeiko Schocher static struct shrinker ubifs_shrinker_info = { 188ff94bc40SHeiko Schocher .scan_objects = ubifs_shrink_scan, 189ff94bc40SHeiko Schocher .count_objects = ubifs_shrink_count, 190ff94bc40SHeiko Schocher .seeks = DEFAULT_SEEKS, 191ff94bc40SHeiko Schocher }; 192ff94bc40SHeiko Schocher #endif 193ff94bc40SHeiko Schocher 194ff94bc40SHeiko Schocher /** 195ff94bc40SHeiko Schocher * validate_inode - validate inode. 196ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 197ff94bc40SHeiko Schocher * @inode: the inode to validate 198ff94bc40SHeiko Schocher * 199ff94bc40SHeiko Schocher * This is a helper function for 'ubifs_iget()' which validates various fields 200ff94bc40SHeiko Schocher * of a newly built inode to make sure they contain sane values and prevent 201ff94bc40SHeiko Schocher * possible vulnerabilities. Returns zero if the inode is all right and 202ff94bc40SHeiko Schocher * a non-zero error code if not. 203ff94bc40SHeiko Schocher */ 204ff94bc40SHeiko Schocher static int validate_inode(struct ubifs_info *c, const struct inode *inode) 205ff94bc40SHeiko Schocher { 206ff94bc40SHeiko Schocher int err; 207ff94bc40SHeiko Schocher const struct ubifs_inode *ui = ubifs_inode(inode); 208ff94bc40SHeiko Schocher 209ff94bc40SHeiko Schocher if (inode->i_size > c->max_inode_sz) { 2100195a7bbSHeiko Schocher ubifs_err(c, "inode is too large (%lld)", 211ff94bc40SHeiko Schocher (long long)inode->i_size); 212ff94bc40SHeiko Schocher return 1; 213ff94bc40SHeiko Schocher } 214ff94bc40SHeiko Schocher 2150195a7bbSHeiko Schocher if (ui->compr_type >= UBIFS_COMPR_TYPES_CNT) { 2160195a7bbSHeiko Schocher ubifs_err(c, "unknown compression type %d", ui->compr_type); 217ff94bc40SHeiko Schocher return 2; 218ff94bc40SHeiko Schocher } 219ff94bc40SHeiko Schocher 220ff94bc40SHeiko Schocher if (ui->xattr_names + ui->xattr_cnt > XATTR_LIST_MAX) 221ff94bc40SHeiko Schocher return 3; 222ff94bc40SHeiko Schocher 223ff94bc40SHeiko Schocher if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA) 224ff94bc40SHeiko Schocher return 4; 225ff94bc40SHeiko Schocher 226ff94bc40SHeiko Schocher if (ui->xattr && !S_ISREG(inode->i_mode)) 227ff94bc40SHeiko Schocher return 5; 228ff94bc40SHeiko Schocher 229ff94bc40SHeiko Schocher if (!ubifs_compr_present(ui->compr_type)) { 2300195a7bbSHeiko Schocher ubifs_warn(c, "inode %lu uses '%s' compression, but it was not compiled in", 231ff94bc40SHeiko Schocher inode->i_ino, ubifs_compr_name(ui->compr_type)); 232ff94bc40SHeiko Schocher } 233ff94bc40SHeiko Schocher 234ff94bc40SHeiko Schocher err = dbg_check_dir(c, inode); 235ff94bc40SHeiko Schocher return err; 236ff94bc40SHeiko Schocher } 237ff94bc40SHeiko Schocher 2389eefe2a2SStefan Roese struct inode *ubifs_iget(struct super_block *sb, unsigned long inum) 2399eefe2a2SStefan Roese { 2409eefe2a2SStefan Roese int err; 2419eefe2a2SStefan Roese union ubifs_key key; 2429eefe2a2SStefan Roese struct ubifs_ino_node *ino; 2439eefe2a2SStefan Roese struct ubifs_info *c = sb->s_fs_info; 2449eefe2a2SStefan Roese struct inode *inode; 2459eefe2a2SStefan Roese struct ubifs_inode *ui; 246ff94bc40SHeiko Schocher #ifdef __UBOOT__ 2479eefe2a2SStefan Roese int i; 248ff94bc40SHeiko Schocher #endif 2499eefe2a2SStefan Roese 2509eefe2a2SStefan Roese dbg_gen("inode %lu", inum); 2519eefe2a2SStefan Roese 252ff94bc40SHeiko Schocher #ifdef __UBOOT__ 2539eefe2a2SStefan Roese /* 2549eefe2a2SStefan Roese * U-Boot special handling of locked down inodes via recovery 2559eefe2a2SStefan Roese * e.g. ubifs_recover_size() 2569eefe2a2SStefan Roese */ 2579eefe2a2SStefan Roese for (i = 0; i < INODE_LOCKED_MAX; i++) { 2589eefe2a2SStefan Roese /* 2599eefe2a2SStefan Roese * Exit on last entry (NULL), inode not found in list 2609eefe2a2SStefan Roese */ 2619eefe2a2SStefan Roese if (inodes_locked_down[i] == NULL) 2629eefe2a2SStefan Roese break; 2639eefe2a2SStefan Roese 2649eefe2a2SStefan Roese if (inodes_locked_down[i]->i_ino == inum) { 2659eefe2a2SStefan Roese /* 2669eefe2a2SStefan Roese * We found the locked down inode in our array, 2679eefe2a2SStefan Roese * so just return this pointer instead of creating 2689eefe2a2SStefan Roese * a new one. 2699eefe2a2SStefan Roese */ 2709eefe2a2SStefan Roese return inodes_locked_down[i]; 2719eefe2a2SStefan Roese } 2729eefe2a2SStefan Roese } 273ff94bc40SHeiko Schocher #endif 2749eefe2a2SStefan Roese 2759eefe2a2SStefan Roese inode = iget_locked(sb, inum); 2769eefe2a2SStefan Roese if (!inode) 2779eefe2a2SStefan Roese return ERR_PTR(-ENOMEM); 2789eefe2a2SStefan Roese if (!(inode->i_state & I_NEW)) 2799eefe2a2SStefan Roese return inode; 2809eefe2a2SStefan Roese ui = ubifs_inode(inode); 2819eefe2a2SStefan Roese 2829eefe2a2SStefan Roese ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS); 2839eefe2a2SStefan Roese if (!ino) { 2849eefe2a2SStefan Roese err = -ENOMEM; 2859eefe2a2SStefan Roese goto out; 2869eefe2a2SStefan Roese } 2879eefe2a2SStefan Roese 2889eefe2a2SStefan Roese ino_key_init(c, &key, inode->i_ino); 2899eefe2a2SStefan Roese 2909eefe2a2SStefan Roese err = ubifs_tnc_lookup(c, &key, ino); 2919eefe2a2SStefan Roese if (err) 2929eefe2a2SStefan Roese goto out_ino; 2939eefe2a2SStefan Roese 2949eefe2a2SStefan Roese inode->i_flags |= (S_NOCMTIME | S_NOATIME); 295ff94bc40SHeiko Schocher set_nlink(inode, le32_to_cpu(ino->nlink)); 296ff94bc40SHeiko Schocher i_uid_write(inode, le32_to_cpu(ino->uid)); 297ff94bc40SHeiko Schocher i_gid_write(inode, le32_to_cpu(ino->gid)); 2989eefe2a2SStefan Roese inode->i_atime.tv_sec = (int64_t)le64_to_cpu(ino->atime_sec); 2999eefe2a2SStefan Roese inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec); 3009eefe2a2SStefan Roese inode->i_mtime.tv_sec = (int64_t)le64_to_cpu(ino->mtime_sec); 3019eefe2a2SStefan Roese inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec); 3029eefe2a2SStefan Roese inode->i_ctime.tv_sec = (int64_t)le64_to_cpu(ino->ctime_sec); 3039eefe2a2SStefan Roese inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec); 3049eefe2a2SStefan Roese inode->i_mode = le32_to_cpu(ino->mode); 3059eefe2a2SStefan Roese inode->i_size = le64_to_cpu(ino->size); 3069eefe2a2SStefan Roese 3079eefe2a2SStefan Roese ui->data_len = le32_to_cpu(ino->data_len); 3089eefe2a2SStefan Roese ui->flags = le32_to_cpu(ino->flags); 3099eefe2a2SStefan Roese ui->compr_type = le16_to_cpu(ino->compr_type); 3109eefe2a2SStefan Roese ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum); 311ff94bc40SHeiko Schocher ui->xattr_cnt = le32_to_cpu(ino->xattr_cnt); 312ff94bc40SHeiko Schocher ui->xattr_size = le32_to_cpu(ino->xattr_size); 313ff94bc40SHeiko Schocher ui->xattr_names = le32_to_cpu(ino->xattr_names); 3149eefe2a2SStefan Roese ui->synced_i_size = ui->ui_size = inode->i_size; 3159eefe2a2SStefan Roese 316ff94bc40SHeiko Schocher ui->xattr = (ui->flags & UBIFS_XATTR_FL) ? 1 : 0; 317ff94bc40SHeiko Schocher 3189eefe2a2SStefan Roese err = validate_inode(c, inode); 3199eefe2a2SStefan Roese if (err) 3209eefe2a2SStefan Roese goto out_invalid; 3219eefe2a2SStefan Roese 322ff94bc40SHeiko Schocher #ifndef __UBOOT__ 323ff94bc40SHeiko Schocher switch (inode->i_mode & S_IFMT) { 324ff94bc40SHeiko Schocher case S_IFREG: 325ff94bc40SHeiko Schocher inode->i_mapping->a_ops = &ubifs_file_address_operations; 326ff94bc40SHeiko Schocher inode->i_op = &ubifs_file_inode_operations; 327ff94bc40SHeiko Schocher inode->i_fop = &ubifs_file_operations; 328ff94bc40SHeiko Schocher if (ui->xattr) { 329ff94bc40SHeiko Schocher ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 330ff94bc40SHeiko Schocher if (!ui->data) { 331ff94bc40SHeiko Schocher err = -ENOMEM; 332ff94bc40SHeiko Schocher goto out_ino; 333ff94bc40SHeiko Schocher } 334ff94bc40SHeiko Schocher memcpy(ui->data, ino->data, ui->data_len); 335ff94bc40SHeiko Schocher ((char *)ui->data)[ui->data_len] = '\0'; 336ff94bc40SHeiko Schocher } else if (ui->data_len != 0) { 337ff94bc40SHeiko Schocher err = 10; 338ff94bc40SHeiko Schocher goto out_invalid; 339ff94bc40SHeiko Schocher } 340ff94bc40SHeiko Schocher break; 341ff94bc40SHeiko Schocher case S_IFDIR: 342ff94bc40SHeiko Schocher inode->i_op = &ubifs_dir_inode_operations; 343ff94bc40SHeiko Schocher inode->i_fop = &ubifs_dir_operations; 344ff94bc40SHeiko Schocher if (ui->data_len != 0) { 345ff94bc40SHeiko Schocher err = 11; 346ff94bc40SHeiko Schocher goto out_invalid; 347ff94bc40SHeiko Schocher } 348ff94bc40SHeiko Schocher break; 349ff94bc40SHeiko Schocher case S_IFLNK: 350ff94bc40SHeiko Schocher inode->i_op = &ubifs_symlink_inode_operations; 351ff94bc40SHeiko Schocher if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) { 352ff94bc40SHeiko Schocher err = 12; 353ff94bc40SHeiko Schocher goto out_invalid; 354ff94bc40SHeiko Schocher } 355ff94bc40SHeiko Schocher ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 356ff94bc40SHeiko Schocher if (!ui->data) { 357ff94bc40SHeiko Schocher err = -ENOMEM; 358ff94bc40SHeiko Schocher goto out_ino; 359ff94bc40SHeiko Schocher } 360ff94bc40SHeiko Schocher memcpy(ui->data, ino->data, ui->data_len); 361ff94bc40SHeiko Schocher ((char *)ui->data)[ui->data_len] = '\0'; 3620195a7bbSHeiko Schocher inode->i_link = ui->data; 363ff94bc40SHeiko Schocher break; 364ff94bc40SHeiko Schocher case S_IFBLK: 365ff94bc40SHeiko Schocher case S_IFCHR: 366ff94bc40SHeiko Schocher { 367ff94bc40SHeiko Schocher dev_t rdev; 368ff94bc40SHeiko Schocher union ubifs_dev_desc *dev; 369ff94bc40SHeiko Schocher 370ff94bc40SHeiko Schocher ui->data = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS); 371ff94bc40SHeiko Schocher if (!ui->data) { 372ff94bc40SHeiko Schocher err = -ENOMEM; 373ff94bc40SHeiko Schocher goto out_ino; 374ff94bc40SHeiko Schocher } 375ff94bc40SHeiko Schocher 376ff94bc40SHeiko Schocher dev = (union ubifs_dev_desc *)ino->data; 377ff94bc40SHeiko Schocher if (ui->data_len == sizeof(dev->new)) 378ff94bc40SHeiko Schocher rdev = new_decode_dev(le32_to_cpu(dev->new)); 379ff94bc40SHeiko Schocher else if (ui->data_len == sizeof(dev->huge)) 380ff94bc40SHeiko Schocher rdev = huge_decode_dev(le64_to_cpu(dev->huge)); 381ff94bc40SHeiko Schocher else { 382ff94bc40SHeiko Schocher err = 13; 383ff94bc40SHeiko Schocher goto out_invalid; 384ff94bc40SHeiko Schocher } 385ff94bc40SHeiko Schocher memcpy(ui->data, ino->data, ui->data_len); 386ff94bc40SHeiko Schocher inode->i_op = &ubifs_file_inode_operations; 387ff94bc40SHeiko Schocher init_special_inode(inode, inode->i_mode, rdev); 388ff94bc40SHeiko Schocher break; 389ff94bc40SHeiko Schocher } 390ff94bc40SHeiko Schocher case S_IFSOCK: 391ff94bc40SHeiko Schocher case S_IFIFO: 392ff94bc40SHeiko Schocher inode->i_op = &ubifs_file_inode_operations; 393ff94bc40SHeiko Schocher init_special_inode(inode, inode->i_mode, 0); 394ff94bc40SHeiko Schocher if (ui->data_len != 0) { 395ff94bc40SHeiko Schocher err = 14; 396ff94bc40SHeiko Schocher goto out_invalid; 397ff94bc40SHeiko Schocher } 398ff94bc40SHeiko Schocher break; 399ff94bc40SHeiko Schocher default: 400ff94bc40SHeiko Schocher err = 15; 401ff94bc40SHeiko Schocher goto out_invalid; 402ff94bc40SHeiko Schocher } 403ff94bc40SHeiko Schocher #else 4049eefe2a2SStefan Roese if ((inode->i_mode & S_IFMT) == S_IFLNK) { 4059eefe2a2SStefan Roese if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) { 4069eefe2a2SStefan Roese err = 12; 4079eefe2a2SStefan Roese goto out_invalid; 4089eefe2a2SStefan Roese } 4099eefe2a2SStefan Roese ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 4109eefe2a2SStefan Roese if (!ui->data) { 4119eefe2a2SStefan Roese err = -ENOMEM; 4129eefe2a2SStefan Roese goto out_ino; 4139eefe2a2SStefan Roese } 4149eefe2a2SStefan Roese memcpy(ui->data, ino->data, ui->data_len); 4159eefe2a2SStefan Roese ((char *)ui->data)[ui->data_len] = '\0'; 4169eefe2a2SStefan Roese } 417ff94bc40SHeiko Schocher #endif 4189eefe2a2SStefan Roese 4199eefe2a2SStefan Roese kfree(ino); 420ff94bc40SHeiko Schocher #ifndef __UBOOT__ 421ff94bc40SHeiko Schocher ubifs_set_inode_flags(inode); 422ff94bc40SHeiko Schocher #endif 423ff94bc40SHeiko Schocher unlock_new_inode(inode); 4249eefe2a2SStefan Roese return inode; 4259eefe2a2SStefan Roese 4269eefe2a2SStefan Roese out_invalid: 4270195a7bbSHeiko Schocher ubifs_err(c, "inode %lu validation failed, error %d", inode->i_ino, err); 428ff94bc40SHeiko Schocher ubifs_dump_node(c, ino); 429ff94bc40SHeiko Schocher ubifs_dump_inode(c, inode); 4309eefe2a2SStefan Roese err = -EINVAL; 4319eefe2a2SStefan Roese out_ino: 4329eefe2a2SStefan Roese kfree(ino); 4339eefe2a2SStefan Roese out: 4340195a7bbSHeiko Schocher ubifs_err(c, "failed to read inode %lu, error %d", inode->i_ino, err); 435ff94bc40SHeiko Schocher iget_failed(inode); 4369eefe2a2SStefan Roese return ERR_PTR(err); 4379eefe2a2SStefan Roese } 4389eefe2a2SStefan Roese 439ff94bc40SHeiko Schocher static struct inode *ubifs_alloc_inode(struct super_block *sb) 440ff94bc40SHeiko Schocher { 441ff94bc40SHeiko Schocher struct ubifs_inode *ui; 442ff94bc40SHeiko Schocher 443ff94bc40SHeiko Schocher ui = kmem_cache_alloc(ubifs_inode_slab, GFP_NOFS); 444ff94bc40SHeiko Schocher if (!ui) 445ff94bc40SHeiko Schocher return NULL; 446ff94bc40SHeiko Schocher 447ff94bc40SHeiko Schocher memset((void *)ui + sizeof(struct inode), 0, 448ff94bc40SHeiko Schocher sizeof(struct ubifs_inode) - sizeof(struct inode)); 449ff94bc40SHeiko Schocher mutex_init(&ui->ui_mutex); 450ff94bc40SHeiko Schocher spin_lock_init(&ui->ui_lock); 451ff94bc40SHeiko Schocher return &ui->vfs_inode; 452ff94bc40SHeiko Schocher }; 453ff94bc40SHeiko Schocher 454ff94bc40SHeiko Schocher #ifndef __UBOOT__ 455ff94bc40SHeiko Schocher static void ubifs_i_callback(struct rcu_head *head) 456ff94bc40SHeiko Schocher { 457ff94bc40SHeiko Schocher struct inode *inode = container_of(head, struct inode, i_rcu); 458ff94bc40SHeiko Schocher struct ubifs_inode *ui = ubifs_inode(inode); 459ff94bc40SHeiko Schocher kmem_cache_free(ubifs_inode_slab, ui); 460ff94bc40SHeiko Schocher } 461ff94bc40SHeiko Schocher 462ff94bc40SHeiko Schocher static void ubifs_destroy_inode(struct inode *inode) 463ff94bc40SHeiko Schocher { 464ff94bc40SHeiko Schocher struct ubifs_inode *ui = ubifs_inode(inode); 465ff94bc40SHeiko Schocher 466ff94bc40SHeiko Schocher kfree(ui->data); 467ff94bc40SHeiko Schocher call_rcu(&inode->i_rcu, ubifs_i_callback); 468ff94bc40SHeiko Schocher } 469ff94bc40SHeiko Schocher 470ff94bc40SHeiko Schocher /* 471ff94bc40SHeiko Schocher * Note, Linux write-back code calls this without 'i_mutex'. 472ff94bc40SHeiko Schocher */ 473ff94bc40SHeiko Schocher static int ubifs_write_inode(struct inode *inode, struct writeback_control *wbc) 474ff94bc40SHeiko Schocher { 475ff94bc40SHeiko Schocher int err = 0; 476ff94bc40SHeiko Schocher struct ubifs_info *c = inode->i_sb->s_fs_info; 477ff94bc40SHeiko Schocher struct ubifs_inode *ui = ubifs_inode(inode); 478ff94bc40SHeiko Schocher 479ff94bc40SHeiko Schocher ubifs_assert(!ui->xattr); 480ff94bc40SHeiko Schocher if (is_bad_inode(inode)) 481ff94bc40SHeiko Schocher return 0; 482ff94bc40SHeiko Schocher 483ff94bc40SHeiko Schocher mutex_lock(&ui->ui_mutex); 484ff94bc40SHeiko Schocher /* 485ff94bc40SHeiko Schocher * Due to races between write-back forced by budgeting 486ff94bc40SHeiko Schocher * (see 'sync_some_inodes()') and background write-back, the inode may 487ff94bc40SHeiko Schocher * have already been synchronized, do not do this again. This might 488ff94bc40SHeiko Schocher * also happen if it was synchronized in an VFS operation, e.g. 489ff94bc40SHeiko Schocher * 'ubifs_link()'. 490ff94bc40SHeiko Schocher */ 491ff94bc40SHeiko Schocher if (!ui->dirty) { 492ff94bc40SHeiko Schocher mutex_unlock(&ui->ui_mutex); 493ff94bc40SHeiko Schocher return 0; 494ff94bc40SHeiko Schocher } 495ff94bc40SHeiko Schocher 496ff94bc40SHeiko Schocher /* 497ff94bc40SHeiko Schocher * As an optimization, do not write orphan inodes to the media just 498ff94bc40SHeiko Schocher * because this is not needed. 499ff94bc40SHeiko Schocher */ 500ff94bc40SHeiko Schocher dbg_gen("inode %lu, mode %#x, nlink %u", 501ff94bc40SHeiko Schocher inode->i_ino, (int)inode->i_mode, inode->i_nlink); 502ff94bc40SHeiko Schocher if (inode->i_nlink) { 503ff94bc40SHeiko Schocher err = ubifs_jnl_write_inode(c, inode); 504ff94bc40SHeiko Schocher if (err) 5050195a7bbSHeiko Schocher ubifs_err(c, "can't write inode %lu, error %d", 506ff94bc40SHeiko Schocher inode->i_ino, err); 507ff94bc40SHeiko Schocher else 508ff94bc40SHeiko Schocher err = dbg_check_inode_size(c, inode, ui->ui_size); 509ff94bc40SHeiko Schocher } 510ff94bc40SHeiko Schocher 511ff94bc40SHeiko Schocher ui->dirty = 0; 512ff94bc40SHeiko Schocher mutex_unlock(&ui->ui_mutex); 513ff94bc40SHeiko Schocher ubifs_release_dirty_inode_budget(c, ui); 514ff94bc40SHeiko Schocher return err; 515ff94bc40SHeiko Schocher } 516ff94bc40SHeiko Schocher 517ff94bc40SHeiko Schocher static void ubifs_evict_inode(struct inode *inode) 518ff94bc40SHeiko Schocher { 519ff94bc40SHeiko Schocher int err; 520ff94bc40SHeiko Schocher struct ubifs_info *c = inode->i_sb->s_fs_info; 521ff94bc40SHeiko Schocher struct ubifs_inode *ui = ubifs_inode(inode); 522ff94bc40SHeiko Schocher 523ff94bc40SHeiko Schocher if (ui->xattr) 524ff94bc40SHeiko Schocher /* 525ff94bc40SHeiko Schocher * Extended attribute inode deletions are fully handled in 526ff94bc40SHeiko Schocher * 'ubifs_removexattr()'. These inodes are special and have 527ff94bc40SHeiko Schocher * limited usage, so there is nothing to do here. 528ff94bc40SHeiko Schocher */ 529ff94bc40SHeiko Schocher goto out; 530ff94bc40SHeiko Schocher 531ff94bc40SHeiko Schocher dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode); 532ff94bc40SHeiko Schocher ubifs_assert(!atomic_read(&inode->i_count)); 533ff94bc40SHeiko Schocher 5344e67c571SHeiko Schocher truncate_inode_pages_final(&inode->i_data); 535ff94bc40SHeiko Schocher 536ff94bc40SHeiko Schocher if (inode->i_nlink) 537ff94bc40SHeiko Schocher goto done; 538ff94bc40SHeiko Schocher 539ff94bc40SHeiko Schocher if (is_bad_inode(inode)) 540ff94bc40SHeiko Schocher goto out; 541ff94bc40SHeiko Schocher 542ff94bc40SHeiko Schocher ui->ui_size = inode->i_size = 0; 543ff94bc40SHeiko Schocher err = ubifs_jnl_delete_inode(c, inode); 544ff94bc40SHeiko Schocher if (err) 545ff94bc40SHeiko Schocher /* 546ff94bc40SHeiko Schocher * Worst case we have a lost orphan inode wasting space, so a 547ff94bc40SHeiko Schocher * simple error message is OK here. 548ff94bc40SHeiko Schocher */ 5490195a7bbSHeiko Schocher ubifs_err(c, "can't delete inode %lu, error %d", 550ff94bc40SHeiko Schocher inode->i_ino, err); 551ff94bc40SHeiko Schocher 552ff94bc40SHeiko Schocher out: 553ff94bc40SHeiko Schocher if (ui->dirty) 554ff94bc40SHeiko Schocher ubifs_release_dirty_inode_budget(c, ui); 555ff94bc40SHeiko Schocher else { 556ff94bc40SHeiko Schocher /* We've deleted something - clean the "no space" flags */ 557ff94bc40SHeiko Schocher c->bi.nospace = c->bi.nospace_rp = 0; 558ff94bc40SHeiko Schocher smp_wmb(); 559ff94bc40SHeiko Schocher } 560ff94bc40SHeiko Schocher done: 561ff94bc40SHeiko Schocher clear_inode(inode); 562ff94bc40SHeiko Schocher } 563ff94bc40SHeiko Schocher #endif 564ff94bc40SHeiko Schocher 565ff94bc40SHeiko Schocher static void ubifs_dirty_inode(struct inode *inode, int flags) 566ff94bc40SHeiko Schocher { 567ff94bc40SHeiko Schocher struct ubifs_inode *ui = ubifs_inode(inode); 568ff94bc40SHeiko Schocher 569ff94bc40SHeiko Schocher ubifs_assert(mutex_is_locked(&ui->ui_mutex)); 570ff94bc40SHeiko Schocher if (!ui->dirty) { 571ff94bc40SHeiko Schocher ui->dirty = 1; 572ff94bc40SHeiko Schocher dbg_gen("inode %lu", inode->i_ino); 573ff94bc40SHeiko Schocher } 574ff94bc40SHeiko Schocher } 575ff94bc40SHeiko Schocher 576ff94bc40SHeiko Schocher #ifndef __UBOOT__ 577ff94bc40SHeiko Schocher static int ubifs_statfs(struct dentry *dentry, struct kstatfs *buf) 578ff94bc40SHeiko Schocher { 579ff94bc40SHeiko Schocher struct ubifs_info *c = dentry->d_sb->s_fs_info; 580ff94bc40SHeiko Schocher unsigned long long free; 581ff94bc40SHeiko Schocher __le32 *uuid = (__le32 *)c->uuid; 582ff94bc40SHeiko Schocher 583ff94bc40SHeiko Schocher free = ubifs_get_free_space(c); 584ff94bc40SHeiko Schocher dbg_gen("free space %lld bytes (%lld blocks)", 585ff94bc40SHeiko Schocher free, free >> UBIFS_BLOCK_SHIFT); 586ff94bc40SHeiko Schocher 587ff94bc40SHeiko Schocher buf->f_type = UBIFS_SUPER_MAGIC; 588ff94bc40SHeiko Schocher buf->f_bsize = UBIFS_BLOCK_SIZE; 589ff94bc40SHeiko Schocher buf->f_blocks = c->block_cnt; 590ff94bc40SHeiko Schocher buf->f_bfree = free >> UBIFS_BLOCK_SHIFT; 591ff94bc40SHeiko Schocher if (free > c->report_rp_size) 592ff94bc40SHeiko Schocher buf->f_bavail = (free - c->report_rp_size) >> UBIFS_BLOCK_SHIFT; 593ff94bc40SHeiko Schocher else 594ff94bc40SHeiko Schocher buf->f_bavail = 0; 595ff94bc40SHeiko Schocher buf->f_files = 0; 596ff94bc40SHeiko Schocher buf->f_ffree = 0; 597ff94bc40SHeiko Schocher buf->f_namelen = UBIFS_MAX_NLEN; 598ff94bc40SHeiko Schocher buf->f_fsid.val[0] = le32_to_cpu(uuid[0]) ^ le32_to_cpu(uuid[2]); 599ff94bc40SHeiko Schocher buf->f_fsid.val[1] = le32_to_cpu(uuid[1]) ^ le32_to_cpu(uuid[3]); 600ff94bc40SHeiko Schocher ubifs_assert(buf->f_bfree <= c->block_cnt); 601ff94bc40SHeiko Schocher return 0; 602ff94bc40SHeiko Schocher } 603ff94bc40SHeiko Schocher 604ff94bc40SHeiko Schocher static int ubifs_show_options(struct seq_file *s, struct dentry *root) 605ff94bc40SHeiko Schocher { 606ff94bc40SHeiko Schocher struct ubifs_info *c = root->d_sb->s_fs_info; 607ff94bc40SHeiko Schocher 608ff94bc40SHeiko Schocher if (c->mount_opts.unmount_mode == 2) 6090195a7bbSHeiko Schocher seq_puts(s, ",fast_unmount"); 610ff94bc40SHeiko Schocher else if (c->mount_opts.unmount_mode == 1) 6110195a7bbSHeiko Schocher seq_puts(s, ",norm_unmount"); 612ff94bc40SHeiko Schocher 613ff94bc40SHeiko Schocher if (c->mount_opts.bulk_read == 2) 6140195a7bbSHeiko Schocher seq_puts(s, ",bulk_read"); 615ff94bc40SHeiko Schocher else if (c->mount_opts.bulk_read == 1) 6160195a7bbSHeiko Schocher seq_puts(s, ",no_bulk_read"); 617ff94bc40SHeiko Schocher 618ff94bc40SHeiko Schocher if (c->mount_opts.chk_data_crc == 2) 6190195a7bbSHeiko Schocher seq_puts(s, ",chk_data_crc"); 620ff94bc40SHeiko Schocher else if (c->mount_opts.chk_data_crc == 1) 6210195a7bbSHeiko Schocher seq_puts(s, ",no_chk_data_crc"); 622ff94bc40SHeiko Schocher 623ff94bc40SHeiko Schocher if (c->mount_opts.override_compr) { 624ff94bc40SHeiko Schocher seq_printf(s, ",compr=%s", 625ff94bc40SHeiko Schocher ubifs_compr_name(c->mount_opts.compr_type)); 626ff94bc40SHeiko Schocher } 627ff94bc40SHeiko Schocher 628ff94bc40SHeiko Schocher return 0; 629ff94bc40SHeiko Schocher } 630ff94bc40SHeiko Schocher 631ff94bc40SHeiko Schocher static int ubifs_sync_fs(struct super_block *sb, int wait) 632ff94bc40SHeiko Schocher { 633ff94bc40SHeiko Schocher int i, err; 634ff94bc40SHeiko Schocher struct ubifs_info *c = sb->s_fs_info; 635ff94bc40SHeiko Schocher 636ff94bc40SHeiko Schocher /* 637ff94bc40SHeiko Schocher * Zero @wait is just an advisory thing to help the file system shove 638ff94bc40SHeiko Schocher * lots of data into the queues, and there will be the second 639ff94bc40SHeiko Schocher * '->sync_fs()' call, with non-zero @wait. 640ff94bc40SHeiko Schocher */ 641ff94bc40SHeiko Schocher if (!wait) 642ff94bc40SHeiko Schocher return 0; 643ff94bc40SHeiko Schocher 644ff94bc40SHeiko Schocher /* 645ff94bc40SHeiko Schocher * Synchronize write buffers, because 'ubifs_run_commit()' does not 646ff94bc40SHeiko Schocher * do this if it waits for an already running commit. 647ff94bc40SHeiko Schocher */ 648ff94bc40SHeiko Schocher for (i = 0; i < c->jhead_cnt; i++) { 649ff94bc40SHeiko Schocher err = ubifs_wbuf_sync(&c->jheads[i].wbuf); 650ff94bc40SHeiko Schocher if (err) 651ff94bc40SHeiko Schocher return err; 652ff94bc40SHeiko Schocher } 653ff94bc40SHeiko Schocher 654ff94bc40SHeiko Schocher /* 655ff94bc40SHeiko Schocher * Strictly speaking, it is not necessary to commit the journal here, 656ff94bc40SHeiko Schocher * synchronizing write-buffers would be enough. But committing makes 657ff94bc40SHeiko Schocher * UBIFS free space predictions much more accurate, so we want to let 658ff94bc40SHeiko Schocher * the user be able to get more accurate results of 'statfs()' after 659ff94bc40SHeiko Schocher * they synchronize the file system. 660ff94bc40SHeiko Schocher */ 661ff94bc40SHeiko Schocher err = ubifs_run_commit(c); 662ff94bc40SHeiko Schocher if (err) 663ff94bc40SHeiko Schocher return err; 664ff94bc40SHeiko Schocher 665ff94bc40SHeiko Schocher return ubi_sync(c->vi.ubi_num); 666ff94bc40SHeiko Schocher } 667ff94bc40SHeiko Schocher #endif 668ff94bc40SHeiko Schocher 6699eefe2a2SStefan Roese /** 6709eefe2a2SStefan Roese * init_constants_early - initialize UBIFS constants. 6719eefe2a2SStefan Roese * @c: UBIFS file-system description object 6729eefe2a2SStefan Roese * 6739eefe2a2SStefan Roese * This function initialize UBIFS constants which do not need the superblock to 6749eefe2a2SStefan Roese * be read. It also checks that the UBI volume satisfies basic UBIFS 6759eefe2a2SStefan Roese * requirements. Returns zero in case of success and a negative error code in 6769eefe2a2SStefan Roese * case of failure. 6779eefe2a2SStefan Roese */ 6789eefe2a2SStefan Roese static int init_constants_early(struct ubifs_info *c) 6799eefe2a2SStefan Roese { 6809eefe2a2SStefan Roese if (c->vi.corrupted) { 6810195a7bbSHeiko Schocher ubifs_warn(c, "UBI volume is corrupted - read-only mode"); 6829eefe2a2SStefan Roese c->ro_media = 1; 6839eefe2a2SStefan Roese } 6849eefe2a2SStefan Roese 6859eefe2a2SStefan Roese if (c->di.ro_mode) { 6860195a7bbSHeiko Schocher ubifs_msg(c, "read-only UBI device"); 6879eefe2a2SStefan Roese c->ro_media = 1; 6889eefe2a2SStefan Roese } 6899eefe2a2SStefan Roese 6909eefe2a2SStefan Roese if (c->vi.vol_type == UBI_STATIC_VOLUME) { 6910195a7bbSHeiko Schocher ubifs_msg(c, "static UBI volume - read-only mode"); 6929eefe2a2SStefan Roese c->ro_media = 1; 6939eefe2a2SStefan Roese } 6949eefe2a2SStefan Roese 6959eefe2a2SStefan Roese c->leb_cnt = c->vi.size; 6969eefe2a2SStefan Roese c->leb_size = c->vi.usable_leb_size; 697ff94bc40SHeiko Schocher c->leb_start = c->di.leb_start; 6989eefe2a2SStefan Roese c->half_leb_size = c->leb_size / 2; 6999eefe2a2SStefan Roese c->min_io_size = c->di.min_io_size; 7009eefe2a2SStefan Roese c->min_io_shift = fls(c->min_io_size) - 1; 701ff94bc40SHeiko Schocher c->max_write_size = c->di.max_write_size; 702ff94bc40SHeiko Schocher c->max_write_shift = fls(c->max_write_size) - 1; 7039eefe2a2SStefan Roese 7049eefe2a2SStefan Roese if (c->leb_size < UBIFS_MIN_LEB_SZ) { 7050195a7bbSHeiko Schocher ubifs_err(c, "too small LEBs (%d bytes), min. is %d bytes", 7069eefe2a2SStefan Roese c->leb_size, UBIFS_MIN_LEB_SZ); 7079eefe2a2SStefan Roese return -EINVAL; 7089eefe2a2SStefan Roese } 7099eefe2a2SStefan Roese 7109eefe2a2SStefan Roese if (c->leb_cnt < UBIFS_MIN_LEB_CNT) { 7110195a7bbSHeiko Schocher ubifs_err(c, "too few LEBs (%d), min. is %d", 7129eefe2a2SStefan Roese c->leb_cnt, UBIFS_MIN_LEB_CNT); 7139eefe2a2SStefan Roese return -EINVAL; 7149eefe2a2SStefan Roese } 7159eefe2a2SStefan Roese 7169eefe2a2SStefan Roese if (!is_power_of_2(c->min_io_size)) { 7170195a7bbSHeiko Schocher ubifs_err(c, "bad min. I/O size %d", c->min_io_size); 7189eefe2a2SStefan Roese return -EINVAL; 7199eefe2a2SStefan Roese } 7209eefe2a2SStefan Roese 7219eefe2a2SStefan Roese /* 722ff94bc40SHeiko Schocher * Maximum write size has to be greater or equivalent to min. I/O 723ff94bc40SHeiko Schocher * size, and be multiple of min. I/O size. 724ff94bc40SHeiko Schocher */ 725ff94bc40SHeiko Schocher if (c->max_write_size < c->min_io_size || 726ff94bc40SHeiko Schocher c->max_write_size % c->min_io_size || 727ff94bc40SHeiko Schocher !is_power_of_2(c->max_write_size)) { 7280195a7bbSHeiko Schocher ubifs_err(c, "bad write buffer size %d for %d min. I/O unit", 729ff94bc40SHeiko Schocher c->max_write_size, c->min_io_size); 730ff94bc40SHeiko Schocher return -EINVAL; 731ff94bc40SHeiko Schocher } 732ff94bc40SHeiko Schocher 733ff94bc40SHeiko Schocher /* 7349eefe2a2SStefan Roese * UBIFS aligns all node to 8-byte boundary, so to make function in 7359eefe2a2SStefan Roese * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is 7369eefe2a2SStefan Roese * less than 8. 7379eefe2a2SStefan Roese */ 7389eefe2a2SStefan Roese if (c->min_io_size < 8) { 7399eefe2a2SStefan Roese c->min_io_size = 8; 7409eefe2a2SStefan Roese c->min_io_shift = 3; 741ff94bc40SHeiko Schocher if (c->max_write_size < c->min_io_size) { 742ff94bc40SHeiko Schocher c->max_write_size = c->min_io_size; 743ff94bc40SHeiko Schocher c->max_write_shift = c->min_io_shift; 744ff94bc40SHeiko Schocher } 7459eefe2a2SStefan Roese } 7469eefe2a2SStefan Roese 7479eefe2a2SStefan Roese c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size); 7489eefe2a2SStefan Roese c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size); 7499eefe2a2SStefan Roese 7509eefe2a2SStefan Roese /* 7519eefe2a2SStefan Roese * Initialize node length ranges which are mostly needed for node 7529eefe2a2SStefan Roese * length validation. 7539eefe2a2SStefan Roese */ 7549eefe2a2SStefan Roese c->ranges[UBIFS_PAD_NODE].len = UBIFS_PAD_NODE_SZ; 7559eefe2a2SStefan Roese c->ranges[UBIFS_SB_NODE].len = UBIFS_SB_NODE_SZ; 7569eefe2a2SStefan Roese c->ranges[UBIFS_MST_NODE].len = UBIFS_MST_NODE_SZ; 7579eefe2a2SStefan Roese c->ranges[UBIFS_REF_NODE].len = UBIFS_REF_NODE_SZ; 7589eefe2a2SStefan Roese c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ; 7599eefe2a2SStefan Roese c->ranges[UBIFS_CS_NODE].len = UBIFS_CS_NODE_SZ; 7609eefe2a2SStefan Roese 7619eefe2a2SStefan Roese c->ranges[UBIFS_INO_NODE].min_len = UBIFS_INO_NODE_SZ; 7629eefe2a2SStefan Roese c->ranges[UBIFS_INO_NODE].max_len = UBIFS_MAX_INO_NODE_SZ; 7639eefe2a2SStefan Roese c->ranges[UBIFS_ORPH_NODE].min_len = 7649eefe2a2SStefan Roese UBIFS_ORPH_NODE_SZ + sizeof(__le64); 7659eefe2a2SStefan Roese c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size; 7669eefe2a2SStefan Roese c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ; 7679eefe2a2SStefan Roese c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ; 7689eefe2a2SStefan Roese c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ; 7699eefe2a2SStefan Roese c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ; 7709eefe2a2SStefan Roese c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ; 7719eefe2a2SStefan Roese c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ; 7729eefe2a2SStefan Roese /* 7739eefe2a2SStefan Roese * Minimum indexing node size is amended later when superblock is 7749eefe2a2SStefan Roese * read and the key length is known. 7759eefe2a2SStefan Roese */ 7769eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ; 7779eefe2a2SStefan Roese /* 7789eefe2a2SStefan Roese * Maximum indexing node size is amended later when superblock is 7799eefe2a2SStefan Roese * read and the fanout is known. 7809eefe2a2SStefan Roese */ 7819eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX; 7829eefe2a2SStefan Roese 7839eefe2a2SStefan Roese /* 7849eefe2a2SStefan Roese * Initialize dead and dark LEB space watermarks. See gc.c for comments 7859eefe2a2SStefan Roese * about these values. 7869eefe2a2SStefan Roese */ 7879eefe2a2SStefan Roese c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size); 7889eefe2a2SStefan Roese c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size); 7899eefe2a2SStefan Roese 7909eefe2a2SStefan Roese /* 7919eefe2a2SStefan Roese * Calculate how many bytes would be wasted at the end of LEB if it was 7929eefe2a2SStefan Roese * fully filled with data nodes of maximum size. This is used in 7939eefe2a2SStefan Roese * calculations when reporting free space. 7949eefe2a2SStefan Roese */ 7959eefe2a2SStefan Roese c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ; 7969eefe2a2SStefan Roese 797ff94bc40SHeiko Schocher /* Buffer size for bulk-reads */ 798ff94bc40SHeiko Schocher c->max_bu_buf_len = UBIFS_MAX_BULK_READ * UBIFS_MAX_DATA_NODE_SZ; 799ff94bc40SHeiko Schocher if (c->max_bu_buf_len > c->leb_size) 800ff94bc40SHeiko Schocher c->max_bu_buf_len = c->leb_size; 8019eefe2a2SStefan Roese return 0; 8029eefe2a2SStefan Roese } 8039eefe2a2SStefan Roese 804ff94bc40SHeiko Schocher /** 805ff94bc40SHeiko Schocher * bud_wbuf_callback - bud LEB write-buffer synchronization call-back. 806ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 807ff94bc40SHeiko Schocher * @lnum: LEB the write-buffer was synchronized to 808ff94bc40SHeiko Schocher * @free: how many free bytes left in this LEB 809ff94bc40SHeiko Schocher * @pad: how many bytes were padded 810ff94bc40SHeiko Schocher * 811ff94bc40SHeiko Schocher * This is a callback function which is called by the I/O unit when the 812ff94bc40SHeiko Schocher * write-buffer is synchronized. We need this to correctly maintain space 813ff94bc40SHeiko Schocher * accounting in bud logical eraseblocks. This function returns zero in case of 814ff94bc40SHeiko Schocher * success and a negative error code in case of failure. 815ff94bc40SHeiko Schocher * 816ff94bc40SHeiko Schocher * This function actually belongs to the journal, but we keep it here because 817ff94bc40SHeiko Schocher * we want to keep it static. 818ff94bc40SHeiko Schocher */ 819ff94bc40SHeiko Schocher static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad) 820ff94bc40SHeiko Schocher { 821ff94bc40SHeiko Schocher return ubifs_update_one_lp(c, lnum, free, pad, 0, 0); 822ff94bc40SHeiko Schocher } 823ff94bc40SHeiko Schocher 8249eefe2a2SStefan Roese /* 8259eefe2a2SStefan Roese * init_constants_sb - initialize UBIFS constants. 8269eefe2a2SStefan Roese * @c: UBIFS file-system description object 8279eefe2a2SStefan Roese * 8289eefe2a2SStefan Roese * This is a helper function which initializes various UBIFS constants after 8299eefe2a2SStefan Roese * the superblock has been read. It also checks various UBIFS parameters and 8309eefe2a2SStefan Roese * makes sure they are all right. Returns zero in case of success and a 8319eefe2a2SStefan Roese * negative error code in case of failure. 8329eefe2a2SStefan Roese */ 8339eefe2a2SStefan Roese static int init_constants_sb(struct ubifs_info *c) 8349eefe2a2SStefan Roese { 8359eefe2a2SStefan Roese int tmp, err; 8369eefe2a2SStefan Roese long long tmp64; 8379eefe2a2SStefan Roese 8389eefe2a2SStefan Roese c->main_bytes = (long long)c->main_lebs * c->leb_size; 8399eefe2a2SStefan Roese c->max_znode_sz = sizeof(struct ubifs_znode) + 8409eefe2a2SStefan Roese c->fanout * sizeof(struct ubifs_zbranch); 8419eefe2a2SStefan Roese 8429eefe2a2SStefan Roese tmp = ubifs_idx_node_sz(c, 1); 8439eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].min_len = tmp; 8449eefe2a2SStefan Roese c->min_idx_node_sz = ALIGN(tmp, 8); 8459eefe2a2SStefan Roese 8469eefe2a2SStefan Roese tmp = ubifs_idx_node_sz(c, c->fanout); 8479eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].max_len = tmp; 8489eefe2a2SStefan Roese c->max_idx_node_sz = ALIGN(tmp, 8); 8499eefe2a2SStefan Roese 8509eefe2a2SStefan Roese /* Make sure LEB size is large enough to fit full commit */ 8519eefe2a2SStefan Roese tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt; 8529eefe2a2SStefan Roese tmp = ALIGN(tmp, c->min_io_size); 8539eefe2a2SStefan Roese if (tmp > c->leb_size) { 8540195a7bbSHeiko Schocher ubifs_err(c, "too small LEB size %d, at least %d needed", 8559eefe2a2SStefan Roese c->leb_size, tmp); 8569eefe2a2SStefan Roese return -EINVAL; 8579eefe2a2SStefan Roese } 8589eefe2a2SStefan Roese 8599eefe2a2SStefan Roese /* 8609eefe2a2SStefan Roese * Make sure that the log is large enough to fit reference nodes for 8619eefe2a2SStefan Roese * all buds plus one reserved LEB. 8629eefe2a2SStefan Roese */ 8639eefe2a2SStefan Roese tmp64 = c->max_bud_bytes + c->leb_size - 1; 8649eefe2a2SStefan Roese c->max_bud_cnt = div_u64(tmp64, c->leb_size); 8659eefe2a2SStefan Roese tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1); 8669eefe2a2SStefan Roese tmp /= c->leb_size; 8679eefe2a2SStefan Roese tmp += 1; 8689eefe2a2SStefan Roese if (c->log_lebs < tmp) { 8690195a7bbSHeiko Schocher ubifs_err(c, "too small log %d LEBs, required min. %d LEBs", 8709eefe2a2SStefan Roese c->log_lebs, tmp); 8719eefe2a2SStefan Roese return -EINVAL; 8729eefe2a2SStefan Roese } 8739eefe2a2SStefan Roese 8749eefe2a2SStefan Roese /* 8759eefe2a2SStefan Roese * When budgeting we assume worst-case scenarios when the pages are not 8769eefe2a2SStefan Roese * be compressed and direntries are of the maximum size. 8779eefe2a2SStefan Roese * 8789eefe2a2SStefan Roese * Note, data, which may be stored in inodes is budgeted separately, so 879ff94bc40SHeiko Schocher * it is not included into 'c->bi.inode_budget'. 8809eefe2a2SStefan Roese */ 881ff94bc40SHeiko Schocher c->bi.page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE; 882ff94bc40SHeiko Schocher c->bi.inode_budget = UBIFS_INO_NODE_SZ; 883ff94bc40SHeiko Schocher c->bi.dent_budget = UBIFS_MAX_DENT_NODE_SZ; 8849eefe2a2SStefan Roese 8859eefe2a2SStefan Roese /* 8869eefe2a2SStefan Roese * When the amount of flash space used by buds becomes 8879eefe2a2SStefan Roese * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit. 8889eefe2a2SStefan Roese * The writers are unblocked when the commit is finished. To avoid 8899eefe2a2SStefan Roese * writers to be blocked UBIFS initiates background commit in advance, 8909eefe2a2SStefan Roese * when number of bud bytes becomes above the limit defined below. 8919eefe2a2SStefan Roese */ 8929eefe2a2SStefan Roese c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4; 8939eefe2a2SStefan Roese 8949eefe2a2SStefan Roese /* 8959eefe2a2SStefan Roese * Ensure minimum journal size. All the bytes in the journal heads are 8969eefe2a2SStefan Roese * considered to be used, when calculating the current journal usage. 8979eefe2a2SStefan Roese * Consequently, if the journal is too small, UBIFS will treat it as 8989eefe2a2SStefan Roese * always full. 8999eefe2a2SStefan Roese */ 9009eefe2a2SStefan Roese tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1; 9019eefe2a2SStefan Roese if (c->bg_bud_bytes < tmp64) 9029eefe2a2SStefan Roese c->bg_bud_bytes = tmp64; 9039eefe2a2SStefan Roese if (c->max_bud_bytes < tmp64 + c->leb_size) 9049eefe2a2SStefan Roese c->max_bud_bytes = tmp64 + c->leb_size; 9059eefe2a2SStefan Roese 9069eefe2a2SStefan Roese err = ubifs_calc_lpt_geom(c); 9079eefe2a2SStefan Roese if (err) 9089eefe2a2SStefan Roese return err; 9099eefe2a2SStefan Roese 910ff94bc40SHeiko Schocher /* Initialize effective LEB size used in budgeting calculations */ 911ff94bc40SHeiko Schocher c->idx_leb_size = c->leb_size - c->max_idx_node_sz; 9129eefe2a2SStefan Roese return 0; 9139eefe2a2SStefan Roese } 9149eefe2a2SStefan Roese 9159eefe2a2SStefan Roese /* 9169eefe2a2SStefan Roese * init_constants_master - initialize UBIFS constants. 9179eefe2a2SStefan Roese * @c: UBIFS file-system description object 9189eefe2a2SStefan Roese * 9199eefe2a2SStefan Roese * This is a helper function which initializes various UBIFS constants after 9209eefe2a2SStefan Roese * the master node has been read. It also checks various UBIFS parameters and 9219eefe2a2SStefan Roese * makes sure they are all right. 9229eefe2a2SStefan Roese */ 9239eefe2a2SStefan Roese static void init_constants_master(struct ubifs_info *c) 9249eefe2a2SStefan Roese { 9259eefe2a2SStefan Roese long long tmp64; 9269eefe2a2SStefan Roese 927ff94bc40SHeiko Schocher c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c); 928ff94bc40SHeiko Schocher c->report_rp_size = ubifs_reported_space(c, c->rp_size); 9299eefe2a2SStefan Roese 9309eefe2a2SStefan Roese /* 9319eefe2a2SStefan Roese * Calculate total amount of FS blocks. This number is not used 9329eefe2a2SStefan Roese * internally because it does not make much sense for UBIFS, but it is 9339eefe2a2SStefan Roese * necessary to report something for the 'statfs()' call. 9349eefe2a2SStefan Roese * 9359eefe2a2SStefan Roese * Subtract the LEB reserved for GC, the LEB which is reserved for 9369eefe2a2SStefan Roese * deletions, minimum LEBs for the index, and assume only one journal 9379eefe2a2SStefan Roese * head is available. 9389eefe2a2SStefan Roese */ 9399eefe2a2SStefan Roese tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1; 9409eefe2a2SStefan Roese tmp64 *= (long long)c->leb_size - c->leb_overhead; 9419eefe2a2SStefan Roese tmp64 = ubifs_reported_space(c, tmp64); 9429eefe2a2SStefan Roese c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT; 9439eefe2a2SStefan Roese } 9449eefe2a2SStefan Roese 9459eefe2a2SStefan Roese /** 946ff94bc40SHeiko Schocher * take_gc_lnum - reserve GC LEB. 947ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 948ff94bc40SHeiko Schocher * 949ff94bc40SHeiko Schocher * This function ensures that the LEB reserved for garbage collection is marked 950ff94bc40SHeiko Schocher * as "taken" in lprops. We also have to set free space to LEB size and dirty 951ff94bc40SHeiko Schocher * space to zero, because lprops may contain out-of-date information if the 952ff94bc40SHeiko Schocher * file-system was un-mounted before it has been committed. This function 953ff94bc40SHeiko Schocher * returns zero in case of success and a negative error code in case of 954ff94bc40SHeiko Schocher * failure. 955ff94bc40SHeiko Schocher */ 956ff94bc40SHeiko Schocher static int take_gc_lnum(struct ubifs_info *c) 957ff94bc40SHeiko Schocher { 958ff94bc40SHeiko Schocher int err; 959ff94bc40SHeiko Schocher 960ff94bc40SHeiko Schocher if (c->gc_lnum == -1) { 9610195a7bbSHeiko Schocher ubifs_err(c, "no LEB for GC"); 962ff94bc40SHeiko Schocher return -EINVAL; 963ff94bc40SHeiko Schocher } 964ff94bc40SHeiko Schocher 965ff94bc40SHeiko Schocher /* And we have to tell lprops that this LEB is taken */ 966ff94bc40SHeiko Schocher err = ubifs_change_one_lp(c, c->gc_lnum, c->leb_size, 0, 967ff94bc40SHeiko Schocher LPROPS_TAKEN, 0, 0); 968ff94bc40SHeiko Schocher return err; 969ff94bc40SHeiko Schocher } 970ff94bc40SHeiko Schocher 971ff94bc40SHeiko Schocher /** 972ff94bc40SHeiko Schocher * alloc_wbufs - allocate write-buffers. 973ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 974ff94bc40SHeiko Schocher * 975ff94bc40SHeiko Schocher * This helper function allocates and initializes UBIFS write-buffers. Returns 976ff94bc40SHeiko Schocher * zero in case of success and %-ENOMEM in case of failure. 977ff94bc40SHeiko Schocher */ 978ff94bc40SHeiko Schocher static int alloc_wbufs(struct ubifs_info *c) 979ff94bc40SHeiko Schocher { 980ff94bc40SHeiko Schocher int i, err; 981ff94bc40SHeiko Schocher 9820195a7bbSHeiko Schocher c->jheads = kcalloc(c->jhead_cnt, sizeof(struct ubifs_jhead), 983ff94bc40SHeiko Schocher GFP_KERNEL); 984ff94bc40SHeiko Schocher if (!c->jheads) 985ff94bc40SHeiko Schocher return -ENOMEM; 986ff94bc40SHeiko Schocher 987ff94bc40SHeiko Schocher /* Initialize journal heads */ 988ff94bc40SHeiko Schocher for (i = 0; i < c->jhead_cnt; i++) { 989ff94bc40SHeiko Schocher INIT_LIST_HEAD(&c->jheads[i].buds_list); 990ff94bc40SHeiko Schocher err = ubifs_wbuf_init(c, &c->jheads[i].wbuf); 991ff94bc40SHeiko Schocher if (err) 992ff94bc40SHeiko Schocher return err; 993ff94bc40SHeiko Schocher 994ff94bc40SHeiko Schocher c->jheads[i].wbuf.sync_callback = &bud_wbuf_callback; 995ff94bc40SHeiko Schocher c->jheads[i].wbuf.jhead = i; 996ff94bc40SHeiko Schocher c->jheads[i].grouped = 1; 997ff94bc40SHeiko Schocher } 998ff94bc40SHeiko Schocher 999ff94bc40SHeiko Schocher /* 1000ff94bc40SHeiko Schocher * Garbage Collector head does not need to be synchronized by timer. 1001ff94bc40SHeiko Schocher * Also GC head nodes are not grouped. 1002ff94bc40SHeiko Schocher */ 1003ff94bc40SHeiko Schocher c->jheads[GCHD].wbuf.no_timer = 1; 1004ff94bc40SHeiko Schocher c->jheads[GCHD].grouped = 0; 1005ff94bc40SHeiko Schocher 1006ff94bc40SHeiko Schocher return 0; 1007ff94bc40SHeiko Schocher } 1008ff94bc40SHeiko Schocher 1009ff94bc40SHeiko Schocher /** 1010ff94bc40SHeiko Schocher * free_wbufs - free write-buffers. 1011ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1012ff94bc40SHeiko Schocher */ 1013ff94bc40SHeiko Schocher static void free_wbufs(struct ubifs_info *c) 1014ff94bc40SHeiko Schocher { 1015ff94bc40SHeiko Schocher int i; 1016ff94bc40SHeiko Schocher 1017ff94bc40SHeiko Schocher if (c->jheads) { 1018ff94bc40SHeiko Schocher for (i = 0; i < c->jhead_cnt; i++) { 1019ff94bc40SHeiko Schocher kfree(c->jheads[i].wbuf.buf); 1020ff94bc40SHeiko Schocher kfree(c->jheads[i].wbuf.inodes); 1021ff94bc40SHeiko Schocher } 1022ff94bc40SHeiko Schocher kfree(c->jheads); 1023ff94bc40SHeiko Schocher c->jheads = NULL; 1024ff94bc40SHeiko Schocher } 1025ff94bc40SHeiko Schocher } 1026ff94bc40SHeiko Schocher 1027ff94bc40SHeiko Schocher /** 10289eefe2a2SStefan Roese * free_orphans - free orphans. 10299eefe2a2SStefan Roese * @c: UBIFS file-system description object 10309eefe2a2SStefan Roese */ 10319eefe2a2SStefan Roese static void free_orphans(struct ubifs_info *c) 10329eefe2a2SStefan Roese { 10339eefe2a2SStefan Roese struct ubifs_orphan *orph; 10349eefe2a2SStefan Roese 10359eefe2a2SStefan Roese while (c->orph_dnext) { 10369eefe2a2SStefan Roese orph = c->orph_dnext; 10379eefe2a2SStefan Roese c->orph_dnext = orph->dnext; 10389eefe2a2SStefan Roese list_del(&orph->list); 10399eefe2a2SStefan Roese kfree(orph); 10409eefe2a2SStefan Roese } 10419eefe2a2SStefan Roese 10429eefe2a2SStefan Roese while (!list_empty(&c->orph_list)) { 10439eefe2a2SStefan Roese orph = list_entry(c->orph_list.next, struct ubifs_orphan, list); 10449eefe2a2SStefan Roese list_del(&orph->list); 10459eefe2a2SStefan Roese kfree(orph); 10460195a7bbSHeiko Schocher ubifs_err(c, "orphan list not empty at unmount"); 10479eefe2a2SStefan Roese } 10489eefe2a2SStefan Roese 10499eefe2a2SStefan Roese vfree(c->orph_buf); 10509eefe2a2SStefan Roese c->orph_buf = NULL; 10519eefe2a2SStefan Roese } 10529eefe2a2SStefan Roese 1053ff94bc40SHeiko Schocher /** 1054ff94bc40SHeiko Schocher * free_buds - free per-bud objects. 1055ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1056ff94bc40SHeiko Schocher */ 1057ff94bc40SHeiko Schocher static void free_buds(struct ubifs_info *c) 1058ff94bc40SHeiko Schocher { 1059ff94bc40SHeiko Schocher struct ubifs_bud *bud, *n; 1060ff94bc40SHeiko Schocher 1061ff94bc40SHeiko Schocher rbtree_postorder_for_each_entry_safe(bud, n, &c->buds, rb) 1062ff94bc40SHeiko Schocher kfree(bud); 1063ff94bc40SHeiko Schocher } 1064ff94bc40SHeiko Schocher 10659eefe2a2SStefan Roese /** 10669eefe2a2SStefan Roese * check_volume_empty - check if the UBI volume is empty. 10679eefe2a2SStefan Roese * @c: UBIFS file-system description object 10689eefe2a2SStefan Roese * 10699eefe2a2SStefan Roese * This function checks if the UBIFS volume is empty by looking if its LEBs are 10709eefe2a2SStefan Roese * mapped or not. The result of checking is stored in the @c->empty variable. 10719eefe2a2SStefan Roese * Returns zero in case of success and a negative error code in case of 10729eefe2a2SStefan Roese * failure. 10739eefe2a2SStefan Roese */ 10749eefe2a2SStefan Roese static int check_volume_empty(struct ubifs_info *c) 10759eefe2a2SStefan Roese { 10769eefe2a2SStefan Roese int lnum, err; 10779eefe2a2SStefan Roese 10789eefe2a2SStefan Roese c->empty = 1; 10799eefe2a2SStefan Roese for (lnum = 0; lnum < c->leb_cnt; lnum++) { 1080ff94bc40SHeiko Schocher err = ubifs_is_mapped(c, lnum); 10819eefe2a2SStefan Roese if (unlikely(err < 0)) 10829eefe2a2SStefan Roese return err; 10839eefe2a2SStefan Roese if (err == 1) { 10849eefe2a2SStefan Roese c->empty = 0; 10859eefe2a2SStefan Roese break; 10869eefe2a2SStefan Roese } 10879eefe2a2SStefan Roese 10889eefe2a2SStefan Roese cond_resched(); 10899eefe2a2SStefan Roese } 10909eefe2a2SStefan Roese 10919eefe2a2SStefan Roese return 0; 10929eefe2a2SStefan Roese } 10939eefe2a2SStefan Roese 1094ff94bc40SHeiko Schocher /* 1095ff94bc40SHeiko Schocher * UBIFS mount options. 1096ff94bc40SHeiko Schocher * 1097ff94bc40SHeiko Schocher * Opt_fast_unmount: do not run a journal commit before un-mounting 1098ff94bc40SHeiko Schocher * Opt_norm_unmount: run a journal commit before un-mounting 1099ff94bc40SHeiko Schocher * Opt_bulk_read: enable bulk-reads 1100ff94bc40SHeiko Schocher * Opt_no_bulk_read: disable bulk-reads 1101ff94bc40SHeiko Schocher * Opt_chk_data_crc: check CRCs when reading data nodes 1102ff94bc40SHeiko Schocher * Opt_no_chk_data_crc: do not check CRCs when reading data nodes 1103ff94bc40SHeiko Schocher * Opt_override_compr: override default compressor 1104ff94bc40SHeiko Schocher * Opt_err: just end of array marker 1105ff94bc40SHeiko Schocher */ 1106ff94bc40SHeiko Schocher enum { 1107ff94bc40SHeiko Schocher Opt_fast_unmount, 1108ff94bc40SHeiko Schocher Opt_norm_unmount, 1109ff94bc40SHeiko Schocher Opt_bulk_read, 1110ff94bc40SHeiko Schocher Opt_no_bulk_read, 1111ff94bc40SHeiko Schocher Opt_chk_data_crc, 1112ff94bc40SHeiko Schocher Opt_no_chk_data_crc, 1113ff94bc40SHeiko Schocher Opt_override_compr, 1114ff94bc40SHeiko Schocher Opt_err, 1115ff94bc40SHeiko Schocher }; 1116ff94bc40SHeiko Schocher 1117ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1118ff94bc40SHeiko Schocher static const match_table_t tokens = { 1119ff94bc40SHeiko Schocher {Opt_fast_unmount, "fast_unmount"}, 1120ff94bc40SHeiko Schocher {Opt_norm_unmount, "norm_unmount"}, 1121ff94bc40SHeiko Schocher {Opt_bulk_read, "bulk_read"}, 1122ff94bc40SHeiko Schocher {Opt_no_bulk_read, "no_bulk_read"}, 1123ff94bc40SHeiko Schocher {Opt_chk_data_crc, "chk_data_crc"}, 1124ff94bc40SHeiko Schocher {Opt_no_chk_data_crc, "no_chk_data_crc"}, 1125ff94bc40SHeiko Schocher {Opt_override_compr, "compr=%s"}, 1126ff94bc40SHeiko Schocher {Opt_err, NULL}, 1127ff94bc40SHeiko Schocher }; 1128ff94bc40SHeiko Schocher 1129ff94bc40SHeiko Schocher /** 1130ff94bc40SHeiko Schocher * parse_standard_option - parse a standard mount option. 1131ff94bc40SHeiko Schocher * @option: the option to parse 1132ff94bc40SHeiko Schocher * 1133ff94bc40SHeiko Schocher * Normally, standard mount options like "sync" are passed to file-systems as 1134ff94bc40SHeiko Schocher * flags. However, when a "rootflags=" kernel boot parameter is used, they may 1135ff94bc40SHeiko Schocher * be present in the options string. This function tries to deal with this 1136ff94bc40SHeiko Schocher * situation and parse standard options. Returns 0 if the option was not 1137ff94bc40SHeiko Schocher * recognized, and the corresponding integer flag if it was. 1138ff94bc40SHeiko Schocher * 1139ff94bc40SHeiko Schocher * UBIFS is only interested in the "sync" option, so do not check for anything 1140ff94bc40SHeiko Schocher * else. 1141ff94bc40SHeiko Schocher */ 1142ff94bc40SHeiko Schocher static int parse_standard_option(const char *option) 1143ff94bc40SHeiko Schocher { 11440195a7bbSHeiko Schocher 11450195a7bbSHeiko Schocher pr_notice("UBIFS: parse %s\n", option); 1146ff94bc40SHeiko Schocher if (!strcmp(option, "sync")) 1147ff94bc40SHeiko Schocher return MS_SYNCHRONOUS; 1148ff94bc40SHeiko Schocher return 0; 1149ff94bc40SHeiko Schocher } 1150ff94bc40SHeiko Schocher 1151ff94bc40SHeiko Schocher /** 1152ff94bc40SHeiko Schocher * ubifs_parse_options - parse mount parameters. 1153ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1154ff94bc40SHeiko Schocher * @options: parameters to parse 1155ff94bc40SHeiko Schocher * @is_remount: non-zero if this is FS re-mount 1156ff94bc40SHeiko Schocher * 1157ff94bc40SHeiko Schocher * This function parses UBIFS mount options and returns zero in case success 1158ff94bc40SHeiko Schocher * and a negative error code in case of failure. 1159ff94bc40SHeiko Schocher */ 1160ff94bc40SHeiko Schocher static int ubifs_parse_options(struct ubifs_info *c, char *options, 1161ff94bc40SHeiko Schocher int is_remount) 1162ff94bc40SHeiko Schocher { 1163ff94bc40SHeiko Schocher char *p; 1164ff94bc40SHeiko Schocher substring_t args[MAX_OPT_ARGS]; 1165ff94bc40SHeiko Schocher 1166ff94bc40SHeiko Schocher if (!options) 1167ff94bc40SHeiko Schocher return 0; 1168ff94bc40SHeiko Schocher 1169ff94bc40SHeiko Schocher while ((p = strsep(&options, ","))) { 1170ff94bc40SHeiko Schocher int token; 1171ff94bc40SHeiko Schocher 1172ff94bc40SHeiko Schocher if (!*p) 1173ff94bc40SHeiko Schocher continue; 1174ff94bc40SHeiko Schocher 1175ff94bc40SHeiko Schocher token = match_token(p, tokens, args); 1176ff94bc40SHeiko Schocher switch (token) { 1177ff94bc40SHeiko Schocher /* 1178ff94bc40SHeiko Schocher * %Opt_fast_unmount and %Opt_norm_unmount options are ignored. 1179ff94bc40SHeiko Schocher * We accept them in order to be backward-compatible. But this 1180ff94bc40SHeiko Schocher * should be removed at some point. 1181ff94bc40SHeiko Schocher */ 1182ff94bc40SHeiko Schocher case Opt_fast_unmount: 1183ff94bc40SHeiko Schocher c->mount_opts.unmount_mode = 2; 1184ff94bc40SHeiko Schocher break; 1185ff94bc40SHeiko Schocher case Opt_norm_unmount: 1186ff94bc40SHeiko Schocher c->mount_opts.unmount_mode = 1; 1187ff94bc40SHeiko Schocher break; 1188ff94bc40SHeiko Schocher case Opt_bulk_read: 1189ff94bc40SHeiko Schocher c->mount_opts.bulk_read = 2; 1190ff94bc40SHeiko Schocher c->bulk_read = 1; 1191ff94bc40SHeiko Schocher break; 1192ff94bc40SHeiko Schocher case Opt_no_bulk_read: 1193ff94bc40SHeiko Schocher c->mount_opts.bulk_read = 1; 1194ff94bc40SHeiko Schocher c->bulk_read = 0; 1195ff94bc40SHeiko Schocher break; 1196ff94bc40SHeiko Schocher case Opt_chk_data_crc: 1197ff94bc40SHeiko Schocher c->mount_opts.chk_data_crc = 2; 1198ff94bc40SHeiko Schocher c->no_chk_data_crc = 0; 1199ff94bc40SHeiko Schocher break; 1200ff94bc40SHeiko Schocher case Opt_no_chk_data_crc: 1201ff94bc40SHeiko Schocher c->mount_opts.chk_data_crc = 1; 1202ff94bc40SHeiko Schocher c->no_chk_data_crc = 1; 1203ff94bc40SHeiko Schocher break; 1204ff94bc40SHeiko Schocher case Opt_override_compr: 1205ff94bc40SHeiko Schocher { 1206ff94bc40SHeiko Schocher char *name = match_strdup(&args[0]); 1207ff94bc40SHeiko Schocher 1208ff94bc40SHeiko Schocher if (!name) 1209ff94bc40SHeiko Schocher return -ENOMEM; 1210ff94bc40SHeiko Schocher if (!strcmp(name, "none")) 1211ff94bc40SHeiko Schocher c->mount_opts.compr_type = UBIFS_COMPR_NONE; 1212ff94bc40SHeiko Schocher else if (!strcmp(name, "lzo")) 1213ff94bc40SHeiko Schocher c->mount_opts.compr_type = UBIFS_COMPR_LZO; 1214ff94bc40SHeiko Schocher else if (!strcmp(name, "zlib")) 1215ff94bc40SHeiko Schocher c->mount_opts.compr_type = UBIFS_COMPR_ZLIB; 1216ff94bc40SHeiko Schocher else { 12170195a7bbSHeiko Schocher ubifs_err(c, "unknown compressor \"%s\"", name); //FIXME: is c ready? 1218ff94bc40SHeiko Schocher kfree(name); 1219ff94bc40SHeiko Schocher return -EINVAL; 1220ff94bc40SHeiko Schocher } 1221ff94bc40SHeiko Schocher kfree(name); 1222ff94bc40SHeiko Schocher c->mount_opts.override_compr = 1; 1223ff94bc40SHeiko Schocher c->default_compr = c->mount_opts.compr_type; 1224ff94bc40SHeiko Schocher break; 1225ff94bc40SHeiko Schocher } 1226ff94bc40SHeiko Schocher default: 1227ff94bc40SHeiko Schocher { 1228ff94bc40SHeiko Schocher unsigned long flag; 1229ff94bc40SHeiko Schocher struct super_block *sb = c->vfs_sb; 1230ff94bc40SHeiko Schocher 1231ff94bc40SHeiko Schocher flag = parse_standard_option(p); 1232ff94bc40SHeiko Schocher if (!flag) { 12330195a7bbSHeiko Schocher ubifs_err(c, "unrecognized mount option \"%s\" or missing value", 1234ff94bc40SHeiko Schocher p); 1235ff94bc40SHeiko Schocher return -EINVAL; 1236ff94bc40SHeiko Schocher } 1237ff94bc40SHeiko Schocher sb->s_flags |= flag; 1238ff94bc40SHeiko Schocher break; 1239ff94bc40SHeiko Schocher } 1240ff94bc40SHeiko Schocher } 1241ff94bc40SHeiko Schocher } 1242ff94bc40SHeiko Schocher 1243ff94bc40SHeiko Schocher return 0; 1244ff94bc40SHeiko Schocher } 1245040cc7b3SAnton Habegger #endif 1246ff94bc40SHeiko Schocher 1247ff94bc40SHeiko Schocher /** 1248ff94bc40SHeiko Schocher * destroy_journal - destroy journal data structures. 1249ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1250ff94bc40SHeiko Schocher * 1251ff94bc40SHeiko Schocher * This function destroys journal data structures including those that may have 1252ff94bc40SHeiko Schocher * been created by recovery functions. 1253ff94bc40SHeiko Schocher */ 1254ff94bc40SHeiko Schocher static void destroy_journal(struct ubifs_info *c) 1255ff94bc40SHeiko Schocher { 1256ff94bc40SHeiko Schocher while (!list_empty(&c->unclean_leb_list)) { 1257ff94bc40SHeiko Schocher struct ubifs_unclean_leb *ucleb; 1258ff94bc40SHeiko Schocher 1259ff94bc40SHeiko Schocher ucleb = list_entry(c->unclean_leb_list.next, 1260ff94bc40SHeiko Schocher struct ubifs_unclean_leb, list); 1261ff94bc40SHeiko Schocher list_del(&ucleb->list); 1262ff94bc40SHeiko Schocher kfree(ucleb); 1263ff94bc40SHeiko Schocher } 1264ff94bc40SHeiko Schocher while (!list_empty(&c->old_buds)) { 1265ff94bc40SHeiko Schocher struct ubifs_bud *bud; 1266ff94bc40SHeiko Schocher 1267ff94bc40SHeiko Schocher bud = list_entry(c->old_buds.next, struct ubifs_bud, list); 1268ff94bc40SHeiko Schocher list_del(&bud->list); 1269ff94bc40SHeiko Schocher kfree(bud); 1270ff94bc40SHeiko Schocher } 1271ff94bc40SHeiko Schocher ubifs_destroy_idx_gc(c); 1272ff94bc40SHeiko Schocher ubifs_destroy_size_tree(c); 1273ff94bc40SHeiko Schocher ubifs_tnc_close(c); 1274ff94bc40SHeiko Schocher free_buds(c); 1275ff94bc40SHeiko Schocher } 1276ff94bc40SHeiko Schocher 1277ff94bc40SHeiko Schocher /** 1278ff94bc40SHeiko Schocher * bu_init - initialize bulk-read information. 1279ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1280ff94bc40SHeiko Schocher */ 1281ff94bc40SHeiko Schocher static void bu_init(struct ubifs_info *c) 1282ff94bc40SHeiko Schocher { 1283ff94bc40SHeiko Schocher ubifs_assert(c->bulk_read == 1); 1284ff94bc40SHeiko Schocher 1285ff94bc40SHeiko Schocher if (c->bu.buf) 1286ff94bc40SHeiko Schocher return; /* Already initialized */ 1287ff94bc40SHeiko Schocher 1288ff94bc40SHeiko Schocher again: 1289ff94bc40SHeiko Schocher c->bu.buf = kmalloc(c->max_bu_buf_len, GFP_KERNEL | __GFP_NOWARN); 1290ff94bc40SHeiko Schocher if (!c->bu.buf) { 1291ff94bc40SHeiko Schocher if (c->max_bu_buf_len > UBIFS_KMALLOC_OK) { 1292ff94bc40SHeiko Schocher c->max_bu_buf_len = UBIFS_KMALLOC_OK; 1293ff94bc40SHeiko Schocher goto again; 1294ff94bc40SHeiko Schocher } 1295ff94bc40SHeiko Schocher 1296ff94bc40SHeiko Schocher /* Just disable bulk-read */ 12970195a7bbSHeiko Schocher ubifs_warn(c, "cannot allocate %d bytes of memory for bulk-read, disabling it", 1298ff94bc40SHeiko Schocher c->max_bu_buf_len); 1299ff94bc40SHeiko Schocher c->mount_opts.bulk_read = 1; 1300ff94bc40SHeiko Schocher c->bulk_read = 0; 1301ff94bc40SHeiko Schocher return; 1302ff94bc40SHeiko Schocher } 1303ff94bc40SHeiko Schocher } 1304ff94bc40SHeiko Schocher 1305ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1306ff94bc40SHeiko Schocher /** 1307ff94bc40SHeiko Schocher * check_free_space - check if there is enough free space to mount. 1308ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1309ff94bc40SHeiko Schocher * 1310ff94bc40SHeiko Schocher * This function makes sure UBIFS has enough free space to be mounted in 1311ff94bc40SHeiko Schocher * read/write mode. UBIFS must always have some free space to allow deletions. 1312ff94bc40SHeiko Schocher */ 1313ff94bc40SHeiko Schocher static int check_free_space(struct ubifs_info *c) 1314ff94bc40SHeiko Schocher { 1315ff94bc40SHeiko Schocher ubifs_assert(c->dark_wm > 0); 1316ff94bc40SHeiko Schocher if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) { 13170195a7bbSHeiko Schocher ubifs_err(c, "insufficient free space to mount in R/W mode"); 1318ff94bc40SHeiko Schocher ubifs_dump_budg(c, &c->bi); 1319ff94bc40SHeiko Schocher ubifs_dump_lprops(c); 1320ff94bc40SHeiko Schocher return -ENOSPC; 1321ff94bc40SHeiko Schocher } 1322ff94bc40SHeiko Schocher return 0; 1323ff94bc40SHeiko Schocher } 1324ff94bc40SHeiko Schocher #endif 1325ff94bc40SHeiko Schocher 13269eefe2a2SStefan Roese /** 13279eefe2a2SStefan Roese * mount_ubifs - mount UBIFS file-system. 13289eefe2a2SStefan Roese * @c: UBIFS file-system description object 13299eefe2a2SStefan Roese * 13309eefe2a2SStefan Roese * This function mounts UBIFS file system. Returns zero in case of success and 13319eefe2a2SStefan Roese * a negative error code in case of failure. 13329eefe2a2SStefan Roese */ 13339eefe2a2SStefan Roese static int mount_ubifs(struct ubifs_info *c) 13349eefe2a2SStefan Roese { 1335ff94bc40SHeiko Schocher int err; 1336afb6fda2SPetr Vorel long long x; 1337afb6fda2SPetr Vorel #ifndef CONFIG_UBIFS_SILENCE_MSG 1338afb6fda2SPetr Vorel long long y; 1339afb6fda2SPetr Vorel #endif 13409eefe2a2SStefan Roese size_t sz; 13419eefe2a2SStefan Roese 1342ff94bc40SHeiko Schocher c->ro_mount = !!(c->vfs_sb->s_flags & MS_RDONLY); 13430195a7bbSHeiko Schocher /* Suppress error messages while probing if MS_SILENT is set */ 13440195a7bbSHeiko Schocher c->probing = !!(c->vfs_sb->s_flags & MS_SILENT); 1345ff94bc40SHeiko Schocher #ifdef __UBOOT__ 1346ff94bc40SHeiko Schocher if (!c->ro_mount) { 1347ff94bc40SHeiko Schocher printf("UBIFS: only ro mode in U-Boot allowed.\n"); 1348ff94bc40SHeiko Schocher return -EACCES; 1349ff94bc40SHeiko Schocher } 1350ff94bc40SHeiko Schocher #endif 1351ff94bc40SHeiko Schocher 13529eefe2a2SStefan Roese err = init_constants_early(c); 13539eefe2a2SStefan Roese if (err) 13549eefe2a2SStefan Roese return err; 13559eefe2a2SStefan Roese 13569eefe2a2SStefan Roese err = ubifs_debugging_init(c); 13579eefe2a2SStefan Roese if (err) 13589eefe2a2SStefan Roese return err; 13599eefe2a2SStefan Roese 13609eefe2a2SStefan Roese err = check_volume_empty(c); 13619eefe2a2SStefan Roese if (err) 13629eefe2a2SStefan Roese goto out_free; 13639eefe2a2SStefan Roese 1364ff94bc40SHeiko Schocher if (c->empty && (c->ro_mount || c->ro_media)) { 13659eefe2a2SStefan Roese /* 13669eefe2a2SStefan Roese * This UBI volume is empty, and read-only, or the file system 13679eefe2a2SStefan Roese * is mounted read-only - we cannot format it. 13689eefe2a2SStefan Roese */ 13690195a7bbSHeiko Schocher ubifs_err(c, "can't format empty UBI volume: read-only %s", 13709eefe2a2SStefan Roese c->ro_media ? "UBI volume" : "mount"); 13719eefe2a2SStefan Roese err = -EROFS; 13729eefe2a2SStefan Roese goto out_free; 13739eefe2a2SStefan Roese } 13749eefe2a2SStefan Roese 1375ff94bc40SHeiko Schocher if (c->ro_media && !c->ro_mount) { 13760195a7bbSHeiko Schocher ubifs_err(c, "cannot mount read-write - read-only media"); 13779eefe2a2SStefan Roese err = -EROFS; 13789eefe2a2SStefan Roese goto out_free; 13799eefe2a2SStefan Roese } 13809eefe2a2SStefan Roese 13819eefe2a2SStefan Roese /* 13829eefe2a2SStefan Roese * The requirement for the buffer is that it should fit indexing B-tree 13839eefe2a2SStefan Roese * height amount of integers. We assume the height if the TNC tree will 13849eefe2a2SStefan Roese * never exceed 64. 13859eefe2a2SStefan Roese */ 13869eefe2a2SStefan Roese err = -ENOMEM; 13879eefe2a2SStefan Roese c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL); 13889eefe2a2SStefan Roese if (!c->bottom_up_buf) 13899eefe2a2SStefan Roese goto out_free; 13909eefe2a2SStefan Roese 13919eefe2a2SStefan Roese c->sbuf = vmalloc(c->leb_size); 13929eefe2a2SStefan Roese if (!c->sbuf) 13939eefe2a2SStefan Roese goto out_free; 13949eefe2a2SStefan Roese 1395ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1396ff94bc40SHeiko Schocher if (!c->ro_mount) { 1397ff94bc40SHeiko Schocher c->ileb_buf = vmalloc(c->leb_size); 1398ff94bc40SHeiko Schocher if (!c->ileb_buf) 1399ff94bc40SHeiko Schocher goto out_free; 1400ff94bc40SHeiko Schocher } 1401ff94bc40SHeiko Schocher #endif 1402ff94bc40SHeiko Schocher 1403ff94bc40SHeiko Schocher if (c->bulk_read == 1) 1404ff94bc40SHeiko Schocher bu_init(c); 1405ff94bc40SHeiko Schocher 1406ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1407ff94bc40SHeiko Schocher if (!c->ro_mount) { 1408ff94bc40SHeiko Schocher c->write_reserve_buf = kmalloc(COMPRESSED_DATA_NODE_BUF_SZ, 1409ff94bc40SHeiko Schocher GFP_KERNEL); 1410ff94bc40SHeiko Schocher if (!c->write_reserve_buf) 1411ff94bc40SHeiko Schocher goto out_free; 1412ff94bc40SHeiko Schocher } 1413ff94bc40SHeiko Schocher #endif 1414ff94bc40SHeiko Schocher 1415ff94bc40SHeiko Schocher c->mounting = 1; 14169eefe2a2SStefan Roese 14179eefe2a2SStefan Roese err = ubifs_read_superblock(c); 14189eefe2a2SStefan Roese if (err) 14199eefe2a2SStefan Roese goto out_free; 14209eefe2a2SStefan Roese 14210195a7bbSHeiko Schocher c->probing = 0; 14220195a7bbSHeiko Schocher 14239eefe2a2SStefan Roese /* 14249eefe2a2SStefan Roese * Make sure the compressor which is set as default in the superblock 14259eefe2a2SStefan Roese * or overridden by mount options is actually compiled in. 14269eefe2a2SStefan Roese */ 14279eefe2a2SStefan Roese if (!ubifs_compr_present(c->default_compr)) { 14280195a7bbSHeiko Schocher ubifs_err(c, "'compressor \"%s\" is not compiled in", 14299eefe2a2SStefan Roese ubifs_compr_name(c->default_compr)); 1430ff94bc40SHeiko Schocher err = -ENOTSUPP; 14319eefe2a2SStefan Roese goto out_free; 14329eefe2a2SStefan Roese } 14339eefe2a2SStefan Roese 14349eefe2a2SStefan Roese err = init_constants_sb(c); 14359eefe2a2SStefan Roese if (err) 14369eefe2a2SStefan Roese goto out_free; 14379eefe2a2SStefan Roese 14389eefe2a2SStefan Roese sz = ALIGN(c->max_idx_node_sz, c->min_io_size); 14399eefe2a2SStefan Roese sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size); 14409eefe2a2SStefan Roese c->cbuf = kmalloc(sz, GFP_NOFS); 14419eefe2a2SStefan Roese if (!c->cbuf) { 14429eefe2a2SStefan Roese err = -ENOMEM; 14439eefe2a2SStefan Roese goto out_free; 14449eefe2a2SStefan Roese } 14459eefe2a2SStefan Roese 1446ff94bc40SHeiko Schocher err = alloc_wbufs(c); 1447ff94bc40SHeiko Schocher if (err) 1448ff94bc40SHeiko Schocher goto out_cbuf; 1449ff94bc40SHeiko Schocher 14509eefe2a2SStefan Roese sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id); 1451ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1452ff94bc40SHeiko Schocher if (!c->ro_mount) { 1453ff94bc40SHeiko Schocher /* Create background thread */ 1454ff94bc40SHeiko Schocher c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name); 1455ff94bc40SHeiko Schocher if (IS_ERR(c->bgt)) { 1456ff94bc40SHeiko Schocher err = PTR_ERR(c->bgt); 1457ff94bc40SHeiko Schocher c->bgt = NULL; 14580195a7bbSHeiko Schocher ubifs_err(c, "cannot spawn \"%s\", error %d", 1459ff94bc40SHeiko Schocher c->bgt_name, err); 1460ff94bc40SHeiko Schocher goto out_wbufs; 1461ff94bc40SHeiko Schocher } 1462ff94bc40SHeiko Schocher wake_up_process(c->bgt); 1463ff94bc40SHeiko Schocher } 1464ff94bc40SHeiko Schocher #endif 14659eefe2a2SStefan Roese 14669eefe2a2SStefan Roese err = ubifs_read_master(c); 14679eefe2a2SStefan Roese if (err) 14689eefe2a2SStefan Roese goto out_master; 14699eefe2a2SStefan Roese 14709eefe2a2SStefan Roese init_constants_master(c); 14719eefe2a2SStefan Roese 14729eefe2a2SStefan Roese if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) { 14730195a7bbSHeiko Schocher ubifs_msg(c, "recovery needed"); 14749eefe2a2SStefan Roese c->need_recovery = 1; 14759eefe2a2SStefan Roese } 14769eefe2a2SStefan Roese 1477ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1478ff94bc40SHeiko Schocher if (c->need_recovery && !c->ro_mount) { 1479ff94bc40SHeiko Schocher err = ubifs_recover_inl_heads(c, c->sbuf); 1480ff94bc40SHeiko Schocher if (err) 1481ff94bc40SHeiko Schocher goto out_master; 1482ff94bc40SHeiko Schocher } 1483ff94bc40SHeiko Schocher #endif 1484ff94bc40SHeiko Schocher 1485ff94bc40SHeiko Schocher err = ubifs_lpt_init(c, 1, !c->ro_mount); 1486ff94bc40SHeiko Schocher if (err) 1487ff94bc40SHeiko Schocher goto out_master; 1488ff94bc40SHeiko Schocher 1489ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1490ff94bc40SHeiko Schocher if (!c->ro_mount && c->space_fixup) { 1491ff94bc40SHeiko Schocher err = ubifs_fixup_free_space(c); 1492ff94bc40SHeiko Schocher if (err) 1493ff94bc40SHeiko Schocher goto out_lpt; 1494ff94bc40SHeiko Schocher } 1495ff94bc40SHeiko Schocher 14960195a7bbSHeiko Schocher if (!c->ro_mount && !c->need_recovery) { 1497ff94bc40SHeiko Schocher /* 1498ff94bc40SHeiko Schocher * Set the "dirty" flag so that if we reboot uncleanly we 1499ff94bc40SHeiko Schocher * will notice this immediately on the next mount. 1500ff94bc40SHeiko Schocher */ 1501ff94bc40SHeiko Schocher c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY); 1502ff94bc40SHeiko Schocher err = ubifs_write_master(c); 1503ff94bc40SHeiko Schocher if (err) 1504ff94bc40SHeiko Schocher goto out_lpt; 1505ff94bc40SHeiko Schocher } 1506ff94bc40SHeiko Schocher #endif 1507ff94bc40SHeiko Schocher 1508ff94bc40SHeiko Schocher err = dbg_check_idx_size(c, c->bi.old_idx_sz); 15099eefe2a2SStefan Roese if (err) 15109eefe2a2SStefan Roese goto out_lpt; 15119eefe2a2SStefan Roese 15129eefe2a2SStefan Roese err = ubifs_replay_journal(c); 15139eefe2a2SStefan Roese if (err) 15149eefe2a2SStefan Roese goto out_journal; 15159eefe2a2SStefan Roese 1516ff94bc40SHeiko Schocher /* Calculate 'min_idx_lebs' after journal replay */ 1517ff94bc40SHeiko Schocher c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c); 1518ff94bc40SHeiko Schocher 1519ff94bc40SHeiko Schocher err = ubifs_mount_orphans(c, c->need_recovery, c->ro_mount); 15209eefe2a2SStefan Roese if (err) 15219eefe2a2SStefan Roese goto out_orphans; 15229eefe2a2SStefan Roese 1523ff94bc40SHeiko Schocher if (!c->ro_mount) { 1524ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1525ff94bc40SHeiko Schocher int lnum; 1526ff94bc40SHeiko Schocher 1527ff94bc40SHeiko Schocher err = check_free_space(c); 1528ff94bc40SHeiko Schocher if (err) 1529ff94bc40SHeiko Schocher goto out_orphans; 1530ff94bc40SHeiko Schocher 1531ff94bc40SHeiko Schocher /* Check for enough log space */ 1532ff94bc40SHeiko Schocher lnum = c->lhead_lnum + 1; 1533ff94bc40SHeiko Schocher if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) 1534ff94bc40SHeiko Schocher lnum = UBIFS_LOG_LNUM; 1535ff94bc40SHeiko Schocher if (lnum == c->ltail_lnum) { 1536ff94bc40SHeiko Schocher err = ubifs_consolidate_log(c); 1537ff94bc40SHeiko Schocher if (err) 1538ff94bc40SHeiko Schocher goto out_orphans; 1539ff94bc40SHeiko Schocher } 1540ff94bc40SHeiko Schocher 15419eefe2a2SStefan Roese if (c->need_recovery) { 15429eefe2a2SStefan Roese err = ubifs_recover_size(c); 15439eefe2a2SStefan Roese if (err) 15449eefe2a2SStefan Roese goto out_orphans; 1545ff94bc40SHeiko Schocher err = ubifs_rcvry_gc_commit(c); 1546ff94bc40SHeiko Schocher if (err) 1547ff94bc40SHeiko Schocher goto out_orphans; 1548ff94bc40SHeiko Schocher } else { 1549ff94bc40SHeiko Schocher err = take_gc_lnum(c); 1550ff94bc40SHeiko Schocher if (err) 1551ff94bc40SHeiko Schocher goto out_orphans; 1552ff94bc40SHeiko Schocher 1553ff94bc40SHeiko Schocher /* 1554ff94bc40SHeiko Schocher * GC LEB may contain garbage if there was an unclean 1555ff94bc40SHeiko Schocher * reboot, and it should be un-mapped. 1556ff94bc40SHeiko Schocher */ 1557ff94bc40SHeiko Schocher err = ubifs_leb_unmap(c, c->gc_lnum); 1558ff94bc40SHeiko Schocher if (err) 1559ff94bc40SHeiko Schocher goto out_orphans; 15609eefe2a2SStefan Roese } 15619eefe2a2SStefan Roese 1562ff94bc40SHeiko Schocher err = dbg_check_lprops(c); 1563ff94bc40SHeiko Schocher if (err) 1564ff94bc40SHeiko Schocher goto out_orphans; 1565ff94bc40SHeiko Schocher #endif 1566ff94bc40SHeiko Schocher } else if (c->need_recovery) { 1567ff94bc40SHeiko Schocher err = ubifs_recover_size(c); 1568ff94bc40SHeiko Schocher if (err) 1569ff94bc40SHeiko Schocher goto out_orphans; 1570ff94bc40SHeiko Schocher } else { 1571ff94bc40SHeiko Schocher /* 1572ff94bc40SHeiko Schocher * Even if we mount read-only, we have to set space in GC LEB 1573ff94bc40SHeiko Schocher * to proper value because this affects UBIFS free space 1574ff94bc40SHeiko Schocher * reporting. We do not want to have a situation when 1575ff94bc40SHeiko Schocher * re-mounting from R/O to R/W changes amount of free space. 1576ff94bc40SHeiko Schocher */ 1577ff94bc40SHeiko Schocher err = take_gc_lnum(c); 1578ff94bc40SHeiko Schocher if (err) 1579ff94bc40SHeiko Schocher goto out_orphans; 1580ff94bc40SHeiko Schocher } 1581ff94bc40SHeiko Schocher 1582ff94bc40SHeiko Schocher #ifndef __UBOOT__ 15839eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 15849eefe2a2SStefan Roese list_add_tail(&c->infos_list, &ubifs_infos); 15859eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 1586ff94bc40SHeiko Schocher #endif 15879eefe2a2SStefan Roese 15889eefe2a2SStefan Roese if (c->need_recovery) { 1589ff94bc40SHeiko Schocher if (c->ro_mount) 15900195a7bbSHeiko Schocher ubifs_msg(c, "recovery deferred"); 15919eefe2a2SStefan Roese else { 15929eefe2a2SStefan Roese c->need_recovery = 0; 15930195a7bbSHeiko Schocher ubifs_msg(c, "recovery completed"); 1594ff94bc40SHeiko Schocher /* 1595ff94bc40SHeiko Schocher * GC LEB has to be empty and taken at this point. But 1596ff94bc40SHeiko Schocher * the journal head LEBs may also be accounted as 1597ff94bc40SHeiko Schocher * "empty taken" if they are empty. 1598ff94bc40SHeiko Schocher */ 1599ff94bc40SHeiko Schocher ubifs_assert(c->lst.taken_empty_lebs > 0); 16009eefe2a2SStefan Roese } 1601ff94bc40SHeiko Schocher } else 1602ff94bc40SHeiko Schocher ubifs_assert(c->lst.taken_empty_lebs > 0); 16039eefe2a2SStefan Roese 16049eefe2a2SStefan Roese err = dbg_check_filesystem(c); 16059eefe2a2SStefan Roese if (err) 16069eefe2a2SStefan Roese goto out_infos; 16079eefe2a2SStefan Roese 1608ff94bc40SHeiko Schocher err = dbg_debugfs_init_fs(c); 1609ff94bc40SHeiko Schocher if (err) 1610ff94bc40SHeiko Schocher goto out_infos; 16119eefe2a2SStefan Roese 1612ff94bc40SHeiko Schocher c->mounting = 0; 1613ff94bc40SHeiko Schocher 16140195a7bbSHeiko Schocher ubifs_msg(c, "UBIFS: mounted UBI device %d, volume %d, name \"%s\"%s", 1615ff94bc40SHeiko Schocher c->vi.ubi_num, c->vi.vol_id, c->vi.name, 1616ff94bc40SHeiko Schocher c->ro_mount ? ", R/O mode" : ""); 16179eefe2a2SStefan Roese x = (long long)c->main_lebs * c->leb_size; 1618afb6fda2SPetr Vorel #ifndef CONFIG_UBIFS_SILENCE_MSG 1619ff94bc40SHeiko Schocher y = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes; 1620afb6fda2SPetr Vorel #endif 16210195a7bbSHeiko Schocher ubifs_msg(c, "LEB size: %d bytes (%d KiB), min./max. I/O unit sizes: %d bytes/%d bytes", 1622ff94bc40SHeiko Schocher c->leb_size, c->leb_size >> 10, c->min_io_size, 1623ff94bc40SHeiko Schocher c->max_write_size); 16240195a7bbSHeiko Schocher ubifs_msg(c, "FS size: %lld bytes (%lld MiB, %d LEBs), journal size %lld bytes (%lld MiB, %d LEBs)", 1625ff94bc40SHeiko Schocher x, x >> 20, c->main_lebs, 1626ff94bc40SHeiko Schocher y, y >> 20, c->log_lebs + c->max_bud_cnt); 16270195a7bbSHeiko Schocher ubifs_msg(c, "reserved for root: %llu bytes (%llu KiB)", 16289eefe2a2SStefan Roese c->report_rp_size, c->report_rp_size >> 10); 16290195a7bbSHeiko Schocher ubifs_msg(c, "media format: w%d/r%d (latest is w%d/r%d), UUID %pUB%s", 1630ff94bc40SHeiko Schocher c->fmt_version, c->ro_compat_version, 1631ff94bc40SHeiko Schocher UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION, c->uuid, 1632ff94bc40SHeiko Schocher c->big_lpt ? ", big LPT model" : ", small LPT model"); 16339eefe2a2SStefan Roese 1634ff94bc40SHeiko Schocher dbg_gen("default compressor: %s", ubifs_compr_name(c->default_compr)); 1635ff94bc40SHeiko Schocher dbg_gen("data journal heads: %d", 16369eefe2a2SStefan Roese c->jhead_cnt - NONDATA_JHEADS_CNT); 1637ff94bc40SHeiko Schocher dbg_gen("log LEBs: %d (%d - %d)", 16389eefe2a2SStefan Roese c->log_lebs, UBIFS_LOG_LNUM, c->log_last); 1639ff94bc40SHeiko Schocher dbg_gen("LPT area LEBs: %d (%d - %d)", 16409eefe2a2SStefan Roese c->lpt_lebs, c->lpt_first, c->lpt_last); 1641ff94bc40SHeiko Schocher dbg_gen("orphan area LEBs: %d (%d - %d)", 16429eefe2a2SStefan Roese c->orph_lebs, c->orph_first, c->orph_last); 1643ff94bc40SHeiko Schocher dbg_gen("main area LEBs: %d (%d - %d)", 16449eefe2a2SStefan Roese c->main_lebs, c->main_first, c->leb_cnt - 1); 1645ff94bc40SHeiko Schocher dbg_gen("index LEBs: %d", c->lst.idx_lebs); 1646ff94bc40SHeiko Schocher dbg_gen("total index bytes: %lld (%lld KiB, %lld MiB)", 1647ff94bc40SHeiko Schocher c->bi.old_idx_sz, c->bi.old_idx_sz >> 10, 1648ff94bc40SHeiko Schocher c->bi.old_idx_sz >> 20); 1649ff94bc40SHeiko Schocher dbg_gen("key hash type: %d", c->key_hash_type); 1650ff94bc40SHeiko Schocher dbg_gen("tree fanout: %d", c->fanout); 1651ff94bc40SHeiko Schocher dbg_gen("reserved GC LEB: %d", c->gc_lnum); 1652ff94bc40SHeiko Schocher dbg_gen("max. znode size %d", c->max_znode_sz); 1653ff94bc40SHeiko Schocher dbg_gen("max. index node size %d", c->max_idx_node_sz); 1654ff94bc40SHeiko Schocher dbg_gen("node sizes: data %zu, inode %zu, dentry %zu", 16559eefe2a2SStefan Roese UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ); 1656ff94bc40SHeiko Schocher dbg_gen("node sizes: trun %zu, sb %zu, master %zu", 16579eefe2a2SStefan Roese UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ); 1658ff94bc40SHeiko Schocher dbg_gen("node sizes: ref %zu, cmt. start %zu, orph %zu", 16599eefe2a2SStefan Roese UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ); 1660ff94bc40SHeiko Schocher dbg_gen("max. node sizes: data %zu, inode %zu dentry %zu, idx %d", 16619eefe2a2SStefan Roese UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ, 1662ff94bc40SHeiko Schocher UBIFS_MAX_DENT_NODE_SZ, ubifs_idx_node_sz(c, c->fanout)); 1663ff94bc40SHeiko Schocher dbg_gen("dead watermark: %d", c->dead_wm); 1664ff94bc40SHeiko Schocher dbg_gen("dark watermark: %d", c->dark_wm); 1665ff94bc40SHeiko Schocher dbg_gen("LEB overhead: %d", c->leb_overhead); 16669eefe2a2SStefan Roese x = (long long)c->main_lebs * c->dark_wm; 1667ff94bc40SHeiko Schocher dbg_gen("max. dark space: %lld (%lld KiB, %lld MiB)", 16689eefe2a2SStefan Roese x, x >> 10, x >> 20); 1669ff94bc40SHeiko Schocher dbg_gen("maximum bud bytes: %lld (%lld KiB, %lld MiB)", 16709eefe2a2SStefan Roese c->max_bud_bytes, c->max_bud_bytes >> 10, 16719eefe2a2SStefan Roese c->max_bud_bytes >> 20); 1672ff94bc40SHeiko Schocher dbg_gen("BG commit bud bytes: %lld (%lld KiB, %lld MiB)", 16739eefe2a2SStefan Roese c->bg_bud_bytes, c->bg_bud_bytes >> 10, 16749eefe2a2SStefan Roese c->bg_bud_bytes >> 20); 1675ff94bc40SHeiko Schocher dbg_gen("current bud bytes %lld (%lld KiB, %lld MiB)", 16769eefe2a2SStefan Roese c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20); 1677ff94bc40SHeiko Schocher dbg_gen("max. seq. number: %llu", c->max_sqnum); 1678ff94bc40SHeiko Schocher dbg_gen("commit number: %llu", c->cmt_no); 16799eefe2a2SStefan Roese 16809eefe2a2SStefan Roese return 0; 16819eefe2a2SStefan Roese 16829eefe2a2SStefan Roese out_infos: 16839eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 16849eefe2a2SStefan Roese list_del(&c->infos_list); 16859eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 16869eefe2a2SStefan Roese out_orphans: 16879eefe2a2SStefan Roese free_orphans(c); 16889eefe2a2SStefan Roese out_journal: 1689ff94bc40SHeiko Schocher destroy_journal(c); 16909eefe2a2SStefan Roese out_lpt: 16919eefe2a2SStefan Roese ubifs_lpt_free(c, 0); 16929eefe2a2SStefan Roese out_master: 16939eefe2a2SStefan Roese kfree(c->mst_node); 16949eefe2a2SStefan Roese kfree(c->rcvrd_mst_node); 16959eefe2a2SStefan Roese if (c->bgt) 16969eefe2a2SStefan Roese kthread_stop(c->bgt); 1697ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1698ff94bc40SHeiko Schocher out_wbufs: 1699ff94bc40SHeiko Schocher #endif 1700ff94bc40SHeiko Schocher free_wbufs(c); 1701ff94bc40SHeiko Schocher out_cbuf: 17029eefe2a2SStefan Roese kfree(c->cbuf); 17039eefe2a2SStefan Roese out_free: 1704ff94bc40SHeiko Schocher kfree(c->write_reserve_buf); 1705ff94bc40SHeiko Schocher kfree(c->bu.buf); 17069eefe2a2SStefan Roese vfree(c->ileb_buf); 17079eefe2a2SStefan Roese vfree(c->sbuf); 17089eefe2a2SStefan Roese kfree(c->bottom_up_buf); 17099eefe2a2SStefan Roese ubifs_debugging_exit(c); 17109eefe2a2SStefan Roese return err; 17119eefe2a2SStefan Roese } 17129eefe2a2SStefan Roese 17139eefe2a2SStefan Roese /** 17149eefe2a2SStefan Roese * ubifs_umount - un-mount UBIFS file-system. 17159eefe2a2SStefan Roese * @c: UBIFS file-system description object 17169eefe2a2SStefan Roese * 17179eefe2a2SStefan Roese * Note, this function is called to free allocated resourced when un-mounting, 17189eefe2a2SStefan Roese * as well as free resources when an error occurred while we were half way 17199eefe2a2SStefan Roese * through mounting (error path cleanup function). So it has to make sure the 17209eefe2a2SStefan Roese * resource was actually allocated before freeing it. 17219eefe2a2SStefan Roese */ 1722ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1723ff94bc40SHeiko Schocher static void ubifs_umount(struct ubifs_info *c) 1724ff94bc40SHeiko Schocher #else 1725cb9c09d4SStefan Roese void ubifs_umount(struct ubifs_info *c) 1726ff94bc40SHeiko Schocher #endif 17279eefe2a2SStefan Roese { 17289eefe2a2SStefan Roese dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num, 17299eefe2a2SStefan Roese c->vi.vol_id); 17309eefe2a2SStefan Roese 1731ff94bc40SHeiko Schocher dbg_debugfs_exit_fs(c); 17329eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 17339eefe2a2SStefan Roese list_del(&c->infos_list); 17349eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 17359eefe2a2SStefan Roese 1736ff94bc40SHeiko Schocher #ifndef __UBOOT__ 17379eefe2a2SStefan Roese if (c->bgt) 17389eefe2a2SStefan Roese kthread_stop(c->bgt); 17399eefe2a2SStefan Roese 1740ff94bc40SHeiko Schocher destroy_journal(c); 1741ff94bc40SHeiko Schocher #endif 1742ff94bc40SHeiko Schocher free_wbufs(c); 17439eefe2a2SStefan Roese free_orphans(c); 17449eefe2a2SStefan Roese ubifs_lpt_free(c, 0); 17459eefe2a2SStefan Roese 17469eefe2a2SStefan Roese kfree(c->cbuf); 17479eefe2a2SStefan Roese kfree(c->rcvrd_mst_node); 17489eefe2a2SStefan Roese kfree(c->mst_node); 1749ff94bc40SHeiko Schocher kfree(c->write_reserve_buf); 1750ff94bc40SHeiko Schocher kfree(c->bu.buf); 17519eefe2a2SStefan Roese vfree(c->ileb_buf); 17529eefe2a2SStefan Roese vfree(c->sbuf); 17539eefe2a2SStefan Roese kfree(c->bottom_up_buf); 17549eefe2a2SStefan Roese ubifs_debugging_exit(c); 1755ff94bc40SHeiko Schocher #ifdef __UBOOT__ 17569eefe2a2SStefan Roese /* Finally free U-Boot's global copy of superblock */ 1757349a8d5eSLars Poeschel if (ubifs_sb != NULL) { 17589eefe2a2SStefan Roese free(ubifs_sb->s_fs_info); 17599eefe2a2SStefan Roese free(ubifs_sb); 17609eefe2a2SStefan Roese } 1761ff94bc40SHeiko Schocher #endif 1762349a8d5eSLars Poeschel } 17639eefe2a2SStefan Roese 1764ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1765ff94bc40SHeiko Schocher /** 1766ff94bc40SHeiko Schocher * ubifs_remount_rw - re-mount in read-write mode. 1767ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1768ff94bc40SHeiko Schocher * 1769ff94bc40SHeiko Schocher * UBIFS avoids allocating many unnecessary resources when mounted in read-only 1770ff94bc40SHeiko Schocher * mode. This function allocates the needed resources and re-mounts UBIFS in 1771ff94bc40SHeiko Schocher * read-write mode. 1772ff94bc40SHeiko Schocher */ 1773ff94bc40SHeiko Schocher static int ubifs_remount_rw(struct ubifs_info *c) 1774ff94bc40SHeiko Schocher { 1775ff94bc40SHeiko Schocher int err, lnum; 1776ff94bc40SHeiko Schocher 1777ff94bc40SHeiko Schocher if (c->rw_incompat) { 17780195a7bbSHeiko Schocher ubifs_err(c, "the file-system is not R/W-compatible"); 17790195a7bbSHeiko Schocher ubifs_msg(c, "on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d", 1780ff94bc40SHeiko Schocher c->fmt_version, c->ro_compat_version, 1781ff94bc40SHeiko Schocher UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION); 1782ff94bc40SHeiko Schocher return -EROFS; 1783ff94bc40SHeiko Schocher } 1784ff94bc40SHeiko Schocher 1785ff94bc40SHeiko Schocher mutex_lock(&c->umount_mutex); 1786ff94bc40SHeiko Schocher dbg_save_space_info(c); 1787ff94bc40SHeiko Schocher c->remounting_rw = 1; 1788ff94bc40SHeiko Schocher c->ro_mount = 0; 1789ff94bc40SHeiko Schocher 1790ff94bc40SHeiko Schocher if (c->space_fixup) { 1791ff94bc40SHeiko Schocher err = ubifs_fixup_free_space(c); 1792ff94bc40SHeiko Schocher if (err) 17934e67c571SHeiko Schocher goto out; 1794ff94bc40SHeiko Schocher } 1795ff94bc40SHeiko Schocher 1796ff94bc40SHeiko Schocher err = check_free_space(c); 1797ff94bc40SHeiko Schocher if (err) 1798ff94bc40SHeiko Schocher goto out; 1799ff94bc40SHeiko Schocher 1800ff94bc40SHeiko Schocher if (c->old_leb_cnt != c->leb_cnt) { 1801ff94bc40SHeiko Schocher struct ubifs_sb_node *sup; 1802ff94bc40SHeiko Schocher 1803ff94bc40SHeiko Schocher sup = ubifs_read_sb_node(c); 1804ff94bc40SHeiko Schocher if (IS_ERR(sup)) { 1805ff94bc40SHeiko Schocher err = PTR_ERR(sup); 1806ff94bc40SHeiko Schocher goto out; 1807ff94bc40SHeiko Schocher } 1808ff94bc40SHeiko Schocher sup->leb_cnt = cpu_to_le32(c->leb_cnt); 1809ff94bc40SHeiko Schocher err = ubifs_write_sb_node(c, sup); 1810ff94bc40SHeiko Schocher kfree(sup); 1811ff94bc40SHeiko Schocher if (err) 1812ff94bc40SHeiko Schocher goto out; 1813ff94bc40SHeiko Schocher } 1814ff94bc40SHeiko Schocher 1815ff94bc40SHeiko Schocher if (c->need_recovery) { 18160195a7bbSHeiko Schocher ubifs_msg(c, "completing deferred recovery"); 1817ff94bc40SHeiko Schocher err = ubifs_write_rcvrd_mst_node(c); 1818ff94bc40SHeiko Schocher if (err) 1819ff94bc40SHeiko Schocher goto out; 1820ff94bc40SHeiko Schocher err = ubifs_recover_size(c); 1821ff94bc40SHeiko Schocher if (err) 1822ff94bc40SHeiko Schocher goto out; 1823ff94bc40SHeiko Schocher err = ubifs_clean_lebs(c, c->sbuf); 1824ff94bc40SHeiko Schocher if (err) 1825ff94bc40SHeiko Schocher goto out; 1826ff94bc40SHeiko Schocher err = ubifs_recover_inl_heads(c, c->sbuf); 1827ff94bc40SHeiko Schocher if (err) 1828ff94bc40SHeiko Schocher goto out; 1829ff94bc40SHeiko Schocher } else { 1830ff94bc40SHeiko Schocher /* A readonly mount is not allowed to have orphans */ 1831ff94bc40SHeiko Schocher ubifs_assert(c->tot_orphans == 0); 1832ff94bc40SHeiko Schocher err = ubifs_clear_orphans(c); 1833ff94bc40SHeiko Schocher if (err) 1834ff94bc40SHeiko Schocher goto out; 1835ff94bc40SHeiko Schocher } 1836ff94bc40SHeiko Schocher 1837ff94bc40SHeiko Schocher if (!(c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY))) { 1838ff94bc40SHeiko Schocher c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY); 1839ff94bc40SHeiko Schocher err = ubifs_write_master(c); 1840ff94bc40SHeiko Schocher if (err) 1841ff94bc40SHeiko Schocher goto out; 1842ff94bc40SHeiko Schocher } 1843ff94bc40SHeiko Schocher 1844ff94bc40SHeiko Schocher c->ileb_buf = vmalloc(c->leb_size); 1845ff94bc40SHeiko Schocher if (!c->ileb_buf) { 1846ff94bc40SHeiko Schocher err = -ENOMEM; 1847ff94bc40SHeiko Schocher goto out; 1848ff94bc40SHeiko Schocher } 1849ff94bc40SHeiko Schocher 1850ff94bc40SHeiko Schocher c->write_reserve_buf = kmalloc(COMPRESSED_DATA_NODE_BUF_SZ, GFP_KERNEL); 1851ff94bc40SHeiko Schocher if (!c->write_reserve_buf) { 1852ff94bc40SHeiko Schocher err = -ENOMEM; 1853ff94bc40SHeiko Schocher goto out; 1854ff94bc40SHeiko Schocher } 1855ff94bc40SHeiko Schocher 1856ff94bc40SHeiko Schocher err = ubifs_lpt_init(c, 0, 1); 1857ff94bc40SHeiko Schocher if (err) 1858ff94bc40SHeiko Schocher goto out; 1859ff94bc40SHeiko Schocher 1860ff94bc40SHeiko Schocher /* Create background thread */ 1861ff94bc40SHeiko Schocher c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name); 1862ff94bc40SHeiko Schocher if (IS_ERR(c->bgt)) { 1863ff94bc40SHeiko Schocher err = PTR_ERR(c->bgt); 1864ff94bc40SHeiko Schocher c->bgt = NULL; 18650195a7bbSHeiko Schocher ubifs_err(c, "cannot spawn \"%s\", error %d", 1866ff94bc40SHeiko Schocher c->bgt_name, err); 1867ff94bc40SHeiko Schocher goto out; 1868ff94bc40SHeiko Schocher } 1869ff94bc40SHeiko Schocher wake_up_process(c->bgt); 1870ff94bc40SHeiko Schocher 1871ff94bc40SHeiko Schocher c->orph_buf = vmalloc(c->leb_size); 1872ff94bc40SHeiko Schocher if (!c->orph_buf) { 1873ff94bc40SHeiko Schocher err = -ENOMEM; 1874ff94bc40SHeiko Schocher goto out; 1875ff94bc40SHeiko Schocher } 1876ff94bc40SHeiko Schocher 1877ff94bc40SHeiko Schocher /* Check for enough log space */ 1878ff94bc40SHeiko Schocher lnum = c->lhead_lnum + 1; 1879ff94bc40SHeiko Schocher if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) 1880ff94bc40SHeiko Schocher lnum = UBIFS_LOG_LNUM; 1881ff94bc40SHeiko Schocher if (lnum == c->ltail_lnum) { 1882ff94bc40SHeiko Schocher err = ubifs_consolidate_log(c); 1883ff94bc40SHeiko Schocher if (err) 1884ff94bc40SHeiko Schocher goto out; 1885ff94bc40SHeiko Schocher } 1886ff94bc40SHeiko Schocher 1887ff94bc40SHeiko Schocher if (c->need_recovery) 1888ff94bc40SHeiko Schocher err = ubifs_rcvry_gc_commit(c); 1889ff94bc40SHeiko Schocher else 1890ff94bc40SHeiko Schocher err = ubifs_leb_unmap(c, c->gc_lnum); 1891ff94bc40SHeiko Schocher if (err) 1892ff94bc40SHeiko Schocher goto out; 1893ff94bc40SHeiko Schocher 1894ff94bc40SHeiko Schocher dbg_gen("re-mounted read-write"); 1895ff94bc40SHeiko Schocher c->remounting_rw = 0; 1896ff94bc40SHeiko Schocher 1897ff94bc40SHeiko Schocher if (c->need_recovery) { 1898ff94bc40SHeiko Schocher c->need_recovery = 0; 18990195a7bbSHeiko Schocher ubifs_msg(c, "deferred recovery completed"); 1900ff94bc40SHeiko Schocher } else { 1901ff94bc40SHeiko Schocher /* 1902ff94bc40SHeiko Schocher * Do not run the debugging space check if the were doing 1903ff94bc40SHeiko Schocher * recovery, because when we saved the information we had the 1904ff94bc40SHeiko Schocher * file-system in a state where the TNC and lprops has been 1905ff94bc40SHeiko Schocher * modified in memory, but all the I/O operations (including a 1906ff94bc40SHeiko Schocher * commit) were deferred. So the file-system was in 1907ff94bc40SHeiko Schocher * "non-committed" state. Now the file-system is in committed 1908ff94bc40SHeiko Schocher * state, and of course the amount of free space will change 1909ff94bc40SHeiko Schocher * because, for example, the old index size was imprecise. 1910ff94bc40SHeiko Schocher */ 1911ff94bc40SHeiko Schocher err = dbg_check_space_info(c); 1912ff94bc40SHeiko Schocher } 1913ff94bc40SHeiko Schocher 1914ff94bc40SHeiko Schocher mutex_unlock(&c->umount_mutex); 1915ff94bc40SHeiko Schocher return err; 1916ff94bc40SHeiko Schocher 1917ff94bc40SHeiko Schocher out: 1918ff94bc40SHeiko Schocher c->ro_mount = 1; 1919ff94bc40SHeiko Schocher vfree(c->orph_buf); 1920ff94bc40SHeiko Schocher c->orph_buf = NULL; 1921ff94bc40SHeiko Schocher if (c->bgt) { 1922ff94bc40SHeiko Schocher kthread_stop(c->bgt); 1923ff94bc40SHeiko Schocher c->bgt = NULL; 1924ff94bc40SHeiko Schocher } 1925ff94bc40SHeiko Schocher free_wbufs(c); 1926ff94bc40SHeiko Schocher kfree(c->write_reserve_buf); 1927ff94bc40SHeiko Schocher c->write_reserve_buf = NULL; 1928ff94bc40SHeiko Schocher vfree(c->ileb_buf); 1929ff94bc40SHeiko Schocher c->ileb_buf = NULL; 1930ff94bc40SHeiko Schocher ubifs_lpt_free(c, 1); 1931ff94bc40SHeiko Schocher c->remounting_rw = 0; 1932ff94bc40SHeiko Schocher mutex_unlock(&c->umount_mutex); 1933ff94bc40SHeiko Schocher return err; 1934ff94bc40SHeiko Schocher } 1935ff94bc40SHeiko Schocher 1936ff94bc40SHeiko Schocher /** 1937ff94bc40SHeiko Schocher * ubifs_remount_ro - re-mount in read-only mode. 1938ff94bc40SHeiko Schocher * @c: UBIFS file-system description object 1939ff94bc40SHeiko Schocher * 1940ff94bc40SHeiko Schocher * We assume VFS has stopped writing. Possibly the background thread could be 1941ff94bc40SHeiko Schocher * running a commit, however kthread_stop will wait in that case. 1942ff94bc40SHeiko Schocher */ 1943ff94bc40SHeiko Schocher static void ubifs_remount_ro(struct ubifs_info *c) 1944ff94bc40SHeiko Schocher { 1945ff94bc40SHeiko Schocher int i, err; 1946ff94bc40SHeiko Schocher 1947ff94bc40SHeiko Schocher ubifs_assert(!c->need_recovery); 1948ff94bc40SHeiko Schocher ubifs_assert(!c->ro_mount); 1949ff94bc40SHeiko Schocher 1950ff94bc40SHeiko Schocher mutex_lock(&c->umount_mutex); 1951ff94bc40SHeiko Schocher if (c->bgt) { 1952ff94bc40SHeiko Schocher kthread_stop(c->bgt); 1953ff94bc40SHeiko Schocher c->bgt = NULL; 1954ff94bc40SHeiko Schocher } 1955ff94bc40SHeiko Schocher 1956ff94bc40SHeiko Schocher dbg_save_space_info(c); 1957ff94bc40SHeiko Schocher 1958ff94bc40SHeiko Schocher for (i = 0; i < c->jhead_cnt; i++) 1959ff94bc40SHeiko Schocher ubifs_wbuf_sync(&c->jheads[i].wbuf); 1960ff94bc40SHeiko Schocher 1961ff94bc40SHeiko Schocher c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY); 1962ff94bc40SHeiko Schocher c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS); 1963ff94bc40SHeiko Schocher c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum); 1964ff94bc40SHeiko Schocher err = ubifs_write_master(c); 1965ff94bc40SHeiko Schocher if (err) 1966ff94bc40SHeiko Schocher ubifs_ro_mode(c, err); 1967ff94bc40SHeiko Schocher 1968ff94bc40SHeiko Schocher vfree(c->orph_buf); 1969ff94bc40SHeiko Schocher c->orph_buf = NULL; 1970ff94bc40SHeiko Schocher kfree(c->write_reserve_buf); 1971ff94bc40SHeiko Schocher c->write_reserve_buf = NULL; 1972ff94bc40SHeiko Schocher vfree(c->ileb_buf); 1973ff94bc40SHeiko Schocher c->ileb_buf = NULL; 1974ff94bc40SHeiko Schocher ubifs_lpt_free(c, 1); 1975ff94bc40SHeiko Schocher c->ro_mount = 1; 1976ff94bc40SHeiko Schocher err = dbg_check_space_info(c); 1977ff94bc40SHeiko Schocher if (err) 1978ff94bc40SHeiko Schocher ubifs_ro_mode(c, err); 1979ff94bc40SHeiko Schocher mutex_unlock(&c->umount_mutex); 1980ff94bc40SHeiko Schocher } 1981ff94bc40SHeiko Schocher 1982ff94bc40SHeiko Schocher static void ubifs_put_super(struct super_block *sb) 1983ff94bc40SHeiko Schocher { 1984ff94bc40SHeiko Schocher int i; 1985ff94bc40SHeiko Schocher struct ubifs_info *c = sb->s_fs_info; 1986ff94bc40SHeiko Schocher 19870195a7bbSHeiko Schocher ubifs_msg(c, "un-mount UBI device %d", c->vi.ubi_num); 1988ff94bc40SHeiko Schocher 1989ff94bc40SHeiko Schocher /* 1990ff94bc40SHeiko Schocher * The following asserts are only valid if there has not been a failure 1991ff94bc40SHeiko Schocher * of the media. For example, there will be dirty inodes if we failed 1992ff94bc40SHeiko Schocher * to write them back because of I/O errors. 1993ff94bc40SHeiko Schocher */ 1994ff94bc40SHeiko Schocher if (!c->ro_error) { 1995ff94bc40SHeiko Schocher ubifs_assert(c->bi.idx_growth == 0); 1996ff94bc40SHeiko Schocher ubifs_assert(c->bi.dd_growth == 0); 1997ff94bc40SHeiko Schocher ubifs_assert(c->bi.data_growth == 0); 1998ff94bc40SHeiko Schocher } 1999ff94bc40SHeiko Schocher 2000ff94bc40SHeiko Schocher /* 2001ff94bc40SHeiko Schocher * The 'c->umount_lock' prevents races between UBIFS memory shrinker 2002ff94bc40SHeiko Schocher * and file system un-mount. Namely, it prevents the shrinker from 2003ff94bc40SHeiko Schocher * picking this superblock for shrinking - it will be just skipped if 2004ff94bc40SHeiko Schocher * the mutex is locked. 2005ff94bc40SHeiko Schocher */ 2006ff94bc40SHeiko Schocher mutex_lock(&c->umount_mutex); 2007ff94bc40SHeiko Schocher if (!c->ro_mount) { 2008ff94bc40SHeiko Schocher /* 2009ff94bc40SHeiko Schocher * First of all kill the background thread to make sure it does 2010ff94bc40SHeiko Schocher * not interfere with un-mounting and freeing resources. 2011ff94bc40SHeiko Schocher */ 2012ff94bc40SHeiko Schocher if (c->bgt) { 2013ff94bc40SHeiko Schocher kthread_stop(c->bgt); 2014ff94bc40SHeiko Schocher c->bgt = NULL; 2015ff94bc40SHeiko Schocher } 2016ff94bc40SHeiko Schocher 2017ff94bc40SHeiko Schocher /* 2018ff94bc40SHeiko Schocher * On fatal errors c->ro_error is set to 1, in which case we do 2019ff94bc40SHeiko Schocher * not write the master node. 2020ff94bc40SHeiko Schocher */ 2021ff94bc40SHeiko Schocher if (!c->ro_error) { 2022ff94bc40SHeiko Schocher int err; 2023ff94bc40SHeiko Schocher 2024ff94bc40SHeiko Schocher /* Synchronize write-buffers */ 2025ff94bc40SHeiko Schocher for (i = 0; i < c->jhead_cnt; i++) 2026ff94bc40SHeiko Schocher ubifs_wbuf_sync(&c->jheads[i].wbuf); 2027ff94bc40SHeiko Schocher 2028ff94bc40SHeiko Schocher /* 2029ff94bc40SHeiko Schocher * We are being cleanly unmounted which means the 2030ff94bc40SHeiko Schocher * orphans were killed - indicate this in the master 2031ff94bc40SHeiko Schocher * node. Also save the reserved GC LEB number. 2032ff94bc40SHeiko Schocher */ 2033ff94bc40SHeiko Schocher c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY); 2034ff94bc40SHeiko Schocher c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS); 2035ff94bc40SHeiko Schocher c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum); 2036ff94bc40SHeiko Schocher err = ubifs_write_master(c); 2037ff94bc40SHeiko Schocher if (err) 2038ff94bc40SHeiko Schocher /* 2039ff94bc40SHeiko Schocher * Recovery will attempt to fix the master area 2040ff94bc40SHeiko Schocher * next mount, so we just print a message and 2041ff94bc40SHeiko Schocher * continue to unmount normally. 2042ff94bc40SHeiko Schocher */ 20430195a7bbSHeiko Schocher ubifs_err(c, "failed to write master node, error %d", 2044ff94bc40SHeiko Schocher err); 2045ff94bc40SHeiko Schocher } else { 2046ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2047ff94bc40SHeiko Schocher for (i = 0; i < c->jhead_cnt; i++) 2048ff94bc40SHeiko Schocher /* Make sure write-buffer timers are canceled */ 2049ff94bc40SHeiko Schocher hrtimer_cancel(&c->jheads[i].wbuf.timer); 2050ff94bc40SHeiko Schocher #endif 2051ff94bc40SHeiko Schocher } 2052ff94bc40SHeiko Schocher } 2053ff94bc40SHeiko Schocher 2054ff94bc40SHeiko Schocher ubifs_umount(c); 2055ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2056ff94bc40SHeiko Schocher bdi_destroy(&c->bdi); 2057ff94bc40SHeiko Schocher #endif 2058ff94bc40SHeiko Schocher ubi_close_volume(c->ubi); 2059ff94bc40SHeiko Schocher mutex_unlock(&c->umount_mutex); 2060ff94bc40SHeiko Schocher } 2061ff94bc40SHeiko Schocher #endif 2062ff94bc40SHeiko Schocher 2063ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2064ff94bc40SHeiko Schocher static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) 2065ff94bc40SHeiko Schocher { 2066ff94bc40SHeiko Schocher int err; 2067ff94bc40SHeiko Schocher struct ubifs_info *c = sb->s_fs_info; 2068ff94bc40SHeiko Schocher 20694e67c571SHeiko Schocher sync_filesystem(sb); 2070ff94bc40SHeiko Schocher dbg_gen("old flags %#lx, new flags %#x", sb->s_flags, *flags); 2071ff94bc40SHeiko Schocher 2072ff94bc40SHeiko Schocher err = ubifs_parse_options(c, data, 1); 2073ff94bc40SHeiko Schocher if (err) { 20740195a7bbSHeiko Schocher ubifs_err(c, "invalid or unknown remount parameter"); 2075ff94bc40SHeiko Schocher return err; 2076ff94bc40SHeiko Schocher } 2077ff94bc40SHeiko Schocher 2078ff94bc40SHeiko Schocher if (c->ro_mount && !(*flags & MS_RDONLY)) { 2079ff94bc40SHeiko Schocher if (c->ro_error) { 20800195a7bbSHeiko Schocher ubifs_msg(c, "cannot re-mount R/W due to prior errors"); 2081ff94bc40SHeiko Schocher return -EROFS; 2082ff94bc40SHeiko Schocher } 2083ff94bc40SHeiko Schocher if (c->ro_media) { 20840195a7bbSHeiko Schocher ubifs_msg(c, "cannot re-mount R/W - UBI volume is R/O"); 2085ff94bc40SHeiko Schocher return -EROFS; 2086ff94bc40SHeiko Schocher } 2087ff94bc40SHeiko Schocher err = ubifs_remount_rw(c); 2088ff94bc40SHeiko Schocher if (err) 2089ff94bc40SHeiko Schocher return err; 2090ff94bc40SHeiko Schocher } else if (!c->ro_mount && (*flags & MS_RDONLY)) { 2091ff94bc40SHeiko Schocher if (c->ro_error) { 20920195a7bbSHeiko Schocher ubifs_msg(c, "cannot re-mount R/O due to prior errors"); 2093ff94bc40SHeiko Schocher return -EROFS; 2094ff94bc40SHeiko Schocher } 2095ff94bc40SHeiko Schocher ubifs_remount_ro(c); 2096ff94bc40SHeiko Schocher } 2097ff94bc40SHeiko Schocher 2098ff94bc40SHeiko Schocher if (c->bulk_read == 1) 2099ff94bc40SHeiko Schocher bu_init(c); 2100ff94bc40SHeiko Schocher else { 2101ff94bc40SHeiko Schocher dbg_gen("disable bulk-read"); 2102ff94bc40SHeiko Schocher kfree(c->bu.buf); 2103ff94bc40SHeiko Schocher c->bu.buf = NULL; 2104ff94bc40SHeiko Schocher } 2105ff94bc40SHeiko Schocher 2106ff94bc40SHeiko Schocher ubifs_assert(c->lst.taken_empty_lebs > 0); 2107ff94bc40SHeiko Schocher return 0; 2108ff94bc40SHeiko Schocher } 2109ff94bc40SHeiko Schocher #endif 2110ff94bc40SHeiko Schocher 2111ff94bc40SHeiko Schocher const struct super_operations ubifs_super_operations = { 2112ff94bc40SHeiko Schocher .alloc_inode = ubifs_alloc_inode, 2113ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2114ff94bc40SHeiko Schocher .destroy_inode = ubifs_destroy_inode, 2115ff94bc40SHeiko Schocher .put_super = ubifs_put_super, 2116ff94bc40SHeiko Schocher .write_inode = ubifs_write_inode, 2117ff94bc40SHeiko Schocher .evict_inode = ubifs_evict_inode, 2118ff94bc40SHeiko Schocher .statfs = ubifs_statfs, 2119ff94bc40SHeiko Schocher #endif 2120ff94bc40SHeiko Schocher .dirty_inode = ubifs_dirty_inode, 2121ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2122ff94bc40SHeiko Schocher .remount_fs = ubifs_remount_fs, 2123ff94bc40SHeiko Schocher .show_options = ubifs_show_options, 2124ff94bc40SHeiko Schocher .sync_fs = ubifs_sync_fs, 2125ff94bc40SHeiko Schocher #endif 2126ff94bc40SHeiko Schocher }; 2127ff94bc40SHeiko Schocher 21289eefe2a2SStefan Roese /** 21299eefe2a2SStefan Roese * open_ubi - parse UBI device name string and open the UBI device. 21309eefe2a2SStefan Roese * @name: UBI volume name 21319eefe2a2SStefan Roese * @mode: UBI volume open mode 21329eefe2a2SStefan Roese * 2133ff94bc40SHeiko Schocher * The primary method of mounting UBIFS is by specifying the UBI volume 2134ff94bc40SHeiko Schocher * character device node path. However, UBIFS may also be mounted withoug any 2135ff94bc40SHeiko Schocher * character device node using one of the following methods: 2136ff94bc40SHeiko Schocher * 2137ff94bc40SHeiko Schocher * o ubiX_Y - mount UBI device number X, volume Y; 2138ff94bc40SHeiko Schocher * o ubiY - mount UBI device number 0, volume Y; 21399eefe2a2SStefan Roese * o ubiX:NAME - mount UBI device X, volume with name NAME; 21409eefe2a2SStefan Roese * o ubi:NAME - mount UBI device 0, volume with name NAME. 21419eefe2a2SStefan Roese * 21429eefe2a2SStefan Roese * Alternative '!' separator may be used instead of ':' (because some shells 21439eefe2a2SStefan Roese * like busybox may interpret ':' as an NFS host name separator). This function 2144ff94bc40SHeiko Schocher * returns UBI volume description object in case of success and a negative 2145ff94bc40SHeiko Schocher * error code in case of failure. 21469eefe2a2SStefan Roese */ 21479eefe2a2SStefan Roese static struct ubi_volume_desc *open_ubi(const char *name, int mode) 21489eefe2a2SStefan Roese { 2149ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2150ff94bc40SHeiko Schocher struct ubi_volume_desc *ubi; 2151ff94bc40SHeiko Schocher #endif 21529eefe2a2SStefan Roese int dev, vol; 21539eefe2a2SStefan Roese char *endptr; 21549eefe2a2SStefan Roese 2155ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2156ff94bc40SHeiko Schocher /* First, try to open using the device node path method */ 2157ff94bc40SHeiko Schocher ubi = ubi_open_volume_path(name, mode); 2158ff94bc40SHeiko Schocher if (!IS_ERR(ubi)) 2159ff94bc40SHeiko Schocher return ubi; 2160ff94bc40SHeiko Schocher #endif 2161ff94bc40SHeiko Schocher 2162ff94bc40SHeiko Schocher /* Try the "nodev" method */ 21639eefe2a2SStefan Roese if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i') 21649eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 21659eefe2a2SStefan Roese 21669eefe2a2SStefan Roese /* ubi:NAME method */ 21679eefe2a2SStefan Roese if ((name[3] == ':' || name[3] == '!') && name[4] != '\0') 21689eefe2a2SStefan Roese return ubi_open_volume_nm(0, name + 4, mode); 21699eefe2a2SStefan Roese 21709eefe2a2SStefan Roese if (!isdigit(name[3])) 21719eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 21729eefe2a2SStefan Roese 21739eefe2a2SStefan Roese dev = simple_strtoul(name + 3, &endptr, 0); 21749eefe2a2SStefan Roese 21759eefe2a2SStefan Roese /* ubiY method */ 21769eefe2a2SStefan Roese if (*endptr == '\0') 21779eefe2a2SStefan Roese return ubi_open_volume(0, dev, mode); 21789eefe2a2SStefan Roese 21799eefe2a2SStefan Roese /* ubiX_Y method */ 21809eefe2a2SStefan Roese if (*endptr == '_' && isdigit(endptr[1])) { 21819eefe2a2SStefan Roese vol = simple_strtoul(endptr + 1, &endptr, 0); 21829eefe2a2SStefan Roese if (*endptr != '\0') 21839eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 21849eefe2a2SStefan Roese return ubi_open_volume(dev, vol, mode); 21859eefe2a2SStefan Roese } 21869eefe2a2SStefan Roese 21879eefe2a2SStefan Roese /* ubiX:NAME method */ 21889eefe2a2SStefan Roese if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0') 21899eefe2a2SStefan Roese return ubi_open_volume_nm(dev, ++endptr, mode); 21909eefe2a2SStefan Roese 21919eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 21929eefe2a2SStefan Roese } 21939eefe2a2SStefan Roese 2194ff94bc40SHeiko Schocher static struct ubifs_info *alloc_ubifs_info(struct ubi_volume_desc *ubi) 21959eefe2a2SStefan Roese { 21969eefe2a2SStefan Roese struct ubifs_info *c; 21979eefe2a2SStefan Roese 21989eefe2a2SStefan Roese c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL); 2199ff94bc40SHeiko Schocher if (c) { 22009eefe2a2SStefan Roese spin_lock_init(&c->cnt_lock); 22019eefe2a2SStefan Roese spin_lock_init(&c->cs_lock); 22029eefe2a2SStefan Roese spin_lock_init(&c->buds_lock); 22039eefe2a2SStefan Roese spin_lock_init(&c->space_lock); 22049eefe2a2SStefan Roese spin_lock_init(&c->orphan_lock); 22059eefe2a2SStefan Roese init_rwsem(&c->commit_sem); 22069eefe2a2SStefan Roese mutex_init(&c->lp_mutex); 22079eefe2a2SStefan Roese mutex_init(&c->tnc_mutex); 22089eefe2a2SStefan Roese mutex_init(&c->log_mutex); 22099eefe2a2SStefan Roese mutex_init(&c->umount_mutex); 2210ff94bc40SHeiko Schocher mutex_init(&c->bu_mutex); 2211ff94bc40SHeiko Schocher mutex_init(&c->write_reserve_mutex); 22129eefe2a2SStefan Roese init_waitqueue_head(&c->cmt_wq); 22139eefe2a2SStefan Roese c->buds = RB_ROOT; 22149eefe2a2SStefan Roese c->old_idx = RB_ROOT; 22159eefe2a2SStefan Roese c->size_tree = RB_ROOT; 22169eefe2a2SStefan Roese c->orph_tree = RB_ROOT; 22179eefe2a2SStefan Roese INIT_LIST_HEAD(&c->infos_list); 22189eefe2a2SStefan Roese INIT_LIST_HEAD(&c->idx_gc); 22199eefe2a2SStefan Roese INIT_LIST_HEAD(&c->replay_list); 22209eefe2a2SStefan Roese INIT_LIST_HEAD(&c->replay_buds); 22219eefe2a2SStefan Roese INIT_LIST_HEAD(&c->uncat_list); 22229eefe2a2SStefan Roese INIT_LIST_HEAD(&c->empty_list); 22239eefe2a2SStefan Roese INIT_LIST_HEAD(&c->freeable_list); 22249eefe2a2SStefan Roese INIT_LIST_HEAD(&c->frdi_idx_list); 22259eefe2a2SStefan Roese INIT_LIST_HEAD(&c->unclean_leb_list); 22269eefe2a2SStefan Roese INIT_LIST_HEAD(&c->old_buds); 22279eefe2a2SStefan Roese INIT_LIST_HEAD(&c->orph_list); 22289eefe2a2SStefan Roese INIT_LIST_HEAD(&c->orph_new); 2229ff94bc40SHeiko Schocher c->no_chk_data_crc = 1; 22309eefe2a2SStefan Roese 22319eefe2a2SStefan Roese c->highest_inum = UBIFS_FIRST_INO; 22329eefe2a2SStefan Roese c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM; 22339eefe2a2SStefan Roese 22349eefe2a2SStefan Roese ubi_get_volume_info(ubi, &c->vi); 22359eefe2a2SStefan Roese ubi_get_device_info(c->vi.ubi_num, &c->di); 2236ff94bc40SHeiko Schocher } 2237ff94bc40SHeiko Schocher return c; 22389eefe2a2SStefan Roese } 22399eefe2a2SStefan Roese 2240ff94bc40SHeiko Schocher static int ubifs_fill_super(struct super_block *sb, void *data, int silent) 2241ff94bc40SHeiko Schocher { 2242ff94bc40SHeiko Schocher struct ubifs_info *c = sb->s_fs_info; 2243ff94bc40SHeiko Schocher struct inode *root; 2244ff94bc40SHeiko Schocher int err; 22459eefe2a2SStefan Roese 2246ff94bc40SHeiko Schocher c->vfs_sb = sb; 2247ddf7bcfaSHeiko Schocher #ifndef __UBOOT__ 2248ff94bc40SHeiko Schocher /* Re-open the UBI device in read-write mode */ 2249ff94bc40SHeiko Schocher c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READWRITE); 2250ddf7bcfaSHeiko Schocher #else 2251ddf7bcfaSHeiko Schocher /* U-Boot read only mode */ 2252ddf7bcfaSHeiko Schocher c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY); 2253ddf7bcfaSHeiko Schocher #endif 2254ddf7bcfaSHeiko Schocher 2255ff94bc40SHeiko Schocher if (IS_ERR(c->ubi)) { 2256ff94bc40SHeiko Schocher err = PTR_ERR(c->ubi); 2257ff94bc40SHeiko Schocher goto out; 2258ff94bc40SHeiko Schocher } 2259ff94bc40SHeiko Schocher 2260ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2261ff94bc40SHeiko Schocher /* 2262ff94bc40SHeiko Schocher * UBIFS provides 'backing_dev_info' in order to disable read-ahead. For 2263ff94bc40SHeiko Schocher * UBIFS, I/O is not deferred, it is done immediately in readpage, 2264ff94bc40SHeiko Schocher * which means the user would have to wait not just for their own I/O 2265ff94bc40SHeiko Schocher * but the read-ahead I/O as well i.e. completely pointless. 2266ff94bc40SHeiko Schocher * 2267ff94bc40SHeiko Schocher * Read-ahead will be disabled because @c->bdi.ra_pages is 0. 2268ff94bc40SHeiko Schocher */ 22690195a7bbSHeiko Schocher c->bdi.name = "ubifs", 22700195a7bbSHeiko Schocher c->bdi.capabilities = 0; 2271ff94bc40SHeiko Schocher err = bdi_init(&c->bdi); 2272ff94bc40SHeiko Schocher if (err) 2273ff94bc40SHeiko Schocher goto out_close; 2274ff94bc40SHeiko Schocher err = bdi_register(&c->bdi, NULL, "ubifs_%d_%d", 2275ff94bc40SHeiko Schocher c->vi.ubi_num, c->vi.vol_id); 2276ff94bc40SHeiko Schocher if (err) 2277ff94bc40SHeiko Schocher goto out_bdi; 2278ff94bc40SHeiko Schocher 2279ff94bc40SHeiko Schocher err = ubifs_parse_options(c, data, 0); 2280ff94bc40SHeiko Schocher if (err) 2281ff94bc40SHeiko Schocher goto out_bdi; 2282ff94bc40SHeiko Schocher 2283ff94bc40SHeiko Schocher sb->s_bdi = &c->bdi; 2284ff94bc40SHeiko Schocher #endif 22859eefe2a2SStefan Roese sb->s_fs_info = c; 22869eefe2a2SStefan Roese sb->s_magic = UBIFS_SUPER_MAGIC; 22879eefe2a2SStefan Roese sb->s_blocksize = UBIFS_BLOCK_SIZE; 22889eefe2a2SStefan Roese sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT; 22899eefe2a2SStefan Roese sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c); 22909eefe2a2SStefan Roese if (c->max_inode_sz > MAX_LFS_FILESIZE) 22919eefe2a2SStefan Roese sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE; 2292ff94bc40SHeiko Schocher sb->s_op = &ubifs_super_operations; 22930195a7bbSHeiko Schocher #ifndef __UBOOT__ 22940195a7bbSHeiko Schocher sb->s_xattr = ubifs_xattr_handlers; 22950195a7bbSHeiko Schocher #endif 2296febd7e41SArtem Bityutskiy 22979eefe2a2SStefan Roese mutex_lock(&c->umount_mutex); 22989eefe2a2SStefan Roese err = mount_ubifs(c); 22999eefe2a2SStefan Roese if (err) { 23009eefe2a2SStefan Roese ubifs_assert(err < 0); 23019eefe2a2SStefan Roese goto out_unlock; 23029eefe2a2SStefan Roese } 23039eefe2a2SStefan Roese 23049eefe2a2SStefan Roese /* Read the root inode */ 23059eefe2a2SStefan Roese root = ubifs_iget(sb, UBIFS_ROOT_INO); 23069eefe2a2SStefan Roese if (IS_ERR(root)) { 23079eefe2a2SStefan Roese err = PTR_ERR(root); 23089eefe2a2SStefan Roese goto out_umount; 23099eefe2a2SStefan Roese } 23109eefe2a2SStefan Roese 2311ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2312ff94bc40SHeiko Schocher sb->s_root = d_make_root(root); 2313ff94bc40SHeiko Schocher if (!sb->s_root) { 2314ff94bc40SHeiko Schocher err = -ENOMEM; 2315ff94bc40SHeiko Schocher goto out_umount; 2316ff94bc40SHeiko Schocher } 2317ff94bc40SHeiko Schocher #else 23189eefe2a2SStefan Roese sb->s_root = NULL; 2319ff94bc40SHeiko Schocher #endif 23209eefe2a2SStefan Roese 23219eefe2a2SStefan Roese mutex_unlock(&c->umount_mutex); 23229eefe2a2SStefan Roese return 0; 23239eefe2a2SStefan Roese 23249eefe2a2SStefan Roese out_umount: 23259eefe2a2SStefan Roese ubifs_umount(c); 23269eefe2a2SStefan Roese out_unlock: 23279eefe2a2SStefan Roese mutex_unlock(&c->umount_mutex); 2328ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2329ff94bc40SHeiko Schocher out_bdi: 2330ff94bc40SHeiko Schocher bdi_destroy(&c->bdi); 2331ff94bc40SHeiko Schocher out_close: 2332ff94bc40SHeiko Schocher #endif 23339eefe2a2SStefan Roese ubi_close_volume(c->ubi); 2334ff94bc40SHeiko Schocher out: 23359eefe2a2SStefan Roese return err; 23369eefe2a2SStefan Roese } 23379eefe2a2SStefan Roese 23389eefe2a2SStefan Roese static int sb_test(struct super_block *sb, void *data) 23399eefe2a2SStefan Roese { 2340ff94bc40SHeiko Schocher struct ubifs_info *c1 = data; 2341ff94bc40SHeiko Schocher struct ubifs_info *c = sb->s_fs_info; 23429eefe2a2SStefan Roese 2343ff94bc40SHeiko Schocher return c->vi.cdev == c1->vi.cdev; 23449eefe2a2SStefan Roese } 23459eefe2a2SStefan Roese 2346ff94bc40SHeiko Schocher static int sb_set(struct super_block *sb, void *data) 2347ff94bc40SHeiko Schocher { 2348ff94bc40SHeiko Schocher sb->s_fs_info = data; 2349ff94bc40SHeiko Schocher return set_anon_super(sb, NULL); 2350ff94bc40SHeiko Schocher } 2351ff94bc40SHeiko Schocher 2352ff94bc40SHeiko Schocher static struct super_block *alloc_super(struct file_system_type *type, int flags) 2353ff94bc40SHeiko Schocher { 2354ff94bc40SHeiko Schocher struct super_block *s; 2355ff94bc40SHeiko Schocher int err; 2356ff94bc40SHeiko Schocher 2357ff94bc40SHeiko Schocher s = kzalloc(sizeof(struct super_block), GFP_USER); 2358ff94bc40SHeiko Schocher if (!s) { 2359ff94bc40SHeiko Schocher err = -ENOMEM; 2360ff94bc40SHeiko Schocher return ERR_PTR(err); 2361ff94bc40SHeiko Schocher } 2362ff94bc40SHeiko Schocher 2363ff94bc40SHeiko Schocher INIT_HLIST_NODE(&s->s_instances); 2364ff94bc40SHeiko Schocher INIT_LIST_HEAD(&s->s_inodes); 2365ff94bc40SHeiko Schocher s->s_time_gran = 1000000000; 2366ff94bc40SHeiko Schocher s->s_flags = flags; 2367ff94bc40SHeiko Schocher 2368ff94bc40SHeiko Schocher return s; 2369ff94bc40SHeiko Schocher } 2370ff94bc40SHeiko Schocher 2371ff94bc40SHeiko Schocher /** 2372ff94bc40SHeiko Schocher * sget - find or create a superblock 2373ff94bc40SHeiko Schocher * @type: filesystem type superblock should belong to 2374ff94bc40SHeiko Schocher * @test: comparison callback 2375ff94bc40SHeiko Schocher * @set: setup callback 2376ff94bc40SHeiko Schocher * @flags: mount flags 2377ff94bc40SHeiko Schocher * @data: argument to each of them 2378ff94bc40SHeiko Schocher */ 2379ff94bc40SHeiko Schocher struct super_block *sget(struct file_system_type *type, 2380ff94bc40SHeiko Schocher int (*test)(struct super_block *,void *), 2381ff94bc40SHeiko Schocher int (*set)(struct super_block *,void *), 2382ff94bc40SHeiko Schocher int flags, 2383ff94bc40SHeiko Schocher void *data) 2384ff94bc40SHeiko Schocher { 2385ff94bc40SHeiko Schocher struct super_block *s = NULL; 2386ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2387ff94bc40SHeiko Schocher struct super_block *old; 2388ff94bc40SHeiko Schocher #endif 2389ff94bc40SHeiko Schocher int err; 2390ff94bc40SHeiko Schocher 2391ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2392ff94bc40SHeiko Schocher retry: 2393ff94bc40SHeiko Schocher spin_lock(&sb_lock); 2394ff94bc40SHeiko Schocher if (test) { 2395ff94bc40SHeiko Schocher hlist_for_each_entry(old, &type->fs_supers, s_instances) { 2396ff94bc40SHeiko Schocher if (!test(old, data)) 2397ff94bc40SHeiko Schocher continue; 2398ff94bc40SHeiko Schocher if (!grab_super(old)) 2399ff94bc40SHeiko Schocher goto retry; 2400ff94bc40SHeiko Schocher if (s) { 2401ff94bc40SHeiko Schocher up_write(&s->s_umount); 2402ff94bc40SHeiko Schocher destroy_super(s); 2403ff94bc40SHeiko Schocher s = NULL; 2404ff94bc40SHeiko Schocher } 2405ff94bc40SHeiko Schocher return old; 2406ff94bc40SHeiko Schocher } 2407ff94bc40SHeiko Schocher } 2408ff94bc40SHeiko Schocher #endif 2409ff94bc40SHeiko Schocher if (!s) { 2410ff94bc40SHeiko Schocher spin_unlock(&sb_lock); 2411ff94bc40SHeiko Schocher s = alloc_super(type, flags); 2412ff94bc40SHeiko Schocher if (!s) 2413ff94bc40SHeiko Schocher return ERR_PTR(-ENOMEM); 2414ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2415ff94bc40SHeiko Schocher goto retry; 2416ff94bc40SHeiko Schocher #endif 2417ff94bc40SHeiko Schocher } 2418ff94bc40SHeiko Schocher 2419ff94bc40SHeiko Schocher err = set(s, data); 2420ff94bc40SHeiko Schocher if (err) { 2421ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2422ff94bc40SHeiko Schocher spin_unlock(&sb_lock); 2423ff94bc40SHeiko Schocher up_write(&s->s_umount); 2424ff94bc40SHeiko Schocher destroy_super(s); 2425ff94bc40SHeiko Schocher #endif 2426ff94bc40SHeiko Schocher return ERR_PTR(err); 2427ff94bc40SHeiko Schocher } 2428ff94bc40SHeiko Schocher s->s_type = type; 2429ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2430ff94bc40SHeiko Schocher strlcpy(s->s_id, type->name, sizeof(s->s_id)); 2431b1d6590dSHeiko Schocher list_add_tail(&s->s_list, &super_blocks); 2432ff94bc40SHeiko Schocher #else 2433ff94bc40SHeiko Schocher strncpy(s->s_id, type->name, sizeof(s->s_id)); 2434ff94bc40SHeiko Schocher #endif 2435ff94bc40SHeiko Schocher hlist_add_head(&s->s_instances, &type->fs_supers); 2436ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2437ff94bc40SHeiko Schocher spin_unlock(&sb_lock); 2438ff94bc40SHeiko Schocher get_filesystem(type); 2439ff94bc40SHeiko Schocher register_shrinker(&s->s_shrink); 2440ff94bc40SHeiko Schocher #endif 2441ff94bc40SHeiko Schocher return s; 2442ff94bc40SHeiko Schocher } 2443ff94bc40SHeiko Schocher 2444ff94bc40SHeiko Schocher EXPORT_SYMBOL(sget); 2445ff94bc40SHeiko Schocher 2446ff94bc40SHeiko Schocher 2447ff94bc40SHeiko Schocher static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags, 2448ff94bc40SHeiko Schocher const char *name, void *data) 24499eefe2a2SStefan Roese { 24509eefe2a2SStefan Roese struct ubi_volume_desc *ubi; 2451ff94bc40SHeiko Schocher struct ubifs_info *c; 24529eefe2a2SStefan Roese struct super_block *sb; 24539eefe2a2SStefan Roese int err; 24549eefe2a2SStefan Roese 24559eefe2a2SStefan Roese dbg_gen("name %s, flags %#x", name, flags); 24569eefe2a2SStefan Roese 24579eefe2a2SStefan Roese /* 24589eefe2a2SStefan Roese * Get UBI device number and volume ID. Mount it read-only so far 24599eefe2a2SStefan Roese * because this might be a new mount point, and UBI allows only one 24609eefe2a2SStefan Roese * read-write user at a time. 24619eefe2a2SStefan Roese */ 24629eefe2a2SStefan Roese ubi = open_ubi(name, UBI_READONLY); 24639eefe2a2SStefan Roese if (IS_ERR(ubi)) { 24640195a7bbSHeiko Schocher pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d", 24650195a7bbSHeiko Schocher current->pid, name, (int)PTR_ERR(ubi)); 2466ff94bc40SHeiko Schocher return ERR_CAST(ubi); 24679eefe2a2SStefan Roese } 24689eefe2a2SStefan Roese 2469ff94bc40SHeiko Schocher c = alloc_ubifs_info(ubi); 2470ff94bc40SHeiko Schocher if (!c) { 2471ff94bc40SHeiko Schocher err = -ENOMEM; 2472ff94bc40SHeiko Schocher goto out_close; 2473ff94bc40SHeiko Schocher } 24749eefe2a2SStefan Roese 2475ff94bc40SHeiko Schocher dbg_gen("opened ubi%d_%d", c->vi.ubi_num, c->vi.vol_id); 2476ff94bc40SHeiko Schocher 2477ff94bc40SHeiko Schocher sb = sget(fs_type, sb_test, sb_set, flags, c); 24789eefe2a2SStefan Roese if (IS_ERR(sb)) { 24799eefe2a2SStefan Roese err = PTR_ERR(sb); 2480ff94bc40SHeiko Schocher kfree(c); 24819eefe2a2SStefan Roese goto out_close; 24829eefe2a2SStefan Roese } 24839eefe2a2SStefan Roese 24849eefe2a2SStefan Roese if (sb->s_root) { 2485ff94bc40SHeiko Schocher struct ubifs_info *c1 = sb->s_fs_info; 2486ff94bc40SHeiko Schocher kfree(c); 24879eefe2a2SStefan Roese /* A new mount point for already mounted UBIFS */ 24889eefe2a2SStefan Roese dbg_gen("this ubi volume is already mounted"); 2489ff94bc40SHeiko Schocher if (!!(flags & MS_RDONLY) != c1->ro_mount) { 24909eefe2a2SStefan Roese err = -EBUSY; 24919eefe2a2SStefan Roese goto out_deact; 24929eefe2a2SStefan Roese } 24939eefe2a2SStefan Roese } else { 24949eefe2a2SStefan Roese err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 24959eefe2a2SStefan Roese if (err) 24969eefe2a2SStefan Roese goto out_deact; 24979eefe2a2SStefan Roese /* We do not support atime */ 24989eefe2a2SStefan Roese sb->s_flags |= MS_ACTIVE | MS_NOATIME; 24999eefe2a2SStefan Roese } 25009eefe2a2SStefan Roese 25019eefe2a2SStefan Roese /* 'fill_super()' opens ubi again so we must close it here */ 25029eefe2a2SStefan Roese ubi_close_volume(ubi); 25039eefe2a2SStefan Roese 2504ff94bc40SHeiko Schocher #ifdef __UBOOT__ 25059eefe2a2SStefan Roese ubifs_sb = sb; 25069eefe2a2SStefan Roese return 0; 2507ff94bc40SHeiko Schocher #else 2508ff94bc40SHeiko Schocher return dget(sb->s_root); 2509ff94bc40SHeiko Schocher #endif 25109eefe2a2SStefan Roese 25119eefe2a2SStefan Roese out_deact: 2512ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2513ff94bc40SHeiko Schocher deactivate_locked_super(sb); 2514ff94bc40SHeiko Schocher #endif 25159eefe2a2SStefan Roese out_close: 25169eefe2a2SStefan Roese ubi_close_volume(ubi); 2517ff94bc40SHeiko Schocher return ERR_PTR(err); 25189eefe2a2SStefan Roese } 25199eefe2a2SStefan Roese 2520ff94bc40SHeiko Schocher static void kill_ubifs_super(struct super_block *s) 2521ff94bc40SHeiko Schocher { 2522ff94bc40SHeiko Schocher struct ubifs_info *c = s->s_fs_info; 2523ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2524ff94bc40SHeiko Schocher kill_anon_super(s); 2525ff94bc40SHeiko Schocher #endif 2526ff94bc40SHeiko Schocher kfree(c); 2527ff94bc40SHeiko Schocher } 2528ff94bc40SHeiko Schocher 2529ff94bc40SHeiko Schocher static struct file_system_type ubifs_fs_type = { 2530ff94bc40SHeiko Schocher .name = "ubifs", 2531ff94bc40SHeiko Schocher .owner = THIS_MODULE, 2532ff94bc40SHeiko Schocher .mount = ubifs_mount, 2533ff94bc40SHeiko Schocher .kill_sb = kill_ubifs_super, 2534ff94bc40SHeiko Schocher }; 2535ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2536ff94bc40SHeiko Schocher MODULE_ALIAS_FS("ubifs"); 2537ff94bc40SHeiko Schocher 2538ff94bc40SHeiko Schocher /* 2539ff94bc40SHeiko Schocher * Inode slab cache constructor. 2540ff94bc40SHeiko Schocher */ 2541ff94bc40SHeiko Schocher static void inode_slab_ctor(void *obj) 2542ff94bc40SHeiko Schocher { 2543ff94bc40SHeiko Schocher struct ubifs_inode *ui = obj; 2544ff94bc40SHeiko Schocher inode_init_once(&ui->vfs_inode); 2545ff94bc40SHeiko Schocher } 2546ff94bc40SHeiko Schocher 2547ff94bc40SHeiko Schocher static int __init ubifs_init(void) 2548ff94bc40SHeiko Schocher #else 2549ff94bc40SHeiko Schocher int ubifs_init(void) 2550ff94bc40SHeiko Schocher #endif 25519eefe2a2SStefan Roese { 25529eefe2a2SStefan Roese int err; 25539eefe2a2SStefan Roese 25549eefe2a2SStefan Roese BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24); 25559eefe2a2SStefan Roese 25569eefe2a2SStefan Roese /* Make sure node sizes are 8-byte aligned */ 25579eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_CH_SZ & 7); 25589eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ & 7); 25599eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7); 25609eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7); 25619eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7); 25629eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7); 25639eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_SB_NODE_SZ & 7); 25649eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MST_NODE_SZ & 7); 25659eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_REF_NODE_SZ & 7); 25669eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_CS_NODE_SZ & 7); 25679eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7); 25689eefe2a2SStefan Roese 25699eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7); 25709eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7); 25719eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7); 25729eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ & 7); 25739eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_NODE_SZ & 7); 25749eefe2a2SStefan Roese BUILD_BUG_ON(MIN_WRITE_SZ & 7); 25759eefe2a2SStefan Roese 25769eefe2a2SStefan Roese /* Check min. node size */ 25779eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ < MIN_WRITE_SZ); 25789eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ); 25799eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ); 25809eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ); 25819eefe2a2SStefan Roese 25829eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 25839eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 25849eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ); 25859eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ > UBIFS_MAX_NODE_SZ); 25869eefe2a2SStefan Roese 25879eefe2a2SStefan Roese /* Defined node sizes */ 25889eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_SB_NODE_SZ != 4096); 25899eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512); 25909eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160); 25919eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64); 25929eefe2a2SStefan Roese 25939eefe2a2SStefan Roese /* 25949eefe2a2SStefan Roese * We use 2 bit wide bit-fields to store compression type, which should 25959eefe2a2SStefan Roese * be amended if more compressors are added. The bit-fields are: 25969eefe2a2SStefan Roese * @compr_type in 'struct ubifs_inode', @default_compr in 25979eefe2a2SStefan Roese * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'. 25989eefe2a2SStefan Roese */ 25999eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4); 26009eefe2a2SStefan Roese 26019eefe2a2SStefan Roese /* 26029eefe2a2SStefan Roese * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to 26039eefe2a2SStefan Roese * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2. 26049eefe2a2SStefan Roese */ 26059eefe2a2SStefan Roese if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) { 26060195a7bbSHeiko Schocher pr_err("UBIFS error (pid %d): VFS page cache size is %u bytes, but UBIFS requires at least 4096 bytes", 26070195a7bbSHeiko Schocher current->pid, (unsigned int)PAGE_CACHE_SIZE); 26089eefe2a2SStefan Roese return -EINVAL; 26099eefe2a2SStefan Roese } 26109eefe2a2SStefan Roese 2611ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2612ff94bc40SHeiko Schocher ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab", 2613ff94bc40SHeiko Schocher sizeof(struct ubifs_inode), 0, 2614ff94bc40SHeiko Schocher SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT, 2615ff94bc40SHeiko Schocher &inode_slab_ctor); 2616ff94bc40SHeiko Schocher if (!ubifs_inode_slab) 2617ff94bc40SHeiko Schocher return -ENOMEM; 2618ff94bc40SHeiko Schocher 26190195a7bbSHeiko Schocher err = register_shrinker(&ubifs_shrinker_info); 26200195a7bbSHeiko Schocher if (err) 26210195a7bbSHeiko Schocher goto out_slab; 2622ff94bc40SHeiko Schocher #endif 26239eefe2a2SStefan Roese 26249eefe2a2SStefan Roese err = ubifs_compressors_init(); 26259eefe2a2SStefan Roese if (err) 26269eefe2a2SStefan Roese goto out_shrinker; 26279eefe2a2SStefan Roese 2628ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2629ff94bc40SHeiko Schocher err = dbg_debugfs_init(); 2630ff94bc40SHeiko Schocher if (err) 2631ff94bc40SHeiko Schocher goto out_compr; 2632ff94bc40SHeiko Schocher 2633ff94bc40SHeiko Schocher err = register_filesystem(&ubifs_fs_type); 2634ff94bc40SHeiko Schocher if (err) { 26350195a7bbSHeiko Schocher pr_err("UBIFS error (pid %d): cannot register file system, error %d", 26360195a7bbSHeiko Schocher current->pid, err); 2637ff94bc40SHeiko Schocher goto out_dbg; 2638ff94bc40SHeiko Schocher } 2639ff94bc40SHeiko Schocher #endif 26409eefe2a2SStefan Roese return 0; 26419eefe2a2SStefan Roese 2642ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2643ff94bc40SHeiko Schocher out_dbg: 2644ff94bc40SHeiko Schocher dbg_debugfs_exit(); 2645ff94bc40SHeiko Schocher out_compr: 2646ff94bc40SHeiko Schocher ubifs_compressors_exit(); 2647ff94bc40SHeiko Schocher #endif 26489eefe2a2SStefan Roese out_shrinker: 2649ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2650ff94bc40SHeiko Schocher unregister_shrinker(&ubifs_shrinker_info); 26510195a7bbSHeiko Schocher out_slab: 2652ff94bc40SHeiko Schocher #endif 2653ff94bc40SHeiko Schocher kmem_cache_destroy(ubifs_inode_slab); 26549eefe2a2SStefan Roese return err; 26559eefe2a2SStefan Roese } 2656ff94bc40SHeiko Schocher /* late_initcall to let compressors initialize first */ 2657ff94bc40SHeiko Schocher late_initcall(ubifs_init); 2658ff94bc40SHeiko Schocher 2659ff94bc40SHeiko Schocher #ifndef __UBOOT__ 2660ff94bc40SHeiko Schocher static void __exit ubifs_exit(void) 2661ff94bc40SHeiko Schocher { 2662ff94bc40SHeiko Schocher ubifs_assert(list_empty(&ubifs_infos)); 2663ff94bc40SHeiko Schocher ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0); 2664ff94bc40SHeiko Schocher 2665ff94bc40SHeiko Schocher dbg_debugfs_exit(); 2666ff94bc40SHeiko Schocher ubifs_compressors_exit(); 2667ff94bc40SHeiko Schocher unregister_shrinker(&ubifs_shrinker_info); 26689eefe2a2SStefan Roese 26699eefe2a2SStefan Roese /* 2670ff94bc40SHeiko Schocher * Make sure all delayed rcu free inodes are flushed before we 2671ff94bc40SHeiko Schocher * destroy cache. 26729eefe2a2SStefan Roese */ 2673ff94bc40SHeiko Schocher rcu_barrier(); 2674ff94bc40SHeiko Schocher kmem_cache_destroy(ubifs_inode_slab); 2675ff94bc40SHeiko Schocher unregister_filesystem(&ubifs_fs_type); 2676ff94bc40SHeiko Schocher } 2677ff94bc40SHeiko Schocher module_exit(ubifs_exit); 26789eefe2a2SStefan Roese 2679ff94bc40SHeiko Schocher MODULE_LICENSE("GPL"); 2680ff94bc40SHeiko Schocher MODULE_VERSION(__stringify(UBIFS_VERSION)); 2681ff94bc40SHeiko Schocher MODULE_AUTHOR("Artem Bityutskiy, Adrian Hunter"); 2682ff94bc40SHeiko Schocher MODULE_DESCRIPTION("UBIFS - UBI File System"); 2683ff94bc40SHeiko Schocher #else 2684ff94bc40SHeiko Schocher int uboot_ubifs_mount(char *vol_name) 26859eefe2a2SStefan Roese { 2686ff94bc40SHeiko Schocher struct dentry *ret; 26879eefe2a2SStefan Roese int flags; 26889eefe2a2SStefan Roese 26899eefe2a2SStefan Roese /* 26909eefe2a2SStefan Roese * First unmount if allready mounted 26919eefe2a2SStefan Roese */ 26929eefe2a2SStefan Roese if (ubifs_sb) 26939eefe2a2SStefan Roese ubifs_umount(ubifs_sb->s_fs_info); 26949eefe2a2SStefan Roese 26959eefe2a2SStefan Roese /* 26969eefe2a2SStefan Roese * Mount in read-only mode 26979eefe2a2SStefan Roese */ 26989eefe2a2SStefan Roese flags = MS_RDONLY; 2699ff94bc40SHeiko Schocher ret = ubifs_mount(&ubifs_fs_type, flags, vol_name, NULL); 2700ff94bc40SHeiko Schocher if (IS_ERR(ret)) { 2701ff94bc40SHeiko Schocher printf("Error reading superblock on volume '%s' " \ 2702ff94bc40SHeiko Schocher "errno=%d!\n", vol_name, (int)PTR_ERR(ret)); 27039eefe2a2SStefan Roese return -1; 27049eefe2a2SStefan Roese } 27059eefe2a2SStefan Roese 27069eefe2a2SStefan Roese return 0; 27079eefe2a2SStefan Roese } 2708ff94bc40SHeiko Schocher #endif 2709