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