2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: fs.c,v 1.66 2005/09/27 13:17:29 dedekind Exp $
14 #include <linux/capability.h>
15 #include <linux/config.h>
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
19 #include <linux/list.h>
20 #include <linux/mtd/mtd.h>
21 #include <linux/pagemap.h>
22 #include <linux/slab.h>
23 #include <linux/vmalloc.h>
24 #include <linux/vfs.h>
25 #include <linux/crc32.h>
28 static int jffs2_flash_setup(struct jffs2_sb_info *c);
30 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
32 struct jffs2_full_dnode *old_metadata, *new_metadata;
33 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
34 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
35 struct jffs2_raw_inode *ri;
37 unsigned char *mdata = NULL;
40 uint32_t phys_ofs, alloclen;
42 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
43 ret = inode_change_ok(inode, iattr);
47 /* Special cases - we don't want more than one data node
48 for these types on the medium at any time. So setattr
49 must read the original data associated with the node
50 (i.e. the device numbers or the target name) and write
51 it out again with the appropriate data attached */
52 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
53 /* For these, we don't actually need to read the old node */
54 dev = old_encode_dev(inode->i_rdev);
56 mdatalen = sizeof(dev);
57 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
58 } else if (S_ISLNK(inode->i_mode)) {
60 mdatalen = f->metadata->size;
61 mdata = kmalloc(f->metadata->size, GFP_USER);
66 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
73 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
76 ri = jffs2_alloc_raw_inode();
78 if (S_ISLNK(inode->i_mode))
83 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen,
84 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
86 jffs2_free_raw_inode(ri);
87 if (S_ISLNK(inode->i_mode & S_IFMT))
92 ivalid = iattr->ia_valid;
94 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
95 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
96 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
97 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
99 ri->ino = cpu_to_je32(inode->i_ino);
100 ri->version = cpu_to_je32(++f->highest_version);
102 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
103 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
105 if (ivalid & ATTR_MODE)
106 if (iattr->ia_mode & S_ISGID &&
107 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
108 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
110 ri->mode = cpu_to_jemode(iattr->ia_mode);
112 ri->mode = cpu_to_jemode(inode->i_mode);
115 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
116 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
117 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
118 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
120 ri->offset = cpu_to_je32(0);
121 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
122 ri->compr = JFFS2_COMPR_NONE;
123 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
124 /* It's an extension. Make it a hole node */
125 ri->compr = JFFS2_COMPR_ZERO;
126 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
127 ri->offset = cpu_to_je32(inode->i_size);
129 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
131 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
133 ri->data_crc = cpu_to_je32(0);
135 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
136 if (S_ISLNK(inode->i_mode))
139 if (IS_ERR(new_metadata)) {
140 jffs2_complete_reservation(c);
141 jffs2_free_raw_inode(ri);
143 return PTR_ERR(new_metadata);
145 /* It worked. Update the inode */
146 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
147 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
148 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
149 inode->i_mode = jemode_to_cpu(ri->mode);
150 inode->i_uid = je16_to_cpu(ri->uid);
151 inode->i_gid = je16_to_cpu(ri->gid);
154 old_metadata = f->metadata;
156 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
157 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
159 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
160 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
161 inode->i_size = iattr->ia_size;
164 f->metadata = new_metadata;
167 jffs2_mark_node_obsolete(c, old_metadata->raw);
168 jffs2_free_full_dnode(old_metadata);
170 jffs2_free_raw_inode(ri);
173 jffs2_complete_reservation(c);
175 /* We have to do the vmtruncate() without f->sem held, since
176 some pages may be locked and waiting for it in readpage().
177 We are protected from a simultaneous write() extending i_size
178 back past iattr->ia_size, because do_truncate() holds the
179 generic inode semaphore. */
180 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
181 vmtruncate(inode, iattr->ia_size);
186 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
190 rc = jffs2_do_setattr(dentry->d_inode, iattr);
191 if (!rc && (iattr->ia_valid & ATTR_MODE))
192 rc = jffs2_acl_chmod(dentry->d_inode);
196 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
198 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
201 buf->f_type = JFFS2_SUPER_MAGIC;
202 buf->f_bsize = 1 << PAGE_SHIFT;
203 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
206 buf->f_namelen = JFFS2_MAX_NAME_LEN;
208 spin_lock(&c->erase_completion_lock);
209 avail = c->dirty_size + c->free_size;
210 if (avail > c->sector_size * c->resv_blocks_write)
211 avail -= c->sector_size * c->resv_blocks_write;
214 spin_unlock(&c->erase_completion_lock);
216 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
222 void jffs2_clear_inode (struct inode *inode)
224 /* We can forget about this inode for now - drop all
225 * the nodelists associated with it, etc.
227 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
228 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
230 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
232 jffs2_xattr_delete_inode(c, f->inocache);
233 jffs2_do_clear_inode(c, f);
236 void jffs2_read_inode (struct inode *inode)
238 struct jffs2_inode_info *f;
239 struct jffs2_sb_info *c;
240 struct jffs2_raw_inode latest_node;
243 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
245 f = JFFS2_INODE_INFO(inode);
246 c = JFFS2_SB_INFO(inode->i_sb);
248 jffs2_init_inode_info(f);
251 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
254 make_bad_inode(inode);
258 inode->i_mode = jemode_to_cpu(latest_node.mode);
259 inode->i_uid = je16_to_cpu(latest_node.uid);
260 inode->i_gid = je16_to_cpu(latest_node.gid);
261 inode->i_size = je32_to_cpu(latest_node.isize);
262 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
263 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
264 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
266 inode->i_nlink = f->inocache->nlink;
268 inode->i_blksize = PAGE_SIZE;
269 inode->i_blocks = (inode->i_size + 511) >> 9;
271 switch (inode->i_mode & S_IFMT) {
275 inode->i_op = &jffs2_symlink_inode_operations;
280 struct jffs2_full_dirent *fd;
282 for (fd=f->dents; fd; fd = fd->next) {
283 if (fd->type == DT_DIR && fd->ino)
288 /* Root dir gets i_nlink 3 for some reason */
289 if (inode->i_ino == 1)
292 inode->i_op = &jffs2_dir_inode_operations;
293 inode->i_fop = &jffs2_dir_operations;
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 inode->i_mapping->nrpages = 0;
305 /* Read the device numbers from the media */
306 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
307 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
309 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
311 jffs2_do_clear_inode(c, f);
312 make_bad_inode(inode);
318 inode->i_op = &jffs2_file_inode_operations;
319 init_special_inode(inode, inode->i_mode,
320 old_decode_dev((je16_to_cpu(rdev))));
324 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
329 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
332 void jffs2_dirty_inode(struct inode *inode)
336 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
337 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
341 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
343 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
344 iattr.ia_mode = inode->i_mode;
345 iattr.ia_uid = inode->i_uid;
346 iattr.ia_gid = inode->i_gid;
347 iattr.ia_atime = inode->i_atime;
348 iattr.ia_mtime = inode->i_mtime;
349 iattr.ia_ctime = inode->i_ctime;
351 jffs2_do_setattr(inode, &iattr);
354 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
356 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
358 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
361 /* We stop if it was running, then restart if it needs to.
362 This also catches the case where it was stopped and this
363 is just a remount to restart it.
364 Flush the writebuffer, if neccecary, else we loose it */
365 if (!(sb->s_flags & MS_RDONLY)) {
366 jffs2_stop_garbage_collect_thread(c);
368 jffs2_flush_wbuf_pad(c);
372 if (!(*flags & MS_RDONLY))
373 jffs2_start_garbage_collect_thread(c);
375 *flags |= MS_NOATIME;
380 void jffs2_write_super (struct super_block *sb)
382 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
385 if (sb->s_flags & MS_RDONLY)
388 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
389 jffs2_garbage_collect_trigger(c);
390 jffs2_erase_pending_blocks(c, 0);
391 jffs2_flush_wbuf_gc(c, 0);
395 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
396 fill in the raw_inode while you're at it. */
397 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
400 struct super_block *sb = dir_i->i_sb;
401 struct jffs2_sb_info *c;
402 struct jffs2_inode_info *f;
405 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
407 c = JFFS2_SB_INFO(sb);
409 inode = new_inode(sb);
412 return ERR_PTR(-ENOMEM);
414 f = JFFS2_INODE_INFO(inode);
415 jffs2_init_inode_info(f);
418 memset(ri, 0, sizeof(*ri));
419 /* Set OS-specific defaults for new inodes */
420 ri->uid = cpu_to_je16(current->fsuid);
422 if (dir_i->i_mode & S_ISGID) {
423 ri->gid = cpu_to_je16(dir_i->i_gid);
427 ri->gid = cpu_to_je16(current->fsgid);
429 ri->mode = cpu_to_jemode(mode);
430 ret = jffs2_do_new_inode (c, f, mode, ri);
432 make_bad_inode(inode);
437 inode->i_ino = je32_to_cpu(ri->ino);
438 inode->i_mode = jemode_to_cpu(ri->mode);
439 inode->i_gid = je16_to_cpu(ri->gid);
440 inode->i_uid = je16_to_cpu(ri->uid);
441 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
442 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
444 inode->i_blksize = PAGE_SIZE;
448 insert_inode_hash(inode);
454 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
456 struct jffs2_sb_info *c;
457 struct inode *root_i;
461 c = JFFS2_SB_INFO(sb);
463 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
464 if (c->mtd->type == MTD_NANDFLASH) {
465 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
468 if (c->mtd->type == MTD_DATAFLASH) {
469 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
474 c->flash_size = c->mtd->size;
475 c->sector_size = c->mtd->erasesize;
476 blocks = c->flash_size / c->sector_size;
479 * Size alignment check
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);
487 if (c->flash_size < 5*c->sector_size) {
488 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
492 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
494 /* NAND (or other bizarre) flash... do setup accordingly */
495 ret = jffs2_flash_setup(c);
499 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
500 if (!c->inocache_list) {
504 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
506 jffs2_init_xattr_subsystem(c);
508 if ((ret = jffs2_do_mount_fs(c)))
513 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
514 root_i = iget(sb, 1);
515 if (is_bad_inode(root_i)) {
516 D1(printk(KERN_WARNING "get root inode failed\n"));
520 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
521 sb->s_root = d_alloc_root(root_i);
525 sb->s_maxbytes = 0xFFFFFFFF;
526 sb->s_blocksize = PAGE_CACHE_SIZE;
527 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
528 sb->s_magic = JFFS2_SUPER_MAGIC;
529 if (!(sb->s_flags & MS_RDONLY))
530 jffs2_start_garbage_collect_thread(c);
535 jffs2_free_ino_caches(c);
536 jffs2_free_raw_node_refs(c);
537 if (jffs2_blocks_use_vmalloc(c))
542 jffs2_clear_xattr_subsystem(c);
543 kfree(c->inocache_list);
545 jffs2_flash_cleanup(c);
550 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
551 struct jffs2_inode_info *f)
553 iput(OFNI_EDONI_2SFFJ(f));
556 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
560 struct jffs2_inode_cache *ic;
562 /* The inode has zero nlink but its nodes weren't yet marked
563 obsolete. This has to be because we're still waiting for
564 the final (close() and) iput() to happen.
566 There's a possibility that the final iput() could have
567 happened while we were contemplating. In order to ensure
568 that we don't cause a new read_inode() (which would fail)
569 for the inode in question, we use ilookup() in this case
572 The nlink can't _become_ zero at this point because we're
573 holding the alloc_sem, and jffs2_do_unlink() would also
574 need that while decrementing nlink on any inode.
576 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
578 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
581 spin_lock(&c->inocache_lock);
582 ic = jffs2_get_ino_cache(c, inum);
584 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
585 spin_unlock(&c->inocache_lock);
588 if (ic->state != INO_STATE_CHECKEDABSENT) {
589 /* Wait for progress. Don't just loop */
590 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
591 ic->ino, ic->state));
592 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
594 spin_unlock(&c->inocache_lock);
600 /* Inode has links to it still; they're not going away because
601 jffs2_do_unlink() would need the alloc_sem and we have it.
602 Just iget() it, and if read_inode() is necessary that's OK.
604 inode = iget(OFNI_BS_2SFFJ(c), inum);
606 return ERR_PTR(-ENOMEM);
608 if (is_bad_inode(inode)) {
609 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
611 /* NB. This will happen again. We need to do something appropriate here. */
613 return ERR_PTR(-EIO);
616 return JFFS2_INODE_INFO(inode);
619 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
620 struct jffs2_inode_info *f,
621 unsigned long offset,
624 struct inode *inode = OFNI_EDONI_2SFFJ(f);
627 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
628 (void *)jffs2_do_readpage_unlock, inode);
632 *priv = (unsigned long)pg;
636 void jffs2_gc_release_page(struct jffs2_sb_info *c,
640 struct page *pg = (void *)*priv;
643 page_cache_release(pg);
646 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
649 if (jffs2_cleanmarker_oob(c)) {
650 /* NAND flash... do setup accordingly */
651 ret = jffs2_nand_flash_setup(c);
656 /* add setups for other bizarre flashes here... */
657 if (jffs2_nor_ecc(c)) {
658 ret = jffs2_nor_ecc_flash_setup(c);
664 if (jffs2_dataflash(c)) {
665 ret = jffs2_dataflash_setup(c);
670 /* and Intel "Sibley" flash */
671 if (jffs2_nor_wbuf_flash(c)) {
672 ret = jffs2_nor_wbuf_flash_setup(c);
680 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
682 if (jffs2_cleanmarker_oob(c)) {
683 jffs2_nand_flash_cleanup(c);
686 /* add cleanups for other bizarre flashes here... */
687 if (jffs2_nor_ecc(c)) {
688 jffs2_nor_ecc_flash_cleanup(c);
692 if (jffs2_dataflash(c)) {
693 jffs2_dataflash_cleanup(c);
696 /* and Intel "Sibley" flash */
697 if (jffs2_nor_wbuf_flash(c)) {
698 jffs2_nor_wbuf_flash_cleanup(c);