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