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