1
2
3
4
5
6
7
8
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
25static int jffs2_flash_setup(struct jffs2_sb_info *c);
26
27int 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
44
45
46
47
48 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
49
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
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
121
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
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
172
173
174
175
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
184int 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
199int 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
227void jffs2_clear_inode (struct inode *inode)
228{
229
230
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
239struct 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;
292
293 for (fd=f->dents; fd; fd = fd->next) {
294 if (fd->type == DT_DIR && fd->ino)
295 inc_nlink(inode);
296 }
297
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
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
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
348error_io:
349 ret = -EIO;
350error:
351 mutex_unlock(&f->sem);
352 jffs2_do_clear_inode(c, f);
353 iget_failed(inode);
354 return ERR_PTR(ret);
355}
356
357void 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
379int 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
387
388
389
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
405void 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
421
422struct 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
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
456
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
486int 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
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
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);
567out_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
583void jffs2_gc_release_inode(struct jffs2_sb_info *c,
584 struct jffs2_inode_info *f)
585{
586 iput(OFNI_EDONI_2SFFJ(f));
587}
588
589struct 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
597
598
599
600
601
602
603
604
605
606
607
608
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
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
635
636
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
646 iput(inode);
647 return ERR_PTR(-EIO);
648 }
649
650 return JFFS2_INODE_INFO(inode);
651}
652
653unsigned 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
670void 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
680static int jffs2_flash_setup(struct jffs2_sb_info *c) {
681 int ret = 0;
682
683 if (jffs2_cleanmarker_oob(c)) {
684
685 ret = jffs2_nand_flash_setup(c);
686 if (ret)
687 return ret;
688 }
689
690
691 if (jffs2_dataflash(c)) {
692 ret = jffs2_dataflash_setup(c);
693 if (ret)
694 return ret;
695 }
696
697
698 if (jffs2_nor_wbuf_flash(c)) {
699 ret = jffs2_nor_wbuf_flash_setup(c);
700 if (ret)
701 return ret;
702 }
703
704
705 if (jffs2_ubivol(c)) {
706 ret = jffs2_ubivol_setup(c);
707 if (ret)
708 return ret;
709 }
710
711 return ret;
712}
713
714void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
715
716 if (jffs2_cleanmarker_oob(c)) {
717 jffs2_nand_flash_cleanup(c);
718 }
719
720
721 if (jffs2_dataflash(c)) {
722 jffs2_dataflash_cleanup(c);
723 }
724
725
726 if (jffs2_nor_wbuf_flash(c)) {
727 jffs2_nor_wbuf_flash_cleanup(c);
728 }
729
730
731 if (jffs2_ubivol(c)) {
732 jffs2_ubivol_cleanup(c);
733 }
734}