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