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