fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc.
   5  * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
   6  *
   7  * Created by David Woodhouse <dwmw2@infradead.org>
   8  *
   9  * For licensing information, see the file 'LICENCE' in this directory.
  10  *
  11  */
  12
  13 #include <linux/capability.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/fs.h>
  17 #include <linux/list.h>
  18 #include <linux/mtd/mtd.h>
  19 #include <linux/pagemap.h>
  20 #include <linux/slab.h>
  21 #include <linux/vmalloc.h>
  22 #include <linux/vfs.h>
  23 #include <linux/crc32.h>
  24 #include <linux/smp_lock.h>
  25 #include "nodelist.h"
  26
  27 static int jffs2_flash_setup(struct jffs2_sb_info *c);
  28
  29 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  30 {
  31         struct jffs2_full_dnode *old_metadata, *new_metadata;
  32         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  33         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  34         struct jffs2_raw_inode *ri;
  35         union jffs2_device_node dev;
  36         unsigned char *mdata = NULL;
  37         int mdatalen = 0;
  38         unsigned int ivalid;
  39         uint32_t alloclen;
  40         int ret;
  41         int alloc_type = ALLOC_NORMAL;
  42
  43         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  44
  45         /* Special cases - we don't want more than one data node
  46            for these types on the medium at any time. So setattr
  47            must read the original data associated with the node
  48            (i.e. the device numbers or the target name) and write
  49            it out again with the appropriate data attached */
  50         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  51                 /* For these, we don't actually need to read the old node */
  52                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  53                 mdata = (char *)&dev;
  54                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  55         } else if (S_ISLNK(inode->i_mode)) {
  56                 mutex_lock(&f->sem);
  57                 mdatalen = f->metadata->size;
  58                 mdata = kmalloc(f->metadata->size, GFP_USER);
  59                 if (!mdata) {
  60                         mutex_unlock(&f->sem);
  61                         return -ENOMEM;
  62                 }
  63                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  64                 if (ret) {
  65                         mutex_unlock(&f->sem);
  66                         kfree(mdata);
  67                         return ret;
  68                 }
  69                 mutex_unlock(&f->sem);
  70                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
  71         }
  72
  73         ri = jffs2_alloc_raw_inode();
  74         if (!ri) {
  75                 if (S_ISLNK(inode->i_mode))
  76                         kfree(mdata);
  77                 return -ENOMEM;
  78         }
  79
  80         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
  81                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  82         if (ret) {
  83                 jffs2_free_raw_inode(ri);
  84                 if (S_ISLNK(inode->i_mode & S_IFMT))
  85                          kfree(mdata);
  86                 return ret;
  87         }
  88         mutex_lock(&f->sem);
  89         ivalid = iattr->ia_valid;
  90
  91         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  92         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  93         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  94         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  95
  96         ri->ino = cpu_to_je32(inode->i_ino);
  97         ri->version = cpu_to_je32(++f->highest_version);
  98
  99         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
 100         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
 101
 102         if (ivalid & ATTR_MODE)
 103                 ri->mode = cpu_to_jemode(iattr->ia_mode);
 104         else
 105                 ri->mode = cpu_to_jemode(inode->i_mode);
 106
 107
 108         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 109         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 110         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 111         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 112
 113         ri->offset = cpu_to_je32(0);
 114         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 115         ri->compr = JFFS2_COMPR_NONE;
 116         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 117                 /* It's an extension. Make it a hole node */
 118                 ri->compr = JFFS2_COMPR_ZERO;
 119                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 120                 ri->offset = cpu_to_je32(inode->i_size);
 121         } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
 122                 /* For truncate-to-zero, treat it as deletion because
 123                    it'll always be obsoleting all previous nodes */
 124                 alloc_type = ALLOC_DELETION;
 125         }
 126         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 127         if (mdatalen)
 128                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 129         else
 130                 ri->data_crc = cpu_to_je32(0);
 131
 132         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
 133         if (S_ISLNK(inode->i_mode))
 134                 kfree(mdata);
 135
 136         if (IS_ERR(new_metadata)) {
 137                 jffs2_complete_reservation(c);
 138                 jffs2_free_raw_inode(ri);
 139                 mutex_unlock(&f->sem);
 140                 return PTR_ERR(new_metadata);
 141         }
 142         /* It worked. Update the inode */
 143         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 144         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 145         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 146         inode->i_mode = jemode_to_cpu(ri->mode);
 147         inode->i_uid = je16_to_cpu(ri->uid);
 148         inode->i_gid = je16_to_cpu(ri->gid);
 149
 150
 151         old_metadata = f->metadata;
 152
 153         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 154                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 155
 156         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 157                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 158                 inode->i_size = iattr->ia_size;
 159                 inode->i_blocks = (inode->i_size + 511) >> 9;
 160                 f->metadata = NULL;
 161         } else {
 162                 f->metadata = new_metadata;
 163         }
 164         if (old_metadata) {
 165                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 166                 jffs2_free_full_dnode(old_metadata);
 167         }
 168         jffs2_free_raw_inode(ri);
 169
 170         mutex_unlock(&f->sem);
 171         jffs2_complete_reservation(c);
 172
 173         /* We have to do the vmtruncate() without f->sem held, since
 174            some pages may be locked and waiting for it in readpage().
 175            We are protected from a simultaneous write() extending i_size
 176            back past iattr->ia_size, because do_truncate() holds the
 177            generic inode semaphore. */
 178         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
 179                 vmtruncate(inode, iattr->ia_size);
 180                 inode->i_blocks = (inode->i_size + 511) >> 9;
 181         }
 182
 183         return 0;
 184 }
 185
 186 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 187 {
 188         int rc;
 189
 190         rc = inode_change_ok(dentry->d_inode, iattr);
 191         if (rc)
 192                 return rc;
 193
 194         rc = jffs2_do_setattr(dentry->d_inode, iattr);
 195         if (!rc && (iattr->ia_valid & ATTR_MODE))
 196                 rc = jffs2_acl_chmod(dentry->d_inode);
 197
 198         return rc;
 199 }
 200
 201 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 202 {
 203         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 204         unsigned long avail;
 205
 206         buf->f_type = JFFS2_SUPER_MAGIC;
 207         buf->f_bsize = 1 << PAGE_SHIFT;
 208         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 209         buf->f_files = 0;
 210         buf->f_ffree = 0;
 211         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 212         buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
 213         buf->f_fsid.val[1] = c->mtd->index;
 214
 215         spin_lock(&c->erase_completion_lock);
 216         avail = c->dirty_size + c->free_size;
 217         if (avail > c->sector_size * c->resv_blocks_write)
 218                 avail -= c->sector_size * c->resv_blocks_write;
 219         else
 220                 avail = 0;
 221         spin_unlock(&c->erase_completion_lock);
 222
 223         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 224
 225         return 0;
 226 }
 227
 228
 229 void jffs2_clear_inode (struct inode *inode)
 230 {
 231         /* We can forget about this inode for now - drop all
 232          *  the nodelists associated with it, etc.
 233          */
 234         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 235         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 236
 237         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 238         jffs2_do_clear_inode(c, f);
 239 }
 240
 241 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
 242 {
 243         struct jffs2_inode_info *f;
 244         struct jffs2_sb_info *c;
 245         struct jffs2_raw_inode latest_node;
 246         union jffs2_device_node jdev;
 247         struct inode *inode;
 248         dev_t rdev = 0;
 249         int ret;
 250
 251         D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
 252
 253         inode = iget_locked(sb, ino);
 254         if (!inode)
 255                 return ERR_PTR(-ENOMEM);
 256         if (!(inode->i_state & I_NEW))
 257                 return inode;
 258
 259         f = JFFS2_INODE_INFO(inode);
 260         c = JFFS2_SB_INFO(inode->i_sb);
 261
 262         jffs2_init_inode_info(f);
 263         mutex_lock(&f->sem);
 264
 265         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 266
 267         if (ret) {
 268                 mutex_unlock(&f->sem);
 269                 iget_failed(inode);
 270                 return ERR_PTR(ret);
 271         }
 272         inode->i_mode = jemode_to_cpu(latest_node.mode);
 273         inode->i_uid = je16_to_cpu(latest_node.uid);
 274         inode->i_gid = je16_to_cpu(latest_node.gid);
 275         inode->i_size = je32_to_cpu(latest_node.isize);
 276         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 277         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 278         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 279
 280         inode->i_nlink = f->inocache->pino_nlink;
 281
 282         inode->i_blocks = (inode->i_size + 511) >> 9;
 283
 284         switch (inode->i_mode & S_IFMT) {
 285
 286         case S_IFLNK:
 287                 inode->i_op = &jffs2_symlink_inode_operations;
 288                 break;
 289
 290         case S_IFDIR:
 291         {
 292                 struct jffs2_full_dirent *fd;
 293                 inode->i_nlink = 2; /* parent and '.' */
 294
 295                 for (fd=f->dents; fd; fd = fd->next) {
 296                         if (fd->type == DT_DIR && fd->ino)
 297                                 inc_nlink(inode);
 298                 }
 299                 /* Root dir gets i_nlink 3 for some reason */
 300                 if (inode->i_ino == 1)
 301                         inc_nlink(inode);
 302
 303                 inode->i_op = &jffs2_dir_inode_operations;
 304                 inode->i_fop = &jffs2_dir_operations;
 305                 break;
 306         }
 307         case S_IFREG:
 308                 inode->i_op = &jffs2_file_inode_operations;
 309                 inode->i_fop = &jffs2_file_operations;
 310                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 311                 inode->i_mapping->nrpages = 0;
 312                 break;
 313
 314         case S_IFBLK:
 315         case S_IFCHR:
 316                 /* Read the device numbers from the media */
 317                 if (f->metadata->size != sizeof(jdev.old_id) &&
 318                     f->metadata->size != sizeof(jdev.new_id)) {
 319                         printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
 320                         goto error_io;
 321                 }
 322                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 323                 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
 324                 if (ret < 0) {
 325                         /* Eep */
 326                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 327                         goto error;
 328                 }
 329                 if (f->metadata->size == sizeof(jdev.old_id))
 330                         rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
 331                 else
 332                         rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
 333
 334         case S_IFSOCK:
 335         case S_IFIFO:
 336                 inode->i_op = &jffs2_file_inode_operations;
 337                 init_special_inode(inode, inode->i_mode, rdev);
 338                 break;
 339
 340         default:
 341                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 342         }
 343
 344         mutex_unlock(&f->sem);
 345
 346         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 347         unlock_new_inode(inode);
 348         return inode;
 349
 350 error_io:
 351         ret = -EIO;
 352 error:
 353         mutex_unlock(&f->sem);
 354         jffs2_do_clear_inode(c, f);
 355         iget_failed(inode);
 356         return ERR_PTR(ret);
 357 }
 358
 359 void jffs2_dirty_inode(struct inode *inode)
 360 {
 361         struct iattr iattr;
 362
 363         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 364                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 365                 return;
 366         }
 367
 368         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 369
 370         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 371         iattr.ia_mode = inode->i_mode;
 372         iattr.ia_uid = inode->i_uid;
 373         iattr.ia_gid = inode->i_gid;
 374         iattr.ia_atime = inode->i_atime;
 375         iattr.ia_mtime = inode->i_mtime;
 376         iattr.ia_ctime = inode->i_ctime;
 377
 378         jffs2_do_setattr(inode, &iattr);
 379 }
 380
 381 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 382 {
 383         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 384
 385         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 386                 return -EROFS;
 387
 388         /* We stop if it was running, then restart if it needs to.
 389            This also catches the case where it was stopped and this
 390            is just a remount to restart it.
 391            Flush the writebuffer, if neccecary, else we loose it */
 392         lock_kernel();
 393         if (!(sb->s_flags & MS_RDONLY)) {
 394                 jffs2_stop_garbage_collect_thread(c);
 395                 mutex_lock(&c->alloc_sem);
 396                 jffs2_flush_wbuf_pad(c);
 397                 mutex_unlock(&c->alloc_sem);
 398         }
 399
 400         if (!(*flags & MS_RDONLY))
 401                 jffs2_start_garbage_collect_thread(c);
 402
 403         *flags |= MS_NOATIME;
 404
 405         unlock_kernel();
 406         return 0;
 407 }
 408
 409 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 410    fill in the raw_inode while you're at it. */
 411 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 412 {
 413         struct inode *inode;
 414         struct super_block *sb = dir_i->i_sb;
 415         struct jffs2_sb_info *c;
 416         struct jffs2_inode_info *f;
 417         int ret;
 418
 419         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 420
 421         c = JFFS2_SB_INFO(sb);
 422
 423         inode = new_inode(sb);
 424
 425         if (!inode)
 426                 return ERR_PTR(-ENOMEM);
 427
 428         f = JFFS2_INODE_INFO(inode);
 429         jffs2_init_inode_info(f);
 430         mutex_lock(&f->sem);
 431
 432         memset(ri, 0, sizeof(*ri));
 433         /* Set OS-specific defaults for new inodes */
 434         ri->uid = cpu_to_je16(current_fsuid());
 435
 436         if (dir_i->i_mode & S_ISGID) {
 437                 ri->gid = cpu_to_je16(dir_i->i_gid);
 438                 if (S_ISDIR(mode))
 439                         mode |= S_ISGID;
 440         } else {
 441                 ri->gid = cpu_to_je16(current_fsgid());
 442         }
 443
 444         /* POSIX ACLs have to be processed now, at least partly.
 445            The umask is only applied if there's no default ACL */
 446         ret = jffs2_init_acl_pre(dir_i, inode, &mode);
 447         if (ret) {
 448             make_bad_inode(inode);
 449             iput(inode);
 450             return ERR_PTR(ret);
 451         }
 452         ret = jffs2_do_new_inode (c, f, mode, ri);
 453         if (ret) {
 454                 make_bad_inode(inode);
 455                 iput(inode);
 456                 return ERR_PTR(ret);
 457         }
 458         inode->i_nlink = 1;
 459         inode->i_ino = je32_to_cpu(ri->ino);
 460         inode->i_mode = jemode_to_cpu(ri->mode);
 461         inode->i_gid = je16_to_cpu(ri->gid);
 462         inode->i_uid = je16_to_cpu(ri->uid);
 463         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 464         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 465
 466         inode->i_blocks = 0;
 467         inode->i_size = 0;
 468
 469         if (insert_inode_locked(inode) < 0) {
 470                 make_bad_inode(inode);
 471                 unlock_new_inode(inode);
 472                 iput(inode);
 473                 return ERR_PTR(-EINVAL);
 474         }
 475
 476         return inode;
 477 }
 478
 479
 480 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 481 {
 482         struct jffs2_sb_info *c;
 483         struct inode *root_i;
 484         int ret;
 485         size_t blocks;
 486
 487         c = JFFS2_SB_INFO(sb);
 488
 489 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 490         if (c->mtd->type == MTD_NANDFLASH) {
 491                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 492                 return -EINVAL;
 493         }
 494         if (c->mtd->type == MTD_DATAFLASH) {
 495                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 496                 return -EINVAL;
 497         }
 498 #endif
 499
 500         c->flash_size = c->mtd->size;
 501         c->sector_size = c->mtd->erasesize;
 502         blocks = c->flash_size / c->sector_size;
 503
 504         /*
 505          * Size alignment check
 506          */
 507         if ((c->sector_size * blocks) != c->flash_size) {
 508                 c->flash_size = c->sector_size * blocks;
 509                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 510                         c->flash_size / 1024);
 511         }
 512
 513         if (c->flash_size < 5*c->sector_size) {
 514                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 515                 return -EINVAL;
 516         }
 517
 518         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 519
 520         /* NAND (or other bizarre) flash... do setup accordingly */
 521         ret = jffs2_flash_setup(c);
 522         if (ret)
 523                 return ret;
 524
 525         c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 526         if (!c->inocache_list) {
 527                 ret = -ENOMEM;
 528                 goto out_wbuf;
 529         }
 530
 531         jffs2_init_xattr_subsystem(c);
 532
 533         if ((ret = jffs2_do_mount_fs(c)))
 534                 goto out_inohash;
 535
 536         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 537         root_i = jffs2_iget(sb, 1);
 538         if (IS_ERR(root_i)) {
 539                 D1(printk(KERN_WARNING "get root inode failed\n"));
 540                 ret = PTR_ERR(root_i);
 541                 goto out_root;
 542         }
 543
 544         ret = -ENOMEM;
 545
 546         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 547         sb->s_root = d_alloc_root(root_i);
 548         if (!sb->s_root)
 549                 goto out_root_i;
 550
 551         sb->s_maxbytes = 0xFFFFFFFF;
 552         sb->s_blocksize = PAGE_CACHE_SIZE;
 553         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 554         sb->s_magic = JFFS2_SUPER_MAGIC;
 555         if (!(sb->s_flags & MS_RDONLY))
 556                 jffs2_start_garbage_collect_thread(c);
 557         return 0;
 558
 559  out_root_i:
 560         iput(root_i);
 561 out_root:
 562         jffs2_free_ino_caches(c);
 563         jffs2_free_raw_node_refs(c);
 564         if (jffs2_blocks_use_vmalloc(c))
 565                 vfree(c->blocks);
 566         else
 567                 kfree(c->blocks);
 568  out_inohash:
 569         jffs2_clear_xattr_subsystem(c);
 570         kfree(c->inocache_list);
 571  out_wbuf:
 572         jffs2_flash_cleanup(c);
 573
 574         return ret;
 575 }
 576
 577 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 578                                    struct jffs2_inode_info *f)
 579 {
 580         iput(OFNI_EDONI_2SFFJ(f));
 581 }
 582
 583 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 584                                               int inum, int unlinked)
 585 {
 586         struct inode *inode;
 587         struct jffs2_inode_cache *ic;
 588
 589         if (unlinked) {
 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. unlinked %d\n",
 638                        inum, unlinked);
 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 }