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