2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
12 #include <linux/capability.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.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>
25 static int jffs2_flash_setup(struct jffs2_sb_info *c);
27 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
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;
40 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
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);
51 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
52 } else if (S_ISLNK(inode->i_mode)) {
54 mdatalen = f->metadata->size;
55 mdata = kmalloc(f->metadata->size, GFP_USER);
60 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
67 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
70 ri = jffs2_alloc_raw_inode();
72 if (S_ISLNK(inode->i_mode))
77 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
78 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
80 jffs2_free_raw_inode(ri);
81 if (S_ISLNK(inode->i_mode & S_IFMT))
86 ivalid = iattr->ia_valid;
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));
93 ri->ino = cpu_to_je32(inode->i_ino);
94 ri->version = cpu_to_je32(++f->highest_version);
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);
99 if (ivalid & ATTR_MODE)
100 if (iattr->ia_mode & S_ISGID &&
101 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
102 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
104 ri->mode = cpu_to_jemode(iattr->ia_mode);
106 ri->mode = cpu_to_jemode(inode->i_mode);
109 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
110 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
111 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
112 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
114 ri->offset = cpu_to_je32(0);
115 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
116 ri->compr = JFFS2_COMPR_NONE;
117 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
118 /* It's an extension. Make it a hole node */
119 ri->compr = JFFS2_COMPR_ZERO;
120 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
121 ri->offset = cpu_to_je32(inode->i_size);
123 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
125 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
127 ri->data_crc = cpu_to_je32(0);
129 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
130 if (S_ISLNK(inode->i_mode))
133 if (IS_ERR(new_metadata)) {
134 jffs2_complete_reservation(c);
135 jffs2_free_raw_inode(ri);
137 return PTR_ERR(new_metadata);
139 /* It worked. Update the inode */
140 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
141 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
142 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
143 inode->i_mode = jemode_to_cpu(ri->mode);
144 inode->i_uid = je16_to_cpu(ri->uid);
145 inode->i_gid = je16_to_cpu(ri->gid);
148 old_metadata = f->metadata;
150 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
151 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
153 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
154 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
155 inode->i_size = iattr->ia_size;
158 f->metadata = new_metadata;
161 jffs2_mark_node_obsolete(c, old_metadata->raw);
162 jffs2_free_full_dnode(old_metadata);
164 jffs2_free_raw_inode(ri);
167 jffs2_complete_reservation(c);
169 /* We have to do the vmtruncate() without f->sem held, since
170 some pages may be locked and waiting for it in readpage().
171 We are protected from a simultaneous write() extending i_size
172 back past iattr->ia_size, because do_truncate() holds the
173 generic inode semaphore. */
174 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
175 vmtruncate(inode, iattr->ia_size);
180 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
184 rc = inode_change_ok(dentry->d_inode, iattr);
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);
195 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
197 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
200 buf->f_type = JFFS2_SUPER_MAGIC;
201 buf->f_bsize = 1 << PAGE_SHIFT;
202 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
205 buf->f_namelen = JFFS2_MAX_NAME_LEN;
207 spin_lock(&c->erase_completion_lock);
208 avail = c->dirty_size + c->free_size;
209 if (avail > c->sector_size * c->resv_blocks_write)
210 avail -= c->sector_size * c->resv_blocks_write;
213 spin_unlock(&c->erase_completion_lock);
215 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
221 void jffs2_clear_inode (struct inode *inode)
223 /* We can forget about this inode for now - drop all
224 * the nodelists associated with it, etc.
226 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
227 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
229 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
230 jffs2_do_clear_inode(c, f);
233 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
235 struct jffs2_inode_info *f;
236 struct jffs2_sb_info *c;
237 struct jffs2_raw_inode latest_node;
238 union jffs2_device_node jdev;
243 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
245 inode = iget_locked(sb, ino);
247 return ERR_PTR(-ENOMEM);
248 if (!(inode->i_state & I_NEW))
251 f = JFFS2_INODE_INFO(inode);
252 c = JFFS2_SB_INFO(inode->i_sb);
254 jffs2_init_inode_info(f);
257 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
264 inode->i_mode = jemode_to_cpu(latest_node.mode);
265 inode->i_uid = je16_to_cpu(latest_node.uid);
266 inode->i_gid = je16_to_cpu(latest_node.gid);
267 inode->i_size = je32_to_cpu(latest_node.isize);
268 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
269 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
270 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
272 inode->i_nlink = f->inocache->nlink;
274 inode->i_blocks = (inode->i_size + 511) >> 9;
276 switch (inode->i_mode & S_IFMT) {
279 inode->i_op = &jffs2_symlink_inode_operations;
284 struct jffs2_full_dirent *fd;
286 for (fd=f->dents; fd; fd = fd->next) {
287 if (fd->type == DT_DIR && fd->ino)
292 /* Root dir gets i_nlink 3 for some reason */
293 if (inode->i_ino == 1)
296 inode->i_op = &jffs2_dir_inode_operations;
297 inode->i_fop = &jffs2_dir_operations;
301 inode->i_op = &jffs2_file_inode_operations;
302 inode->i_fop = &jffs2_file_operations;
303 inode->i_mapping->a_ops = &jffs2_file_address_operations;
304 inode->i_mapping->nrpages = 0;
309 /* Read the device numbers from the media */
310 if (f->metadata->size != sizeof(jdev.old) &&
311 f->metadata->size != sizeof(jdev.new)) {
312 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
315 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
316 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
319 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
322 if (f->metadata->size == sizeof(jdev.old))
323 rdev = old_decode_dev(je16_to_cpu(jdev.old));
325 rdev = new_decode_dev(je32_to_cpu(jdev.new));
329 inode->i_op = &jffs2_file_inode_operations;
330 init_special_inode(inode, inode->i_mode, rdev);
334 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
339 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
340 unlock_new_inode(inode);
347 jffs2_do_clear_inode(c, f);
352 void jffs2_dirty_inode(struct inode *inode)
356 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
357 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
361 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
363 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
364 iattr.ia_mode = inode->i_mode;
365 iattr.ia_uid = inode->i_uid;
366 iattr.ia_gid = inode->i_gid;
367 iattr.ia_atime = inode->i_atime;
368 iattr.ia_mtime = inode->i_mtime;
369 iattr.ia_ctime = inode->i_ctime;
371 jffs2_do_setattr(inode, &iattr);
374 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
376 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
378 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
381 /* We stop if it was running, then restart if it needs to.
382 This also catches the case where it was stopped and this
383 is just a remount to restart it.
384 Flush the writebuffer, if neccecary, else we loose it */
385 if (!(sb->s_flags & MS_RDONLY)) {
386 jffs2_stop_garbage_collect_thread(c);
388 jffs2_flush_wbuf_pad(c);
392 if (!(*flags & MS_RDONLY))
393 jffs2_start_garbage_collect_thread(c);
395 *flags |= MS_NOATIME;
400 void jffs2_write_super (struct super_block *sb)
402 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
405 if (sb->s_flags & MS_RDONLY)
408 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
409 jffs2_garbage_collect_trigger(c);
410 jffs2_erase_pending_blocks(c, 0);
411 jffs2_flush_wbuf_gc(c, 0);
415 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
416 fill in the raw_inode while you're at it. */
417 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
420 struct super_block *sb = dir_i->i_sb;
421 struct jffs2_sb_info *c;
422 struct jffs2_inode_info *f;
425 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
427 c = JFFS2_SB_INFO(sb);
429 inode = new_inode(sb);
432 return ERR_PTR(-ENOMEM);
434 f = JFFS2_INODE_INFO(inode);
435 jffs2_init_inode_info(f);
438 memset(ri, 0, sizeof(*ri));
439 /* Set OS-specific defaults for new inodes */
440 ri->uid = cpu_to_je16(current->fsuid);
442 if (dir_i->i_mode & S_ISGID) {
443 ri->gid = cpu_to_je16(dir_i->i_gid);
447 ri->gid = cpu_to_je16(current->fsgid);
450 /* POSIX ACLs have to be processed now, at least partly.
451 The umask is only applied if there's no default ACL */
452 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
454 make_bad_inode(inode);
458 ret = jffs2_do_new_inode (c, f, mode, ri);
460 make_bad_inode(inode);
465 inode->i_ino = je32_to_cpu(ri->ino);
466 inode->i_mode = jemode_to_cpu(ri->mode);
467 inode->i_gid = je16_to_cpu(ri->gid);
468 inode->i_uid = je16_to_cpu(ri->uid);
469 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
470 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
475 insert_inode_hash(inode);
481 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
483 struct jffs2_sb_info *c;
484 struct inode *root_i;
488 c = JFFS2_SB_INFO(sb);
490 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
491 if (c->mtd->type == MTD_NANDFLASH) {
492 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
495 if (c->mtd->type == MTD_DATAFLASH) {
496 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
501 c->flash_size = c->mtd->size;
502 c->sector_size = c->mtd->erasesize;
503 blocks = c->flash_size / c->sector_size;
506 * Size alignment check
508 if ((c->sector_size * blocks) != c->flash_size) {
509 c->flash_size = c->sector_size * blocks;
510 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
511 c->flash_size / 1024);
514 if (c->flash_size < 5*c->sector_size) {
515 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
519 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
521 /* NAND (or other bizarre) flash... do setup accordingly */
522 ret = jffs2_flash_setup(c);
526 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
527 if (!c->inocache_list) {
532 jffs2_init_xattr_subsystem(c);
534 if ((ret = jffs2_do_mount_fs(c)))
537 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
538 root_i = jffs2_iget(sb, 1);
539 if (IS_ERR(root_i)) {
540 D1(printk(KERN_WARNING "get root inode failed\n"));
541 ret = PTR_ERR(root_i);
547 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
548 sb->s_root = d_alloc_root(root_i);
552 sb->s_maxbytes = 0xFFFFFFFF;
553 sb->s_blocksize = PAGE_CACHE_SIZE;
554 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
555 sb->s_magic = JFFS2_SUPER_MAGIC;
556 if (!(sb->s_flags & MS_RDONLY))
557 jffs2_start_garbage_collect_thread(c);
563 jffs2_free_ino_caches(c);
564 jffs2_free_raw_node_refs(c);
565 if (jffs2_blocks_use_vmalloc(c))
570 jffs2_clear_xattr_subsystem(c);
571 kfree(c->inocache_list);
573 jffs2_flash_cleanup(c);
578 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
579 struct jffs2_inode_info *f)
581 iput(OFNI_EDONI_2SFFJ(f));
584 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
588 struct jffs2_inode_cache *ic;
590 /* The inode has zero nlink but its nodes weren't yet marked
591 obsolete. This has to be because we're still waiting for
592 the final (close() and) iput() to happen.
594 There's a possibility that the final iput() could have
595 happened while we were contemplating. In order to ensure
596 that we don't cause a new read_inode() (which would fail)
597 for the inode in question, we use ilookup() in this case
600 The nlink can't _become_ zero at this point because we're
601 holding the alloc_sem, and jffs2_do_unlink() would also
602 need that while decrementing nlink on any inode.
604 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
606 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
609 spin_lock(&c->inocache_lock);
610 ic = jffs2_get_ino_cache(c, inum);
612 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
613 spin_unlock(&c->inocache_lock);
616 if (ic->state != INO_STATE_CHECKEDABSENT) {
617 /* Wait for progress. Don't just loop */
618 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
619 ic->ino, ic->state));
620 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
622 spin_unlock(&c->inocache_lock);
628 /* Inode has links to it still; they're not going away because
629 jffs2_do_unlink() would need the alloc_sem and we have it.
630 Just iget() it, and if read_inode() is necessary that's OK.
632 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
634 return ERR_CAST(inode);
636 if (is_bad_inode(inode)) {
637 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
639 /* NB. This will happen again. We need to do something appropriate here. */
641 return ERR_PTR(-EIO);
644 return JFFS2_INODE_INFO(inode);
647 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
648 struct jffs2_inode_info *f,
649 unsigned long offset,
652 struct inode *inode = OFNI_EDONI_2SFFJ(f);
655 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
656 (void *)jffs2_do_readpage_unlock, inode);
660 *priv = (unsigned long)pg;
664 void jffs2_gc_release_page(struct jffs2_sb_info *c,
668 struct page *pg = (void *)*priv;
671 page_cache_release(pg);
674 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
677 if (jffs2_cleanmarker_oob(c)) {
678 /* NAND flash... do setup accordingly */
679 ret = jffs2_nand_flash_setup(c);
685 if (jffs2_dataflash(c)) {
686 ret = jffs2_dataflash_setup(c);
691 /* and Intel "Sibley" flash */
692 if (jffs2_nor_wbuf_flash(c)) {
693 ret = jffs2_nor_wbuf_flash_setup(c);
698 /* and an UBI volume */
699 if (jffs2_ubivol(c)) {
700 ret = jffs2_ubivol_setup(c);
708 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
710 if (jffs2_cleanmarker_oob(c)) {
711 jffs2_nand_flash_cleanup(c);
715 if (jffs2_dataflash(c)) {
716 jffs2_dataflash_cleanup(c);
719 /* and Intel "Sibley" flash */
720 if (jffs2_nor_wbuf_flash(c)) {
721 jffs2_nor_wbuf_flash_cleanup(c);
724 /* and an UBI volume */
725 if (jffs2_ubivol(c)) {
726 jffs2_ubivol_cleanup(c);