err.no Git - linux-2.6/blob - fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@infradead.org>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  */
  11
  12 #include <linux/capability.h>
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/fs.h>
  16 #include <linux/list.h>
  17 #include <linux/mtd/mtd.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/slab.h>
  20 #include <linux/vmalloc.h>
  21 #include <linux/vfs.h>
  22 #include <linux/crc32.h>
  23 #include "nodelist.h"
  24
  25 static int jffs2_flash_setup(struct jffs2_sb_info *c);
  26
  27 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  28 {
  29         struct jffs2_full_dnode *old_metadata, *new_metadata;
  30         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  31         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  32         struct jffs2_raw_inode *ri;
  33         union jffs2_device_node dev;
  34         unsigned char *mdata = NULL;
  35         int mdatalen = 0;
  36         unsigned int ivalid;
  37         uint32_t alloclen;
  38         int ret;
  39
  40         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  41
  42         /* Special cases - we don't want more than one data node
  43            for these types on the medium at any time. So setattr
  44            must read the original data associated with the node
  45            (i.e. the device numbers or the target name) and write
  46            it out again with the appropriate data attached */
  47         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  48                 /* For these, we don't actually need to read the old node */
  49                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  50                 mdata = (char *)&dev;
  51                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  52         } else if (S_ISLNK(inode->i_mode)) {
  53                 down(&f->sem);
  54                 mdatalen = f->metadata->size;
  55                 mdata = kmalloc(f->metadata->size, GFP_USER);
  56                 if (!mdata) {
  57                         up(&f->sem);
  58                         return -ENOMEM;
  59                 }
  60                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  61                 if (ret) {
  62                         up(&f->sem);
  63                         kfree(mdata);
  64                         return ret;
  65                 }
  66                 up(&f->sem);
  67                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
  68         }
  69
  70         ri = jffs2_alloc_raw_inode();
  71         if (!ri) {
  72                 if (S_ISLNK(inode->i_mode))
  73                         kfree(mdata);
  74                 return -ENOMEM;
  75         }
  76
  77         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
  78                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  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                 ri->mode = cpu_to_jemode(iattr->ia_mode);
 101         else
 102                 ri->mode = cpu_to_jemode(inode->i_mode);
 103
 104
 105         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 106         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 107         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 108         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 109
 110         ri->offset = cpu_to_je32(0);
 111         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 112         ri->compr = JFFS2_COMPR_NONE;
 113         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 114                 /* It's an extension. Make it a hole node */
 115                 ri->compr = JFFS2_COMPR_ZERO;
 116                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 117                 ri->offset = cpu_to_je32(inode->i_size);
 118         }
 119         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 120         if (mdatalen)
 121                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 122         else
 123                 ri->data_crc = cpu_to_je32(0);
 124
 125         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
 126         if (S_ISLNK(inode->i_mode))
 127                 kfree(mdata);
 128
 129         if (IS_ERR(new_metadata)) {
 130                 jffs2_complete_reservation(c);
 131                 jffs2_free_raw_inode(ri);
 132                 up(&f->sem);
 133                 return PTR_ERR(new_metadata);
 134         }
 135         /* It worked. Update the inode */
 136         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 137         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 138         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 139         inode->i_mode = jemode_to_cpu(ri->mode);
 140         inode->i_uid = je16_to_cpu(ri->uid);
 141         inode->i_gid = je16_to_cpu(ri->gid);
 142
 143
 144         old_metadata = f->metadata;
 145
 146         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 147                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 148
 149         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 150                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 151                 inode->i_size = iattr->ia_size;
 152                 inode->i_blocks = (inode->i_size + 511) >> 9;
 153                 f->metadata = NULL;
 154         } else {
 155                 f->metadata = new_metadata;
 156         }
 157         if (old_metadata) {
 158                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 159                 jffs2_free_full_dnode(old_metadata);
 160         }
 161         jffs2_free_raw_inode(ri);
 162
 163         up(&f->sem);
 164         jffs2_complete_reservation(c);
 165
 166         /* We have to do the vmtruncate() without f->sem held, since
 167            some pages may be locked and waiting for it in readpage().
 168            We are protected from a simultaneous write() extending i_size
 169            back past iattr->ia_size, because do_truncate() holds the
 170            generic inode semaphore. */
 171         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
 172                 vmtruncate(inode, iattr->ia_size);
 173                 inode->i_blocks = (inode->i_size + 511) >> 9;
 174         }
 175
 176         return 0;
 177 }
 178
 179 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 180 {
 181         int rc;
 182
 183         rc = inode_change_ok(dentry->d_inode, iattr);
 184         if (rc)
 185                 return rc;
 186
 187         rc = jffs2_do_setattr(dentry->d_inode, iattr);
 188         if (!rc && (iattr->ia_valid & ATTR_MODE))
 189                 rc = jffs2_acl_chmod(dentry->d_inode);
 190
 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 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
 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         struct inode *inode;
 239         dev_t rdev = 0;
 240         int ret;
 241
 242         D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
 243
 244         inode = iget_locked(sb, ino);
 245         if (!inode)
 246                 return ERR_PTR(-ENOMEM);
 247         if (!(inode->i_state & I_NEW))
 248                 return inode;
 249
 250         f = JFFS2_INODE_INFO(inode);
 251         c = JFFS2_SB_INFO(inode->i_sb);
 252
 253         jffs2_init_inode_info(f);
 254         down(&f->sem);
 255
 256         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 257
 258         if (ret) {
 259                 up(&f->sem);
 260                 iget_failed(inode);
 261                 return ERR_PTR(ret);
 262         }
 263         inode->i_mode = jemode_to_cpu(latest_node.mode);
 264         inode->i_uid = je16_to_cpu(latest_node.uid);
 265         inode->i_gid = je16_to_cpu(latest_node.gid);
 266         inode->i_size = je32_to_cpu(latest_node.isize);
 267         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 268         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 269         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 270
 271         inode->i_nlink = f->inocache->nlink;
 272
 273         inode->i_blocks = (inode->i_size + 511) >> 9;
 274
 275         switch (inode->i_mode & S_IFMT) {
 276
 277         case S_IFLNK:
 278                 inode->i_op = &jffs2_symlink_inode_operations;
 279                 break;
 280
 281         case S_IFDIR:
 282         {
 283                 struct jffs2_full_dirent *fd;
 284
 285                 for (fd=f->dents; fd; fd = fd->next) {
 286                         if (fd->type == DT_DIR && fd->ino)
 287                                 inc_nlink(inode);
 288                 }
 289                 /* and '..' */
 290                 inc_nlink(inode);
 291                 /* Root dir gets i_nlink 3 for some reason */
 292                 if (inode->i_ino == 1)
 293                         inc_nlink(inode);
 294
 295                 inode->i_op = &jffs2_dir_inode_operations;
 296                 inode->i_fop = &jffs2_dir_operations;
 297                 break;
 298         }
 299         case S_IFREG:
 300                 inode->i_op = &jffs2_file_inode_operations;
 301                 inode->i_fop = &jffs2_file_operations;
 302                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 303                 inode->i_mapping->nrpages = 0;
 304                 break;
 305
 306         case S_IFBLK:
 307         case S_IFCHR:
 308                 /* Read the device numbers from the media */
 309                 if (f->metadata->size != sizeof(jdev.old) &&
 310                     f->metadata->size != sizeof(jdev.new)) {
 311                         printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
 312                         goto error_io;
 313                 }
 314                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 315                 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
 316                 if (ret < 0) {
 317                         /* Eep */
 318                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 319                         goto error;
 320                 }
 321                 if (f->metadata->size == sizeof(jdev.old))
 322                         rdev = old_decode_dev(je16_to_cpu(jdev.old));
 323                 else
 324                         rdev = new_decode_dev(je32_to_cpu(jdev.new));
 325
 326         case S_IFSOCK:
 327         case S_IFIFO:
 328                 inode->i_op = &jffs2_file_inode_operations;
 329                 init_special_inode(inode, inode->i_mode, rdev);
 330                 break;
 331
 332         default:
 333                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 334         }
 335
 336         up(&f->sem);
 337
 338         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 339         unlock_new_inode(inode);
 340         return inode;
 341
 342 error_io:
 343         ret = -EIO;
 344 error:
 345         up(&f->sem);
 346         jffs2_do_clear_inode(c, f);
 347         iget_failed(inode);
 348         return ERR_PTR(ret);
 349 }
 350
 351 void jffs2_dirty_inode(struct inode *inode)
 352 {
 353         struct iattr iattr;
 354
 355         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 356                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 357                 return;
 358         }
 359
 360         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 361
 362         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 363         iattr.ia_mode = inode->i_mode;
 364         iattr.ia_uid = inode->i_uid;
 365         iattr.ia_gid = inode->i_gid;
 366         iattr.ia_atime = inode->i_atime;
 367         iattr.ia_mtime = inode->i_mtime;
 368         iattr.ia_ctime = inode->i_ctime;
 369
 370         jffs2_do_setattr(inode, &iattr);
 371 }
 372
 373 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 374 {
 375         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 376
 377         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 378                 return -EROFS;
 379
 380         /* We stop if it was running, then restart if it needs to.
 381            This also catches the case where it was stopped and this
 382            is just a remount to restart it.
 383            Flush the writebuffer, if neccecary, else we loose it */
 384         if (!(sb->s_flags & MS_RDONLY)) {
 385                 jffs2_stop_garbage_collect_thread(c);
 386                 down(&c->alloc_sem);
 387                 jffs2_flush_wbuf_pad(c);
 388                 up(&c->alloc_sem);
 389         }
 390
 391         if (!(*flags & MS_RDONLY))
 392                 jffs2_start_garbage_collect_thread(c);
 393
 394         *flags |= MS_NOATIME;
 395
 396         return 0;
 397 }
 398
 399 void jffs2_write_super (struct super_block *sb)
 400 {
 401         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 402         sb->s_dirt = 0;
 403
 404         if (sb->s_flags & MS_RDONLY)
 405                 return;
 406
 407         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 408         jffs2_garbage_collect_trigger(c);
 409         jffs2_erase_pending_blocks(c, 0);
 410         jffs2_flush_wbuf_gc(c, 0);
 411 }
 412
 413
 414 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 415    fill in the raw_inode while you're at it. */
 416 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 417 {
 418         struct inode *inode;
 419         struct super_block *sb = dir_i->i_sb;
 420         struct jffs2_sb_info *c;
 421         struct jffs2_inode_info *f;
 422         int ret;
 423
 424         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 425
 426         c = JFFS2_SB_INFO(sb);
 427
 428         inode = new_inode(sb);
 429
 430         if (!inode)
 431                 return ERR_PTR(-ENOMEM);
 432
 433         f = JFFS2_INODE_INFO(inode);
 434         jffs2_init_inode_info(f);
 435         down(&f->sem);
 436
 437         memset(ri, 0, sizeof(*ri));
 438         /* Set OS-specific defaults for new inodes */
 439         ri->uid = cpu_to_je16(current->fsuid);
 440
 441         if (dir_i->i_mode & S_ISGID) {
 442                 ri->gid = cpu_to_je16(dir_i->i_gid);
 443                 if (S_ISDIR(mode))
 444                         mode |= S_ISGID;
 445         } else {
 446                 ri->gid = cpu_to_je16(current->fsgid);
 447         }
 448
 449         /* POSIX ACLs have to be processed now, at least partly.
 450            The umask is only applied if there's no default ACL */
 451         ret = jffs2_init_acl_pre(dir_i, inode, &mode);
 452         if (ret) {
 453             make_bad_inode(inode);
 454             iput(inode);
 455             return ERR_PTR(ret);
 456         }
 457         ret = jffs2_do_new_inode (c, f, mode, ri);
 458         if (ret) {
 459                 make_bad_inode(inode);
 460                 iput(inode);
 461                 return ERR_PTR(ret);
 462         }
 463         inode->i_nlink = 1;
 464         inode->i_ino = je32_to_cpu(ri->ino);
 465         inode->i_mode = jemode_to_cpu(ri->mode);
 466         inode->i_gid = je16_to_cpu(ri->gid);
 467         inode->i_uid = je16_to_cpu(ri->uid);
 468         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 469         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 470
 471         inode->i_blocks = 0;
 472         inode->i_size = 0;
 473
 474         insert_inode_hash(inode);
 475
 476         return inode;
 477 }
 478
 479
 480 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 481 {
 482         struct jffs2_sb_info *c;
 483         struct inode *root_i;
 484         int ret;
 485         size_t blocks;
 486
 487         c = JFFS2_SB_INFO(sb);
 488
 489 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 490         if (c->mtd->type == MTD_NANDFLASH) {
 491                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 492                 return -EINVAL;
 493         }
 494         if (c->mtd->type == MTD_DATAFLASH) {
 495                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 496                 return -EINVAL;
 497         }
 498 #endif
 499
 500         c->flash_size = c->mtd->size;
 501         c->sector_size = c->mtd->erasesize;
 502         blocks = c->flash_size / c->sector_size;
 503
 504         /*
 505          * Size alignment check
 506          */
 507         if ((c->sector_size * blocks) != c->flash_size) {
 508                 c->flash_size = c->sector_size * blocks;
 509                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 510                         c->flash_size / 1024);
 511         }
 512
 513         if (c->flash_size < 5*c->sector_size) {
 514                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 515                 return -EINVAL;
 516         }
 517
 518         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 519
 520         /* NAND (or other bizarre) flash... do setup accordingly */
 521         ret = jffs2_flash_setup(c);
 522         if (ret)
 523                 return ret;
 524
 525         c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 526         if (!c->inocache_list) {
 527                 ret = -ENOMEM;
 528                 goto out_wbuf;
 529         }
 530
 531         jffs2_init_xattr_subsystem(c);
 532
 533         if ((ret = jffs2_do_mount_fs(c)))
 534                 goto out_inohash;
 535
 536         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 537         root_i = jffs2_iget(sb, 1);
 538         if (IS_ERR(root_i)) {
 539                 D1(printk(KERN_WARNING "get root inode failed\n"));
 540                 ret = PTR_ERR(root_i);
 541                 goto out_root;
 542         }
 543
 544         ret = -ENOMEM;
 545
 546         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 547         sb->s_root = d_alloc_root(root_i);
 548         if (!sb->s_root)
 549                 goto out_root_i;
 550
 551         sb->s_maxbytes = 0xFFFFFFFF;
 552         sb->s_blocksize = PAGE_CACHE_SIZE;
 553         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 554         sb->s_magic = JFFS2_SUPER_MAGIC;
 555         if (!(sb->s_flags & MS_RDONLY))
 556                 jffs2_start_garbage_collect_thread(c);
 557         return 0;
 558
 559  out_root_i:
 560         iput(root_i);
 561 out_root:
 562         jffs2_free_ino_caches(c);
 563         jffs2_free_raw_node_refs(c);
 564         if (jffs2_blocks_use_vmalloc(c))
 565                 vfree(c->blocks);
 566         else
 567                 kfree(c->blocks);
 568  out_inohash:
 569         jffs2_clear_xattr_subsystem(c);
 570         kfree(c->inocache_list);
 571  out_wbuf:
 572         jffs2_flash_cleanup(c);
 573
 574         return ret;
 575 }
 576
 577 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 578                                    struct jffs2_inode_info *f)
 579 {
 580         iput(OFNI_EDONI_2SFFJ(f));
 581 }
 582
 583 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 584                                                      int inum, int nlink)
 585 {
 586         struct inode *inode;
 587         struct jffs2_inode_cache *ic;
 588         if (!nlink) {
 589                 /* The inode has zero nlink but its nodes weren't yet marked
 590                    obsolete. This has to be because we're still waiting for
 591                    the final (close() and) iput() to happen.
 592
 593                    There's a possibility that the final iput() could have
 594                    happened while we were contemplating. In order to ensure
 595                    that we don't cause a new read_inode() (which would fail)
 596                    for the inode in question, we use ilookup() in this case
 597                    instead of iget().
 598
 599                    The nlink can't _become_ zero at this point because we're
 600                    holding the alloc_sem, and jffs2_do_unlink() would also
 601                    need that while decrementing nlink on any inode.
 602                 */
 603                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 604                 if (!inode) {
 605                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 606                                   inum));
 607
 608                         spin_lock(&c->inocache_lock);
 609                         ic = jffs2_get_ino_cache(c, inum);
 610                         if (!ic) {
 611                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 612                                 spin_unlock(&c->inocache_lock);
 613                                 return NULL;
 614                         }
 615                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 616                                 /* Wait for progress. Don't just loop */
 617                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 618                                           ic->ino, ic->state));
 619                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 620                         } else {
 621                                 spin_unlock(&c->inocache_lock);
 622                         }
 623
 624                         return NULL;
 625                 }
 626         } else {
 627                 /* Inode has links to it still; they're not going away because
 628                    jffs2_do_unlink() would need the alloc_sem and we have it.
 629                    Just iget() it, and if read_inode() is necessary that's OK.
 630                 */
 631                 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
 632                 if (IS_ERR(inode))
 633                         return ERR_CAST(inode);
 634         }
 635         if (is_bad_inode(inode)) {
 636                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 637                        inum, nlink);
 638                 /* NB. This will happen again. We need to do something appropriate here. */
 639                 iput(inode);
 640                 return ERR_PTR(-EIO);
 641         }
 642
 643         return JFFS2_INODE_INFO(inode);
 644 }
 645
 646 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 647                                    struct jffs2_inode_info *f,
 648                                    unsigned long offset,
 649                                    unsigned long *priv)
 650 {
 651         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 652         struct page *pg;
 653
 654         pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 655                              (void *)jffs2_do_readpage_unlock, inode);
 656         if (IS_ERR(pg))
 657                 return (void *)pg;
 658
 659         *priv = (unsigned long)pg;
 660         return kmap(pg);
 661 }
 662
 663 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 664                            unsigned char *ptr,
 665                            unsigned long *priv)
 666 {
 667         struct page *pg = (void *)*priv;
 668
 669         kunmap(pg);
 670         page_cache_release(pg);
 671 }
 672
 673 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 674         int ret = 0;
 675
 676         if (jffs2_cleanmarker_oob(c)) {
 677                 /* NAND flash... do setup accordingly */
 678                 ret = jffs2_nand_flash_setup(c);
 679                 if (ret)
 680                         return ret;
 681         }
 682
 683         /* and Dataflash */
 684         if (jffs2_dataflash(c)) {
 685                 ret = jffs2_dataflash_setup(c);
 686                 if (ret)
 687                         return ret;
 688         }
 689
 690         /* and Intel "Sibley" flash */
 691         if (jffs2_nor_wbuf_flash(c)) {
 692                 ret = jffs2_nor_wbuf_flash_setup(c);
 693                 if (ret)
 694                         return ret;
 695         }
 696
 697         /* and an UBI volume */
 698         if (jffs2_ubivol(c)) {
 699                 ret = jffs2_ubivol_setup(c);
 700                 if (ret)
 701                         return ret;
 702         }
 703
 704         return ret;
 705 }
 706
 707 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 708
 709         if (jffs2_cleanmarker_oob(c)) {
 710                 jffs2_nand_flash_cleanup(c);
 711         }
 712
 713         /* and DataFlash */
 714         if (jffs2_dataflash(c)) {
 715                 jffs2_dataflash_cleanup(c);
 716         }
 717
 718         /* and Intel "Sibley" flash */
 719         if (jffs2_nor_wbuf_flash(c)) {
 720                 jffs2_nor_wbuf_flash_cleanup(c);
 721         }
 722
 723         /* and an UBI volume */
 724         if (jffs2_ubivol(c)) {
 725                 jffs2_ubivol_cleanup(c);
 726         }
 727 }