blob: 2900ec3ec3afb79614a5479179880d0682dddf20 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
Artem B. Bityutskiy2f0077e2005-09-27 14:17:32 +010010 * $Id: fs.c,v 1.66 2005/09/27 13:17:29 dedekind Exp $
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
12 */
13
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080014#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/config.h>
16#include <linux/kernel.h>
17#include <linux/sched.h>
18#include <linux/fs.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>
26#include "nodelist.h"
27
28static int jffs2_flash_setup(struct jffs2_sb_info *c);
29
30static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
31{
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;
David Woodhouseaef9ab42006-05-19 00:28:49 +010036 union jffs2_device_node dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 unsigned char *mdata = NULL;
38 int mdatalen = 0;
39 unsigned int ivalid;
David Woodhouse9fe48542006-05-23 00:38:06 +010040 uint32_t alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 int ret;
42 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
43 ret = inode_change_ok(inode, iattr);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000044 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 return ret;
46
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 */
David Woodhouseaef9ab42006-05-19 00:28:49 +010054 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 mdata = (char *)&dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
57 } else if (S_ISLNK(inode->i_mode)) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010058 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 mdatalen = f->metadata->size;
60 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010061 if (!mdata) {
62 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
66 if (ret) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010067 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 kfree(mdata);
69 return ret;
70 }
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010071 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
73 }
74
75 ri = jffs2_alloc_raw_inode();
76 if (!ri) {
77 if (S_ISLNK(inode->i_mode))
78 kfree(mdata);
79 return -ENOMEM;
80 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000081
David Woodhouse9fe48542006-05-23 00:38:06 +010082 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
83 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 if (ret) {
85 jffs2_free_raw_inode(ri);
86 if (S_ISLNK(inode->i_mode & S_IFMT))
87 kfree(mdata);
88 return ret;
89 }
90 down(&f->sem);
91 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000092
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
94 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
95 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
96 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
97
98 ri->ino = cpu_to_je32(inode->i_ino);
99 ri->version = cpu_to_je32(++f->highest_version);
100
101 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
102 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
103
104 if (ivalid & ATTR_MODE)
105 if (iattr->ia_mode & S_ISGID &&
106 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
107 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000108 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 ri->mode = cpu_to_jemode(iattr->ia_mode);
110 else
111 ri->mode = cpu_to_jemode(inode->i_mode);
112
113
114 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
115 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
116 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
117 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
118
119 ri->offset = cpu_to_je32(0);
120 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
121 ri->compr = JFFS2_COMPR_NONE;
122 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
123 /* It's an extension. Make it a hole node */
124 ri->compr = JFFS2_COMPR_ZERO;
125 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
126 ri->offset = cpu_to_je32(inode->i_size);
127 }
128 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
129 if (mdatalen)
130 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
131 else
132 ri->data_crc = cpu_to_je32(0);
133
David Woodhouse9fe48542006-05-23 00:38:06 +0100134 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 if (S_ISLNK(inode->i_mode))
136 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 if (IS_ERR(new_metadata)) {
139 jffs2_complete_reservation(c);
140 jffs2_free_raw_inode(ri);
141 up(&f->sem);
142 return PTR_ERR(new_metadata);
143 }
144 /* It worked. Update the inode */
145 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
146 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
147 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
148 inode->i_mode = jemode_to_cpu(ri->mode);
149 inode->i_uid = je16_to_cpu(ri->uid);
150 inode->i_gid = je16_to_cpu(ri->gid);
151
152
153 old_metadata = f->metadata;
154
155 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100156 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
159 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
160 inode->i_size = iattr->ia_size;
161 f->metadata = NULL;
162 } else {
163 f->metadata = new_metadata;
164 }
165 if (old_metadata) {
166 jffs2_mark_node_obsolete(c, old_metadata->raw);
167 jffs2_free_full_dnode(old_metadata);
168 }
169 jffs2_free_raw_inode(ri);
170
171 up(&f->sem);
172 jffs2_complete_reservation(c);
173
174 /* We have to do the vmtruncate() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000175 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 We are protected from a simultaneous write() extending i_size
177 back past iattr->ia_size, because do_truncate() holds the
178 generic inode semaphore. */
179 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
180 vmtruncate(inode, iattr->ia_size);
181
182 return 0;
183}
184
185int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
186{
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900187 int rc;
188
189 rc = jffs2_do_setattr(dentry->d_inode, iattr);
190 if (!rc && (iattr->ia_valid & ATTR_MODE))
191 rc = jffs2_acl_chmod(dentry->d_inode);
192 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193}
194
David Howells726c3342006-06-23 02:02:58 -0700195int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
David Howells726c3342006-06-23 02:02:58 -0700197 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 unsigned long avail;
199
200 buf->f_type = JFFS2_SUPER_MAGIC;
201 buf->f_bsize = 1 << PAGE_SHIFT;
202 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
203 buf->f_files = 0;
204 buf->f_ffree = 0;
205 buf->f_namelen = JFFS2_MAX_NAME_LEN;
206
207 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 avail = c->dirty_size + c->free_size;
209 if (avail > c->sector_size * c->resv_blocks_write)
210 avail -= c->sector_size * c->resv_blocks_write;
211 else
212 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100213 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return 0;
218}
219
220
221void jffs2_clear_inode (struct inode *inode)
222{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000223 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 * the nodelists associated with it, etc.
225 */
226 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
227 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
230
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900231 jffs2_xattr_delete_inode(c, f->inocache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 jffs2_do_clear_inode(c, f);
233}
234
235void jffs2_read_inode (struct inode *inode)
236{
237 struct jffs2_inode_info *f;
238 struct jffs2_sb_info *c;
239 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100240 union jffs2_device_node jdev;
241 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 int ret;
243
244 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
245
246 f = JFFS2_INODE_INFO(inode);
247 c = JFFS2_SB_INFO(inode->i_sb);
248
249 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100250 down(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
253
254 if (ret) {
255 make_bad_inode(inode);
256 up(&f->sem);
257 return;
258 }
259 inode->i_mode = jemode_to_cpu(latest_node.mode);
260 inode->i_uid = je16_to_cpu(latest_node.uid);
261 inode->i_gid = je16_to_cpu(latest_node.gid);
262 inode->i_size = je32_to_cpu(latest_node.isize);
263 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
264 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
265 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
266
267 inode->i_nlink = f->inocache->nlink;
268
269 inode->i_blksize = PAGE_SIZE;
270 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 case S_IFLNK:
275 inode->i_op = &jffs2_symlink_inode_operations;
276 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 case S_IFDIR:
279 {
280 struct jffs2_full_dirent *fd;
281
282 for (fd=f->dents; fd; fd = fd->next) {
283 if (fd->type == DT_DIR && fd->ino)
284 inode->i_nlink++;
285 }
286 /* and '..' */
287 inode->i_nlink++;
288 /* Root dir gets i_nlink 3 for some reason */
289 if (inode->i_ino == 1)
290 inode->i_nlink++;
291
292 inode->i_op = &jffs2_dir_inode_operations;
293 inode->i_fop = &jffs2_dir_operations;
294 break;
295 }
296 case S_IFREG:
297 inode->i_op = &jffs2_file_inode_operations;
298 inode->i_fop = &jffs2_file_operations;
299 inode->i_mapping->a_ops = &jffs2_file_address_operations;
300 inode->i_mapping->nrpages = 0;
301 break;
302
303 case S_IFBLK:
304 case S_IFCHR:
305 /* Read the device numbers from the media */
David Woodhouseaef9ab42006-05-19 00:28:49 +0100306 if (f->metadata->size != sizeof(jdev.old) &&
307 f->metadata->size != sizeof(jdev.new)) {
308 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
309 up(&f->sem);
310 jffs2_do_clear_inode(c, f);
311 make_bad_inode(inode);
312 return;
313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100315 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 /* Eep */
317 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
318 up(&f->sem);
319 jffs2_do_clear_inode(c, f);
320 make_bad_inode(inode);
321 return;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000322 }
David Woodhouseaef9ab42006-05-19 00:28:49 +0100323 if (f->metadata->size == sizeof(jdev.old))
324 rdev = old_decode_dev(je16_to_cpu(jdev.old));
325 else
326 rdev = new_decode_dev(je32_to_cpu(jdev.new));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 case S_IFSOCK:
329 case S_IFIFO:
330 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100331 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 break;
333
334 default:
335 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
336 }
337
338 up(&f->sem);
339
340 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
341}
342
343void jffs2_dirty_inode(struct inode *inode)
344{
345 struct iattr iattr;
346
347 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
348 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
349 return;
350 }
351
352 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
353
354 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
355 iattr.ia_mode = inode->i_mode;
356 iattr.ia_uid = inode->i_uid;
357 iattr.ia_gid = inode->i_gid;
358 iattr.ia_atime = inode->i_atime;
359 iattr.ia_mtime = inode->i_mtime;
360 iattr.ia_ctime = inode->i_ctime;
361
362 jffs2_do_setattr(inode, &iattr);
363}
364
365int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
366{
367 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
368
369 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
370 return -EROFS;
371
372 /* We stop if it was running, then restart if it needs to.
373 This also catches the case where it was stopped and this
374 is just a remount to restart it.
375 Flush the writebuffer, if neccecary, else we loose it */
376 if (!(sb->s_flags & MS_RDONLY)) {
377 jffs2_stop_garbage_collect_thread(c);
378 down(&c->alloc_sem);
379 jffs2_flush_wbuf_pad(c);
380 up(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000381 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 if (!(*flags & MS_RDONLY))
384 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 *flags |= MS_NOATIME;
387
388 return 0;
389}
390
391void jffs2_write_super (struct super_block *sb)
392{
393 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
394 sb->s_dirt = 0;
395
396 if (sb->s_flags & MS_RDONLY)
397 return;
398
399 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
400 jffs2_garbage_collect_trigger(c);
401 jffs2_erase_pending_blocks(c, 0);
402 jffs2_flush_wbuf_gc(c, 0);
403}
404
405
406/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
407 fill in the raw_inode while you're at it. */
408struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
409{
410 struct inode *inode;
411 struct super_block *sb = dir_i->i_sb;
412 struct jffs2_sb_info *c;
413 struct jffs2_inode_info *f;
414 int ret;
415
416 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
417
418 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000421
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 if (!inode)
423 return ERR_PTR(-ENOMEM);
424
425 f = JFFS2_INODE_INFO(inode);
426 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100427 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429 memset(ri, 0, sizeof(*ri));
430 /* Set OS-specific defaults for new inodes */
431 ri->uid = cpu_to_je16(current->fsuid);
432
433 if (dir_i->i_mode & S_ISGID) {
434 ri->gid = cpu_to_je16(dir_i->i_gid);
435 if (S_ISDIR(mode))
436 mode |= S_ISGID;
437 } else {
438 ri->gid = cpu_to_je16(current->fsgid);
439 }
440 ri->mode = cpu_to_jemode(mode);
441 ret = jffs2_do_new_inode (c, f, mode, ri);
442 if (ret) {
443 make_bad_inode(inode);
444 iput(inode);
445 return ERR_PTR(ret);
446 }
447 inode->i_nlink = 1;
448 inode->i_ino = je32_to_cpu(ri->ino);
449 inode->i_mode = jemode_to_cpu(ri->mode);
450 inode->i_gid = je16_to_cpu(ri->gid);
451 inode->i_uid = je16_to_cpu(ri->uid);
452 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
453 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
454
455 inode->i_blksize = PAGE_SIZE;
456 inode->i_blocks = 0;
457 inode->i_size = 0;
458
459 insert_inode_hash(inode);
460
461 return inode;
462}
463
464
465int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
466{
467 struct jffs2_sb_info *c;
468 struct inode *root_i;
469 int ret;
470 size_t blocks;
471
472 c = JFFS2_SB_INFO(sb);
473
Andrew Victor2f82ce12005-02-09 09:24:26 +0000474#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 if (c->mtd->type == MTD_NANDFLASH) {
476 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
477 return -EINVAL;
478 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000479 if (c->mtd->type == MTD_DATAFLASH) {
480 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
481 return -EINVAL;
482 }
483#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000486 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 /*
490 * Size alignment check
491 */
492 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000493 c->flash_size = c->sector_size * blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
495 c->flash_size / 1024);
496 }
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 if (c->flash_size < 5*c->sector_size) {
499 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
500 return -EINVAL;
501 }
502
503 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 /* NAND (or other bizarre) flash... do setup accordingly */
506 ret = jffs2_flash_setup(c);
507 if (ret)
508 return ret;
509
510 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
511 if (!c->inocache_list) {
512 ret = -ENOMEM;
513 goto out_wbuf;
514 }
515 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
516
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900517 jffs2_init_xattr_subsystem(c);
518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 if ((ret = jffs2_do_mount_fs(c)))
520 goto out_inohash;
521
522 ret = -EINVAL;
523
524 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
525 root_i = iget(sb, 1);
526 if (is_bad_inode(root_i)) {
527 D1(printk(KERN_WARNING "get root inode failed\n"));
Artem B. Bityutskiy6dac02a2005-07-18 12:21:23 +0100528 goto out_root_i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 }
530
531 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
532 sb->s_root = d_alloc_root(root_i);
533 if (!sb->s_root)
534 goto out_root_i;
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 sb->s_blocksize = PAGE_CACHE_SIZE;
538 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
539 sb->s_magic = JFFS2_SUPER_MAGIC;
540 if (!(sb->s_flags & MS_RDONLY))
541 jffs2_start_garbage_collect_thread(c);
542 return 0;
543
544 out_root_i:
545 iput(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 jffs2_free_ino_caches(c);
547 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100548 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 vfree(c->blocks);
550 else
551 kfree(c->blocks);
552 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900553 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 kfree(c->inocache_list);
555 out_wbuf:
556 jffs2_flash_cleanup(c);
557
558 return ret;
559}
560
561void jffs2_gc_release_inode(struct jffs2_sb_info *c,
562 struct jffs2_inode_info *f)
563{
564 iput(OFNI_EDONI_2SFFJ(f));
565}
566
567struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
568 int inum, int nlink)
569{
570 struct inode *inode;
571 struct jffs2_inode_cache *ic;
572 if (!nlink) {
573 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000574 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 the final (close() and) iput() to happen.
576
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000577 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 happened while we were contemplating. In order to ensure
579 that we don't cause a new read_inode() (which would fail)
580 for the inode in question, we use ilookup() in this case
581 instead of iget().
582
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000583 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 holding the alloc_sem, and jffs2_do_unlink() would also
585 need that while decrementing nlink on any inode.
586 */
587 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
588 if (!inode) {
589 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
590 inum));
591
592 spin_lock(&c->inocache_lock);
593 ic = jffs2_get_ino_cache(c, inum);
594 if (!ic) {
595 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
596 spin_unlock(&c->inocache_lock);
597 return NULL;
598 }
599 if (ic->state != INO_STATE_CHECKEDABSENT) {
600 /* Wait for progress. Don't just loop */
601 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
602 ic->ino, ic->state));
603 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
604 } else {
605 spin_unlock(&c->inocache_lock);
606 }
607
608 return NULL;
609 }
610 } else {
611 /* Inode has links to it still; they're not going away because
612 jffs2_do_unlink() would need the alloc_sem and we have it.
613 Just iget() it, and if read_inode() is necessary that's OK.
614 */
615 inode = iget(OFNI_BS_2SFFJ(c), inum);
616 if (!inode)
617 return ERR_PTR(-ENOMEM);
618 }
619 if (is_bad_inode(inode)) {
620 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
621 inum, nlink);
622 /* NB. This will happen again. We need to do something appropriate here. */
623 iput(inode);
624 return ERR_PTR(-EIO);
625 }
626
627 return JFFS2_INODE_INFO(inode);
628}
629
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000630unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
631 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 unsigned long offset,
633 unsigned long *priv)
634{
635 struct inode *inode = OFNI_EDONI_2SFFJ(f);
636 struct page *pg;
637
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000638 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 (void *)jffs2_do_readpage_unlock, inode);
640 if (IS_ERR(pg))
641 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 *priv = (unsigned long)pg;
644 return kmap(pg);
645}
646
647void jffs2_gc_release_page(struct jffs2_sb_info *c,
648 unsigned char *ptr,
649 unsigned long *priv)
650{
651 struct page *pg = (void *)*priv;
652
653 kunmap(pg);
654 page_cache_release(pg);
655}
656
657static int jffs2_flash_setup(struct jffs2_sb_info *c) {
658 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 if (jffs2_cleanmarker_oob(c)) {
661 /* NAND flash... do setup accordingly */
662 ret = jffs2_nand_flash_setup(c);
663 if (ret)
664 return ret;
665 }
666
Andrew Victor8f15fd52005-02-09 09:17:45 +0000667 /* and Dataflash */
668 if (jffs2_dataflash(c)) {
669 ret = jffs2_dataflash_setup(c);
670 if (ret)
671 return ret;
672 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100673
674 /* and Intel "Sibley" flash */
675 if (jffs2_nor_wbuf_flash(c)) {
676 ret = jffs2_nor_wbuf_flash_setup(c);
677 if (ret)
678 return ret;
679 }
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 return ret;
682}
683
684void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
685
686 if (jffs2_cleanmarker_oob(c)) {
687 jffs2_nand_flash_cleanup(c);
688 }
689
Andrew Victor8f15fd52005-02-09 09:17:45 +0000690 /* and DataFlash */
691 if (jffs2_dataflash(c)) {
692 jffs2_dataflash_cleanup(c);
693 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100694
695 /* and Intel "Sibley" flash */
696 if (jffs2_nor_wbuf_flash(c)) {
697 jffs2_nor_wbuf_flash_cleanup(c);
698 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699}