blob: 7bc1a4201c0c233437dd5e60d45159620b39e57c [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. Bityutskiy2f0077e02005-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/kernel.h>
16#include <linux/sched.h>
17#include <linux/fs.h>
18#include <linux/list.h>
19#include <linux/mtd/mtd.h>
20#include <linux/pagemap.h>
21#include <linux/slab.h>
22#include <linux/vmalloc.h>
23#include <linux/vfs.h>
24#include <linux/crc32.h>
25#include "nodelist.h"
26
27static int jffs2_flash_setup(struct jffs2_sb_info *c);
28
29static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
30{
31 struct jffs2_full_dnode *old_metadata, *new_metadata;
32 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
33 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
34 struct jffs2_raw_inode *ri;
David Woodhouseaef9ab42006-05-19 00:28:49 +010035 union jffs2_device_node dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 unsigned char *mdata = NULL;
37 int mdatalen = 0;
38 unsigned int ivalid;
David Woodhouse9fe48542006-05-23 00:38:06 +010039 uint32_t alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 int ret;
41 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
42 ret = inode_change_ok(inode, iattr);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000043 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 return ret;
45
46 /* Special cases - we don't want more than one data node
47 for these types on the medium at any time. So setattr
48 must read the original data associated with the node
49 (i.e. the device numbers or the target name) and write
50 it out again with the appropriate data attached */
51 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
52 /* For these, we don't actually need to read the old node */
David Woodhouseaef9ab42006-05-19 00:28:49 +010053 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 mdata = (char *)&dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
56 } else if (S_ISLNK(inode->i_mode)) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010057 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 mdatalen = f->metadata->size;
59 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010060 if (!mdata) {
61 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
65 if (ret) {
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010066 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 kfree(mdata);
68 return ret;
69 }
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010070 up(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
72 }
73
74 ri = jffs2_alloc_raw_inode();
75 if (!ri) {
76 if (S_ISLNK(inode->i_mode))
77 kfree(mdata);
78 return -ENOMEM;
79 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000080
David Woodhouse9fe48542006-05-23 00:38:06 +010081 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
82 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 if (ret) {
84 jffs2_free_raw_inode(ri);
85 if (S_ISLNK(inode->i_mode & S_IFMT))
86 kfree(mdata);
87 return ret;
88 }
89 down(&f->sem);
90 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
93 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
94 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
95 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
96
97 ri->ino = cpu_to_je32(inode->i_ino);
98 ri->version = cpu_to_je32(++f->highest_version);
99
100 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
101 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
102
103 if (ivalid & ATTR_MODE)
104 if (iattr->ia_mode & S_ISGID &&
105 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
106 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000107 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 ri->mode = cpu_to_jemode(iattr->ia_mode);
109 else
110 ri->mode = cpu_to_jemode(inode->i_mode);
111
112
113 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
114 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
115 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
116 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
117
118 ri->offset = cpu_to_je32(0);
119 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
120 ri->compr = JFFS2_COMPR_NONE;
121 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
122 /* It's an extension. Make it a hole node */
123 ri->compr = JFFS2_COMPR_ZERO;
124 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
125 ri->offset = cpu_to_je32(inode->i_size);
126 }
127 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
128 if (mdatalen)
129 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
130 else
131 ri->data_crc = cpu_to_je32(0);
132
David Woodhouse9fe48542006-05-23 00:38:06 +0100133 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 if (S_ISLNK(inode->i_mode))
135 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 if (IS_ERR(new_metadata)) {
138 jffs2_complete_reservation(c);
139 jffs2_free_raw_inode(ri);
140 up(&f->sem);
141 return PTR_ERR(new_metadata);
142 }
143 /* It worked. Update the inode */
144 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
145 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
146 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
147 inode->i_mode = jemode_to_cpu(ri->mode);
148 inode->i_uid = je16_to_cpu(ri->uid);
149 inode->i_gid = je16_to_cpu(ri->gid);
150
151
152 old_metadata = f->metadata;
153
154 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100155 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
158 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
159 inode->i_size = iattr->ia_size;
160 f->metadata = NULL;
161 } else {
162 f->metadata = new_metadata;
163 }
164 if (old_metadata) {
165 jffs2_mark_node_obsolete(c, old_metadata->raw);
166 jffs2_free_full_dnode(old_metadata);
167 }
168 jffs2_free_raw_inode(ri);
169
170 up(&f->sem);
171 jffs2_complete_reservation(c);
172
173 /* We have to do the vmtruncate() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000174 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 We are protected from a simultaneous write() extending i_size
176 back past iattr->ia_size, because do_truncate() holds the
177 generic inode semaphore. */
178 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
179 vmtruncate(inode, iattr->ia_size);
180
181 return 0;
182}
183
184int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
185{
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900186 int rc;
187
188 rc = jffs2_do_setattr(dentry->d_inode, iattr);
189 if (!rc && (iattr->ia_valid & ATTR_MODE))
190 rc = jffs2_acl_chmod(dentry->d_inode);
191 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
193
David Howells726c3342006-06-23 02:02:58 -0700194int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
David Howells726c3342006-06-23 02:02:58 -0700196 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 unsigned long avail;
198
199 buf->f_type = JFFS2_SUPER_MAGIC;
200 buf->f_bsize = 1 << PAGE_SHIFT;
201 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
202 buf->f_files = 0;
203 buf->f_ffree = 0;
204 buf->f_namelen = JFFS2_MAX_NAME_LEN;
205
206 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 avail = c->dirty_size + c->free_size;
208 if (avail > c->sector_size * c->resv_blocks_write)
209 avail -= c->sector_size * c->resv_blocks_write;
210 else
211 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100212 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 return 0;
217}
218
219
220void jffs2_clear_inode (struct inode *inode)
221{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000222 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 * the nodelists associated with it, etc.
224 */
225 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
226 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 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 -0700229 jffs2_do_clear_inode(c, f);
230}
231
232void jffs2_read_inode (struct inode *inode)
233{
234 struct jffs2_inode_info *f;
235 struct jffs2_sb_info *c;
236 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100237 union jffs2_device_node jdev;
238 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 int ret;
240
241 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
242
243 f = JFFS2_INODE_INFO(inode);
244 c = JFFS2_SB_INFO(inode->i_sb);
245
246 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100247 down(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
250
251 if (ret) {
252 make_bad_inode(inode);
253 up(&f->sem);
254 return;
255 }
256 inode->i_mode = jemode_to_cpu(latest_node.mode);
257 inode->i_uid = je16_to_cpu(latest_node.uid);
258 inode->i_gid = je16_to_cpu(latest_node.gid);
259 inode->i_size = je32_to_cpu(latest_node.isize);
260 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
261 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
262 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
263
264 inode->i_nlink = f->inocache->nlink;
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 case S_IFLNK:
271 inode->i_op = &jffs2_symlink_inode_operations;
272 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 case S_IFDIR:
275 {
276 struct jffs2_full_dirent *fd;
277
278 for (fd=f->dents; fd; fd = fd->next) {
279 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700280 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 }
282 /* and '..' */
Dave Hansend8c76e62006-09-30 23:29:04 -0700283 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 /* Root dir gets i_nlink 3 for some reason */
285 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700286 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 inode->i_op = &jffs2_dir_inode_operations;
289 inode->i_fop = &jffs2_dir_operations;
290 break;
291 }
292 case S_IFREG:
293 inode->i_op = &jffs2_file_inode_operations;
294 inode->i_fop = &jffs2_file_operations;
295 inode->i_mapping->a_ops = &jffs2_file_address_operations;
296 inode->i_mapping->nrpages = 0;
297 break;
298
299 case S_IFBLK:
300 case S_IFCHR:
301 /* Read the device numbers from the media */
David Woodhouseaef9ab42006-05-19 00:28:49 +0100302 if (f->metadata->size != sizeof(jdev.old) &&
303 f->metadata->size != sizeof(jdev.new)) {
304 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
305 up(&f->sem);
306 jffs2_do_clear_inode(c, f);
307 make_bad_inode(inode);
308 return;
309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100311 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 /* Eep */
313 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
314 up(&f->sem);
315 jffs2_do_clear_inode(c, f);
316 make_bad_inode(inode);
317 return;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000318 }
David Woodhouseaef9ab42006-05-19 00:28:49 +0100319 if (f->metadata->size == sizeof(jdev.old))
320 rdev = old_decode_dev(je16_to_cpu(jdev.old));
321 else
322 rdev = new_decode_dev(je32_to_cpu(jdev.new));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324 case S_IFSOCK:
325 case S_IFIFO:
326 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100327 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 break;
329
330 default:
331 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
332 }
333
334 up(&f->sem);
335
336 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
337}
338
339void jffs2_dirty_inode(struct inode *inode)
340{
341 struct iattr iattr;
342
343 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
344 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
345 return;
346 }
347
348 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
349
350 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
351 iattr.ia_mode = inode->i_mode;
352 iattr.ia_uid = inode->i_uid;
353 iattr.ia_gid = inode->i_gid;
354 iattr.ia_atime = inode->i_atime;
355 iattr.ia_mtime = inode->i_mtime;
356 iattr.ia_ctime = inode->i_ctime;
357
358 jffs2_do_setattr(inode, &iattr);
359}
360
361int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
362{
363 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
364
365 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
366 return -EROFS;
367
368 /* We stop if it was running, then restart if it needs to.
369 This also catches the case where it was stopped and this
370 is just a remount to restart it.
371 Flush the writebuffer, if neccecary, else we loose it */
372 if (!(sb->s_flags & MS_RDONLY)) {
373 jffs2_stop_garbage_collect_thread(c);
374 down(&c->alloc_sem);
375 jffs2_flush_wbuf_pad(c);
376 up(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 if (!(*flags & MS_RDONLY))
380 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 *flags |= MS_NOATIME;
383
384 return 0;
385}
386
387void jffs2_write_super (struct super_block *sb)
388{
389 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
390 sb->s_dirt = 0;
391
392 if (sb->s_flags & MS_RDONLY)
393 return;
394
395 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
396 jffs2_garbage_collect_trigger(c);
397 jffs2_erase_pending_blocks(c, 0);
398 jffs2_flush_wbuf_gc(c, 0);
399}
400
401
402/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
403 fill in the raw_inode while you're at it. */
404struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
405{
406 struct inode *inode;
407 struct super_block *sb = dir_i->i_sb;
408 struct jffs2_sb_info *c;
409 struct jffs2_inode_info *f;
410 int ret;
411
412 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
413
414 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 if (!inode)
419 return ERR_PTR(-ENOMEM);
420
421 f = JFFS2_INODE_INFO(inode);
422 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100423 down(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
425 memset(ri, 0, sizeof(*ri));
426 /* Set OS-specific defaults for new inodes */
427 ri->uid = cpu_to_je16(current->fsuid);
428
429 if (dir_i->i_mode & S_ISGID) {
430 ri->gid = cpu_to_je16(dir_i->i_gid);
431 if (S_ISDIR(mode))
432 mode |= S_ISGID;
433 } else {
434 ri->gid = cpu_to_je16(current->fsgid);
435 }
436 ri->mode = cpu_to_jemode(mode);
437 ret = jffs2_do_new_inode (c, f, mode, ri);
438 if (ret) {
439 make_bad_inode(inode);
440 iput(inode);
441 return ERR_PTR(ret);
442 }
443 inode->i_nlink = 1;
444 inode->i_ino = je32_to_cpu(ri->ino);
445 inode->i_mode = jemode_to_cpu(ri->mode);
446 inode->i_gid = je16_to_cpu(ri->gid);
447 inode->i_uid = je16_to_cpu(ri->uid);
448 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
449 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 inode->i_blocks = 0;
452 inode->i_size = 0;
453
454 insert_inode_hash(inode);
455
456 return inode;
457}
458
459
460int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
461{
462 struct jffs2_sb_info *c;
463 struct inode *root_i;
464 int ret;
465 size_t blocks;
466
467 c = JFFS2_SB_INFO(sb);
468
Andrew Victor2f82ce12005-02-09 09:24:26 +0000469#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 if (c->mtd->type == MTD_NANDFLASH) {
471 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
472 return -EINVAL;
473 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000474 if (c->mtd->type == MTD_DATAFLASH) {
475 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
476 return -EINVAL;
477 }
478#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000481 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 /*
485 * Size alignment check
486 */
487 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000488 c->flash_size = c->sector_size * blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
490 c->flash_size / 1024);
491 }
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (c->flash_size < 5*c->sector_size) {
494 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
495 return -EINVAL;
496 }
497
498 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
500 /* NAND (or other bizarre) flash... do setup accordingly */
501 ret = jffs2_flash_setup(c);
502 if (ret)
503 return ret;
504
505 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
506 if (!c->inocache_list) {
507 ret = -ENOMEM;
508 goto out_wbuf;
509 }
510 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
511
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900512 jffs2_init_xattr_subsystem(c);
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if ((ret = jffs2_do_mount_fs(c)))
515 goto out_inohash;
516
517 ret = -EINVAL;
518
519 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
520 root_i = iget(sb, 1);
521 if (is_bad_inode(root_i)) {
522 D1(printk(KERN_WARNING "get root inode failed\n"));
Artem B. Bityutskiy6dac02a2005-07-18 12:21:23 +0100523 goto out_root_i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
525
526 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
527 sb->s_root = d_alloc_root(root_i);
528 if (!sb->s_root)
529 goto out_root_i;
530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 sb->s_blocksize = PAGE_CACHE_SIZE;
533 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
534 sb->s_magic = JFFS2_SUPER_MAGIC;
535 if (!(sb->s_flags & MS_RDONLY))
536 jffs2_start_garbage_collect_thread(c);
537 return 0;
538
539 out_root_i:
540 iput(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 jffs2_free_ino_caches(c);
542 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100543 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 vfree(c->blocks);
545 else
546 kfree(c->blocks);
547 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900548 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 kfree(c->inocache_list);
550 out_wbuf:
551 jffs2_flash_cleanup(c);
552
553 return ret;
554}
555
556void jffs2_gc_release_inode(struct jffs2_sb_info *c,
557 struct jffs2_inode_info *f)
558{
559 iput(OFNI_EDONI_2SFFJ(f));
560}
561
562struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
563 int inum, int nlink)
564{
565 struct inode *inode;
566 struct jffs2_inode_cache *ic;
567 if (!nlink) {
568 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000569 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 the final (close() and) iput() to happen.
571
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000572 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 happened while we were contemplating. In order to ensure
574 that we don't cause a new read_inode() (which would fail)
575 for the inode in question, we use ilookup() in this case
576 instead of iget().
577
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000578 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 holding the alloc_sem, and jffs2_do_unlink() would also
580 need that while decrementing nlink on any inode.
581 */
582 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
583 if (!inode) {
584 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
585 inum));
586
587 spin_lock(&c->inocache_lock);
588 ic = jffs2_get_ino_cache(c, inum);
589 if (!ic) {
590 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
591 spin_unlock(&c->inocache_lock);
592 return NULL;
593 }
594 if (ic->state != INO_STATE_CHECKEDABSENT) {
595 /* Wait for progress. Don't just loop */
596 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
597 ic->ino, ic->state));
598 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
599 } else {
600 spin_unlock(&c->inocache_lock);
601 }
602
603 return NULL;
604 }
605 } else {
606 /* Inode has links to it still; they're not going away because
607 jffs2_do_unlink() would need the alloc_sem and we have it.
608 Just iget() it, and if read_inode() is necessary that's OK.
609 */
610 inode = iget(OFNI_BS_2SFFJ(c), inum);
611 if (!inode)
612 return ERR_PTR(-ENOMEM);
613 }
614 if (is_bad_inode(inode)) {
615 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
616 inum, nlink);
617 /* NB. This will happen again. We need to do something appropriate here. */
618 iput(inode);
619 return ERR_PTR(-EIO);
620 }
621
622 return JFFS2_INODE_INFO(inode);
623}
624
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000625unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
626 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 unsigned long offset,
628 unsigned long *priv)
629{
630 struct inode *inode = OFNI_EDONI_2SFFJ(f);
631 struct page *pg;
632
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000633 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 (void *)jffs2_do_readpage_unlock, inode);
635 if (IS_ERR(pg))
636 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 *priv = (unsigned long)pg;
639 return kmap(pg);
640}
641
642void jffs2_gc_release_page(struct jffs2_sb_info *c,
643 unsigned char *ptr,
644 unsigned long *priv)
645{
646 struct page *pg = (void *)*priv;
647
648 kunmap(pg);
649 page_cache_release(pg);
650}
651
652static int jffs2_flash_setup(struct jffs2_sb_info *c) {
653 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (jffs2_cleanmarker_oob(c)) {
656 /* NAND flash... do setup accordingly */
657 ret = jffs2_nand_flash_setup(c);
658 if (ret)
659 return ret;
660 }
661
Andrew Victor8f15fd52005-02-09 09:17:45 +0000662 /* and Dataflash */
663 if (jffs2_dataflash(c)) {
664 ret = jffs2_dataflash_setup(c);
665 if (ret)
666 return ret;
667 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100668
669 /* and Intel "Sibley" flash */
670 if (jffs2_nor_wbuf_flash(c)) {
671 ret = jffs2_nor_wbuf_flash_setup(c);
672 if (ret)
673 return ret;
674 }
675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return ret;
677}
678
679void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
680
681 if (jffs2_cleanmarker_oob(c)) {
682 jffs2_nand_flash_cleanup(c);
683 }
684
Andrew Victor8f15fd52005-02-09 09:17:45 +0000685 /* and DataFlash */
686 if (jffs2_dataflash(c)) {
687 jffs2_dataflash_cleanup(c);
688 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100689
690 /* and Intel "Sibley" flash */
691 if (jffs2_nor_wbuf_flash(c)) {
692 jffs2_nor_wbuf_flash_cleanup(c);
693 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}