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