Merge branch 'master' of git://oak/home/sfr/kernels/iseries/work
[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_blocks = (inode->i_size + 511) >> 9;
267
268         switch (inode->i_mode & S_IFMT) {
269
270         case S_IFLNK:
271                 inode->i_op = &jffs2_symlink_inode_operations;
272                 break;
273
274         case S_IFDIR:
275         {
276                 struct jffs2_full_dirent *fd;
277
278                 for (fd=f->dents; fd; fd = fd->next) {
279                         if (fd->type == DT_DIR && fd->ino)
280                                 inc_nlink(inode);
281                 }
282                 /* and '..' */
283                 inc_nlink(inode);
284                 /* Root dir gets i_nlink 3 for some reason */
285                 if (inode->i_ino == 1)
286                         inc_nlink(inode);
287
288                 inode->i_op = &jffs2_dir_inode_operations;
289                 inode->i_fop = &jffs2_dir_operations;
290                 break;
291         }
292         case S_IFREG:
293                 inode->i_op = &jffs2_file_inode_operations;
294                 inode->i_fop = &jffs2_file_operations;
295                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
296                 inode->i_mapping->nrpages = 0;
297                 break;
298
299         case S_IFBLK:
300         case S_IFCHR:
301                 /* Read the device numbers from the media */
302                 if (f->metadata->size != sizeof(jdev.old) &&
303                     f->metadata->size != sizeof(jdev.new)) {
304                         printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
305                         up(&f->sem);
306                         jffs2_do_clear_inode(c, f);
307                         make_bad_inode(inode);
308                         return;
309                 }
310                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
311                 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
312                         /* Eep */
313                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
314                         up(&f->sem);
315                         jffs2_do_clear_inode(c, f);
316                         make_bad_inode(inode);
317                         return;
318                 }
319                 if (f->metadata->size == sizeof(jdev.old))
320                         rdev = old_decode_dev(je16_to_cpu(jdev.old));
321                 else
322                         rdev = new_decode_dev(je32_to_cpu(jdev.new));
323
324         case S_IFSOCK:
325         case S_IFIFO:
326                 inode->i_op = &jffs2_file_inode_operations;
327                 init_special_inode(inode, inode->i_mode, rdev);
328                 break;
329
330         default:
331                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
332         }
333
334         up(&f->sem);
335
336         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
337 }
338
339 void jffs2_dirty_inode(struct inode *inode)
340 {
341         struct iattr iattr;
342
343         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
344                 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
345                 return;
346         }
347
348         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
349
350         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
351         iattr.ia_mode = inode->i_mode;
352         iattr.ia_uid = inode->i_uid;
353         iattr.ia_gid = inode->i_gid;
354         iattr.ia_atime = inode->i_atime;
355         iattr.ia_mtime = inode->i_mtime;
356         iattr.ia_ctime = inode->i_ctime;
357
358         jffs2_do_setattr(inode, &iattr);
359 }
360
361 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
362 {
363         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
364
365         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
366                 return -EROFS;
367
368         /* We stop if it was running, then restart if it needs to.
369            This also catches the case where it was stopped and this
370            is just a remount to restart it.
371            Flush the writebuffer, if neccecary, else we loose it */
372         if (!(sb->s_flags & MS_RDONLY)) {
373                 jffs2_stop_garbage_collect_thread(c);
374                 down(&c->alloc_sem);
375                 jffs2_flush_wbuf_pad(c);
376                 up(&c->alloc_sem);
377         }
378
379         if (!(*flags & MS_RDONLY))
380                 jffs2_start_garbage_collect_thread(c);
381
382         *flags |= MS_NOATIME;
383
384         return 0;
385 }
386
387 void jffs2_write_super (struct super_block *sb)
388 {
389         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
390         sb->s_dirt = 0;
391
392         if (sb->s_flags & MS_RDONLY)
393                 return;
394
395         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
396         jffs2_garbage_collect_trigger(c);
397         jffs2_erase_pending_blocks(c, 0);
398         jffs2_flush_wbuf_gc(c, 0);
399 }
400
401
402 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
403    fill in the raw_inode while you're at it. */
404 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
405 {
406         struct inode *inode;
407         struct super_block *sb = dir_i->i_sb;
408         struct jffs2_sb_info *c;
409         struct jffs2_inode_info *f;
410         int ret;
411
412         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
413
414         c = JFFS2_SB_INFO(sb);
415
416         inode = new_inode(sb);
417
418         if (!inode)
419                 return ERR_PTR(-ENOMEM);
420
421         f = JFFS2_INODE_INFO(inode);
422         jffs2_init_inode_info(f);
423         down(&f->sem);
424
425         memset(ri, 0, sizeof(*ri));
426         /* Set OS-specific defaults for new inodes */
427         ri->uid = cpu_to_je16(current->fsuid);
428
429         if (dir_i->i_mode & S_ISGID) {
430                 ri->gid = cpu_to_je16(dir_i->i_gid);
431                 if (S_ISDIR(mode))
432                         mode |= S_ISGID;
433         } else {
434                 ri->gid = cpu_to_je16(current->fsgid);
435         }
436         ri->mode =  cpu_to_jemode(mode);
437         ret = jffs2_do_new_inode (c, f, mode, ri);
438         if (ret) {
439                 make_bad_inode(inode);
440                 iput(inode);
441                 return ERR_PTR(ret);
442         }
443         inode->i_nlink = 1;
444         inode->i_ino = je32_to_cpu(ri->ino);
445         inode->i_mode = jemode_to_cpu(ri->mode);
446         inode->i_gid = je16_to_cpu(ri->gid);
447         inode->i_uid = je16_to_cpu(ri->uid);
448         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
449         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
450
451         inode->i_blocks = 0;
452         inode->i_size = 0;
453
454         insert_inode_hash(inode);
455
456         return inode;
457 }
458
459
460 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
461 {
462         struct jffs2_sb_info *c;
463         struct inode *root_i;
464         int ret;
465         size_t blocks;
466
467         c = JFFS2_SB_INFO(sb);
468
469 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
470         if (c->mtd->type == MTD_NANDFLASH) {
471                 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
472                 return -EINVAL;
473         }
474         if (c->mtd->type == MTD_DATAFLASH) {
475                 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
476                 return -EINVAL;
477         }
478 #endif
479
480         c->flash_size = c->mtd->size;
481         c->sector_size = c->mtd->erasesize;
482         blocks = c->flash_size / c->sector_size;
483
484         /*
485          * Size alignment check
486          */
487         if ((c->sector_size * blocks) != c->flash_size) {
488                 c->flash_size = c->sector_size * blocks;
489                 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
490                         c->flash_size / 1024);
491         }
492
493         if (c->flash_size < 5*c->sector_size) {
494                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
495                 return -EINVAL;
496         }
497
498         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
499
500         /* NAND (or other bizarre) flash... do setup accordingly */
501         ret = jffs2_flash_setup(c);
502         if (ret)
503                 return ret;
504
505         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
506         if (!c->inocache_list) {
507                 ret = -ENOMEM;
508                 goto out_wbuf;
509         }
510         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
511
512         jffs2_init_xattr_subsystem(c);
513
514         if ((ret = jffs2_do_mount_fs(c)))
515                 goto out_inohash;
516
517         ret = -EINVAL;
518
519         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
520         root_i = iget(sb, 1);
521         if (is_bad_inode(root_i)) {
522                 D1(printk(KERN_WARNING "get root inode failed\n"));
523                 goto out_root_i;
524         }
525
526         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
527         sb->s_root = d_alloc_root(root_i);
528         if (!sb->s_root)
529                 goto out_root_i;
530
531         sb->s_maxbytes = 0xFFFFFFFF;
532         sb->s_blocksize = PAGE_CACHE_SIZE;
533         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
534         sb->s_magic = JFFS2_SUPER_MAGIC;
535         if (!(sb->s_flags & MS_RDONLY))
536                 jffs2_start_garbage_collect_thread(c);
537         return 0;
538
539  out_root_i:
540         iput(root_i);
541         jffs2_free_ino_caches(c);
542         jffs2_free_raw_node_refs(c);
543         if (jffs2_blocks_use_vmalloc(c))
544                 vfree(c->blocks);
545         else
546                 kfree(c->blocks);
547  out_inohash:
548         jffs2_clear_xattr_subsystem(c);
549         kfree(c->inocache_list);
550  out_wbuf:
551         jffs2_flash_cleanup(c);
552
553         return ret;
554 }
555
556 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
557                                    struct jffs2_inode_info *f)
558 {
559         iput(OFNI_EDONI_2SFFJ(f));
560 }
561
562 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
563                                                      int inum, int nlink)
564 {
565         struct inode *inode;
566         struct jffs2_inode_cache *ic;
567         if (!nlink) {
568                 /* The inode has zero nlink but its nodes weren't yet marked
569                    obsolete. This has to be because we're still waiting for
570                    the final (close() and) iput() to happen.
571
572                    There's a possibility that the final iput() could have
573                    happened while we were contemplating. In order to ensure
574                    that we don't cause a new read_inode() (which would fail)
575                    for the inode in question, we use ilookup() in this case
576                    instead of iget().
577
578                    The nlink can't _become_ zero at this point because we're
579                    holding the alloc_sem, and jffs2_do_unlink() would also
580                    need that while decrementing nlink on any inode.
581                 */
582                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
583                 if (!inode) {
584                         D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
585                                   inum));
586
587                         spin_lock(&c->inocache_lock);
588                         ic = jffs2_get_ino_cache(c, inum);
589                         if (!ic) {
590                                 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
591                                 spin_unlock(&c->inocache_lock);
592                                 return NULL;
593                         }
594                         if (ic->state != INO_STATE_CHECKEDABSENT) {
595                                 /* Wait for progress. Don't just loop */
596                                 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
597                                           ic->ino, ic->state));
598                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
599                         } else {
600                                 spin_unlock(&c->inocache_lock);
601                         }
602
603                         return NULL;
604                 }
605         } else {
606                 /* Inode has links to it still; they're not going away because
607                    jffs2_do_unlink() would need the alloc_sem and we have it.
608                    Just iget() it, and if read_inode() is necessary that's OK.
609                 */
610                 inode = iget(OFNI_BS_2SFFJ(c), inum);
611                 if (!inode)
612                         return ERR_PTR(-ENOMEM);
613         }
614         if (is_bad_inode(inode)) {
615                 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
616                        inum, nlink);
617                 /* NB. This will happen again. We need to do something appropriate here. */
618                 iput(inode);
619                 return ERR_PTR(-EIO);
620         }
621
622         return JFFS2_INODE_INFO(inode);
623 }
624
625 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
626                                    struct jffs2_inode_info *f,
627                                    unsigned long offset,
628                                    unsigned long *priv)
629 {
630         struct inode *inode = OFNI_EDONI_2SFFJ(f);
631         struct page *pg;
632
633         pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
634                              (void *)jffs2_do_readpage_unlock, inode);
635         if (IS_ERR(pg))
636                 return (void *)pg;
637
638         *priv = (unsigned long)pg;
639         return kmap(pg);
640 }
641
642 void jffs2_gc_release_page(struct jffs2_sb_info *c,
643                            unsigned char *ptr,
644                            unsigned long *priv)
645 {
646         struct page *pg = (void *)*priv;
647
648         kunmap(pg);
649         page_cache_release(pg);
650 }
651
652 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
653         int ret = 0;
654
655         if (jffs2_cleanmarker_oob(c)) {
656                 /* NAND flash... do setup accordingly */
657                 ret = jffs2_nand_flash_setup(c);
658                 if (ret)
659                         return ret;
660         }
661
662         /* and Dataflash */
663         if (jffs2_dataflash(c)) {
664                 ret = jffs2_dataflash_setup(c);
665                 if (ret)
666                         return ret;
667         }
668
669         /* and Intel "Sibley" flash */
670         if (jffs2_nor_wbuf_flash(c)) {
671                 ret = jffs2_nor_wbuf_flash_setup(c);
672                 if (ret)
673                         return ret;
674         }
675
676         return ret;
677 }
678
679 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
680
681         if (jffs2_cleanmarker_oob(c)) {
682                 jffs2_nand_flash_cleanup(c);
683         }
684
685         /* and DataFlash */
686         if (jffs2_dataflash(c)) {
687                 jffs2_dataflash_cleanup(c);
688         }
689
690         /* and Intel "Sibley" flash */
691         if (jffs2_nor_wbuf_flash(c)) {
692                 jffs2_nor_wbuf_flash_cleanup(c);
693         }
694 }