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@redhat.com>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: fs.c,v 1.46 2004/07/13 08:56:54 dwmw2 Exp $
  11  *
  12  */
  13
  14 #include <linux/version.h>
  15 #include <linux/config.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/fs.h>
  19 #include <linux/list.h>
  20 #include <linux/mtd/mtd.h>
  21 #include <linux/pagemap.h>
  22 #include <linux/slab.h>
  23 #include <linux/vfs.h>
  24 #include <linux/crc32.h>
  25 #include "nodelist.h"
  26
  27
  28 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  29 {
  30         struct jffs2_full_dnode *old_metadata, *new_metadata;
  31         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  32         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  33         struct jffs2_raw_inode *ri;
  34         unsigned short dev;
  35         unsigned char *mdata = NULL;
  36         int mdatalen = 0;
  37         unsigned int ivalid;
  38         uint32_t phys_ofs, alloclen;
  39         int ret;
  40         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  41         ret = inode_change_ok(inode, iattr);
  42         if (ret)
  43                 return ret;
  44
  45         /* Special cases - we don't want more than one data node
  46            for these types on the medium at any time. So setattr
  47            must read the original data associated with the node
  48            (i.e. the device numbers or the target name) and write
  49            it out again with the appropriate data attached */
  50         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  51                 /* For these, we don't actually need to read the old node */
  52                 dev = old_encode_dev(inode->i_rdev);
  53                 mdata = (char *)&dev;
  54                 mdatalen = sizeof(dev);
  55                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  56         } else if (S_ISLNK(inode->i_mode)) {
  57                 mdatalen = f->metadata->size;
  58                 mdata = kmalloc(f->metadata->size, GFP_USER);
  59                 if (!mdata)
  60                         return -ENOMEM;
  61                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  62                 if (ret) {
  63                         kfree(mdata);
  64                         return ret;
  65                 }
  66                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
  67         }
  68
  69         ri = jffs2_alloc_raw_inode();
  70         if (!ri) {
  71                 if (S_ISLNK(inode->i_mode))
  72                         kfree(mdata);
  73                 return -ENOMEM;
  74         }
  75
  76         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
  77         if (ret) {
  78                 jffs2_free_raw_inode(ri);
  79                 if (S_ISLNK(inode->i_mode & S_IFMT))
  80                          kfree(mdata);
  81                 return ret;
  82         }
  83         down(&f->sem);
  84         ivalid = iattr->ia_valid;
  85
  86         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  87         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  88         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  89         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  90
  91         ri->ino = cpu_to_je32(inode->i_ino);
  92         ri->version = cpu_to_je32(++f->highest_version);
  93
  94         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
  95         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
  96
  97         if (ivalid & ATTR_MODE)
  98                 if (iattr->ia_mode & S_ISGID &&
  99                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
 100                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
 101                 else
 102                         ri->mode = cpu_to_jemode(iattr->ia_mode);
 103         else
 104                 ri->mode = cpu_to_jemode(inode->i_mode);
 105
 106
 107         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 108         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 109         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 110         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 111
 112         ri->offset = cpu_to_je32(0);
 113         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 114         ri->compr = JFFS2_COMPR_NONE;
 115         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 116                 /* It's an extension. Make it a hole node */
 117                 ri->compr = JFFS2_COMPR_ZERO;
 118                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 119                 ri->offset = cpu_to_je32(inode->i_size);
 120         }
 121         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 122         if (mdatalen)
 123                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 124         else
 125                 ri->data_crc = cpu_to_je32(0);
 126
 127         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
 128         if (S_ISLNK(inode->i_mode))
 129                 kfree(mdata);
 130
 131         if (IS_ERR(new_metadata)) {
 132                 jffs2_complete_reservation(c);
 133                 jffs2_free_raw_inode(ri);
 134                 up(&f->sem);
 135                 return PTR_ERR(new_metadata);
 136         }
 137         /* It worked. Update the inode */
 138         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 139         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 140         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 141         inode->i_mode = jemode_to_cpu(ri->mode);
 142         inode->i_uid = je16_to_cpu(ri->uid);
 143         inode->i_gid = je16_to_cpu(ri->gid);
 144
 145
 146         old_metadata = f->metadata;
 147
 148         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 149                 jffs2_truncate_fraglist (c, &f->fragtree, iattr->ia_size);
 150
 151         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 152                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 153                 inode->i_size = iattr->ia_size;
 154                 f->metadata = NULL;
 155         } else {
 156                 f->metadata = new_metadata;
 157         }
 158         if (old_metadata) {
 159                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 160                 jffs2_free_full_dnode(old_metadata);
 161         }
 162         jffs2_free_raw_inode(ri);
 163
 164         up(&f->sem);
 165         jffs2_complete_reservation(c);
 166
 167         /* We have to do the vmtruncate() without f->sem held, since
 168            some pages may be locked and waiting for it in readpage().
 169            We are protected from a simultaneous write() extending i_size
 170            back past iattr->ia_size, because do_truncate() holds the
 171            generic inode semaphore. */
 172         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 173                 vmtruncate(inode, iattr->ia_size);
 174
 175         return 0;
 176 }
 177
 178 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 179 {
 180         return jffs2_do_setattr(dentry->d_inode, iattr);
 181 }
 182
 183 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
 184 {
 185         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 186         unsigned long avail;
 187
 188         buf->f_type = JFFS2_SUPER_MAGIC;
 189         buf->f_bsize = 1 << PAGE_SHIFT;
 190         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 191         buf->f_files = 0;
 192         buf->f_ffree = 0;
 193         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 194
 195         spin_lock(&c->erase_completion_lock);
 196
 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
 203         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 204
 205         D1(jffs2_dump_block_lists(c));
 206
 207         spin_unlock(&c->erase_completion_lock);
 208
 209         return 0;
 210 }
 211
 212
 213 void jffs2_clear_inode (struct inode *inode)
 214 {
 215         /* We can forget about this inode for now - drop all
 216          *  the nodelists associated with it, etc.
 217          */
 218         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 219         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 220
 221         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 222
 223         jffs2_do_clear_inode(c, f);
 224 }
 225
 226 void jffs2_read_inode (struct inode *inode)
 227 {
 228         struct jffs2_inode_info *f;
 229         struct jffs2_sb_info *c;
 230         struct jffs2_raw_inode latest_node;
 231         int ret;
 232
 233         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 234
 235         f = JFFS2_INODE_INFO(inode);
 236         c = JFFS2_SB_INFO(inode->i_sb);
 237
 238         jffs2_init_inode_info(f);
 239
 240         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 241
 242         if (ret) {
 243                 make_bad_inode(inode);
 244                 up(&f->sem);
 245                 return;
 246         }
 247         inode->i_mode = jemode_to_cpu(latest_node.mode);
 248         inode->i_uid = je16_to_cpu(latest_node.uid);
 249         inode->i_gid = je16_to_cpu(latest_node.gid);
 250         inode->i_size = je32_to_cpu(latest_node.isize);
 251         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 252         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 253         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 254
 255         inode->i_nlink = f->inocache->nlink;
 256
 257         inode->i_blksize = PAGE_SIZE;
 258         inode->i_blocks = (inode->i_size + 511) >> 9;
 259
 260         switch (inode->i_mode & S_IFMT) {
 261                 jint16_t rdev;
 262
 263         case S_IFLNK:
 264                 inode->i_op = &jffs2_symlink_inode_operations;
 265                 break;
 266
 267         case S_IFDIR:
 268         {
 269                 struct jffs2_full_dirent *fd;
 270
 271                 for (fd=f->dents; fd; fd = fd->next) {
 272                         if (fd->type == DT_DIR && fd->ino)
 273                                 inode->i_nlink++;
 274                 }
 275                 /* and '..' */
 276                 inode->i_nlink++;
 277                 /* Root dir gets i_nlink 3 for some reason */
 278                 if (inode->i_ino == 1)
 279                         inode->i_nlink++;
 280
 281                 inode->i_op = &jffs2_dir_inode_operations;
 282                 inode->i_fop = &jffs2_dir_operations;
 283                 break;
 284         }
 285         case S_IFREG:
 286                 inode->i_op = &jffs2_file_inode_operations;
 287                 inode->i_fop = &jffs2_file_operations;
 288                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 289                 inode->i_mapping->nrpages = 0;
 290                 break;
 291
 292         case S_IFBLK:
 293         case S_IFCHR:
 294                 /* Read the device numbers from the media */
 295                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 296                 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
 297                         /* Eep */
 298                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 299                         up(&f->sem);
 300                         jffs2_do_clear_inode(c, f);
 301                         make_bad_inode(inode);
 302                         return;
 303                 }
 304
 305         case S_IFSOCK:
 306         case S_IFIFO:
 307                 inode->i_op = &jffs2_file_inode_operations;
 308                 init_special_inode(inode, inode->i_mode,
 309                                    old_decode_dev((je16_to_cpu(rdev))));
 310                 break;
 311
 312         default:
 313                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 314         }
 315
 316         up(&f->sem);
 317
 318         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 319 }
 320
 321 void jffs2_dirty_inode(struct inode *inode)
 322 {
 323         struct iattr iattr;
 324
 325         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 326                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 327                 return;
 328         }
 329
 330         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 331
 332         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 333         iattr.ia_mode = inode->i_mode;
 334         iattr.ia_uid = inode->i_uid;
 335         iattr.ia_gid = inode->i_gid;
 336         iattr.ia_atime = inode->i_atime;
 337         iattr.ia_mtime = inode->i_mtime;
 338         iattr.ia_ctime = inode->i_ctime;
 339
 340         jffs2_do_setattr(inode, &iattr);
 341 }
 342
 343 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 344 {
 345         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 346
 347         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 348                 return -EROFS;
 349
 350         /* We stop if it was running, then restart if it needs to.
 351            This also catches the case where it was stopped and this
 352            is just a remount to restart it.
 353            Flush the writebuffer, if neccecary, else we loose it */
 354         if (!(sb->s_flags & MS_RDONLY)) {
 355                 jffs2_stop_garbage_collect_thread(c);
 356                 down(&c->alloc_sem);
 357                 jffs2_flush_wbuf_pad(c);
 358                 up(&c->alloc_sem);
 359         }
 360
 361         if (!(*flags & MS_RDONLY))
 362                 jffs2_start_garbage_collect_thread(c);
 363
 364         *flags |= MS_NOATIME;
 365
 366         return 0;
 367 }
 368
 369 void jffs2_write_super (struct super_block *sb)
 370 {
 371         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 372         sb->s_dirt = 0;
 373
 374         if (sb->s_flags & MS_RDONLY)
 375                 return;
 376
 377         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 378         jffs2_garbage_collect_trigger(c);
 379         jffs2_erase_pending_blocks(c, 0);
 380         jffs2_flush_wbuf_gc(c, 0);
 381 }
 382
 383
 384 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 385    fill in the raw_inode while you're at it. */
 386 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 387 {
 388         struct inode *inode;
 389         struct super_block *sb = dir_i->i_sb;
 390         struct jffs2_sb_info *c;
 391         struct jffs2_inode_info *f;
 392         int ret;
 393
 394         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 395
 396         c = JFFS2_SB_INFO(sb);
 397
 398         inode = new_inode(sb);
 399
 400         if (!inode)
 401                 return ERR_PTR(-ENOMEM);
 402
 403         f = JFFS2_INODE_INFO(inode);
 404         jffs2_init_inode_info(f);
 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;
 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_NAND
 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 #endif
 457
 458         c->flash_size = c->mtd->size;
 459
 460         /*
 461          * Check, if we have to concatenate physical blocks to larger virtual blocks
 462          * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
 463          */
 464         c->sector_size = c->mtd->erasesize;
 465         blocks = c->flash_size / c->sector_size;
 466         while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) {
 467                 blocks >>= 1;
 468                 c->sector_size <<= 1;
 469         }
 470
 471         /*
 472          * Size alignment check
 473          */
 474         if ((c->sector_size * blocks) != c->flash_size) {
 475                 c->flash_size = c->sector_size * blocks;
 476                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 477                         c->flash_size / 1024);
 478         }
 479
 480         if (c->sector_size != c->mtd->erasesize)
 481                 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
 482                         c->mtd->erasesize / 1024, c->sector_size / 1024);
 483
 484         if (c->flash_size < 5*c->sector_size) {
 485                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 486                 return -EINVAL;
 487         }
 488
 489         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 490         /* Joern -- stick alignment for weird 8-byte-page flash here */
 491
 492         /* NAND (or other bizarre) flash... do setup accordingly */
 493         ret = jffs2_flash_setup(c);
 494         if (ret)
 495                 return ret;
 496
 497         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 498         if (!c->inocache_list) {
 499                 ret = -ENOMEM;
 500                 goto out_wbuf;
 501         }
 502         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 503
 504         if ((ret = jffs2_do_mount_fs(c)))
 505                 goto out_inohash;
 506
 507         ret = -EINVAL;
 508
 509         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 510         root_i = iget(sb, 1);
 511         if (is_bad_inode(root_i)) {
 512                 D1(printk(KERN_WARNING "get root inode failed\n"));
 513                 goto out_nodes;
 514         }
 515
 516         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 517         sb->s_root = d_alloc_root(root_i);
 518         if (!sb->s_root)
 519                 goto out_root_i;
 520
 521 #if LINUX_VERSION_CODE >= 0x20403
 522         sb->s_maxbytes = 0xFFFFFFFF;
 523 #endif
 524         sb->s_blocksize = PAGE_CACHE_SIZE;
 525         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 526         sb->s_magic = JFFS2_SUPER_MAGIC;
 527         if (!(sb->s_flags & MS_RDONLY))
 528                 jffs2_start_garbage_collect_thread(c);
 529         return 0;
 530
 531  out_root_i:
 532         iput(root_i);
 533  out_nodes:
 534         jffs2_free_ino_caches(c);
 535         jffs2_free_raw_node_refs(c);
 536         kfree(c->blocks);
 537  out_inohash:
 538         kfree(c->inocache_list);
 539  out_wbuf:
 540         jffs2_flash_cleanup(c);
 541
 542         return ret;
 543 }
 544
 545 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 546                                    struct jffs2_inode_info *f)
 547 {
 548         iput(OFNI_EDONI_2SFFJ(f));
 549 }
 550
 551 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 552                                                      int inum, int nlink)
 553 {
 554         struct inode *inode;
 555         struct jffs2_inode_cache *ic;
 556         if (!nlink) {
 557                 /* The inode has zero nlink but its nodes weren't yet marked
 558                    obsolete. This has to be because we're still waiting for
 559                    the final (close() and) iput() to happen.
 560
 561                    There's a possibility that the final iput() could have
 562                    happened while we were contemplating. In order to ensure
 563                    that we don't cause a new read_inode() (which would fail)
 564                    for the inode in question, we use ilookup() in this case
 565                    instead of iget().
 566
 567                    The nlink can't _become_ zero at this point because we're
 568                    holding the alloc_sem, and jffs2_do_unlink() would also
 569                    need that while decrementing nlink on any inode.
 570                 */
 571                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 572                 if (!inode) {
 573                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 574                                   inum));
 575
 576                         spin_lock(&c->inocache_lock);
 577                         ic = jffs2_get_ino_cache(c, inum);
 578                         if (!ic) {
 579                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 580                                 spin_unlock(&c->inocache_lock);
 581                                 return NULL;
 582                         }
 583                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 584                                 /* Wait for progress. Don't just loop */
 585                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 586                                           ic->ino, ic->state));
 587                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 588                         } else {
 589                                 spin_unlock(&c->inocache_lock);
 590                         }
 591
 592                         return NULL;
 593                 }
 594         } else {
 595                 /* Inode has links to it still; they're not going away because
 596                    jffs2_do_unlink() would need the alloc_sem and we have it.
 597                    Just iget() it, and if read_inode() is necessary that's OK.
 598                 */
 599                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 600                 if (!inode)
 601                         return ERR_PTR(-ENOMEM);
 602         }
 603         if (is_bad_inode(inode)) {
 604                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 605                        inum, nlink);
 606                 /* NB. This will happen again. We need to do something appropriate here. */
 607                 iput(inode);
 608                 return ERR_PTR(-EIO);
 609         }
 610
 611         return JFFS2_INODE_INFO(inode);
 612 }
 613
 614 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 615                                    struct jffs2_inode_info *f,
 616                                    unsigned long offset,
 617                                    unsigned long *priv)
 618 {
 619         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 620         struct page *pg;
 621
 622         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 623                              (void *)jffs2_do_readpage_unlock, inode);
 624         if (IS_ERR(pg))
 625                 return (void *)pg;
 626
 627         *priv = (unsigned long)pg;
 628         return kmap(pg);
 629 }
 630
 631 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 632                            unsigned char *ptr,
 633                            unsigned long *priv)
 634 {
 635         struct page *pg = (void *)*priv;
 636
 637         kunmap(pg);
 638         page_cache_release(pg);
 639 }
 640
 641 int jffs2_flash_setup(struct jffs2_sb_info *c) {
 642         int ret = 0;
 643
 644         if (jffs2_cleanmarker_oob(c)) {
 645                 /* NAND flash... do setup accordingly */
 646                 ret = jffs2_nand_flash_setup(c);
 647                 if (ret)
 648                         return ret;
 649         }
 650
 651         /* add setups for other bizarre flashes here... */
 652         return ret;
 653 }
 654
 655 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 656
 657         if (jffs2_cleanmarker_oob(c)) {
 658                 jffs2_nand_flash_cleanup(c);
 659         }
 660
 661         /* add cleanups for other bizarre flashes here... */
 662 }