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)
188 return jffs2_do_setattr(dentry->d_inode, iattr);
191 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
193 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
196 buf->f_type = JFFS2_SUPER_MAGIC;
197 buf->f_bsize = 1 << PAGE_SHIFT;
198 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
201 buf->f_namelen = JFFS2_MAX_NAME_LEN;
203 spin_lock(&c->erase_completion_lock);
204 avail = c->dirty_size + c->free_size;
205 if (avail > c->sector_size * c->resv_blocks_write)
206 avail -= c->sector_size * c->resv_blocks_write;
209 spin_unlock(&c->erase_completion_lock);
211 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
217 void jffs2_clear_inode (struct inode *inode)
219 /* We can forget about this inode for now - drop all
220 * the nodelists associated with it, etc.
222 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
223 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
225 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
227 jffs2_do_clear_inode(c, f);
230 void jffs2_read_inode (struct inode *inode)
232 struct jffs2_inode_info *f;
233 struct jffs2_sb_info *c;
234 struct jffs2_raw_inode latest_node;
237 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
239 f = JFFS2_INODE_INFO(inode);
240 c = JFFS2_SB_INFO(inode->i_sb);
242 jffs2_init_inode_info(f);
245 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
248 make_bad_inode(inode);
252 inode->i_mode = jemode_to_cpu(latest_node.mode);
253 inode->i_uid = je16_to_cpu(latest_node.uid);
254 inode->i_gid = je16_to_cpu(latest_node.gid);
255 inode->i_size = je32_to_cpu(latest_node.isize);
256 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
257 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
258 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
260 inode->i_nlink = f->inocache->nlink;
262 inode->i_blksize = PAGE_SIZE;
263 inode->i_blocks = (inode->i_size + 511) >> 9;
265 switch (inode->i_mode & S_IFMT) {
269 inode->i_op = &jffs2_symlink_inode_operations;
274 struct jffs2_full_dirent *fd;
276 for (fd=f->dents; fd; fd = fd->next) {
277 if (fd->type == DT_DIR && fd->ino)
282 /* Root dir gets i_nlink 3 for some reason */
283 if (inode->i_ino == 1)
286 inode->i_op = &jffs2_dir_inode_operations;
287 inode->i_fop = &jffs2_dir_operations;
291 inode->i_op = &jffs2_file_inode_operations;
292 inode->i_fop = &jffs2_file_operations;
293 inode->i_mapping->a_ops = &jffs2_file_address_operations;
294 inode->i_mapping->nrpages = 0;
299 /* Read the device numbers from the media */
300 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
301 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
303 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
305 jffs2_do_clear_inode(c, f);
306 make_bad_inode(inode);
312 inode->i_op = &jffs2_file_inode_operations;
313 init_special_inode(inode, inode->i_mode,
314 old_decode_dev((je16_to_cpu(rdev))));
318 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
323 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
326 void jffs2_dirty_inode(struct inode *inode)
330 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
331 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
335 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
337 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
338 iattr.ia_mode = inode->i_mode;
339 iattr.ia_uid = inode->i_uid;
340 iattr.ia_gid = inode->i_gid;
341 iattr.ia_atime = inode->i_atime;
342 iattr.ia_mtime = inode->i_mtime;
343 iattr.ia_ctime = inode->i_ctime;
345 jffs2_do_setattr(inode, &iattr);
348 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
350 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
352 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
355 /* We stop if it was running, then restart if it needs to.
356 This also catches the case where it was stopped and this
357 is just a remount to restart it.
358 Flush the writebuffer, if neccecary, else we loose it */
359 if (!(sb->s_flags & MS_RDONLY)) {
360 jffs2_stop_garbage_collect_thread(c);
362 jffs2_flush_wbuf_pad(c);
366 if (!(*flags & MS_RDONLY))
367 jffs2_start_garbage_collect_thread(c);
369 *flags |= MS_NOATIME;
374 void jffs2_write_super (struct super_block *sb)
376 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
379 if (sb->s_flags & MS_RDONLY)
382 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
383 jffs2_garbage_collect_trigger(c);
384 jffs2_erase_pending_blocks(c, 0);
385 jffs2_flush_wbuf_gc(c, 0);
389 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
390 fill in the raw_inode while you're at it. */
391 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
394 struct super_block *sb = dir_i->i_sb;
395 struct jffs2_sb_info *c;
396 struct jffs2_inode_info *f;
399 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
401 c = JFFS2_SB_INFO(sb);
403 inode = new_inode(sb);
406 return ERR_PTR(-ENOMEM);
408 f = JFFS2_INODE_INFO(inode);
409 jffs2_init_inode_info(f);
412 memset(ri, 0, sizeof(*ri));
413 /* Set OS-specific defaults for new inodes */
414 ri->uid = cpu_to_je16(current->fsuid);
416 if (dir_i->i_mode & S_ISGID) {
417 ri->gid = cpu_to_je16(dir_i->i_gid);
421 ri->gid = cpu_to_je16(current->fsgid);
423 ri->mode = cpu_to_jemode(mode);
424 ret = jffs2_do_new_inode (c, f, mode, ri);
426 make_bad_inode(inode);
431 inode->i_ino = je32_to_cpu(ri->ino);
432 inode->i_mode = jemode_to_cpu(ri->mode);
433 inode->i_gid = je16_to_cpu(ri->gid);
434 inode->i_uid = je16_to_cpu(ri->uid);
435 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
436 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
438 inode->i_blksize = PAGE_SIZE;
442 insert_inode_hash(inode);
448 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
450 struct jffs2_sb_info *c;
451 struct inode *root_i;
455 c = JFFS2_SB_INFO(sb);
457 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
458 if (c->mtd->type == MTD_NANDFLASH) {
459 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
462 if (c->mtd->type == MTD_DATAFLASH) {
463 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
468 c->flash_size = c->mtd->size;
469 c->sector_size = c->mtd->erasesize;
470 blocks = c->flash_size / c->sector_size;
473 * Size alignment check
475 if ((c->sector_size * blocks) != c->flash_size) {
476 c->flash_size = c->sector_size * blocks;
477 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
478 c->flash_size / 1024);
481 if (c->flash_size < 5*c->sector_size) {
482 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
486 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
488 /* NAND (or other bizarre) flash... do setup accordingly */
489 ret = jffs2_flash_setup(c);
493 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
494 if (!c->inocache_list) {
498 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
500 if ((ret = jffs2_do_mount_fs(c)))
505 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
506 root_i = iget(sb, 1);
507 if (is_bad_inode(root_i)) {
508 D1(printk(KERN_WARNING "get root inode failed\n"));
512 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
513 sb->s_root = d_alloc_root(root_i);
517 sb->s_maxbytes = 0xFFFFFFFF;
518 sb->s_blocksize = PAGE_CACHE_SIZE;
519 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
520 sb->s_magic = JFFS2_SUPER_MAGIC;
521 if (!(sb->s_flags & MS_RDONLY))
522 jffs2_start_garbage_collect_thread(c);
527 jffs2_free_ino_caches(c);
528 jffs2_free_raw_node_refs(c);
529 if (jffs2_blocks_use_vmalloc(c))
534 kfree(c->inocache_list);
536 jffs2_flash_cleanup(c);
541 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
542 struct jffs2_inode_info *f)
544 iput(OFNI_EDONI_2SFFJ(f));
547 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
551 struct jffs2_inode_cache *ic;
553 /* The inode has zero nlink but its nodes weren't yet marked
554 obsolete. This has to be because we're still waiting for
555 the final (close() and) iput() to happen.
557 There's a possibility that the final iput() could have
558 happened while we were contemplating. In order to ensure
559 that we don't cause a new read_inode() (which would fail)
560 for the inode in question, we use ilookup() in this case
563 The nlink can't _become_ zero at this point because we're
564 holding the alloc_sem, and jffs2_do_unlink() would also
565 need that while decrementing nlink on any inode.
567 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
569 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
572 spin_lock(&c->inocache_lock);
573 ic = jffs2_get_ino_cache(c, inum);
575 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
576 spin_unlock(&c->inocache_lock);
579 if (ic->state != INO_STATE_CHECKEDABSENT) {
580 /* Wait for progress. Don't just loop */
581 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
582 ic->ino, ic->state));
583 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
585 spin_unlock(&c->inocache_lock);
591 /* Inode has links to it still; they're not going away because
592 jffs2_do_unlink() would need the alloc_sem and we have it.
593 Just iget() it, and if read_inode() is necessary that's OK.
595 inode = iget(OFNI_BS_2SFFJ(c), inum);
597 return ERR_PTR(-ENOMEM);
599 if (is_bad_inode(inode)) {
600 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
602 /* NB. This will happen again. We need to do something appropriate here. */
604 return ERR_PTR(-EIO);
607 return JFFS2_INODE_INFO(inode);
610 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
611 struct jffs2_inode_info *f,
612 unsigned long offset,
615 struct inode *inode = OFNI_EDONI_2SFFJ(f);
618 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
619 (void *)jffs2_do_readpage_unlock, inode);
623 *priv = (unsigned long)pg;
627 void jffs2_gc_release_page(struct jffs2_sb_info *c,
631 struct page *pg = (void *)*priv;
634 page_cache_release(pg);
637 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
640 if (jffs2_cleanmarker_oob(c)) {
641 /* NAND flash... do setup accordingly */
642 ret = jffs2_nand_flash_setup(c);
647 /* add setups for other bizarre flashes here... */
648 if (jffs2_nor_ecc(c)) {
649 ret = jffs2_nor_ecc_flash_setup(c);
655 if (jffs2_dataflash(c)) {
656 ret = jffs2_dataflash_setup(c);
661 /* and Intel "Sibley" flash */
662 if (jffs2_nor_wbuf_flash(c)) {
663 ret = jffs2_nor_wbuf_flash_setup(c);
671 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
673 if (jffs2_cleanmarker_oob(c)) {
674 jffs2_nand_flash_cleanup(c);
677 /* add cleanups for other bizarre flashes here... */
678 if (jffs2_nor_ecc(c)) {
679 jffs2_nor_ecc_flash_cleanup(c);
683 if (jffs2_dataflash(c)) {
684 jffs2_dataflash_cleanup(c);
687 /* and Intel "Sibley" flash */
688 if (jffs2_nor_wbuf_flash(c)) {
689 jffs2_nor_wbuf_flash_cleanup(c);