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.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 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, &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, 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         int rc;
 188
 189         rc = jffs2_do_setattr(dentry->d_inode, iattr);
 190         if (!rc && (iattr->ia_valid & ATTR_MODE))
 191                 rc = jffs2_acl_chmod(dentry->d_inode);
 192         return rc;
 193 }
 194
 195 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
 196 {
 197         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 198         unsigned long avail;
 199
 200         buf->f_type = JFFS2_SUPER_MAGIC;
 201         buf->f_bsize = 1 << PAGE_SHIFT;
 202         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 203         buf->f_files = 0;
 204         buf->f_ffree = 0;
 205         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 206
 207         spin_lock(&c->erase_completion_lock);
 208         avail = c->dirty_size + c->free_size;
 209         if (avail > c->sector_size * c->resv_blocks_write)
 210                 avail -= c->sector_size * c->resv_blocks_write;
 211         else
 212                 avail = 0;
 213         spin_unlock(&c->erase_completion_lock);
 214
 215         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 216
 217         return 0;
 218 }
 219
 220
 221 void jffs2_clear_inode (struct inode *inode)
 222 {
 223         /* We can forget about this inode for now - drop all
 224          *  the nodelists associated with it, etc.
 225          */
 226         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 227         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 228
 229         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 230
 231         jffs2_xattr_delete_inode(c, f->inocache);
 232         jffs2_do_clear_inode(c, f);
 233 }
 234
 235 void jffs2_read_inode (struct inode *inode)
 236 {
 237         struct jffs2_inode_info *f;
 238         struct jffs2_sb_info *c;
 239         struct jffs2_raw_inode latest_node;
 240         union jffs2_device_node jdev;
 241         dev_t rdev = 0;
 242         int ret;
 243
 244         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 245
 246         f = JFFS2_INODE_INFO(inode);
 247         c = JFFS2_SB_INFO(inode->i_sb);
 248
 249         jffs2_init_inode_info(f);
 250         down(&f->sem);
 251
 252         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 253
 254         if (ret) {
 255                 make_bad_inode(inode);
 256                 up(&f->sem);
 257                 return;
 258         }
 259         inode->i_mode = jemode_to_cpu(latest_node.mode);
 260         inode->i_uid = je16_to_cpu(latest_node.uid);
 261         inode->i_gid = je16_to_cpu(latest_node.gid);
 262         inode->i_size = je32_to_cpu(latest_node.isize);
 263         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 264         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 265         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 266
 267         inode->i_nlink = f->inocache->nlink;
 268
 269         inode->i_blksize = PAGE_SIZE;
 270         inode->i_blocks = (inode->i_size + 511) >> 9;
 271
 272         switch (inode->i_mode & S_IFMT) {
 273
 274         case S_IFLNK:
 275                 inode->i_op = &jffs2_symlink_inode_operations;
 276                 break;
 277
 278         case S_IFDIR:
 279         {
 280                 struct jffs2_full_dirent *fd;
 281
 282                 for (fd=f->dents; fd; fd = fd->next) {
 283                         if (fd->type == DT_DIR && fd->ino)
 284                                 inode->i_nlink++;
 285                 }
 286                 /* and '..' */
 287                 inode->i_nlink++;
 288                 /* Root dir gets i_nlink 3 for some reason */
 289                 if (inode->i_ino == 1)
 290                         inode->i_nlink++;
 291
 292                 inode->i_op = &jffs2_dir_inode_operations;
 293                 inode->i_fop = &jffs2_dir_operations;
 294                 break;
 295         }
 296         case S_IFREG:
 297                 inode->i_op = &jffs2_file_inode_operations;
 298                 inode->i_fop = &jffs2_file_operations;
 299                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 300                 inode->i_mapping->nrpages = 0;
 301                 break;
 302
 303         case S_IFBLK:
 304         case S_IFCHR:
 305                 /* Read the device numbers from the media */
 306                 if (f->metadata->size != sizeof(jdev.old) &&
 307                     f->metadata->size != sizeof(jdev.new)) {
 308                         printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
 309                         up(&f->sem);
 310                         jffs2_do_clear_inode(c, f);
 311                         make_bad_inode(inode);
 312                         return;
 313                 }
 314                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 315                 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
 316                         /* Eep */
 317                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 318                         up(&f->sem);
 319                         jffs2_do_clear_inode(c, f);
 320                         make_bad_inode(inode);
 321                         return;
 322                 }
 323                 if (f->metadata->size == sizeof(jdev.old))
 324                         rdev = old_decode_dev(je16_to_cpu(jdev.old));
 325                 else
 326                         rdev = new_decode_dev(je32_to_cpu(jdev.new));
 327
 328         case S_IFSOCK:
 329         case S_IFIFO:
 330                 inode->i_op = &jffs2_file_inode_operations;
 331                 init_special_inode(inode, inode->i_mode, rdev);
 332                 break;
 333
 334         default:
 335                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 336         }
 337
 338         up(&f->sem);
 339
 340         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 341 }
 342
 343 void jffs2_dirty_inode(struct inode *inode)
 344 {
 345         struct iattr iattr;
 346
 347         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 348                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 349                 return;
 350         }
 351
 352         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 353
 354         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 355         iattr.ia_mode = inode->i_mode;
 356         iattr.ia_uid = inode->i_uid;
 357         iattr.ia_gid = inode->i_gid;
 358         iattr.ia_atime = inode->i_atime;
 359         iattr.ia_mtime = inode->i_mtime;
 360         iattr.ia_ctime = inode->i_ctime;
 361
 362         jffs2_do_setattr(inode, &iattr);
 363 }
 364
 365 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 366 {
 367         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 368
 369         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 370                 return -EROFS;
 371
 372         /* We stop if it was running, then restart if it needs to.
 373            This also catches the case where it was stopped and this
 374            is just a remount to restart it.
 375            Flush the writebuffer, if neccecary, else we loose it */
 376         if (!(sb->s_flags & MS_RDONLY)) {
 377                 jffs2_stop_garbage_collect_thread(c);
 378                 down(&c->alloc_sem);
 379                 jffs2_flush_wbuf_pad(c);
 380                 up(&c->alloc_sem);
 381         }
 382
 383         if (!(*flags & MS_RDONLY))
 384                 jffs2_start_garbage_collect_thread(c);
 385
 386         *flags |= MS_NOATIME;
 387
 388         return 0;
 389 }
 390
 391 void jffs2_write_super (struct super_block *sb)
 392 {
 393         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 394         sb->s_dirt = 0;
 395
 396         if (sb->s_flags & MS_RDONLY)
 397                 return;
 398
 399         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 400         jffs2_garbage_collect_trigger(c);
 401         jffs2_erase_pending_blocks(c, 0);
 402         jffs2_flush_wbuf_gc(c, 0);
 403 }
 404
 405
 406 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 407    fill in the raw_inode while you're at it. */
 408 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 409 {
 410         struct inode *inode;
 411         struct super_block *sb = dir_i->i_sb;
 412         struct jffs2_sb_info *c;
 413         struct jffs2_inode_info *f;
 414         int ret;
 415
 416         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 417
 418         c = JFFS2_SB_INFO(sb);
 419
 420         inode = new_inode(sb);
 421
 422         if (!inode)
 423                 return ERR_PTR(-ENOMEM);
 424
 425         f = JFFS2_INODE_INFO(inode);
 426         jffs2_init_inode_info(f);
 427         down(&f->sem);
 428
 429         memset(ri, 0, sizeof(*ri));
 430         /* Set OS-specific defaults for new inodes */
 431         ri->uid = cpu_to_je16(current->fsuid);
 432
 433         if (dir_i->i_mode & S_ISGID) {
 434                 ri->gid = cpu_to_je16(dir_i->i_gid);
 435                 if (S_ISDIR(mode))
 436                         mode |= S_ISGID;
 437         } else {
 438                 ri->gid = cpu_to_je16(current->fsgid);
 439         }
 440         ri->mode =  cpu_to_jemode(mode);
 441         ret = jffs2_do_new_inode (c, f, mode, ri);
 442         if (ret) {
 443                 make_bad_inode(inode);
 444                 iput(inode);
 445                 return ERR_PTR(ret);
 446         }
 447         inode->i_nlink = 1;
 448         inode->i_ino = je32_to_cpu(ri->ino);
 449         inode->i_mode = jemode_to_cpu(ri->mode);
 450         inode->i_gid = je16_to_cpu(ri->gid);
 451         inode->i_uid = je16_to_cpu(ri->uid);
 452         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 453         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 454
 455         inode->i_blksize = PAGE_SIZE;
 456         inode->i_blocks = 0;
 457         inode->i_size = 0;
 458
 459         insert_inode_hash(inode);
 460
 461         return inode;
 462 }
 463
 464
 465 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 466 {
 467         struct jffs2_sb_info *c;
 468         struct inode *root_i;
 469         int ret;
 470         size_t blocks;
 471
 472         c = JFFS2_SB_INFO(sb);
 473
 474 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 475         if (c->mtd->type == MTD_NANDFLASH) {
 476                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 477                 return -EINVAL;
 478         }
 479         if (c->mtd->type == MTD_DATAFLASH) {
 480                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 481                 return -EINVAL;
 482         }
 483 #endif
 484
 485         c->flash_size = c->mtd->size;
 486         c->sector_size = c->mtd->erasesize;
 487         blocks = c->flash_size / c->sector_size;
 488
 489         /*
 490          * Size alignment check
 491          */
 492         if ((c->sector_size * blocks) != c->flash_size) {
 493                 c->flash_size = c->sector_size * blocks;
 494                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 495                         c->flash_size / 1024);
 496         }
 497
 498         if (c->flash_size < 5*c->sector_size) {
 499                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 500                 return -EINVAL;
 501         }
 502
 503         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 504
 505         /* NAND (or other bizarre) flash... do setup accordingly */
 506         ret = jffs2_flash_setup(c);
 507         if (ret)
 508                 return ret;
 509
 510         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 511         if (!c->inocache_list) {
 512                 ret = -ENOMEM;
 513                 goto out_wbuf;
 514         }
 515         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 516
 517         jffs2_init_xattr_subsystem(c);
 518
 519         if ((ret = jffs2_do_mount_fs(c)))
 520                 goto out_inohash;
 521
 522         ret = -EINVAL;
 523
 524         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 525         root_i = iget(sb, 1);
 526         if (is_bad_inode(root_i)) {
 527                 D1(printk(KERN_WARNING "get root inode failed\n"));
 528                 goto out_root_i;
 529         }
 530
 531         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 532         sb->s_root = d_alloc_root(root_i);
 533         if (!sb->s_root)
 534                 goto out_root_i;
 535
 536         sb->s_maxbytes = 0xFFFFFFFF;
 537         sb->s_blocksize = PAGE_CACHE_SIZE;
 538         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 539         sb->s_magic = JFFS2_SUPER_MAGIC;
 540         if (!(sb->s_flags & MS_RDONLY))
 541                 jffs2_start_garbage_collect_thread(c);
 542         return 0;
 543
 544  out_root_i:
 545         iput(root_i);
 546         jffs2_free_ino_caches(c);
 547         jffs2_free_raw_node_refs(c);
 548         if (jffs2_blocks_use_vmalloc(c))
 549                 vfree(c->blocks);
 550         else
 551                 kfree(c->blocks);
 552  out_inohash:
 553         jffs2_clear_xattr_subsystem(c);
 554         kfree(c->inocache_list);
 555  out_wbuf:
 556         jffs2_flash_cleanup(c);
 557
 558         return ret;
 559 }
 560
 561 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 562                                    struct jffs2_inode_info *f)
 563 {
 564         iput(OFNI_EDONI_2SFFJ(f));
 565 }
 566
 567 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 568                                                      int inum, int nlink)
 569 {
 570         struct inode *inode;
 571         struct jffs2_inode_cache *ic;
 572         if (!nlink) {
 573                 /* The inode has zero nlink but its nodes weren't yet marked
 574                    obsolete. This has to be because we're still waiting for
 575                    the final (close() and) iput() to happen.
 576
 577                    There's a possibility that the final iput() could have
 578                    happened while we were contemplating. In order to ensure
 579                    that we don't cause a new read_inode() (which would fail)
 580                    for the inode in question, we use ilookup() in this case
 581                    instead of iget().
 582
 583                    The nlink can't _become_ zero at this point because we're
 584                    holding the alloc_sem, and jffs2_do_unlink() would also
 585                    need that while decrementing nlink on any inode.
 586                 */
 587                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 588                 if (!inode) {
 589                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 590                                   inum));
 591
 592                         spin_lock(&c->inocache_lock);
 593                         ic = jffs2_get_ino_cache(c, inum);
 594                         if (!ic) {
 595                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 596                                 spin_unlock(&c->inocache_lock);
 597                                 return NULL;
 598                         }
 599                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 600                                 /* Wait for progress. Don't just loop */
 601                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 602                                           ic->ino, ic->state));
 603                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 604                         } else {
 605                                 spin_unlock(&c->inocache_lock);
 606                         }
 607
 608                         return NULL;
 609                 }
 610         } else {
 611                 /* Inode has links to it still; they're not going away because
 612                    jffs2_do_unlink() would need the alloc_sem and we have it.
 613                    Just iget() it, and if read_inode() is necessary that's OK.
 614                 */
 615                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 616                 if (!inode)
 617                         return ERR_PTR(-ENOMEM);
 618         }
 619         if (is_bad_inode(inode)) {
 620                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 621                        inum, nlink);
 622                 /* NB. This will happen again. We need to do something appropriate here. */
 623                 iput(inode);
 624                 return ERR_PTR(-EIO);
 625         }
 626
 627         return JFFS2_INODE_INFO(inode);
 628 }
 629
 630 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 631                                    struct jffs2_inode_info *f,
 632                                    unsigned long offset,
 633                                    unsigned long *priv)
 634 {
 635         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 636         struct page *pg;
 637
 638         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 639                              (void *)jffs2_do_readpage_unlock, inode);
 640         if (IS_ERR(pg))
 641                 return (void *)pg;
 642
 643         *priv = (unsigned long)pg;
 644         return kmap(pg);
 645 }
 646
 647 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 648                            unsigned char *ptr,
 649                            unsigned long *priv)
 650 {
 651         struct page *pg = (void *)*priv;
 652
 653         kunmap(pg);
 654         page_cache_release(pg);
 655 }
 656
 657 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 658         int ret = 0;
 659
 660         if (jffs2_cleanmarker_oob(c)) {
 661                 /* NAND flash... do setup accordingly */
 662                 ret = jffs2_nand_flash_setup(c);
 663                 if (ret)
 664                         return ret;
 665         }
 666
 667         /* and Dataflash */
 668         if (jffs2_dataflash(c)) {
 669                 ret = jffs2_dataflash_setup(c);
 670                 if (ret)
 671                         return ret;
 672         }
 673
 674         /* and Intel "Sibley" flash */
 675         if (jffs2_nor_wbuf_flash(c)) {
 676                 ret = jffs2_nor_wbuf_flash_setup(c);
 677                 if (ret)
 678                         return ret;
 679         }
 680
 681         return ret;
 682 }
 683
 684 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 685
 686         if (jffs2_cleanmarker_oob(c)) {
 687                 jffs2_nand_flash_cleanup(c);
 688         }
 689
 690         /* and DataFlash */
 691         if (jffs2_dataflash(c)) {
 692                 jffs2_dataflash_cleanup(c);
 693         }
 694
 695         /* and Intel "Sibley" flash */
 696         if (jffs2_nor_wbuf_flash(c)) {
 697                 jffs2_nor_wbuf_flash_cleanup(c);
 698         }
 699 }