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