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