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