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