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