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/config.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
18 #include <linux/list.h>
19 #include <linux/mtd/mtd.h>
20 #include <linux/pagemap.h>
21 #include <linux/slab.h>
22 #include <linux/vmalloc.h>
23 #include <linux/vfs.h>
24 #include <linux/crc32.h>
27 static int jffs2_flash_setup(struct jffs2_sb_info *c);
29 static 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;
36 unsigned char *mdata = NULL;
39 uint32_t phys_ofs, alloclen;
41 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
42 ret = inode_change_ok(inode, iattr);
46 /* Special cases - we don't want more than one data node
47 for these types on the medium at any time. So setattr
48 must read the original data associated with the node
49 (i.e. the device numbers or the target name) and write
50 it out again with the appropriate data attached */
51 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
52 /* For these, we don't actually need to read the old node */
53 dev = old_encode_dev(inode->i_rdev);
55 mdatalen = sizeof(dev);
56 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
57 } else if (S_ISLNK(inode->i_mode)) {
58 mdatalen = f->metadata->size;
59 mdata = kmalloc(f->metadata->size, GFP_USER);
62 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, &phys_ofs, &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, 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_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)
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);
198 avail = c->dirty_size + c->free_size;
199 if (avail > c->sector_size * c->resv_blocks_write)
200 avail -= c->sector_size * c->resv_blocks_write;
203 spin_unlock(&c->erase_completion_lock);
205 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
211 void jffs2_clear_inode (struct inode *inode)
213 /* We can forget about this inode for now - drop all
214 * the nodelists associated with it, etc.
216 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
217 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
219 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
221 jffs2_do_clear_inode(c, f);
224 void jffs2_read_inode (struct inode *inode)
226 struct jffs2_inode_info *f;
227 struct jffs2_sb_info *c;
228 struct jffs2_raw_inode latest_node;
231 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
233 f = JFFS2_INODE_INFO(inode);
234 c = JFFS2_SB_INFO(inode->i_sb);
236 jffs2_init_inode_info(f);
238 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
241 make_bad_inode(inode);
245 inode->i_mode = jemode_to_cpu(latest_node.mode);
246 inode->i_uid = je16_to_cpu(latest_node.uid);
247 inode->i_gid = je16_to_cpu(latest_node.gid);
248 inode->i_size = je32_to_cpu(latest_node.isize);
249 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
250 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
251 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
253 inode->i_nlink = f->inocache->nlink;
255 inode->i_blksize = PAGE_SIZE;
256 inode->i_blocks = (inode->i_size + 511) >> 9;
258 switch (inode->i_mode & S_IFMT) {
262 inode->i_op = &jffs2_symlink_inode_operations;
267 struct jffs2_full_dirent *fd;
269 for (fd=f->dents; fd; fd = fd->next) {
270 if (fd->type == DT_DIR && fd->ino)
275 /* Root dir gets i_nlink 3 for some reason */
276 if (inode->i_ino == 1)
279 inode->i_op = &jffs2_dir_inode_operations;
280 inode->i_fop = &jffs2_dir_operations;
284 inode->i_op = &jffs2_file_inode_operations;
285 inode->i_fop = &jffs2_file_operations;
286 inode->i_mapping->a_ops = &jffs2_file_address_operations;
287 inode->i_mapping->nrpages = 0;
292 /* Read the device numbers from the media */
293 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
294 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
296 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
298 jffs2_do_clear_inode(c, f);
299 make_bad_inode(inode);
305 inode->i_op = &jffs2_file_inode_operations;
306 init_special_inode(inode, inode->i_mode,
307 old_decode_dev((je16_to_cpu(rdev))));
311 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
316 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
319 void jffs2_dirty_inode(struct inode *inode)
323 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
324 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
328 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
330 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
331 iattr.ia_mode = inode->i_mode;
332 iattr.ia_uid = inode->i_uid;
333 iattr.ia_gid = inode->i_gid;
334 iattr.ia_atime = inode->i_atime;
335 iattr.ia_mtime = inode->i_mtime;
336 iattr.ia_ctime = inode->i_ctime;
338 jffs2_do_setattr(inode, &iattr);
341 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
343 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
345 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
348 /* We stop if it was running, then restart if it needs to.
349 This also catches the case where it was stopped and this
350 is just a remount to restart it.
351 Flush the writebuffer, if neccecary, else we loose it */
352 if (!(sb->s_flags & MS_RDONLY)) {
353 jffs2_stop_garbage_collect_thread(c);
355 jffs2_flush_wbuf_pad(c);
359 if (!(*flags & MS_RDONLY))
360 jffs2_start_garbage_collect_thread(c);
362 *flags |= MS_NOATIME;
367 void jffs2_write_super (struct super_block *sb)
369 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
372 if (sb->s_flags & MS_RDONLY)
375 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
376 jffs2_garbage_collect_trigger(c);
377 jffs2_erase_pending_blocks(c, 0);
378 jffs2_flush_wbuf_gc(c, 0);
382 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
383 fill in the raw_inode while you're at it. */
384 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
387 struct super_block *sb = dir_i->i_sb;
388 struct jffs2_sb_info *c;
389 struct jffs2_inode_info *f;
392 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
394 c = JFFS2_SB_INFO(sb);
396 inode = new_inode(sb);
399 return ERR_PTR(-ENOMEM);
401 f = JFFS2_INODE_INFO(inode);
402 jffs2_init_inode_info(f);
404 memset(ri, 0, sizeof(*ri));
405 /* Set OS-specific defaults for new inodes */
406 ri->uid = cpu_to_je16(current->fsuid);
408 if (dir_i->i_mode & S_ISGID) {
409 ri->gid = cpu_to_je16(dir_i->i_gid);
413 ri->gid = cpu_to_je16(current->fsgid);
415 ri->mode = cpu_to_jemode(mode);
416 ret = jffs2_do_new_inode (c, f, mode, ri);
418 make_bad_inode(inode);
423 inode->i_ino = je32_to_cpu(ri->ino);
424 inode->i_mode = jemode_to_cpu(ri->mode);
425 inode->i_gid = je16_to_cpu(ri->gid);
426 inode->i_uid = je16_to_cpu(ri->uid);
427 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
428 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
430 inode->i_blksize = PAGE_SIZE;
434 insert_inode_hash(inode);
440 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
442 struct jffs2_sb_info *c;
443 struct inode *root_i;
447 c = JFFS2_SB_INFO(sb);
449 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
450 if (c->mtd->type == MTD_NANDFLASH) {
451 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
454 if (c->mtd->type == MTD_DATAFLASH) {
455 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
460 c->flash_size = c->mtd->size;
461 c->sector_size = c->mtd->erasesize;
462 blocks = c->flash_size / c->sector_size;
465 * Size alignment check
467 if ((c->sector_size * blocks) != c->flash_size) {
468 c->flash_size = c->sector_size * blocks;
469 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
470 c->flash_size / 1024);
473 if (c->flash_size < 5*c->sector_size) {
474 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
478 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
480 /* NAND (or other bizarre) flash... do setup accordingly */
481 ret = jffs2_flash_setup(c);
485 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
486 if (!c->inocache_list) {
490 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
492 if ((ret = jffs2_do_mount_fs(c)))
497 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
498 root_i = iget(sb, 1);
499 if (is_bad_inode(root_i)) {
500 D1(printk(KERN_WARNING "get root inode failed\n"));
504 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
505 sb->s_root = d_alloc_root(root_i);
509 sb->s_maxbytes = 0xFFFFFFFF;
510 sb->s_blocksize = PAGE_CACHE_SIZE;
511 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
512 sb->s_magic = JFFS2_SUPER_MAGIC;
513 if (!(sb->s_flags & MS_RDONLY))
514 jffs2_start_garbage_collect_thread(c);
519 jffs2_free_ino_caches(c);
520 jffs2_free_raw_node_refs(c);
521 if (jffs2_blocks_use_vmalloc(c))
526 kfree(c->inocache_list);
528 jffs2_flash_cleanup(c);
533 void jffs2_gc_release_inode(struct jffs2_sb_info *c,
534 struct jffs2_inode_info *f)
536 iput(OFNI_EDONI_2SFFJ(f));
539 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
543 struct jffs2_inode_cache *ic;
545 /* The inode has zero nlink but its nodes weren't yet marked
546 obsolete. This has to be because we're still waiting for
547 the final (close() and) iput() to happen.
549 There's a possibility that the final iput() could have
550 happened while we were contemplating. In order to ensure
551 that we don't cause a new read_inode() (which would fail)
552 for the inode in question, we use ilookup() in this case
555 The nlink can't _become_ zero at this point because we're
556 holding the alloc_sem, and jffs2_do_unlink() would also
557 need that while decrementing nlink on any inode.
559 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
561 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
564 spin_lock(&c->inocache_lock);
565 ic = jffs2_get_ino_cache(c, inum);
567 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
568 spin_unlock(&c->inocache_lock);
571 if (ic->state != INO_STATE_CHECKEDABSENT) {
572 /* Wait for progress. Don't just loop */
573 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
574 ic->ino, ic->state));
575 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
577 spin_unlock(&c->inocache_lock);
583 /* Inode has links to it still; they're not going away because
584 jffs2_do_unlink() would need the alloc_sem and we have it.
585 Just iget() it, and if read_inode() is necessary that's OK.
587 inode = iget(OFNI_BS_2SFFJ(c), inum);
589 return ERR_PTR(-ENOMEM);
591 if (is_bad_inode(inode)) {
592 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
594 /* NB. This will happen again. We need to do something appropriate here. */
596 return ERR_PTR(-EIO);
599 return JFFS2_INODE_INFO(inode);
602 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
603 struct jffs2_inode_info *f,
604 unsigned long offset,
607 struct inode *inode = OFNI_EDONI_2SFFJ(f);
610 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
611 (void *)jffs2_do_readpage_unlock, inode);
615 *priv = (unsigned long)pg;
619 void jffs2_gc_release_page(struct jffs2_sb_info *c,
623 struct page *pg = (void *)*priv;
626 page_cache_release(pg);
629 static int jffs2_flash_setup(struct jffs2_sb_info *c) {
632 if (jffs2_cleanmarker_oob(c)) {
633 /* NAND flash... do setup accordingly */
634 ret = jffs2_nand_flash_setup(c);
639 /* add setups for other bizarre flashes here... */
640 if (jffs2_nor_ecc(c)) {
641 ret = jffs2_nor_ecc_flash_setup(c);
647 if (jffs2_dataflash(c)) {
648 ret = jffs2_dataflash_setup(c);
653 /* and Intel "Sibley" flash */
654 if (jffs2_nor_wbuf_flash(c)) {
655 ret = jffs2_nor_wbuf_flash_setup(c);
663 void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
665 if (jffs2_cleanmarker_oob(c)) {
666 jffs2_nand_flash_cleanup(c);
669 /* add cleanups for other bizarre flashes here... */
670 if (jffs2_nor_ecc(c)) {
671 jffs2_nor_ecc_flash_cleanup(c);
675 if (jffs2_dataflash(c)) {
676 jffs2_dataflash_cleanup(c);
679 /* and Intel "Sibley" flash */
680 if (jffs2_nor_wbuf_flash(c)) {
681 jffs2_nor_wbuf_flash_cleanup(c);