fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc.
   5  * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
   6  *
   7  * Created by David Woodhouse <dwmw2@infradead.org>
   8  *
   9  * For licensing information, see the file 'LICENCE' in this directory.
  10  *
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/capability.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/fs.h>
  19 #include <linux/list.h>
  20 #include <linux/mtd/mtd.h>
  21 #include <linux/pagemap.h>
  22 #include <linux/slab.h>
  23 #include <linux/vmalloc.h>
  24 #include <linux/vfs.h>
  25 #include <linux/crc32.h>
  26 #include "nodelist.h"
  27
  28 static int jffs2_flash_setup(struct jffs2_sb_info *c);
  29
  30 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  31 {
  32         struct jffs2_full_dnode *old_metadata, *new_metadata;
  33         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  34         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  35         struct jffs2_raw_inode *ri;
  36         union jffs2_device_node dev;
  37         unsigned char *mdata = NULL;
  38         int mdatalen = 0;
  39         unsigned int ivalid;
  40         uint32_t alloclen;
  41         int ret;
  42         int alloc_type = ALLOC_NORMAL;
  43
  44         jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
  45
  46         /* Special cases - we don't want more than one data node
  47            for these types on the medium at any time. So setattr
  48            must read the original data associated with the node
  49            (i.e. the device numbers or the target name) and write
  50            it out again with the appropriate data attached */
  51         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  52                 /* For these, we don't actually need to read the old node */
  53                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  54                 mdata = (char *)&dev;
  55                 jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
  56                           __func__, mdatalen);
  57         } else if (S_ISLNK(inode->i_mode)) {
  58                 mutex_lock(&f->sem);
  59                 mdatalen = f->metadata->size;
  60                 mdata = kmalloc(f->metadata->size, GFP_USER);
  61                 if (!mdata) {
  62                         mutex_unlock(&f->sem);
  63                         return -ENOMEM;
  64                 }
  65                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  66                 if (ret) {
  67                         mutex_unlock(&f->sem);
  68                         kfree(mdata);
  69                         return ret;
  70                 }
  71                 mutex_unlock(&f->sem);
  72                 jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
  73                           __func__, mdatalen);
  74         }
  75
  76         ri = jffs2_alloc_raw_inode();
  77         if (!ri) {
  78                 if (S_ISLNK(inode->i_mode))
  79                         kfree(mdata);
  80                 return -ENOMEM;
  81         }
  82
  83         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
  84                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  85         if (ret) {
  86                 jffs2_free_raw_inode(ri);
  87                 if (S_ISLNK(inode->i_mode))
  88                          kfree(mdata);
  89                 return ret;
  90         }
  91         mutex_lock(&f->sem);
  92         ivalid = iattr->ia_valid;
  93
  94         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  95         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  96         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  97         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  98
  99         ri->ino = cpu_to_je32(inode->i_ino);
 100         ri->version = cpu_to_je32(++f->highest_version);
 101
 102         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
 103                 from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
 104         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
 105                 from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
 106
 107         if (ivalid & ATTR_MODE)
 108                 ri->mode = cpu_to_jemode(iattr->ia_mode);
 109         else
 110                 ri->mode = cpu_to_jemode(inode->i_mode);
 111
 112
 113         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 114         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 115         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 116         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 117
 118         ri->offset = cpu_to_je32(0);
 119         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 120         ri->compr = JFFS2_COMPR_NONE;
 121         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 122                 /* It's an extension. Make it a hole node */
 123                 ri->compr = JFFS2_COMPR_ZERO;
 124                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 125                 ri->offset = cpu_to_je32(inode->i_size);
 126         } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
 127                 /* For truncate-to-zero, treat it as deletion because
 128                    it'll always be obsoleting all previous nodes */
 129                 alloc_type = ALLOC_DELETION;
 130         }
 131         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 132         if (mdatalen)
 133                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 134         else
 135                 ri->data_crc = cpu_to_je32(0);
 136
 137         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
 138         if (S_ISLNK(inode->i_mode))
 139                 kfree(mdata);
 140
 141         if (IS_ERR(new_metadata)) {
 142                 jffs2_complete_reservation(c);
 143                 jffs2_free_raw_inode(ri);
 144                 mutex_unlock(&f->sem);
 145                 return PTR_ERR(new_metadata);
 146         }
 147         /* It worked. Update the inode */
 148         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 149         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 150         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 151         inode->i_mode = jemode_to_cpu(ri->mode);
 152         i_uid_write(inode, je16_to_cpu(ri->uid));
 153         i_gid_write(inode, je16_to_cpu(ri->gid));
 154
 155
 156         old_metadata = f->metadata;
 157
 158         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 159                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 160
 161         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 162                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 163                 inode->i_size = iattr->ia_size;
 164                 inode->i_blocks = (inode->i_size + 511) >> 9;
 165                 f->metadata = NULL;
 166         } else {
 167                 f->metadata = new_metadata;
 168         }
 169         if (old_metadata) {
 170                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 171                 jffs2_free_full_dnode(old_metadata);
 172         }
 173         jffs2_free_raw_inode(ri);
 174
 175         mutex_unlock(&f->sem);
 176         jffs2_complete_reservation(c);
 177
 178         /* We have to do the truncate_setsize() without f->sem held, since
 179            some pages may be locked and waiting for it in readpage().
 180            We are protected from a simultaneous write() extending i_size
 181            back past iattr->ia_size, because do_truncate() holds the
 182            generic inode semaphore. */
 183         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
 184                 truncate_setsize(inode, iattr->ia_size);
 185                 inode->i_blocks = (inode->i_size + 511) >> 9;
 186         }
 187
 188         return 0;
 189 }
 190
 191 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 192 {
 193         struct inode *inode = d_inode(dentry);
 194         int rc;
 195
 196         rc = inode_change_ok(inode, iattr);
 197         if (rc)
 198                 return rc;
 199
 200         rc = jffs2_do_setattr(inode, iattr);
 201         if (!rc && (iattr->ia_valid & ATTR_MODE))
 202                 rc = posix_acl_chmod(inode, inode->i_mode);
 203
 204         return rc;
 205 }
 206
 207 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 208 {
 209         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 210         unsigned long avail;
 211
 212         buf->f_type = JFFS2_SUPER_MAGIC;
 213         buf->f_bsize = 1 << PAGE_SHIFT;
 214         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 215         buf->f_files = 0;
 216         buf->f_ffree = 0;
 217         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 218         buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
 219         buf->f_fsid.val[1] = c->mtd->index;
 220
 221         spin_lock(&c->erase_completion_lock);
 222         avail = c->dirty_size + c->free_size;
 223         if (avail > c->sector_size * c->resv_blocks_write)
 224                 avail -= c->sector_size * c->resv_blocks_write;
 225         else
 226                 avail = 0;
 227         spin_unlock(&c->erase_completion_lock);
 228
 229         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 230
 231         return 0;
 232 }
 233
 234
 235 void jffs2_evict_inode (struct inode *inode)
 236 {
 237         /* We can forget about this inode for now - drop all
 238          *  the nodelists associated with it, etc.
 239          */
 240         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 241         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 242
 243         jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
 244                   __func__, inode->i_ino, inode->i_mode);
 245         truncate_inode_pages_final(&inode->i_data);
 246         clear_inode(inode);
 247         jffs2_do_clear_inode(c, f);
 248 }
 249
 250 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
 251 {
 252         struct jffs2_inode_info *f;
 253         struct jffs2_sb_info *c;
 254         struct jffs2_raw_inode latest_node;
 255         union jffs2_device_node jdev;
 256         struct inode *inode;
 257         dev_t rdev = 0;
 258         int ret;
 259
 260         jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
 261
 262         inode = iget_locked(sb, ino);
 263         if (!inode)
 264                 return ERR_PTR(-ENOMEM);
 265         if (!(inode->i_state & I_NEW))
 266                 return inode;
 267
 268         f = JFFS2_INODE_INFO(inode);
 269         c = JFFS2_SB_INFO(inode->i_sb);
 270
 271         jffs2_init_inode_info(f);
 272         mutex_lock(&f->sem);
 273
 274         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 275
 276         if (ret) {
 277                 mutex_unlock(&f->sem);
 278                 iget_failed(inode);
 279                 return ERR_PTR(ret);
 280         }
 281         inode->i_mode = jemode_to_cpu(latest_node.mode);
 282         i_uid_write(inode, je16_to_cpu(latest_node.uid));
 283         i_gid_write(inode, je16_to_cpu(latest_node.gid));
 284         inode->i_size = je32_to_cpu(latest_node.isize);
 285         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 286         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 287         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 288
 289         set_nlink(inode, f->inocache->pino_nlink);
 290
 291         inode->i_blocks = (inode->i_size + 511) >> 9;
 292
 293         switch (inode->i_mode & S_IFMT) {
 294
 295         case S_IFLNK:
 296                 inode->i_op = &jffs2_symlink_inode_operations;
 297                 inode->i_link = f->target;
 298                 break;
 299
 300         case S_IFDIR:
 301         {
 302                 struct jffs2_full_dirent *fd;
 303                 set_nlink(inode, 2); /* parent and '.' */
 304
 305                 for (fd=f->dents; fd; fd = fd->next) {
 306                         if (fd->type == DT_DIR && fd->ino)
 307                                 inc_nlink(inode);
 308                 }
 309                 /* Root dir gets i_nlink 3 for some reason */
 310                 if (inode->i_ino == 1)
 311                         inc_nlink(inode);
 312
 313                 inode->i_op = &jffs2_dir_inode_operations;
 314                 inode->i_fop = &jffs2_dir_operations;
 315                 break;
 316         }
 317         case S_IFREG:
 318                 inode->i_op = &jffs2_file_inode_operations;
 319                 inode->i_fop = &jffs2_file_operations;
 320                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 321                 inode->i_mapping->nrpages = 0;
 322                 break;
 323
 324         case S_IFBLK:
 325         case S_IFCHR:
 326                 /* Read the device numbers from the media */
 327                 if (f->metadata->size != sizeof(jdev.old_id) &&
 328                     f->metadata->size != sizeof(jdev.new_id)) {
 329                         pr_notice("Device node has strange size %d\n",
 330                                   f->metadata->size);
 331                         goto error_io;
 332                 }
 333                 jffs2_dbg(1, "Reading device numbers from flash\n");
 334                 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
 335                 if (ret < 0) {
 336                         /* Eep */
 337                         pr_notice("Read device numbers for inode %lu failed\n",
 338                                   (unsigned long)inode->i_ino);
 339                         goto error;
 340                 }
 341                 if (f->metadata->size == sizeof(jdev.old_id))
 342                         rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
 343                 else
 344                         rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
 345
 346         case S_IFSOCK:
 347         case S_IFIFO:
 348                 inode->i_op = &jffs2_file_inode_operations;
 349                 init_special_inode(inode, inode->i_mode, rdev);
 350                 break;
 351
 352         default:
 353                 pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
 354                         __func__, inode->i_mode, (unsigned long)inode->i_ino);
 355         }
 356
 357         mutex_unlock(&f->sem);
 358
 359         jffs2_dbg(1, "jffs2_read_inode() returning\n");
 360         unlock_new_inode(inode);
 361         return inode;
 362
 363 error_io:
 364         ret = -EIO;
 365 error:
 366         mutex_unlock(&f->sem);
 367         jffs2_do_clear_inode(c, f);
 368         iget_failed(inode);
 369         return ERR_PTR(ret);
 370 }
 371
 372 void jffs2_dirty_inode(struct inode *inode, int flags)
 373 {
 374         struct iattr iattr;
 375
 376         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 377                 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
 378                           __func__, inode->i_ino);
 379                 return;
 380         }
 381
 382         jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
 383                   __func__, inode->i_ino);
 384
 385         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 386         iattr.ia_mode = inode->i_mode;
 387         iattr.ia_uid = inode->i_uid;
 388         iattr.ia_gid = inode->i_gid;
 389         iattr.ia_atime = inode->i_atime;
 390         iattr.ia_mtime = inode->i_mtime;
 391         iattr.ia_ctime = inode->i_ctime;
 392
 393         jffs2_do_setattr(inode, &iattr);
 394 }
 395
 396 int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
 397 {
 398         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 399
 400         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 401                 return -EROFS;
 402
 403         /* We stop if it was running, then restart if it needs to.
 404            This also catches the case where it was stopped and this
 405            is just a remount to restart it.
 406            Flush the writebuffer, if neccecary, else we loose it */
 407         if (!(sb->s_flags & MS_RDONLY)) {
 408                 jffs2_stop_garbage_collect_thread(c);
 409                 mutex_lock(&c->alloc_sem);
 410                 jffs2_flush_wbuf_pad(c);
 411                 mutex_unlock(&c->alloc_sem);
 412         }
 413
 414         if (!(*flags & MS_RDONLY))
 415                 jffs2_start_garbage_collect_thread(c);
 416
 417         *flags |= MS_NOATIME;
 418         return 0;
 419 }
 420
 421 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 422    fill in the raw_inode while you're at it. */
 423 struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
 424 {
 425         struct inode *inode;
 426         struct super_block *sb = dir_i->i_sb;
 427         struct jffs2_sb_info *c;
 428         struct jffs2_inode_info *f;
 429         int ret;
 430
 431         jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
 432                   __func__, dir_i->i_ino, mode);
 433
 434         c = JFFS2_SB_INFO(sb);
 435
 436         inode = new_inode(sb);
 437
 438         if (!inode)
 439                 return ERR_PTR(-ENOMEM);
 440
 441         f = JFFS2_INODE_INFO(inode);
 442         jffs2_init_inode_info(f);
 443         mutex_lock(&f->sem);
 444
 445         memset(ri, 0, sizeof(*ri));
 446         /* Set OS-specific defaults for new inodes */
 447         ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid()));
 448
 449         if (dir_i->i_mode & S_ISGID) {
 450                 ri->gid = cpu_to_je16(i_gid_read(dir_i));
 451                 if (S_ISDIR(mode))
 452                         mode |= S_ISGID;
 453         } else {
 454                 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid()));
 455         }
 456
 457         /* POSIX ACLs have to be processed now, at least partly.
 458            The umask is only applied if there's no default ACL */
 459         ret = jffs2_init_acl_pre(dir_i, inode, &mode);
 460         if (ret) {
 461                 mutex_unlock(&f->sem);
 462                 make_bad_inode(inode);
 463                 iput(inode);
 464                 return ERR_PTR(ret);
 465         }
 466         ret = jffs2_do_new_inode (c, f, mode, ri);
 467         if (ret) {
 468                 mutex_unlock(&f->sem);
 469                 make_bad_inode(inode);
 470                 iput(inode);
 471                 return ERR_PTR(ret);
 472         }
 473         set_nlink(inode, 1);
 474         inode->i_ino = je32_to_cpu(ri->ino);
 475         inode->i_mode = jemode_to_cpu(ri->mode);
 476         i_gid_write(inode, je16_to_cpu(ri->gid));
 477         i_uid_write(inode, je16_to_cpu(ri->uid));
 478         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 479         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 480
 481         inode->i_blocks = 0;
 482         inode->i_size = 0;
 483
 484         if (insert_inode_locked(inode) < 0) {
 485                 mutex_unlock(&f->sem);
 486                 make_bad_inode(inode);
 487                 iput(inode);
 488                 return ERR_PTR(-EINVAL);
 489         }
 490
 491         return inode;
 492 }
 493
 494 static int calculate_inocache_hashsize(uint32_t flash_size)
 495 {
 496         /*
 497          * Pick a inocache hash size based on the size of the medium.
 498          * Count how many megabytes we're dealing with, apply a hashsize twice
 499          * that size, but rounding down to the usual big powers of 2. And keep
 500          * to sensible bounds.
 501          */
 502
 503         int size_mb = flash_size / 1024 / 1024;
 504         int hashsize = (size_mb * 2) & ~0x3f;
 505
 506         if (hashsize < INOCACHE_HASHSIZE_MIN)
 507                 return INOCACHE_HASHSIZE_MIN;
 508         if (hashsize > INOCACHE_HASHSIZE_MAX)
 509                 return INOCACHE_HASHSIZE_MAX;
 510
 511         return hashsize;
 512 }
 513
 514 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 515 {
 516         struct jffs2_sb_info *c;
 517         struct inode *root_i;
 518         int ret;
 519         size_t blocks;
 520
 521         c = JFFS2_SB_INFO(sb);
 522
 523         /* Do not support the MLC nand */
 524         if (c->mtd->type == MTD_MLCNANDFLASH)
 525                 return -EINVAL;
 526
 527 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 528         if (c->mtd->type == MTD_NANDFLASH) {
 529                 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
 530                 return -EINVAL;
 531         }
 532         if (c->mtd->type == MTD_DATAFLASH) {
 533                 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
 534                 return -EINVAL;
 535         }
 536 #endif
 537
 538         c->flash_size = c->mtd->size;
 539         c->sector_size = c->mtd->erasesize;
 540         blocks = c->flash_size / c->sector_size;
 541
 542         /*
 543          * Size alignment check
 544          */
 545         if ((c->sector_size * blocks) != c->flash_size) {
 546                 c->flash_size = c->sector_size * blocks;
 547                 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
 548                         c->flash_size / 1024);
 549         }
 550
 551         if (c->flash_size < 5*c->sector_size) {
 552                 pr_err("Too few erase blocks (%d)\n",
 553                        c->flash_size / c->sector_size);
 554                 return -EINVAL;
 555         }
 556
 557         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 558
 559         /* NAND (or other bizarre) flash... do setup accordingly */
 560         ret = jffs2_flash_setup(c);
 561         if (ret)
 562                 return ret;
 563
 564         c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
 565         c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 566         if (!c->inocache_list) {
 567                 ret = -ENOMEM;
 568                 goto out_wbuf;
 569         }
 570
 571         jffs2_init_xattr_subsystem(c);
 572
 573         if ((ret = jffs2_do_mount_fs(c)))
 574                 goto out_inohash;
 575
 576         jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
 577         root_i = jffs2_iget(sb, 1);
 578         if (IS_ERR(root_i)) {
 579                 jffs2_dbg(1, "get root inode failed\n");
 580                 ret = PTR_ERR(root_i);
 581                 goto out_root;
 582         }
 583
 584         ret = -ENOMEM;
 585
 586         jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
 587         sb->s_root = d_make_root(root_i);
 588         if (!sb->s_root)
 589                 goto out_root;
 590
 591         sb->s_maxbytes = 0xFFFFFFFF;
 592         sb->s_blocksize = PAGE_CACHE_SIZE;
 593         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 594         sb->s_magic = JFFS2_SUPER_MAGIC;
 595         if (!(sb->s_flags & MS_RDONLY))
 596                 jffs2_start_garbage_collect_thread(c);
 597         return 0;
 598
 599 out_root:
 600         jffs2_free_ino_caches(c);
 601         jffs2_free_raw_node_refs(c);
 602         if (jffs2_blocks_use_vmalloc(c))
 603                 vfree(c->blocks);
 604         else
 605                 kfree(c->blocks);
 606  out_inohash:
 607         jffs2_clear_xattr_subsystem(c);
 608         kfree(c->inocache_list);
 609  out_wbuf:
 610         jffs2_flash_cleanup(c);
 611
 612         return ret;
 613 }
 614
 615 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 616                                    struct jffs2_inode_info *f)
 617 {
 618         iput(OFNI_EDONI_2SFFJ(f));
 619 }
 620
 621 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 622                                               int inum, int unlinked)
 623 {
 624         struct inode *inode;
 625         struct jffs2_inode_cache *ic;
 626
 627         if (unlinked) {
 628                 /* The inode has zero nlink but its nodes weren't yet marked
 629                    obsolete. This has to be because we're still waiting for
 630                    the final (close() and) iput() to happen.
 631
 632                    There's a possibility that the final iput() could have
 633                    happened while we were contemplating. In order to ensure
 634                    that we don't cause a new read_inode() (which would fail)
 635                    for the inode in question, we use ilookup() in this case
 636                    instead of iget().
 637
 638                    The nlink can't _become_ zero at this point because we're
 639                    holding the alloc_sem, and jffs2_do_unlink() would also
 640                    need that while decrementing nlink on any inode.
 641                 */
 642                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 643                 if (!inode) {
 644                         jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
 645                                   inum);
 646
 647                         spin_lock(&c->inocache_lock);
 648                         ic = jffs2_get_ino_cache(c, inum);
 649                         if (!ic) {
 650                                 jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
 651                                           inum);
 652                                 spin_unlock(&c->inocache_lock);
 653                                 return NULL;
 654                         }
 655                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 656                                 /* Wait for progress. Don't just loop */
 657                                 jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
 658                                           ic->ino, ic->state);
 659                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 660                         } else {
 661                                 spin_unlock(&c->inocache_lock);
 662                         }
 663
 664                         return NULL;
 665                 }
 666         } else {
 667                 /* Inode has links to it still; they're not going away because
 668                    jffs2_do_unlink() would need the alloc_sem and we have it.
 669                    Just iget() it, and if read_inode() is necessary that's OK.
 670                 */
 671                 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
 672                 if (IS_ERR(inode))
 673                         return ERR_CAST(inode);
 674         }
 675         if (is_bad_inode(inode)) {
 676                 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
 677                           inum, unlinked);
 678                 /* NB. This will happen again. We need to do something appropriate here. */
 679                 iput(inode);
 680                 return ERR_PTR(-EIO);
 681         }
 682
 683         return JFFS2_INODE_INFO(inode);
 684 }
 685
 686 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 687                                    struct jffs2_inode_info *f,
 688                                    unsigned long offset,
 689                                    unsigned long *priv)
 690 {
 691         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 692         struct page *pg;
 693
 694         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 695                              (void *)jffs2_do_readpage_unlock, inode);
 696         if (IS_ERR(pg))
 697                 return (void *)pg;
 698
 699         *priv = (unsigned long)pg;
 700         return kmap(pg);
 701 }
 702
 703 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 704                            unsigned char *ptr,
 705                            unsigned long *priv)
 706 {
 707         struct page *pg = (void *)*priv;
 708
 709         kunmap(pg);
 710         page_cache_release(pg);
 711 }
 712
 713 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 714         int ret = 0;
 715
 716         if (jffs2_cleanmarker_oob(c)) {
 717                 /* NAND flash... do setup accordingly */
 718                 ret = jffs2_nand_flash_setup(c);
 719                 if (ret)
 720                         return ret;
 721         }
 722
 723         /* and Dataflash */
 724         if (jffs2_dataflash(c)) {
 725                 ret = jffs2_dataflash_setup(c);
 726                 if (ret)
 727                         return ret;
 728         }
 729
 730         /* and Intel "Sibley" flash */
 731         if (jffs2_nor_wbuf_flash(c)) {
 732                 ret = jffs2_nor_wbuf_flash_setup(c);
 733                 if (ret)
 734                         return ret;
 735         }
 736
 737         /* and an UBI volume */
 738         if (jffs2_ubivol(c)) {
 739                 ret = jffs2_ubivol_setup(c);
 740                 if (ret)
 741                         return ret;
 742         }
 743
 744         return ret;
 745 }
 746
 747 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 748
 749         if (jffs2_cleanmarker_oob(c)) {
 750                 jffs2_nand_flash_cleanup(c);
 751         }
 752
 753         /* and DataFlash */
 754         if (jffs2_dataflash(c)) {
 755                 jffs2_dataflash_cleanup(c);
 756         }
 757
 758         /* and Intel "Sibley" flash */
 759         if (jffs2_nor_wbuf_flash(c)) {
 760                 jffs2_nor_wbuf_flash_cleanup(c);
 761         }
 762
 763         /* and an UBI volume */
 764         if (jffs2_ubivol(c)) {
 765                 jffs2_ubivol_cleanup(c);
 766         }
 767 }