fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 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  * $Id: fs.c,v 1.66 2005/09/27 13:17:29 dedekind Exp $
  11  *
  12  */
  13
  14 #include <linux/capability.h>
  15 #include <linux/kernel.h>
  16 #include <linux/sched.h>
  17 #include <linux/fs.h>
  18 #include <linux/list.h>
  19 #include <linux/mtd/mtd.h>
  20 #include <linux/pagemap.h>
  21 #include <linux/slab.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/vfs.h>
  24 #include <linux/crc32.h>
  25 #include "nodelist.h"
  26
  27 static int jffs2_flash_setup(struct jffs2_sb_info *c);
  28
  29 static 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         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  42         ret = inode_change_ok(inode, iattr);
  43         if (ret)
  44                 return ret;
  45
  46         /* Special cases - we don't want more than one data node
  47            for these types on the medium at any time. So setattr
  48            must read the original data associated with the node
  49            (i.e. the device numbers or the target name) and write
  50            it out again with the appropriate data attached */
  51         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  52                 /* For these, we don't actually need to read the old node */
  53                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  54                 mdata = (char *)&dev;
  55                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  56         } else if (S_ISLNK(inode->i_mode)) {
  57                 down(&f->sem);
  58                 mdatalen = f->metadata->size;
  59                 mdata = kmalloc(f->metadata->size, GFP_USER);
  60                 if (!mdata) {
  61                         up(&f->sem);
  62                         return -ENOMEM;
  63                 }
  64                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  65                 if (ret) {
  66                         up(&f->sem);
  67                         kfree(mdata);
  68                         return ret;
  69                 }
  70                 up(&f->sem);
  71                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", 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 & S_IFMT))
  86                          kfree(mdata);
  87                 return ret;
  88         }
  89         down(&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                 if (iattr->ia_mode & S_ISGID &&
 105                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
 106                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
 107                 else
 108                         ri->mode = cpu_to_jemode(iattr->ia_mode);
 109         else
 110                 ri->mode = cpu_to_jemode(inode->i_mode);
 111
 112
 113         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 114         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 115         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 116         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 117
 118         ri->offset = cpu_to_je32(0);
 119         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 120         ri->compr = JFFS2_COMPR_NONE;
 121         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 122                 /* It's an extension. Make it a hole node */
 123                 ri->compr = JFFS2_COMPR_ZERO;
 124                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 125                 ri->offset = cpu_to_je32(inode->i_size);
 126         }
 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_NORMAL);
 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                 up(&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                 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         up(&f->sem);
 171         jffs2_complete_reservation(c);
 172
 173         /* We have to do the vmtruncate() 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                 vmtruncate(inode, iattr->ia_size);
 180
 181         return 0;
 182 }
 183
 184 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 185 {
 186         int rc;
 187
 188         rc = jffs2_do_setattr(dentry->d_inode, iattr);
 189         if (!rc && (iattr->ia_valid & ATTR_MODE))
 190                 rc = jffs2_acl_chmod(dentry->d_inode);
 191         return rc;
 192 }
 193
 194 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 195 {
 196         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 197         unsigned long avail;
 198
 199         buf->f_type = JFFS2_SUPER_MAGIC;
 200         buf->f_bsize = 1 << PAGE_SHIFT;
 201         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 202         buf->f_files = 0;
 203         buf->f_ffree = 0;
 204         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 205
 206         spin_lock(&c->erase_completion_lock);
 207         avail = c->dirty_size + c->free_size;
 208         if (avail > c->sector_size * c->resv_blocks_write)
 209                 avail -= c->sector_size * c->resv_blocks_write;
 210         else
 211                 avail = 0;
 212         spin_unlock(&c->erase_completion_lock);
 213
 214         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 215
 216         return 0;
 217 }
 218
 219
 220 void jffs2_clear_inode (struct inode *inode)
 221 {
 222         /* We can forget about this inode for now - drop all
 223          *  the nodelists associated with it, etc.
 224          */
 225         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 226         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 227
 228         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 229         jffs2_do_clear_inode(c, f);
 230 }
 231
 232 void jffs2_read_inode (struct inode *inode)
 233 {
 234         struct jffs2_inode_info *f;
 235         struct jffs2_sb_info *c;
 236         struct jffs2_raw_inode latest_node;
 237         union jffs2_device_node jdev;
 238         dev_t rdev = 0;
 239         int ret;
 240
 241         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 242
 243         f = JFFS2_INODE_INFO(inode);
 244         c = JFFS2_SB_INFO(inode->i_sb);
 245
 246         jffs2_init_inode_info(f);
 247         down(&f->sem);
 248
 249         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 250
 251         if (ret) {
 252                 make_bad_inode(inode);
 253                 up(&f->sem);
 254                 return;
 255         }
 256         inode->i_mode = jemode_to_cpu(latest_node.mode);
 257         inode->i_uid = je16_to_cpu(latest_node.uid);
 258         inode->i_gid = je16_to_cpu(latest_node.gid);
 259         inode->i_size = je32_to_cpu(latest_node.isize);
 260         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 261         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 262         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 263
 264         inode->i_nlink = f->inocache->nlink;
 265
 266         inode->i_blocks = (inode->i_size + 511) >> 9;
 267
 268         switch (inode->i_mode & S_IFMT) {
 269
 270         case S_IFLNK:
 271                 inode->i_op = &jffs2_symlink_inode_operations;
 272                 break;
 273
 274         case S_IFDIR:
 275         {
 276                 struct jffs2_full_dirent *fd;
 277
 278                 for (fd=f->dents; fd; fd = fd->next) {
 279                         if (fd->type == DT_DIR && fd->ino)
 280                                 inc_nlink(inode);
 281                 }
 282                 /* and '..' */
 283                 inc_nlink(inode);
 284                 /* Root dir gets i_nlink 3 for some reason */
 285                 if (inode->i_ino == 1)
 286                         inc_nlink(inode);
 287
 288                 inode->i_op = &jffs2_dir_inode_operations;
 289                 inode->i_fop = &jffs2_dir_operations;
 290                 break;
 291         }
 292         case S_IFREG:
 293                 inode->i_op = &jffs2_file_inode_operations;
 294                 inode->i_fop = &jffs2_file_operations;
 295                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 296                 inode->i_mapping->nrpages = 0;
 297                 break;
 298
 299         case S_IFBLK:
 300         case S_IFCHR:
 301                 /* Read the device numbers from the media */
 302                 if (f->metadata->size != sizeof(jdev.old) &&
 303                     f->metadata->size != sizeof(jdev.new)) {
 304                         printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
 305                         up(&f->sem);
 306                         jffs2_do_clear_inode(c, f);
 307                         make_bad_inode(inode);
 308                         return;
 309                 }
 310                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 311                 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
 312                         /* Eep */
 313                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 314                         up(&f->sem);
 315                         jffs2_do_clear_inode(c, f);
 316                         make_bad_inode(inode);
 317                         return;
 318                 }
 319                 if (f->metadata->size == sizeof(jdev.old))
 320                         rdev = old_decode_dev(je16_to_cpu(jdev.old));
 321                 else
 322                         rdev = new_decode_dev(je32_to_cpu(jdev.new));
 323
 324         case S_IFSOCK:
 325         case S_IFIFO:
 326                 inode->i_op = &jffs2_file_inode_operations;
 327                 init_special_inode(inode, inode->i_mode, rdev);
 328                 break;
 329
 330         default:
 331                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 332         }
 333
 334         up(&f->sem);
 335
 336         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 337 }
 338
 339 void jffs2_dirty_inode(struct inode *inode)
 340 {
 341         struct iattr iattr;
 342
 343         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 344                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 345                 return;
 346         }
 347
 348         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 349
 350         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 351         iattr.ia_mode = inode->i_mode;
 352         iattr.ia_uid = inode->i_uid;
 353         iattr.ia_gid = inode->i_gid;
 354         iattr.ia_atime = inode->i_atime;
 355         iattr.ia_mtime = inode->i_mtime;
 356         iattr.ia_ctime = inode->i_ctime;
 357
 358         jffs2_do_setattr(inode, &iattr);
 359 }
 360
 361 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 362 {
 363         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 364
 365         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 366                 return -EROFS;
 367
 368         /* We stop if it was running, then restart if it needs to.
 369            This also catches the case where it was stopped and this
 370            is just a remount to restart it.
 371            Flush the writebuffer, if neccecary, else we loose it */
 372         if (!(sb->s_flags & MS_RDONLY)) {
 373                 jffs2_stop_garbage_collect_thread(c);
 374                 down(&c->alloc_sem);
 375                 jffs2_flush_wbuf_pad(c);
 376                 up(&c->alloc_sem);
 377         }
 378
 379         if (!(*flags & MS_RDONLY))
 380                 jffs2_start_garbage_collect_thread(c);
 381
 382         *flags |= MS_NOATIME;
 383
 384         return 0;
 385 }
 386
 387 void jffs2_write_super (struct super_block *sb)
 388 {
 389         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 390         sb->s_dirt = 0;
 391
 392         if (sb->s_flags & MS_RDONLY)
 393                 return;
 394
 395         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 396         jffs2_garbage_collect_trigger(c);
 397         jffs2_erase_pending_blocks(c, 0);
 398         jffs2_flush_wbuf_gc(c, 0);
 399 }
 400
 401
 402 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 403    fill in the raw_inode while you're at it. */
 404 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 405 {
 406         struct inode *inode;
 407         struct super_block *sb = dir_i->i_sb;
 408         struct jffs2_sb_info *c;
 409         struct jffs2_inode_info *f;
 410         int ret;
 411
 412         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 413
 414         c = JFFS2_SB_INFO(sb);
 415
 416         inode = new_inode(sb);
 417
 418         if (!inode)
 419                 return ERR_PTR(-ENOMEM);
 420
 421         f = JFFS2_INODE_INFO(inode);
 422         jffs2_init_inode_info(f);
 423         down(&f->sem);
 424
 425         memset(ri, 0, sizeof(*ri));
 426         /* Set OS-specific defaults for new inodes */
 427         ri->uid = cpu_to_je16(current->fsuid);
 428
 429         if (dir_i->i_mode & S_ISGID) {
 430                 ri->gid = cpu_to_je16(dir_i->i_gid);
 431                 if (S_ISDIR(mode))
 432                         mode |= S_ISGID;
 433         } else {
 434                 ri->gid = cpu_to_je16(current->fsgid);
 435         }
 436         ri->mode =  cpu_to_jemode(mode);
 437         ret = jffs2_do_new_inode (c, f, mode, ri);
 438         if (ret) {
 439                 make_bad_inode(inode);
 440                 iput(inode);
 441                 return ERR_PTR(ret);
 442         }
 443         inode->i_nlink = 1;
 444         inode->i_ino = je32_to_cpu(ri->ino);
 445         inode->i_mode = jemode_to_cpu(ri->mode);
 446         inode->i_gid = je16_to_cpu(ri->gid);
 447         inode->i_uid = je16_to_cpu(ri->uid);
 448         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 449         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 450
 451         inode->i_blocks = 0;
 452         inode->i_size = 0;
 453
 454         insert_inode_hash(inode);
 455
 456         return inode;
 457 }
 458
 459
 460 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 461 {
 462         struct jffs2_sb_info *c;
 463         struct inode *root_i;
 464         int ret;
 465         size_t blocks;
 466
 467         c = JFFS2_SB_INFO(sb);
 468
 469 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 470         if (c->mtd->type == MTD_NANDFLASH) {
 471                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
 472                 return -EINVAL;
 473         }
 474         if (c->mtd->type == MTD_DATAFLASH) {
 475                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
 476                 return -EINVAL;
 477         }
 478 #endif
 479
 480         c->flash_size = c->mtd->size;
 481         c->sector_size = c->mtd->erasesize;
 482         blocks = c->flash_size / c->sector_size;
 483
 484         /*
 485          * Size alignment check
 486          */
 487         if ((c->sector_size * blocks) != c->flash_size) {
 488                 c->flash_size = c->sector_size * blocks;
 489                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
 490                         c->flash_size / 1024);
 491         }
 492
 493         if (c->flash_size < 5*c->sector_size) {
 494                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 495                 return -EINVAL;
 496         }
 497
 498         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 499
 500         /* NAND (or other bizarre) flash... do setup accordingly */
 501         ret = jffs2_flash_setup(c);
 502         if (ret)
 503                 return ret;
 504
 505         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 506         if (!c->inocache_list) {
 507                 ret = -ENOMEM;
 508                 goto out_wbuf;
 509         }
 510         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 511
 512         jffs2_init_xattr_subsystem(c);
 513
 514         if ((ret = jffs2_do_mount_fs(c)))
 515                 goto out_inohash;
 516
 517         ret = -EINVAL;
 518
 519         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 520         root_i = iget(sb, 1);
 521         if (is_bad_inode(root_i)) {
 522                 D1(printk(KERN_WARNING "get root inode failed\n"));
 523                 goto out_root_i;
 524         }
 525
 526         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 527         sb->s_root = d_alloc_root(root_i);
 528         if (!sb->s_root)
 529                 goto out_root_i;
 530
 531         sb->s_maxbytes = 0xFFFFFFFF;
 532         sb->s_blocksize = PAGE_CACHE_SIZE;
 533         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 534         sb->s_magic = JFFS2_SUPER_MAGIC;
 535         if (!(sb->s_flags & MS_RDONLY))
 536                 jffs2_start_garbage_collect_thread(c);
 537         return 0;
 538
 539  out_root_i:
 540         iput(root_i);
 541         jffs2_free_ino_caches(c);
 542         jffs2_free_raw_node_refs(c);
 543         if (jffs2_blocks_use_vmalloc(c))
 544                 vfree(c->blocks);
 545         else
 546                 kfree(c->blocks);
 547  out_inohash:
 548         jffs2_clear_xattr_subsystem(c);
 549         kfree(c->inocache_list);
 550  out_wbuf:
 551         jffs2_flash_cleanup(c);
 552
 553         return ret;
 554 }
 555
 556 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 557                                    struct jffs2_inode_info *f)
 558 {
 559         iput(OFNI_EDONI_2SFFJ(f));
 560 }
 561
 562 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 563                                                      int inum, int nlink)
 564 {
 565         struct inode *inode;
 566         struct jffs2_inode_cache *ic;
 567         if (!nlink) {
 568                 /* The inode has zero nlink but its nodes weren't yet marked
 569                    obsolete. This has to be because we're still waiting for
 570                    the final (close() and) iput() to happen.
 571
 572                    There's a possibility that the final iput() could have
 573                    happened while we were contemplating. In order to ensure
 574                    that we don't cause a new read_inode() (which would fail)
 575                    for the inode in question, we use ilookup() in this case
 576                    instead of iget().
 577
 578                    The nlink can't _become_ zero at this point because we're
 579                    holding the alloc_sem, and jffs2_do_unlink() would also
 580                    need that while decrementing nlink on any inode.
 581                 */
 582                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 583                 if (!inode) {
 584                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
 585                                   inum));
 586
 587                         spin_lock(&c->inocache_lock);
 588                         ic = jffs2_get_ino_cache(c, inum);
 589                         if (!ic) {
 590                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
 591                                 spin_unlock(&c->inocache_lock);
 592                                 return NULL;
 593                         }
 594                         if (ic->state != INO_STATE_CHECKEDABSENT) {
 595                                 /* Wait for progress. Don't just loop */
 596                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
 597                                           ic->ino, ic->state));
 598                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 599                         } else {
 600                                 spin_unlock(&c->inocache_lock);
 601                         }
 602
 603                         return NULL;
 604                 }
 605         } else {
 606                 /* Inode has links to it still; they're not going away because
 607                    jffs2_do_unlink() would need the alloc_sem and we have it.
 608                    Just iget() it, and if read_inode() is necessary that's OK.
 609                 */
 610                 inode = iget(OFNI_BS_2SFFJ(c), inum);
 611                 if (!inode)
 612                         return ERR_PTR(-ENOMEM);
 613         }
 614         if (is_bad_inode(inode)) {
 615                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
 616                        inum, nlink);
 617                 /* NB. This will happen again. We need to do something appropriate here. */
 618                 iput(inode);
 619                 return ERR_PTR(-EIO);
 620         }
 621
 622         return JFFS2_INODE_INFO(inode);
 623 }
 624
 625 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 626                                    struct jffs2_inode_info *f,
 627                                    unsigned long offset,
 628                                    unsigned long *priv)
 629 {
 630         struct inode *inode = OFNI_EDONI_2SFFJ(f);
 631         struct page *pg;
 632
 633         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 634                              (void *)jffs2_do_readpage_unlock, inode);
 635         if (IS_ERR(pg))
 636                 return (void *)pg;
 637
 638         *priv = (unsigned long)pg;
 639         return kmap(pg);
 640 }
 641
 642 void jffs2_gc_release_page(struct jffs2_sb_info *c,
 643                            unsigned char *ptr,
 644                            unsigned long *priv)
 645 {
 646         struct page *pg = (void *)*priv;
 647
 648         kunmap(pg);
 649         page_cache_release(pg);
 650 }
 651
 652 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 653         int ret = 0;
 654
 655         if (jffs2_cleanmarker_oob(c)) {
 656                 /* NAND flash... do setup accordingly */
 657                 ret = jffs2_nand_flash_setup(c);
 658                 if (ret)
 659                         return ret;
 660         }
 661
 662         /* and Dataflash */
 663         if (jffs2_dataflash(c)) {
 664                 ret = jffs2_dataflash_setup(c);
 665                 if (ret)
 666                         return ret;
 667         }
 668
 669         /* and Intel "Sibley" flash */
 670         if (jffs2_nor_wbuf_flash(c)) {
 671                 ret = jffs2_nor_wbuf_flash_setup(c);
 672                 if (ret)
 673                         return ret;
 674         }
 675
 676         return ret;
 677 }
 678
 679 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 680
 681         if (jffs2_cleanmarker_oob(c)) {
 682                 jffs2_nand_flash_cleanup(c);
 683         }
 684
 685         /* and DataFlash */
 686         if (jffs2_dataflash(c)) {
 687                 jffs2_dataflash_cleanup(c);
 688         }
 689
 690         /* and Intel "Sibley" flash */
 691         if (jffs2_nor_wbuf_flash(c)) {
 692                 jffs2_nor_wbuf_flash_cleanup(c);
 693         }
 694 }