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
 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
 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 }