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