git.oblomov.eu Git - linux-2.6/blob - fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 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  */
  11
  12 #include <linux/capability.h>
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/fs.h>
  16 #include <linux/list.h>
  17 #include <linux/mtd/mtd.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/slab.h>
  20 #include <linux/vmalloc.h>
  21 #include <linux/vfs.h>
  22 #include <linux/crc32.h>
  23 #include "nodelist.h"
  24
  25 static int jffs2_flash_setup(struct jffs2_sb_info *c);
  26
  27 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  28 {
  29         struct jffs2_full_dnode *old_metadata, *new_metadata;
  30         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  31         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  32         struct jffs2_raw_inode *ri;
  33         union jffs2_device_node dev;
  34         unsigned char *mdata = NULL;
  35         int mdatalen = 0;
  36         unsigned int ivalid;
  37         uint32_t alloclen;
  38         int ret;
  39         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  40         ret = inode_change_ok(inode, iattr);
  41         if (ret)
  42                 return ret;
  43
  44         /* Special cases - we don't want more than one data node
  45            for these types on the medium at any time. So setattr
  46            must read the original data associated with the node
  47            (i.e. the device numbers or the target name) and write
  48            it out again with the appropriate data attached */
  49         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  50                 /* For these, we don't actually need to read the old node */
  51                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  52                 mdata = (char *)&dev;
  53                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  54         } else if (S_ISLNK(inode->i_mode)) {
  55                 down(&f->sem);
  56                 mdatalen = f->metadata->size;
  57                 mdata = kmalloc(f->metadata->size, GFP_USER);
  58                 if (!mdata) {
  59                         up(&f->sem);
  60                         return -ENOMEM;
  61                 }
  62                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  63                 if (ret) {
  64                         up(&f->sem);
  65                         kfree(mdata);
  66                         return ret;
  67                 }
  68                 up(&f->sem);
  69                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
  70         }
  71
  72         ri = jffs2_alloc_raw_inode();
  73         if (!ri) {
  74                 if (S_ISLNK(inode->i_mode))
  75                         kfree(mdata);
  76                 return -ENOMEM;
  77         }
  78
  79         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
  80                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  81         if (ret) {
  82                 jffs2_free_raw_inode(ri);
  83                 if (S_ISLNK(inode->i_mode & S_IFMT))
  84                          kfree(mdata);
  85                 return ret;
  86         }
  87         down(&f->sem);
  88         ivalid = iattr->ia_valid;
  89
  90         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  91         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  92         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  93         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  94
  95         ri->ino = cpu_to_je32(inode->i_ino);
  96         ri->version = cpu_to_je32(++f->highest_version);
  97
  98         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
  99         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
 100
 101         if (ivalid & ATTR_MODE)
 102                 if (iattr->ia_mode & S_ISGID &&
 103                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
 104                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
 105                 else
 106                         ri->mode = cpu_to_jemode(iattr->ia_mode);
 107         else
 108                 ri->mode = cpu_to_jemode(inode->i_mode);
 109
 110
 111         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 112         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 113         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 114         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 115
 116         ri->offset = cpu_to_je32(0);
 117         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 118         ri->compr = JFFS2_COMPR_NONE;
 119         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 120                 /* It's an extension. Make it a hole node */
 121                 ri->compr = JFFS2_COMPR_ZERO;
 122                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 123                 ri->offset = cpu_to_je32(inode->i_size);
 124         }
 125         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 126         if (mdatalen)
 127                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 128         else
 129                 ri->data_crc = cpu_to_je32(0);
 130
 131         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
 132         if (S_ISLNK(inode->i_mode))
 133                 kfree(mdata);
 134
 135         if (IS_ERR(new_metadata)) {
 136                 jffs2_complete_reservation(c);
 137                 jffs2_free_raw_inode(ri);
 138                 up(&f->sem);
 139                 return PTR_ERR(new_metadata);
 140         }
 141         /* It worked. Update the inode */
 142         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 143         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 144         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 145         inode->i_mode = jemode_to_cpu(ri->mode);
 146         inode->i_uid = je16_to_cpu(ri->uid);
 147         inode->i_gid = je16_to_cpu(ri->gid);
 148
 149
 150         old_metadata = f->metadata;
 151
 152         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 153                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 154
 155         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 156                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 157                 inode->i_size = iattr->ia_size;
 158                 f->metadata = NULL;
 159         } else {
 160                 f->metadata = new_metadata;
 161         }
 162         if (old_metadata) {
 163                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 164                 jffs2_free_full_dnode(old_metadata);
 165         }
 166         jffs2_free_raw_inode(ri);
 167
 168         up(&f->sem);
 169         jffs2_complete_reservation(c);
 170
 171         /* We have to do the vmtruncate() without f->sem held, since
 172            some pages may be locked and waiting for it in readpage().
 173            We are protected from a simultaneous write() extending i_size
 174            back past iattr->ia_size, because do_truncate() holds the
 175            generic inode semaphore. */
 176         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 177                 vmtruncate(inode, iattr->ia_size);
 178
 179         return 0;
 180 }
 181
 182 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 183 {
 184         int rc;
 185
 186         rc = jffs2_do_setattr(dentry->d_inode, iattr);
 187         if (!rc && (iattr->ia_valid & ATTR_MODE))
 188                 rc = jffs2_acl_chmod(dentry->d_inode);
 189         return rc;
 190 }
 191
 192 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 193 {
 194         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 195         unsigned long avail;
 196
 197         buf->f_type = JFFS2_SUPER_MAGIC;
 198         buf->f_bsize = 1 << PAGE_SHIFT;
 199         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 200         buf->f_files = 0;
 201         buf->f_ffree = 0;
 202         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 203
 204         spin_lock(&c->erase_completion_lock);
 205         avail = c->dirty_size + c->free_size;
 206         if (avail > c->sector_size * c->resv_blocks_write)
 207                 avail -= c->sector_size * c->resv_blocks_write;
 208         else
 209                 avail = 0;
 210         spin_unlock(&c->erase_completion_lock);
 211
 212         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 213
 214         return 0;
 215 }
 216
 217
 218 void jffs2_clear_inode (struct inode *inode)
 219 {
 220         /* We can forget about this inode for now - drop all
 221          *  the nodelists associated with it, etc.
 222          */
 223         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 224         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 225
 226         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 227         jffs2_do_clear_inode(c, f);
 228 }
 229
 230 void jffs2_read_inode (struct inode *inode)
 231 {
 232         struct jffs2_inode_info *f;
 233         struct jffs2_sb_info *c;
 234         struct jffs2_raw_inode latest_node;
 235         union jffs2_device_node jdev;
 236         dev_t rdev = 0;
 237         int ret;
 238
 239         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 240
 241         f = JFFS2_INODE_INFO(inode);
 242         c = JFFS2_SB_INFO(inode->i_sb);
 243
 244         jffs2_init_inode_info(f);
 245         down(&f->sem);
 246
 247         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 248
 249         if (ret) {
 250                 make_bad_inode(inode);
 251                 up(&f->sem);
 252                 return;
 253         }
 254         inode->i_mode = jemode_to_cpu(latest_node.mode);
 255         inode->i_uid = je16_to_cpu(latest_node.uid);
 256         inode->i_gid = je16_to_cpu(latest_node.gid);
 257         inode->i_size = je32_to_cpu(latest_node.isize);
 258         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 259         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 260         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 261
 262         inode->i_nlink = f->inocache->nlink;
 263
 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                                 inc_nlink(inode);
 279                 }
 280                 /* and '..' */
 281                 inc_nlink(inode);
 282                 /* Root dir gets i_nlink 3 for some reason */
 283                 if (inode->i_ino == 1)
 284                         inc_nlink(inode);
 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_blocks = 0;
 450         inode->i_size = 0;
 451
 452         insert_inode_hash(inode);
 453
 454         return inode;
 455 }
 456
 457
 458 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 459 {
 460         struct jffs2_sb_info *c;
 461         struct inode *root_i;
 462         int ret;
 463         size_t blocks;
 464
 465         c = JFFS2_SB_INFO(sb);
 466
 467 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 468         if (c->mtd->type == MTD_NANDFLASH) {
 469                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 470                 return -EINVAL;
 471         }
 472         if (c->mtd->type == MTD_DATAFLASH) {
 473                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 474                 return -EINVAL;
 475         }
 476 #endif
 477
 478         c->flash_size = c->mtd->size;
 479         c->sector_size = c->mtd->erasesize;
 480         blocks = c->flash_size / c->sector_size;
 481
 482         /*
 483          * Size alignment check
 484          */
 485         if ((c->sector_size * blocks) != c->flash_size) {
 486                 c->flash_size = c->sector_size * blocks;
 487                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 488                         c->flash_size / 1024);
 489         }
 490
 491         if (c->flash_size < 5*c->sector_size) {
 492                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 493                 return -EINVAL;
 494         }
 495
 496         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 497
 498         /* NAND (or other bizarre) flash... do setup accordingly */
 499         ret = jffs2_flash_setup(c);
 500         if (ret)
 501                 return ret;
 502
 503         c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 504         if (!c->inocache_list) {
 505                 ret = -ENOMEM;
 506                 goto out_wbuf;
 507         }
 508
 509         jffs2_init_xattr_subsystem(c);
 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         jffs2_clear_xattr_subsystem(c);
 546         kfree(c->inocache_list);
 547  out_wbuf:
 548         jffs2_flash_cleanup(c);
 549
 550         return ret;
 551 }
 552
 553 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 554                                    struct jffs2_inode_info *f)
 555 {
 556         iput(OFNI_EDONI_2SFFJ(f));
 557 }
 558
 559 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 560                                                      int inum, int nlink)
 561 {
 562         struct inode *inode;
 563         struct jffs2_inode_cache *ic;
 564         if (!nlink) {
 565                 /* The inode has zero nlink but its nodes weren't yet marked
 566                    obsolete. This has to be because we're still waiting for
 567                    the final (close() and) iput() to happen.
 568
 569                    There's a possibility that the final iput() could have
 570                    happened while we were contemplating. In order to ensure
 571                    that we don't cause a new read_inode() (which would fail)
 572                    for the inode in question, we use ilookup() in this case
 573                    instead of iget().
 574
 575                    The nlink can't _become_ zero at this point because we're
 576                    holding the alloc_sem, and jffs2_do_unlink() would also
 577                    need that while decrementing nlink on any inode.
 578                 */
 579                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 580                 if (!inode) {
 581                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 582                                   inum));
 583
 584                         spin_lock(&c->inocache_lock);
 585                         ic = jffs2_get_ino_cache(c, inum);
 586                         if (!ic) {
 587                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 588                                 spin_unlock(&c->inocache_lock);
 589                                 return NULL;
 590                         }
 591                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 592                                 /* Wait for progress. Don't just loop */
 593                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 594                                           ic->ino, ic->state));
 595                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 596                         } else {
 597                                 spin_unlock(&c->inocache_lock);
 598                         }
 599
 600                         return NULL;
 601                 }
 602         } else {
 603                 /* Inode has links to it still; they're not going away because
 604                    jffs2_do_unlink() would need the alloc_sem and we have it.
 605                    Just iget() it, and if read_inode() is necessary that's OK.
 606                 */
 607                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 608                 if (!inode)
 609                         return ERR_PTR(-ENOMEM);
 610         }
 611         if (is_bad_inode(inode)) {
 612                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 613                        inum, nlink);
 614                 /* NB. This will happen again. We need to do something appropriate here. */
 615                 iput(inode);
 616                 return ERR_PTR(-EIO);
 617         }
 618
 619         return JFFS2_INODE_INFO(inode);
 620 }
 621
 622 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 623                                    struct jffs2_inode_info *f,
 624                                    unsigned long offset,
 625                                    unsigned long *priv)
 626 {
 627         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 628         struct page *pg;
 629
 630         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 631                              (void *)jffs2_do_readpage_unlock, inode);
 632         if (IS_ERR(pg))
 633                 return (void *)pg;
 634
 635         *priv = (unsigned long)pg;
 636         return kmap(pg);
 637 }
 638
 639 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 640                            unsigned char *ptr,
 641                            unsigned long *priv)
 642 {
 643         struct page *pg = (void *)*priv;
 644
 645         kunmap(pg);
 646         page_cache_release(pg);
 647 }
 648
 649 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 650         int ret = 0;
 651
 652         if (jffs2_cleanmarker_oob(c)) {
 653                 /* NAND flash... do setup accordingly */
 654                 ret = jffs2_nand_flash_setup(c);
 655                 if (ret)
 656                         return ret;
 657         }
 658
 659         /* and Dataflash */
 660         if (jffs2_dataflash(c)) {
 661                 ret = jffs2_dataflash_setup(c);
 662                 if (ret)
 663                         return ret;
 664         }
 665
 666         /* and Intel "Sibley" flash */
 667         if (jffs2_nor_wbuf_flash(c)) {
 668                 ret = jffs2_nor_wbuf_flash_setup(c);
 669                 if (ret)
 670                         return ret;
 671         }
 672
 673         /* and an UBI volume */
 674         if (jffs2_ubivol(c)) {
 675                 ret = jffs2_ubivol_setup(c);
 676                 if (ret)
 677                         return ret;
 678         }
 679
 680         return ret;
 681 }
 682
 683 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 684
 685         if (jffs2_cleanmarker_oob(c)) {
 686                 jffs2_nand_flash_cleanup(c);
 687         }
 688
 689         /* and DataFlash */
 690         if (jffs2_dataflash(c)) {
 691                 jffs2_dataflash_cleanup(c);
 692         }
 693
 694         /* and Intel "Sibley" flash */
 695         if (jffs2_nor_wbuf_flash(c)) {
 696                 jffs2_nor_wbuf_flash_cleanup(c);
 697         }
 698
 699         /* and an UBI volume */
 700         if (jffs2_ubivol(c)) {
 701                 jffs2_ubivol_cleanup(c);
 702         }
 703 }