Loading...
1/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright © 2001-2007 Red Hat, Inc.
5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
6 *
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 *
9 * For licensing information, see the file 'LICENCE' in this directory.
10 *
11 */
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/capability.h>
16#include <linux/kernel.h>
17#include <linux/sched.h>
18#include <linux/cred.h>
19#include <linux/fs.h>
20#include <linux/fs_context.h>
21#include <linux/list.h>
22#include <linux/mtd/mtd.h>
23#include <linux/pagemap.h>
24#include <linux/slab.h>
25#include <linux/vmalloc.h>
26#include <linux/vfs.h>
27#include <linux/crc32.h>
28#include "nodelist.h"
29
30static int jffs2_flash_setup(struct jffs2_sb_info *c);
31
32int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
33{
34 struct jffs2_full_dnode *old_metadata, *new_metadata;
35 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
36 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
37 struct jffs2_raw_inode *ri;
38 union jffs2_device_node dev;
39 unsigned char *mdata = NULL;
40 int mdatalen = 0;
41 unsigned int ivalid;
42 uint32_t alloclen;
43 int ret;
44 int alloc_type = ALLOC_NORMAL;
45
46 jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
47
48 /* Special cases - we don't want more than one data node
49 for these types on the medium at any time. So setattr
50 must read the original data associated with the node
51 (i.e. the device numbers or the target name) and write
52 it out again with the appropriate data attached */
53 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
54 /* For these, we don't actually need to read the old node */
55 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
56 mdata = (char *)&dev;
57 jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
58 __func__, mdatalen);
59 } else if (S_ISLNK(inode->i_mode)) {
60 mutex_lock(&f->sem);
61 mdatalen = f->metadata->size;
62 mdata = kmalloc(f->metadata->size, GFP_USER);
63 if (!mdata) {
64 mutex_unlock(&f->sem);
65 return -ENOMEM;
66 }
67 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
68 if (ret) {
69 mutex_unlock(&f->sem);
70 kfree(mdata);
71 return ret;
72 }
73 mutex_unlock(&f->sem);
74 jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
75 __func__, mdatalen);
76 }
77
78 ri = jffs2_alloc_raw_inode();
79 if (!ri) {
80 if (S_ISLNK(inode->i_mode))
81 kfree(mdata);
82 return -ENOMEM;
83 }
84
85 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
86 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
87 if (ret) {
88 jffs2_free_raw_inode(ri);
89 if (S_ISLNK(inode->i_mode))
90 kfree(mdata);
91 return ret;
92 }
93 mutex_lock(&f->sem);
94 ivalid = iattr->ia_valid;
95
96 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
97 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
98 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
99 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
100
101 ri->ino = cpu_to_je32(inode->i_ino);
102 ri->version = cpu_to_je32(++f->highest_version);
103
104 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
105 from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
106 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
107 from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
108
109 if (ivalid & ATTR_MODE)
110 ri->mode = cpu_to_jemode(iattr->ia_mode);
111 else
112 ri->mode = cpu_to_jemode(inode->i_mode);
113
114
115 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
116 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
117 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
118 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
119
120 ri->offset = cpu_to_je32(0);
121 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
122 ri->compr = JFFS2_COMPR_NONE;
123 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
124 /* It's an extension. Make it a hole node */
125 ri->compr = JFFS2_COMPR_ZERO;
126 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
127 ri->offset = cpu_to_je32(inode->i_size);
128 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
129 /* For truncate-to-zero, treat it as deletion because
130 it'll always be obsoleting all previous nodes */
131 alloc_type = ALLOC_DELETION;
132 }
133 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
134 if (mdatalen)
135 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
136 else
137 ri->data_crc = cpu_to_je32(0);
138
139 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
140 if (S_ISLNK(inode->i_mode))
141 kfree(mdata);
142
143 if (IS_ERR(new_metadata)) {
144 jffs2_complete_reservation(c);
145 jffs2_free_raw_inode(ri);
146 mutex_unlock(&f->sem);
147 return PTR_ERR(new_metadata);
148 }
149 /* It worked. Update the inode */
150 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
151 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
152 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
153 inode->i_mode = jemode_to_cpu(ri->mode);
154 i_uid_write(inode, je16_to_cpu(ri->uid));
155 i_gid_write(inode, je16_to_cpu(ri->gid));
156
157
158 old_metadata = f->metadata;
159
160 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
161 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
162
163 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
164 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
165 inode->i_size = iattr->ia_size;
166 inode->i_blocks = (inode->i_size + 511) >> 9;
167 f->metadata = NULL;
168 } else {
169 f->metadata = new_metadata;
170 }
171 if (old_metadata) {
172 jffs2_mark_node_obsolete(c, old_metadata->raw);
173 jffs2_free_full_dnode(old_metadata);
174 }
175 jffs2_free_raw_inode(ri);
176
177 mutex_unlock(&f->sem);
178 jffs2_complete_reservation(c);
179
180 /* We have to do the truncate_setsize() without f->sem held, since
181 some pages may be locked and waiting for it in readpage().
182 We are protected from a simultaneous write() extending i_size
183 back past iattr->ia_size, because do_truncate() holds the
184 generic inode semaphore. */
185 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
186 truncate_setsize(inode, iattr->ia_size);
187 inode->i_blocks = (inode->i_size + 511) >> 9;
188 }
189
190 return 0;
191}
192
193int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
194{
195 struct inode *inode = d_inode(dentry);
196 int rc;
197
198 rc = setattr_prepare(dentry, iattr);
199 if (rc)
200 return rc;
201
202 rc = jffs2_do_setattr(inode, iattr);
203 if (!rc && (iattr->ia_valid & ATTR_MODE))
204 rc = posix_acl_chmod(inode, inode->i_mode);
205
206 return rc;
207}
208
209int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
210{
211 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
212 unsigned long avail;
213
214 buf->f_type = JFFS2_SUPER_MAGIC;
215 buf->f_bsize = 1 << PAGE_SHIFT;
216 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
217 buf->f_files = 0;
218 buf->f_ffree = 0;
219 buf->f_namelen = JFFS2_MAX_NAME_LEN;
220 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
221 buf->f_fsid.val[1] = c->mtd->index;
222
223 spin_lock(&c->erase_completion_lock);
224 avail = c->dirty_size + c->free_size;
225 if (avail > c->sector_size * c->resv_blocks_write)
226 avail -= c->sector_size * c->resv_blocks_write;
227 else
228 avail = 0;
229 spin_unlock(&c->erase_completion_lock);
230
231 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
232
233 return 0;
234}
235
236
237void jffs2_evict_inode (struct inode *inode)
238{
239 /* We can forget about this inode for now - drop all
240 * the nodelists associated with it, etc.
241 */
242 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
243 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
244
245 jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
246 __func__, inode->i_ino, inode->i_mode);
247 truncate_inode_pages_final(&inode->i_data);
248 clear_inode(inode);
249 jffs2_do_clear_inode(c, f);
250}
251
252struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
253{
254 struct jffs2_inode_info *f;
255 struct jffs2_sb_info *c;
256 struct jffs2_raw_inode latest_node;
257 union jffs2_device_node jdev;
258 struct inode *inode;
259 dev_t rdev = 0;
260 int ret;
261
262 jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
263
264 inode = iget_locked(sb, ino);
265 if (!inode)
266 return ERR_PTR(-ENOMEM);
267 if (!(inode->i_state & I_NEW))
268 return inode;
269
270 f = JFFS2_INODE_INFO(inode);
271 c = JFFS2_SB_INFO(inode->i_sb);
272
273 jffs2_init_inode_info(f);
274 mutex_lock(&f->sem);
275
276 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
277 if (ret)
278 goto error;
279
280 inode->i_mode = jemode_to_cpu(latest_node.mode);
281 i_uid_write(inode, je16_to_cpu(latest_node.uid));
282 i_gid_write(inode, je16_to_cpu(latest_node.gid));
283 inode->i_size = je32_to_cpu(latest_node.isize);
284 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
285 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
286 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
287
288 set_nlink(inode, f->inocache->pino_nlink);
289
290 inode->i_blocks = (inode->i_size + 511) >> 9;
291
292 switch (inode->i_mode & S_IFMT) {
293
294 case S_IFLNK:
295 inode->i_op = &jffs2_symlink_inode_operations;
296 inode->i_link = f->target;
297 break;
298
299 case S_IFDIR:
300 {
301 struct jffs2_full_dirent *fd;
302 set_nlink(inode, 2); /* parent and '.' */
303
304 for (fd=f->dents; fd; fd = fd->next) {
305 if (fd->type == DT_DIR && fd->ino)
306 inc_nlink(inode);
307 }
308 /* Root dir gets i_nlink 3 for some reason */
309 if (inode->i_ino == 1)
310 inc_nlink(inode);
311
312 inode->i_op = &jffs2_dir_inode_operations;
313 inode->i_fop = &jffs2_dir_operations;
314 break;
315 }
316 case S_IFREG:
317 inode->i_op = &jffs2_file_inode_operations;
318 inode->i_fop = &jffs2_file_operations;
319 inode->i_mapping->a_ops = &jffs2_file_address_operations;
320 inode->i_mapping->nrpages = 0;
321 break;
322
323 case S_IFBLK:
324 case S_IFCHR:
325 /* Read the device numbers from the media */
326 if (f->metadata->size != sizeof(jdev.old_id) &&
327 f->metadata->size != sizeof(jdev.new_id)) {
328 pr_notice("Device node has strange size %d\n",
329 f->metadata->size);
330 goto error_io;
331 }
332 jffs2_dbg(1, "Reading device numbers from flash\n");
333 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
334 if (ret < 0) {
335 /* Eep */
336 pr_notice("Read device numbers for inode %lu failed\n",
337 (unsigned long)inode->i_ino);
338 goto error;
339 }
340 if (f->metadata->size == sizeof(jdev.old_id))
341 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
342 else
343 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
344 /* fall through */
345
346 case S_IFSOCK:
347 case S_IFIFO:
348 inode->i_op = &jffs2_file_inode_operations;
349 init_special_inode(inode, inode->i_mode, rdev);
350 break;
351
352 default:
353 pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
354 __func__, inode->i_mode, (unsigned long)inode->i_ino);
355 }
356
357 mutex_unlock(&f->sem);
358
359 jffs2_dbg(1, "jffs2_read_inode() returning\n");
360 unlock_new_inode(inode);
361 return inode;
362
363error_io:
364 ret = -EIO;
365error:
366 mutex_unlock(&f->sem);
367 iget_failed(inode);
368 return ERR_PTR(ret);
369}
370
371void jffs2_dirty_inode(struct inode *inode, int flags)
372{
373 struct iattr iattr;
374
375 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
376 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
377 __func__, inode->i_ino);
378 return;
379 }
380
381 jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
382 __func__, inode->i_ino);
383
384 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
385 iattr.ia_mode = inode->i_mode;
386 iattr.ia_uid = inode->i_uid;
387 iattr.ia_gid = inode->i_gid;
388 iattr.ia_atime = inode->i_atime;
389 iattr.ia_mtime = inode->i_mtime;
390 iattr.ia_ctime = inode->i_ctime;
391
392 jffs2_do_setattr(inode, &iattr);
393}
394
395int jffs2_do_remount_fs(struct super_block *sb, struct fs_context *fc)
396{
397 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
398
399 if (c->flags & JFFS2_SB_FLAG_RO && !sb_rdonly(sb))
400 return -EROFS;
401
402 /* We stop if it was running, then restart if it needs to.
403 This also catches the case where it was stopped and this
404 is just a remount to restart it.
405 Flush the writebuffer, if neccecary, else we loose it */
406 if (!sb_rdonly(sb)) {
407 jffs2_stop_garbage_collect_thread(c);
408 mutex_lock(&c->alloc_sem);
409 jffs2_flush_wbuf_pad(c);
410 mutex_unlock(&c->alloc_sem);
411 }
412
413 if (!(fc->sb_flags & SB_RDONLY))
414 jffs2_start_garbage_collect_thread(c);
415
416 fc->sb_flags |= SB_NOATIME;
417 return 0;
418}
419
420/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
421 fill in the raw_inode while you're at it. */
422struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
423{
424 struct inode *inode;
425 struct super_block *sb = dir_i->i_sb;
426 struct jffs2_sb_info *c;
427 struct jffs2_inode_info *f;
428 int ret;
429
430 jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
431 __func__, dir_i->i_ino, mode);
432
433 c = JFFS2_SB_INFO(sb);
434
435 inode = new_inode(sb);
436
437 if (!inode)
438 return ERR_PTR(-ENOMEM);
439
440 f = JFFS2_INODE_INFO(inode);
441 jffs2_init_inode_info(f);
442 mutex_lock(&f->sem);
443
444 memset(ri, 0, sizeof(*ri));
445 /* Set OS-specific defaults for new inodes */
446 ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid()));
447
448 if (dir_i->i_mode & S_ISGID) {
449 ri->gid = cpu_to_je16(i_gid_read(dir_i));
450 if (S_ISDIR(mode))
451 mode |= S_ISGID;
452 } else {
453 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid()));
454 }
455
456 /* POSIX ACLs have to be processed now, at least partly.
457 The umask is only applied if there's no default ACL */
458 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
459 if (ret) {
460 mutex_unlock(&f->sem);
461 make_bad_inode(inode);
462 iput(inode);
463 return ERR_PTR(ret);
464 }
465 ret = jffs2_do_new_inode (c, f, mode, ri);
466 if (ret) {
467 mutex_unlock(&f->sem);
468 make_bad_inode(inode);
469 iput(inode);
470 return ERR_PTR(ret);
471 }
472 set_nlink(inode, 1);
473 inode->i_ino = je32_to_cpu(ri->ino);
474 inode->i_mode = jemode_to_cpu(ri->mode);
475 i_gid_write(inode, je16_to_cpu(ri->gid));
476 i_uid_write(inode, je16_to_cpu(ri->uid));
477 inode->i_atime = inode->i_ctime = inode->i_mtime = current_time(inode);
478 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
479
480 inode->i_blocks = 0;
481 inode->i_size = 0;
482
483 if (insert_inode_locked(inode) < 0) {
484 mutex_unlock(&f->sem);
485 make_bad_inode(inode);
486 iput(inode);
487 return ERR_PTR(-EINVAL);
488 }
489
490 return inode;
491}
492
493static int calculate_inocache_hashsize(uint32_t flash_size)
494{
495 /*
496 * Pick a inocache hash size based on the size of the medium.
497 * Count how many megabytes we're dealing with, apply a hashsize twice
498 * that size, but rounding down to the usual big powers of 2. And keep
499 * to sensible bounds.
500 */
501
502 int size_mb = flash_size / 1024 / 1024;
503 int hashsize = (size_mb * 2) & ~0x3f;
504
505 if (hashsize < INOCACHE_HASHSIZE_MIN)
506 return INOCACHE_HASHSIZE_MIN;
507 if (hashsize > INOCACHE_HASHSIZE_MAX)
508 return INOCACHE_HASHSIZE_MAX;
509
510 return hashsize;
511}
512
513int jffs2_do_fill_super(struct super_block *sb, struct fs_context *fc)
514{
515 struct jffs2_sb_info *c;
516 struct inode *root_i;
517 int ret;
518 size_t blocks;
519
520 c = JFFS2_SB_INFO(sb);
521
522 /* Do not support the MLC nand */
523 if (c->mtd->type == MTD_MLCNANDFLASH)
524 return -EINVAL;
525
526#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
527 if (c->mtd->type == MTD_NANDFLASH) {
528 errorf(fc, "Cannot operate on NAND flash unless jffs2 NAND support is compiled in");
529 return -EINVAL;
530 }
531 if (c->mtd->type == MTD_DATAFLASH) {
532 errorf(fc, "Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in");
533 return -EINVAL;
534 }
535#endif
536
537 c->flash_size = c->mtd->size;
538 c->sector_size = c->mtd->erasesize;
539 blocks = c->flash_size / c->sector_size;
540
541 /*
542 * Size alignment check
543 */
544 if ((c->sector_size * blocks) != c->flash_size) {
545 c->flash_size = c->sector_size * blocks;
546 infof(fc, "Flash size not aligned to erasesize, reducing to %dKiB",
547 c->flash_size / 1024);
548 }
549
550 if (c->flash_size < 5*c->sector_size) {
551 errorf(fc, "Too few erase blocks (%d)",
552 c->flash_size / c->sector_size);
553 return -EINVAL;
554 }
555
556 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
557
558 /* NAND (or other bizarre) flash... do setup accordingly */
559 ret = jffs2_flash_setup(c);
560 if (ret)
561 return ret;
562
563 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
564 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
565 if (!c->inocache_list) {
566 ret = -ENOMEM;
567 goto out_wbuf;
568 }
569
570 jffs2_init_xattr_subsystem(c);
571
572 if ((ret = jffs2_do_mount_fs(c)))
573 goto out_inohash;
574
575 jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
576 root_i = jffs2_iget(sb, 1);
577 if (IS_ERR(root_i)) {
578 jffs2_dbg(1, "get root inode failed\n");
579 ret = PTR_ERR(root_i);
580 goto out_root;
581 }
582
583 ret = -ENOMEM;
584
585 jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
586 sb->s_root = d_make_root(root_i);
587 if (!sb->s_root)
588 goto out_root;
589
590 sb->s_maxbytes = 0xFFFFFFFF;
591 sb->s_blocksize = PAGE_SIZE;
592 sb->s_blocksize_bits = PAGE_SHIFT;
593 sb->s_magic = JFFS2_SUPER_MAGIC;
594 sb->s_time_min = 0;
595 sb->s_time_max = U32_MAX;
596
597 if (!sb_rdonly(sb))
598 jffs2_start_garbage_collect_thread(c);
599 return 0;
600
601out_root:
602 jffs2_free_ino_caches(c);
603 jffs2_free_raw_node_refs(c);
604 kvfree(c->blocks);
605 out_inohash:
606 jffs2_clear_xattr_subsystem(c);
607 kfree(c->inocache_list);
608 out_wbuf:
609 jffs2_flash_cleanup(c);
610
611 return ret;
612}
613
614void jffs2_gc_release_inode(struct jffs2_sb_info *c,
615 struct jffs2_inode_info *f)
616{
617 iput(OFNI_EDONI_2SFFJ(f));
618}
619
620struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
621 int inum, int unlinked)
622{
623 struct inode *inode;
624 struct jffs2_inode_cache *ic;
625
626 if (unlinked) {
627 /* The inode has zero nlink but its nodes weren't yet marked
628 obsolete. This has to be because we're still waiting for
629 the final (close() and) iput() to happen.
630
631 There's a possibility that the final iput() could have
632 happened while we were contemplating. In order to ensure
633 that we don't cause a new read_inode() (which would fail)
634 for the inode in question, we use ilookup() in this case
635 instead of iget().
636
637 The nlink can't _become_ zero at this point because we're
638 holding the alloc_sem, and jffs2_do_unlink() would also
639 need that while decrementing nlink on any inode.
640 */
641 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
642 if (!inode) {
643 jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
644 inum);
645
646 spin_lock(&c->inocache_lock);
647 ic = jffs2_get_ino_cache(c, inum);
648 if (!ic) {
649 jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
650 inum);
651 spin_unlock(&c->inocache_lock);
652 return NULL;
653 }
654 if (ic->state != INO_STATE_CHECKEDABSENT) {
655 /* Wait for progress. Don't just loop */
656 jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
657 ic->ino, ic->state);
658 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
659 } else {
660 spin_unlock(&c->inocache_lock);
661 }
662
663 return NULL;
664 }
665 } else {
666 /* Inode has links to it still; they're not going away because
667 jffs2_do_unlink() would need the alloc_sem and we have it.
668 Just iget() it, and if read_inode() is necessary that's OK.
669 */
670 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
671 if (IS_ERR(inode))
672 return ERR_CAST(inode);
673 }
674 if (is_bad_inode(inode)) {
675 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
676 inum, unlinked);
677 /* NB. This will happen again. We need to do something appropriate here. */
678 iput(inode);
679 return ERR_PTR(-EIO);
680 }
681
682 return JFFS2_INODE_INFO(inode);
683}
684
685static int jffs2_flash_setup(struct jffs2_sb_info *c) {
686 int ret = 0;
687
688 if (jffs2_cleanmarker_oob(c)) {
689 /* NAND flash... do setup accordingly */
690 ret = jffs2_nand_flash_setup(c);
691 if (ret)
692 return ret;
693 }
694
695 /* and Dataflash */
696 if (jffs2_dataflash(c)) {
697 ret = jffs2_dataflash_setup(c);
698 if (ret)
699 return ret;
700 }
701
702 /* and Intel "Sibley" flash */
703 if (jffs2_nor_wbuf_flash(c)) {
704 ret = jffs2_nor_wbuf_flash_setup(c);
705 if (ret)
706 return ret;
707 }
708
709 /* and an UBI volume */
710 if (jffs2_ubivol(c)) {
711 ret = jffs2_ubivol_setup(c);
712 if (ret)
713 return ret;
714 }
715
716 return ret;
717}
718
719void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
720
721 if (jffs2_cleanmarker_oob(c)) {
722 jffs2_nand_flash_cleanup(c);
723 }
724
725 /* and DataFlash */
726 if (jffs2_dataflash(c)) {
727 jffs2_dataflash_cleanup(c);
728 }
729
730 /* and Intel "Sibley" flash */
731 if (jffs2_nor_wbuf_flash(c)) {
732 jffs2_nor_wbuf_flash_cleanup(c);
733 }
734
735 /* and an UBI volume */
736 if (jffs2_ubivol(c)) {
737 jffs2_ubivol_cleanup(c);
738 }
739}
1/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright © 2001-2007 Red Hat, Inc.
5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
6 *
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 *
9 * For licensing information, see the file 'LICENCE' in this directory.
10 *
11 */
12
13#include <linux/capability.h>
14#include <linux/kernel.h>
15#include <linux/sched.h>
16#include <linux/fs.h>
17#include <linux/list.h>
18#include <linux/mtd/mtd.h>
19#include <linux/pagemap.h>
20#include <linux/slab.h>
21#include <linux/vmalloc.h>
22#include <linux/vfs.h>
23#include <linux/crc32.h>
24#include "nodelist.h"
25
26static int jffs2_flash_setup(struct jffs2_sb_info *c);
27
28int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
29{
30 struct jffs2_full_dnode *old_metadata, *new_metadata;
31 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
32 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
33 struct jffs2_raw_inode *ri;
34 union jffs2_device_node dev;
35 unsigned char *mdata = NULL;
36 int mdatalen = 0;
37 unsigned int ivalid;
38 uint32_t alloclen;
39 int ret;
40 int alloc_type = ALLOC_NORMAL;
41
42 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
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 */
51 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
52 mdata = (char *)&dev;
53 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
54 } else if (S_ISLNK(inode->i_mode)) {
55 mutex_lock(&f->sem);
56 mdatalen = f->metadata->size;
57 mdata = kmalloc(f->metadata->size, GFP_USER);
58 if (!mdata) {
59 mutex_unlock(&f->sem);
60 return -ENOMEM;
61 }
62 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
63 if (ret) {
64 mutex_unlock(&f->sem);
65 kfree(mdata);
66 return ret;
67 }
68 mutex_unlock(&f->sem);
69 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 }
78
79 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
80 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
81 if (ret) {
82 jffs2_free_raw_inode(ri);
83 if (S_ISLNK(inode->i_mode))
84 kfree(mdata);
85 return ret;
86 }
87 mutex_lock(&f->sem);
88 ivalid = iattr->ia_valid;
89
90 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 ri->mode = cpu_to_jemode(iattr->ia_mode);
103 else
104 ri->mode = cpu_to_jemode(inode->i_mode);
105
106
107 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
108 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
109 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
110 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
111
112 ri->offset = cpu_to_je32(0);
113 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
114 ri->compr = JFFS2_COMPR_NONE;
115 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
116 /* It's an extension. Make it a hole node */
117 ri->compr = JFFS2_COMPR_ZERO;
118 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
119 ri->offset = cpu_to_je32(inode->i_size);
120 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
121 /* For truncate-to-zero, treat it as deletion because
122 it'll always be obsoleting all previous nodes */
123 alloc_type = ALLOC_DELETION;
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
131 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
132 if (S_ISLNK(inode->i_mode))
133 kfree(mdata);
134
135 if (IS_ERR(new_metadata)) {
136 jffs2_complete_reservation(c);
137 jffs2_free_raw_inode(ri);
138 mutex_unlock(&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)
153 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
154
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 inode->i_blocks = (inode->i_size + 511) >> 9;
159 f->metadata = NULL;
160 } else {
161 f->metadata = new_metadata;
162 }
163 if (old_metadata) {
164 jffs2_mark_node_obsolete(c, old_metadata->raw);
165 jffs2_free_full_dnode(old_metadata);
166 }
167 jffs2_free_raw_inode(ri);
168
169 mutex_unlock(&f->sem);
170 jffs2_complete_reservation(c);
171
172 /* We have to do the truncate_setsize() without f->sem held, since
173 some pages may be locked and waiting for it in readpage().
174 We are protected from a simultaneous write() extending i_size
175 back past iattr->ia_size, because do_truncate() holds the
176 generic inode semaphore. */
177 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
178 truncate_setsize(inode, iattr->ia_size);
179 inode->i_blocks = (inode->i_size + 511) >> 9;
180 }
181
182 return 0;
183}
184
185int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
186{
187 int rc;
188
189 rc = inode_change_ok(dentry->d_inode, iattr);
190 if (rc)
191 return rc;
192
193 rc = jffs2_do_setattr(dentry->d_inode, iattr);
194 if (!rc && (iattr->ia_valid & ATTR_MODE))
195 rc = jffs2_acl_chmod(dentry->d_inode);
196
197 return rc;
198}
199
200int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
201{
202 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
203 unsigned long avail;
204
205 buf->f_type = JFFS2_SUPER_MAGIC;
206 buf->f_bsize = 1 << PAGE_SHIFT;
207 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
208 buf->f_files = 0;
209 buf->f_ffree = 0;
210 buf->f_namelen = JFFS2_MAX_NAME_LEN;
211 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
212 buf->f_fsid.val[1] = c->mtd->index;
213
214 spin_lock(&c->erase_completion_lock);
215 avail = c->dirty_size + c->free_size;
216 if (avail > c->sector_size * c->resv_blocks_write)
217 avail -= c->sector_size * c->resv_blocks_write;
218 else
219 avail = 0;
220 spin_unlock(&c->erase_completion_lock);
221
222 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
223
224 return 0;
225}
226
227
228void jffs2_evict_inode (struct inode *inode)
229{
230 /* We can forget about this inode for now - drop all
231 * the nodelists associated with it, etc.
232 */
233 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
234 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
235
236 D1(printk(KERN_DEBUG "jffs2_evict_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
237 truncate_inode_pages(&inode->i_data, 0);
238 end_writeback(inode);
239 jffs2_do_clear_inode(c, f);
240}
241
242struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
243{
244 struct jffs2_inode_info *f;
245 struct jffs2_sb_info *c;
246 struct jffs2_raw_inode latest_node;
247 union jffs2_device_node jdev;
248 struct inode *inode;
249 dev_t rdev = 0;
250 int ret;
251
252 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
253
254 inode = iget_locked(sb, ino);
255 if (!inode)
256 return ERR_PTR(-ENOMEM);
257 if (!(inode->i_state & I_NEW))
258 return inode;
259
260 f = JFFS2_INODE_INFO(inode);
261 c = JFFS2_SB_INFO(inode->i_sb);
262
263 jffs2_init_inode_info(f);
264 mutex_lock(&f->sem);
265
266 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
267
268 if (ret) {
269 mutex_unlock(&f->sem);
270 iget_failed(inode);
271 return ERR_PTR(ret);
272 }
273 inode->i_mode = jemode_to_cpu(latest_node.mode);
274 inode->i_uid = je16_to_cpu(latest_node.uid);
275 inode->i_gid = je16_to_cpu(latest_node.gid);
276 inode->i_size = je32_to_cpu(latest_node.isize);
277 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
278 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
279 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
280
281 inode->i_nlink = f->inocache->pino_nlink;
282
283 inode->i_blocks = (inode->i_size + 511) >> 9;
284
285 switch (inode->i_mode & S_IFMT) {
286
287 case S_IFLNK:
288 inode->i_op = &jffs2_symlink_inode_operations;
289 break;
290
291 case S_IFDIR:
292 {
293 struct jffs2_full_dirent *fd;
294 inode->i_nlink = 2; /* parent and '.' */
295
296 for (fd=f->dents; fd; fd = fd->next) {
297 if (fd->type == DT_DIR && fd->ino)
298 inc_nlink(inode);
299 }
300 /* Root dir gets i_nlink 3 for some reason */
301 if (inode->i_ino == 1)
302 inc_nlink(inode);
303
304 inode->i_op = &jffs2_dir_inode_operations;
305 inode->i_fop = &jffs2_dir_operations;
306 break;
307 }
308 case S_IFREG:
309 inode->i_op = &jffs2_file_inode_operations;
310 inode->i_fop = &jffs2_file_operations;
311 inode->i_mapping->a_ops = &jffs2_file_address_operations;
312 inode->i_mapping->nrpages = 0;
313 break;
314
315 case S_IFBLK:
316 case S_IFCHR:
317 /* Read the device numbers from the media */
318 if (f->metadata->size != sizeof(jdev.old_id) &&
319 f->metadata->size != sizeof(jdev.new_id)) {
320 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
321 goto error_io;
322 }
323 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
324 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
325 if (ret < 0) {
326 /* Eep */
327 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
328 goto error;
329 }
330 if (f->metadata->size == sizeof(jdev.old_id))
331 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
332 else
333 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
334
335 case S_IFSOCK:
336 case S_IFIFO:
337 inode->i_op = &jffs2_file_inode_operations;
338 init_special_inode(inode, inode->i_mode, rdev);
339 break;
340
341 default:
342 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
343 }
344
345 mutex_unlock(&f->sem);
346
347 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
348 unlock_new_inode(inode);
349 return inode;
350
351error_io:
352 ret = -EIO;
353error:
354 mutex_unlock(&f->sem);
355 jffs2_do_clear_inode(c, f);
356 iget_failed(inode);
357 return ERR_PTR(ret);
358}
359
360void jffs2_dirty_inode(struct inode *inode, int flags)
361{
362 struct iattr iattr;
363
364 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
365 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
366 return;
367 }
368
369 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
370
371 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
372 iattr.ia_mode = inode->i_mode;
373 iattr.ia_uid = inode->i_uid;
374 iattr.ia_gid = inode->i_gid;
375 iattr.ia_atime = inode->i_atime;
376 iattr.ia_mtime = inode->i_mtime;
377 iattr.ia_ctime = inode->i_ctime;
378
379 jffs2_do_setattr(inode, &iattr);
380}
381
382int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
383{
384 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
385
386 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
387 return -EROFS;
388
389 /* We stop if it was running, then restart if it needs to.
390 This also catches the case where it was stopped and this
391 is just a remount to restart it.
392 Flush the writebuffer, if neccecary, else we loose it */
393 if (!(sb->s_flags & MS_RDONLY)) {
394 jffs2_stop_garbage_collect_thread(c);
395 mutex_lock(&c->alloc_sem);
396 jffs2_flush_wbuf_pad(c);
397 mutex_unlock(&c->alloc_sem);
398 }
399
400 if (!(*flags & MS_RDONLY))
401 jffs2_start_garbage_collect_thread(c);
402
403 *flags |= MS_NOATIME;
404 return 0;
405}
406
407/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
408 fill in the raw_inode while you're at it. */
409struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
410{
411 struct inode *inode;
412 struct super_block *sb = dir_i->i_sb;
413 struct jffs2_sb_info *c;
414 struct jffs2_inode_info *f;
415 int ret;
416
417 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
418
419 c = JFFS2_SB_INFO(sb);
420
421 inode = new_inode(sb);
422
423 if (!inode)
424 return ERR_PTR(-ENOMEM);
425
426 f = JFFS2_INODE_INFO(inode);
427 jffs2_init_inode_info(f);
428 mutex_lock(&f->sem);
429
430 memset(ri, 0, sizeof(*ri));
431 /* Set OS-specific defaults for new inodes */
432 ri->uid = cpu_to_je16(current_fsuid());
433
434 if (dir_i->i_mode & S_ISGID) {
435 ri->gid = cpu_to_je16(dir_i->i_gid);
436 if (S_ISDIR(mode))
437 mode |= S_ISGID;
438 } else {
439 ri->gid = cpu_to_je16(current_fsgid());
440 }
441
442 /* POSIX ACLs have to be processed now, at least partly.
443 The umask is only applied if there's no default ACL */
444 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
445 if (ret) {
446 make_bad_inode(inode);
447 iput(inode);
448 return ERR_PTR(ret);
449 }
450 ret = jffs2_do_new_inode (c, f, mode, ri);
451 if (ret) {
452 make_bad_inode(inode);
453 iput(inode);
454 return ERR_PTR(ret);
455 }
456 inode->i_nlink = 1;
457 inode->i_ino = je32_to_cpu(ri->ino);
458 inode->i_mode = jemode_to_cpu(ri->mode);
459 inode->i_gid = je16_to_cpu(ri->gid);
460 inode->i_uid = je16_to_cpu(ri->uid);
461 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
462 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
463
464 inode->i_blocks = 0;
465 inode->i_size = 0;
466
467 if (insert_inode_locked(inode) < 0) {
468 make_bad_inode(inode);
469 unlock_new_inode(inode);
470 iput(inode);
471 return ERR_PTR(-EINVAL);
472 }
473
474 return inode;
475}
476
477static int calculate_inocache_hashsize(uint32_t flash_size)
478{
479 /*
480 * Pick a inocache hash size based on the size of the medium.
481 * Count how many megabytes we're dealing with, apply a hashsize twice
482 * that size, but rounding down to the usual big powers of 2. And keep
483 * to sensible bounds.
484 */
485
486 int size_mb = flash_size / 1024 / 1024;
487 int hashsize = (size_mb * 2) & ~0x3f;
488
489 if (hashsize < INOCACHE_HASHSIZE_MIN)
490 return INOCACHE_HASHSIZE_MIN;
491 if (hashsize > INOCACHE_HASHSIZE_MAX)
492 return INOCACHE_HASHSIZE_MAX;
493
494 return hashsize;
495}
496
497int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
498{
499 struct jffs2_sb_info *c;
500 struct inode *root_i;
501 int ret;
502 size_t blocks;
503
504 c = JFFS2_SB_INFO(sb);
505
506#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
507 if (c->mtd->type == MTD_NANDFLASH) {
508 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
509 return -EINVAL;
510 }
511 if (c->mtd->type == MTD_DATAFLASH) {
512 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
513 return -EINVAL;
514 }
515#endif
516
517 c->flash_size = c->mtd->size;
518 c->sector_size = c->mtd->erasesize;
519 blocks = c->flash_size / c->sector_size;
520
521 /*
522 * Size alignment check
523 */
524 if ((c->sector_size * blocks) != c->flash_size) {
525 c->flash_size = c->sector_size * blocks;
526 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
527 c->flash_size / 1024);
528 }
529
530 if (c->flash_size < 5*c->sector_size) {
531 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
532 return -EINVAL;
533 }
534
535 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
536
537 /* NAND (or other bizarre) flash... do setup accordingly */
538 ret = jffs2_flash_setup(c);
539 if (ret)
540 return ret;
541
542 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
543 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
544 if (!c->inocache_list) {
545 ret = -ENOMEM;
546 goto out_wbuf;
547 }
548
549 jffs2_init_xattr_subsystem(c);
550
551 if ((ret = jffs2_do_mount_fs(c)))
552 goto out_inohash;
553
554 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
555 root_i = jffs2_iget(sb, 1);
556 if (IS_ERR(root_i)) {
557 D1(printk(KERN_WARNING "get root inode failed\n"));
558 ret = PTR_ERR(root_i);
559 goto out_root;
560 }
561
562 ret = -ENOMEM;
563
564 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
565 sb->s_root = d_alloc_root(root_i);
566 if (!sb->s_root)
567 goto out_root_i;
568
569 sb->s_maxbytes = 0xFFFFFFFF;
570 sb->s_blocksize = PAGE_CACHE_SIZE;
571 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
572 sb->s_magic = JFFS2_SUPER_MAGIC;
573 if (!(sb->s_flags & MS_RDONLY))
574 jffs2_start_garbage_collect_thread(c);
575 return 0;
576
577 out_root_i:
578 iput(root_i);
579out_root:
580 jffs2_free_ino_caches(c);
581 jffs2_free_raw_node_refs(c);
582 if (jffs2_blocks_use_vmalloc(c))
583 vfree(c->blocks);
584 else
585 kfree(c->blocks);
586 out_inohash:
587 jffs2_clear_xattr_subsystem(c);
588 kfree(c->inocache_list);
589 out_wbuf:
590 jffs2_flash_cleanup(c);
591
592 return ret;
593}
594
595void jffs2_gc_release_inode(struct jffs2_sb_info *c,
596 struct jffs2_inode_info *f)
597{
598 iput(OFNI_EDONI_2SFFJ(f));
599}
600
601struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
602 int inum, int unlinked)
603{
604 struct inode *inode;
605 struct jffs2_inode_cache *ic;
606
607 if (unlinked) {
608 /* The inode has zero nlink but its nodes weren't yet marked
609 obsolete. This has to be because we're still waiting for
610 the final (close() and) iput() to happen.
611
612 There's a possibility that the final iput() could have
613 happened while we were contemplating. In order to ensure
614 that we don't cause a new read_inode() (which would fail)
615 for the inode in question, we use ilookup() in this case
616 instead of iget().
617
618 The nlink can't _become_ zero at this point because we're
619 holding the alloc_sem, and jffs2_do_unlink() would also
620 need that while decrementing nlink on any inode.
621 */
622 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
623 if (!inode) {
624 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
625 inum));
626
627 spin_lock(&c->inocache_lock);
628 ic = jffs2_get_ino_cache(c, inum);
629 if (!ic) {
630 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
631 spin_unlock(&c->inocache_lock);
632 return NULL;
633 }
634 if (ic->state != INO_STATE_CHECKEDABSENT) {
635 /* Wait for progress. Don't just loop */
636 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
637 ic->ino, ic->state));
638 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
639 } else {
640 spin_unlock(&c->inocache_lock);
641 }
642
643 return NULL;
644 }
645 } else {
646 /* Inode has links to it still; they're not going away because
647 jffs2_do_unlink() would need the alloc_sem and we have it.
648 Just iget() it, and if read_inode() is necessary that's OK.
649 */
650 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
651 if (IS_ERR(inode))
652 return ERR_CAST(inode);
653 }
654 if (is_bad_inode(inode)) {
655 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. unlinked %d\n",
656 inum, unlinked);
657 /* NB. This will happen again. We need to do something appropriate here. */
658 iput(inode);
659 return ERR_PTR(-EIO);
660 }
661
662 return JFFS2_INODE_INFO(inode);
663}
664
665unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
666 struct jffs2_inode_info *f,
667 unsigned long offset,
668 unsigned long *priv)
669{
670 struct inode *inode = OFNI_EDONI_2SFFJ(f);
671 struct page *pg;
672
673 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
674 (void *)jffs2_do_readpage_unlock, inode);
675 if (IS_ERR(pg))
676 return (void *)pg;
677
678 *priv = (unsigned long)pg;
679 return kmap(pg);
680}
681
682void jffs2_gc_release_page(struct jffs2_sb_info *c,
683 unsigned char *ptr,
684 unsigned long *priv)
685{
686 struct page *pg = (void *)*priv;
687
688 kunmap(pg);
689 page_cache_release(pg);
690}
691
692static int jffs2_flash_setup(struct jffs2_sb_info *c) {
693 int ret = 0;
694
695 if (jffs2_cleanmarker_oob(c)) {
696 /* NAND flash... do setup accordingly */
697 ret = jffs2_nand_flash_setup(c);
698 if (ret)
699 return ret;
700 }
701
702 /* and Dataflash */
703 if (jffs2_dataflash(c)) {
704 ret = jffs2_dataflash_setup(c);
705 if (ret)
706 return ret;
707 }
708
709 /* and Intel "Sibley" flash */
710 if (jffs2_nor_wbuf_flash(c)) {
711 ret = jffs2_nor_wbuf_flash_setup(c);
712 if (ret)
713 return ret;
714 }
715
716 /* and an UBI volume */
717 if (jffs2_ubivol(c)) {
718 ret = jffs2_ubivol_setup(c);
719 if (ret)
720 return ret;
721 }
722
723 return ret;
724}
725
726void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
727
728 if (jffs2_cleanmarker_oob(c)) {
729 jffs2_nand_flash_cleanup(c);
730 }
731
732 /* and DataFlash */
733 if (jffs2_dataflash(c)) {
734 jffs2_dataflash_cleanup(c);
735 }
736
737 /* and Intel "Sibley" flash */
738 if (jffs2_nor_wbuf_flash(c)) {
739 jffs2_nor_wbuf_flash_cleanup(c);
740 }
741
742 /* and an UBI volume */
743 if (jffs2_ubivol(c)) {
744 jffs2_ubivol_cleanup(c);
745 }
746}