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