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/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,
  78                                 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  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_fragtree (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         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         spin_unlock(&c->erase_completion_lock);
 204
 205         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 206
 207         return 0;
 208 }
 209
 210
 211 void jffs2_clear_inode (struct inode *inode)
 212 {
 213         /* We can forget about this inode for now - drop all
 214          *  the nodelists associated with it, etc.
 215          */
 216         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 217         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 218
 219         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 220
 221         jffs2_do_clear_inode(c, f);
 222 }
 223
 224 void jffs2_read_inode (struct inode *inode)
 225 {
 226         struct jffs2_inode_info *f;
 227         struct jffs2_sb_info *c;
 228         struct jffs2_raw_inode latest_node;
 229         int ret;
 230
 231         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 232
 233         f = JFFS2_INODE_INFO(inode);
 234         c = JFFS2_SB_INFO(inode->i_sb);
 235
 236         jffs2_init_inode_info(f);
 237         down(&f->sem);
 238
 239         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 240
 241         if (ret) {
 242                 make_bad_inode(inode);
 243                 up(&f->sem);
 244                 return;
 245         }
 246         inode->i_mode = jemode_to_cpu(latest_node.mode);
 247         inode->i_uid = je16_to_cpu(latest_node.uid);
 248         inode->i_gid = je16_to_cpu(latest_node.gid);
 249         inode->i_size = je32_to_cpu(latest_node.isize);
 250         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 251         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 252         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 253
 254         inode->i_nlink = f->inocache->nlink;
 255
 256         inode->i_blksize = PAGE_SIZE;
 257         inode->i_blocks = (inode->i_size + 511) >> 9;
 258
 259         switch (inode->i_mode & S_IFMT) {
 260                 jint16_t rdev;
 261
 262         case S_IFLNK:
 263                 inode->i_op = &jffs2_symlink_inode_operations;
 264                 break;
 265
 266         case S_IFDIR:
 267         {
 268                 struct jffs2_full_dirent *fd;
 269
 270                 for (fd=f->dents; fd; fd = fd->next) {
 271                         if (fd->type == DT_DIR && fd->ino)
 272                                 inode->i_nlink++;
 273                 }
 274                 /* and '..' */
 275                 inode->i_nlink++;
 276                 /* Root dir gets i_nlink 3 for some reason */
 277                 if (inode->i_ino == 1)
 278                         inode->i_nlink++;
 279
 280                 inode->i_op = &jffs2_dir_inode_operations;
 281                 inode->i_fop = &jffs2_dir_operations;
 282                 break;
 283         }
 284         case S_IFREG:
 285                 inode->i_op = &jffs2_file_inode_operations;
 286                 inode->i_fop = &jffs2_file_operations;
 287                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 288                 inode->i_mapping->nrpages = 0;
 289                 break;
 290
 291         case S_IFBLK:
 292         case S_IFCHR:
 293                 /* Read the device numbers from the media */
 294                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 295                 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
 296                         /* Eep */
 297                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 298                         up(&f->sem);
 299                         jffs2_do_clear_inode(c, f);
 300                         make_bad_inode(inode);
 301                         return;
 302                 }
 303
 304         case S_IFSOCK:
 305         case S_IFIFO:
 306                 inode->i_op = &jffs2_file_inode_operations;
 307                 init_special_inode(inode, inode->i_mode,
 308                                    old_decode_dev((je16_to_cpu(rdev))));
 309                 break;
 310
 311         default:
 312                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 313         }
 314
 315         up(&f->sem);
 316
 317         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 318 }
 319
 320 void jffs2_dirty_inode(struct inode *inode)
 321 {
 322         struct iattr iattr;
 323
 324         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 325                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 326                 return;
 327         }
 328
 329         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 330
 331         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 332         iattr.ia_mode = inode->i_mode;
 333         iattr.ia_uid = inode->i_uid;
 334         iattr.ia_gid = inode->i_gid;
 335         iattr.ia_atime = inode->i_atime;
 336         iattr.ia_mtime = inode->i_mtime;
 337         iattr.ia_ctime = inode->i_ctime;
 338
 339         jffs2_do_setattr(inode, &iattr);
 340 }
 341
 342 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 343 {
 344         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 345
 346         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 347                 return -EROFS;
 348
 349         /* We stop if it was running, then restart if it needs to.
 350            This also catches the case where it was stopped and this
 351            is just a remount to restart it.
 352            Flush the writebuffer, if neccecary, else we loose it */
 353         if (!(sb->s_flags & MS_RDONLY)) {
 354                 jffs2_stop_garbage_collect_thread(c);
 355                 down(&c->alloc_sem);
 356                 jffs2_flush_wbuf_pad(c);
 357                 up(&c->alloc_sem);
 358         }
 359
 360         if (!(*flags & MS_RDONLY))
 361                 jffs2_start_garbage_collect_thread(c);
 362
 363         *flags |= MS_NOATIME;
 364
 365         return 0;
 366 }
 367
 368 void jffs2_write_super (struct super_block *sb)
 369 {
 370         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 371         sb->s_dirt = 0;
 372
 373         if (sb->s_flags & MS_RDONLY)
 374                 return;
 375
 376         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 377         jffs2_garbage_collect_trigger(c);
 378         jffs2_erase_pending_blocks(c, 0);
 379         jffs2_flush_wbuf_gc(c, 0);
 380 }
 381
 382
 383 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 384    fill in the raw_inode while you're at it. */
 385 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 386 {
 387         struct inode *inode;
 388         struct super_block *sb = dir_i->i_sb;
 389         struct jffs2_sb_info *c;
 390         struct jffs2_inode_info *f;
 391         int ret;
 392
 393         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 394
 395         c = JFFS2_SB_INFO(sb);
 396
 397         inode = new_inode(sb);
 398
 399         if (!inode)
 400                 return ERR_PTR(-ENOMEM);
 401
 402         f = JFFS2_INODE_INFO(inode);
 403         jffs2_init_inode_info(f);
 404         down(&f->sem);
 405
 406         memset(ri, 0, sizeof(*ri));
 407         /* Set OS-specific defaults for new inodes */
 408         ri->uid = cpu_to_je16(current->fsuid);
 409
 410         if (dir_i->i_mode & S_ISGID) {
 411                 ri->gid = cpu_to_je16(dir_i->i_gid);
 412                 if (S_ISDIR(mode))
 413                         mode |= S_ISGID;
 414         } else {
 415                 ri->gid = cpu_to_je16(current->fsgid);
 416         }
 417         ri->mode =  cpu_to_jemode(mode);
 418         ret = jffs2_do_new_inode (c, f, mode, ri);
 419         if (ret) {
 420                 make_bad_inode(inode);
 421                 iput(inode);
 422                 return ERR_PTR(ret);
 423         }
 424         inode->i_nlink = 1;
 425         inode->i_ino = je32_to_cpu(ri->ino);
 426         inode->i_mode = jemode_to_cpu(ri->mode);
 427         inode->i_gid = je16_to_cpu(ri->gid);
 428         inode->i_uid = je16_to_cpu(ri->uid);
 429         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 430         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 431
 432         inode->i_blksize = PAGE_SIZE;
 433         inode->i_blocks = 0;
 434         inode->i_size = 0;
 435
 436         insert_inode_hash(inode);
 437
 438         return inode;
 439 }
 440
 441
 442 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 443 {
 444         struct jffs2_sb_info *c;
 445         struct inode *root_i;
 446         int ret;
 447         size_t blocks;
 448
 449         c = JFFS2_SB_INFO(sb);
 450
 451 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 452         if (c->mtd->type == MTD_NANDFLASH) {
 453                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 454                 return -EINVAL;
 455         }
 456         if (c->mtd->type == MTD_DATAFLASH) {
 457                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 458                 return -EINVAL;
 459         }
 460 #endif
 461
 462         c->flash_size = c->mtd->size;
 463         c->sector_size = c->mtd->erasesize;
 464         blocks = c->flash_size / c->sector_size;
 465
 466         /*
 467          * Size alignment check
 468          */
 469         if ((c->sector_size * blocks) != c->flash_size) {
 470                 c->flash_size = c->sector_size * blocks;
 471                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 472                         c->flash_size / 1024);
 473         }
 474
 475         if (c->flash_size < 5*c->sector_size) {
 476                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 477                 return -EINVAL;
 478         }
 479
 480         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 481
 482         /* NAND (or other bizarre) flash... do setup accordingly */
 483         ret = jffs2_flash_setup(c);
 484         if (ret)
 485                 return ret;
 486
 487         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 488         if (!c->inocache_list) {
 489                 ret = -ENOMEM;
 490                 goto out_wbuf;
 491         }
 492         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 493
 494         if ((ret = jffs2_do_mount_fs(c)))
 495                 goto out_inohash;
 496
 497         ret = -EINVAL;
 498
 499         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 500         root_i = iget(sb, 1);
 501         if (is_bad_inode(root_i)) {
 502                 D1(printk(KERN_WARNING "get root inode failed\n"));
 503                 goto out_root_i;
 504         }
 505
 506         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 507         sb->s_root = d_alloc_root(root_i);
 508         if (!sb->s_root)
 509                 goto out_root_i;
 510
 511         sb->s_maxbytes = 0xFFFFFFFF;
 512         sb->s_blocksize = PAGE_CACHE_SIZE;
 513         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 514         sb->s_magic = JFFS2_SUPER_MAGIC;
 515         if (!(sb->s_flags & MS_RDONLY))
 516                 jffs2_start_garbage_collect_thread(c);
 517         return 0;
 518
 519  out_root_i:
 520         iput(root_i);
 521         jffs2_free_ino_caches(c);
 522         jffs2_free_raw_node_refs(c);
 523         if (jffs2_blocks_use_vmalloc(c))
 524                 vfree(c->blocks);
 525         else
 526                 kfree(c->blocks);
 527  out_inohash:
 528         kfree(c->inocache_list);
 529  out_wbuf:
 530         jffs2_flash_cleanup(c);
 531
 532         return ret;
 533 }
 534
 535 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 536                                    struct jffs2_inode_info *f)
 537 {
 538         iput(OFNI_EDONI_2SFFJ(f));
 539 }
 540
 541 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 542                                                      int inum, int nlink)
 543 {
 544         struct inode *inode;
 545         struct jffs2_inode_cache *ic;
 546         if (!nlink) {
 547                 /* The inode has zero nlink but its nodes weren't yet marked
 548                    obsolete. This has to be because we're still waiting for
 549                    the final (close() and) iput() to happen.
 550
 551                    There's a possibility that the final iput() could have
 552                    happened while we were contemplating. In order to ensure
 553                    that we don't cause a new read_inode() (which would fail)
 554                    for the inode in question, we use ilookup() in this case
 555                    instead of iget().
 556
 557                    The nlink can't _become_ zero at this point because we're
 558                    holding the alloc_sem, and jffs2_do_unlink() would also
 559                    need that while decrementing nlink on any inode.
 560                 */
 561                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 562                 if (!inode) {
 563                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 564                                   inum));
 565
 566                         spin_lock(&c->inocache_lock);
 567                         ic = jffs2_get_ino_cache(c, inum);
 568                         if (!ic) {
 569                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 570                                 spin_unlock(&c->inocache_lock);
 571                                 return NULL;
 572                         }
 573                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 574                                 /* Wait for progress. Don't just loop */
 575                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 576                                           ic->ino, ic->state));
 577                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 578                         } else {
 579                                 spin_unlock(&c->inocache_lock);
 580                         }
 581
 582                         return NULL;
 583                 }
 584         } else {
 585                 /* Inode has links to it still; they're not going away because
 586                    jffs2_do_unlink() would need the alloc_sem and we have it.
 587                    Just iget() it, and if read_inode() is necessary that's OK.
 588                 */
 589                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 590                 if (!inode)
 591                         return ERR_PTR(-ENOMEM);
 592         }
 593         if (is_bad_inode(inode)) {
 594                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 595                        inum, nlink);
 596                 /* NB. This will happen again. We need to do something appropriate here. */
 597                 iput(inode);
 598                 return ERR_PTR(-EIO);
 599         }
 600
 601         return JFFS2_INODE_INFO(inode);
 602 }
 603
 604 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 605                                    struct jffs2_inode_info *f,
 606                                    unsigned long offset,
 607                                    unsigned long *priv)
 608 {
 609         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 610         struct page *pg;
 611
 612         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 613                              (void *)jffs2_do_readpage_unlock, inode);
 614         if (IS_ERR(pg))
 615                 return (void *)pg;
 616
 617         *priv = (unsigned long)pg;
 618         return kmap(pg);
 619 }
 620
 621 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 622                            unsigned char *ptr,
 623                            unsigned long *priv)
 624 {
 625         struct page *pg = (void *)*priv;
 626
 627         kunmap(pg);
 628         page_cache_release(pg);
 629 }
 630
 631 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 632         int ret = 0;
 633
 634         if (jffs2_cleanmarker_oob(c)) {
 635                 /* NAND flash... do setup accordingly */
 636                 ret = jffs2_nand_flash_setup(c);
 637                 if (ret)
 638                         return ret;
 639         }
 640
 641         /* add setups for other bizarre flashes here... */
 642         if (jffs2_nor_ecc(c)) {
 643                 ret = jffs2_nor_ecc_flash_setup(c);
 644                 if (ret)
 645                         return ret;
 646         }
 647
 648         /* and Dataflash */
 649         if (jffs2_dataflash(c)) {
 650                 ret = jffs2_dataflash_setup(c);
 651                 if (ret)
 652                         return ret;
 653         }
 654
 655         /* and Intel "Sibley" flash */
 656         if (jffs2_nor_wbuf_flash(c)) {
 657                 ret = jffs2_nor_wbuf_flash_setup(c);
 658                 if (ret)
 659                         return ret;
 660         }
 661
 662         return ret;
 663 }
 664
 665 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 666
 667         if (jffs2_cleanmarker_oob(c)) {
 668                 jffs2_nand_flash_cleanup(c);
 669         }
 670
 671         /* add cleanups for other bizarre flashes here... */
 672         if (jffs2_nor_ecc(c)) {
 673                 jffs2_nor_ecc_flash_cleanup(c);
 674         }
 675
 676         /* and DataFlash */
 677         if (jffs2_dataflash(c)) {
 678                 jffs2_dataflash_cleanup(c);
 679         }
 680
 681         /* and Intel "Sibley" flash */
 682         if (jffs2_nor_wbuf_flash(c)) {
 683                 jffs2_nor_wbuf_flash_cleanup(c);
 684         }
 685 }