blob: 24cb4c688efc9f9257218d7e13148496316c86af [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/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;
40 uint32_t phys_ofs, alloclen;
41 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
Ferenc Havasie631ddb2005-09-07 09:35:26 +010082 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &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
134 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
135 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{
187 return jffs2_do_setattr(dentry->d_inode, iattr);
188}
189
190int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
191{
192 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
193 unsigned long avail;
194
195 buf->f_type = JFFS2_SUPER_MAGIC;
196 buf->f_bsize = 1 << PAGE_SHIFT;
197 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
198 buf->f_files = 0;
199 buf->f_ffree = 0;
200 buf->f_namelen = JFFS2_MAX_NAME_LEN;
201
202 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 avail = c->dirty_size + c->free_size;
204 if (avail > c->sector_size * c->resv_blocks_write)
205 avail -= c->sector_size * c->resv_blocks_write;
206 else
207 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100208 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
210 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return 0;
213}
214
215
216void jffs2_clear_inode (struct inode *inode)
217{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000218 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 * the nodelists associated with it, etc.
220 */
221 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
222 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
225
226 jffs2_do_clear_inode(c, f);
227}
228
229void jffs2_read_inode (struct inode *inode)
230{
231 struct jffs2_inode_info *f;
232 struct jffs2_sb_info *c;
233 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100234 union jffs2_device_node jdev;
235 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 int ret;
237
238 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
239
240 f = JFFS2_INODE_INFO(inode);
241 c = JFFS2_SB_INFO(inode->i_sb);
242
243 jffs2_init_inode_info(f);
Thomas Gleixner21eeb7a2005-11-29 16:57:17 +0100244 down(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
247
248 if (ret) {
249 make_bad_inode(inode);
250 up(&f->sem);
251 return;
252 }
253 inode->i_mode = jemode_to_cpu(latest_node.mode);
254 inode->i_uid = je16_to_cpu(latest_node.uid);
255 inode->i_gid = je16_to_cpu(latest_node.gid);
256 inode->i_size = je32_to_cpu(latest_node.isize);
257 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
258 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
259 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
260
261 inode->i_nlink = f->inocache->nlink;
262
263 inode->i_blksize = PAGE_SIZE;
264 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)
278 inode->i_nlink++;
279 }
280 /* and '..' */
281 inode->i_nlink++;
282 /* Root dir gets i_nlink 3 for some reason */
283 if (inode->i_ino == 1)
284 inode->i_nlink++;
285
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
449 inode->i_blksize = PAGE_SIZE;
450 inode->i_blocks = 0;
451 inode->i_size = 0;
452
453 insert_inode_hash(inode);
454
455 return inode;
456}
457
458
459int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
460{
461 struct jffs2_sb_info *c;
462 struct inode *root_i;
463 int ret;
464 size_t blocks;
465
466 c = JFFS2_SB_INFO(sb);
467
Andrew Victor2f82ce12005-02-09 09:24:26 +0000468#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 if (c->mtd->type == MTD_NANDFLASH) {
470 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
471 return -EINVAL;
472 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000473 if (c->mtd->type == MTD_DATAFLASH) {
474 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
475 return -EINVAL;
476 }
477#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
479 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000480 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 /*
484 * Size alignment check
485 */
486 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000487 c->flash_size = c->sector_size * blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
489 c->flash_size / 1024);
490 }
491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 if (c->flash_size < 5*c->sector_size) {
493 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
494 return -EINVAL;
495 }
496
497 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
499 /* NAND (or other bizarre) flash... do setup accordingly */
500 ret = jffs2_flash_setup(c);
501 if (ret)
502 return ret;
503
504 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
505 if (!c->inocache_list) {
506 ret = -ENOMEM;
507 goto out_wbuf;
508 }
509 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
510
511 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:
545 kfree(c->inocache_list);
546 out_wbuf:
547 jffs2_flash_cleanup(c);
548
549 return ret;
550}
551
552void jffs2_gc_release_inode(struct jffs2_sb_info *c,
553 struct jffs2_inode_info *f)
554{
555 iput(OFNI_EDONI_2SFFJ(f));
556}
557
558struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
559 int inum, int nlink)
560{
561 struct inode *inode;
562 struct jffs2_inode_cache *ic;
563 if (!nlink) {
564 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000565 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 the final (close() and) iput() to happen.
567
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000568 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 happened while we were contemplating. In order to ensure
570 that we don't cause a new read_inode() (which would fail)
571 for the inode in question, we use ilookup() in this case
572 instead of iget().
573
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000574 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 holding the alloc_sem, and jffs2_do_unlink() would also
576 need that while decrementing nlink on any inode.
577 */
578 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
579 if (!inode) {
580 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
581 inum));
582
583 spin_lock(&c->inocache_lock);
584 ic = jffs2_get_ino_cache(c, inum);
585 if (!ic) {
586 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
587 spin_unlock(&c->inocache_lock);
588 return NULL;
589 }
590 if (ic->state != INO_STATE_CHECKEDABSENT) {
591 /* Wait for progress. Don't just loop */
592 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
593 ic->ino, ic->state));
594 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
595 } else {
596 spin_unlock(&c->inocache_lock);
597 }
598
599 return NULL;
600 }
601 } else {
602 /* Inode has links to it still; they're not going away because
603 jffs2_do_unlink() would need the alloc_sem and we have it.
604 Just iget() it, and if read_inode() is necessary that's OK.
605 */
606 inode = iget(OFNI_BS_2SFFJ(c), inum);
607 if (!inode)
608 return ERR_PTR(-ENOMEM);
609 }
610 if (is_bad_inode(inode)) {
611 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
612 inum, nlink);
613 /* NB. This will happen again. We need to do something appropriate here. */
614 iput(inode);
615 return ERR_PTR(-EIO);
616 }
617
618 return JFFS2_INODE_INFO(inode);
619}
620
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000621unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
622 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 unsigned long offset,
624 unsigned long *priv)
625{
626 struct inode *inode = OFNI_EDONI_2SFFJ(f);
627 struct page *pg;
628
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000629 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 (void *)jffs2_do_readpage_unlock, inode);
631 if (IS_ERR(pg))
632 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 *priv = (unsigned long)pg;
635 return kmap(pg);
636}
637
638void jffs2_gc_release_page(struct jffs2_sb_info *c,
639 unsigned char *ptr,
640 unsigned long *priv)
641{
642 struct page *pg = (void *)*priv;
643
644 kunmap(pg);
645 page_cache_release(pg);
646}
647
648static int jffs2_flash_setup(struct jffs2_sb_info *c) {
649 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 if (jffs2_cleanmarker_oob(c)) {
652 /* NAND flash... do setup accordingly */
653 ret = jffs2_nand_flash_setup(c);
654 if (ret)
655 return ret;
656 }
657
658 /* add setups for other bizarre flashes here... */
659 if (jffs2_nor_ecc(c)) {
660 ret = jffs2_nor_ecc_flash_setup(c);
661 if (ret)
662 return ret;
663 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000664
Andrew Victor8f15fd52005-02-09 09:17:45 +0000665 /* and Dataflash */
666 if (jffs2_dataflash(c)) {
667 ret = jffs2_dataflash_setup(c);
668 if (ret)
669 return ret;
670 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100671
672 /* and Intel "Sibley" flash */
673 if (jffs2_nor_wbuf_flash(c)) {
674 ret = jffs2_nor_wbuf_flash_setup(c);
675 if (ret)
676 return ret;
677 }
678
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 return ret;
680}
681
682void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
683
684 if (jffs2_cleanmarker_oob(c)) {
685 jffs2_nand_flash_cleanup(c);
686 }
687
688 /* add cleanups for other bizarre flashes here... */
689 if (jffs2_nor_ecc(c)) {
690 jffs2_nor_ecc_flash_cleanup(c);
691 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000692
Andrew Victor8f15fd52005-02-09 09:17:45 +0000693 /* and DataFlash */
694 if (jffs2_dataflash(c)) {
695 jffs2_dataflash_cleanup(c);
696 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100697
698 /* and Intel "Sibley" flash */
699 if (jffs2_nor_wbuf_flash(c)) {
700 jffs2_nor_wbuf_flash_cleanup(c);
701 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}