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