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