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