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.56 2005/07/06 12:13:09 dwmw2 Exp $
  11  *
  12  */
  13
  14 #include <linux/config.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         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_WRITEBUFFER
 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         if (c->mtd->type == MTD_DATAFLASH) {
 458                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 459                 return -EINVAL;
 460         }
 461 #endif
 462
 463         c->flash_size = c->mtd->size;
 464
 465         /*
 466          * Check, if we have to concatenate physical blocks to larger virtual blocks
 467          * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
 468          */
 469         c->sector_size = c->mtd->erasesize;
 470         blocks = c->flash_size / c->sector_size;
 471         if (!(c->mtd->flags & MTD_NO_VIRTBLOCKS)) {
 472                 while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) {
 473                         blocks >>= 1;
 474                         c->sector_size <<= 1;
 475                 }
 476         }
 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->sector_size != c->mtd->erasesize)
 488                 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
 489                         c->mtd->erasesize / 1024, c->sector_size / 1024);
 490
 491         if (c->flash_size < 5*c->sector_size) {
 492                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 493                 return -EINVAL;
 494         }
 495
 496         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 497         /* Joern -- stick alignment for weird 8-byte-page flash here */
 498
 499         /* NAND (or other bizarre) flash... do setup accordingly */
 500         ret = jffs2_flash_setup(c);
 501         if (ret)
 502                 return ret;
 503
 504         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 505         if (!c->inocache_list) {
 506                 ret = -ENOMEM;
 507                 goto out_wbuf;
 508         }
 509         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 510
 511         if ((ret = jffs2_do_mount_fs(c)))
 512                 goto out_inohash;
 513
 514         ret = -EINVAL;
 515
 516         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 517         root_i = iget(sb, 1);
 518         if (is_bad_inode(root_i)) {
 519                 D1(printk(KERN_WARNING "get root inode failed\n"));
 520                 goto out_nodes;
 521         }
 522
 523         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 524         sb->s_root = d_alloc_root(root_i);
 525         if (!sb->s_root)
 526                 goto out_root_i;
 527
 528         sb->s_maxbytes = 0xFFFFFFFF;
 529         sb->s_blocksize = PAGE_CACHE_SIZE;
 530         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 531         sb->s_magic = JFFS2_SUPER_MAGIC;
 532         if (!(sb->s_flags & MS_RDONLY))
 533                 jffs2_start_garbage_collect_thread(c);
 534         return 0;
 535
 536  out_root_i:
 537         iput(root_i);
 538  out_nodes:
 539         jffs2_free_ino_caches(c);
 540         jffs2_free_raw_node_refs(c);
 541         if (c->mtd->flags & MTD_NO_VIRTBLOCKS)
 542                 vfree(c->blocks);
 543         else
 544                 kfree(c->blocks);
 545  out_inohash:
 546         kfree(c->inocache_list);
 547  out_wbuf:
 548         jffs2_flash_cleanup(c);
 549
 550         return ret;
 551 }
 552
 553 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 554                                    struct jffs2_inode_info *f)
 555 {
 556         iput(OFNI_EDONI_2SFFJ(f));
 557 }
 558
 559 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 560                                                      int inum, int nlink)
 561 {
 562         struct inode *inode;
 563         struct jffs2_inode_cache *ic;
 564         if (!nlink) {
 565                 /* The inode has zero nlink but its nodes weren't yet marked
 566                    obsolete. This has to be because we're still waiting for
 567                    the final (close() and) iput() to happen.
 568
 569                    There's a possibility that the final iput() could have
 570                    happened while we were contemplating. In order to ensure
 571                    that we don't cause a new read_inode() (which would fail)
 572                    for the inode in question, we use ilookup() in this case
 573                    instead of iget().
 574
 575                    The nlink can't _become_ zero at this point because we're
 576                    holding the alloc_sem, and jffs2_do_unlink() would also
 577                    need that while decrementing nlink on any inode.
 578                 */
 579                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 580                 if (!inode) {
 581                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 582                                   inum));
 583
 584                         spin_lock(&c->inocache_lock);
 585                         ic = jffs2_get_ino_cache(c, inum);
 586                         if (!ic) {
 587                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 588                                 spin_unlock(&c->inocache_lock);
 589                                 return NULL;
 590                         }
 591                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 592                                 /* Wait for progress. Don't just loop */
 593                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 594                                           ic->ino, ic->state));
 595                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 596                         } else {
 597                                 spin_unlock(&c->inocache_lock);
 598                         }
 599
 600                         return NULL;
 601                 }
 602         } else {
 603                 /* Inode has links to it still; they're not going away because
 604                    jffs2_do_unlink() would need the alloc_sem and we have it.
 605                    Just iget() it, and if read_inode() is necessary that's OK.
 606                 */
 607                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 608                 if (!inode)
 609                         return ERR_PTR(-ENOMEM);
 610         }
 611         if (is_bad_inode(inode)) {
 612                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 613                        inum, nlink);
 614                 /* NB. This will happen again. We need to do something appropriate here. */
 615                 iput(inode);
 616                 return ERR_PTR(-EIO);
 617         }
 618
 619         return JFFS2_INODE_INFO(inode);
 620 }
 621
 622 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 623                                    struct jffs2_inode_info *f,
 624                                    unsigned long offset,
 625                                    unsigned long *priv)
 626 {
 627         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 628         struct page *pg;
 629
 630         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 631                              (void *)jffs2_do_readpage_unlock, inode);
 632         if (IS_ERR(pg))
 633                 return (void *)pg;
 634
 635         *priv = (unsigned long)pg;
 636         return kmap(pg);
 637 }
 638
 639 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 640                            unsigned char *ptr,
 641                            unsigned long *priv)
 642 {
 643         struct page *pg = (void *)*priv;
 644
 645         kunmap(pg);
 646         page_cache_release(pg);
 647 }
 648
 649 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 650         int ret = 0;
 651
 652         if (jffs2_cleanmarker_oob(c)) {
 653                 /* NAND flash... do setup accordingly */
 654                 ret = jffs2_nand_flash_setup(c);
 655                 if (ret)
 656                         return ret;
 657         }
 658
 659         /* add setups for other bizarre flashes here... */
 660         if (jffs2_nor_ecc(c)) {
 661                 ret = jffs2_nor_ecc_flash_setup(c);
 662                 if (ret)
 663                         return ret;
 664         }
 665
 666         /* and Dataflash */
 667         if (jffs2_dataflash(c)) {
 668                 ret = jffs2_dataflash_setup(c);
 669                 if (ret)
 670                         return ret;
 671         }
 672
 673         return ret;
 674 }
 675
 676 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 677
 678         if (jffs2_cleanmarker_oob(c)) {
 679                 jffs2_nand_flash_cleanup(c);
 680         }
 681
 682         /* add cleanups for other bizarre flashes here... */
 683         if (jffs2_nor_ecc(c)) {
 684                 jffs2_nor_ecc_flash_cleanup(c);
 685         }
 686
 687         /* and DataFlash */
 688         if (jffs2_dataflash(c)) {
 689                 jffs2_dataflash_cleanup(c);
 690         }
 691 }