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