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