blob: 8bc727b7169627713dd3fa89c5ee38d50cb521d9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
David Woodhousec00c3102007-04-25 14:16:47 +01004 * Copyright © 2001-2007 Red Hat, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 */
11
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080012#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/kernel.h>
14#include <linux/sched.h>
15#include <linux/fs.h>
16#include <linux/list.h>
17#include <linux/mtd/mtd.h>
18#include <linux/pagemap.h>
19#include <linux/slab.h>
20#include <linux/vmalloc.h>
21#include <linux/vfs.h>
22#include <linux/crc32.h>
23#include "nodelist.h"
24
25static int jffs2_flash_setup(struct jffs2_sb_info *c);
26
27static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
28{
29 struct jffs2_full_dnode *old_metadata, *new_metadata;
30 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
31 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
32 struct jffs2_raw_inode *ri;
David Woodhouseaef9ab42006-05-19 00:28:49 +010033 union jffs2_device_node dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 unsigned char *mdata = NULL;
35 int mdatalen = 0;
36 unsigned int ivalid;
David Woodhouse9fe48542006-05-23 00:38:06 +010037 uint32_t alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 int ret;
39 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
40 ret = inode_change_ok(inode, iattr);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000041 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 return ret;
43
44 /* Special cases - we don't want more than one data node
45 for these types on the medium at any time. So setattr
46 must read the original data associated with the node
47 (i.e. the device numbers or the target name) and write
48 it out again with the appropriate data attached */
49 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
50 /* For these, we don't actually need to read the old node */
David Woodhouseaef9ab42006-05-19 00:28:49 +010051 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 mdata = (char *)&dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
54 } else if (S_ISLNK(inode->i_mode)) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010055 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 mdatalen = f->metadata->size;
57 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010058 if (!mdata) {
59 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010061 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
63 if (ret) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010064 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 kfree(mdata);
66 return ret;
67 }
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010068 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
70 }
71
72 ri = jffs2_alloc_raw_inode();
73 if (!ri) {
74 if (S_ISLNK(inode->i_mode))
75 kfree(mdata);
76 return -ENOMEM;
77 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000078
David Woodhouse9fe48542006-05-23 00:38:06 +010079 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
80 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 if (ret) {
82 jffs2_free_raw_inode(ri);
83 if (S_ISLNK(inode->i_mode & S_IFMT))
84 kfree(mdata);
85 return ret;
86 }
87 down(&f->sem);
88 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
91 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
92 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
93 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
94
95 ri->ino = cpu_to_je32(inode->i_ino);
96 ri->version = cpu_to_je32(++f->highest_version);
97
98 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
99 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
100
101 if (ivalid & ATTR_MODE)
102 if (iattr->ia_mode & S_ISGID &&
103 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
104 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000105 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 ri->mode = cpu_to_jemode(iattr->ia_mode);
107 else
108 ri->mode = cpu_to_jemode(inode->i_mode);
109
110
111 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
112 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
113 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
114 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
115
116 ri->offset = cpu_to_je32(0);
117 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
118 ri->compr = JFFS2_COMPR_NONE;
119 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
120 /* It's an extension. Make it a hole node */
121 ri->compr = JFFS2_COMPR_ZERO;
122 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
123 ri->offset = cpu_to_je32(inode->i_size);
124 }
125 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
126 if (mdatalen)
127 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
128 else
129 ri->data_crc = cpu_to_je32(0);
130
David Woodhouse9fe48542006-05-23 00:38:06 +0100131 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 if (S_ISLNK(inode->i_mode))
133 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 if (IS_ERR(new_metadata)) {
136 jffs2_complete_reservation(c);
137 jffs2_free_raw_inode(ri);
138 up(&f->sem);
139 return PTR_ERR(new_metadata);
140 }
141 /* It worked. Update the inode */
142 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
143 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
144 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
145 inode->i_mode = jemode_to_cpu(ri->mode);
146 inode->i_uid = je16_to_cpu(ri->uid);
147 inode->i_gid = je16_to_cpu(ri->gid);
148
149
150 old_metadata = f->metadata;
151
152 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100153 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
156 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
157 inode->i_size = iattr->ia_size;
158 f->metadata = NULL;
159 } else {
160 f->metadata = new_metadata;
161 }
162 if (old_metadata) {
163 jffs2_mark_node_obsolete(c, old_metadata->raw);
164 jffs2_free_full_dnode(old_metadata);
165 }
166 jffs2_free_raw_inode(ri);
167
168 up(&f->sem);
169 jffs2_complete_reservation(c);
170
171 /* We have to do the vmtruncate() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000172 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 We are protected from a simultaneous write() extending i_size
174 back past iattr->ia_size, because do_truncate() holds the
175 generic inode semaphore. */
176 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
177 vmtruncate(inode, iattr->ia_size);
178
179 return 0;
180}
181
182int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
183{
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900184 int rc;
185
186 rc = jffs2_do_setattr(dentry->d_inode, iattr);
187 if (!rc && (iattr->ia_valid & ATTR_MODE))
188 rc = jffs2_acl_chmod(dentry->d_inode);
189 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190}
191
David Howells726c3342006-06-23 02:02:58 -0700192int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
David Howells726c3342006-06-23 02:02:58 -0700194 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 unsigned long avail;
196
197 buf->f_type = JFFS2_SUPER_MAGIC;
198 buf->f_bsize = 1 << PAGE_SHIFT;
199 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
200 buf->f_files = 0;
201 buf->f_ffree = 0;
202 buf->f_namelen = JFFS2_MAX_NAME_LEN;
203
204 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 avail = c->dirty_size + c->free_size;
206 if (avail > c->sector_size * c->resv_blocks_write)
207 avail -= c->sector_size * c->resv_blocks_write;
208 else
209 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100210 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 return 0;
215}
216
217
218void jffs2_clear_inode (struct inode *inode)
219{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000220 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 * the nodelists associated with it, etc.
222 */
223 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
224 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 jffs2_do_clear_inode(c, f);
228}
229
230void jffs2_read_inode (struct inode *inode)
231{
232 struct jffs2_inode_info *f;
233 struct jffs2_sb_info *c;
234 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100235 union jffs2_device_node jdev;
236 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 int ret;
238
239 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
240
241 f = JFFS2_INODE_INFO(inode);
242 c = JFFS2_SB_INFO(inode->i_sb);
243
244 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100245 down(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
248
249 if (ret) {
250 make_bad_inode(inode);
251 up(&f->sem);
252 return;
253 }
254 inode->i_mode = jemode_to_cpu(latest_node.mode);
255 inode->i_uid = je16_to_cpu(latest_node.uid);
256 inode->i_gid = je16_to_cpu(latest_node.gid);
257 inode->i_size = je32_to_cpu(latest_node.isize);
258 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
259 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
260 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
261
262 inode->i_nlink = f->inocache->nlink;
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 case S_IFLNK:
269 inode->i_op = &jffs2_symlink_inode_operations;
270 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 case S_IFDIR:
273 {
274 struct jffs2_full_dirent *fd;
275
276 for (fd=f->dents; fd; fd = fd->next) {
277 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700278 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280 /* and '..' */
Dave Hansend8c76e62006-09-30 23:29:04 -0700281 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 /* Root dir gets i_nlink 3 for some reason */
283 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700284 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 inode->i_op = &jffs2_dir_inode_operations;
287 inode->i_fop = &jffs2_dir_operations;
288 break;
289 }
290 case S_IFREG:
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;
295 break;
296
297 case S_IFBLK:
298 case S_IFCHR:
299 /* Read the device numbers from the media */
David Woodhouseaef9ab42006-05-19 00:28:49 +0100300 if (f->metadata->size != sizeof(jdev.old) &&
301 f->metadata->size != sizeof(jdev.new)) {
302 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
303 up(&f->sem);
304 jffs2_do_clear_inode(c, f);
305 make_bad_inode(inode);
306 return;
307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100309 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* Eep */
311 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
312 up(&f->sem);
313 jffs2_do_clear_inode(c, f);
314 make_bad_inode(inode);
315 return;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000316 }
David Woodhouseaef9ab42006-05-19 00:28:49 +0100317 if (f->metadata->size == sizeof(jdev.old))
318 rdev = old_decode_dev(je16_to_cpu(jdev.old));
319 else
320 rdev = new_decode_dev(je32_to_cpu(jdev.new));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322 case S_IFSOCK:
323 case S_IFIFO:
324 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100325 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 break;
327
328 default:
329 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
330 }
331
332 up(&f->sem);
333
334 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
335}
336
337void jffs2_dirty_inode(struct inode *inode)
338{
339 struct iattr iattr;
340
341 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
342 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
343 return;
344 }
345
346 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
347
348 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
349 iattr.ia_mode = inode->i_mode;
350 iattr.ia_uid = inode->i_uid;
351 iattr.ia_gid = inode->i_gid;
352 iattr.ia_atime = inode->i_atime;
353 iattr.ia_mtime = inode->i_mtime;
354 iattr.ia_ctime = inode->i_ctime;
355
356 jffs2_do_setattr(inode, &iattr);
357}
358
359int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
360{
361 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
362
363 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
364 return -EROFS;
365
366 /* We stop if it was running, then restart if it needs to.
367 This also catches the case where it was stopped and this
368 is just a remount to restart it.
369 Flush the writebuffer, if neccecary, else we loose it */
370 if (!(sb->s_flags & MS_RDONLY)) {
371 jffs2_stop_garbage_collect_thread(c);
372 down(&c->alloc_sem);
373 jffs2_flush_wbuf_pad(c);
374 up(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 if (!(*flags & MS_RDONLY))
378 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 *flags |= MS_NOATIME;
381
382 return 0;
383}
384
385void jffs2_write_super (struct super_block *sb)
386{
387 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
388 sb->s_dirt = 0;
389
390 if (sb->s_flags & MS_RDONLY)
391 return;
392
393 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
394 jffs2_garbage_collect_trigger(c);
395 jffs2_erase_pending_blocks(c, 0);
396 jffs2_flush_wbuf_gc(c, 0);
397}
398
399
400/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
401 fill in the raw_inode while you're at it. */
402struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
403{
404 struct inode *inode;
405 struct super_block *sb = dir_i->i_sb;
406 struct jffs2_sb_info *c;
407 struct jffs2_inode_info *f;
408 int ret;
409
410 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
411
412 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 if (!inode)
417 return ERR_PTR(-ENOMEM);
418
419 f = JFFS2_INODE_INFO(inode);
420 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100421 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
423 memset(ri, 0, sizeof(*ri));
424 /* Set OS-specific defaults for new inodes */
425 ri->uid = cpu_to_je16(current->fsuid);
426
427 if (dir_i->i_mode & S_ISGID) {
428 ri->gid = cpu_to_je16(dir_i->i_gid);
429 if (S_ISDIR(mode))
430 mode |= S_ISGID;
431 } else {
432 ri->gid = cpu_to_je16(current->fsgid);
433 }
434 ri->mode = cpu_to_jemode(mode);
435 ret = jffs2_do_new_inode (c, f, mode, ri);
436 if (ret) {
437 make_bad_inode(inode);
438 iput(inode);
439 return ERR_PTR(ret);
440 }
441 inode->i_nlink = 1;
442 inode->i_ino = je32_to_cpu(ri->ino);
443 inode->i_mode = jemode_to_cpu(ri->mode);
444 inode->i_gid = je16_to_cpu(ri->gid);
445 inode->i_uid = je16_to_cpu(ri->uid);
446 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
447 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 inode->i_blocks = 0;
450 inode->i_size = 0;
451
452 insert_inode_hash(inode);
453
454 return inode;
455}
456
457
458int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
459{
460 struct jffs2_sb_info *c;
461 struct inode *root_i;
462 int ret;
463 size_t blocks;
464
465 c = JFFS2_SB_INFO(sb);
466
Andrew Victor2f82ce12005-02-09 09:24:26 +0000467#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 if (c->mtd->type == MTD_NANDFLASH) {
469 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
470 return -EINVAL;
471 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000472 if (c->mtd->type == MTD_DATAFLASH) {
473 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
474 return -EINVAL;
475 }
476#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000479 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 /*
483 * Size alignment check
484 */
485 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000486 c->flash_size = c->sector_size * blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
488 c->flash_size / 1024);
489 }
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 if (c->flash_size < 5*c->sector_size) {
492 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
493 return -EINVAL;
494 }
495
496 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498 /* NAND (or other bizarre) flash... do setup accordingly */
499 ret = jffs2_flash_setup(c);
500 if (ret)
501 return ret;
502
Yan Burman3d375d92006-12-04 15:03:01 -0800503 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (!c->inocache_list) {
505 ret = -ENOMEM;
506 goto out_wbuf;
507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900509 jffs2_init_xattr_subsystem(c);
510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 if ((ret = jffs2_do_mount_fs(c)))
512 goto out_inohash;
513
514 ret = -EINVAL;
515
516 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
517 root_i = iget(sb, 1);
518 if (is_bad_inode(root_i)) {
519 D1(printk(KERN_WARNING "get root inode failed\n"));
Artem B. Bityutskiy6dac02a2005-07-18 12:21:23 +0100520 goto out_root_i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522
523 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
524 sb->s_root = d_alloc_root(root_i);
525 if (!sb->s_root)
526 goto out_root_i;
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 sb->s_blocksize = PAGE_CACHE_SIZE;
530 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
531 sb->s_magic = JFFS2_SUPER_MAGIC;
532 if (!(sb->s_flags & MS_RDONLY))
533 jffs2_start_garbage_collect_thread(c);
534 return 0;
535
536 out_root_i:
537 iput(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 jffs2_free_ino_caches(c);
539 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100540 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 vfree(c->blocks);
542 else
543 kfree(c->blocks);
544 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900545 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 kfree(c->inocache_list);
547 out_wbuf:
548 jffs2_flash_cleanup(c);
549
550 return ret;
551}
552
553void jffs2_gc_release_inode(struct jffs2_sb_info *c,
554 struct jffs2_inode_info *f)
555{
556 iput(OFNI_EDONI_2SFFJ(f));
557}
558
559struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
560 int inum, int nlink)
561{
562 struct inode *inode;
563 struct jffs2_inode_cache *ic;
564 if (!nlink) {
565 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000566 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 the final (close() and) iput() to happen.
568
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000569 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 happened while we were contemplating. In order to ensure
571 that we don't cause a new read_inode() (which would fail)
572 for the inode in question, we use ilookup() in this case
573 instead of iget().
574
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000575 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 holding the alloc_sem, and jffs2_do_unlink() would also
577 need that while decrementing nlink on any inode.
578 */
579 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
580 if (!inode) {
581 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
582 inum));
583
584 spin_lock(&c->inocache_lock);
585 ic = jffs2_get_ino_cache(c, inum);
586 if (!ic) {
587 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
588 spin_unlock(&c->inocache_lock);
589 return NULL;
590 }
591 if (ic->state != INO_STATE_CHECKEDABSENT) {
592 /* Wait for progress. Don't just loop */
593 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
594 ic->ino, ic->state));
595 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
596 } else {
597 spin_unlock(&c->inocache_lock);
598 }
599
600 return NULL;
601 }
602 } else {
603 /* Inode has links to it still; they're not going away because
604 jffs2_do_unlink() would need the alloc_sem and we have it.
605 Just iget() it, and if read_inode() is necessary that's OK.
606 */
607 inode = iget(OFNI_BS_2SFFJ(c), inum);
608 if (!inode)
609 return ERR_PTR(-ENOMEM);
610 }
611 if (is_bad_inode(inode)) {
612 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
613 inum, nlink);
614 /* NB. This will happen again. We need to do something appropriate here. */
615 iput(inode);
616 return ERR_PTR(-EIO);
617 }
618
619 return JFFS2_INODE_INFO(inode);
620}
621
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000622unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
623 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 unsigned long offset,
625 unsigned long *priv)
626{
627 struct inode *inode = OFNI_EDONI_2SFFJ(f);
628 struct page *pg;
629
Jason Lunzfc0e0192007-09-01 12:06:03 -0700630 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 (void *)jffs2_do_readpage_unlock, inode);
632 if (IS_ERR(pg))
633 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 *priv = (unsigned long)pg;
636 return kmap(pg);
637}
638
639void jffs2_gc_release_page(struct jffs2_sb_info *c,
640 unsigned char *ptr,
641 unsigned long *priv)
642{
643 struct page *pg = (void *)*priv;
644
645 kunmap(pg);
646 page_cache_release(pg);
647}
648
649static int jffs2_flash_setup(struct jffs2_sb_info *c) {
650 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 if (jffs2_cleanmarker_oob(c)) {
653 /* NAND flash... do setup accordingly */
654 ret = jffs2_nand_flash_setup(c);
655 if (ret)
656 return ret;
657 }
658
Andrew Victor8f15fd52005-02-09 09:17:45 +0000659 /* and Dataflash */
660 if (jffs2_dataflash(c)) {
661 ret = jffs2_dataflash_setup(c);
662 if (ret)
663 return ret;
664 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100665
666 /* and Intel "Sibley" flash */
667 if (jffs2_nor_wbuf_flash(c)) {
668 ret = jffs2_nor_wbuf_flash_setup(c);
669 if (ret)
670 return ret;
671 }
672
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300673 /* and an UBI volume */
674 if (jffs2_ubivol(c)) {
675 ret = jffs2_ubivol_setup(c);
676 if (ret)
677 return ret;
678 }
679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return ret;
681}
682
683void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
684
685 if (jffs2_cleanmarker_oob(c)) {
686 jffs2_nand_flash_cleanup(c);
687 }
688
Andrew Victor8f15fd52005-02-09 09:17:45 +0000689 /* and DataFlash */
690 if (jffs2_dataflash(c)) {
691 jffs2_dataflash_cleanup(c);
692 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100693
694 /* and Intel "Sibley" flash */
695 if (jffs2_nor_wbuf_flash(c)) {
696 jffs2_nor_wbuf_flash_cleanup(c);
697 }
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300698
699 /* and an UBI volume */
700 if (jffs2_ubivol(c)) {
701 jffs2_ubivol_cleanup(c);
702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}