blob: d2e06f7ea96fdff2eac4a3c683c026e5c5d9fac6 [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
David Woodhouse9ed437c2007-08-22 12:39:19 +010027int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028{
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;
David Woodhouse9ed437c2007-08-22 12:39:19 +010039
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42 /* Special cases - we don't want more than one data node
43 for these types on the medium at any time. So setattr
44 must read the original data associated with the node
45 (i.e. the device numbers or the target name) and write
46 it out again with the appropriate data attached */
47 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
48 /* For these, we don't actually need to read the old node */
David Woodhouseaef9ab42006-05-19 00:28:49 +010049 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 mdata = (char *)&dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
52 } else if (S_ISLNK(inode->i_mode)) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010053 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 mdatalen = f->metadata->size;
55 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010056 if (!mdata) {
57 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010059 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
61 if (ret) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010062 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 kfree(mdata);
64 return ret;
65 }
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010066 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
68 }
69
70 ri = jffs2_alloc_raw_inode();
71 if (!ri) {
72 if (S_ISLNK(inode->i_mode))
73 kfree(mdata);
74 return -ENOMEM;
75 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000076
David Woodhouse9fe48542006-05-23 00:38:06 +010077 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
78 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 if (ret) {
80 jffs2_free_raw_inode(ri);
81 if (S_ISLNK(inode->i_mode & S_IFMT))
82 kfree(mdata);
83 return ret;
84 }
85 down(&f->sem);
86 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 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));
92
93 ri->ino = cpu_to_je32(inode->i_ino);
94 ri->version = cpu_to_je32(++f->highest_version);
95
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);
98
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);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000103 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 ri->mode = cpu_to_jemode(iattr->ia_mode);
105 else
106 ri->mode = cpu_to_jemode(inode->i_mode);
107
108
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));
113
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);
122 }
123 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
124 if (mdatalen)
125 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
126 else
127 ri->data_crc = cpu_to_je32(0);
128
David Woodhouse9fe48542006-05-23 00:38:06 +0100129 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 if (S_ISLNK(inode->i_mode))
131 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 if (IS_ERR(new_metadata)) {
134 jffs2_complete_reservation(c);
135 jffs2_free_raw_inode(ri);
136 up(&f->sem);
137 return PTR_ERR(new_metadata);
138 }
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);
146
147
148 old_metadata = f->metadata;
149
150 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100151 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
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;
156 f->metadata = NULL;
157 } else {
158 f->metadata = new_metadata;
159 }
160 if (old_metadata) {
161 jffs2_mark_node_obsolete(c, old_metadata->raw);
162 jffs2_free_full_dnode(old_metadata);
163 }
164 jffs2_free_raw_inode(ri);
165
166 up(&f->sem);
167 jffs2_complete_reservation(c);
168
169 /* We have to do the vmtruncate() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000170 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 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);
176
177 return 0;
178}
179
180int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
181{
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900182 int rc;
183
David Woodhouse9ed437c2007-08-22 12:39:19 +0100184 rc = inode_change_ok(dentry->d_inode, iattr);
185 if (rc)
186 return rc;
187
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900188 rc = jffs2_do_setattr(dentry->d_inode, iattr);
189 if (!rc && (iattr->ia_valid & ATTR_MODE))
190 rc = jffs2_acl_chmod(dentry->d_inode);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100191
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900192 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 jffs2_do_clear_inode(c, f);
231}
232
233void jffs2_read_inode (struct inode *inode)
234{
235 struct jffs2_inode_info *f;
236 struct jffs2_sb_info *c;
237 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100238 union jffs2_device_node jdev;
239 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 int ret;
241
242 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
243
244 f = JFFS2_INODE_INFO(inode);
245 c = JFFS2_SB_INFO(inode->i_sb);
246
247 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100248 down(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
251
252 if (ret) {
253 make_bad_inode(inode);
254 up(&f->sem);
255 return;
256 }
257 inode->i_mode = jemode_to_cpu(latest_node.mode);
258 inode->i_uid = je16_to_cpu(latest_node.uid);
259 inode->i_gid = je16_to_cpu(latest_node.gid);
260 inode->i_size = je32_to_cpu(latest_node.isize);
261 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
262 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
263 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
264
265 inode->i_nlink = f->inocache->nlink;
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 case S_IFLNK:
272 inode->i_op = &jffs2_symlink_inode_operations;
273 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 case S_IFDIR:
276 {
277 struct jffs2_full_dirent *fd;
278
279 for (fd=f->dents; fd; fd = fd->next) {
280 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700281 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 }
283 /* and '..' */
Dave Hansend8c76e62006-09-30 23:29:04 -0700284 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 /* Root dir gets i_nlink 3 for some reason */
286 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700287 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 inode->i_op = &jffs2_dir_inode_operations;
290 inode->i_fop = &jffs2_dir_operations;
291 break;
292 }
293 case S_IFREG:
294 inode->i_op = &jffs2_file_inode_operations;
295 inode->i_fop = &jffs2_file_operations;
296 inode->i_mapping->a_ops = &jffs2_file_address_operations;
297 inode->i_mapping->nrpages = 0;
298 break;
299
300 case S_IFBLK:
301 case S_IFCHR:
302 /* Read the device numbers from the media */
David Woodhouseaef9ab42006-05-19 00:28:49 +0100303 if (f->metadata->size != sizeof(jdev.old) &&
304 f->metadata->size != sizeof(jdev.new)) {
305 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
306 up(&f->sem);
307 jffs2_do_clear_inode(c, f);
308 make_bad_inode(inode);
309 return;
310 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100312 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 /* Eep */
314 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
315 up(&f->sem);
316 jffs2_do_clear_inode(c, f);
317 make_bad_inode(inode);
318 return;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000319 }
David Woodhouseaef9ab42006-05-19 00:28:49 +0100320 if (f->metadata->size == sizeof(jdev.old))
321 rdev = old_decode_dev(je16_to_cpu(jdev.old));
322 else
323 rdev = new_decode_dev(je32_to_cpu(jdev.new));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325 case S_IFSOCK:
326 case S_IFIFO:
327 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100328 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 break;
330
331 default:
332 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
333 }
334
335 up(&f->sem);
336
337 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
338}
339
340void jffs2_dirty_inode(struct inode *inode)
341{
342 struct iattr iattr;
343
344 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
345 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
346 return;
347 }
348
349 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
350
351 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
352 iattr.ia_mode = inode->i_mode;
353 iattr.ia_uid = inode->i_uid;
354 iattr.ia_gid = inode->i_gid;
355 iattr.ia_atime = inode->i_atime;
356 iattr.ia_mtime = inode->i_mtime;
357 iattr.ia_ctime = inode->i_ctime;
358
359 jffs2_do_setattr(inode, &iattr);
360}
361
362int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
363{
364 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
365
366 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
367 return -EROFS;
368
369 /* We stop if it was running, then restart if it needs to.
370 This also catches the case where it was stopped and this
371 is just a remount to restart it.
372 Flush the writebuffer, if neccecary, else we loose it */
373 if (!(sb->s_flags & MS_RDONLY)) {
374 jffs2_stop_garbage_collect_thread(c);
375 down(&c->alloc_sem);
376 jffs2_flush_wbuf_pad(c);
377 up(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 if (!(*flags & MS_RDONLY))
381 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 *flags |= MS_NOATIME;
384
385 return 0;
386}
387
388void jffs2_write_super (struct super_block *sb)
389{
390 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
391 sb->s_dirt = 0;
392
393 if (sb->s_flags & MS_RDONLY)
394 return;
395
396 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
397 jffs2_garbage_collect_trigger(c);
398 jffs2_erase_pending_blocks(c, 0);
399 jffs2_flush_wbuf_gc(c, 0);
400}
401
402
403/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
404 fill in the raw_inode while you're at it. */
KaiGai Koheicfc8dc62007-09-14 15:16:35 +0900405struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 struct inode *inode;
408 struct super_block *sb = dir_i->i_sb;
409 struct jffs2_sb_info *c;
410 struct jffs2_inode_info *f;
411 int ret;
412
413 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
414
415 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 if (!inode)
420 return ERR_PTR(-ENOMEM);
421
422 f = JFFS2_INODE_INFO(inode);
423 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100424 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 memset(ri, 0, sizeof(*ri));
427 /* Set OS-specific defaults for new inodes */
428 ri->uid = cpu_to_je16(current->fsuid);
429
430 if (dir_i->i_mode & S_ISGID) {
431 ri->gid = cpu_to_je16(dir_i->i_gid);
432 if (S_ISDIR(mode))
433 mode |= S_ISGID;
434 } else {
435 ri->gid = cpu_to_je16(current->fsgid);
436 }
David Woodhouse9ed437c2007-08-22 12:39:19 +0100437
438 /* POSIX ACLs have to be processed now, at least partly.
439 The umask is only applied if there's no default ACL */
KaiGai Koheicfc8dc62007-09-14 15:16:35 +0900440 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
441 if (ret) {
442 make_bad_inode(inode);
443 iput(inode);
444 return ERR_PTR(ret);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100445 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 ret = jffs2_do_new_inode (c, f, mode, ri);
447 if (ret) {
448 make_bad_inode(inode);
449 iput(inode);
450 return ERR_PTR(ret);
451 }
452 inode->i_nlink = 1;
453 inode->i_ino = je32_to_cpu(ri->ino);
454 inode->i_mode = jemode_to_cpu(ri->mode);
455 inode->i_gid = je16_to_cpu(ri->gid);
456 inode->i_uid = je16_to_cpu(ri->uid);
457 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
458 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 inode->i_blocks = 0;
461 inode->i_size = 0;
462
463 insert_inode_hash(inode);
464
465 return inode;
466}
467
468
469int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
470{
471 struct jffs2_sb_info *c;
472 struct inode *root_i;
473 int ret;
474 size_t blocks;
475
476 c = JFFS2_SB_INFO(sb);
477
Andrew Victor2f82ce12005-02-09 09:24:26 +0000478#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (c->mtd->type == MTD_NANDFLASH) {
480 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
481 return -EINVAL;
482 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000483 if (c->mtd->type == MTD_DATAFLASH) {
484 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
485 return -EINVAL;
486 }
487#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000490 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493 /*
494 * Size alignment check
495 */
496 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000497 c->flash_size = c->sector_size * blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
499 c->flash_size / 1024);
500 }
501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (c->flash_size < 5*c->sector_size) {
503 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
504 return -EINVAL;
505 }
506
507 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
509 /* NAND (or other bizarre) flash... do setup accordingly */
510 ret = jffs2_flash_setup(c);
511 if (ret)
512 return ret;
513
Yan Burman3d375d92006-12-04 15:03:01 -0800514 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 if (!c->inocache_list) {
516 ret = -ENOMEM;
517 goto out_wbuf;
518 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900520 jffs2_init_xattr_subsystem(c);
521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 if ((ret = jffs2_do_mount_fs(c)))
523 goto out_inohash;
524
525 ret = -EINVAL;
526
527 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
528 root_i = iget(sb, 1);
529 if (is_bad_inode(root_i)) {
530 D1(printk(KERN_WARNING "get root inode failed\n"));
Artem B. Bityutskiy6dac02a2005-07-18 12:21:23 +0100531 goto out_root_i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 }
533
534 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
535 sb->s_root = d_alloc_root(root_i);
536 if (!sb->s_root)
537 goto out_root_i;
538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 sb->s_blocksize = PAGE_CACHE_SIZE;
541 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
542 sb->s_magic = JFFS2_SUPER_MAGIC;
543 if (!(sb->s_flags & MS_RDONLY))
544 jffs2_start_garbage_collect_thread(c);
545 return 0;
546
547 out_root_i:
548 iput(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 jffs2_free_ino_caches(c);
550 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100551 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 vfree(c->blocks);
553 else
554 kfree(c->blocks);
555 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900556 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 kfree(c->inocache_list);
558 out_wbuf:
559 jffs2_flash_cleanup(c);
560
561 return ret;
562}
563
564void jffs2_gc_release_inode(struct jffs2_sb_info *c,
565 struct jffs2_inode_info *f)
566{
567 iput(OFNI_EDONI_2SFFJ(f));
568}
569
570struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
571 int inum, int nlink)
572{
573 struct inode *inode;
574 struct jffs2_inode_cache *ic;
575 if (!nlink) {
576 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000577 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 the final (close() and) iput() to happen.
579
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000580 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 happened while we were contemplating. In order to ensure
582 that we don't cause a new read_inode() (which would fail)
583 for the inode in question, we use ilookup() in this case
584 instead of iget().
585
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000586 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 holding the alloc_sem, and jffs2_do_unlink() would also
588 need that while decrementing nlink on any inode.
589 */
590 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
591 if (!inode) {
592 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
593 inum));
594
595 spin_lock(&c->inocache_lock);
596 ic = jffs2_get_ino_cache(c, inum);
597 if (!ic) {
598 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
599 spin_unlock(&c->inocache_lock);
600 return NULL;
601 }
602 if (ic->state != INO_STATE_CHECKEDABSENT) {
603 /* Wait for progress. Don't just loop */
604 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
605 ic->ino, ic->state));
606 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
607 } else {
608 spin_unlock(&c->inocache_lock);
609 }
610
611 return NULL;
612 }
613 } else {
614 /* Inode has links to it still; they're not going away because
615 jffs2_do_unlink() would need the alloc_sem and we have it.
616 Just iget() it, and if read_inode() is necessary that's OK.
617 */
618 inode = iget(OFNI_BS_2SFFJ(c), inum);
619 if (!inode)
620 return ERR_PTR(-ENOMEM);
621 }
622 if (is_bad_inode(inode)) {
623 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
624 inum, nlink);
625 /* NB. This will happen again. We need to do something appropriate here. */
626 iput(inode);
627 return ERR_PTR(-EIO);
628 }
629
630 return JFFS2_INODE_INFO(inode);
631}
632
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000633unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
634 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 unsigned long offset,
636 unsigned long *priv)
637{
638 struct inode *inode = OFNI_EDONI_2SFFJ(f);
639 struct page *pg;
640
Jason Lunzfc0e0192007-09-01 12:06:03 -0700641 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 (void *)jffs2_do_readpage_unlock, inode);
643 if (IS_ERR(pg))
644 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000645
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 *priv = (unsigned long)pg;
647 return kmap(pg);
648}
649
650void jffs2_gc_release_page(struct jffs2_sb_info *c,
651 unsigned char *ptr,
652 unsigned long *priv)
653{
654 struct page *pg = (void *)*priv;
655
656 kunmap(pg);
657 page_cache_release(pg);
658}
659
660static int jffs2_flash_setup(struct jffs2_sb_info *c) {
661 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (jffs2_cleanmarker_oob(c)) {
664 /* NAND flash... do setup accordingly */
665 ret = jffs2_nand_flash_setup(c);
666 if (ret)
667 return ret;
668 }
669
Andrew Victor8f15fd52005-02-09 09:17:45 +0000670 /* and Dataflash */
671 if (jffs2_dataflash(c)) {
672 ret = jffs2_dataflash_setup(c);
673 if (ret)
674 return ret;
675 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100676
677 /* and Intel "Sibley" flash */
678 if (jffs2_nor_wbuf_flash(c)) {
679 ret = jffs2_nor_wbuf_flash_setup(c);
680 if (ret)
681 return ret;
682 }
683
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300684 /* and an UBI volume */
685 if (jffs2_ubivol(c)) {
686 ret = jffs2_ubivol_setup(c);
687 if (ret)
688 return ret;
689 }
690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 return ret;
692}
693
694void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
695
696 if (jffs2_cleanmarker_oob(c)) {
697 jffs2_nand_flash_cleanup(c);
698 }
699
Andrew Victor8f15fd52005-02-09 09:17:45 +0000700 /* and DataFlash */
701 if (jffs2_dataflash(c)) {
702 jffs2_dataflash_cleanup(c);
703 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100704
705 /* and Intel "Sibley" flash */
706 if (jffs2_nor_wbuf_flash(c)) {
707 jffs2_nor_wbuf_flash_cleanup(c);
708 }
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300709
710 /* and an UBI volume */
711 if (jffs2_ubivol(c)) {
712 jffs2_ubivol_cleanup(c);
713 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714}