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