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