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