fs/jffs2/fs.c

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