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