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.61 2005/07/24 15:29:56 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, 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
 461         /*
 462          * Check, if we have to concatenate physical blocks to larger virtual blocks
 463          * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
 464          */
 465         c->sector_size = c->mtd->erasesize;
 466         blocks = c->flash_size / c->sector_size;
 467         if (!(c->mtd->flags & MTD_NO_VIRTBLOCKS)) {
 468                 while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) {
 469                         blocks >>= 1;
 470                         c->sector_size <<= 1;
 471                 }
 472         }
 473
 474         /*
 475          * Size alignment check
 476          */
 477         if ((c->sector_size * blocks) != c->flash_size) {
 478                 c->flash_size = c->sector_size * blocks;
 479                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 480                         c->flash_size / 1024);
 481         }
 482
 483         if (c->sector_size != c->mtd->erasesize)
 484                 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
 485                         c->mtd->erasesize / 1024, c->sector_size / 1024);
 486
 487         if (c->flash_size < 5*c->sector_size) {
 488                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 489                 return -EINVAL;
 490         }
 491
 492         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 493         /* Joern -- stick alignment for weird 8-byte-page flash here */
 494
 495         /* NAND (or other bizarre) flash... do setup accordingly */
 496         ret = jffs2_flash_setup(c);
 497         if (ret)
 498                 return ret;
 499
 500         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 501         if (!c->inocache_list) {
 502                 ret = -ENOMEM;
 503                 goto out_wbuf;
 504         }
 505         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 506
 507         if ((ret = jffs2_do_mount_fs(c)))
 508                 goto out_inohash;
 509
 510         ret = -EINVAL;
 511
 512         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 513         root_i = iget(sb, 1);
 514         if (is_bad_inode(root_i)) {
 515                 D1(printk(KERN_WARNING "get root inode failed\n"));
 516                 goto out_root_i;
 517         }
 518
 519         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 520         sb->s_root = d_alloc_root(root_i);
 521         if (!sb->s_root)
 522                 goto out_root_i;
 523
 524         sb->s_maxbytes = 0xFFFFFFFF;
 525         sb->s_blocksize = PAGE_CACHE_SIZE;
 526         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 527         sb->s_magic = JFFS2_SUPER_MAGIC;
 528         if (!(sb->s_flags & MS_RDONLY))
 529                 jffs2_start_garbage_collect_thread(c);
 530         return 0;
 531
 532  out_root_i:
 533         iput(root_i);
 534         jffs2_free_ino_caches(c);
 535         jffs2_free_raw_node_refs(c);
 536         if (c->mtd->flags & MTD_NO_VIRTBLOCKS)
 537                 vfree(c->blocks);
 538         else
 539                 kfree(c->blocks);
 540  out_inohash:
 541         kfree(c->inocache_list);
 542  out_wbuf:
 543         jffs2_flash_cleanup(c);
 544
 545         return ret;
 546 }
 547
 548 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 549                                    struct jffs2_inode_info *f)
 550 {
 551         iput(OFNI_EDONI_2SFFJ(f));
 552 }
 553
 554 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 555                                                      int inum, int nlink)
 556 {
 557         struct inode *inode;
 558         struct jffs2_inode_cache *ic;
 559         if (!nlink) {
 560                 /* The inode has zero nlink but its nodes weren't yet marked
 561                    obsolete. This has to be because we're still waiting for
 562                    the final (close() and) iput() to happen.
 563
 564                    There's a possibility that the final iput() could have
 565                    happened while we were contemplating. In order to ensure
 566                    that we don't cause a new read_inode() (which would fail)
 567                    for the inode in question, we use ilookup() in this case
 568                    instead of iget().
 569
 570                    The nlink can't _become_ zero at this point because we're
 571                    holding the alloc_sem, and jffs2_do_unlink() would also
 572                    need that while decrementing nlink on any inode.
 573                 */
 574                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 575                 if (!inode) {
 576                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 577                                   inum));
 578
 579                         spin_lock(&c->inocache_lock);
 580                         ic = jffs2_get_ino_cache(c, inum);
 581                         if (!ic) {
 582                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 583                                 spin_unlock(&c->inocache_lock);
 584                                 return NULL;
 585                         }
 586                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 587                                 /* Wait for progress. Don't just loop */
 588                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 589                                           ic->ino, ic->state));
 590                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 591                         } else {
 592                                 spin_unlock(&c->inocache_lock);
 593                         }
 594
 595                         return NULL;
 596                 }
 597         } else {
 598                 /* Inode has links to it still; they're not going away because
 599                    jffs2_do_unlink() would need the alloc_sem and we have it.
 600                    Just iget() it, and if read_inode() is necessary that's OK.
 601                 */
 602                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 603                 if (!inode)
 604                         return ERR_PTR(-ENOMEM);
 605         }
 606         if (is_bad_inode(inode)) {
 607                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 608                        inum, nlink);
 609                 /* NB. This will happen again. We need to do something appropriate here. */
 610                 iput(inode);
 611                 return ERR_PTR(-EIO);
 612         }
 613
 614         return JFFS2_INODE_INFO(inode);
 615 }
 616
 617 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 618                                    struct jffs2_inode_info *f,
 619                                    unsigned long offset,
 620                                    unsigned long *priv)
 621 {
 622         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 623         struct page *pg;
 624
 625         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 626                              (void *)jffs2_do_readpage_unlock, inode);
 627         if (IS_ERR(pg))
 628                 return (void *)pg;
 629
 630         *priv = (unsigned long)pg;
 631         return kmap(pg);
 632 }
 633
 634 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 635                            unsigned char *ptr,
 636                            unsigned long *priv)
 637 {
 638         struct page *pg = (void *)*priv;
 639
 640         kunmap(pg);
 641         page_cache_release(pg);
 642 }
 643
 644 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 645         int ret = 0;
 646
 647         if (jffs2_cleanmarker_oob(c)) {
 648                 /* NAND flash... do setup accordingly */
 649                 ret = jffs2_nand_flash_setup(c);
 650                 if (ret)
 651                         return ret;
 652         }
 653
 654         /* add setups for other bizarre flashes here... */
 655         if (jffs2_nor_ecc(c)) {
 656                 ret = jffs2_nor_ecc_flash_setup(c);
 657                 if (ret)
 658                         return ret;
 659         }
 660
 661         /* and Dataflash */
 662         if (jffs2_dataflash(c)) {
 663                 ret = jffs2_dataflash_setup(c);
 664                 if (ret)
 665                         return ret;
 666         }
 667
 668         return ret;
 669 }
 670
 671 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 672
 673         if (jffs2_cleanmarker_oob(c)) {
 674                 jffs2_nand_flash_cleanup(c);
 675         }
 676
 677         /* add cleanups for other bizarre flashes here... */
 678         if (jffs2_nor_ecc(c)) {
 679                 jffs2_nor_ecc_flash_cleanup(c);
 680         }
 681
 682         /* and DataFlash */
 683         if (jffs2_dataflash(c)) {
 684                 jffs2_dataflash_cleanup(c);
 685         }
 686 }