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/kernel.h>
  16 #include <linux/sched.h>
  17 #include <linux/fs.h>
  18 #include <linux/list.h>
  19 #include <linux/mtd/mtd.h>
  20 #include <linux/pagemap.h>
  21 #include <linux/slab.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/vfs.h>
  24 #include <linux/crc32.h>
  25 #include "nodelist.h"
  26
  27 static int jffs2_flash_setup(struct jffs2_sb_info *c);
  28
  29 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  30 {
  31         struct jffs2_full_dnode *old_metadata, *new_metadata;
  32         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  33         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  34         struct jffs2_raw_inode *ri;
  35         union jffs2_device_node dev;
  36         unsigned char *mdata = NULL;
  37         int mdatalen = 0;
  38         unsigned int ivalid;
  39         uint32_t alloclen;
  40         int ret;
  41         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  42         ret = inode_change_ok(inode, iattr);
  43         if (ret)
  44                 return ret;
  45
  46         /* Special cases - we don't want more than one data node
  47            for these types on the medium at any time. So setattr
  48            must read the original data associated with the node
  49            (i.e. the device numbers or the target name) and write
  50            it out again with the appropriate data attached */
  51         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  52                 /* For these, we don't actually need to read the old node */
  53                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  54                 mdata = (char *)&dev;
  55                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  56         } else if (S_ISLNK(inode->i_mode)) {
  57                 down(&f->sem);
  58                 mdatalen = f->metadata->size;
  59                 mdata = kmalloc(f->metadata->size, GFP_USER);
  60                 if (!mdata) {
  61                         up(&f->sem);
  62                         return -ENOMEM;
  63                 }
  64                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  65                 if (ret) {
  66                         up(&f->sem);
  67                         kfree(mdata);
  68                         return ret;
  69                 }
  70                 up(&f->sem);
  71                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
  72         }
  73
  74         ri = jffs2_alloc_raw_inode();
  75         if (!ri) {
  76                 if (S_ISLNK(inode->i_mode))
  77                         kfree(mdata);
  78                 return -ENOMEM;
  79         }
  80
  81         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
  82                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  83         if (ret) {
  84                 jffs2_free_raw_inode(ri);
  85                 if (S_ISLNK(inode->i_mode & S_IFMT))
  86                          kfree(mdata);
  87                 return ret;
  88         }
  89         down(&f->sem);
  90         ivalid = iattr->ia_valid;
  91
  92         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  93         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  94         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  95         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  96
  97         ri->ino = cpu_to_je32(inode->i_ino);
  98         ri->version = cpu_to_je32(++f->highest_version);
  99
 100         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
 101         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
 102
 103         if (ivalid & ATTR_MODE)
 104                 if (iattr->ia_mode & S_ISGID &&
 105                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
 106                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
 107                 else
 108                         ri->mode = cpu_to_jemode(iattr->ia_mode);
 109         else
 110                 ri->mode = cpu_to_jemode(inode->i_mode);
 111
 112
 113         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 114         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 115         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 116         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 117
 118         ri->offset = cpu_to_je32(0);
 119         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 120         ri->compr = JFFS2_COMPR_NONE;
 121         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 122                 /* It's an extension. Make it a hole node */
 123                 ri->compr = JFFS2_COMPR_ZERO;
 124                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 125                 ri->offset = cpu_to_je32(inode->i_size);
 126         }
 127         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 128         if (mdatalen)
 129                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 130         else
 131                 ri->data_crc = cpu_to_je32(0);
 132
 133         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
 134         if (S_ISLNK(inode->i_mode))
 135                 kfree(mdata);
 136
 137         if (IS_ERR(new_metadata)) {
 138                 jffs2_complete_reservation(c);
 139                 jffs2_free_raw_inode(ri);
 140                 up(&f->sem);
 141                 return PTR_ERR(new_metadata);
 142         }
 143         /* It worked. Update the inode */
 144         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 145         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 146         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 147         inode->i_mode = jemode_to_cpu(ri->mode);
 148         inode->i_uid = je16_to_cpu(ri->uid);
 149         inode->i_gid = je16_to_cpu(ri->gid);
 150
 151
 152         old_metadata = f->metadata;
 153
 154         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 155                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 156
 157         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 158                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 159                 inode->i_size = iattr->ia_size;
 160                 f->metadata = NULL;
 161         } else {
 162                 f->metadata = new_metadata;
 163         }
 164         if (old_metadata) {
 165                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 166                 jffs2_free_full_dnode(old_metadata);
 167         }
 168         jffs2_free_raw_inode(ri);
 169
 170         up(&f->sem);
 171         jffs2_complete_reservation(c);
 172
 173         /* We have to do the vmtruncate() without f->sem held, since
 174            some pages may be locked and waiting for it in readpage().
 175            We are protected from a simultaneous write() extending i_size
 176            back past iattr->ia_size, because do_truncate() holds the
 177            generic inode semaphore. */
 178         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 179                 vmtruncate(inode, iattr->ia_size);
 180
 181         return 0;
 182 }
 183
 184 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 185 {
 186         int rc;
 187
 188         rc = jffs2_do_setattr(dentry->d_inode, iattr);
 189         if (!rc && (iattr->ia_valid & ATTR_MODE))
 190                 rc = jffs2_acl_chmod(dentry->d_inode);
 191         return rc;
 192 }
 193
 194 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 195 {
 196         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 197         unsigned long avail;
 198
 199         buf->f_type = JFFS2_SUPER_MAGIC;
 200         buf->f_bsize = 1 << PAGE_SHIFT;
 201         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 202         buf->f_files = 0;
 203         buf->f_ffree = 0;
 204         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 205
 206         spin_lock(&c->erase_completion_lock);
 207         avail = c->dirty_size + c->free_size;
 208         if (avail > c->sector_size * c->resv_blocks_write)
 209                 avail -= c->sector_size * c->resv_blocks_write;
 210         else
 211                 avail = 0;
 212         spin_unlock(&c->erase_completion_lock);
 213
 214         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 215
 216         return 0;
 217 }
 218
 219
 220 void jffs2_clear_inode (struct inode *inode)
 221 {
 222         /* We can forget about this inode for now - drop all
 223          *  the nodelists associated with it, etc.
 224          */
 225         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 226         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 227
 228         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 229         jffs2_do_clear_inode(c, f);
 230 }
 231
 232 void jffs2_read_inode (struct inode *inode)
 233 {
 234         struct jffs2_inode_info *f;
 235         struct jffs2_sb_info *c;
 236         struct jffs2_raw_inode latest_node;
 237         union jffs2_device_node jdev;
 238         dev_t rdev = 0;
 239         int ret;
 240
 241         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 242
 243         f = JFFS2_INODE_INFO(inode);
 244         c = JFFS2_SB_INFO(inode->i_sb);
 245
 246         jffs2_init_inode_info(f);
 247         down(&f->sem);
 248
 249         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 250
 251         if (ret) {
 252                 make_bad_inode(inode);
 253                 up(&f->sem);
 254                 return;
 255         }
 256         inode->i_mode = jemode_to_cpu(latest_node.mode);
 257         inode->i_uid = je16_to_cpu(latest_node.uid);
 258         inode->i_gid = je16_to_cpu(latest_node.gid);
 259         inode->i_size = je32_to_cpu(latest_node.isize);
 260         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 261         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 262         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 263
 264         inode->i_nlink = f->inocache->nlink;
 265
 266         inode->i_blksize = PAGE_SIZE;
 267         inode->i_blocks = (inode->i_size + 511) >> 9;
 268
 269         switch (inode->i_mode & S_IFMT) {
 270
 271         case S_IFLNK:
 272                 inode->i_op = &jffs2_symlink_inode_operations;
 273                 break;
 274
 275         case S_IFDIR:
 276         {
 277                 struct jffs2_full_dirent *fd;
 278
 279                 for (fd=f->dents; fd; fd = fd->next) {
 280                         if (fd->type == DT_DIR && fd->ino)
 281                                 inode->i_nlink++;
 282                 }
 283                 /* and '..' */
 284                 inode->i_nlink++;
 285                 /* Root dir gets i_nlink 3 for some reason */
 286                 if (inode->i_ino == 1)
 287                         inode->i_nlink++;
 288
 289                 inode->i_op = &jffs2_dir_inode_operations;
 290                 inode->i_fop = &jffs2_dir_operations;
 291                 break;
 292         }
 293         case S_IFREG:
 294                 inode->i_op = &jffs2_file_inode_operations;
 295                 inode->i_fop = &jffs2_file_operations;
 296                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 297                 inode->i_mapping->nrpages = 0;
 298                 break;
 299
 300         case S_IFBLK:
 301         case S_IFCHR:
 302                 /* Read the device numbers from the media */
 303                 if (f->metadata->size != sizeof(jdev.old) &&
 304                     f->metadata->size != sizeof(jdev.new)) {
 305                         printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
 306                         up(&f->sem);
 307                         jffs2_do_clear_inode(c, f);
 308                         make_bad_inode(inode);
 309                         return;
 310                 }
 311                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 312                 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
 313                         /* Eep */
 314                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 315                         up(&f->sem);
 316                         jffs2_do_clear_inode(c, f);
 317                         make_bad_inode(inode);
 318                         return;
 319                 }
 320                 if (f->metadata->size == sizeof(jdev.old))
 321                         rdev = old_decode_dev(je16_to_cpu(jdev.old));
 322                 else
 323                         rdev = new_decode_dev(je32_to_cpu(jdev.new));
 324
 325         case S_IFSOCK:
 326         case S_IFIFO:
 327                 inode->i_op = &jffs2_file_inode_operations;
 328                 init_special_inode(inode, inode->i_mode, rdev);
 329                 break;
 330
 331         default:
 332                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 333         }
 334
 335         up(&f->sem);
 336
 337         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 338 }
 339
 340 void jffs2_dirty_inode(struct inode *inode)
 341 {
 342         struct iattr iattr;
 343
 344         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 345                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 346                 return;
 347         }
 348
 349         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 350
 351         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 352         iattr.ia_mode = inode->i_mode;
 353         iattr.ia_uid = inode->i_uid;
 354         iattr.ia_gid = inode->i_gid;
 355         iattr.ia_atime = inode->i_atime;
 356         iattr.ia_mtime = inode->i_mtime;
 357         iattr.ia_ctime = inode->i_ctime;
 358
 359         jffs2_do_setattr(inode, &iattr);
 360 }
 361
 362 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 363 {
 364         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 365
 366         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 367                 return -EROFS;
 368
 369         /* We stop if it was running, then restart if it needs to.
 370            This also catches the case where it was stopped and this
 371            is just a remount to restart it.
 372            Flush the writebuffer, if neccecary, else we loose it */
 373         if (!(sb->s_flags & MS_RDONLY)) {
 374                 jffs2_stop_garbage_collect_thread(c);
 375                 down(&c->alloc_sem);
 376                 jffs2_flush_wbuf_pad(c);
 377                 up(&c->alloc_sem);
 378         }
 379
 380         if (!(*flags & MS_RDONLY))
 381                 jffs2_start_garbage_collect_thread(c);
 382
 383         *flags |= MS_NOATIME;
 384
 385         return 0;
 386 }
 387
 388 void jffs2_write_super (struct super_block *sb)
 389 {
 390         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 391         sb->s_dirt = 0;
 392
 393         if (sb->s_flags & MS_RDONLY)
 394                 return;
 395
 396         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 397         jffs2_garbage_collect_trigger(c);
 398         jffs2_erase_pending_blocks(c, 0);
 399         jffs2_flush_wbuf_gc(c, 0);
 400 }
 401
 402
 403 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 404    fill in the raw_inode while you're at it. */
 405 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 406 {
 407         struct inode *inode;
 408         struct super_block *sb = dir_i->i_sb;
 409         struct jffs2_sb_info *c;
 410         struct jffs2_inode_info *f;
 411         int ret;
 412
 413         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 414
 415         c = JFFS2_SB_INFO(sb);
 416
 417         inode = new_inode(sb);
 418
 419         if (!inode)
 420                 return ERR_PTR(-ENOMEM);
 421
 422         f = JFFS2_INODE_INFO(inode);
 423         jffs2_init_inode_info(f);
 424         down(&f->sem);
 425
 426         memset(ri, 0, sizeof(*ri));
 427         /* Set OS-specific defaults for new inodes */
 428         ri->uid = cpu_to_je16(current->fsuid);
 429
 430         if (dir_i->i_mode & S_ISGID) {
 431                 ri->gid = cpu_to_je16(dir_i->i_gid);
 432                 if (S_ISDIR(mode))
 433                         mode |= S_ISGID;
 434         } else {
 435                 ri->gid = cpu_to_je16(current->fsgid);
 436         }
 437         ri->mode =  cpu_to_jemode(mode);
 438         ret = jffs2_do_new_inode (c, f, mode, ri);
 439         if (ret) {
 440                 make_bad_inode(inode);
 441                 iput(inode);
 442                 return ERR_PTR(ret);
 443         }
 444         inode->i_nlink = 1;
 445         inode->i_ino = je32_to_cpu(ri->ino);
 446         inode->i_mode = jemode_to_cpu(ri->mode);
 447         inode->i_gid = je16_to_cpu(ri->gid);
 448         inode->i_uid = je16_to_cpu(ri->uid);
 449         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 450         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 451
 452         inode->i_blksize = PAGE_SIZE;
 453         inode->i_blocks = 0;
 454         inode->i_size = 0;
 455
 456         insert_inode_hash(inode);
 457
 458         return inode;
 459 }
 460
 461
 462 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 463 {
 464         struct jffs2_sb_info *c;
 465         struct inode *root_i;
 466         int ret;
 467         size_t blocks;
 468
 469         c = JFFS2_SB_INFO(sb);
 470
 471 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 472         if (c->mtd->type == MTD_NANDFLASH) {
 473                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 474                 return -EINVAL;
 475         }
 476         if (c->mtd->type == MTD_DATAFLASH) {
 477                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 478                 return -EINVAL;
 479         }
 480 #endif
 481
 482         c->flash_size = c->mtd->size;
 483         c->sector_size = c->mtd->erasesize;
 484         blocks = c->flash_size / c->sector_size;
 485
 486         /*
 487          * Size alignment check
 488          */
 489         if ((c->sector_size * blocks) != c->flash_size) {
 490                 c->flash_size = c->sector_size * blocks;
 491                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 492                         c->flash_size / 1024);
 493         }
 494
 495         if (c->flash_size < 5*c->sector_size) {
 496                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 497                 return -EINVAL;
 498         }
 499
 500         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 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         jffs2_init_xattr_subsystem(c);
 515
 516         if ((ret = jffs2_do_mount_fs(c)))
 517                 goto out_inohash;
 518
 519         ret = -EINVAL;
 520
 521         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 522         root_i = iget(sb, 1);
 523         if (is_bad_inode(root_i)) {
 524                 D1(printk(KERN_WARNING "get root inode failed\n"));
 525                 goto out_root_i;
 526         }
 527
 528         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 529         sb->s_root = d_alloc_root(root_i);
 530         if (!sb->s_root)
 531                 goto out_root_i;
 532
 533         sb->s_maxbytes = 0xFFFFFFFF;
 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         jffs2_free_ino_caches(c);
 544         jffs2_free_raw_node_refs(c);
 545         if (jffs2_blocks_use_vmalloc(c))
 546                 vfree(c->blocks);
 547         else
 548                 kfree(c->blocks);
 549  out_inohash:
 550         jffs2_clear_xattr_subsystem(c);
 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         /* and Dataflash */
 665         if (jffs2_dataflash(c)) {
 666                 ret = jffs2_dataflash_setup(c);
 667                 if (ret)
 668                         return ret;
 669         }
 670
 671         /* and Intel "Sibley" flash */
 672         if (jffs2_nor_wbuf_flash(c)) {
 673                 ret = jffs2_nor_wbuf_flash_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         /* and DataFlash */
 688         if (jffs2_dataflash(c)) {
 689                 jffs2_dataflash_cleanup(c);
 690         }
 691
 692         /* and Intel "Sibley" flash */
 693         if (jffs2_nor_wbuf_flash(c)) {
 694                 jffs2_nor_wbuf_flash_cleanup(c);
 695         }
 696 }