fs/jffs2/fs.c

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