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