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