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