blob: a6661e8be25a06cf92d7e673faf4fc0d7922b0a7 [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 *
Artem B. Bityutskiy6dac02a2005-07-18 12:21:23 +010010 * $Id: fs.c,v 1.59 2005/07/18 11:21:19 dedekind 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
Artem B. Bityutskiy61a39b62005-07-17 13:01:46 +0100206 jffs2_dbg_dump_block_lists(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
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"));
Artem B. Bityutskiy6dac02a2005-07-18 12:21:23 +0100520 goto out_root_i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 jffs2_free_ino_caches(c);
539 jffs2_free_raw_node_refs(c);
540 if (c->mtd->flags & MTD_NO_VIRTBLOCKS)
541 vfree(c->blocks);
542 else
543 kfree(c->blocks);
544 out_inohash:
545 kfree(c->inocache_list);
546 out_wbuf:
547 jffs2_flash_cleanup(c);
548
549 return ret;
550}
551
552void jffs2_gc_release_inode(struct jffs2_sb_info *c,
553 struct jffs2_inode_info *f)
554{
555 iput(OFNI_EDONI_2SFFJ(f));
556}
557
558struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
559 int inum, int nlink)
560{
561 struct inode *inode;
562 struct jffs2_inode_cache *ic;
563 if (!nlink) {
564 /* The inode has zero nlink but its nodes weren't yet marked
565 obsolete. This has to be because we're still waiting for
566 the final (close() and) iput() to happen.
567
568 There's a possibility that the final iput() could have
569 happened while we were contemplating. In order to ensure
570 that we don't cause a new read_inode() (which would fail)
571 for the inode in question, we use ilookup() in this case
572 instead of iget().
573
574 The nlink can't _become_ zero at this point because we're
575 holding the alloc_sem, and jffs2_do_unlink() would also
576 need that while decrementing nlink on any inode.
577 */
578 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
579 if (!inode) {
580 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
581 inum));
582
583 spin_lock(&c->inocache_lock);
584 ic = jffs2_get_ino_cache(c, inum);
585 if (!ic) {
586 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
587 spin_unlock(&c->inocache_lock);
588 return NULL;
589 }
590 if (ic->state != INO_STATE_CHECKEDABSENT) {
591 /* Wait for progress. Don't just loop */
592 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
593 ic->ino, ic->state));
594 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
595 } else {
596 spin_unlock(&c->inocache_lock);
597 }
598
599 return NULL;
600 }
601 } else {
602 /* Inode has links to it still; they're not going away because
603 jffs2_do_unlink() would need the alloc_sem and we have it.
604 Just iget() it, and if read_inode() is necessary that's OK.
605 */
606 inode = iget(OFNI_BS_2SFFJ(c), inum);
607 if (!inode)
608 return ERR_PTR(-ENOMEM);
609 }
610 if (is_bad_inode(inode)) {
611 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
612 inum, nlink);
613 /* NB. This will happen again. We need to do something appropriate here. */
614 iput(inode);
615 return ERR_PTR(-EIO);
616 }
617
618 return JFFS2_INODE_INFO(inode);
619}
620
621unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
622 struct jffs2_inode_info *f,
623 unsigned long offset,
624 unsigned long *priv)
625{
626 struct inode *inode = OFNI_EDONI_2SFFJ(f);
627 struct page *pg;
628
629 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
630 (void *)jffs2_do_readpage_unlock, inode);
631 if (IS_ERR(pg))
632 return (void *)pg;
633
634 *priv = (unsigned long)pg;
635 return kmap(pg);
636}
637
638void jffs2_gc_release_page(struct jffs2_sb_info *c,
639 unsigned char *ptr,
640 unsigned long *priv)
641{
642 struct page *pg = (void *)*priv;
643
644 kunmap(pg);
645 page_cache_release(pg);
646}
647
648static int jffs2_flash_setup(struct jffs2_sb_info *c) {
649 int ret = 0;
650
651 if (jffs2_cleanmarker_oob(c)) {
652 /* NAND flash... do setup accordingly */
653 ret = jffs2_nand_flash_setup(c);
654 if (ret)
655 return ret;
656 }
657
658 /* add setups for other bizarre flashes here... */
659 if (jffs2_nor_ecc(c)) {
660 ret = jffs2_nor_ecc_flash_setup(c);
661 if (ret)
662 return ret;
663 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000664
665 /* and Dataflash */
666 if (jffs2_dataflash(c)) {
667 ret = jffs2_dataflash_setup(c);
668 if (ret)
669 return ret;
670 }
671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 return ret;
673}
674
675void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
676
677 if (jffs2_cleanmarker_oob(c)) {
678 jffs2_nand_flash_cleanup(c);
679 }
680
681 /* add cleanups for other bizarre flashes here... */
682 if (jffs2_nor_ecc(c)) {
683 jffs2_nor_ecc_flash_cleanup(c);
684 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000685
686 /* and DataFlash */
687 if (jffs2_dataflash(c)) {
688 jffs2_dataflash_cleanup(c);
689 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690}