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 {
 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
 438         /* POSIX ACLs have to be processed now, at least partly.
 439            The umask is only applied if there's no default ACL */
 440         ret = jffs2_init_acl_pre(dir_i, inode, &mode);
 441         if (ret) {
 442             make_bad_inode(inode);
 443             iput(inode);
 444             return ERR_PTR(ret);
 445         }
 446         ret = jffs2_do_new_inode (c, f, mode, ri);
 447         if (ret) {
 448                 make_bad_inode(inode);
 449                 iput(inode);
 450                 return ERR_PTR(ret);
 451         }
 452         inode->i_nlink = 1;
 453         inode->i_ino = je32_to_cpu(ri->ino);
 454         inode->i_mode = jemode_to_cpu(ri->mode);
 455         inode->i_gid = je16_to_cpu(ri->gid);
 456         inode->i_uid = je16_to_cpu(ri->uid);
 457         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 458         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 459
 460         inode->i_blocks = 0;
 461         inode->i_size = 0;
 462
 463         insert_inode_hash(inode);
 464
 465         return inode;
 466 }
 467
 468
 469 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 470 {
 471         struct jffs2_sb_info *c;
 472         struct inode *root_i;
 473         int ret;
 474         size_t blocks;
 475
 476         c = JFFS2_SB_INFO(sb);
 477
 478 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 479         if (c->mtd->type == MTD_NANDFLASH) {
 480                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 481                 return -EINVAL;
 482         }
 483         if (c->mtd->type == MTD_DATAFLASH) {
 484                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 485                 return -EINVAL;
 486         }
 487 #endif
 488
 489         c->flash_size = c->mtd->size;
 490         c->sector_size = c->mtd->erasesize;
 491         blocks = c->flash_size / c->sector_size;
 492
 493         /*
 494          * Size alignment check
 495          */
 496         if ((c->sector_size * blocks) != c->flash_size) {
 497                 c->flash_size = c->sector_size * blocks;
 498                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 499                         c->flash_size / 1024);
 500         }
 501
 502         if (c->flash_size < 5*c->sector_size) {
 503                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 504                 return -EINVAL;
 505         }
 506
 507         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 508
 509         /* NAND (or other bizarre) flash... do setup accordingly */
 510         ret = jffs2_flash_setup(c);
 511         if (ret)
 512                 return ret;
 513
 514         c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 515         if (!c->inocache_list) {
 516                 ret = -ENOMEM;
 517                 goto out_wbuf;
 518         }
 519
 520         jffs2_init_xattr_subsystem(c);
 521
 522         if ((ret = jffs2_do_mount_fs(c)))
 523                 goto out_inohash;
 524
 525         ret = -EINVAL;
 526
 527         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 528         root_i = iget(sb, 1);
 529         if (is_bad_inode(root_i)) {
 530                 D1(printk(KERN_WARNING "get root inode failed\n"));
 531                 goto out_root_i;
 532         }
 533
 534         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 535         sb->s_root = d_alloc_root(root_i);
 536         if (!sb->s_root)
 537                 goto out_root_i;
 538
 539         sb->s_maxbytes = 0xFFFFFFFF;
 540         sb->s_blocksize = PAGE_CACHE_SIZE;
 541         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 542         sb->s_magic = JFFS2_SUPER_MAGIC;
 543         if (!(sb->s_flags & MS_RDONLY))
 544                 jffs2_start_garbage_collect_thread(c);
 545         return 0;
 546
 547  out_root_i:
 548         iput(root_i);
 549         jffs2_free_ino_caches(c);
 550         jffs2_free_raw_node_refs(c);
 551         if (jffs2_blocks_use_vmalloc(c))
 552                 vfree(c->blocks);
 553         else
 554                 kfree(c->blocks);
 555  out_inohash:
 556         jffs2_clear_xattr_subsystem(c);
 557         kfree(c->inocache_list);
 558  out_wbuf:
 559         jffs2_flash_cleanup(c);
 560
 561         return ret;
 562 }
 563
 564 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 565                                    struct jffs2_inode_info *f)
 566 {
 567         iput(OFNI_EDONI_2SFFJ(f));
 568 }
 569
 570 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 571                                                      int inum, int nlink)
 572 {
 573         struct inode *inode;
 574         struct jffs2_inode_cache *ic;
 575         if (!nlink) {
 576                 /* The inode has zero nlink but its nodes weren't yet marked
 577                    obsolete. This has to be because we're still waiting for
 578                    the final (close() and) iput() to happen.
 579
 580                    There's a possibility that the final iput() could have
 581                    happened while we were contemplating. In order to ensure
 582                    that we don't cause a new read_inode() (which would fail)
 583                    for the inode in question, we use ilookup() in this case
 584                    instead of iget().
 585
 586                    The nlink can't _become_ zero at this point because we're
 587                    holding the alloc_sem, and jffs2_do_unlink() would also
 588                    need that while decrementing nlink on any inode.
 589                 */
 590                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 591                 if (!inode) {
 592                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 593                                   inum));
 594
 595                         spin_lock(&c->inocache_lock);
 596                         ic = jffs2_get_ino_cache(c, inum);
 597                         if (!ic) {
 598                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 599                                 spin_unlock(&c->inocache_lock);
 600                                 return NULL;
 601                         }
 602                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 603                                 /* Wait for progress. Don't just loop */
 604                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 605                                           ic->ino, ic->state));
 606                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 607                         } else {
 608                                 spin_unlock(&c->inocache_lock);
 609                         }
 610
 611                         return NULL;
 612                 }
 613         } else {
 614                 /* Inode has links to it still; they're not going away because
 615                    jffs2_do_unlink() would need the alloc_sem and we have it.
 616                    Just iget() it, and if read_inode() is necessary that's OK.
 617                 */
 618                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 619                 if (!inode)
 620                         return ERR_PTR(-ENOMEM);
 621         }
 622         if (is_bad_inode(inode)) {
 623                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 624                        inum, nlink);
 625                 /* NB. This will happen again. We need to do something appropriate here. */
 626                 iput(inode);
 627                 return ERR_PTR(-EIO);
 628         }
 629
 630         return JFFS2_INODE_INFO(inode);
 631 }
 632
 633 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 634                                    struct jffs2_inode_info *f,
 635                                    unsigned long offset,
 636                                    unsigned long *priv)
 637 {
 638         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 639         struct page *pg;
 640
 641         pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 642                              (void *)jffs2_do_readpage_unlock, inode);
 643         if (IS_ERR(pg))
 644                 return (void *)pg;
 645
 646         *priv = (unsigned long)pg;
 647         return kmap(pg);
 648 }
 649
 650 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 651                            unsigned char *ptr,
 652                            unsigned long *priv)
 653 {
 654         struct page *pg = (void *)*priv;
 655
 656         kunmap(pg);
 657         page_cache_release(pg);
 658 }
 659
 660 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 661         int ret = 0;
 662
 663         if (jffs2_cleanmarker_oob(c)) {
 664                 /* NAND flash... do setup accordingly */
 665                 ret = jffs2_nand_flash_setup(c);
 666                 if (ret)
 667                         return ret;
 668         }
 669
 670         /* and Dataflash */
 671         if (jffs2_dataflash(c)) {
 672                 ret = jffs2_dataflash_setup(c);
 673                 if (ret)
 674                         return ret;
 675         }
 676
 677         /* and Intel "Sibley" flash */
 678         if (jffs2_nor_wbuf_flash(c)) {
 679                 ret = jffs2_nor_wbuf_flash_setup(c);
 680                 if (ret)
 681                         return ret;
 682         }
 683
 684         /* and an UBI volume */
 685         if (jffs2_ubivol(c)) {
 686                 ret = jffs2_ubivol_setup(c);
 687                 if (ret)
 688                         return ret;
 689         }
 690
 691         return ret;
 692 }
 693
 694 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 695
 696         if (jffs2_cleanmarker_oob(c)) {
 697                 jffs2_nand_flash_cleanup(c);
 698         }
 699
 700         /* and DataFlash */
 701         if (jffs2_dataflash(c)) {
 702                 jffs2_dataflash_cleanup(c);
 703         }
 704
 705         /* and Intel "Sibley" flash */
 706         if (jffs2_nor_wbuf_flash(c)) {
 707                 jffs2_nor_wbuf_flash_cleanup(c);
 708         }
 709
 710         /* and an UBI volume */
 711         if (jffs2_ubivol(c)) {
 712                 jffs2_ubivol_cleanup(c);
 713         }
 714 }