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