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                 if (iattr->ia_mode & S_ISGID &&
 101                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
 102                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
 103                 else
 104                         ri->mode = cpu_to_jemode(iattr->ia_mode);
 105         else
 106                 ri->mode = cpu_to_jemode(inode->i_mode);
 107
 108
 109         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 110         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 111         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 112         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 113
 114         ri->offset = cpu_to_je32(0);
 115         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 116         ri->compr = JFFS2_COMPR_NONE;
 117         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 118                 /* It's an extension. Make it a hole node */
 119                 ri->compr = JFFS2_COMPR_ZERO;
 120                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 121                 ri->offset = cpu_to_je32(inode->i_size);
 122         }
 123         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 124         if (mdatalen)
 125                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 126         else
 127                 ri->data_crc = cpu_to_je32(0);
 128
 129         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
 130         if (S_ISLNK(inode->i_mode))
 131                 kfree(mdata);
 132
 133         if (IS_ERR(new_metadata)) {
 134                 jffs2_complete_reservation(c);
 135                 jffs2_free_raw_inode(ri);
 136                 up(&f->sem);
 137                 return PTR_ERR(new_metadata);
 138         }
 139         /* It worked. Update the inode */
 140         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 141         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 142         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 143         inode->i_mode = jemode_to_cpu(ri->mode);
 144         inode->i_uid = je16_to_cpu(ri->uid);
 145         inode->i_gid = je16_to_cpu(ri->gid);
 146
 147
 148         old_metadata = f->metadata;
 149
 150         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 151                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 152
 153         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 154                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 155                 inode->i_size = iattr->ia_size;
 156                 f->metadata = NULL;
 157         } else {
 158                 f->metadata = new_metadata;
 159         }
 160         if (old_metadata) {
 161                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 162                 jffs2_free_full_dnode(old_metadata);
 163         }
 164         jffs2_free_raw_inode(ri);
 165
 166         up(&f->sem);
 167         jffs2_complete_reservation(c);
 168
 169         /* We have to do the vmtruncate() without f->sem held, since
 170            some pages may be locked and waiting for it in readpage().
 171            We are protected from a simultaneous write() extending i_size
 172            back past iattr->ia_size, because do_truncate() holds the
 173            generic inode semaphore. */
 174         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 175                 vmtruncate(inode, iattr->ia_size);
 176
 177         return 0;
 178 }
 179
 180 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 181 {
 182         int rc;
 183
 184         rc = inode_change_ok(dentry->d_inode, iattr);
 185         if (rc)
 186                 return 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
 192         return rc;
 193 }
 194
 195 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 196 {
 197         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_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         jffs2_do_clear_inode(c, f);
 231 }
 232
 233 void jffs2_read_inode (struct inode *inode)
 234 {
 235         struct jffs2_inode_info *f;
 236         struct jffs2_sb_info *c;
 237         struct jffs2_raw_inode latest_node;
 238         union jffs2_device_node jdev;
 239         dev_t rdev = 0;
 240         int ret;
 241
 242         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 243
 244         f = JFFS2_INODE_INFO(inode);
 245         c = JFFS2_SB_INFO(inode->i_sb);
 246
 247         jffs2_init_inode_info(f);
 248         down(&f->sem);
 249
 250         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 251
 252         if (ret) {
 253                 make_bad_inode(inode);
 254                 up(&f->sem);
 255                 return;
 256         }
 257         inode->i_mode = jemode_to_cpu(latest_node.mode);
 258         inode->i_uid = je16_to_cpu(latest_node.uid);
 259         inode->i_gid = je16_to_cpu(latest_node.gid);
 260         inode->i_size = je32_to_cpu(latest_node.isize);
 261         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 262         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 263         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 264
 265         inode->i_nlink = f->inocache->nlink;
 266
 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                                 inc_nlink(inode);
 282                 }
 283                 /* and '..' */
 284                 inc_nlink(inode);
 285                 /* Root dir gets i_nlink 3 for some reason */
 286                 if (inode->i_ino == 1)
 287                         inc_nlink(inode);
 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                                struct posix_acl **acl)
 407 {
 408         struct inode *inode;
 409         struct super_block *sb = dir_i->i_sb;
 410         struct jffs2_sb_info *c;
 411         struct jffs2_inode_info *f;
 412         int ret;
 413
 414         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 415
 416         c = JFFS2_SB_INFO(sb);
 417
 418         inode = new_inode(sb);
 419
 420         if (!inode)
 421                 return ERR_PTR(-ENOMEM);
 422
 423         f = JFFS2_INODE_INFO(inode);
 424         jffs2_init_inode_info(f);
 425         down(&f->sem);
 426
 427         memset(ri, 0, sizeof(*ri));
 428         /* Set OS-specific defaults for new inodes */
 429         ri->uid = cpu_to_je16(current->fsuid);
 430
 431         if (dir_i->i_mode & S_ISGID) {
 432                 ri->gid = cpu_to_je16(dir_i->i_gid);
 433                 if (S_ISDIR(mode))
 434                         mode |= S_ISGID;
 435         } else {
 436                 ri->gid = cpu_to_je16(current->fsgid);
 437         }
 438
 439         /* POSIX ACLs have to be processed now, at least partly.
 440            The umask is only applied if there's no default ACL */
 441         if (!S_ISLNK(mode)) {
 442                 *acl = jffs2_get_acl(dir_i, ACL_TYPE_DEFAULT);
 443                 if (IS_ERR(*acl)) {
 444                         make_bad_inode(inode);
 445                         iput(inode);
 446                         inode = (void *)*acl;
 447                         *acl = NULL;
 448                         return inode;
 449                 }
 450                 if (!(*acl))
 451                         mode &= ~current->fs->umask;
 452         } else {
 453                 *acl = NULL;
 454         }
 455         ret = jffs2_do_new_inode (c, f, mode, ri);
 456         if (ret) {
 457                 make_bad_inode(inode);
 458                 iput(inode);
 459                 return ERR_PTR(ret);
 460         }
 461         inode->i_nlink = 1;
 462         inode->i_ino = je32_to_cpu(ri->ino);
 463         inode->i_mode = jemode_to_cpu(ri->mode);
 464         inode->i_gid = je16_to_cpu(ri->gid);
 465         inode->i_uid = je16_to_cpu(ri->uid);
 466         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 467         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 468
 469         inode->i_blocks = 0;
 470         inode->i_size = 0;
 471
 472         insert_inode_hash(inode);
 473
 474         return inode;
 475 }
 476
 477
 478 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 479 {
 480         struct jffs2_sb_info *c;
 481         struct inode *root_i;
 482         int ret;
 483         size_t blocks;
 484
 485         c = JFFS2_SB_INFO(sb);
 486
 487 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 488         if (c->mtd->type == MTD_NANDFLASH) {
 489                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 490                 return -EINVAL;
 491         }
 492         if (c->mtd->type == MTD_DATAFLASH) {
 493                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 494                 return -EINVAL;
 495         }
 496 #endif
 497
 498         c->flash_size = c->mtd->size;
 499         c->sector_size = c->mtd->erasesize;
 500         blocks = c->flash_size / c->sector_size;
 501
 502         /*
 503          * Size alignment check
 504          */
 505         if ((c->sector_size * blocks) != c->flash_size) {
 506                 c->flash_size = c->sector_size * blocks;
 507                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 508                         c->flash_size / 1024);
 509         }
 510
 511         if (c->flash_size < 5*c->sector_size) {
 512                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 513                 return -EINVAL;
 514         }
 515
 516         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 517
 518         /* NAND (or other bizarre) flash... do setup accordingly */
 519         ret = jffs2_flash_setup(c);
 520         if (ret)
 521                 return ret;
 522
 523         c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 524         if (!c->inocache_list) {
 525                 ret = -ENOMEM;
 526                 goto out_wbuf;
 527         }
 528
 529         jffs2_init_xattr_subsystem(c);
 530
 531         if ((ret = jffs2_do_mount_fs(c)))
 532                 goto out_inohash;
 533
 534         ret = -EINVAL;
 535
 536         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 537         root_i = iget(sb, 1);
 538         if (is_bad_inode(root_i)) {
 539                 D1(printk(KERN_WARNING "get root inode failed\n"));
 540                 goto out_root_i;
 541         }
 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         jffs2_free_ino_caches(c);
 559         jffs2_free_raw_node_refs(c);
 560         if (jffs2_blocks_use_vmalloc(c))
 561                 vfree(c->blocks);
 562         else
 563                 kfree(c->blocks);
 564  out_inohash:
 565         jffs2_clear_xattr_subsystem(c);
 566         kfree(c->inocache_list);
 567  out_wbuf:
 568         jffs2_flash_cleanup(c);
 569
 570         return ret;
 571 }
 572
 573 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 574                                    struct jffs2_inode_info *f)
 575 {
 576         iput(OFNI_EDONI_2SFFJ(f));
 577 }
 578
 579 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 580                                                      int inum, int nlink)
 581 {
 582         struct inode *inode;
 583         struct jffs2_inode_cache *ic;
 584         if (!nlink) {
 585                 /* The inode has zero nlink but its nodes weren't yet marked
 586                    obsolete. This has to be because we're still waiting for
 587                    the final (close() and) iput() to happen.
 588
 589                    There's a possibility that the final iput() could have
 590                    happened while we were contemplating. In order to ensure
 591                    that we don't cause a new read_inode() (which would fail)
 592                    for the inode in question, we use ilookup() in this case
 593                    instead of iget().
 594
 595                    The nlink can't _become_ zero at this point because we're
 596                    holding the alloc_sem, and jffs2_do_unlink() would also
 597                    need that while decrementing nlink on any inode.
 598                 */
 599                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 600                 if (!inode) {
 601                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 602                                   inum));
 603
 604                         spin_lock(&c->inocache_lock);
 605                         ic = jffs2_get_ino_cache(c, inum);
 606                         if (!ic) {
 607                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 608                                 spin_unlock(&c->inocache_lock);
 609                                 return NULL;
 610                         }
 611                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 612                                 /* Wait for progress. Don't just loop */
 613                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 614                                           ic->ino, ic->state));
 615                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 616                         } else {
 617                                 spin_unlock(&c->inocache_lock);
 618                         }
 619
 620                         return NULL;
 621                 }
 622         } else {
 623                 /* Inode has links to it still; they're not going away because
 624                    jffs2_do_unlink() would need the alloc_sem and we have it.
 625                    Just iget() it, and if read_inode() is necessary that's OK.
 626                 */
 627                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 628                 if (!inode)
 629                         return ERR_PTR(-ENOMEM);
 630         }
 631         if (is_bad_inode(inode)) {
 632                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 633                        inum, nlink);
 634                 /* NB. This will happen again. We need to do something appropriate here. */
 635                 iput(inode);
 636                 return ERR_PTR(-EIO);
 637         }
 638
 639         return JFFS2_INODE_INFO(inode);
 640 }
 641
 642 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 643                                    struct jffs2_inode_info *f,
 644                                    unsigned long offset,
 645                                    unsigned long *priv)
 646 {
 647         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 648         struct page *pg;
 649
 650         pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 651                              (void *)jffs2_do_readpage_unlock, inode);
 652         if (IS_ERR(pg))
 653                 return (void *)pg;
 654
 655         *priv = (unsigned long)pg;
 656         return kmap(pg);
 657 }
 658
 659 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 660                            unsigned char *ptr,
 661                            unsigned long *priv)
 662 {
 663         struct page *pg = (void *)*priv;
 664
 665         kunmap(pg);
 666         page_cache_release(pg);
 667 }
 668
 669 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 670         int ret = 0;
 671
 672         if (jffs2_cleanmarker_oob(c)) {
 673                 /* NAND flash... do setup accordingly */
 674                 ret = jffs2_nand_flash_setup(c);
 675                 if (ret)
 676                         return ret;
 677         }
 678
 679         /* and Dataflash */
 680         if (jffs2_dataflash(c)) {
 681                 ret = jffs2_dataflash_setup(c);
 682                 if (ret)
 683                         return ret;
 684         }
 685
 686         /* and Intel "Sibley" flash */
 687         if (jffs2_nor_wbuf_flash(c)) {
 688                 ret = jffs2_nor_wbuf_flash_setup(c);
 689                 if (ret)
 690                         return ret;
 691         }
 692
 693         /* and an UBI volume */
 694         if (jffs2_ubivol(c)) {
 695                 ret = jffs2_ubivol_setup(c);
 696                 if (ret)
 697                         return ret;
 698         }
 699
 700         return ret;
 701 }
 702
 703 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 704
 705         if (jffs2_cleanmarker_oob(c)) {
 706                 jffs2_nand_flash_cleanup(c);
 707         }
 708
 709         /* and DataFlash */
 710         if (jffs2_dataflash(c)) {
 711                 jffs2_dataflash_cleanup(c);
 712         }
 713
 714         /* and Intel "Sibley" flash */
 715         if (jffs2_nor_wbuf_flash(c)) {
 716                 jffs2_nor_wbuf_flash_cleanup(c);
 717         }
 718
 719         /* and an UBI volume */
 720         if (jffs2_ubivol(c)) {
 721                 jffs2_ubivol_cleanup(c);
 722         }
 723 }