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