2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
7 * Created by David Woodhouse <dwmw2@infradead.org>
9 * For licensing information, see the file 'LICENCE' in this directory.
13 #include <linux/capability.h>
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
17 #include <linux/list.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/pagemap.h>
20 #include <linux/slab.h>
21 #include <linux/vmalloc.h>
22 #include <linux/vfs.h>
23 #include <linux/crc32.h>
24 #include <linux/smp_lock.h>
27 static int jffs2_flash_setup(struct jffs2_sb_info *c);
29 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
31 struct jffs2_full_dnode *old_metadata, *new_metadata;
32 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
33 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
34 struct jffs2_raw_inode *ri;
35 union jffs2_device_node dev;
36 unsigned char *mdata = NULL;
41 int alloc_type = ALLOC_NORMAL;
43 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
45 /* Special cases - we don't want more than one data node
46 for these types on the medium at any time. So setattr
47 must read the original data associated with the node
48 (i.e. the device numbers or the target name) and write
49 it out again with the appropriate data attached */
50 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
51 /* For these, we don't actually need to read the old node */
52 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
54 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
55 } else if (S_ISLNK(inode->i_mode)) {
57 mdatalen = f->metadata->size;
58 mdata = kmalloc(f->metadata->size, GFP_USER);
60 mutex_unlock(&f->sem);
63 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
65 mutex_unlock(&f->sem);
69 mutex_unlock(&f->sem);
70 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
73 ri = jffs2_alloc_raw_inode();
75 if (S_ISLNK(inode->i_mode))
80 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
81 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
83 jffs2_free_raw_inode(ri);
84 if (S_ISLNK(inode->i_mode & S_IFMT))
89 ivalid = iattr->ia_valid;
91 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
92 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
93 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
94 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
96 ri->ino = cpu_to_je32(inode->i_ino);
97 ri->version = cpu_to_je32(++f->highest_version);
99 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
100 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
102 if (ivalid & ATTR_MODE)
103 ri->mode = cpu_to_jemode(iattr->ia_mode);
105 ri->mode = cpu_to_jemode(inode->i_mode);
108 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
109 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
110 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
111 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
113 ri->offset = cpu_to_je32(0);
114 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
115 ri->compr = JFFS2_COMPR_NONE;
116 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
117 /* It's an extension. Make it a hole node */
118 ri->compr = JFFS2_COMPR_ZERO;
119 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
120 ri->offset = cpu_to_je32(inode->i_size);
121 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
122 /* For truncate-to-zero, treat it as deletion because
123 it'll always be obsoleting all previous nodes */
124 alloc_type = ALLOC_DELETION;
126 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
128 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
130 ri->data_crc = cpu_to_je32(0);
132 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
133 if (S_ISLNK(inode->i_mode))
136 if (IS_ERR(new_metadata)) {
137 jffs2_complete_reservation(c);
138 jffs2_free_raw_inode(ri);
139 mutex_unlock(&f->sem);
140 return PTR_ERR(new_metadata);
142 /* It worked. Update the inode */
143 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
144 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
145 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
146 inode->i_mode = jemode_to_cpu(ri->mode);
147 inode->i_uid = je16_to_cpu(ri->uid);
148 inode->i_gid = je16_to_cpu(ri->gid);
151 old_metadata = f->metadata;
153 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
154 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
156 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
157 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
158 inode->i_size = iattr->ia_size;
159 inode->i_blocks = (inode->i_size + 511) >> 9;
162 f->metadata = new_metadata;
165 jffs2_mark_node_obsolete(c, old_metadata->raw);
166 jffs2_free_full_dnode(old_metadata);
168 jffs2_free_raw_inode(ri);
170 mutex_unlock(&f->sem);
171 jffs2_complete_reservation(c);
173 /* We have to do the truncate_setsize() without f->sem held, since
174 some pages may be locked and waiting for it in readpage().
175 We are protected from a simultaneous write() extending i_size
176 back past iattr->ia_size, because do_truncate() holds the
177 generic inode semaphore. */
178 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
179 truncate_setsize(inode, iattr->ia_size);
180 inode->i_blocks = (inode->i_size + 511) >> 9;
186 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
190 rc = inode_change_ok(dentry->d_inode, iattr);
194 rc = jffs2_do_setattr(dentry->d_inode, iattr);
195 if (!rc && (iattr->ia_valid & ATTR_MODE))
196 rc = jffs2_acl_chmod(dentry->d_inode);
201 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
203 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
206 buf->f_type = JFFS2_SUPER_MAGIC;
207 buf->f_bsize = 1 << PAGE_SHIFT;
208 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
211 buf->f_namelen = JFFS2_MAX_NAME_LEN;
212 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
213 buf->f_fsid.val[1] = c->mtd->index;
215 spin_lock(&c->erase_completion_lock);
216 avail = c->dirty_size + c->free_size;
217 if (avail > c->sector_size * c->resv_blocks_write)
218 avail -= c->sector_size * c->resv_blocks_write;
221 spin_unlock(&c->erase_completion_lock);
223 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
229 void jffs2_evict_inode (struct inode *inode)
231 /* We can forget about this inode for now - drop all
232 * the nodelists associated with it, etc.
234 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
235 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
237 D1(printk(KERN_DEBUG "jffs2_evict_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
238 truncate_inode_pages(&inode->i_data, 0);
239 end_writeback(inode);
240 jffs2_do_clear_inode(c, f);
243 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
245 struct jffs2_inode_info *f;
246 struct jffs2_sb_info *c;
247 struct jffs2_raw_inode latest_node;
248 union jffs2_device_node jdev;
253 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
255 inode = iget_locked(sb, ino);
257 return ERR_PTR(-ENOMEM);
258 if (!(inode->i_state & I_NEW))
261 f = JFFS2_INODE_INFO(inode);
262 c = JFFS2_SB_INFO(inode->i_sb);
264 jffs2_init_inode_info(f);
267 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
270 mutex_unlock(&f->sem);
274 inode->i_mode = jemode_to_cpu(latest_node.mode);
275 inode->i_uid = je16_to_cpu(latest_node.uid);
276 inode->i_gid = je16_to_cpu(latest_node.gid);
277 inode->i_size = je32_to_cpu(latest_node.isize);
278 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
279 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
280 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
282 inode->i_nlink = f->inocache->pino_nlink;
284 inode->i_blocks = (inode->i_size + 511) >> 9;
286 switch (inode->i_mode & S_IFMT) {
289 inode->i_op = &jffs2_symlink_inode_operations;
294 struct jffs2_full_dirent *fd;
295 inode->i_nlink = 2; /* parent and '.' */
297 for (fd=f->dents; fd; fd = fd->next) {
298 if (fd->type == DT_DIR && fd->ino)
301 /* Root dir gets i_nlink 3 for some reason */
302 if (inode->i_ino == 1)
305 inode->i_op = &jffs2_dir_inode_operations;
306 inode->i_fop = &jffs2_dir_operations;
310 inode->i_op = &jffs2_file_inode_operations;
311 inode->i_fop = &jffs2_file_operations;
312 inode->i_mapping->a_ops = &jffs2_file_address_operations;
313 inode->i_mapping->nrpages = 0;
318 /* Read the device numbers from the media */
319 if (f->metadata->size != sizeof(jdev.old_id) &&
320 f->metadata->size != sizeof(jdev.new_id)) {
321 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
324 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
325 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
328 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
331 if (f->metadata->size == sizeof(jdev.old_id))
332 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
334 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
338 inode->i_op = &jffs2_file_inode_operations;
339 init_special_inode(inode, inode->i_mode, rdev);
343 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
346 mutex_unlock(&f->sem);
348 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
349 unlock_new_inode(inode);
355 mutex_unlock(&f->sem);
356 jffs2_do_clear_inode(c, f);
361 void jffs2_dirty_inode(struct inode *inode)
365 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
366 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
370 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
372 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
373 iattr.ia_mode = inode->i_mode;
374 iattr.ia_uid = inode->i_uid;
375 iattr.ia_gid = inode->i_gid;
376 iattr.ia_atime = inode->i_atime;
377 iattr.ia_mtime = inode->i_mtime;
378 iattr.ia_ctime = inode->i_ctime;
380 jffs2_do_setattr(inode, &iattr);
383 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
385 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
387 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
390 /* We stop if it was running, then restart if it needs to.
391 This also catches the case where it was stopped and this
392 is just a remount to restart it.
393 Flush the writebuffer, if neccecary, else we loose it */
395 if (!(sb->s_flags & MS_RDONLY)) {
396 jffs2_stop_garbage_collect_thread(c);
397 mutex_lock(&c->alloc_sem);
398 jffs2_flush_wbuf_pad(c);
399 mutex_unlock(&c->alloc_sem);
402 if (!(*flags & MS_RDONLY))
403 jffs2_start_garbage_collect_thread(c);
405 *flags |= MS_NOATIME;
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)
416 struct super_block *sb = dir_i->i_sb;
417 struct jffs2_sb_info *c;
418 struct jffs2_inode_info *f;
421 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
423 c = JFFS2_SB_INFO(sb);
425 inode = new_inode(sb);
428 return ERR_PTR(-ENOMEM);
430 f = JFFS2_INODE_INFO(inode);
431 jffs2_init_inode_info(f);
434 memset(ri, 0, sizeof(*ri));
435 /* Set OS-specific defaults for new inodes */
436 ri->uid = cpu_to_je16(current_fsuid());
438 if (dir_i->i_mode & S_ISGID) {
439 ri->gid = cpu_to_je16(dir_i->i_gid);
443 ri->gid = cpu_to_je16(current_fsgid());
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);
450 make_bad_inode(inode);
454 ret = jffs2_do_new_inode (c, f, mode, ri);
456 make_bad_inode(inode);
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));
471 if (insert_inode_locked(inode) < 0) {
472 make_bad_inode(inode);
473 unlock_new_inode(inode);
475 return ERR_PTR(-EINVAL);
481 static int calculate_inocache_hashsize(uint32_t flash_size)
484 * Pick a inocache hash size based on the size of the medium.
485 * Count how many megabytes we're dealing with, apply a hashsize twice
486 * that size, but rounding down to the usual big powers of 2. And keep
487 * to sensible bounds.
490 int size_mb = flash_size / 1024 / 1024;
491 int hashsize = (size_mb * 2) & ~0x3f;
493 if (hashsize < INOCACHE_HASHSIZE_MIN)
494 return INOCACHE_HASHSIZE_MIN;
495 if (hashsize > INOCACHE_HASHSIZE_MAX)
496 return INOCACHE_HASHSIZE_MAX;
501 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
503 struct jffs2_sb_info *c;
504 struct inode *root_i;
508 c = JFFS2_SB_INFO(sb);
510 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
511 if (c->mtd->type == MTD_NANDFLASH) {
512 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
515 if (c->mtd->type == MTD_DATAFLASH) {
516 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
521 c->flash_size = c->mtd->size;
522 c->sector_size = c->mtd->erasesize;
523 blocks = c->flash_size / c->sector_size;
526 * Size alignment check
528 if ((c->sector_size * blocks) != c->flash_size) {
529 c->flash_size = c->sector_size * blocks;
530 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
531 c->flash_size / 1024);
534 if (c->flash_size < 5*c->sector_size) {
535 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
539 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
541 /* NAND (or other bizarre) flash... do setup accordingly */
542 ret = jffs2_flash_setup(c);
546 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
547 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
548 if (!c->inocache_list) {
553 jffs2_init_xattr_subsystem(c);
555 if ((ret = jffs2_do_mount_fs(c)))
558 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
559 root_i = jffs2_iget(sb, 1);
560 if (IS_ERR(root_i)) {
561 D1(printk(KERN_WARNING "get root inode failed\n"));
562 ret = PTR_ERR(root_i);
568 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
569 sb->s_root = d_alloc_root(root_i);
573 sb->s_maxbytes = 0xFFFFFFFF;
574 sb->s_blocksize = PAGE_CACHE_SIZE;
575 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
576 sb->s_magic = JFFS2_SUPER_MAGIC;
577 if (!(sb->s_flags & MS_RDONLY))
578 jffs2_start_garbage_collect_thread(c);
584 jffs2_free_ino_caches(c);
585 jffs2_free_raw_node_refs(c);
586 if (jffs2_blocks_use_vmalloc(c))
591 jffs2_clear_xattr_subsystem(c);
592 kfree(c->inocache_list);
594 jffs2_flash_cleanup(c);
599 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
600 struct jffs2_inode_info *f)
602 iput(OFNI_EDONI_2SFFJ(f));
605 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
606 int inum, int unlinked)
609 struct jffs2_inode_cache *ic;
612 /* The inode has zero nlink but its nodes weren't yet marked
613 obsolete. This has to be because we're still waiting for
614 the final (close() and) iput() to happen.
616 There's a possibility that the final iput() could have
617 happened while we were contemplating. In order to ensure
618 that we don't cause a new read_inode() (which would fail)
619 for the inode in question, we use ilookup() in this case
622 The nlink can't _become_ zero at this point because we're
623 holding the alloc_sem, and jffs2_do_unlink() would also
624 need that while decrementing nlink on any inode.
626 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
628 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
631 spin_lock(&c->inocache_lock);
632 ic = jffs2_get_ino_cache(c, inum);
634 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
635 spin_unlock(&c->inocache_lock);
638 if (ic->state != INO_STATE_CHECKEDABSENT) {
639 /* Wait for progress. Don't just loop */
640 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
641 ic->ino, ic->state));
642 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
644 spin_unlock(&c->inocache_lock);
650 /* Inode has links to it still; they're not going away because
651 jffs2_do_unlink() would need the alloc_sem and we have it.
652 Just iget() it, and if read_inode() is necessary that's OK.
654 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
656 return ERR_CAST(inode);
658 if (is_bad_inode(inode)) {
659 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. unlinked %d\n",
661 /* NB. This will happen again. We need to do something appropriate here. */
663 return ERR_PTR(-EIO);
666 return JFFS2_INODE_INFO(inode);
669 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
670 struct jffs2_inode_info *f,
671 unsigned long offset,
674 struct inode *inode = OFNI_EDONI_2SFFJ(f);
677 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
678 (void *)jffs2_do_readpage_unlock, inode);
682 *priv = (unsigned long)pg;
686 void jffs2_gc_release_page(struct jffs2_sb_info *c,
690 struct page *pg = (void *)*priv;
693 page_cache_release(pg);
696 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
699 if (jffs2_cleanmarker_oob(c)) {
700 /* NAND flash... do setup accordingly */
701 ret = jffs2_nand_flash_setup(c);
707 if (jffs2_dataflash(c)) {
708 ret = jffs2_dataflash_setup(c);
713 /* and Intel "Sibley" flash */
714 if (jffs2_nor_wbuf_flash(c)) {
715 ret = jffs2_nor_wbuf_flash_setup(c);
720 /* and an UBI volume */
721 if (jffs2_ubivol(c)) {
722 ret = jffs2_ubivol_setup(c);
730 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
732 if (jffs2_cleanmarker_oob(c)) {
733 jffs2_nand_flash_cleanup(c);
737 if (jffs2_dataflash(c)) {
738 jffs2_dataflash_cleanup(c);
741 /* and Intel "Sibley" flash */
742 if (jffs2_nor_wbuf_flash(c)) {
743 jffs2_nor_wbuf_flash_cleanup(c);
746 /* and an UBI volume */
747 if (jffs2_ubivol(c)) {
748 jffs2_ubivol_cleanup(c);