ia64/linux-2.6.18-xen.hg

view fs/jffs2/fs.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

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