fs/jffs2/fs.c

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