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