1*9eefe2a2SStefan Roese /* 2*9eefe2a2SStefan Roese * This file is part of UBIFS. 3*9eefe2a2SStefan Roese * 4*9eefe2a2SStefan Roese * Copyright (C) 2006-2008 Nokia Corporation. 5*9eefe2a2SStefan Roese * 6*9eefe2a2SStefan Roese * This program is free software; you can redistribute it and/or modify it 7*9eefe2a2SStefan Roese * under the terms of the GNU General Public License version 2 as published by 8*9eefe2a2SStefan Roese * the Free Software Foundation. 9*9eefe2a2SStefan Roese * 10*9eefe2a2SStefan Roese * This program is distributed in the hope that it will be useful, but WITHOUT 11*9eefe2a2SStefan Roese * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12*9eefe2a2SStefan Roese * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13*9eefe2a2SStefan Roese * more details. 14*9eefe2a2SStefan Roese * 15*9eefe2a2SStefan Roese * You should have received a copy of the GNU General Public License along with 16*9eefe2a2SStefan Roese * this program; if not, write to the Free Software Foundation, Inc., 51 17*9eefe2a2SStefan Roese * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18*9eefe2a2SStefan Roese * 19*9eefe2a2SStefan Roese * Authors: Artem Bityutskiy (Битюцкий Артём) 20*9eefe2a2SStefan Roese * Adrian Hunter 21*9eefe2a2SStefan Roese */ 22*9eefe2a2SStefan Roese 23*9eefe2a2SStefan Roese /* 24*9eefe2a2SStefan Roese * This file implements UBIFS initialization and VFS superblock operations. Some 25*9eefe2a2SStefan Roese * initialization stuff which is rather large and complex is placed at 26*9eefe2a2SStefan Roese * corresponding subsystems, but most of it is here. 27*9eefe2a2SStefan Roese */ 28*9eefe2a2SStefan Roese 29*9eefe2a2SStefan Roese #include "ubifs.h" 30*9eefe2a2SStefan Roese #include <linux/math64.h> 31*9eefe2a2SStefan Roese 32*9eefe2a2SStefan Roese #define INODE_LOCKED_MAX 64 33*9eefe2a2SStefan Roese 34*9eefe2a2SStefan Roese struct super_block *ubifs_sb; 35*9eefe2a2SStefan Roese static struct inode *inodes_locked_down[INODE_LOCKED_MAX]; 36*9eefe2a2SStefan Roese 37*9eefe2a2SStefan Roese /* shrinker.c */ 38*9eefe2a2SStefan Roese 39*9eefe2a2SStefan Roese /* List of all UBIFS file-system instances */ 40*9eefe2a2SStefan Roese struct list_head ubifs_infos; 41*9eefe2a2SStefan Roese 42*9eefe2a2SStefan Roese /* linux/fs/super.c */ 43*9eefe2a2SStefan Roese 44*9eefe2a2SStefan Roese static int sb_set(struct super_block *sb, void *data) 45*9eefe2a2SStefan Roese { 46*9eefe2a2SStefan Roese dev_t *dev = data; 47*9eefe2a2SStefan Roese 48*9eefe2a2SStefan Roese sb->s_dev = *dev; 49*9eefe2a2SStefan Roese return 0; 50*9eefe2a2SStefan Roese } 51*9eefe2a2SStefan Roese 52*9eefe2a2SStefan Roese /** 53*9eefe2a2SStefan Roese * sget - find or create a superblock 54*9eefe2a2SStefan Roese * @type: filesystem type superblock should belong to 55*9eefe2a2SStefan Roese * @test: comparison callback 56*9eefe2a2SStefan Roese * @set: setup callback 57*9eefe2a2SStefan Roese * @data: argument to each of them 58*9eefe2a2SStefan Roese */ 59*9eefe2a2SStefan Roese struct super_block *sget(struct file_system_type *type, 60*9eefe2a2SStefan Roese int (*test)(struct super_block *,void *), 61*9eefe2a2SStefan Roese int (*set)(struct super_block *,void *), 62*9eefe2a2SStefan Roese void *data) 63*9eefe2a2SStefan Roese { 64*9eefe2a2SStefan Roese struct super_block *s = NULL; 65*9eefe2a2SStefan Roese int err; 66*9eefe2a2SStefan Roese 67*9eefe2a2SStefan Roese s = kzalloc(sizeof(struct super_block), GFP_USER); 68*9eefe2a2SStefan Roese if (!s) { 69*9eefe2a2SStefan Roese err = -ENOMEM; 70*9eefe2a2SStefan Roese return ERR_PTR(err); 71*9eefe2a2SStefan Roese } 72*9eefe2a2SStefan Roese 73*9eefe2a2SStefan Roese INIT_LIST_HEAD(&s->s_instances); 74*9eefe2a2SStefan Roese INIT_LIST_HEAD(&s->s_inodes); 75*9eefe2a2SStefan Roese s->s_time_gran = 1000000000; 76*9eefe2a2SStefan Roese 77*9eefe2a2SStefan Roese err = set(s, data); 78*9eefe2a2SStefan Roese if (err) { 79*9eefe2a2SStefan Roese return ERR_PTR(err); 80*9eefe2a2SStefan Roese } 81*9eefe2a2SStefan Roese s->s_type = type; 82*9eefe2a2SStefan Roese strncpy(s->s_id, type->name, sizeof(s->s_id)); 83*9eefe2a2SStefan Roese list_add(&s->s_instances, &type->fs_supers); 84*9eefe2a2SStefan Roese return s; 85*9eefe2a2SStefan Roese } 86*9eefe2a2SStefan Roese 87*9eefe2a2SStefan Roese /** 88*9eefe2a2SStefan Roese * validate_inode - validate inode. 89*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 90*9eefe2a2SStefan Roese * @inode: the inode to validate 91*9eefe2a2SStefan Roese * 92*9eefe2a2SStefan Roese * This is a helper function for 'ubifs_iget()' which validates various fields 93*9eefe2a2SStefan Roese * of a newly built inode to make sure they contain sane values and prevent 94*9eefe2a2SStefan Roese * possible vulnerabilities. Returns zero if the inode is all right and 95*9eefe2a2SStefan Roese * a non-zero error code if not. 96*9eefe2a2SStefan Roese */ 97*9eefe2a2SStefan Roese static int validate_inode(struct ubifs_info *c, const struct inode *inode) 98*9eefe2a2SStefan Roese { 99*9eefe2a2SStefan Roese int err; 100*9eefe2a2SStefan Roese const struct ubifs_inode *ui = ubifs_inode(inode); 101*9eefe2a2SStefan Roese 102*9eefe2a2SStefan Roese if (inode->i_size > c->max_inode_sz) { 103*9eefe2a2SStefan Roese ubifs_err("inode is too large (%lld)", 104*9eefe2a2SStefan Roese (long long)inode->i_size); 105*9eefe2a2SStefan Roese return 1; 106*9eefe2a2SStefan Roese } 107*9eefe2a2SStefan Roese 108*9eefe2a2SStefan Roese if (ui->compr_type < 0 || ui->compr_type >= UBIFS_COMPR_TYPES_CNT) { 109*9eefe2a2SStefan Roese ubifs_err("unknown compression type %d", ui->compr_type); 110*9eefe2a2SStefan Roese return 2; 111*9eefe2a2SStefan Roese } 112*9eefe2a2SStefan Roese 113*9eefe2a2SStefan Roese if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA) 114*9eefe2a2SStefan Roese return 4; 115*9eefe2a2SStefan Roese 116*9eefe2a2SStefan Roese if (!ubifs_compr_present(ui->compr_type)) { 117*9eefe2a2SStefan Roese ubifs_warn("inode %lu uses '%s' compression, but it was not " 118*9eefe2a2SStefan Roese "compiled in", inode->i_ino, 119*9eefe2a2SStefan Roese ubifs_compr_name(ui->compr_type)); 120*9eefe2a2SStefan Roese } 121*9eefe2a2SStefan Roese 122*9eefe2a2SStefan Roese err = dbg_check_dir_size(c, inode); 123*9eefe2a2SStefan Roese return err; 124*9eefe2a2SStefan Roese } 125*9eefe2a2SStefan Roese 126*9eefe2a2SStefan Roese struct inode *iget_locked(struct super_block *sb, unsigned long ino) 127*9eefe2a2SStefan Roese { 128*9eefe2a2SStefan Roese struct inode *inode; 129*9eefe2a2SStefan Roese 130*9eefe2a2SStefan Roese inode = (struct inode *)malloc(sizeof(struct ubifs_inode)); 131*9eefe2a2SStefan Roese if (inode) { 132*9eefe2a2SStefan Roese inode->i_ino = ino; 133*9eefe2a2SStefan Roese inode->i_sb = sb; 134*9eefe2a2SStefan Roese list_add(&inode->i_sb_list, &sb->s_inodes); 135*9eefe2a2SStefan Roese inode->i_state = I_LOCK | I_NEW; 136*9eefe2a2SStefan Roese } 137*9eefe2a2SStefan Roese 138*9eefe2a2SStefan Roese return inode; 139*9eefe2a2SStefan Roese } 140*9eefe2a2SStefan Roese 141*9eefe2a2SStefan Roese int ubifs_iput(struct inode *inode) 142*9eefe2a2SStefan Roese { 143*9eefe2a2SStefan Roese list_del_init(&inode->i_sb_list); 144*9eefe2a2SStefan Roese 145*9eefe2a2SStefan Roese free(inode); 146*9eefe2a2SStefan Roese return 0; 147*9eefe2a2SStefan Roese } 148*9eefe2a2SStefan Roese 149*9eefe2a2SStefan Roese /* 150*9eefe2a2SStefan Roese * Lock (save) inode in inode array for readback after recovery 151*9eefe2a2SStefan Roese */ 152*9eefe2a2SStefan Roese void iput(struct inode *inode) 153*9eefe2a2SStefan Roese { 154*9eefe2a2SStefan Roese int i; 155*9eefe2a2SStefan Roese struct inode *ino; 156*9eefe2a2SStefan Roese 157*9eefe2a2SStefan Roese /* 158*9eefe2a2SStefan Roese * Search end of list 159*9eefe2a2SStefan Roese */ 160*9eefe2a2SStefan Roese for (i = 0; i < INODE_LOCKED_MAX; i++) { 161*9eefe2a2SStefan Roese if (inodes_locked_down[i] == NULL) 162*9eefe2a2SStefan Roese break; 163*9eefe2a2SStefan Roese } 164*9eefe2a2SStefan Roese 165*9eefe2a2SStefan Roese if (i >= INODE_LOCKED_MAX) { 166*9eefe2a2SStefan Roese ubifs_err("Error, can't lock (save) more inodes while recovery!!!"); 167*9eefe2a2SStefan Roese return; 168*9eefe2a2SStefan Roese } 169*9eefe2a2SStefan Roese 170*9eefe2a2SStefan Roese /* 171*9eefe2a2SStefan Roese * Allocate and use new inode 172*9eefe2a2SStefan Roese */ 173*9eefe2a2SStefan Roese ino = (struct inode *)malloc(sizeof(struct ubifs_inode)); 174*9eefe2a2SStefan Roese memcpy(ino, inode, sizeof(struct ubifs_inode)); 175*9eefe2a2SStefan Roese 176*9eefe2a2SStefan Roese /* 177*9eefe2a2SStefan Roese * Finally save inode in array 178*9eefe2a2SStefan Roese */ 179*9eefe2a2SStefan Roese inodes_locked_down[i] = ino; 180*9eefe2a2SStefan Roese } 181*9eefe2a2SStefan Roese 182*9eefe2a2SStefan Roese struct inode *ubifs_iget(struct super_block *sb, unsigned long inum) 183*9eefe2a2SStefan Roese { 184*9eefe2a2SStefan Roese int err; 185*9eefe2a2SStefan Roese union ubifs_key key; 186*9eefe2a2SStefan Roese struct ubifs_ino_node *ino; 187*9eefe2a2SStefan Roese struct ubifs_info *c = sb->s_fs_info; 188*9eefe2a2SStefan Roese struct inode *inode; 189*9eefe2a2SStefan Roese struct ubifs_inode *ui; 190*9eefe2a2SStefan Roese int i; 191*9eefe2a2SStefan Roese 192*9eefe2a2SStefan Roese dbg_gen("inode %lu", inum); 193*9eefe2a2SStefan Roese 194*9eefe2a2SStefan Roese /* 195*9eefe2a2SStefan Roese * U-Boot special handling of locked down inodes via recovery 196*9eefe2a2SStefan Roese * e.g. ubifs_recover_size() 197*9eefe2a2SStefan Roese */ 198*9eefe2a2SStefan Roese for (i = 0; i < INODE_LOCKED_MAX; i++) { 199*9eefe2a2SStefan Roese /* 200*9eefe2a2SStefan Roese * Exit on last entry (NULL), inode not found in list 201*9eefe2a2SStefan Roese */ 202*9eefe2a2SStefan Roese if (inodes_locked_down[i] == NULL) 203*9eefe2a2SStefan Roese break; 204*9eefe2a2SStefan Roese 205*9eefe2a2SStefan Roese if (inodes_locked_down[i]->i_ino == inum) { 206*9eefe2a2SStefan Roese /* 207*9eefe2a2SStefan Roese * We found the locked down inode in our array, 208*9eefe2a2SStefan Roese * so just return this pointer instead of creating 209*9eefe2a2SStefan Roese * a new one. 210*9eefe2a2SStefan Roese */ 211*9eefe2a2SStefan Roese return inodes_locked_down[i]; 212*9eefe2a2SStefan Roese } 213*9eefe2a2SStefan Roese } 214*9eefe2a2SStefan Roese 215*9eefe2a2SStefan Roese inode = iget_locked(sb, inum); 216*9eefe2a2SStefan Roese if (!inode) 217*9eefe2a2SStefan Roese return ERR_PTR(-ENOMEM); 218*9eefe2a2SStefan Roese if (!(inode->i_state & I_NEW)) 219*9eefe2a2SStefan Roese return inode; 220*9eefe2a2SStefan Roese ui = ubifs_inode(inode); 221*9eefe2a2SStefan Roese 222*9eefe2a2SStefan Roese ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS); 223*9eefe2a2SStefan Roese if (!ino) { 224*9eefe2a2SStefan Roese err = -ENOMEM; 225*9eefe2a2SStefan Roese goto out; 226*9eefe2a2SStefan Roese } 227*9eefe2a2SStefan Roese 228*9eefe2a2SStefan Roese ino_key_init(c, &key, inode->i_ino); 229*9eefe2a2SStefan Roese 230*9eefe2a2SStefan Roese err = ubifs_tnc_lookup(c, &key, ino); 231*9eefe2a2SStefan Roese if (err) 232*9eefe2a2SStefan Roese goto out_ino; 233*9eefe2a2SStefan Roese 234*9eefe2a2SStefan Roese inode->i_flags |= (S_NOCMTIME | S_NOATIME); 235*9eefe2a2SStefan Roese inode->i_nlink = le32_to_cpu(ino->nlink); 236*9eefe2a2SStefan Roese inode->i_uid = le32_to_cpu(ino->uid); 237*9eefe2a2SStefan Roese inode->i_gid = le32_to_cpu(ino->gid); 238*9eefe2a2SStefan Roese inode->i_atime.tv_sec = (int64_t)le64_to_cpu(ino->atime_sec); 239*9eefe2a2SStefan Roese inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec); 240*9eefe2a2SStefan Roese inode->i_mtime.tv_sec = (int64_t)le64_to_cpu(ino->mtime_sec); 241*9eefe2a2SStefan Roese inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec); 242*9eefe2a2SStefan Roese inode->i_ctime.tv_sec = (int64_t)le64_to_cpu(ino->ctime_sec); 243*9eefe2a2SStefan Roese inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec); 244*9eefe2a2SStefan Roese inode->i_mode = le32_to_cpu(ino->mode); 245*9eefe2a2SStefan Roese inode->i_size = le64_to_cpu(ino->size); 246*9eefe2a2SStefan Roese 247*9eefe2a2SStefan Roese ui->data_len = le32_to_cpu(ino->data_len); 248*9eefe2a2SStefan Roese ui->flags = le32_to_cpu(ino->flags); 249*9eefe2a2SStefan Roese ui->compr_type = le16_to_cpu(ino->compr_type); 250*9eefe2a2SStefan Roese ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum); 251*9eefe2a2SStefan Roese ui->synced_i_size = ui->ui_size = inode->i_size; 252*9eefe2a2SStefan Roese 253*9eefe2a2SStefan Roese err = validate_inode(c, inode); 254*9eefe2a2SStefan Roese if (err) 255*9eefe2a2SStefan Roese goto out_invalid; 256*9eefe2a2SStefan Roese 257*9eefe2a2SStefan Roese if ((inode->i_mode & S_IFMT) == S_IFLNK) { 258*9eefe2a2SStefan Roese if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) { 259*9eefe2a2SStefan Roese err = 12; 260*9eefe2a2SStefan Roese goto out_invalid; 261*9eefe2a2SStefan Roese } 262*9eefe2a2SStefan Roese ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); 263*9eefe2a2SStefan Roese if (!ui->data) { 264*9eefe2a2SStefan Roese err = -ENOMEM; 265*9eefe2a2SStefan Roese goto out_ino; 266*9eefe2a2SStefan Roese } 267*9eefe2a2SStefan Roese memcpy(ui->data, ino->data, ui->data_len); 268*9eefe2a2SStefan Roese ((char *)ui->data)[ui->data_len] = '\0'; 269*9eefe2a2SStefan Roese } 270*9eefe2a2SStefan Roese 271*9eefe2a2SStefan Roese kfree(ino); 272*9eefe2a2SStefan Roese inode->i_state &= ~(I_LOCK | I_NEW); 273*9eefe2a2SStefan Roese return inode; 274*9eefe2a2SStefan Roese 275*9eefe2a2SStefan Roese out_invalid: 276*9eefe2a2SStefan Roese ubifs_err("inode %lu validation failed, error %d", inode->i_ino, err); 277*9eefe2a2SStefan Roese dbg_dump_node(c, ino); 278*9eefe2a2SStefan Roese dbg_dump_inode(c, inode); 279*9eefe2a2SStefan Roese err = -EINVAL; 280*9eefe2a2SStefan Roese out_ino: 281*9eefe2a2SStefan Roese kfree(ino); 282*9eefe2a2SStefan Roese out: 283*9eefe2a2SStefan Roese ubifs_err("failed to read inode %lu, error %d", inode->i_ino, err); 284*9eefe2a2SStefan Roese return ERR_PTR(err); 285*9eefe2a2SStefan Roese } 286*9eefe2a2SStefan Roese 287*9eefe2a2SStefan Roese /** 288*9eefe2a2SStefan Roese * init_constants_early - initialize UBIFS constants. 289*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 290*9eefe2a2SStefan Roese * 291*9eefe2a2SStefan Roese * This function initialize UBIFS constants which do not need the superblock to 292*9eefe2a2SStefan Roese * be read. It also checks that the UBI volume satisfies basic UBIFS 293*9eefe2a2SStefan Roese * requirements. Returns zero in case of success and a negative error code in 294*9eefe2a2SStefan Roese * case of failure. 295*9eefe2a2SStefan Roese */ 296*9eefe2a2SStefan Roese static int init_constants_early(struct ubifs_info *c) 297*9eefe2a2SStefan Roese { 298*9eefe2a2SStefan Roese if (c->vi.corrupted) { 299*9eefe2a2SStefan Roese ubifs_warn("UBI volume is corrupted - read-only mode"); 300*9eefe2a2SStefan Roese c->ro_media = 1; 301*9eefe2a2SStefan Roese } 302*9eefe2a2SStefan Roese 303*9eefe2a2SStefan Roese if (c->di.ro_mode) { 304*9eefe2a2SStefan Roese ubifs_msg("read-only UBI device"); 305*9eefe2a2SStefan Roese c->ro_media = 1; 306*9eefe2a2SStefan Roese } 307*9eefe2a2SStefan Roese 308*9eefe2a2SStefan Roese if (c->vi.vol_type == UBI_STATIC_VOLUME) { 309*9eefe2a2SStefan Roese ubifs_msg("static UBI volume - read-only mode"); 310*9eefe2a2SStefan Roese c->ro_media = 1; 311*9eefe2a2SStefan Roese } 312*9eefe2a2SStefan Roese 313*9eefe2a2SStefan Roese c->leb_cnt = c->vi.size; 314*9eefe2a2SStefan Roese c->leb_size = c->vi.usable_leb_size; 315*9eefe2a2SStefan Roese c->half_leb_size = c->leb_size / 2; 316*9eefe2a2SStefan Roese c->min_io_size = c->di.min_io_size; 317*9eefe2a2SStefan Roese c->min_io_shift = fls(c->min_io_size) - 1; 318*9eefe2a2SStefan Roese 319*9eefe2a2SStefan Roese if (c->leb_size < UBIFS_MIN_LEB_SZ) { 320*9eefe2a2SStefan Roese ubifs_err("too small LEBs (%d bytes), min. is %d bytes", 321*9eefe2a2SStefan Roese c->leb_size, UBIFS_MIN_LEB_SZ); 322*9eefe2a2SStefan Roese return -EINVAL; 323*9eefe2a2SStefan Roese } 324*9eefe2a2SStefan Roese 325*9eefe2a2SStefan Roese if (c->leb_cnt < UBIFS_MIN_LEB_CNT) { 326*9eefe2a2SStefan Roese ubifs_err("too few LEBs (%d), min. is %d", 327*9eefe2a2SStefan Roese c->leb_cnt, UBIFS_MIN_LEB_CNT); 328*9eefe2a2SStefan Roese return -EINVAL; 329*9eefe2a2SStefan Roese } 330*9eefe2a2SStefan Roese 331*9eefe2a2SStefan Roese if (!is_power_of_2(c->min_io_size)) { 332*9eefe2a2SStefan Roese ubifs_err("bad min. I/O size %d", c->min_io_size); 333*9eefe2a2SStefan Roese return -EINVAL; 334*9eefe2a2SStefan Roese } 335*9eefe2a2SStefan Roese 336*9eefe2a2SStefan Roese /* 337*9eefe2a2SStefan Roese * UBIFS aligns all node to 8-byte boundary, so to make function in 338*9eefe2a2SStefan Roese * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is 339*9eefe2a2SStefan Roese * less than 8. 340*9eefe2a2SStefan Roese */ 341*9eefe2a2SStefan Roese if (c->min_io_size < 8) { 342*9eefe2a2SStefan Roese c->min_io_size = 8; 343*9eefe2a2SStefan Roese c->min_io_shift = 3; 344*9eefe2a2SStefan Roese } 345*9eefe2a2SStefan Roese 346*9eefe2a2SStefan Roese c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size); 347*9eefe2a2SStefan Roese c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size); 348*9eefe2a2SStefan Roese 349*9eefe2a2SStefan Roese /* 350*9eefe2a2SStefan Roese * Initialize node length ranges which are mostly needed for node 351*9eefe2a2SStefan Roese * length validation. 352*9eefe2a2SStefan Roese */ 353*9eefe2a2SStefan Roese c->ranges[UBIFS_PAD_NODE].len = UBIFS_PAD_NODE_SZ; 354*9eefe2a2SStefan Roese c->ranges[UBIFS_SB_NODE].len = UBIFS_SB_NODE_SZ; 355*9eefe2a2SStefan Roese c->ranges[UBIFS_MST_NODE].len = UBIFS_MST_NODE_SZ; 356*9eefe2a2SStefan Roese c->ranges[UBIFS_REF_NODE].len = UBIFS_REF_NODE_SZ; 357*9eefe2a2SStefan Roese c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ; 358*9eefe2a2SStefan Roese c->ranges[UBIFS_CS_NODE].len = UBIFS_CS_NODE_SZ; 359*9eefe2a2SStefan Roese 360*9eefe2a2SStefan Roese c->ranges[UBIFS_INO_NODE].min_len = UBIFS_INO_NODE_SZ; 361*9eefe2a2SStefan Roese c->ranges[UBIFS_INO_NODE].max_len = UBIFS_MAX_INO_NODE_SZ; 362*9eefe2a2SStefan Roese c->ranges[UBIFS_ORPH_NODE].min_len = 363*9eefe2a2SStefan Roese UBIFS_ORPH_NODE_SZ + sizeof(__le64); 364*9eefe2a2SStefan Roese c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size; 365*9eefe2a2SStefan Roese c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ; 366*9eefe2a2SStefan Roese c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ; 367*9eefe2a2SStefan Roese c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ; 368*9eefe2a2SStefan Roese c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ; 369*9eefe2a2SStefan Roese c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ; 370*9eefe2a2SStefan Roese c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ; 371*9eefe2a2SStefan Roese /* 372*9eefe2a2SStefan Roese * Minimum indexing node size is amended later when superblock is 373*9eefe2a2SStefan Roese * read and the key length is known. 374*9eefe2a2SStefan Roese */ 375*9eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ; 376*9eefe2a2SStefan Roese /* 377*9eefe2a2SStefan Roese * Maximum indexing node size is amended later when superblock is 378*9eefe2a2SStefan Roese * read and the fanout is known. 379*9eefe2a2SStefan Roese */ 380*9eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX; 381*9eefe2a2SStefan Roese 382*9eefe2a2SStefan Roese /* 383*9eefe2a2SStefan Roese * Initialize dead and dark LEB space watermarks. See gc.c for comments 384*9eefe2a2SStefan Roese * about these values. 385*9eefe2a2SStefan Roese */ 386*9eefe2a2SStefan Roese c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size); 387*9eefe2a2SStefan Roese c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size); 388*9eefe2a2SStefan Roese 389*9eefe2a2SStefan Roese /* 390*9eefe2a2SStefan Roese * Calculate how many bytes would be wasted at the end of LEB if it was 391*9eefe2a2SStefan Roese * fully filled with data nodes of maximum size. This is used in 392*9eefe2a2SStefan Roese * calculations when reporting free space. 393*9eefe2a2SStefan Roese */ 394*9eefe2a2SStefan Roese c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ; 395*9eefe2a2SStefan Roese 396*9eefe2a2SStefan Roese return 0; 397*9eefe2a2SStefan Roese } 398*9eefe2a2SStefan Roese 399*9eefe2a2SStefan Roese /* 400*9eefe2a2SStefan Roese * init_constants_sb - initialize UBIFS constants. 401*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 402*9eefe2a2SStefan Roese * 403*9eefe2a2SStefan Roese * This is a helper function which initializes various UBIFS constants after 404*9eefe2a2SStefan Roese * the superblock has been read. It also checks various UBIFS parameters and 405*9eefe2a2SStefan Roese * makes sure they are all right. Returns zero in case of success and a 406*9eefe2a2SStefan Roese * negative error code in case of failure. 407*9eefe2a2SStefan Roese */ 408*9eefe2a2SStefan Roese static int init_constants_sb(struct ubifs_info *c) 409*9eefe2a2SStefan Roese { 410*9eefe2a2SStefan Roese int tmp, err; 411*9eefe2a2SStefan Roese long long tmp64; 412*9eefe2a2SStefan Roese 413*9eefe2a2SStefan Roese c->main_bytes = (long long)c->main_lebs * c->leb_size; 414*9eefe2a2SStefan Roese c->max_znode_sz = sizeof(struct ubifs_znode) + 415*9eefe2a2SStefan Roese c->fanout * sizeof(struct ubifs_zbranch); 416*9eefe2a2SStefan Roese 417*9eefe2a2SStefan Roese tmp = ubifs_idx_node_sz(c, 1); 418*9eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].min_len = tmp; 419*9eefe2a2SStefan Roese c->min_idx_node_sz = ALIGN(tmp, 8); 420*9eefe2a2SStefan Roese 421*9eefe2a2SStefan Roese tmp = ubifs_idx_node_sz(c, c->fanout); 422*9eefe2a2SStefan Roese c->ranges[UBIFS_IDX_NODE].max_len = tmp; 423*9eefe2a2SStefan Roese c->max_idx_node_sz = ALIGN(tmp, 8); 424*9eefe2a2SStefan Roese 425*9eefe2a2SStefan Roese /* Make sure LEB size is large enough to fit full commit */ 426*9eefe2a2SStefan Roese tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt; 427*9eefe2a2SStefan Roese tmp = ALIGN(tmp, c->min_io_size); 428*9eefe2a2SStefan Roese if (tmp > c->leb_size) { 429*9eefe2a2SStefan Roese dbg_err("too small LEB size %d, at least %d needed", 430*9eefe2a2SStefan Roese c->leb_size, tmp); 431*9eefe2a2SStefan Roese return -EINVAL; 432*9eefe2a2SStefan Roese } 433*9eefe2a2SStefan Roese 434*9eefe2a2SStefan Roese /* 435*9eefe2a2SStefan Roese * Make sure that the log is large enough to fit reference nodes for 436*9eefe2a2SStefan Roese * all buds plus one reserved LEB. 437*9eefe2a2SStefan Roese */ 438*9eefe2a2SStefan Roese tmp64 = c->max_bud_bytes + c->leb_size - 1; 439*9eefe2a2SStefan Roese c->max_bud_cnt = div_u64(tmp64, c->leb_size); 440*9eefe2a2SStefan Roese tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1); 441*9eefe2a2SStefan Roese tmp /= c->leb_size; 442*9eefe2a2SStefan Roese tmp += 1; 443*9eefe2a2SStefan Roese if (c->log_lebs < tmp) { 444*9eefe2a2SStefan Roese dbg_err("too small log %d LEBs, required min. %d LEBs", 445*9eefe2a2SStefan Roese c->log_lebs, tmp); 446*9eefe2a2SStefan Roese return -EINVAL; 447*9eefe2a2SStefan Roese } 448*9eefe2a2SStefan Roese 449*9eefe2a2SStefan Roese /* 450*9eefe2a2SStefan Roese * When budgeting we assume worst-case scenarios when the pages are not 451*9eefe2a2SStefan Roese * be compressed and direntries are of the maximum size. 452*9eefe2a2SStefan Roese * 453*9eefe2a2SStefan Roese * Note, data, which may be stored in inodes is budgeted separately, so 454*9eefe2a2SStefan Roese * it is not included into 'c->inode_budget'. 455*9eefe2a2SStefan Roese */ 456*9eefe2a2SStefan Roese c->page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE; 457*9eefe2a2SStefan Roese c->inode_budget = UBIFS_INO_NODE_SZ; 458*9eefe2a2SStefan Roese c->dent_budget = UBIFS_MAX_DENT_NODE_SZ; 459*9eefe2a2SStefan Roese 460*9eefe2a2SStefan Roese /* 461*9eefe2a2SStefan Roese * When the amount of flash space used by buds becomes 462*9eefe2a2SStefan Roese * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit. 463*9eefe2a2SStefan Roese * The writers are unblocked when the commit is finished. To avoid 464*9eefe2a2SStefan Roese * writers to be blocked UBIFS initiates background commit in advance, 465*9eefe2a2SStefan Roese * when number of bud bytes becomes above the limit defined below. 466*9eefe2a2SStefan Roese */ 467*9eefe2a2SStefan Roese c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4; 468*9eefe2a2SStefan Roese 469*9eefe2a2SStefan Roese /* 470*9eefe2a2SStefan Roese * Ensure minimum journal size. All the bytes in the journal heads are 471*9eefe2a2SStefan Roese * considered to be used, when calculating the current journal usage. 472*9eefe2a2SStefan Roese * Consequently, if the journal is too small, UBIFS will treat it as 473*9eefe2a2SStefan Roese * always full. 474*9eefe2a2SStefan Roese */ 475*9eefe2a2SStefan Roese tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1; 476*9eefe2a2SStefan Roese if (c->bg_bud_bytes < tmp64) 477*9eefe2a2SStefan Roese c->bg_bud_bytes = tmp64; 478*9eefe2a2SStefan Roese if (c->max_bud_bytes < tmp64 + c->leb_size) 479*9eefe2a2SStefan Roese c->max_bud_bytes = tmp64 + c->leb_size; 480*9eefe2a2SStefan Roese 481*9eefe2a2SStefan Roese err = ubifs_calc_lpt_geom(c); 482*9eefe2a2SStefan Roese if (err) 483*9eefe2a2SStefan Roese return err; 484*9eefe2a2SStefan Roese 485*9eefe2a2SStefan Roese return 0; 486*9eefe2a2SStefan Roese } 487*9eefe2a2SStefan Roese 488*9eefe2a2SStefan Roese /* 489*9eefe2a2SStefan Roese * init_constants_master - initialize UBIFS constants. 490*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 491*9eefe2a2SStefan Roese * 492*9eefe2a2SStefan Roese * This is a helper function which initializes various UBIFS constants after 493*9eefe2a2SStefan Roese * the master node has been read. It also checks various UBIFS parameters and 494*9eefe2a2SStefan Roese * makes sure they are all right. 495*9eefe2a2SStefan Roese */ 496*9eefe2a2SStefan Roese static void init_constants_master(struct ubifs_info *c) 497*9eefe2a2SStefan Roese { 498*9eefe2a2SStefan Roese long long tmp64; 499*9eefe2a2SStefan Roese 500*9eefe2a2SStefan Roese c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); 501*9eefe2a2SStefan Roese 502*9eefe2a2SStefan Roese /* 503*9eefe2a2SStefan Roese * Calculate total amount of FS blocks. This number is not used 504*9eefe2a2SStefan Roese * internally because it does not make much sense for UBIFS, but it is 505*9eefe2a2SStefan Roese * necessary to report something for the 'statfs()' call. 506*9eefe2a2SStefan Roese * 507*9eefe2a2SStefan Roese * Subtract the LEB reserved for GC, the LEB which is reserved for 508*9eefe2a2SStefan Roese * deletions, minimum LEBs for the index, and assume only one journal 509*9eefe2a2SStefan Roese * head is available. 510*9eefe2a2SStefan Roese */ 511*9eefe2a2SStefan Roese tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1; 512*9eefe2a2SStefan Roese tmp64 *= (long long)c->leb_size - c->leb_overhead; 513*9eefe2a2SStefan Roese tmp64 = ubifs_reported_space(c, tmp64); 514*9eefe2a2SStefan Roese c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT; 515*9eefe2a2SStefan Roese } 516*9eefe2a2SStefan Roese 517*9eefe2a2SStefan Roese /** 518*9eefe2a2SStefan Roese * free_orphans - free orphans. 519*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 520*9eefe2a2SStefan Roese */ 521*9eefe2a2SStefan Roese static void free_orphans(struct ubifs_info *c) 522*9eefe2a2SStefan Roese { 523*9eefe2a2SStefan Roese struct ubifs_orphan *orph; 524*9eefe2a2SStefan Roese 525*9eefe2a2SStefan Roese while (c->orph_dnext) { 526*9eefe2a2SStefan Roese orph = c->orph_dnext; 527*9eefe2a2SStefan Roese c->orph_dnext = orph->dnext; 528*9eefe2a2SStefan Roese list_del(&orph->list); 529*9eefe2a2SStefan Roese kfree(orph); 530*9eefe2a2SStefan Roese } 531*9eefe2a2SStefan Roese 532*9eefe2a2SStefan Roese while (!list_empty(&c->orph_list)) { 533*9eefe2a2SStefan Roese orph = list_entry(c->orph_list.next, struct ubifs_orphan, list); 534*9eefe2a2SStefan Roese list_del(&orph->list); 535*9eefe2a2SStefan Roese kfree(orph); 536*9eefe2a2SStefan Roese dbg_err("orphan list not empty at unmount"); 537*9eefe2a2SStefan Roese } 538*9eefe2a2SStefan Roese 539*9eefe2a2SStefan Roese vfree(c->orph_buf); 540*9eefe2a2SStefan Roese c->orph_buf = NULL; 541*9eefe2a2SStefan Roese } 542*9eefe2a2SStefan Roese 543*9eefe2a2SStefan Roese /** 544*9eefe2a2SStefan Roese * check_volume_empty - check if the UBI volume is empty. 545*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 546*9eefe2a2SStefan Roese * 547*9eefe2a2SStefan Roese * This function checks if the UBIFS volume is empty by looking if its LEBs are 548*9eefe2a2SStefan Roese * mapped or not. The result of checking is stored in the @c->empty variable. 549*9eefe2a2SStefan Roese * Returns zero in case of success and a negative error code in case of 550*9eefe2a2SStefan Roese * failure. 551*9eefe2a2SStefan Roese */ 552*9eefe2a2SStefan Roese static int check_volume_empty(struct ubifs_info *c) 553*9eefe2a2SStefan Roese { 554*9eefe2a2SStefan Roese int lnum, err; 555*9eefe2a2SStefan Roese 556*9eefe2a2SStefan Roese c->empty = 1; 557*9eefe2a2SStefan Roese for (lnum = 0; lnum < c->leb_cnt; lnum++) { 558*9eefe2a2SStefan Roese err = ubi_is_mapped(c->ubi, lnum); 559*9eefe2a2SStefan Roese if (unlikely(err < 0)) 560*9eefe2a2SStefan Roese return err; 561*9eefe2a2SStefan Roese if (err == 1) { 562*9eefe2a2SStefan Roese c->empty = 0; 563*9eefe2a2SStefan Roese break; 564*9eefe2a2SStefan Roese } 565*9eefe2a2SStefan Roese 566*9eefe2a2SStefan Roese cond_resched(); 567*9eefe2a2SStefan Roese } 568*9eefe2a2SStefan Roese 569*9eefe2a2SStefan Roese return 0; 570*9eefe2a2SStefan Roese } 571*9eefe2a2SStefan Roese 572*9eefe2a2SStefan Roese /** 573*9eefe2a2SStefan Roese * mount_ubifs - mount UBIFS file-system. 574*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 575*9eefe2a2SStefan Roese * 576*9eefe2a2SStefan Roese * This function mounts UBIFS file system. Returns zero in case of success and 577*9eefe2a2SStefan Roese * a negative error code in case of failure. 578*9eefe2a2SStefan Roese * 579*9eefe2a2SStefan Roese * Note, the function does not de-allocate resources it it fails half way 580*9eefe2a2SStefan Roese * through, and the caller has to do this instead. 581*9eefe2a2SStefan Roese */ 582*9eefe2a2SStefan Roese static int mount_ubifs(struct ubifs_info *c) 583*9eefe2a2SStefan Roese { 584*9eefe2a2SStefan Roese struct super_block *sb = c->vfs_sb; 585*9eefe2a2SStefan Roese int err, mounted_read_only = (sb->s_flags & MS_RDONLY); 586*9eefe2a2SStefan Roese long long x; 587*9eefe2a2SStefan Roese size_t sz; 588*9eefe2a2SStefan Roese 589*9eefe2a2SStefan Roese err = init_constants_early(c); 590*9eefe2a2SStefan Roese if (err) 591*9eefe2a2SStefan Roese return err; 592*9eefe2a2SStefan Roese 593*9eefe2a2SStefan Roese err = ubifs_debugging_init(c); 594*9eefe2a2SStefan Roese if (err) 595*9eefe2a2SStefan Roese return err; 596*9eefe2a2SStefan Roese 597*9eefe2a2SStefan Roese err = check_volume_empty(c); 598*9eefe2a2SStefan Roese if (err) 599*9eefe2a2SStefan Roese goto out_free; 600*9eefe2a2SStefan Roese 601*9eefe2a2SStefan Roese if (c->empty && (mounted_read_only || c->ro_media)) { 602*9eefe2a2SStefan Roese /* 603*9eefe2a2SStefan Roese * This UBI volume is empty, and read-only, or the file system 604*9eefe2a2SStefan Roese * is mounted read-only - we cannot format it. 605*9eefe2a2SStefan Roese */ 606*9eefe2a2SStefan Roese ubifs_err("can't format empty UBI volume: read-only %s", 607*9eefe2a2SStefan Roese c->ro_media ? "UBI volume" : "mount"); 608*9eefe2a2SStefan Roese err = -EROFS; 609*9eefe2a2SStefan Roese goto out_free; 610*9eefe2a2SStefan Roese } 611*9eefe2a2SStefan Roese 612*9eefe2a2SStefan Roese if (c->ro_media && !mounted_read_only) { 613*9eefe2a2SStefan Roese ubifs_err("cannot mount read-write - read-only media"); 614*9eefe2a2SStefan Roese err = -EROFS; 615*9eefe2a2SStefan Roese goto out_free; 616*9eefe2a2SStefan Roese } 617*9eefe2a2SStefan Roese 618*9eefe2a2SStefan Roese /* 619*9eefe2a2SStefan Roese * The requirement for the buffer is that it should fit indexing B-tree 620*9eefe2a2SStefan Roese * height amount of integers. We assume the height if the TNC tree will 621*9eefe2a2SStefan Roese * never exceed 64. 622*9eefe2a2SStefan Roese */ 623*9eefe2a2SStefan Roese err = -ENOMEM; 624*9eefe2a2SStefan Roese c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL); 625*9eefe2a2SStefan Roese if (!c->bottom_up_buf) 626*9eefe2a2SStefan Roese goto out_free; 627*9eefe2a2SStefan Roese 628*9eefe2a2SStefan Roese c->sbuf = vmalloc(c->leb_size); 629*9eefe2a2SStefan Roese if (!c->sbuf) 630*9eefe2a2SStefan Roese goto out_free; 631*9eefe2a2SStefan Roese 632*9eefe2a2SStefan Roese /* 633*9eefe2a2SStefan Roese * We have to check all CRCs, even for data nodes, when we mount the FS 634*9eefe2a2SStefan Roese * (specifically, when we are replaying). 635*9eefe2a2SStefan Roese */ 636*9eefe2a2SStefan Roese c->always_chk_crc = 1; 637*9eefe2a2SStefan Roese 638*9eefe2a2SStefan Roese err = ubifs_read_superblock(c); 639*9eefe2a2SStefan Roese if (err) 640*9eefe2a2SStefan Roese goto out_free; 641*9eefe2a2SStefan Roese 642*9eefe2a2SStefan Roese /* 643*9eefe2a2SStefan Roese * Make sure the compressor which is set as default in the superblock 644*9eefe2a2SStefan Roese * or overridden by mount options is actually compiled in. 645*9eefe2a2SStefan Roese */ 646*9eefe2a2SStefan Roese if (!ubifs_compr_present(c->default_compr)) { 647*9eefe2a2SStefan Roese ubifs_err("'compressor \"%s\" is not compiled in", 648*9eefe2a2SStefan Roese ubifs_compr_name(c->default_compr)); 649*9eefe2a2SStefan Roese goto out_free; 650*9eefe2a2SStefan Roese } 651*9eefe2a2SStefan Roese 652*9eefe2a2SStefan Roese dbg_failure_mode_registration(c); 653*9eefe2a2SStefan Roese 654*9eefe2a2SStefan Roese err = init_constants_sb(c); 655*9eefe2a2SStefan Roese if (err) 656*9eefe2a2SStefan Roese goto out_free; 657*9eefe2a2SStefan Roese 658*9eefe2a2SStefan Roese sz = ALIGN(c->max_idx_node_sz, c->min_io_size); 659*9eefe2a2SStefan Roese sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size); 660*9eefe2a2SStefan Roese c->cbuf = kmalloc(sz, GFP_NOFS); 661*9eefe2a2SStefan Roese if (!c->cbuf) { 662*9eefe2a2SStefan Roese err = -ENOMEM; 663*9eefe2a2SStefan Roese goto out_free; 664*9eefe2a2SStefan Roese } 665*9eefe2a2SStefan Roese 666*9eefe2a2SStefan Roese sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id); 667*9eefe2a2SStefan Roese 668*9eefe2a2SStefan Roese err = ubifs_read_master(c); 669*9eefe2a2SStefan Roese if (err) 670*9eefe2a2SStefan Roese goto out_master; 671*9eefe2a2SStefan Roese 672*9eefe2a2SStefan Roese init_constants_master(c); 673*9eefe2a2SStefan Roese 674*9eefe2a2SStefan Roese if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) { 675*9eefe2a2SStefan Roese ubifs_msg("recovery needed"); 676*9eefe2a2SStefan Roese c->need_recovery = 1; 677*9eefe2a2SStefan Roese } 678*9eefe2a2SStefan Roese 679*9eefe2a2SStefan Roese err = ubifs_lpt_init(c, 1, !mounted_read_only); 680*9eefe2a2SStefan Roese if (err) 681*9eefe2a2SStefan Roese goto out_lpt; 682*9eefe2a2SStefan Roese 683*9eefe2a2SStefan Roese err = dbg_check_idx_size(c, c->old_idx_sz); 684*9eefe2a2SStefan Roese if (err) 685*9eefe2a2SStefan Roese goto out_lpt; 686*9eefe2a2SStefan Roese 687*9eefe2a2SStefan Roese err = ubifs_replay_journal(c); 688*9eefe2a2SStefan Roese if (err) 689*9eefe2a2SStefan Roese goto out_journal; 690*9eefe2a2SStefan Roese 691*9eefe2a2SStefan Roese err = ubifs_mount_orphans(c, c->need_recovery, mounted_read_only); 692*9eefe2a2SStefan Roese if (err) 693*9eefe2a2SStefan Roese goto out_orphans; 694*9eefe2a2SStefan Roese 695*9eefe2a2SStefan Roese if (c->need_recovery) { 696*9eefe2a2SStefan Roese err = ubifs_recover_size(c); 697*9eefe2a2SStefan Roese if (err) 698*9eefe2a2SStefan Roese goto out_orphans; 699*9eefe2a2SStefan Roese } 700*9eefe2a2SStefan Roese 701*9eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 702*9eefe2a2SStefan Roese list_add_tail(&c->infos_list, &ubifs_infos); 703*9eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 704*9eefe2a2SStefan Roese 705*9eefe2a2SStefan Roese if (c->need_recovery) { 706*9eefe2a2SStefan Roese if (mounted_read_only) 707*9eefe2a2SStefan Roese ubifs_msg("recovery deferred"); 708*9eefe2a2SStefan Roese else { 709*9eefe2a2SStefan Roese c->need_recovery = 0; 710*9eefe2a2SStefan Roese ubifs_msg("recovery completed"); 711*9eefe2a2SStefan Roese } 712*9eefe2a2SStefan Roese } 713*9eefe2a2SStefan Roese 714*9eefe2a2SStefan Roese err = dbg_check_filesystem(c); 715*9eefe2a2SStefan Roese if (err) 716*9eefe2a2SStefan Roese goto out_infos; 717*9eefe2a2SStefan Roese 718*9eefe2a2SStefan Roese c->always_chk_crc = 0; 719*9eefe2a2SStefan Roese 720*9eefe2a2SStefan Roese ubifs_msg("mounted UBI device %d, volume %d, name \"%s\"", 721*9eefe2a2SStefan Roese c->vi.ubi_num, c->vi.vol_id, c->vi.name); 722*9eefe2a2SStefan Roese if (mounted_read_only) 723*9eefe2a2SStefan Roese ubifs_msg("mounted read-only"); 724*9eefe2a2SStefan Roese x = (long long)c->main_lebs * c->leb_size; 725*9eefe2a2SStefan Roese ubifs_msg("file system size: %lld bytes (%lld KiB, %lld MiB, %d " 726*9eefe2a2SStefan Roese "LEBs)", x, x >> 10, x >> 20, c->main_lebs); 727*9eefe2a2SStefan Roese x = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes; 728*9eefe2a2SStefan Roese ubifs_msg("journal size: %lld bytes (%lld KiB, %lld MiB, %d " 729*9eefe2a2SStefan Roese "LEBs)", x, x >> 10, x >> 20, c->log_lebs + c->max_bud_cnt); 730*9eefe2a2SStefan Roese ubifs_msg("media format: %d (latest is %d)", 731*9eefe2a2SStefan Roese c->fmt_version, UBIFS_FORMAT_VERSION); 732*9eefe2a2SStefan Roese ubifs_msg("default compressor: %s", ubifs_compr_name(c->default_compr)); 733*9eefe2a2SStefan Roese ubifs_msg("reserved for root: %llu bytes (%llu KiB)", 734*9eefe2a2SStefan Roese c->report_rp_size, c->report_rp_size >> 10); 735*9eefe2a2SStefan Roese 736*9eefe2a2SStefan Roese dbg_msg("compiled on: " __DATE__ " at " __TIME__); 737*9eefe2a2SStefan Roese dbg_msg("min. I/O unit size: %d bytes", c->min_io_size); 738*9eefe2a2SStefan Roese dbg_msg("LEB size: %d bytes (%d KiB)", 739*9eefe2a2SStefan Roese c->leb_size, c->leb_size >> 10); 740*9eefe2a2SStefan Roese dbg_msg("data journal heads: %d", 741*9eefe2a2SStefan Roese c->jhead_cnt - NONDATA_JHEADS_CNT); 742*9eefe2a2SStefan Roese dbg_msg("UUID: %02X%02X%02X%02X-%02X%02X" 743*9eefe2a2SStefan Roese "-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", 744*9eefe2a2SStefan Roese c->uuid[0], c->uuid[1], c->uuid[2], c->uuid[3], 745*9eefe2a2SStefan Roese c->uuid[4], c->uuid[5], c->uuid[6], c->uuid[7], 746*9eefe2a2SStefan Roese c->uuid[8], c->uuid[9], c->uuid[10], c->uuid[11], 747*9eefe2a2SStefan Roese c->uuid[12], c->uuid[13], c->uuid[14], c->uuid[15]); 748*9eefe2a2SStefan Roese dbg_msg("big_lpt %d", c->big_lpt); 749*9eefe2a2SStefan Roese dbg_msg("log LEBs: %d (%d - %d)", 750*9eefe2a2SStefan Roese c->log_lebs, UBIFS_LOG_LNUM, c->log_last); 751*9eefe2a2SStefan Roese dbg_msg("LPT area LEBs: %d (%d - %d)", 752*9eefe2a2SStefan Roese c->lpt_lebs, c->lpt_first, c->lpt_last); 753*9eefe2a2SStefan Roese dbg_msg("orphan area LEBs: %d (%d - %d)", 754*9eefe2a2SStefan Roese c->orph_lebs, c->orph_first, c->orph_last); 755*9eefe2a2SStefan Roese dbg_msg("main area LEBs: %d (%d - %d)", 756*9eefe2a2SStefan Roese c->main_lebs, c->main_first, c->leb_cnt - 1); 757*9eefe2a2SStefan Roese dbg_msg("index LEBs: %d", c->lst.idx_lebs); 758*9eefe2a2SStefan Roese dbg_msg("total index bytes: %lld (%lld KiB, %lld MiB)", 759*9eefe2a2SStefan Roese c->old_idx_sz, c->old_idx_sz >> 10, c->old_idx_sz >> 20); 760*9eefe2a2SStefan Roese dbg_msg("key hash type: %d", c->key_hash_type); 761*9eefe2a2SStefan Roese dbg_msg("tree fanout: %d", c->fanout); 762*9eefe2a2SStefan Roese dbg_msg("reserved GC LEB: %d", c->gc_lnum); 763*9eefe2a2SStefan Roese dbg_msg("first main LEB: %d", c->main_first); 764*9eefe2a2SStefan Roese dbg_msg("max. znode size %d", c->max_znode_sz); 765*9eefe2a2SStefan Roese dbg_msg("max. index node size %d", c->max_idx_node_sz); 766*9eefe2a2SStefan Roese dbg_msg("node sizes: data %zu, inode %zu, dentry %zu", 767*9eefe2a2SStefan Roese UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ); 768*9eefe2a2SStefan Roese dbg_msg("node sizes: trun %zu, sb %zu, master %zu", 769*9eefe2a2SStefan Roese UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ); 770*9eefe2a2SStefan Roese dbg_msg("node sizes: ref %zu, cmt. start %zu, orph %zu", 771*9eefe2a2SStefan Roese UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ); 772*9eefe2a2SStefan Roese dbg_msg("max. node sizes: data %zu, inode %zu dentry %zu", 773*9eefe2a2SStefan Roese UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ, 774*9eefe2a2SStefan Roese UBIFS_MAX_DENT_NODE_SZ); 775*9eefe2a2SStefan Roese dbg_msg("dead watermark: %d", c->dead_wm); 776*9eefe2a2SStefan Roese dbg_msg("dark watermark: %d", c->dark_wm); 777*9eefe2a2SStefan Roese dbg_msg("LEB overhead: %d", c->leb_overhead); 778*9eefe2a2SStefan Roese x = (long long)c->main_lebs * c->dark_wm; 779*9eefe2a2SStefan Roese dbg_msg("max. dark space: %lld (%lld KiB, %lld MiB)", 780*9eefe2a2SStefan Roese x, x >> 10, x >> 20); 781*9eefe2a2SStefan Roese dbg_msg("maximum bud bytes: %lld (%lld KiB, %lld MiB)", 782*9eefe2a2SStefan Roese c->max_bud_bytes, c->max_bud_bytes >> 10, 783*9eefe2a2SStefan Roese c->max_bud_bytes >> 20); 784*9eefe2a2SStefan Roese dbg_msg("BG commit bud bytes: %lld (%lld KiB, %lld MiB)", 785*9eefe2a2SStefan Roese c->bg_bud_bytes, c->bg_bud_bytes >> 10, 786*9eefe2a2SStefan Roese c->bg_bud_bytes >> 20); 787*9eefe2a2SStefan Roese dbg_msg("current bud bytes %lld (%lld KiB, %lld MiB)", 788*9eefe2a2SStefan Roese c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20); 789*9eefe2a2SStefan Roese dbg_msg("max. seq. number: %llu", c->max_sqnum); 790*9eefe2a2SStefan Roese dbg_msg("commit number: %llu", c->cmt_no); 791*9eefe2a2SStefan Roese 792*9eefe2a2SStefan Roese return 0; 793*9eefe2a2SStefan Roese 794*9eefe2a2SStefan Roese out_infos: 795*9eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 796*9eefe2a2SStefan Roese list_del(&c->infos_list); 797*9eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 798*9eefe2a2SStefan Roese out_orphans: 799*9eefe2a2SStefan Roese free_orphans(c); 800*9eefe2a2SStefan Roese out_journal: 801*9eefe2a2SStefan Roese out_lpt: 802*9eefe2a2SStefan Roese ubifs_lpt_free(c, 0); 803*9eefe2a2SStefan Roese out_master: 804*9eefe2a2SStefan Roese kfree(c->mst_node); 805*9eefe2a2SStefan Roese kfree(c->rcvrd_mst_node); 806*9eefe2a2SStefan Roese if (c->bgt) 807*9eefe2a2SStefan Roese kthread_stop(c->bgt); 808*9eefe2a2SStefan Roese kfree(c->cbuf); 809*9eefe2a2SStefan Roese out_free: 810*9eefe2a2SStefan Roese vfree(c->ileb_buf); 811*9eefe2a2SStefan Roese vfree(c->sbuf); 812*9eefe2a2SStefan Roese kfree(c->bottom_up_buf); 813*9eefe2a2SStefan Roese ubifs_debugging_exit(c); 814*9eefe2a2SStefan Roese return err; 815*9eefe2a2SStefan Roese } 816*9eefe2a2SStefan Roese 817*9eefe2a2SStefan Roese /** 818*9eefe2a2SStefan Roese * ubifs_umount - un-mount UBIFS file-system. 819*9eefe2a2SStefan Roese * @c: UBIFS file-system description object 820*9eefe2a2SStefan Roese * 821*9eefe2a2SStefan Roese * Note, this function is called to free allocated resourced when un-mounting, 822*9eefe2a2SStefan Roese * as well as free resources when an error occurred while we were half way 823*9eefe2a2SStefan Roese * through mounting (error path cleanup function). So it has to make sure the 824*9eefe2a2SStefan Roese * resource was actually allocated before freeing it. 825*9eefe2a2SStefan Roese */ 826*9eefe2a2SStefan Roese static void ubifs_umount(struct ubifs_info *c) 827*9eefe2a2SStefan Roese { 828*9eefe2a2SStefan Roese dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num, 829*9eefe2a2SStefan Roese c->vi.vol_id); 830*9eefe2a2SStefan Roese 831*9eefe2a2SStefan Roese spin_lock(&ubifs_infos_lock); 832*9eefe2a2SStefan Roese list_del(&c->infos_list); 833*9eefe2a2SStefan Roese spin_unlock(&ubifs_infos_lock); 834*9eefe2a2SStefan Roese 835*9eefe2a2SStefan Roese if (c->bgt) 836*9eefe2a2SStefan Roese kthread_stop(c->bgt); 837*9eefe2a2SStefan Roese 838*9eefe2a2SStefan Roese free_orphans(c); 839*9eefe2a2SStefan Roese ubifs_lpt_free(c, 0); 840*9eefe2a2SStefan Roese 841*9eefe2a2SStefan Roese kfree(c->cbuf); 842*9eefe2a2SStefan Roese kfree(c->rcvrd_mst_node); 843*9eefe2a2SStefan Roese kfree(c->mst_node); 844*9eefe2a2SStefan Roese vfree(c->ileb_buf); 845*9eefe2a2SStefan Roese vfree(c->sbuf); 846*9eefe2a2SStefan Roese kfree(c->bottom_up_buf); 847*9eefe2a2SStefan Roese ubifs_debugging_exit(c); 848*9eefe2a2SStefan Roese 849*9eefe2a2SStefan Roese /* Finally free U-Boot's global copy of superblock */ 850*9eefe2a2SStefan Roese free(ubifs_sb->s_fs_info); 851*9eefe2a2SStefan Roese free(ubifs_sb); 852*9eefe2a2SStefan Roese } 853*9eefe2a2SStefan Roese 854*9eefe2a2SStefan Roese /** 855*9eefe2a2SStefan Roese * open_ubi - parse UBI device name string and open the UBI device. 856*9eefe2a2SStefan Roese * @name: UBI volume name 857*9eefe2a2SStefan Roese * @mode: UBI volume open mode 858*9eefe2a2SStefan Roese * 859*9eefe2a2SStefan Roese * There are several ways to specify UBI volumes when mounting UBIFS: 860*9eefe2a2SStefan Roese * o ubiX_Y - UBI device number X, volume Y; 861*9eefe2a2SStefan Roese * o ubiY - UBI device number 0, volume Y; 862*9eefe2a2SStefan Roese * o ubiX:NAME - mount UBI device X, volume with name NAME; 863*9eefe2a2SStefan Roese * o ubi:NAME - mount UBI device 0, volume with name NAME. 864*9eefe2a2SStefan Roese * 865*9eefe2a2SStefan Roese * Alternative '!' separator may be used instead of ':' (because some shells 866*9eefe2a2SStefan Roese * like busybox may interpret ':' as an NFS host name separator). This function 867*9eefe2a2SStefan Roese * returns ubi volume object in case of success and a negative error code in 868*9eefe2a2SStefan Roese * case of failure. 869*9eefe2a2SStefan Roese */ 870*9eefe2a2SStefan Roese static struct ubi_volume_desc *open_ubi(const char *name, int mode) 871*9eefe2a2SStefan Roese { 872*9eefe2a2SStefan Roese int dev, vol; 873*9eefe2a2SStefan Roese char *endptr; 874*9eefe2a2SStefan Roese 875*9eefe2a2SStefan Roese if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i') 876*9eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 877*9eefe2a2SStefan Roese 878*9eefe2a2SStefan Roese /* ubi:NAME method */ 879*9eefe2a2SStefan Roese if ((name[3] == ':' || name[3] == '!') && name[4] != '\0') 880*9eefe2a2SStefan Roese return ubi_open_volume_nm(0, name + 4, mode); 881*9eefe2a2SStefan Roese 882*9eefe2a2SStefan Roese if (!isdigit(name[3])) 883*9eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 884*9eefe2a2SStefan Roese 885*9eefe2a2SStefan Roese dev = simple_strtoul(name + 3, &endptr, 0); 886*9eefe2a2SStefan Roese 887*9eefe2a2SStefan Roese /* ubiY method */ 888*9eefe2a2SStefan Roese if (*endptr == '\0') 889*9eefe2a2SStefan Roese return ubi_open_volume(0, dev, mode); 890*9eefe2a2SStefan Roese 891*9eefe2a2SStefan Roese /* ubiX_Y method */ 892*9eefe2a2SStefan Roese if (*endptr == '_' && isdigit(endptr[1])) { 893*9eefe2a2SStefan Roese vol = simple_strtoul(endptr + 1, &endptr, 0); 894*9eefe2a2SStefan Roese if (*endptr != '\0') 895*9eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 896*9eefe2a2SStefan Roese return ubi_open_volume(dev, vol, mode); 897*9eefe2a2SStefan Roese } 898*9eefe2a2SStefan Roese 899*9eefe2a2SStefan Roese /* ubiX:NAME method */ 900*9eefe2a2SStefan Roese if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0') 901*9eefe2a2SStefan Roese return ubi_open_volume_nm(dev, ++endptr, mode); 902*9eefe2a2SStefan Roese 903*9eefe2a2SStefan Roese return ERR_PTR(-EINVAL); 904*9eefe2a2SStefan Roese } 905*9eefe2a2SStefan Roese 906*9eefe2a2SStefan Roese static int ubifs_fill_super(struct super_block *sb, void *data, int silent) 907*9eefe2a2SStefan Roese { 908*9eefe2a2SStefan Roese struct ubi_volume_desc *ubi = sb->s_fs_info; 909*9eefe2a2SStefan Roese struct ubifs_info *c; 910*9eefe2a2SStefan Roese struct inode *root; 911*9eefe2a2SStefan Roese int err; 912*9eefe2a2SStefan Roese 913*9eefe2a2SStefan Roese c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL); 914*9eefe2a2SStefan Roese if (!c) 915*9eefe2a2SStefan Roese return -ENOMEM; 916*9eefe2a2SStefan Roese 917*9eefe2a2SStefan Roese spin_lock_init(&c->cnt_lock); 918*9eefe2a2SStefan Roese spin_lock_init(&c->cs_lock); 919*9eefe2a2SStefan Roese spin_lock_init(&c->buds_lock); 920*9eefe2a2SStefan Roese spin_lock_init(&c->space_lock); 921*9eefe2a2SStefan Roese spin_lock_init(&c->orphan_lock); 922*9eefe2a2SStefan Roese init_rwsem(&c->commit_sem); 923*9eefe2a2SStefan Roese mutex_init(&c->lp_mutex); 924*9eefe2a2SStefan Roese mutex_init(&c->tnc_mutex); 925*9eefe2a2SStefan Roese mutex_init(&c->log_mutex); 926*9eefe2a2SStefan Roese mutex_init(&c->mst_mutex); 927*9eefe2a2SStefan Roese mutex_init(&c->umount_mutex); 928*9eefe2a2SStefan Roese init_waitqueue_head(&c->cmt_wq); 929*9eefe2a2SStefan Roese c->buds = RB_ROOT; 930*9eefe2a2SStefan Roese c->old_idx = RB_ROOT; 931*9eefe2a2SStefan Roese c->size_tree = RB_ROOT; 932*9eefe2a2SStefan Roese c->orph_tree = RB_ROOT; 933*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->infos_list); 934*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->idx_gc); 935*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->replay_list); 936*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->replay_buds); 937*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->uncat_list); 938*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->empty_list); 939*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->freeable_list); 940*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->frdi_idx_list); 941*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->unclean_leb_list); 942*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->old_buds); 943*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->orph_list); 944*9eefe2a2SStefan Roese INIT_LIST_HEAD(&c->orph_new); 945*9eefe2a2SStefan Roese 946*9eefe2a2SStefan Roese c->highest_inum = UBIFS_FIRST_INO; 947*9eefe2a2SStefan Roese c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM; 948*9eefe2a2SStefan Roese 949*9eefe2a2SStefan Roese ubi_get_volume_info(ubi, &c->vi); 950*9eefe2a2SStefan Roese ubi_get_device_info(c->vi.ubi_num, &c->di); 951*9eefe2a2SStefan Roese 952*9eefe2a2SStefan Roese /* Re-open the UBI device in read-write mode */ 953*9eefe2a2SStefan Roese c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY); 954*9eefe2a2SStefan Roese if (IS_ERR(c->ubi)) { 955*9eefe2a2SStefan Roese err = PTR_ERR(c->ubi); 956*9eefe2a2SStefan Roese goto out_free; 957*9eefe2a2SStefan Roese } 958*9eefe2a2SStefan Roese 959*9eefe2a2SStefan Roese c->vfs_sb = sb; 960*9eefe2a2SStefan Roese 961*9eefe2a2SStefan Roese sb->s_fs_info = c; 962*9eefe2a2SStefan Roese sb->s_magic = UBIFS_SUPER_MAGIC; 963*9eefe2a2SStefan Roese sb->s_blocksize = UBIFS_BLOCK_SIZE; 964*9eefe2a2SStefan Roese sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT; 965*9eefe2a2SStefan Roese sb->s_dev = c->vi.cdev; 966*9eefe2a2SStefan Roese sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c); 967*9eefe2a2SStefan Roese if (c->max_inode_sz > MAX_LFS_FILESIZE) 968*9eefe2a2SStefan Roese sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE; 969*9eefe2a2SStefan Roese 970*9eefe2a2SStefan Roese mutex_lock(&c->umount_mutex); 971*9eefe2a2SStefan Roese err = mount_ubifs(c); 972*9eefe2a2SStefan Roese if (err) { 973*9eefe2a2SStefan Roese ubifs_assert(err < 0); 974*9eefe2a2SStefan Roese goto out_unlock; 975*9eefe2a2SStefan Roese } 976*9eefe2a2SStefan Roese 977*9eefe2a2SStefan Roese /* Read the root inode */ 978*9eefe2a2SStefan Roese root = ubifs_iget(sb, UBIFS_ROOT_INO); 979*9eefe2a2SStefan Roese if (IS_ERR(root)) { 980*9eefe2a2SStefan Roese err = PTR_ERR(root); 981*9eefe2a2SStefan Roese goto out_umount; 982*9eefe2a2SStefan Roese } 983*9eefe2a2SStefan Roese 984*9eefe2a2SStefan Roese sb->s_root = NULL; 985*9eefe2a2SStefan Roese 986*9eefe2a2SStefan Roese mutex_unlock(&c->umount_mutex); 987*9eefe2a2SStefan Roese return 0; 988*9eefe2a2SStefan Roese 989*9eefe2a2SStefan Roese out_umount: 990*9eefe2a2SStefan Roese ubifs_umount(c); 991*9eefe2a2SStefan Roese out_unlock: 992*9eefe2a2SStefan Roese mutex_unlock(&c->umount_mutex); 993*9eefe2a2SStefan Roese ubi_close_volume(c->ubi); 994*9eefe2a2SStefan Roese out_free: 995*9eefe2a2SStefan Roese kfree(c); 996*9eefe2a2SStefan Roese return err; 997*9eefe2a2SStefan Roese } 998*9eefe2a2SStefan Roese 999*9eefe2a2SStefan Roese static int sb_test(struct super_block *sb, void *data) 1000*9eefe2a2SStefan Roese { 1001*9eefe2a2SStefan Roese dev_t *dev = data; 1002*9eefe2a2SStefan Roese 1003*9eefe2a2SStefan Roese return sb->s_dev == *dev; 1004*9eefe2a2SStefan Roese } 1005*9eefe2a2SStefan Roese 1006*9eefe2a2SStefan Roese static int ubifs_get_sb(struct file_system_type *fs_type, int flags, 1007*9eefe2a2SStefan Roese const char *name, void *data, struct vfsmount *mnt) 1008*9eefe2a2SStefan Roese { 1009*9eefe2a2SStefan Roese struct ubi_volume_desc *ubi; 1010*9eefe2a2SStefan Roese struct ubi_volume_info vi; 1011*9eefe2a2SStefan Roese struct super_block *sb; 1012*9eefe2a2SStefan Roese int err; 1013*9eefe2a2SStefan Roese 1014*9eefe2a2SStefan Roese dbg_gen("name %s, flags %#x", name, flags); 1015*9eefe2a2SStefan Roese 1016*9eefe2a2SStefan Roese /* 1017*9eefe2a2SStefan Roese * Get UBI device number and volume ID. Mount it read-only so far 1018*9eefe2a2SStefan Roese * because this might be a new mount point, and UBI allows only one 1019*9eefe2a2SStefan Roese * read-write user at a time. 1020*9eefe2a2SStefan Roese */ 1021*9eefe2a2SStefan Roese ubi = open_ubi(name, UBI_READONLY); 1022*9eefe2a2SStefan Roese if (IS_ERR(ubi)) { 1023*9eefe2a2SStefan Roese ubifs_err("cannot open \"%s\", error %d", 1024*9eefe2a2SStefan Roese name, (int)PTR_ERR(ubi)); 1025*9eefe2a2SStefan Roese return PTR_ERR(ubi); 1026*9eefe2a2SStefan Roese } 1027*9eefe2a2SStefan Roese ubi_get_volume_info(ubi, &vi); 1028*9eefe2a2SStefan Roese 1029*9eefe2a2SStefan Roese dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id); 1030*9eefe2a2SStefan Roese 1031*9eefe2a2SStefan Roese sb = sget(fs_type, &sb_test, &sb_set, &vi.cdev); 1032*9eefe2a2SStefan Roese if (IS_ERR(sb)) { 1033*9eefe2a2SStefan Roese err = PTR_ERR(sb); 1034*9eefe2a2SStefan Roese goto out_close; 1035*9eefe2a2SStefan Roese } 1036*9eefe2a2SStefan Roese 1037*9eefe2a2SStefan Roese if (sb->s_root) { 1038*9eefe2a2SStefan Roese /* A new mount point for already mounted UBIFS */ 1039*9eefe2a2SStefan Roese dbg_gen("this ubi volume is already mounted"); 1040*9eefe2a2SStefan Roese if ((flags ^ sb->s_flags) & MS_RDONLY) { 1041*9eefe2a2SStefan Roese err = -EBUSY; 1042*9eefe2a2SStefan Roese goto out_deact; 1043*9eefe2a2SStefan Roese } 1044*9eefe2a2SStefan Roese } else { 1045*9eefe2a2SStefan Roese sb->s_flags = flags; 1046*9eefe2a2SStefan Roese /* 1047*9eefe2a2SStefan Roese * Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is 1048*9eefe2a2SStefan Roese * replaced by 'c'. 1049*9eefe2a2SStefan Roese */ 1050*9eefe2a2SStefan Roese sb->s_fs_info = ubi; 1051*9eefe2a2SStefan Roese err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 1052*9eefe2a2SStefan Roese if (err) 1053*9eefe2a2SStefan Roese goto out_deact; 1054*9eefe2a2SStefan Roese /* We do not support atime */ 1055*9eefe2a2SStefan Roese sb->s_flags |= MS_ACTIVE | MS_NOATIME; 1056*9eefe2a2SStefan Roese } 1057*9eefe2a2SStefan Roese 1058*9eefe2a2SStefan Roese /* 'fill_super()' opens ubi again so we must close it here */ 1059*9eefe2a2SStefan Roese ubi_close_volume(ubi); 1060*9eefe2a2SStefan Roese 1061*9eefe2a2SStefan Roese ubifs_sb = sb; 1062*9eefe2a2SStefan Roese return 0; 1063*9eefe2a2SStefan Roese 1064*9eefe2a2SStefan Roese out_deact: 1065*9eefe2a2SStefan Roese up_write(&sb->s_umount); 1066*9eefe2a2SStefan Roese out_close: 1067*9eefe2a2SStefan Roese ubi_close_volume(ubi); 1068*9eefe2a2SStefan Roese return err; 1069*9eefe2a2SStefan Roese } 1070*9eefe2a2SStefan Roese 1071*9eefe2a2SStefan Roese int __init ubifs_init(void) 1072*9eefe2a2SStefan Roese { 1073*9eefe2a2SStefan Roese int err; 1074*9eefe2a2SStefan Roese 1075*9eefe2a2SStefan Roese BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24); 1076*9eefe2a2SStefan Roese 1077*9eefe2a2SStefan Roese /* Make sure node sizes are 8-byte aligned */ 1078*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_CH_SZ & 7); 1079*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ & 7); 1080*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7); 1081*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7); 1082*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7); 1083*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7); 1084*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_SB_NODE_SZ & 7); 1085*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MST_NODE_SZ & 7); 1086*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_REF_NODE_SZ & 7); 1087*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_CS_NODE_SZ & 7); 1088*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7); 1089*9eefe2a2SStefan Roese 1090*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7); 1091*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7); 1092*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7); 1093*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ & 7); 1094*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_NODE_SZ & 7); 1095*9eefe2a2SStefan Roese BUILD_BUG_ON(MIN_WRITE_SZ & 7); 1096*9eefe2a2SStefan Roese 1097*9eefe2a2SStefan Roese /* Check min. node size */ 1098*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ < MIN_WRITE_SZ); 1099*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ); 1100*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ); 1101*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ); 1102*9eefe2a2SStefan Roese 1103*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 1104*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ); 1105*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ); 1106*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ > UBIFS_MAX_NODE_SZ); 1107*9eefe2a2SStefan Roese 1108*9eefe2a2SStefan Roese /* Defined node sizes */ 1109*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_SB_NODE_SZ != 4096); 1110*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512); 1111*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160); 1112*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64); 1113*9eefe2a2SStefan Roese 1114*9eefe2a2SStefan Roese /* 1115*9eefe2a2SStefan Roese * We use 2 bit wide bit-fields to store compression type, which should 1116*9eefe2a2SStefan Roese * be amended if more compressors are added. The bit-fields are: 1117*9eefe2a2SStefan Roese * @compr_type in 'struct ubifs_inode', @default_compr in 1118*9eefe2a2SStefan Roese * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'. 1119*9eefe2a2SStefan Roese */ 1120*9eefe2a2SStefan Roese BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4); 1121*9eefe2a2SStefan Roese 1122*9eefe2a2SStefan Roese /* 1123*9eefe2a2SStefan Roese * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to 1124*9eefe2a2SStefan Roese * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2. 1125*9eefe2a2SStefan Roese */ 1126*9eefe2a2SStefan Roese if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) { 1127*9eefe2a2SStefan Roese ubifs_err("VFS page cache size is %u bytes, but UBIFS requires" 1128*9eefe2a2SStefan Roese " at least 4096 bytes", 1129*9eefe2a2SStefan Roese (unsigned int)PAGE_CACHE_SIZE); 1130*9eefe2a2SStefan Roese return -EINVAL; 1131*9eefe2a2SStefan Roese } 1132*9eefe2a2SStefan Roese 1133*9eefe2a2SStefan Roese err = -ENOMEM; 1134*9eefe2a2SStefan Roese 1135*9eefe2a2SStefan Roese err = ubifs_compressors_init(); 1136*9eefe2a2SStefan Roese if (err) 1137*9eefe2a2SStefan Roese goto out_shrinker; 1138*9eefe2a2SStefan Roese 1139*9eefe2a2SStefan Roese return 0; 1140*9eefe2a2SStefan Roese 1141*9eefe2a2SStefan Roese out_shrinker: 1142*9eefe2a2SStefan Roese return err; 1143*9eefe2a2SStefan Roese } 1144*9eefe2a2SStefan Roese 1145*9eefe2a2SStefan Roese /* 1146*9eefe2a2SStefan Roese * ubifsmount... 1147*9eefe2a2SStefan Roese */ 1148*9eefe2a2SStefan Roese 1149*9eefe2a2SStefan Roese static struct file_system_type ubifs_fs_type = { 1150*9eefe2a2SStefan Roese .name = "ubifs", 1151*9eefe2a2SStefan Roese .owner = THIS_MODULE, 1152*9eefe2a2SStefan Roese .get_sb = ubifs_get_sb, 1153*9eefe2a2SStefan Roese }; 1154*9eefe2a2SStefan Roese 1155*9eefe2a2SStefan Roese int ubifs_mount(char *vol_name) 1156*9eefe2a2SStefan Roese { 1157*9eefe2a2SStefan Roese int flags; 1158*9eefe2a2SStefan Roese char name[80] = "ubi:"; 1159*9eefe2a2SStefan Roese void *data; 1160*9eefe2a2SStefan Roese struct vfsmount *mnt; 1161*9eefe2a2SStefan Roese int ret; 1162*9eefe2a2SStefan Roese struct ubifs_info *c; 1163*9eefe2a2SStefan Roese 1164*9eefe2a2SStefan Roese /* 1165*9eefe2a2SStefan Roese * First unmount if allready mounted 1166*9eefe2a2SStefan Roese */ 1167*9eefe2a2SStefan Roese if (ubifs_sb) 1168*9eefe2a2SStefan Roese ubifs_umount(ubifs_sb->s_fs_info); 1169*9eefe2a2SStefan Roese 1170*9eefe2a2SStefan Roese INIT_LIST_HEAD(&ubifs_infos); 1171*9eefe2a2SStefan Roese 1172*9eefe2a2SStefan Roese /* 1173*9eefe2a2SStefan Roese * Mount in read-only mode 1174*9eefe2a2SStefan Roese */ 1175*9eefe2a2SStefan Roese flags = MS_RDONLY; 1176*9eefe2a2SStefan Roese strcat(name, vol_name); 1177*9eefe2a2SStefan Roese data = NULL; 1178*9eefe2a2SStefan Roese mnt = NULL; 1179*9eefe2a2SStefan Roese ret = ubifs_get_sb(&ubifs_fs_type, flags, name, data, mnt); 1180*9eefe2a2SStefan Roese if (ret) { 1181*9eefe2a2SStefan Roese printf("Error reading superblock on volume '%s'!\n", name); 1182*9eefe2a2SStefan Roese return -1; 1183*9eefe2a2SStefan Roese } 1184*9eefe2a2SStefan Roese 1185*9eefe2a2SStefan Roese c = ubifs_sb->s_fs_info; 1186*9eefe2a2SStefan Roese ubi_close_volume(c->ubi); 1187*9eefe2a2SStefan Roese 1188*9eefe2a2SStefan Roese return 0; 1189*9eefe2a2SStefan Roese } 1190