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