19eefe2a2SStefan Roese /* 29eefe2a2SStefan Roese * This file is part of UBIFS. 39eefe2a2SStefan Roese * 49eefe2a2SStefan Roese * Copyright (C) 2006-2008 Nokia Corporation. 59eefe2a2SStefan Roese * 69eefe2a2SStefan Roese * This program is free software; you can redistribute it and/or modify it 79eefe2a2SStefan Roese * under the terms of the GNU General Public License version 2 as published by 89eefe2a2SStefan Roese * the Free Software Foundation. 99eefe2a2SStefan Roese * 109eefe2a2SStefan Roese * This program is distributed in the hope that it will be useful, but WITHOUT 119eefe2a2SStefan Roese * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 129eefe2a2SStefan Roese * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 139eefe2a2SStefan Roese * more details. 149eefe2a2SStefan Roese * 159eefe2a2SStefan Roese * You should have received a copy of the GNU General Public License along with 169eefe2a2SStefan Roese * this program; if not, write to the Free Software Foundation, Inc., 51 179eefe2a2SStefan Roese * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 189eefe2a2SStefan Roese * 199eefe2a2SStefan Roese * Authors: Artem Bityutskiy (Битюцкий Артём) 209eefe2a2SStefan Roese * Adrian Hunter 219eefe2a2SStefan Roese */ 229eefe2a2SStefan Roese 239eefe2a2SStefan Roese /* 249eefe2a2SStefan Roese * This file implements UBIFS initialization and VFS superblock operations. Some 259eefe2a2SStefan Roese * initialization stuff which is rather large and complex is placed at 269eefe2a2SStefan Roese * corresponding subsystems, but most of it is here. 279eefe2a2SStefan Roese */ 289eefe2a2SStefan Roese 299eefe2a2SStefan Roese #include "ubifs.h" 309eefe2a2SStefan Roese #include <linux/math64.h> 319eefe2a2SStefan Roese 329eefe2a2SStefan Roese #define INODE_LOCKED_MAX 64 339eefe2a2SStefan Roese 349eefe2a2SStefan Roese struct super_block *ubifs_sb; 359eefe2a2SStefan Roese static struct inode *inodes_locked_down[INODE_LOCKED_MAX]; 369eefe2a2SStefan Roese 379eefe2a2SStefan Roese /* shrinker.c */ 389eefe2a2SStefan Roese 399eefe2a2SStefan Roese /* List of all UBIFS file-system instances */ 409eefe2a2SStefan Roese struct list_head ubifs_infos; 419eefe2a2SStefan Roese 429eefe2a2SStefan Roese /* linux/fs/super.c */ 439eefe2a2SStefan Roese 449eefe2a2SStefan Roese static int sb_set(struct super_block *sb, void *data) 459eefe2a2SStefan Roese { 469eefe2a2SStefan Roese dev_t *dev = data; 479eefe2a2SStefan Roese 489eefe2a2SStefan Roese sb->s_dev = *dev; 499eefe2a2SStefan Roese return 0; 509eefe2a2SStefan Roese } 519eefe2a2SStefan Roese 529eefe2a2SStefan Roese /** 539eefe2a2SStefan Roese * sget - find or create a superblock 549eefe2a2SStefan Roese * @type: filesystem type superblock should belong to 559eefe2a2SStefan Roese * @test: comparison callback 569eefe2a2SStefan Roese * @set: setup callback 579eefe2a2SStefan Roese * @data: argument to each of them 589eefe2a2SStefan Roese */ 599eefe2a2SStefan Roese struct super_block *sget(struct file_system_type *type, 609eefe2a2SStefan Roese int (*test)(struct super_block *,void *), 619eefe2a2SStefan Roese int (*set)(struct super_block *,void *), 629eefe2a2SStefan Roese void *data) 639eefe2a2SStefan Roese { 649eefe2a2SStefan Roese struct super_block *s = NULL; 659eefe2a2SStefan Roese int err; 669eefe2a2SStefan Roese 679eefe2a2SStefan Roese s = kzalloc(sizeof(struct super_block), GFP_USER); 689eefe2a2SStefan Roese if (!s) { 699eefe2a2SStefan Roese err = -ENOMEM; 709eefe2a2SStefan Roese return ERR_PTR(err); 719eefe2a2SStefan Roese } 729eefe2a2SStefan Roese 739eefe2a2SStefan Roese INIT_LIST_HEAD(&s->s_instances); 749eefe2a2SStefan Roese INIT_LIST_HEAD(&s->s_inodes); 759eefe2a2SStefan Roese s->s_time_gran = 1000000000; 769eefe2a2SStefan Roese 779eefe2a2SStefan Roese err = set(s, data); 789eefe2a2SStefan Roese if (err) { 799eefe2a2SStefan Roese return ERR_PTR(err); 809eefe2a2SStefan Roese } 819eefe2a2SStefan Roese s->s_type = type; 829eefe2a2SStefan Roese strncpy(s->s_id, type->name, sizeof(s->s_id)); 839eefe2a2SStefan Roese list_add(&s->s_instances, &type->fs_supers); 849eefe2a2SStefan Roese return s; 859eefe2a2SStefan Roese } 869eefe2a2SStefan Roese 879eefe2a2SStefan Roese /** 889eefe2a2SStefan Roese * validate_inode - validate inode. 899eefe2a2SStefan Roese * @c: UBIFS file-system description object 909eefe2a2SStefan Roese * @inode: the inode to validate 919eefe2a2SStefan Roese * 929eefe2a2SStefan Roese * This is a helper function for 'ubifs_iget()' which validates various fields 939eefe2a2SStefan Roese * of a newly built inode to make sure they contain sane values and prevent 949eefe2a2SStefan Roese * possible vulnerabilities. Returns zero if the inode is all right and 959eefe2a2SStefan Roese * a non-zero error code if not. 969eefe2a2SStefan Roese */ 979eefe2a2SStefan Roese static int validate_inode(struct ubifs_info *c, const struct inode *inode) 989eefe2a2SStefan Roese { 999eefe2a2SStefan Roese int err; 1009eefe2a2SStefan Roese const struct ubifs_inode *ui = ubifs_inode(inode); 1019eefe2a2SStefan Roese 1029eefe2a2SStefan Roese if (inode->i_size > c->max_inode_sz) { 1039eefe2a2SStefan Roese ubifs_err("inode is too large (%lld)", 1049eefe2a2SStefan Roese (long long)inode->i_size); 1059eefe2a2SStefan Roese return 1; 1069eefe2a2SStefan Roese } 1079eefe2a2SStefan Roese 1089eefe2a2SStefan Roese if (ui->compr_type < 0 || ui->compr_type >= UBIFS_COMPR_TYPES_CNT) { 1099eefe2a2SStefan Roese ubifs_err("unknown compression type %d", ui->compr_type); 1109eefe2a2SStefan Roese return 2; 1119eefe2a2SStefan Roese } 1129eefe2a2SStefan Roese 1139eefe2a2SStefan Roese if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA) 1149eefe2a2SStefan Roese return 4; 1159eefe2a2SStefan Roese 1169eefe2a2SStefan Roese if (!ubifs_compr_present(ui->compr_type)) { 1179eefe2a2SStefan Roese ubifs_warn("inode %lu uses '%s' compression, but it was not " 1189eefe2a2SStefan Roese "compiled in", inode->i_ino, 1199eefe2a2SStefan Roese ubifs_compr_name(ui->compr_type)); 1209eefe2a2SStefan Roese } 1219eefe2a2SStefan Roese 1229eefe2a2SStefan Roese err = dbg_check_dir_size(c, inode); 1239eefe2a2SStefan Roese return err; 1249eefe2a2SStefan Roese } 1259eefe2a2SStefan Roese 1269eefe2a2SStefan Roese struct inode *iget_locked(struct super_block *sb, unsigned long ino) 1279eefe2a2SStefan Roese { 1289eefe2a2SStefan Roese struct inode *inode; 1299eefe2a2SStefan Roese 1309eefe2a2SStefan Roese inode = (struct inode *)malloc(sizeof(struct ubifs_inode)); 1319eefe2a2SStefan Roese if (inode) { 1329eefe2a2SStefan Roese inode->i_ino = ino; 1339eefe2a2SStefan Roese inode->i_sb = sb; 1349eefe2a2SStefan Roese list_add(&inode->i_sb_list, &sb->s_inodes); 1359eefe2a2SStefan Roese inode->i_state = I_LOCK | I_NEW; 1369eefe2a2SStefan Roese } 1379eefe2a2SStefan Roese 1389eefe2a2SStefan Roese return inode; 1399eefe2a2SStefan Roese } 1409eefe2a2SStefan Roese 1419eefe2a2SStefan Roese int ubifs_iput(struct inode *inode) 1429eefe2a2SStefan Roese { 1439eefe2a2SStefan Roese list_del_init(&inode->i_sb_list); 1449eefe2a2SStefan Roese 1459eefe2a2SStefan Roese free(inode); 1469eefe2a2SStefan Roese return 0; 1479eefe2a2SStefan Roese } 1489eefe2a2SStefan Roese 1499eefe2a2SStefan Roese /* 1509eefe2a2SStefan Roese * Lock (save) inode in inode array for readback after recovery 1519eefe2a2SStefan Roese */ 1529eefe2a2SStefan Roese void iput(struct inode *inode) 1539eefe2a2SStefan Roese { 1549eefe2a2SStefan Roese int i; 1559eefe2a2SStefan Roese struct inode *ino; 1569eefe2a2SStefan Roese 1579eefe2a2SStefan Roese /* 1589eefe2a2SStefan Roese * Search end of list 1599eefe2a2SStefan Roese */ 1609eefe2a2SStefan Roese for (i = 0; i < INODE_LOCKED_MAX; i++) { 1619eefe2a2SStefan Roese if (inodes_locked_down[i] == NULL) 1629eefe2a2SStefan Roese break; 1639eefe2a2SStefan Roese } 1649eefe2a2SStefan Roese 1659eefe2a2SStefan Roese if (i >= INODE_LOCKED_MAX) { 1669eefe2a2SStefan Roese ubifs_err("Error, can't lock (save) more inodes while recovery!!!"); 1679eefe2a2SStefan Roese return; 1689eefe2a2SStefan Roese } 1699eefe2a2SStefan Roese 1709eefe2a2SStefan Roese /* 1719eefe2a2SStefan Roese * Allocate and use new inode 1729eefe2a2SStefan Roese */ 1739eefe2a2SStefan Roese ino = (struct inode *)malloc(sizeof(struct ubifs_inode)); 1749eefe2a2SStefan Roese memcpy(ino, inode, sizeof(struct ubifs_inode)); 1759eefe2a2SStefan Roese 1769eefe2a2SStefan Roese /* 1779eefe2a2SStefan Roese * Finally save inode in array 1789eefe2a2SStefan Roese */ 1799eefe2a2SStefan Roese inodes_locked_down[i] = ino; 1809eefe2a2SStefan Roese } 1819eefe2a2SStefan Roese 1829eefe2a2SStefan Roese struct inode *ubifs_iget(struct super_block *sb, unsigned long inum) 1839eefe2a2SStefan Roese { 1849eefe2a2SStefan Roese int err; 1859eefe2a2SStefan Roese union ubifs_key key; 1869eefe2a2SStefan Roese struct ubifs_ino_node *ino; 1879eefe2a2SStefan Roese struct ubifs_info *c = sb->s_fs_info; 1889eefe2a2SStefan Roese struct inode *inode; 1899eefe2a2SStefan Roese struct ubifs_inode *ui; 1909eefe2a2SStefan Roese int i; 1919eefe2a2SStefan Roese 1929eefe2a2SStefan Roese dbg_gen("inode %lu", inum); 1939eefe2a2SStefan Roese 1949eefe2a2SStefan Roese /* 1959eefe2a2SStefan Roese * U-Boot special handling of locked down inodes via recovery 1969eefe2a2SStefan Roese * e.g. ubifs_recover_size() 1979eefe2a2SStefan Roese */ 1989eefe2a2SStefan Roese for (i = 0; i < INODE_LOCKED_MAX; i++) { 1999eefe2a2SStefan Roese /* 2009eefe2a2SStefan Roese * Exit on last entry (NULL), inode not found in list 2019eefe2a2SStefan Roese */ 2029eefe2a2SStefan Roese if (inodes_locked_down[i] == NULL) 2039eefe2a2SStefan Roese break; 2049eefe2a2SStefan Roese 2059eefe2a2SStefan Roese if (inodes_locked_down[i]->i_ino == inum) { 2069eefe2a2SStefan Roese /* 2079eefe2a2SStefan Roese * We found the locked down inode in our array, 2089eefe2a2SStefan Roese * so just return this pointer instead of creating 2099eefe2a2SStefan Roese * a new one. 2109eefe2a2SStefan Roese */ 2119eefe2a2SStefan Roese return inodes_locked_down[i]; 2129eefe2a2SStefan Roese } 2139eefe2a2SStefan Roese } 2149eefe2a2SStefan Roese 2159eefe2a2SStefan Roese inode = iget_locked(sb, inum); 2169eefe2a2SStefan Roese if (!inode) 2179eefe2a2SStefan Roese return ERR_PTR(-ENOMEM); 2189eefe2a2SStefan Roese if (!(inode->i_state & I_NEW)) 2199eefe2a2SStefan Roese return inode; 2209eefe2a2SStefan Roese ui = ubifs_inode(inode); 2219eefe2a2SStefan Roese 2229eefe2a2SStefan Roese ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS); 2239eefe2a2SStefan Roese if (!ino) { 2249eefe2a2SStefan Roese err = -ENOMEM; 2259eefe2a2SStefan Roese goto out; 2269eefe2a2SStefan Roese } 2279eefe2a2SStefan Roese 2289eefe2a2SStefan Roese ino_key_init(c, &key, inode->i_ino); 2299eefe2a2SStefan Roese 2309eefe2a2SStefan Roese err = ubifs_tnc_lookup(c, &key, ino); 2319eefe2a2SStefan Roese if (err) 2329eefe2a2SStefan Roese goto out_ino; 2339eefe2a2SStefan Roese 2349eefe2a2SStefan Roese inode->i_flags |= (S_NOCMTIME | S_NOATIME); 2359eefe2a2SStefan Roese inode->i_nlink = le32_to_cpu(ino->nlink); 2369eefe2a2SStefan Roese inode->i_uid = le32_to_cpu(ino->uid); 2379eefe2a2SStefan Roese inode->i_gid = le32_to_cpu(ino->gid); 2389eefe2a2SStefan Roese inode->i_atime.tv_sec = (int64_t)le64_to_cpu(ino->atime_sec); 2399eefe2a2SStefan Roese inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec); 2409eefe2a2SStefan Roese inode->i_mtime.tv_sec = (int64_t)le64_to_cpu(ino->mtime_sec); 2419eefe2a2SStefan Roese inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec); 2429eefe2a2SStefan Roese inode->i_ctime.tv_sec = (int64_t)le64_to_cpu(ino->ctime_sec); 2439eefe2a2SStefan Roese inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec); 2449eefe2a2SStefan Roese inode->i_mode = le32_to_cpu(ino->mode); 2459eefe2a2SStefan Roese inode->i_size = le64_to_cpu(ino->size); 2469eefe2a2SStefan Roese 2479eefe2a2SStefan Roese ui->data_len = le32_to_cpu(ino->data_len); 2489eefe2a2SStefan Roese ui->flags = le32_to_cpu(ino->flags); 2499eefe2a2SStefan Roese ui->compr_type = le16_to_cpu(ino->compr_type); 2509eefe2a2SStefan Roese ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum); 2519eefe2a2SStefan Roese ui->synced_i_size = ui->ui_size = inode->i_size; 2529eefe2a2SStefan Roese 2539eefe2a2SStefan Roese err = validate_inode(c, inode); 2549eefe2a2SStefan Roese if (err) 2559eefe2a2SStefan Roese goto out_invalid; 2569eefe2a2SStefan Roese 2579eefe2a2SStefan Roese if ((inode->i_mode & S_IFMT) == S_IFLNK) { 2589eefe2a2SStefan Roese if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) { 2599eefe2a2SStefan Roese err = 12; 2609eefe2a2SStefan Roese goto out_invalid; 2619eefe2a2SStefan Roese } 2629eefe2a2SStefan Roese ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 2639eefe2a2SStefan Roese if (!ui->data) { 2649eefe2a2SStefan Roese err = -ENOMEM; 2659eefe2a2SStefan Roese goto out_ino; 2669eefe2a2SStefan Roese } 2679eefe2a2SStefan Roese memcpy(ui->data, ino->data, ui->data_len); 2689eefe2a2SStefan Roese ((char *)ui->data)[ui->data_len] = '\0'; 2699eefe2a2SStefan Roese } 2709eefe2a2SStefan Roese 2719eefe2a2SStefan Roese kfree(ino); 2729eefe2a2SStefan Roese inode->i_state &= ~(I_LOCK | I_NEW); 2739eefe2a2SStefan Roese return inode; 2749eefe2a2SStefan Roese 2759eefe2a2SStefan Roese out_invalid: 2769eefe2a2SStefan Roese ubifs_err("inode %lu validation failed, error %d", inode->i_ino, err); 2779eefe2a2SStefan Roese dbg_dump_node(c, ino); 2789eefe2a2SStefan Roese dbg_dump_inode(c, inode); 2799eefe2a2SStefan Roese err = -EINVAL; 2809eefe2a2SStefan Roese out_ino: 2819eefe2a2SStefan Roese kfree(ino); 2829eefe2a2SStefan Roese out: 2839eefe2a2SStefan Roese ubifs_err("failed to read inode %lu, error %d", inode->i_ino, err); 2849eefe2a2SStefan Roese return ERR_PTR(err); 2859eefe2a2SStefan Roese } 2869eefe2a2SStefan Roese 2879eefe2a2SStefan Roese /** 2889eefe2a2SStefan Roese * init_constants_early - initialize UBIFS constants. 2899eefe2a2SStefan Roese * @c: UBIFS file-system description object 2909eefe2a2SStefan Roese * 2919eefe2a2SStefan Roese * This function initialize UBIFS constants which do not need the superblock to 2929eefe2a2SStefan Roese * be read. It also checks that the UBI volume satisfies basic UBIFS 2939eefe2a2SStefan Roese * requirements. Returns zero in case of success and a negative error code in 2949eefe2a2SStefan Roese * case of failure. 2959eefe2a2SStefan Roese */ 2969eefe2a2SStefan Roese static int init_constants_early(struct ubifs_info *c) 2979eefe2a2SStefan Roese { 2989eefe2a2SStefan Roese if (c->vi.corrupted) { 2999eefe2a2SStefan Roese ubifs_warn("UBI volume is corrupted - read-only mode"); 3009eefe2a2SStefan Roese c->ro_media = 1; 3019eefe2a2SStefan Roese } 3029eefe2a2SStefan Roese 3039eefe2a2SStefan Roese if (c->di.ro_mode) { 3049eefe2a2SStefan Roese ubifs_msg("read-only UBI device"); 3059eefe2a2SStefan Roese c->ro_media = 1; 3069eefe2a2SStefan Roese } 3079eefe2a2SStefan Roese 3089eefe2a2SStefan Roese if (c->vi.vol_type == UBI_STATIC_VOLUME) { 3099eefe2a2SStefan Roese ubifs_msg("static UBI volume - read-only mode"); 3109eefe2a2SStefan Roese c->ro_media = 1; 3119eefe2a2SStefan Roese } 3129eefe2a2SStefan Roese 3139eefe2a2SStefan Roese c->leb_cnt = c->vi.size; 3149eefe2a2SStefan Roese c->leb_size = c->vi.usable_leb_size; 3159eefe2a2SStefan Roese c->half_leb_size = c->leb_size / 2; 3169eefe2a2SStefan Roese c->min_io_size = c->di.min_io_size; 3179eefe2a2SStefan Roese c->min_io_shift = fls(c->min_io_size) - 1; 3189eefe2a2SStefan Roese 3199eefe2a2SStefan Roese if (c->leb_size < UBIFS_MIN_LEB_SZ) { 3209eefe2a2SStefan Roese ubifs_err("too small LEBs (%d bytes), min. is %d bytes", 3219eefe2a2SStefan Roese c->leb_size, UBIFS_MIN_LEB_SZ); 3229eefe2a2SStefan Roese return -EINVAL; 3239eefe2a2SStefan Roese } 3249eefe2a2SStefan Roese 3259eefe2a2SStefan Roese if (c->leb_cnt < UBIFS_MIN_LEB_CNT) { 3269eefe2a2SStefan Roese ubifs_err("too few LEBs (%d), min. is %d", 3279eefe2a2SStefan Roese c->leb_cnt, UBIFS_MIN_LEB_CNT); 3289eefe2a2SStefan Roese return -EINVAL; 3299eefe2a2SStefan Roese } 3309eefe2a2SStefan Roese 3319eefe2a2SStefan Roese if (!is_power_of_2(c->min_io_size)) { 3329eefe2a2SStefan Roese ubifs_err("bad min. I/O size %d", c->min_io_size); 3339eefe2a2SStefan Roese return -EINVAL; 3349eefe2a2SStefan Roese } 3359eefe2a2SStefan Roese 3369eefe2a2SStefan Roese /* 3379eefe2a2SStefan Roese * UBIFS aligns all node to 8-byte boundary, so to make function in 3389eefe2a2SStefan Roese * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is 3399eefe2a2SStefan Roese * less than 8. 3409eefe2a2SStefan Roese */ 3419eefe2a2SStefan Roese if (c->min_io_size < 8) { 3429eefe2a2SStefan Roese c->min_io_size = 8; 3439eefe2a2SStefan Roese c->min_io_shift = 3; 3449eefe2a2SStefan Roese } 3459eefe2a2SStefan Roese 3469eefe2a2SStefan Roese c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size); 3479eefe2a2SStefan Roese c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size); 3489eefe2a2SStefan Roese 3499eefe2a2SStefan Roese /* 3509eefe2a2SStefan Roese * Initialize node length ranges which are mostly needed for node 3519eefe2a2SStefan Roese * length validation. 3529eefe2a2SStefan Roese */ 3539eefe2a2SStefan Roese c->ranges[UBIFS_PAD_NODE].len = UBIFS_PAD_NODE_SZ; 3549eefe2a2SStefan Roese c->ranges[UBIFS_SB_NODE].len = UBIFS_SB_NODE_SZ; 3559eefe2a2SStefan Roese c->ranges[UBIFS_MST_NODE].len = UBIFS_MST_NODE_SZ; 3569eefe2a2SStefan Roese c->ranges[UBIFS_REF_NODE].len = UBIFS_REF_NODE_SZ; 3579eefe2a2SStefan Roese c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ; 3589eefe2a2SStefan Roese c->ranges[UBIFS_CS_NODE].len = UBIFS_CS_NODE_SZ; 3599eefe2a2SStefan Roese 3609eefe2a2SStefan Roese c->ranges[UBIFS_INO_NODE].min_len = UBIFS_INO_NODE_SZ; 3619eefe2a2SStefan Roese c->ranges[UBIFS_INO_NODE].max_len = UBIFS_MAX_INO_NODE_SZ; 3629eefe2a2SStefan Roese c->ranges[UBIFS_ORPH_NODE].min_len = 3639eefe2a2SStefan Roese UBIFS_ORPH_NODE_SZ + sizeof(__le64); 3649eefe2a2SStefan Roese c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size; 3659eefe2a2SStefan Roese c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ; 3669eefe2a2SStefan Roese c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ; 3679eefe2a2SStefan Roese c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ; 3689eefe2a2SStefan Roese c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ; 3699eefe2a2SStefan Roese c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ; 3709eefe2a2SStefan Roese c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ; 3719eefe2a2SStefan Roese /* 3729eefe2a2SStefan Roese * Minimum indexing node size is amended later when superblock is 3739eefe2a2SStefan Roese * read and the key length is known. 3749eefe2a2SStefan Roese */ 3759eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ; 3769eefe2a2SStefan Roese /* 3779eefe2a2SStefan Roese * Maximum indexing node size is amended later when superblock is 3789eefe2a2SStefan Roese * read and the fanout is known. 3799eefe2a2SStefan Roese */ 3809eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX; 3819eefe2a2SStefan Roese 3829eefe2a2SStefan Roese /* 3839eefe2a2SStefan Roese * Initialize dead and dark LEB space watermarks. See gc.c for comments 3849eefe2a2SStefan Roese * about these values. 3859eefe2a2SStefan Roese */ 3869eefe2a2SStefan Roese c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size); 3879eefe2a2SStefan Roese c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size); 3889eefe2a2SStefan Roese 3899eefe2a2SStefan Roese /* 3909eefe2a2SStefan Roese * Calculate how many bytes would be wasted at the end of LEB if it was 3919eefe2a2SStefan Roese * fully filled with data nodes of maximum size. This is used in 3929eefe2a2SStefan Roese * calculations when reporting free space. 3939eefe2a2SStefan Roese */ 3949eefe2a2SStefan Roese c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ; 3959eefe2a2SStefan Roese 3969eefe2a2SStefan Roese return 0; 3979eefe2a2SStefan Roese } 3989eefe2a2SStefan Roese 3999eefe2a2SStefan Roese /* 4009eefe2a2SStefan Roese * init_constants_sb - initialize UBIFS constants. 4019eefe2a2SStefan Roese * @c: UBIFS file-system description object 4029eefe2a2SStefan Roese * 4039eefe2a2SStefan Roese * This is a helper function which initializes various UBIFS constants after 4049eefe2a2SStefan Roese * the superblock has been read. It also checks various UBIFS parameters and 4059eefe2a2SStefan Roese * makes sure they are all right. Returns zero in case of success and a 4069eefe2a2SStefan Roese * negative error code in case of failure. 4079eefe2a2SStefan Roese */ 4089eefe2a2SStefan Roese static int init_constants_sb(struct ubifs_info *c) 4099eefe2a2SStefan Roese { 4109eefe2a2SStefan Roese int tmp, err; 4119eefe2a2SStefan Roese long long tmp64; 4129eefe2a2SStefan Roese 4139eefe2a2SStefan Roese c->main_bytes = (long long)c->main_lebs * c->leb_size; 4149eefe2a2SStefan Roese c->max_znode_sz = sizeof(struct ubifs_znode) + 4159eefe2a2SStefan Roese c->fanout * sizeof(struct ubifs_zbranch); 4169eefe2a2SStefan Roese 4179eefe2a2SStefan Roese tmp = ubifs_idx_node_sz(c, 1); 4189eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].min_len = tmp; 4199eefe2a2SStefan Roese c->min_idx_node_sz = ALIGN(tmp, 8); 4209eefe2a2SStefan Roese 4219eefe2a2SStefan Roese tmp = ubifs_idx_node_sz(c, c->fanout); 4229eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].max_len = tmp; 4239eefe2a2SStefan Roese c->max_idx_node_sz = ALIGN(tmp, 8); 4249eefe2a2SStefan Roese 4259eefe2a2SStefan Roese /* Make sure LEB size is large enough to fit full commit */ 4269eefe2a2SStefan Roese tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt; 4279eefe2a2SStefan Roese tmp = ALIGN(tmp, c->min_io_size); 4289eefe2a2SStefan Roese if (tmp > c->leb_size) { 4299eefe2a2SStefan Roese dbg_err("too small LEB size %d, at least %d needed", 4309eefe2a2SStefan Roese c->leb_size, tmp); 4319eefe2a2SStefan Roese return -EINVAL; 4329eefe2a2SStefan Roese } 4339eefe2a2SStefan Roese 4349eefe2a2SStefan Roese /* 4359eefe2a2SStefan Roese * Make sure that the log is large enough to fit reference nodes for 4369eefe2a2SStefan Roese * all buds plus one reserved LEB. 4379eefe2a2SStefan Roese */ 4389eefe2a2SStefan Roese tmp64 = c->max_bud_bytes + c->leb_size - 1; 4399eefe2a2SStefan Roese c->max_bud_cnt = div_u64(tmp64, c->leb_size); 4409eefe2a2SStefan Roese tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1); 4419eefe2a2SStefan Roese tmp /= c->leb_size; 4429eefe2a2SStefan Roese tmp += 1; 4439eefe2a2SStefan Roese if (c->log_lebs < tmp) { 4449eefe2a2SStefan Roese dbg_err("too small log %d LEBs, required min. %d LEBs", 4459eefe2a2SStefan Roese c->log_lebs, tmp); 4469eefe2a2SStefan Roese return -EINVAL; 4479eefe2a2SStefan Roese } 4489eefe2a2SStefan Roese 4499eefe2a2SStefan Roese /* 4509eefe2a2SStefan Roese * When budgeting we assume worst-case scenarios when the pages are not 4519eefe2a2SStefan Roese * be compressed and direntries are of the maximum size. 4529eefe2a2SStefan Roese * 4539eefe2a2SStefan Roese * Note, data, which may be stored in inodes is budgeted separately, so 4549eefe2a2SStefan Roese * it is not included into 'c->inode_budget'. 4559eefe2a2SStefan Roese */ 4569eefe2a2SStefan Roese c->page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE; 4579eefe2a2SStefan Roese c->inode_budget = UBIFS_INO_NODE_SZ; 4589eefe2a2SStefan Roese c->dent_budget = UBIFS_MAX_DENT_NODE_SZ; 4599eefe2a2SStefan Roese 4609eefe2a2SStefan Roese /* 4619eefe2a2SStefan Roese * When the amount of flash space used by buds becomes 4629eefe2a2SStefan Roese * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit. 4639eefe2a2SStefan Roese * The writers are unblocked when the commit is finished. To avoid 4649eefe2a2SStefan Roese * writers to be blocked UBIFS initiates background commit in advance, 4659eefe2a2SStefan Roese * when number of bud bytes becomes above the limit defined below. 4669eefe2a2SStefan Roese */ 4679eefe2a2SStefan Roese c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4; 4689eefe2a2SStefan Roese 4699eefe2a2SStefan Roese /* 4709eefe2a2SStefan Roese * Ensure minimum journal size. All the bytes in the journal heads are 4719eefe2a2SStefan Roese * considered to be used, when calculating the current journal usage. 4729eefe2a2SStefan Roese * Consequently, if the journal is too small, UBIFS will treat it as 4739eefe2a2SStefan Roese * always full. 4749eefe2a2SStefan Roese */ 4759eefe2a2SStefan Roese tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1; 4769eefe2a2SStefan Roese if (c->bg_bud_bytes < tmp64) 4779eefe2a2SStefan Roese c->bg_bud_bytes = tmp64; 4789eefe2a2SStefan Roese if (c->max_bud_bytes < tmp64 + c->leb_size) 4799eefe2a2SStefan Roese c->max_bud_bytes = tmp64 + c->leb_size; 4809eefe2a2SStefan Roese 4819eefe2a2SStefan Roese err = ubifs_calc_lpt_geom(c); 4829eefe2a2SStefan Roese if (err) 4839eefe2a2SStefan Roese return err; 4849eefe2a2SStefan Roese 4859eefe2a2SStefan Roese return 0; 4869eefe2a2SStefan Roese } 4879eefe2a2SStefan Roese 4889eefe2a2SStefan Roese /* 4899eefe2a2SStefan Roese * init_constants_master - initialize UBIFS constants. 4909eefe2a2SStefan Roese * @c: UBIFS file-system description object 4919eefe2a2SStefan Roese * 4929eefe2a2SStefan Roese * This is a helper function which initializes various UBIFS constants after 4939eefe2a2SStefan Roese * the master node has been read. It also checks various UBIFS parameters and 4949eefe2a2SStefan Roese * makes sure they are all right. 4959eefe2a2SStefan Roese */ 4969eefe2a2SStefan Roese static void init_constants_master(struct ubifs_info *c) 4979eefe2a2SStefan Roese { 4989eefe2a2SStefan Roese long long tmp64; 4999eefe2a2SStefan Roese 5009eefe2a2SStefan Roese c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); 5019eefe2a2SStefan Roese 5029eefe2a2SStefan Roese /* 5039eefe2a2SStefan Roese * Calculate total amount of FS blocks. This number is not used 5049eefe2a2SStefan Roese * internally because it does not make much sense for UBIFS, but it is 5059eefe2a2SStefan Roese * necessary to report something for the 'statfs()' call. 5069eefe2a2SStefan Roese * 5079eefe2a2SStefan Roese * Subtract the LEB reserved for GC, the LEB which is reserved for 5089eefe2a2SStefan Roese * deletions, minimum LEBs for the index, and assume only one journal 5099eefe2a2SStefan Roese * head is available. 5109eefe2a2SStefan Roese */ 5119eefe2a2SStefan Roese tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1; 5129eefe2a2SStefan Roese tmp64 *= (long long)c->leb_size - c->leb_overhead; 5139eefe2a2SStefan Roese tmp64 = ubifs_reported_space(c, tmp64); 5149eefe2a2SStefan Roese c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT; 5159eefe2a2SStefan Roese } 5169eefe2a2SStefan Roese 5179eefe2a2SStefan Roese /** 5189eefe2a2SStefan Roese * free_orphans - free orphans. 5199eefe2a2SStefan Roese * @c: UBIFS file-system description object 5209eefe2a2SStefan Roese */ 5219eefe2a2SStefan Roese static void free_orphans(struct ubifs_info *c) 5229eefe2a2SStefan Roese { 5239eefe2a2SStefan Roese struct ubifs_orphan *orph; 5249eefe2a2SStefan Roese 5259eefe2a2SStefan Roese while (c->orph_dnext) { 5269eefe2a2SStefan Roese orph = c->orph_dnext; 5279eefe2a2SStefan Roese c->orph_dnext = orph->dnext; 5289eefe2a2SStefan Roese list_del(&orph->list); 5299eefe2a2SStefan Roese kfree(orph); 5309eefe2a2SStefan Roese } 5319eefe2a2SStefan Roese 5329eefe2a2SStefan Roese while (!list_empty(&c->orph_list)) { 5339eefe2a2SStefan Roese orph = list_entry(c->orph_list.next, struct ubifs_orphan, list); 5349eefe2a2SStefan Roese list_del(&orph->list); 5359eefe2a2SStefan Roese kfree(orph); 5369eefe2a2SStefan Roese dbg_err("orphan list not empty at unmount"); 5379eefe2a2SStefan Roese } 5389eefe2a2SStefan Roese 5399eefe2a2SStefan Roese vfree(c->orph_buf); 5409eefe2a2SStefan Roese c->orph_buf = NULL; 5419eefe2a2SStefan Roese } 5429eefe2a2SStefan Roese 5439eefe2a2SStefan Roese /** 5449eefe2a2SStefan Roese * check_volume_empty - check if the UBI volume is empty. 5459eefe2a2SStefan Roese * @c: UBIFS file-system description object 5469eefe2a2SStefan Roese * 5479eefe2a2SStefan Roese * This function checks if the UBIFS volume is empty by looking if its LEBs are 5489eefe2a2SStefan Roese * mapped or not. The result of checking is stored in the @c->empty variable. 5499eefe2a2SStefan Roese * Returns zero in case of success and a negative error code in case of 5509eefe2a2SStefan Roese * failure. 5519eefe2a2SStefan Roese */ 5529eefe2a2SStefan Roese static int check_volume_empty(struct ubifs_info *c) 5539eefe2a2SStefan Roese { 5549eefe2a2SStefan Roese int lnum, err; 5559eefe2a2SStefan Roese 5569eefe2a2SStefan Roese c->empty = 1; 5579eefe2a2SStefan Roese for (lnum = 0; lnum < c->leb_cnt; lnum++) { 5589eefe2a2SStefan Roese err = ubi_is_mapped(c->ubi, lnum); 5599eefe2a2SStefan Roese if (unlikely(err < 0)) 5609eefe2a2SStefan Roese return err; 5619eefe2a2SStefan Roese if (err == 1) { 5629eefe2a2SStefan Roese c->empty = 0; 5639eefe2a2SStefan Roese break; 5649eefe2a2SStefan Roese } 5659eefe2a2SStefan Roese 5669eefe2a2SStefan Roese cond_resched(); 5679eefe2a2SStefan Roese } 5689eefe2a2SStefan Roese 5699eefe2a2SStefan Roese return 0; 5709eefe2a2SStefan Roese } 5719eefe2a2SStefan Roese 5729eefe2a2SStefan Roese /** 5739eefe2a2SStefan Roese * mount_ubifs - mount UBIFS file-system. 5749eefe2a2SStefan Roese * @c: UBIFS file-system description object 5759eefe2a2SStefan Roese * 5769eefe2a2SStefan Roese * This function mounts UBIFS file system. Returns zero in case of success and 5779eefe2a2SStefan Roese * a negative error code in case of failure. 5789eefe2a2SStefan Roese * 5799eefe2a2SStefan Roese * Note, the function does not de-allocate resources it it fails half way 5809eefe2a2SStefan Roese * through, and the caller has to do this instead. 5819eefe2a2SStefan Roese */ 5829eefe2a2SStefan Roese static int mount_ubifs(struct ubifs_info *c) 5839eefe2a2SStefan Roese { 5849eefe2a2SStefan Roese struct super_block *sb = c->vfs_sb; 5859eefe2a2SStefan Roese int err, mounted_read_only = (sb->s_flags & MS_RDONLY); 5869eefe2a2SStefan Roese long long x; 5879eefe2a2SStefan Roese size_t sz; 5889eefe2a2SStefan Roese 5899eefe2a2SStefan Roese err = init_constants_early(c); 5909eefe2a2SStefan Roese if (err) 5919eefe2a2SStefan Roese return err; 5929eefe2a2SStefan Roese 5939eefe2a2SStefan Roese err = ubifs_debugging_init(c); 5949eefe2a2SStefan Roese if (err) 5959eefe2a2SStefan Roese return err; 5969eefe2a2SStefan Roese 5979eefe2a2SStefan Roese err = check_volume_empty(c); 5989eefe2a2SStefan Roese if (err) 5999eefe2a2SStefan Roese goto out_free; 6009eefe2a2SStefan Roese 6019eefe2a2SStefan Roese if (c->empty && (mounted_read_only || c->ro_media)) { 6029eefe2a2SStefan Roese /* 6039eefe2a2SStefan Roese * This UBI volume is empty, and read-only, or the file system 6049eefe2a2SStefan Roese * is mounted read-only - we cannot format it. 6059eefe2a2SStefan Roese */ 6069eefe2a2SStefan Roese ubifs_err("can't format empty UBI volume: read-only %s", 6079eefe2a2SStefan Roese c->ro_media ? "UBI volume" : "mount"); 6089eefe2a2SStefan Roese err = -EROFS; 6099eefe2a2SStefan Roese goto out_free; 6109eefe2a2SStefan Roese } 6119eefe2a2SStefan Roese 6129eefe2a2SStefan Roese if (c->ro_media && !mounted_read_only) { 6139eefe2a2SStefan Roese ubifs_err("cannot mount read-write - read-only media"); 6149eefe2a2SStefan Roese err = -EROFS; 6159eefe2a2SStefan Roese goto out_free; 6169eefe2a2SStefan Roese } 6179eefe2a2SStefan Roese 6189eefe2a2SStefan Roese /* 6199eefe2a2SStefan Roese * The requirement for the buffer is that it should fit indexing B-tree 6209eefe2a2SStefan Roese * height amount of integers. We assume the height if the TNC tree will 6219eefe2a2SStefan Roese * never exceed 64. 6229eefe2a2SStefan Roese */ 6239eefe2a2SStefan Roese err = -ENOMEM; 6249eefe2a2SStefan Roese c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL); 6259eefe2a2SStefan Roese if (!c->bottom_up_buf) 6269eefe2a2SStefan Roese goto out_free; 6279eefe2a2SStefan Roese 6289eefe2a2SStefan Roese c->sbuf = vmalloc(c->leb_size); 6299eefe2a2SStefan Roese if (!c->sbuf) 6309eefe2a2SStefan Roese goto out_free; 6319eefe2a2SStefan Roese 6329eefe2a2SStefan Roese /* 6339eefe2a2SStefan Roese * We have to check all CRCs, even for data nodes, when we mount the FS 6349eefe2a2SStefan Roese * (specifically, when we are replaying). 6359eefe2a2SStefan Roese */ 6369eefe2a2SStefan Roese c->always_chk_crc = 1; 6379eefe2a2SStefan Roese 6389eefe2a2SStefan Roese err = ubifs_read_superblock(c); 6399eefe2a2SStefan Roese if (err) 6409eefe2a2SStefan Roese goto out_free; 6419eefe2a2SStefan Roese 6429eefe2a2SStefan Roese /* 6439eefe2a2SStefan Roese * Make sure the compressor which is set as default in the superblock 6449eefe2a2SStefan Roese * or overridden by mount options is actually compiled in. 6459eefe2a2SStefan Roese */ 6469eefe2a2SStefan Roese if (!ubifs_compr_present(c->default_compr)) { 6479eefe2a2SStefan Roese ubifs_err("'compressor \"%s\" is not compiled in", 6489eefe2a2SStefan Roese ubifs_compr_name(c->default_compr)); 6499eefe2a2SStefan Roese goto out_free; 6509eefe2a2SStefan Roese } 6519eefe2a2SStefan Roese 6529eefe2a2SStefan Roese dbg_failure_mode_registration(c); 6539eefe2a2SStefan Roese 6549eefe2a2SStefan Roese err = init_constants_sb(c); 6559eefe2a2SStefan Roese if (err) 6569eefe2a2SStefan Roese goto out_free; 6579eefe2a2SStefan Roese 6589eefe2a2SStefan Roese sz = ALIGN(c->max_idx_node_sz, c->min_io_size); 6599eefe2a2SStefan Roese sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size); 6609eefe2a2SStefan Roese c->cbuf = kmalloc(sz, GFP_NOFS); 6619eefe2a2SStefan Roese if (!c->cbuf) { 6629eefe2a2SStefan Roese err = -ENOMEM; 6639eefe2a2SStefan Roese goto out_free; 6649eefe2a2SStefan Roese } 6659eefe2a2SStefan Roese 6669eefe2a2SStefan Roese sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id); 6679eefe2a2SStefan Roese 6689eefe2a2SStefan Roese err = ubifs_read_master(c); 6699eefe2a2SStefan Roese if (err) 6709eefe2a2SStefan Roese goto out_master; 6719eefe2a2SStefan Roese 6729eefe2a2SStefan Roese init_constants_master(c); 6739eefe2a2SStefan Roese 6749eefe2a2SStefan Roese if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) { 6759eefe2a2SStefan Roese ubifs_msg("recovery needed"); 6769eefe2a2SStefan Roese c->need_recovery = 1; 6779eefe2a2SStefan Roese } 6789eefe2a2SStefan Roese 6799eefe2a2SStefan Roese err = ubifs_lpt_init(c, 1, !mounted_read_only); 6809eefe2a2SStefan Roese if (err) 6819eefe2a2SStefan Roese goto out_lpt; 6829eefe2a2SStefan Roese 6839eefe2a2SStefan Roese err = dbg_check_idx_size(c, c->old_idx_sz); 6849eefe2a2SStefan Roese if (err) 6859eefe2a2SStefan Roese goto out_lpt; 6869eefe2a2SStefan Roese 6879eefe2a2SStefan Roese err = ubifs_replay_journal(c); 6889eefe2a2SStefan Roese if (err) 6899eefe2a2SStefan Roese goto out_journal; 6909eefe2a2SStefan Roese 6919eefe2a2SStefan Roese err = ubifs_mount_orphans(c, c->need_recovery, mounted_read_only); 6929eefe2a2SStefan Roese if (err) 6939eefe2a2SStefan Roese goto out_orphans; 6949eefe2a2SStefan Roese 6959eefe2a2SStefan Roese if (c->need_recovery) { 6969eefe2a2SStefan Roese err = ubifs_recover_size(c); 6979eefe2a2SStefan Roese if (err) 6989eefe2a2SStefan Roese goto out_orphans; 6999eefe2a2SStefan Roese } 7009eefe2a2SStefan Roese 7019eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 7029eefe2a2SStefan Roese list_add_tail(&c->infos_list, &ubifs_infos); 7039eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 7049eefe2a2SStefan Roese 7059eefe2a2SStefan Roese if (c->need_recovery) { 7069eefe2a2SStefan Roese if (mounted_read_only) 7079eefe2a2SStefan Roese ubifs_msg("recovery deferred"); 7089eefe2a2SStefan Roese else { 7099eefe2a2SStefan Roese c->need_recovery = 0; 7109eefe2a2SStefan Roese ubifs_msg("recovery completed"); 7119eefe2a2SStefan Roese } 7129eefe2a2SStefan Roese } 7139eefe2a2SStefan Roese 7149eefe2a2SStefan Roese err = dbg_check_filesystem(c); 7159eefe2a2SStefan Roese if (err) 7169eefe2a2SStefan Roese goto out_infos; 7179eefe2a2SStefan Roese 7189eefe2a2SStefan Roese c->always_chk_crc = 0; 7199eefe2a2SStefan Roese 7209eefe2a2SStefan Roese ubifs_msg("mounted UBI device %d, volume %d, name \"%s\"", 7219eefe2a2SStefan Roese c->vi.ubi_num, c->vi.vol_id, c->vi.name); 7229eefe2a2SStefan Roese if (mounted_read_only) 7239eefe2a2SStefan Roese ubifs_msg("mounted read-only"); 7249eefe2a2SStefan Roese x = (long long)c->main_lebs * c->leb_size; 7259eefe2a2SStefan Roese ubifs_msg("file system size: %lld bytes (%lld KiB, %lld MiB, %d " 7269eefe2a2SStefan Roese "LEBs)", x, x >> 10, x >> 20, c->main_lebs); 7279eefe2a2SStefan Roese x = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes; 7289eefe2a2SStefan Roese ubifs_msg("journal size: %lld bytes (%lld KiB, %lld MiB, %d " 7299eefe2a2SStefan Roese "LEBs)", x, x >> 10, x >> 20, c->log_lebs + c->max_bud_cnt); 730febd7e41SArtem Bityutskiy ubifs_msg("media format: w%d/r%d (latest is w%d/r%d)", 731febd7e41SArtem Bityutskiy c->fmt_version, c->ro_compat_version, 732febd7e41SArtem Bityutskiy UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION); 7339eefe2a2SStefan Roese ubifs_msg("default compressor: %s", ubifs_compr_name(c->default_compr)); 7349eefe2a2SStefan Roese ubifs_msg("reserved for root: %llu bytes (%llu KiB)", 7359eefe2a2SStefan Roese c->report_rp_size, c->report_rp_size >> 10); 7369eefe2a2SStefan Roese 7379eefe2a2SStefan Roese dbg_msg("compiled on: " __DATE__ " at " __TIME__); 7389eefe2a2SStefan Roese dbg_msg("min. I/O unit size: %d bytes", c->min_io_size); 7399eefe2a2SStefan Roese dbg_msg("LEB size: %d bytes (%d KiB)", 7409eefe2a2SStefan Roese c->leb_size, c->leb_size >> 10); 7419eefe2a2SStefan Roese dbg_msg("data journal heads: %d", 7429eefe2a2SStefan Roese c->jhead_cnt - NONDATA_JHEADS_CNT); 7439eefe2a2SStefan Roese dbg_msg("UUID: %02X%02X%02X%02X-%02X%02X" 7449eefe2a2SStefan Roese "-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", 7459eefe2a2SStefan Roese c->uuid[0], c->uuid[1], c->uuid[2], c->uuid[3], 7469eefe2a2SStefan Roese c->uuid[4], c->uuid[5], c->uuid[6], c->uuid[7], 7479eefe2a2SStefan Roese c->uuid[8], c->uuid[9], c->uuid[10], c->uuid[11], 7489eefe2a2SStefan Roese c->uuid[12], c->uuid[13], c->uuid[14], c->uuid[15]); 7499eefe2a2SStefan Roese dbg_msg("big_lpt %d", c->big_lpt); 7509eefe2a2SStefan Roese dbg_msg("log LEBs: %d (%d - %d)", 7519eefe2a2SStefan Roese c->log_lebs, UBIFS_LOG_LNUM, c->log_last); 7529eefe2a2SStefan Roese dbg_msg("LPT area LEBs: %d (%d - %d)", 7539eefe2a2SStefan Roese c->lpt_lebs, c->lpt_first, c->lpt_last); 7549eefe2a2SStefan Roese dbg_msg("orphan area LEBs: %d (%d - %d)", 7559eefe2a2SStefan Roese c->orph_lebs, c->orph_first, c->orph_last); 7569eefe2a2SStefan Roese dbg_msg("main area LEBs: %d (%d - %d)", 7579eefe2a2SStefan Roese c->main_lebs, c->main_first, c->leb_cnt - 1); 7589eefe2a2SStefan Roese dbg_msg("index LEBs: %d", c->lst.idx_lebs); 7599eefe2a2SStefan Roese dbg_msg("total index bytes: %lld (%lld KiB, %lld MiB)", 7609eefe2a2SStefan Roese c->old_idx_sz, c->old_idx_sz >> 10, c->old_idx_sz >> 20); 7619eefe2a2SStefan Roese dbg_msg("key hash type: %d", c->key_hash_type); 7629eefe2a2SStefan Roese dbg_msg("tree fanout: %d", c->fanout); 7639eefe2a2SStefan Roese dbg_msg("reserved GC LEB: %d", c->gc_lnum); 7649eefe2a2SStefan Roese dbg_msg("first main LEB: %d", c->main_first); 7659eefe2a2SStefan Roese dbg_msg("max. znode size %d", c->max_znode_sz); 7669eefe2a2SStefan Roese dbg_msg("max. index node size %d", c->max_idx_node_sz); 7679eefe2a2SStefan Roese dbg_msg("node sizes: data %zu, inode %zu, dentry %zu", 7689eefe2a2SStefan Roese UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ); 7699eefe2a2SStefan Roese dbg_msg("node sizes: trun %zu, sb %zu, master %zu", 7709eefe2a2SStefan Roese UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ); 7719eefe2a2SStefan Roese dbg_msg("node sizes: ref %zu, cmt. start %zu, orph %zu", 7729eefe2a2SStefan Roese UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ); 7739eefe2a2SStefan Roese dbg_msg("max. node sizes: data %zu, inode %zu dentry %zu", 7749eefe2a2SStefan Roese UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ, 7759eefe2a2SStefan Roese UBIFS_MAX_DENT_NODE_SZ); 7769eefe2a2SStefan Roese dbg_msg("dead watermark: %d", c->dead_wm); 7779eefe2a2SStefan Roese dbg_msg("dark watermark: %d", c->dark_wm); 7789eefe2a2SStefan Roese dbg_msg("LEB overhead: %d", c->leb_overhead); 7799eefe2a2SStefan Roese x = (long long)c->main_lebs * c->dark_wm; 7809eefe2a2SStefan Roese dbg_msg("max. dark space: %lld (%lld KiB, %lld MiB)", 7819eefe2a2SStefan Roese x, x >> 10, x >> 20); 7829eefe2a2SStefan Roese dbg_msg("maximum bud bytes: %lld (%lld KiB, %lld MiB)", 7839eefe2a2SStefan Roese c->max_bud_bytes, c->max_bud_bytes >> 10, 7849eefe2a2SStefan Roese c->max_bud_bytes >> 20); 7859eefe2a2SStefan Roese dbg_msg("BG commit bud bytes: %lld (%lld KiB, %lld MiB)", 7869eefe2a2SStefan Roese c->bg_bud_bytes, c->bg_bud_bytes >> 10, 7879eefe2a2SStefan Roese c->bg_bud_bytes >> 20); 7889eefe2a2SStefan Roese dbg_msg("current bud bytes %lld (%lld KiB, %lld MiB)", 7899eefe2a2SStefan Roese c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20); 7909eefe2a2SStefan Roese dbg_msg("max. seq. number: %llu", c->max_sqnum); 7919eefe2a2SStefan Roese dbg_msg("commit number: %llu", c->cmt_no); 7929eefe2a2SStefan Roese 7939eefe2a2SStefan Roese return 0; 7949eefe2a2SStefan Roese 7959eefe2a2SStefan Roese out_infos: 7969eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 7979eefe2a2SStefan Roese list_del(&c->infos_list); 7989eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 7999eefe2a2SStefan Roese out_orphans: 8009eefe2a2SStefan Roese free_orphans(c); 8019eefe2a2SStefan Roese out_journal: 8029eefe2a2SStefan Roese out_lpt: 8039eefe2a2SStefan Roese ubifs_lpt_free(c, 0); 8049eefe2a2SStefan Roese out_master: 8059eefe2a2SStefan Roese kfree(c->mst_node); 8069eefe2a2SStefan Roese kfree(c->rcvrd_mst_node); 8079eefe2a2SStefan Roese if (c->bgt) 8089eefe2a2SStefan Roese kthread_stop(c->bgt); 8099eefe2a2SStefan Roese kfree(c->cbuf); 8109eefe2a2SStefan Roese out_free: 8119eefe2a2SStefan Roese vfree(c->ileb_buf); 8129eefe2a2SStefan Roese vfree(c->sbuf); 8139eefe2a2SStefan Roese kfree(c->bottom_up_buf); 8149eefe2a2SStefan Roese ubifs_debugging_exit(c); 8159eefe2a2SStefan Roese return err; 8169eefe2a2SStefan Roese } 8179eefe2a2SStefan Roese 8189eefe2a2SStefan Roese /** 8199eefe2a2SStefan Roese * ubifs_umount - un-mount UBIFS file-system. 8209eefe2a2SStefan Roese * @c: UBIFS file-system description object 8219eefe2a2SStefan Roese * 8229eefe2a2SStefan Roese * Note, this function is called to free allocated resourced when un-mounting, 8239eefe2a2SStefan Roese * as well as free resources when an error occurred while we were half way 8249eefe2a2SStefan Roese * through mounting (error path cleanup function). So it has to make sure the 8259eefe2a2SStefan Roese * resource was actually allocated before freeing it. 8269eefe2a2SStefan Roese */ 827cb9c09d4SStefan Roese void ubifs_umount(struct ubifs_info *c) 8289eefe2a2SStefan Roese { 8299eefe2a2SStefan Roese dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num, 8309eefe2a2SStefan Roese c->vi.vol_id); 8319eefe2a2SStefan Roese 8329eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 8339eefe2a2SStefan Roese list_del(&c->infos_list); 8349eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 8359eefe2a2SStefan Roese 8369eefe2a2SStefan Roese if (c->bgt) 8379eefe2a2SStefan Roese kthread_stop(c->bgt); 8389eefe2a2SStefan Roese 8399eefe2a2SStefan Roese free_orphans(c); 8409eefe2a2SStefan Roese ubifs_lpt_free(c, 0); 8419eefe2a2SStefan Roese 8429eefe2a2SStefan Roese kfree(c->cbuf); 8439eefe2a2SStefan Roese kfree(c->rcvrd_mst_node); 8449eefe2a2SStefan Roese kfree(c->mst_node); 8459eefe2a2SStefan Roese vfree(c->ileb_buf); 8469eefe2a2SStefan Roese vfree(c->sbuf); 8479eefe2a2SStefan Roese kfree(c->bottom_up_buf); 8489eefe2a2SStefan Roese ubifs_debugging_exit(c); 8499eefe2a2SStefan Roese 8509eefe2a2SStefan Roese /* Finally free U-Boot's global copy of superblock */ 851*349a8d5eSLars Poeschel if (ubifs_sb != NULL) { 8529eefe2a2SStefan Roese free(ubifs_sb->s_fs_info); 8539eefe2a2SStefan Roese free(ubifs_sb); 8549eefe2a2SStefan Roese } 855*349a8d5eSLars Poeschel } 8569eefe2a2SStefan Roese 8579eefe2a2SStefan Roese /** 8589eefe2a2SStefan Roese * open_ubi - parse UBI device name string and open the UBI device. 8599eefe2a2SStefan Roese * @name: UBI volume name 8609eefe2a2SStefan Roese * @mode: UBI volume open mode 8619eefe2a2SStefan Roese * 8629eefe2a2SStefan Roese * There are several ways to specify UBI volumes when mounting UBIFS: 8639eefe2a2SStefan Roese * o ubiX_Y - UBI device number X, volume Y; 8649eefe2a2SStefan Roese * o ubiY - UBI device number 0, volume Y; 8659eefe2a2SStefan Roese * o ubiX:NAME - mount UBI device X, volume with name NAME; 8669eefe2a2SStefan Roese * o ubi:NAME - mount UBI device 0, volume with name NAME. 8679eefe2a2SStefan Roese * 8689eefe2a2SStefan Roese * Alternative '!' separator may be used instead of ':' (because some shells 8699eefe2a2SStefan Roese * like busybox may interpret ':' as an NFS host name separator). This function 8709eefe2a2SStefan Roese * returns ubi volume object in case of success and a negative error code in 8719eefe2a2SStefan Roese * case of failure. 8729eefe2a2SStefan Roese */ 8739eefe2a2SStefan Roese static struct ubi_volume_desc *open_ubi(const char *name, int mode) 8749eefe2a2SStefan Roese { 8759eefe2a2SStefan Roese int dev, vol; 8769eefe2a2SStefan Roese char *endptr; 8779eefe2a2SStefan Roese 8789eefe2a2SStefan Roese if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i') 8799eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 8809eefe2a2SStefan Roese 8819eefe2a2SStefan Roese /* ubi:NAME method */ 8829eefe2a2SStefan Roese if ((name[3] == ':' || name[3] == '!') && name[4] != '\0') 8839eefe2a2SStefan Roese return ubi_open_volume_nm(0, name + 4, mode); 8849eefe2a2SStefan Roese 8859eefe2a2SStefan Roese if (!isdigit(name[3])) 8869eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 8879eefe2a2SStefan Roese 8889eefe2a2SStefan Roese dev = simple_strtoul(name + 3, &endptr, 0); 8899eefe2a2SStefan Roese 8909eefe2a2SStefan Roese /* ubiY method */ 8919eefe2a2SStefan Roese if (*endptr == '\0') 8929eefe2a2SStefan Roese return ubi_open_volume(0, dev, mode); 8939eefe2a2SStefan Roese 8949eefe2a2SStefan Roese /* ubiX_Y method */ 8959eefe2a2SStefan Roese if (*endptr == '_' && isdigit(endptr[1])) { 8969eefe2a2SStefan Roese vol = simple_strtoul(endptr + 1, &endptr, 0); 8979eefe2a2SStefan Roese if (*endptr != '\0') 8989eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 8999eefe2a2SStefan Roese return ubi_open_volume(dev, vol, mode); 9009eefe2a2SStefan Roese } 9019eefe2a2SStefan Roese 9029eefe2a2SStefan Roese /* ubiX:NAME method */ 9039eefe2a2SStefan Roese if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0') 9049eefe2a2SStefan Roese return ubi_open_volume_nm(dev, ++endptr, mode); 9059eefe2a2SStefan Roese 9069eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 9079eefe2a2SStefan Roese } 9089eefe2a2SStefan Roese 9099eefe2a2SStefan Roese static int ubifs_fill_super(struct super_block *sb, void *data, int silent) 9109eefe2a2SStefan Roese { 9119eefe2a2SStefan Roese struct ubi_volume_desc *ubi = sb->s_fs_info; 9129eefe2a2SStefan Roese struct ubifs_info *c; 9139eefe2a2SStefan Roese struct inode *root; 9149eefe2a2SStefan Roese int err; 9159eefe2a2SStefan Roese 9169eefe2a2SStefan Roese c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL); 9179eefe2a2SStefan Roese if (!c) 9189eefe2a2SStefan Roese return -ENOMEM; 9199eefe2a2SStefan Roese 9209eefe2a2SStefan Roese spin_lock_init(&c->cnt_lock); 9219eefe2a2SStefan Roese spin_lock_init(&c->cs_lock); 9229eefe2a2SStefan Roese spin_lock_init(&c->buds_lock); 9239eefe2a2SStefan Roese spin_lock_init(&c->space_lock); 9249eefe2a2SStefan Roese spin_lock_init(&c->orphan_lock); 9259eefe2a2SStefan Roese init_rwsem(&c->commit_sem); 9269eefe2a2SStefan Roese mutex_init(&c->lp_mutex); 9279eefe2a2SStefan Roese mutex_init(&c->tnc_mutex); 9289eefe2a2SStefan Roese mutex_init(&c->log_mutex); 9299eefe2a2SStefan Roese mutex_init(&c->mst_mutex); 9309eefe2a2SStefan Roese mutex_init(&c->umount_mutex); 9319eefe2a2SStefan Roese init_waitqueue_head(&c->cmt_wq); 9329eefe2a2SStefan Roese c->buds = RB_ROOT; 9339eefe2a2SStefan Roese c->old_idx = RB_ROOT; 9349eefe2a2SStefan Roese c->size_tree = RB_ROOT; 9359eefe2a2SStefan Roese c->orph_tree = RB_ROOT; 9369eefe2a2SStefan Roese INIT_LIST_HEAD(&c->infos_list); 9379eefe2a2SStefan Roese INIT_LIST_HEAD(&c->idx_gc); 9389eefe2a2SStefan Roese INIT_LIST_HEAD(&c->replay_list); 9399eefe2a2SStefan Roese INIT_LIST_HEAD(&c->replay_buds); 9409eefe2a2SStefan Roese INIT_LIST_HEAD(&c->uncat_list); 9419eefe2a2SStefan Roese INIT_LIST_HEAD(&c->empty_list); 9429eefe2a2SStefan Roese INIT_LIST_HEAD(&c->freeable_list); 9439eefe2a2SStefan Roese INIT_LIST_HEAD(&c->frdi_idx_list); 9449eefe2a2SStefan Roese INIT_LIST_HEAD(&c->unclean_leb_list); 9459eefe2a2SStefan Roese INIT_LIST_HEAD(&c->old_buds); 9469eefe2a2SStefan Roese INIT_LIST_HEAD(&c->orph_list); 9479eefe2a2SStefan Roese INIT_LIST_HEAD(&c->orph_new); 9489eefe2a2SStefan Roese 9499eefe2a2SStefan Roese c->highest_inum = UBIFS_FIRST_INO; 9509eefe2a2SStefan Roese c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM; 9519eefe2a2SStefan Roese 9529eefe2a2SStefan Roese ubi_get_volume_info(ubi, &c->vi); 9539eefe2a2SStefan Roese ubi_get_device_info(c->vi.ubi_num, &c->di); 9549eefe2a2SStefan Roese 9559eefe2a2SStefan Roese /* Re-open the UBI device in read-write mode */ 9569eefe2a2SStefan Roese c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY); 9579eefe2a2SStefan Roese if (IS_ERR(c->ubi)) { 9589eefe2a2SStefan Roese err = PTR_ERR(c->ubi); 9599eefe2a2SStefan Roese goto out_free; 9609eefe2a2SStefan Roese } 9619eefe2a2SStefan Roese 9629eefe2a2SStefan Roese c->vfs_sb = sb; 9639eefe2a2SStefan Roese 9649eefe2a2SStefan Roese sb->s_fs_info = c; 9659eefe2a2SStefan Roese sb->s_magic = UBIFS_SUPER_MAGIC; 9669eefe2a2SStefan Roese sb->s_blocksize = UBIFS_BLOCK_SIZE; 9679eefe2a2SStefan Roese sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT; 9689eefe2a2SStefan Roese sb->s_dev = c->vi.cdev; 9699eefe2a2SStefan Roese sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c); 9709eefe2a2SStefan Roese if (c->max_inode_sz > MAX_LFS_FILESIZE) 9719eefe2a2SStefan Roese sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE; 9729eefe2a2SStefan Roese 973febd7e41SArtem Bityutskiy if (c->rw_incompat) { 974febd7e41SArtem Bityutskiy ubifs_err("the file-system is not R/W-compatible"); 975febd7e41SArtem Bityutskiy ubifs_msg("on-flash format version is w%d/r%d, but software " 976febd7e41SArtem Bityutskiy "only supports up to version w%d/r%d", c->fmt_version, 977febd7e41SArtem Bityutskiy c->ro_compat_version, UBIFS_FORMAT_VERSION, 978febd7e41SArtem Bityutskiy UBIFS_RO_COMPAT_VERSION); 979febd7e41SArtem Bityutskiy return -EROFS; 980febd7e41SArtem Bityutskiy } 981febd7e41SArtem Bityutskiy 9829eefe2a2SStefan Roese mutex_lock(&c->umount_mutex); 9839eefe2a2SStefan Roese err = mount_ubifs(c); 9849eefe2a2SStefan Roese if (err) { 9859eefe2a2SStefan Roese ubifs_assert(err < 0); 9869eefe2a2SStefan Roese goto out_unlock; 9879eefe2a2SStefan Roese } 9889eefe2a2SStefan Roese 9899eefe2a2SStefan Roese /* Read the root inode */ 9909eefe2a2SStefan Roese root = ubifs_iget(sb, UBIFS_ROOT_INO); 9919eefe2a2SStefan Roese if (IS_ERR(root)) { 9929eefe2a2SStefan Roese err = PTR_ERR(root); 9939eefe2a2SStefan Roese goto out_umount; 9949eefe2a2SStefan Roese } 9959eefe2a2SStefan Roese 9969eefe2a2SStefan Roese sb->s_root = NULL; 9979eefe2a2SStefan Roese 9989eefe2a2SStefan Roese mutex_unlock(&c->umount_mutex); 9999eefe2a2SStefan Roese return 0; 10009eefe2a2SStefan Roese 10019eefe2a2SStefan Roese out_umount: 10029eefe2a2SStefan Roese ubifs_umount(c); 10039eefe2a2SStefan Roese out_unlock: 10049eefe2a2SStefan Roese mutex_unlock(&c->umount_mutex); 10059eefe2a2SStefan Roese ubi_close_volume(c->ubi); 10069eefe2a2SStefan Roese out_free: 10079eefe2a2SStefan Roese kfree(c); 10089eefe2a2SStefan Roese return err; 10099eefe2a2SStefan Roese } 10109eefe2a2SStefan Roese 10119eefe2a2SStefan Roese static int sb_test(struct super_block *sb, void *data) 10129eefe2a2SStefan Roese { 10139eefe2a2SStefan Roese dev_t *dev = data; 10149eefe2a2SStefan Roese 10159eefe2a2SStefan Roese return sb->s_dev == *dev; 10169eefe2a2SStefan Roese } 10179eefe2a2SStefan Roese 10189eefe2a2SStefan Roese static int ubifs_get_sb(struct file_system_type *fs_type, int flags, 10199eefe2a2SStefan Roese const char *name, void *data, struct vfsmount *mnt) 10209eefe2a2SStefan Roese { 10219eefe2a2SStefan Roese struct ubi_volume_desc *ubi; 10229eefe2a2SStefan Roese struct ubi_volume_info vi; 10239eefe2a2SStefan Roese struct super_block *sb; 10249eefe2a2SStefan Roese int err; 10259eefe2a2SStefan Roese 10269eefe2a2SStefan Roese dbg_gen("name %s, flags %#x", name, flags); 10279eefe2a2SStefan Roese 10289eefe2a2SStefan Roese /* 10299eefe2a2SStefan Roese * Get UBI device number and volume ID. Mount it read-only so far 10309eefe2a2SStefan Roese * because this might be a new mount point, and UBI allows only one 10319eefe2a2SStefan Roese * read-write user at a time. 10329eefe2a2SStefan Roese */ 10339eefe2a2SStefan Roese ubi = open_ubi(name, UBI_READONLY); 10349eefe2a2SStefan Roese if (IS_ERR(ubi)) { 10359eefe2a2SStefan Roese ubifs_err("cannot open \"%s\", error %d", 10369eefe2a2SStefan Roese name, (int)PTR_ERR(ubi)); 10379eefe2a2SStefan Roese return PTR_ERR(ubi); 10389eefe2a2SStefan Roese } 10399eefe2a2SStefan Roese ubi_get_volume_info(ubi, &vi); 10409eefe2a2SStefan Roese 10419eefe2a2SStefan Roese dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id); 10429eefe2a2SStefan Roese 10439eefe2a2SStefan Roese sb = sget(fs_type, &sb_test, &sb_set, &vi.cdev); 10449eefe2a2SStefan Roese if (IS_ERR(sb)) { 10459eefe2a2SStefan Roese err = PTR_ERR(sb); 10469eefe2a2SStefan Roese goto out_close; 10479eefe2a2SStefan Roese } 10489eefe2a2SStefan Roese 10499eefe2a2SStefan Roese if (sb->s_root) { 10509eefe2a2SStefan Roese /* A new mount point for already mounted UBIFS */ 10519eefe2a2SStefan Roese dbg_gen("this ubi volume is already mounted"); 10529eefe2a2SStefan Roese if ((flags ^ sb->s_flags) & MS_RDONLY) { 10539eefe2a2SStefan Roese err = -EBUSY; 10549eefe2a2SStefan Roese goto out_deact; 10559eefe2a2SStefan Roese } 10569eefe2a2SStefan Roese } else { 10579eefe2a2SStefan Roese sb->s_flags = flags; 10589eefe2a2SStefan Roese /* 10599eefe2a2SStefan Roese * Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is 10609eefe2a2SStefan Roese * replaced by 'c'. 10619eefe2a2SStefan Roese */ 10629eefe2a2SStefan Roese sb->s_fs_info = ubi; 10639eefe2a2SStefan Roese err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 10649eefe2a2SStefan Roese if (err) 10659eefe2a2SStefan Roese goto out_deact; 10669eefe2a2SStefan Roese /* We do not support atime */ 10679eefe2a2SStefan Roese sb->s_flags |= MS_ACTIVE | MS_NOATIME; 10689eefe2a2SStefan Roese } 10699eefe2a2SStefan Roese 10709eefe2a2SStefan Roese /* 'fill_super()' opens ubi again so we must close it here */ 10719eefe2a2SStefan Roese ubi_close_volume(ubi); 10729eefe2a2SStefan Roese 10739eefe2a2SStefan Roese ubifs_sb = sb; 10749eefe2a2SStefan Roese return 0; 10759eefe2a2SStefan Roese 10769eefe2a2SStefan Roese out_deact: 10779eefe2a2SStefan Roese up_write(&sb->s_umount); 10789eefe2a2SStefan Roese out_close: 10799eefe2a2SStefan Roese ubi_close_volume(ubi); 10809eefe2a2SStefan Roese return err; 10819eefe2a2SStefan Roese } 10829eefe2a2SStefan Roese 10839eefe2a2SStefan Roese int __init ubifs_init(void) 10849eefe2a2SStefan Roese { 10859eefe2a2SStefan Roese int err; 10869eefe2a2SStefan Roese 10879eefe2a2SStefan Roese BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24); 10889eefe2a2SStefan Roese 10899eefe2a2SStefan Roese /* Make sure node sizes are 8-byte aligned */ 10909eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_CH_SZ & 7); 10919eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ & 7); 10929eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7); 10939eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7); 10949eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7); 10959eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7); 10969eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_SB_NODE_SZ & 7); 10979eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MST_NODE_SZ & 7); 10989eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_REF_NODE_SZ & 7); 10999eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_CS_NODE_SZ & 7); 11009eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7); 11019eefe2a2SStefan Roese 11029eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7); 11039eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7); 11049eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7); 11059eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ & 7); 11069eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_NODE_SZ & 7); 11079eefe2a2SStefan Roese BUILD_BUG_ON(MIN_WRITE_SZ & 7); 11089eefe2a2SStefan Roese 11099eefe2a2SStefan Roese /* Check min. node size */ 11109eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ < MIN_WRITE_SZ); 11119eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ); 11129eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ); 11139eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ); 11149eefe2a2SStefan Roese 11159eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 11169eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 11179eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ); 11189eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ > UBIFS_MAX_NODE_SZ); 11199eefe2a2SStefan Roese 11209eefe2a2SStefan Roese /* Defined node sizes */ 11219eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_SB_NODE_SZ != 4096); 11229eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512); 11239eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160); 11249eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64); 11259eefe2a2SStefan Roese 11269eefe2a2SStefan Roese /* 11279eefe2a2SStefan Roese * We use 2 bit wide bit-fields to store compression type, which should 11289eefe2a2SStefan Roese * be amended if more compressors are added. The bit-fields are: 11299eefe2a2SStefan Roese * @compr_type in 'struct ubifs_inode', @default_compr in 11309eefe2a2SStefan Roese * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'. 11319eefe2a2SStefan Roese */ 11329eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4); 11339eefe2a2SStefan Roese 11349eefe2a2SStefan Roese /* 11359eefe2a2SStefan Roese * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to 11369eefe2a2SStefan Roese * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2. 11379eefe2a2SStefan Roese */ 11389eefe2a2SStefan Roese if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) { 11399eefe2a2SStefan Roese ubifs_err("VFS page cache size is %u bytes, but UBIFS requires" 11409eefe2a2SStefan Roese " at least 4096 bytes", 11419eefe2a2SStefan Roese (unsigned int)PAGE_CACHE_SIZE); 11429eefe2a2SStefan Roese return -EINVAL; 11439eefe2a2SStefan Roese } 11449eefe2a2SStefan Roese 11459eefe2a2SStefan Roese err = -ENOMEM; 11469eefe2a2SStefan Roese 11479eefe2a2SStefan Roese err = ubifs_compressors_init(); 11489eefe2a2SStefan Roese if (err) 11499eefe2a2SStefan Roese goto out_shrinker; 11509eefe2a2SStefan Roese 11519eefe2a2SStefan Roese return 0; 11529eefe2a2SStefan Roese 11539eefe2a2SStefan Roese out_shrinker: 11549eefe2a2SStefan Roese return err; 11559eefe2a2SStefan Roese } 11569eefe2a2SStefan Roese 11579eefe2a2SStefan Roese /* 11589eefe2a2SStefan Roese * ubifsmount... 11599eefe2a2SStefan Roese */ 11609eefe2a2SStefan Roese 11619eefe2a2SStefan Roese static struct file_system_type ubifs_fs_type = { 11629eefe2a2SStefan Roese .name = "ubifs", 11639eefe2a2SStefan Roese .owner = THIS_MODULE, 11649eefe2a2SStefan Roese .get_sb = ubifs_get_sb, 11659eefe2a2SStefan Roese }; 11669eefe2a2SStefan Roese 11679eefe2a2SStefan Roese int ubifs_mount(char *vol_name) 11689eefe2a2SStefan Roese { 11699eefe2a2SStefan Roese int flags; 11709eefe2a2SStefan Roese char name[80] = "ubi:"; 11719eefe2a2SStefan Roese void *data; 11729eefe2a2SStefan Roese struct vfsmount *mnt; 11739eefe2a2SStefan Roese int ret; 11749eefe2a2SStefan Roese struct ubifs_info *c; 11759eefe2a2SStefan Roese 11769eefe2a2SStefan Roese /* 11779eefe2a2SStefan Roese * First unmount if allready mounted 11789eefe2a2SStefan Roese */ 11799eefe2a2SStefan Roese if (ubifs_sb) 11809eefe2a2SStefan Roese ubifs_umount(ubifs_sb->s_fs_info); 11819eefe2a2SStefan Roese 11829eefe2a2SStefan Roese INIT_LIST_HEAD(&ubifs_infos); 118368651683SStefano Babic INIT_LIST_HEAD(&ubifs_fs_type.fs_supers); 11849eefe2a2SStefan Roese 11859eefe2a2SStefan Roese /* 11869eefe2a2SStefan Roese * Mount in read-only mode 11879eefe2a2SStefan Roese */ 11889eefe2a2SStefan Roese flags = MS_RDONLY; 11899eefe2a2SStefan Roese strcat(name, vol_name); 11909eefe2a2SStefan Roese data = NULL; 11919eefe2a2SStefan Roese mnt = NULL; 11929eefe2a2SStefan Roese ret = ubifs_get_sb(&ubifs_fs_type, flags, name, data, mnt); 11939eefe2a2SStefan Roese if (ret) { 11949eefe2a2SStefan Roese printf("Error reading superblock on volume '%s'!\n", name); 11959eefe2a2SStefan Roese return -1; 11969eefe2a2SStefan Roese } 11979eefe2a2SStefan Roese 11989eefe2a2SStefan Roese c = ubifs_sb->s_fs_info; 11999eefe2a2SStefan Roese ubi_close_volume(c->ubi); 12009eefe2a2SStefan Roese 12019eefe2a2SStefan Roese return 0; 12029eefe2a2SStefan Roese } 1203