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 ri->mode = cpu_to_jemode(iattr->ia_mode);
102 ri->mode = cpu_to_jemode(inode->i_mode);
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));
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);
119 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
121 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
123 ri->data_crc = cpu_to_je32(0);
125 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
126 if (S_ISLNK(inode->i_mode))
129 if (IS_ERR(new_metadata)) {
130 jffs2_complete_reservation(c);
131 jffs2_free_raw_inode(ri);
133 return PTR_ERR(new_metadata);
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);
144 old_metadata = f->metadata;
146 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
147 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
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 inode->i_blocks = (inode->i_size + 511) >> 9;
155 f->metadata = new_metadata;
158 jffs2_mark_node_obsolete(c, old_metadata->raw);
159 jffs2_free_full_dnode(old_metadata);
161 jffs2_free_raw_inode(ri);
164 jffs2_complete_reservation(c);
166 /* We have to do the vmtruncate() without f->sem held, since
167 some pages may be locked and waiting for it in readpage().
168 We are protected from a simultaneous write() extending i_size
169 back past iattr->ia_size, because do_truncate() holds the
170 generic inode semaphore. */
171 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
172 vmtruncate(inode, iattr->ia_size);
173 inode->i_blocks = (inode->i_size + 511) >> 9;
179 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
183 rc = inode_change_ok(dentry->d_inode, iattr);
187 rc = jffs2_do_setattr(dentry->d_inode, iattr);
188 if (!rc && (iattr->ia_valid & ATTR_MODE))
189 rc = jffs2_acl_chmod(dentry->d_inode);
194 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
196 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
199 buf->f_type = JFFS2_SUPER_MAGIC;
200 buf->f_bsize = 1 << PAGE_SHIFT;
201 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
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;
212 spin_unlock(&c->erase_completion_lock);
214 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
220 void jffs2_clear_inode (struct inode *inode)
222 /* We can forget about this inode for now - drop all
223 * the nodelists associated with it, etc.
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);
232 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
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;
242 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
244 inode = iget_locked(sb, ino);
246 return ERR_PTR(-ENOMEM);
247 if (!(inode->i_state & I_NEW))
250 f = JFFS2_INODE_INFO(inode);
251 c = JFFS2_SB_INFO(inode->i_sb);
253 jffs2_init_inode_info(f);
256 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
263 inode->i_mode = jemode_to_cpu(latest_node.mode);
264 inode->i_uid = je16_to_cpu(latest_node.uid);
265 inode->i_gid = je16_to_cpu(latest_node.gid);
266 inode->i_size = je32_to_cpu(latest_node.isize);
267 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
268 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
269 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
271 inode->i_nlink = f->inocache->nlink;
273 inode->i_blocks = (inode->i_size + 511) >> 9;
275 switch (inode->i_mode & S_IFMT) {
278 inode->i_op = &jffs2_symlink_inode_operations;
283 struct jffs2_full_dirent *fd;
285 for (fd=f->dents; fd; fd = fd->next) {
286 if (fd->type == DT_DIR && fd->ino)
291 /* Root dir gets i_nlink 3 for some reason */
292 if (inode->i_ino == 1)
295 inode->i_op = &jffs2_dir_inode_operations;
296 inode->i_fop = &jffs2_dir_operations;
300 inode->i_op = &jffs2_file_inode_operations;
301 inode->i_fop = &jffs2_file_operations;
302 inode->i_mapping->a_ops = &jffs2_file_address_operations;
303 inode->i_mapping->nrpages = 0;
308 /* Read the device numbers from the media */
309 if (f->metadata->size != sizeof(jdev.old) &&
310 f->metadata->size != sizeof(jdev.new)) {
311 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
314 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
315 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
318 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
321 if (f->metadata->size == sizeof(jdev.old))
322 rdev = old_decode_dev(je16_to_cpu(jdev.old));
324 rdev = new_decode_dev(je32_to_cpu(jdev.new));
328 inode->i_op = &jffs2_file_inode_operations;
329 init_special_inode(inode, inode->i_mode, rdev);
333 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
338 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
339 unlock_new_inode(inode);
346 jffs2_do_clear_inode(c, f);
351 void jffs2_dirty_inode(struct inode *inode)
355 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
356 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
360 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
362 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
363 iattr.ia_mode = inode->i_mode;
364 iattr.ia_uid = inode->i_uid;
365 iattr.ia_gid = inode->i_gid;
366 iattr.ia_atime = inode->i_atime;
367 iattr.ia_mtime = inode->i_mtime;
368 iattr.ia_ctime = inode->i_ctime;
370 jffs2_do_setattr(inode, &iattr);
373 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
375 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
377 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
380 /* We stop if it was running, then restart if it needs to.
381 This also catches the case where it was stopped and this
382 is just a remount to restart it.
383 Flush the writebuffer, if neccecary, else we loose it */
384 if (!(sb->s_flags & MS_RDONLY)) {
385 jffs2_stop_garbage_collect_thread(c);
387 jffs2_flush_wbuf_pad(c);
391 if (!(*flags & MS_RDONLY))
392 jffs2_start_garbage_collect_thread(c);
394 *flags |= MS_NOATIME;
399 void jffs2_write_super (struct super_block *sb)
401 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
404 if (sb->s_flags & MS_RDONLY)
407 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
408 jffs2_garbage_collect_trigger(c);
409 jffs2_erase_pending_blocks(c, 0);
410 jffs2_flush_wbuf_gc(c, 0);
414 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
415 fill in the raw_inode while you're at it. */
416 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
419 struct super_block *sb = dir_i->i_sb;
420 struct jffs2_sb_info *c;
421 struct jffs2_inode_info *f;
424 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
426 c = JFFS2_SB_INFO(sb);
428 inode = new_inode(sb);
431 return ERR_PTR(-ENOMEM);
433 f = JFFS2_INODE_INFO(inode);
434 jffs2_init_inode_info(f);
437 memset(ri, 0, sizeof(*ri));
438 /* Set OS-specific defaults for new inodes */
439 ri->uid = cpu_to_je16(current->fsuid);
441 if (dir_i->i_mode & S_ISGID) {
442 ri->gid = cpu_to_je16(dir_i->i_gid);
446 ri->gid = cpu_to_je16(current->fsgid);
449 /* POSIX ACLs have to be processed now, at least partly.
450 The umask is only applied if there's no default ACL */
451 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
453 make_bad_inode(inode);
457 ret = jffs2_do_new_inode (c, f, mode, ri);
459 make_bad_inode(inode);
464 inode->i_ino = je32_to_cpu(ri->ino);
465 inode->i_mode = jemode_to_cpu(ri->mode);
466 inode->i_gid = je16_to_cpu(ri->gid);
467 inode->i_uid = je16_to_cpu(ri->uid);
468 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
469 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
474 insert_inode_hash(inode);
480 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
482 struct jffs2_sb_info *c;
483 struct inode *root_i;
487 c = JFFS2_SB_INFO(sb);
489 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
490 if (c->mtd->type == MTD_NANDFLASH) {
491 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
494 if (c->mtd->type == MTD_DATAFLASH) {
495 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
500 c->flash_size = c->mtd->size;
501 c->sector_size = c->mtd->erasesize;
502 blocks = c->flash_size / c->sector_size;
505 * Size alignment check
507 if ((c->sector_size * blocks) != c->flash_size) {
508 c->flash_size = c->sector_size * blocks;
509 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
510 c->flash_size / 1024);
513 if (c->flash_size < 5*c->sector_size) {
514 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
518 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
520 /* NAND (or other bizarre) flash... do setup accordingly */
521 ret = jffs2_flash_setup(c);
525 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
526 if (!c->inocache_list) {
531 jffs2_init_xattr_subsystem(c);
533 if ((ret = jffs2_do_mount_fs(c)))
536 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
537 root_i = jffs2_iget(sb, 1);
538 if (IS_ERR(root_i)) {
539 D1(printk(KERN_WARNING "get root inode failed\n"));
540 ret = PTR_ERR(root_i);
546 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
547 sb->s_root = d_alloc_root(root_i);
551 sb->s_maxbytes = 0xFFFFFFFF;
552 sb->s_blocksize = PAGE_CACHE_SIZE;
553 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
554 sb->s_magic = JFFS2_SUPER_MAGIC;
555 if (!(sb->s_flags & MS_RDONLY))
556 jffs2_start_garbage_collect_thread(c);
562 jffs2_free_ino_caches(c);
563 jffs2_free_raw_node_refs(c);
564 if (jffs2_blocks_use_vmalloc(c))
569 jffs2_clear_xattr_subsystem(c);
570 kfree(c->inocache_list);
572 jffs2_flash_cleanup(c);
577 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
578 struct jffs2_inode_info *f)
580 iput(OFNI_EDONI_2SFFJ(f));
583 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
587 struct jffs2_inode_cache *ic;
589 /* The inode has zero nlink but its nodes weren't yet marked
590 obsolete. This has to be because we're still waiting for
591 the final (close() and) iput() to happen.
593 There's a possibility that the final iput() could have
594 happened while we were contemplating. In order to ensure
595 that we don't cause a new read_inode() (which would fail)
596 for the inode in question, we use ilookup() in this case
599 The nlink can't _become_ zero at this point because we're
600 holding the alloc_sem, and jffs2_do_unlink() would also
601 need that while decrementing nlink on any inode.
603 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
605 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
608 spin_lock(&c->inocache_lock);
609 ic = jffs2_get_ino_cache(c, inum);
611 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
612 spin_unlock(&c->inocache_lock);
615 if (ic->state != INO_STATE_CHECKEDABSENT) {
616 /* Wait for progress. Don't just loop */
617 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
618 ic->ino, ic->state));
619 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
621 spin_unlock(&c->inocache_lock);
627 /* Inode has links to it still; they're not going away because
628 jffs2_do_unlink() would need the alloc_sem and we have it.
629 Just iget() it, and if read_inode() is necessary that's OK.
631 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
633 return ERR_CAST(inode);
635 if (is_bad_inode(inode)) {
636 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
638 /* NB. This will happen again. We need to do something appropriate here. */
640 return ERR_PTR(-EIO);
643 return JFFS2_INODE_INFO(inode);
646 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
647 struct jffs2_inode_info *f,
648 unsigned long offset,
651 struct inode *inode = OFNI_EDONI_2SFFJ(f);
654 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
655 (void *)jffs2_do_readpage_unlock, inode);
659 *priv = (unsigned long)pg;
663 void jffs2_gc_release_page(struct jffs2_sb_info *c,
667 struct page *pg = (void *)*priv;
670 page_cache_release(pg);
673 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
676 if (jffs2_cleanmarker_oob(c)) {
677 /* NAND flash... do setup accordingly */
678 ret = jffs2_nand_flash_setup(c);
684 if (jffs2_dataflash(c)) {
685 ret = jffs2_dataflash_setup(c);
690 /* and Intel "Sibley" flash */
691 if (jffs2_nor_wbuf_flash(c)) {
692 ret = jffs2_nor_wbuf_flash_setup(c);
697 /* and an UBI volume */
698 if (jffs2_ubivol(c)) {
699 ret = jffs2_ubivol_setup(c);
707 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
709 if (jffs2_cleanmarker_oob(c)) {
710 jffs2_nand_flash_cleanup(c);
714 if (jffs2_dataflash(c)) {
715 jffs2_dataflash_cleanup(c);
718 /* and Intel "Sibley" flash */
719 if (jffs2_nor_wbuf_flash(c)) {
720 jffs2_nor_wbuf_flash_cleanup(c);
723 /* and an UBI volume */
724 if (jffs2_ubivol(c)) {
725 jffs2_ubivol_cleanup(c);