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