2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@redhat.com>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: fs.c,v 1.32 2003/10/11 11:47:23 dwmw2 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/vfs.h>
24 #include <linux/crc32.h>
28 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
30 struct jffs2_full_dnode *old_metadata, *new_metadata;
31 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
32 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
33 struct jffs2_raw_inode *ri;
35 unsigned char *mdata = NULL;
38 uint32_t phys_ofs, alloclen;
40 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
41 ret = inode_change_ok(inode, iattr);
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 dev = old_encode_dev(inode->i_rdev);
54 mdatalen = sizeof(dev);
55 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
56 } else if (S_ISLNK(inode->i_mode)) {
57 mdatalen = f->metadata->size;
58 mdata = kmalloc(f->metadata->size, GFP_USER);
61 ret = jffs2_read_dnode(c, f->metadata, mdata, 0, mdatalen);
66 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
69 ri = jffs2_alloc_raw_inode();
71 if (S_ISLNK(inode->i_mode))
76 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
78 jffs2_free_raw_inode(ri);
79 if (S_ISLNK(inode->i_mode & S_IFMT))
84 ivalid = iattr->ia_valid;
86 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
87 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
88 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
89 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
91 ri->ino = cpu_to_je32(inode->i_ino);
92 ri->version = cpu_to_je32(++f->highest_version);
94 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
95 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
97 if (ivalid & ATTR_MODE)
98 if (iattr->ia_mode & S_ISGID &&
99 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
100 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
102 ri->mode = cpu_to_jemode(iattr->ia_mode);
104 ri->mode = cpu_to_jemode(inode->i_mode);
107 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
108 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
109 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
110 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
112 ri->offset = cpu_to_je32(0);
113 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
114 ri->compr = JFFS2_COMPR_NONE;
115 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
116 /* It's an extension. Make it a hole node */
117 ri->compr = JFFS2_COMPR_ZERO;
118 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
119 ri->offset = cpu_to_je32(inode->i_size);
121 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
123 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
125 ri->data_crc = cpu_to_je32(0);
127 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
128 if (S_ISLNK(inode->i_mode))
131 if (IS_ERR(new_metadata)) {
132 jffs2_complete_reservation(c);
133 jffs2_free_raw_inode(ri);
135 return PTR_ERR(new_metadata);
137 /* It worked. Update the inode */
138 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
139 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
140 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
141 inode->i_mode = jemode_to_cpu(ri->mode);
142 inode->i_uid = je16_to_cpu(ri->uid);
143 inode->i_gid = je16_to_cpu(ri->gid);
146 old_metadata = f->metadata;
148 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
149 vmtruncate(inode, iattr->ia_size);
150 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);
172 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
174 return jffs2_do_setattr(dentry->d_inode, iattr);
177 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
179 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
182 buf->f_type = JFFS2_SUPER_MAGIC;
183 buf->f_bsize = 1 << PAGE_SHIFT;
184 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
187 buf->f_namelen = JFFS2_MAX_NAME_LEN;
189 spin_lock(&c->erase_completion_lock);
191 avail = c->dirty_size + c->free_size;
192 if (avail > c->sector_size * c->resv_blocks_write)
193 avail -= c->sector_size * c->resv_blocks_write;
197 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
199 D1(jffs2_dump_block_lists(c));
201 spin_unlock(&c->erase_completion_lock);
207 void jffs2_clear_inode (struct inode *inode)
209 /* We can forget about this inode for now - drop all
210 * the nodelists associated with it, etc.
212 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
213 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
215 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
217 jffs2_do_clear_inode(c, f);
220 void jffs2_read_inode (struct inode *inode)
222 struct jffs2_inode_info *f;
223 struct jffs2_sb_info *c;
224 struct jffs2_raw_inode latest_node;
227 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
229 f = JFFS2_INODE_INFO(inode);
230 c = JFFS2_SB_INFO(inode->i_sb);
232 jffs2_init_inode_info(f);
234 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
237 make_bad_inode(inode);
241 inode->i_mode = jemode_to_cpu(latest_node.mode);
242 inode->i_uid = je16_to_cpu(latest_node.uid);
243 inode->i_gid = je16_to_cpu(latest_node.gid);
244 inode->i_size = je32_to_cpu(latest_node.isize);
245 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
246 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
247 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
249 inode->i_nlink = f->inocache->nlink;
251 inode->i_blksize = PAGE_SIZE;
252 inode->i_blocks = (inode->i_size + 511) >> 9;
254 switch (inode->i_mode & S_IFMT) {
258 inode->i_op = &jffs2_symlink_inode_operations;
263 struct jffs2_full_dirent *fd;
265 for (fd=f->dents; fd; fd = fd->next) {
266 if (fd->type == DT_DIR && fd->ino)
271 /* Root dir gets i_nlink 3 for some reason */
272 if (inode->i_ino == 1)
275 inode->i_op = &jffs2_dir_inode_operations;
276 inode->i_fop = &jffs2_dir_operations;
280 inode->i_op = &jffs2_file_inode_operations;
281 inode->i_fop = &jffs2_file_operations;
282 inode->i_mapping->a_ops = &jffs2_file_address_operations;
283 inode->i_mapping->nrpages = 0;
288 /* Read the device numbers from the media */
289 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
290 if (jffs2_read_dnode(c, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
292 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
294 jffs2_do_clear_inode(c, f);
295 make_bad_inode(inode);
301 inode->i_op = &jffs2_file_inode_operations;
302 init_special_inode(inode, inode->i_mode,
303 old_decode_dev((je16_to_cpu(rdev))));
307 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
312 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
315 void jffs2_dirty_inode(struct inode *inode)
319 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
320 D1(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
324 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
326 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
327 iattr.ia_mode = inode->i_mode;
328 iattr.ia_uid = inode->i_uid;
329 iattr.ia_gid = inode->i_gid;
330 iattr.ia_atime = inode->i_atime;
331 iattr.ia_mtime = inode->i_mtime;
332 iattr.ia_ctime = inode->i_ctime;
334 jffs2_do_setattr(inode, &iattr);
337 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
339 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
341 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
344 /* We stop if it was running, then restart if it needs to.
345 This also catches the case where it was stopped and this
346 is just a remount to restart it */
347 if (!(sb->s_flags & MS_RDONLY))
348 jffs2_stop_garbage_collect_thread(c);
350 if (!(*flags & MS_RDONLY))
351 jffs2_start_garbage_collect_thread(c);
353 *flags |= MS_NOATIME;
358 void jffs2_write_super (struct super_block *sb)
360 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
363 if (sb->s_flags & MS_RDONLY)
366 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
367 jffs2_garbage_collect_trigger(c);
368 jffs2_erase_pending_blocks(c);
369 jffs2_flush_wbuf_gc(c, 0);
373 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
374 fill in the raw_inode while you're at it. */
375 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
378 struct super_block *sb = dir_i->i_sb;
379 struct jffs2_sb_info *c;
380 struct jffs2_inode_info *f;
383 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
385 c = JFFS2_SB_INFO(sb);
387 inode = new_inode(sb);
390 return ERR_PTR(-ENOMEM);
392 f = JFFS2_INODE_INFO(inode);
393 jffs2_init_inode_info(f);
395 memset(ri, 0, sizeof(*ri));
396 /* Set OS-specific defaults for new inodes */
397 ri->uid = cpu_to_je16(current->fsuid);
399 if (dir_i->i_mode & S_ISGID) {
400 ri->gid = cpu_to_je16(dir_i->i_gid);
404 ri->gid = cpu_to_je16(current->fsgid);
406 ri->mode = cpu_to_jemode(mode);
407 ret = jffs2_do_new_inode (c, f, mode, ri);
409 make_bad_inode(inode);
414 inode->i_ino = je32_to_cpu(ri->ino);
415 inode->i_mode = jemode_to_cpu(ri->mode);
416 inode->i_gid = je16_to_cpu(ri->gid);
417 inode->i_uid = je16_to_cpu(ri->uid);
418 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
419 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
421 inode->i_blksize = PAGE_SIZE;
425 insert_inode_hash(inode);
431 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
433 struct jffs2_sb_info *c;
434 struct inode *root_i;
438 c = JFFS2_SB_INFO(sb);
440 c->flash_size = c->mtd->size;
443 * Check, if we have to concatenate physical blocks to larger virtual blocks
444 * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
446 blocks = c->flash_size / c->mtd->erasesize;
447 while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024))
450 c->sector_size = c->flash_size / blocks;
451 if (c->sector_size != c->mtd->erasesize)
452 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
453 c->mtd->erasesize / 1024, c->sector_size / 1024);
455 if (c->flash_size < 5*c->sector_size) {
456 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
460 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
461 /* Joern -- stick alignment for weird 8-byte-page flash here */
463 if (jffs2_cleanmarker_oob(c)) {
464 /* NAND (or other bizarre) flash... do setup accordingly */
465 ret = jffs2_nand_flash_setup(c);
470 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
471 if (!c->inocache_list) {
475 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
477 if ((ret = jffs2_do_mount_fs(c)))
482 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
483 root_i = iget(sb, 1);
484 if (is_bad_inode(root_i)) {
485 D1(printk(KERN_WARNING "get root inode failed\n"));
489 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
490 sb->s_root = d_alloc_root(root_i);
494 #if LINUX_VERSION_CODE >= 0x20403
495 sb->s_maxbytes = 0xFFFFFFFF;
497 sb->s_blocksize = PAGE_CACHE_SIZE;
498 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
499 sb->s_magic = JFFS2_SUPER_MAGIC;
500 if (!(sb->s_flags & MS_RDONLY))
501 jffs2_start_garbage_collect_thread(c);
507 jffs2_free_ino_caches(c);
508 jffs2_free_raw_node_refs(c);
511 kfree(c->inocache_list);
513 jffs2_nand_flash_cleanup(c);