]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - fs/jffs2/fs.c
Merge Linux 2.6.23
[linux-2.6.git] / 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                 if (iattr->ia_mode & S_ISGID &&
101                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
102                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
103                 else
104                         ri->mode = cpu_to_jemode(iattr->ia_mode);
105         else
106                 ri->mode = cpu_to_jemode(inode->i_mode);
107
108
109         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
110         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
111         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
112         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
113
114         ri->offset = cpu_to_je32(0);
115         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
116         ri->compr = JFFS2_COMPR_NONE;
117         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
118                 /* It's an extension. Make it a hole node */
119                 ri->compr = JFFS2_COMPR_ZERO;
120                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
121                 ri->offset = cpu_to_je32(inode->i_size);
122         }
123         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
124         if (mdatalen)
125                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
126         else
127                 ri->data_crc = cpu_to_je32(0);
128
129         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
130         if (S_ISLNK(inode->i_mode))
131                 kfree(mdata);
132
133         if (IS_ERR(new_metadata)) {
134                 jffs2_complete_reservation(c);
135                 jffs2_free_raw_inode(ri);
136                 up(&f->sem);
137                 return PTR_ERR(new_metadata);
138         }
139         /* It worked. Update the inode */
140         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
141         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
142         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
143         inode->i_mode = jemode_to_cpu(ri->mode);
144         inode->i_uid = je16_to_cpu(ri->uid);
145         inode->i_gid = je16_to_cpu(ri->gid);
146
147
148         old_metadata = f->metadata;
149
150         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
151                 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
152
153         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
154                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
155                 inode->i_size = iattr->ia_size;
156                 f->metadata = NULL;
157         } else {
158                 f->metadata = new_metadata;
159         }
160         if (old_metadata) {
161                 jffs2_mark_node_obsolete(c, old_metadata->raw);
162                 jffs2_free_full_dnode(old_metadata);
163         }
164         jffs2_free_raw_inode(ri);
165
166         up(&f->sem);
167         jffs2_complete_reservation(c);
168
169         /* We have to do the vmtruncate() without f->sem held, since
170            some pages may be locked and waiting for it in readpage().
171            We are protected from a simultaneous write() extending i_size
172            back past iattr->ia_size, because do_truncate() holds the
173            generic inode semaphore. */
174         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
175                 vmtruncate(inode, iattr->ia_size);
176
177         return 0;
178 }
179
180 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
181 {
182         int rc;
183
184         rc = inode_change_ok(dentry->d_inode, iattr);
185         if (rc)
186                 return 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
192         return rc;
193 }
194
195 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
196 {
197         struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_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         jffs2_do_clear_inode(c, f);
231 }
232
233 void jffs2_read_inode (struct inode *inode)
234 {
235         struct jffs2_inode_info *f;
236         struct jffs2_sb_info *c;
237         struct jffs2_raw_inode latest_node;
238         union jffs2_device_node jdev;
239         dev_t rdev = 0;
240         int ret;
241
242         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
243
244         f = JFFS2_INODE_INFO(inode);
245         c = JFFS2_SB_INFO(inode->i_sb);
246
247         jffs2_init_inode_info(f);
248         down(&f->sem);
249
250         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
251
252         if (ret) {
253                 make_bad_inode(inode);
254                 up(&f->sem);
255                 return;
256         }
257         inode->i_mode = jemode_to_cpu(latest_node.mode);
258         inode->i_uid = je16_to_cpu(latest_node.uid);
259         inode->i_gid = je16_to_cpu(latest_node.gid);
260         inode->i_size = je32_to_cpu(latest_node.isize);
261         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
262         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
263         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
264
265         inode->i_nlink = f->inocache->nlink;
266
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                                 inc_nlink(inode);
282                 }
283                 /* and '..' */
284                 inc_nlink(inode);
285                 /* Root dir gets i_nlink 3 for some reason */
286                 if (inode->i_ino == 1)
287                         inc_nlink(inode);
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                                struct posix_acl **acl)
407 {
408         struct inode *inode;
409         struct super_block *sb = dir_i->i_sb;
410         struct jffs2_sb_info *c;
411         struct jffs2_inode_info *f;
412         int ret;
413
414         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
415
416         c = JFFS2_SB_INFO(sb);
417
418         inode = new_inode(sb);
419
420         if (!inode)
421                 return ERR_PTR(-ENOMEM);
422
423         f = JFFS2_INODE_INFO(inode);
424         jffs2_init_inode_info(f);
425         down(&f->sem);
426
427         memset(ri, 0, sizeof(*ri));
428         /* Set OS-specific defaults for new inodes */
429         ri->uid = cpu_to_je16(current->fsuid);
430
431         if (dir_i->i_mode & S_ISGID) {
432                 ri->gid = cpu_to_je16(dir_i->i_gid);
433                 if (S_ISDIR(mode))
434                         mode |= S_ISGID;
435         } else {
436                 ri->gid = cpu_to_je16(current->fsgid);
437         }
438
439         /* POSIX ACLs have to be processed now, at least partly.
440            The umask is only applied if there's no default ACL */
441         if (!S_ISLNK(mode)) {
442                 *acl = jffs2_get_acl(dir_i, ACL_TYPE_DEFAULT);
443                 if (IS_ERR(*acl)) {
444                         make_bad_inode(inode);
445                         iput(inode);
446                         inode = (void *)*acl;
447                         *acl = NULL;
448                         return inode;
449                 }
450                 if (!(*acl))
451                         mode &= ~current->fs->umask;
452         } else {
453                 *acl = NULL;
454         }
455         ret = jffs2_do_new_inode (c, f, mode, ri);
456         if (ret) {
457                 make_bad_inode(inode);
458                 iput(inode);
459                 return ERR_PTR(ret);
460         }
461         inode->i_nlink = 1;
462         inode->i_ino = je32_to_cpu(ri->ino);
463         inode->i_mode = jemode_to_cpu(ri->mode);
464         inode->i_gid = je16_to_cpu(ri->gid);
465         inode->i_uid = je16_to_cpu(ri->uid);
466         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
467         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
468
469         inode->i_blocks = 0;
470         inode->i_size = 0;
471
472         insert_inode_hash(inode);
473
474         return inode;
475 }
476
477
478 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
479 {
480         struct jffs2_sb_info *c;
481         struct inode *root_i;
482         int ret;
483         size_t blocks;
484
485         c = JFFS2_SB_INFO(sb);
486
487 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
488         if (c->mtd->type == MTD_NANDFLASH) {
489                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
490                 return -EINVAL;
491         }
492         if (c->mtd->type == MTD_DATAFLASH) {
493                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
494                 return -EINVAL;
495         }
496 #endif
497
498         c->flash_size = c->mtd->size;
499         c->sector_size = c->mtd->erasesize;
500         blocks = c->flash_size / c->sector_size;
501
502         /*
503          * Size alignment check
504          */
505         if ((c->sector_size * blocks) != c->flash_size) {
506                 c->flash_size = c->sector_size * blocks;
507                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
508                         c->flash_size / 1024);
509         }
510
511         if (c->flash_size < 5*c->sector_size) {
512                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
513                 return -EINVAL;
514         }
515
516         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
517
518         /* NAND (or other bizarre) flash... do setup accordingly */
519         ret = jffs2_flash_setup(c);
520         if (ret)
521                 return ret;
522
523         c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
524         if (!c->inocache_list) {
525                 ret = -ENOMEM;
526                 goto out_wbuf;
527         }
528
529         jffs2_init_xattr_subsystem(c);
530
531         if ((ret = jffs2_do_mount_fs(c)))
532                 goto out_inohash;
533
534         ret = -EINVAL;
535
536         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
537         root_i = iget(sb, 1);
538         if (is_bad_inode(root_i)) {
539                 D1(printk(KERN_WARNING "get root inode failed\n"));
540                 goto out_root_i;
541         }
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         jffs2_free_ino_caches(c);
559         jffs2_free_raw_node_refs(c);
560         if (jffs2_blocks_use_vmalloc(c))
561                 vfree(c->blocks);
562         else
563                 kfree(c->blocks);
564  out_inohash:
565         jffs2_clear_xattr_subsystem(c);
566         kfree(c->inocache_list);
567  out_wbuf:
568         jffs2_flash_cleanup(c);
569
570         return ret;
571 }
572
573 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
574                                    struct jffs2_inode_info *f)
575 {
576         iput(OFNI_EDONI_2SFFJ(f));
577 }
578
579 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
580                                                      int inum, int nlink)
581 {
582         struct inode *inode;
583         struct jffs2_inode_cache *ic;
584         if (!nlink) {
585                 /* The inode has zero nlink but its nodes weren't yet marked
586                    obsolete. This has to be because we're still waiting for
587                    the final (close() and) iput() to happen.
588
589                    There's a possibility that the final iput() could have
590                    happened while we were contemplating. In order to ensure
591                    that we don't cause a new read_inode() (which would fail)
592                    for the inode in question, we use ilookup() in this case
593                    instead of iget().
594
595                    The nlink can't _become_ zero at this point because we're
596                    holding the alloc_sem, and jffs2_do_unlink() would also
597                    need that while decrementing nlink on any inode.
598                 */
599                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
600                 if (!inode) {
601                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
602                                   inum));
603
604                         spin_lock(&c->inocache_lock);
605                         ic = jffs2_get_ino_cache(c, inum);
606                         if (!ic) {
607                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
608                                 spin_unlock(&c->inocache_lock);
609                                 return NULL;
610                         }
611                         if (ic->state != INO_STATE_CHECKEDABSENT) {
612                                 /* Wait for progress. Don't just loop */
613                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
614                                           ic->ino, ic->state));
615                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
616                         } else {
617                                 spin_unlock(&c->inocache_lock);
618                         }
619
620                         return NULL;
621                 }
622         } else {
623                 /* Inode has links to it still; they're not going away because
624                    jffs2_do_unlink() would need the alloc_sem and we have it.
625                    Just iget() it, and if read_inode() is necessary that's OK.
626                 */
627                 inode = iget(OFNI_BS_2SFFJ(c), inum);
628                 if (!inode)
629                         return ERR_PTR(-ENOMEM);
630         }
631         if (is_bad_inode(inode)) {
632                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
633                        inum, nlink);
634                 /* NB. This will happen again. We need to do something appropriate here. */
635                 iput(inode);
636                 return ERR_PTR(-EIO);
637         }
638
639         return JFFS2_INODE_INFO(inode);
640 }
641
642 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
643                                    struct jffs2_inode_info *f,
644                                    unsigned long offset,
645                                    unsigned long *priv)
646 {
647         struct inode *inode = OFNI_EDONI_2SFFJ(f);
648         struct page *pg;
649
650         pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
651                              (void *)jffs2_do_readpage_unlock, inode);
652         if (IS_ERR(pg))
653                 return (void *)pg;
654
655         *priv = (unsigned long)pg;
656         return kmap(pg);
657 }
658
659 void jffs2_gc_release_page(struct jffs2_sb_info *c,
660                            unsigned char *ptr,
661                            unsigned long *priv)
662 {
663         struct page *pg = (void *)*priv;
664
665         kunmap(pg);
666         page_cache_release(pg);
667 }
668
669 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
670         int ret = 0;
671
672         if (jffs2_cleanmarker_oob(c)) {
673                 /* NAND flash... do setup accordingly */
674                 ret = jffs2_nand_flash_setup(c);
675                 if (ret)
676                         return ret;
677         }
678
679         /* and Dataflash */
680         if (jffs2_dataflash(c)) {
681                 ret = jffs2_dataflash_setup(c);
682                 if (ret)
683                         return ret;
684         }
685
686         /* and Intel "Sibley" flash */
687         if (jffs2_nor_wbuf_flash(c)) {
688                 ret = jffs2_nor_wbuf_flash_setup(c);
689                 if (ret)
690                         return ret;
691         }
692
693         /* and an UBI volume */
694         if (jffs2_ubivol(c)) {
695                 ret = jffs2_ubivol_setup(c);
696                 if (ret)
697                         return ret;
698         }
699
700         return ret;
701 }
702
703 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
704
705         if (jffs2_cleanmarker_oob(c)) {
706                 jffs2_nand_flash_cleanup(c);
707         }
708
709         /* and DataFlash */
710         if (jffs2_dataflash(c)) {
711                 jffs2_dataflash_cleanup(c);
712         }
713
714         /* and Intel "Sibley" flash */
715         if (jffs2_nor_wbuf_flash(c)) {
716                 jffs2_nor_wbuf_flash_cleanup(c);
717         }
718
719         /* and an UBI volume */
720         if (jffs2_ubivol(c)) {
721                 jffs2_ubivol_cleanup(c);
722         }
723 }