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.53 2005/02/09 09:23:53 pavlov Exp $
14 #include <linux/version.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)) {
59 mdatalen = f->metadata->size;
60 mdata = kmalloc(f->metadata->size, GFP_USER);
63 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
68 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
71 ri = jffs2_alloc_raw_inode();
73 if (S_ISLNK(inode->i_mode))
78 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
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, phys_ofs, 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_fraglist (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)
182 return jffs2_do_setattr(dentry->d_inode, iattr);
185 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
187 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
190 buf->f_type = JFFS2_SUPER_MAGIC;
191 buf->f_bsize = 1 << PAGE_SHIFT;
192 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
195 buf->f_namelen = JFFS2_MAX_NAME_LEN;
197 spin_lock(&c->erase_completion_lock);
199 avail = c->dirty_size + c->free_size;
200 if (avail > c->sector_size * c->resv_blocks_write)
201 avail -= c->sector_size * c->resv_blocks_write;
205 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
207 D2(jffs2_dump_block_lists(c));
209 spin_unlock(&c->erase_completion_lock);
215 void jffs2_clear_inode (struct inode *inode)
217 /* We can forget about this inode for now - drop all
218 * the nodelists associated with it, etc.
220 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
221 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
223 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
225 jffs2_do_clear_inode(c, f);
228 void jffs2_read_inode (struct inode *inode)
230 struct jffs2_inode_info *f;
231 struct jffs2_sb_info *c;
232 struct jffs2_raw_inode latest_node;
235 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
237 f = JFFS2_INODE_INFO(inode);
238 c = JFFS2_SB_INFO(inode->i_sb);
240 jffs2_init_inode_info(f);
242 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
245 make_bad_inode(inode);
249 inode->i_mode = jemode_to_cpu(latest_node.mode);
250 inode->i_uid = je16_to_cpu(latest_node.uid);
251 inode->i_gid = je16_to_cpu(latest_node.gid);
252 inode->i_size = je32_to_cpu(latest_node.isize);
253 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
254 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
255 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
257 inode->i_nlink = f->inocache->nlink;
259 inode->i_blksize = PAGE_SIZE;
260 inode->i_blocks = (inode->i_size + 511) >> 9;
262 switch (inode->i_mode & S_IFMT) {
266 inode->i_op = &jffs2_symlink_inode_operations;
271 struct jffs2_full_dirent *fd;
273 for (fd=f->dents; fd; fd = fd->next) {
274 if (fd->type == DT_DIR && fd->ino)
279 /* Root dir gets i_nlink 3 for some reason */
280 if (inode->i_ino == 1)
283 inode->i_op = &jffs2_dir_inode_operations;
284 inode->i_fop = &jffs2_dir_operations;
288 inode->i_op = &jffs2_file_inode_operations;
289 inode->i_fop = &jffs2_file_operations;
290 inode->i_mapping->a_ops = &jffs2_file_address_operations;
291 inode->i_mapping->nrpages = 0;
296 /* Read the device numbers from the media */
297 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
298 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
300 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
302 jffs2_do_clear_inode(c, f);
303 make_bad_inode(inode);
309 inode->i_op = &jffs2_file_inode_operations;
310 init_special_inode(inode, inode->i_mode,
311 old_decode_dev((je16_to_cpu(rdev))));
315 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
320 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
323 void jffs2_dirty_inode(struct inode *inode)
327 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
328 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
332 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
334 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
335 iattr.ia_mode = inode->i_mode;
336 iattr.ia_uid = inode->i_uid;
337 iattr.ia_gid = inode->i_gid;
338 iattr.ia_atime = inode->i_atime;
339 iattr.ia_mtime = inode->i_mtime;
340 iattr.ia_ctime = inode->i_ctime;
342 jffs2_do_setattr(inode, &iattr);
345 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
347 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
349 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
352 /* We stop if it was running, then restart if it needs to.
353 This also catches the case where it was stopped and this
354 is just a remount to restart it.
355 Flush the writebuffer, if neccecary, else we loose it */
356 if (!(sb->s_flags & MS_RDONLY)) {
357 jffs2_stop_garbage_collect_thread(c);
359 jffs2_flush_wbuf_pad(c);
363 if (!(*flags & MS_RDONLY))
364 jffs2_start_garbage_collect_thread(c);
366 *flags |= MS_NOATIME;
371 void jffs2_write_super (struct super_block *sb)
373 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
376 if (sb->s_flags & MS_RDONLY)
379 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
380 jffs2_garbage_collect_trigger(c);
381 jffs2_erase_pending_blocks(c, 0);
382 jffs2_flush_wbuf_gc(c, 0);
386 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
387 fill in the raw_inode while you're at it. */
388 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
391 struct super_block *sb = dir_i->i_sb;
392 struct jffs2_sb_info *c;
393 struct jffs2_inode_info *f;
396 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
398 c = JFFS2_SB_INFO(sb);
400 inode = new_inode(sb);
403 return ERR_PTR(-ENOMEM);
405 f = JFFS2_INODE_INFO(inode);
406 jffs2_init_inode_info(f);
408 memset(ri, 0, sizeof(*ri));
409 /* Set OS-specific defaults for new inodes */
410 ri->uid = cpu_to_je16(current->fsuid);
412 if (dir_i->i_mode & S_ISGID) {
413 ri->gid = cpu_to_je16(dir_i->i_gid);
417 ri->gid = cpu_to_je16(current->fsgid);
419 ri->mode = cpu_to_jemode(mode);
420 ret = jffs2_do_new_inode (c, f, mode, ri);
422 make_bad_inode(inode);
427 inode->i_ino = je32_to_cpu(ri->ino);
428 inode->i_mode = jemode_to_cpu(ri->mode);
429 inode->i_gid = je16_to_cpu(ri->gid);
430 inode->i_uid = je16_to_cpu(ri->uid);
431 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
432 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
434 inode->i_blksize = PAGE_SIZE;
438 insert_inode_hash(inode);
444 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
446 struct jffs2_sb_info *c;
447 struct inode *root_i;
451 c = JFFS2_SB_INFO(sb);
453 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
454 if (c->mtd->type == MTD_NANDFLASH) {
455 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
458 if (c->mtd->type == MTD_DATAFLASH) {
459 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
464 c->flash_size = c->mtd->size;
467 * Check, if we have to concatenate physical blocks to larger virtual blocks
468 * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
470 c->sector_size = c->mtd->erasesize;
471 blocks = c->flash_size / c->sector_size;
472 if (!(c->mtd->flags & MTD_NO_VIRTBLOCKS)) {
473 while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) {
475 c->sector_size <<= 1;
480 * Size alignment check
482 if ((c->sector_size * blocks) != c->flash_size) {
483 c->flash_size = c->sector_size * blocks;
484 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
485 c->flash_size / 1024);
488 if (c->sector_size != c->mtd->erasesize)
489 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
490 c->mtd->erasesize / 1024, c->sector_size / 1024);
492 if (c->flash_size < 5*c->sector_size) {
493 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
497 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
498 /* Joern -- stick alignment for weird 8-byte-page flash here */
500 /* NAND (or other bizarre) flash... do setup accordingly */
501 ret = jffs2_flash_setup(c);
505 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
506 if (!c->inocache_list) {
510 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
512 if ((ret = jffs2_do_mount_fs(c)))
517 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
518 root_i = iget(sb, 1);
519 if (is_bad_inode(root_i)) {
520 D1(printk(KERN_WARNING "get root inode failed\n"));
524 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
525 sb->s_root = d_alloc_root(root_i);
529 #if LINUX_VERSION_CODE >= 0x20403
530 sb->s_maxbytes = 0xFFFFFFFF;
532 sb->s_blocksize = PAGE_CACHE_SIZE;
533 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
534 sb->s_magic = JFFS2_SUPER_MAGIC;
535 if (!(sb->s_flags & MS_RDONLY))
536 jffs2_start_garbage_collect_thread(c);
542 jffs2_free_ino_caches(c);
543 jffs2_free_raw_node_refs(c);
544 if (c->mtd->flags & MTD_NO_VIRTBLOCKS)
549 kfree(c->inocache_list);
551 jffs2_flash_cleanup(c);
556 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
557 struct jffs2_inode_info *f)
559 iput(OFNI_EDONI_2SFFJ(f));
562 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
566 struct jffs2_inode_cache *ic;
568 /* The inode has zero nlink but its nodes weren't yet marked
569 obsolete. This has to be because we're still waiting for
570 the final (close() and) iput() to happen.
572 There's a possibility that the final iput() could have
573 happened while we were contemplating. In order to ensure
574 that we don't cause a new read_inode() (which would fail)
575 for the inode in question, we use ilookup() in this case
578 The nlink can't _become_ zero at this point because we're
579 holding the alloc_sem, and jffs2_do_unlink() would also
580 need that while decrementing nlink on any inode.
582 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
584 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
587 spin_lock(&c->inocache_lock);
588 ic = jffs2_get_ino_cache(c, inum);
590 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
591 spin_unlock(&c->inocache_lock);
594 if (ic->state != INO_STATE_CHECKEDABSENT) {
595 /* Wait for progress. Don't just loop */
596 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
597 ic->ino, ic->state));
598 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
600 spin_unlock(&c->inocache_lock);
606 /* Inode has links to it still; they're not going away because
607 jffs2_do_unlink() would need the alloc_sem and we have it.
608 Just iget() it, and if read_inode() is necessary that's OK.
610 inode = iget(OFNI_BS_2SFFJ(c), inum);
612 return ERR_PTR(-ENOMEM);
614 if (is_bad_inode(inode)) {
615 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
617 /* NB. This will happen again. We need to do something appropriate here. */
619 return ERR_PTR(-EIO);
622 return JFFS2_INODE_INFO(inode);
625 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
626 struct jffs2_inode_info *f,
627 unsigned long offset,
630 struct inode *inode = OFNI_EDONI_2SFFJ(f);
633 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
634 (void *)jffs2_do_readpage_unlock, inode);
638 *priv = (unsigned long)pg;
642 void jffs2_gc_release_page(struct jffs2_sb_info *c,
646 struct page *pg = (void *)*priv;
649 page_cache_release(pg);
652 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
655 if (jffs2_cleanmarker_oob(c)) {
656 /* NAND flash... do setup accordingly */
657 ret = jffs2_nand_flash_setup(c);
662 /* add setups for other bizarre flashes here... */
663 if (jffs2_nor_ecc(c)) {
664 ret = jffs2_nor_ecc_flash_setup(c);
670 if (jffs2_dataflash(c)) {
671 ret = jffs2_dataflash_setup(c);
679 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
681 if (jffs2_cleanmarker_oob(c)) {
682 jffs2_nand_flash_cleanup(c);
685 /* add cleanups for other bizarre flashes here... */
686 if (jffs2_nor_ecc(c)) {
687 jffs2_nor_ecc_flash_cleanup(c);
691 if (jffs2_dataflash(c)) {
692 jffs2_dataflash_cleanup(c);