blob: 2e0123867cb1b67b1a6a88d9f03439af1da4c204 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
David Woodhousec00c3102007-04-25 14:16:47 +01004 * Copyright © 2001-2007 Red Hat, Inc.
David Woodhouse6088c052010-08-08 14:15:22 +01005 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 *
9 * For licensing information, see the file 'LICENCE' in this directory.
10 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080013#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#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
David Woodhouse9ed437c2007-08-22 12:39:19 +010028int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070029{
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;
David Woodhouseaef9ab42006-05-19 00:28:49 +010034 union jffs2_device_node dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 unsigned char *mdata = NULL;
36 int mdatalen = 0;
37 unsigned int ivalid;
David Woodhouse9fe48542006-05-23 00:38:06 +010038 uint32_t alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 int ret;
David Woodhousedd919662008-02-25 15:25:25 +000040 int alloc_type = ALLOC_NORMAL;
David Woodhouse9ed437c2007-08-22 12:39:19 +010041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
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 */
David Woodhouseaef9ab42006-05-19 00:28:49 +010051 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 mdata = (char *)&dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
54 } else if (S_ISLNK(inode->i_mode)) {
David Woodhouseced22072008-04-22 15:13:40 +010055 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 mdatalen = f->metadata->size;
57 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010058 if (!mdata) {
David Woodhouseced22072008-04-22 15:13:40 +010059 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010061 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
63 if (ret) {
David Woodhouseced22072008-04-22 15:13:40 +010064 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 kfree(mdata);
66 return ret;
67 }
David Woodhouseced22072008-04-22 15:13:40 +010068 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 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 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000078
David Woodhouse9fe48542006-05-23 00:38:06 +010079 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
80 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 if (ret) {
82 jffs2_free_raw_inode(ri);
Al Viro61effb52011-07-24 17:11:33 -040083 if (S_ISLNK(inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 kfree(mdata);
85 return ret;
86 }
David Woodhouseced22072008-04-22 15:13:40 +010087 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 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)
David Woodhouse857013b2007-11-01 16:27:38 -0400102 ri->mode = cpu_to_jemode(iattr->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 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);
David Woodhousedd919662008-02-25 15:25:25 +0000120 } 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 }
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
David Woodhousedd919662008-02-25 15:25:25 +0000131 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 if (S_ISLNK(inode->i_mode))
133 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 if (IS_ERR(new_metadata)) {
136 jffs2_complete_reservation(c);
137 jffs2_free_raw_inode(ri);
David Woodhouseced22072008-04-22 15:13:40 +0100138 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 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)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100153 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
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;
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000158 inode->i_blocks = (inode->i_size + 511) >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 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
David Woodhouseced22072008-04-22 15:13:40 +0100169 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 jffs2_complete_reservation(c);
171
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200172 /* We have to do the truncate_setsize() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000173 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 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. */
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000177 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200178 truncate_setsize(inode, iattr->ia_size);
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000179 inode->i_blocks = (inode->i_size + 511) >> 9;
180 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 return 0;
183}
184
185int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
186{
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900187 int rc;
188
David Woodhouse9ed437c2007-08-22 12:39:19 +0100189 rc = inode_change_ok(dentry->d_inode, iattr);
190 if (rc)
191 return rc;
192
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900193 rc = jffs2_do_setattr(dentry->d_inode, iattr);
194 if (!rc && (iattr->ia_valid & ATTR_MODE))
195 rc = jffs2_acl_chmod(dentry->d_inode);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100196
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900197 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198}
199
David Howells726c3342006-06-23 02:02:58 -0700200int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
David Howells726c3342006-06-23 02:02:58 -0700202 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 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;
David Woodhouse75caf6b2008-08-18 16:23:53 +0100211 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
212 buf->f_fsid.val[1] = c->mtd->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 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;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100220 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 return 0;
225}
226
227
Al Virob57922d2010-06-07 14:34:48 -0400228void jffs2_evict_inode (struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000230 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 * 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);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000235
Al Virob57922d2010-06-07 14:34:48 -0400236 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 jffs2_do_clear_inode(c, f);
240}
241
David Howells5451f792008-02-07 00:15:42 -0800242struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
244 struct jffs2_inode_info *f;
245 struct jffs2_sb_info *c;
246 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100247 union jffs2_device_node jdev;
David Howells5451f792008-02-07 00:15:42 -0800248 struct inode *inode;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100249 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 int ret;
251
David Howells5451f792008-02-07 00:15:42 -0800252 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260 f = JFFS2_INODE_INFO(inode);
261 c = JFFS2_SB_INFO(inode->i_sb);
262
263 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100264 mutex_lock(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
267
268 if (ret) {
David Woodhouseced22072008-04-22 15:13:40 +0100269 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800270 iget_failed(inode);
271 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
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
Miklos Szeredibfe86842011-10-28 14:13:29 +0200281 set_nlink(inode, f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 case S_IFLNK:
288 inode->i_op = &jffs2_symlink_inode_operations;
289 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 case S_IFDIR:
292 {
293 struct jffs2_full_dirent *fd;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200294 set_nlink(inode, 2); /* parent and '.' */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 for (fd=f->dents; fd; fd = fd->next) {
297 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700298 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 /* Root dir gets i_nlink 3 for some reason */
301 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700302 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
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 */
Andrew Morton91f80262010-02-02 14:43:10 -0800318 if (f->metadata->size != sizeof(jdev.old_id) &&
319 f->metadata->size != sizeof(jdev.new_id)) {
David Woodhouseaef9ab42006-05-19 00:28:49 +0100320 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
David Howells5451f792008-02-07 00:15:42 -0800321 goto error_io;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
David Howells5451f792008-02-07 00:15:42 -0800324 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
325 if (ret < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 /* Eep */
327 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
David Howells5451f792008-02-07 00:15:42 -0800328 goto error;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000329 }
Andrew Morton91f80262010-02-02 14:43:10 -0800330 if (f->metadata->size == sizeof(jdev.old_id))
331 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100332 else
Andrew Morton91f80262010-02-02 14:43:10 -0800333 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
335 case S_IFSOCK:
336 case S_IFIFO:
337 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100338 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 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
David Woodhouseced22072008-04-22 15:13:40 +0100345 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
David Howells5451f792008-02-07 00:15:42 -0800348 unlock_new_inode(inode);
349 return inode;
350
351error_io:
352 ret = -EIO;
353error:
David Woodhouseced22072008-04-22 15:13:40 +0100354 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800355 jffs2_do_clear_inode(c, f);
356 iget_failed(inode);
357 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
Christoph Hellwigaa385722011-05-27 06:53:02 -0400360void jffs2_dirty_inode(struct inode *inode, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
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
Andres Salomon92abc472011-10-16 18:15:16 -0700382int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
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);
David Woodhouseced22072008-04-22 15:13:40 +0100395 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100397 mutex_unlock(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000398 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
400 if (!(*flags & MS_RDONLY))
401 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 *flags |= MS_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 return 0;
405}
406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407/* 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. */
Al Virod3fb6122011-07-23 18:37:50 -0400409struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
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);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 if (!inode)
424 return ERR_PTR(-ENOMEM);
425
426 f = JFFS2_INODE_INFO(inode);
427 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100428 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
430 memset(ri, 0, sizeof(*ri));
431 /* Set OS-specific defaults for new inodes */
David Howells3fc678a2008-08-27 14:48:32 +0100432 ri->uid = cpu_to_je16(current_fsuid());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
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 {
David Howells3fc678a2008-08-27 14:48:32 +0100439 ri->gid = cpu_to_je16(current_fsgid());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
David Woodhouse9ed437c2007-08-22 12:39:19 +0100441
442 /* POSIX ACLs have to be processed now, at least partly.
443 The umask is only applied if there's no default ACL */
KaiGai Koheicfc8dc62007-09-14 15:16:35 +0900444 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);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 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 }
Miklos Szeredibfe86842011-10-28 14:13:29 +0200456 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 inode->i_blocks = 0;
465 inode->i_size = 0;
466
David Woodhousee72e6492010-06-03 08:09:12 +0100467 if (insert_inode_locked(inode) < 0) {
468 make_bad_inode(inode);
David Woodhousee72e6492010-06-03 08:09:12 +0100469 iput(inode);
470 return ERR_PTR(-EINVAL);
471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 return inode;
474}
475
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100476static int calculate_inocache_hashsize(uint32_t flash_size)
477{
478 /*
479 * Pick a inocache hash size based on the size of the medium.
480 * Count how many megabytes we're dealing with, apply a hashsize twice
481 * that size, but rounding down to the usual big powers of 2. And keep
482 * to sensible bounds.
483 */
484
485 int size_mb = flash_size / 1024 / 1024;
486 int hashsize = (size_mb * 2) & ~0x3f;
487
488 if (hashsize < INOCACHE_HASHSIZE_MIN)
489 return INOCACHE_HASHSIZE_MIN;
490 if (hashsize > INOCACHE_HASHSIZE_MAX)
491 return INOCACHE_HASHSIZE_MAX;
492
493 return hashsize;
494}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
496int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
497{
498 struct jffs2_sb_info *c;
499 struct inode *root_i;
500 int ret;
501 size_t blocks;
502
503 c = JFFS2_SB_INFO(sb);
504
Andrew Victor2f82ce12005-02-09 09:24:26 +0000505#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 if (c->mtd->type == MTD_NANDFLASH) {
507 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
508 return -EINVAL;
509 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000510 if (c->mtd->type == MTD_DATAFLASH) {
511 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
512 return -EINVAL;
513 }
514#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000517 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 /*
521 * Size alignment check
522 */
523 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000524 c->flash_size = c->sector_size * blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
526 c->flash_size / 1024);
527 }
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 if (c->flash_size < 5*c->sector_size) {
530 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
531 return -EINVAL;
532 }
533
534 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
536 /* NAND (or other bizarre) flash... do setup accordingly */
537 ret = jffs2_flash_setup(c);
538 if (ret)
539 return ret;
540
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100541 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
542 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (!c->inocache_list) {
544 ret = -ENOMEM;
545 goto out_wbuf;
546 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900548 jffs2_init_xattr_subsystem(c);
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if ((ret = jffs2_do_mount_fs(c)))
551 goto out_inohash;
552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
David Howells5451f792008-02-07 00:15:42 -0800554 root_i = jffs2_iget(sb, 1);
555 if (IS_ERR(root_i)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 D1(printk(KERN_WARNING "get root inode failed\n"));
David Howells5451f792008-02-07 00:15:42 -0800557 ret = PTR_ERR(root_i);
558 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
560
David Howells5451f792008-02-07 00:15:42 -0800561 ret = -ENOMEM;
562
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
564 sb->s_root = d_alloc_root(root_i);
565 if (!sb->s_root)
566 goto out_root_i;
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 sb->s_blocksize = PAGE_CACHE_SIZE;
570 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
571 sb->s_magic = JFFS2_SUPER_MAGIC;
572 if (!(sb->s_flags & MS_RDONLY))
573 jffs2_start_garbage_collect_thread(c);
574 return 0;
575
576 out_root_i:
577 iput(root_i);
David Howells5451f792008-02-07 00:15:42 -0800578out_root:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 jffs2_free_ino_caches(c);
580 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100581 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 vfree(c->blocks);
583 else
584 kfree(c->blocks);
585 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900586 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 kfree(c->inocache_list);
588 out_wbuf:
589 jffs2_flash_cleanup(c);
590
591 return ret;
592}
593
594void jffs2_gc_release_inode(struct jffs2_sb_info *c,
595 struct jffs2_inode_info *f)
596{
597 iput(OFNI_EDONI_2SFFJ(f));
598}
599
600struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
David Woodhouse1b690b42008-05-01 16:59:24 +0100601 int inum, int unlinked)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 struct inode *inode;
604 struct jffs2_inode_cache *ic;
David Woodhouse1b690b42008-05-01 16:59:24 +0100605
606 if (unlinked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000608 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 the final (close() and) iput() to happen.
610
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000611 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 happened while we were contemplating. In order to ensure
613 that we don't cause a new read_inode() (which would fail)
614 for the inode in question, we use ilookup() in this case
615 instead of iget().
616
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000617 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 holding the alloc_sem, and jffs2_do_unlink() would also
619 need that while decrementing nlink on any inode.
620 */
621 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
622 if (!inode) {
623 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
624 inum));
625
626 spin_lock(&c->inocache_lock);
627 ic = jffs2_get_ino_cache(c, inum);
628 if (!ic) {
629 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
630 spin_unlock(&c->inocache_lock);
631 return NULL;
632 }
633 if (ic->state != INO_STATE_CHECKEDABSENT) {
634 /* Wait for progress. Don't just loop */
635 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
636 ic->ino, ic->state));
637 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
638 } else {
639 spin_unlock(&c->inocache_lock);
640 }
641
642 return NULL;
643 }
644 } else {
645 /* Inode has links to it still; they're not going away because
646 jffs2_do_unlink() would need the alloc_sem and we have it.
647 Just iget() it, and if read_inode() is necessary that's OK.
648 */
David Howells5451f792008-02-07 00:15:42 -0800649 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
650 if (IS_ERR(inode))
651 return ERR_CAST(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 }
653 if (is_bad_inode(inode)) {
David Woodhouse1b690b42008-05-01 16:59:24 +0100654 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. unlinked %d\n",
655 inum, unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 /* NB. This will happen again. We need to do something appropriate here. */
657 iput(inode);
658 return ERR_PTR(-EIO);
659 }
660
661 return JFFS2_INODE_INFO(inode);
662}
663
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000664unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
665 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 unsigned long offset,
667 unsigned long *priv)
668{
669 struct inode *inode = OFNI_EDONI_2SFFJ(f);
670 struct page *pg;
671
Jason Lunzfc0e0192007-09-01 12:06:03 -0700672 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 (void *)jffs2_do_readpage_unlock, inode);
674 if (IS_ERR(pg))
675 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 *priv = (unsigned long)pg;
678 return kmap(pg);
679}
680
681void jffs2_gc_release_page(struct jffs2_sb_info *c,
682 unsigned char *ptr,
683 unsigned long *priv)
684{
685 struct page *pg = (void *)*priv;
686
687 kunmap(pg);
688 page_cache_release(pg);
689}
690
691static int jffs2_flash_setup(struct jffs2_sb_info *c) {
692 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 if (jffs2_cleanmarker_oob(c)) {
695 /* NAND flash... do setup accordingly */
696 ret = jffs2_nand_flash_setup(c);
697 if (ret)
698 return ret;
699 }
700
Andrew Victor8f15fd52005-02-09 09:17:45 +0000701 /* and Dataflash */
702 if (jffs2_dataflash(c)) {
703 ret = jffs2_dataflash_setup(c);
704 if (ret)
705 return ret;
706 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100707
708 /* and Intel "Sibley" flash */
709 if (jffs2_nor_wbuf_flash(c)) {
710 ret = jffs2_nor_wbuf_flash_setup(c);
711 if (ret)
712 return ret;
713 }
714
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300715 /* and an UBI volume */
716 if (jffs2_ubivol(c)) {
717 ret = jffs2_ubivol_setup(c);
718 if (ret)
719 return ret;
720 }
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 return ret;
723}
724
725void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
726
727 if (jffs2_cleanmarker_oob(c)) {
728 jffs2_nand_flash_cleanup(c);
729 }
730
Andrew Victor8f15fd52005-02-09 09:17:45 +0000731 /* and DataFlash */
732 if (jffs2_dataflash(c)) {
733 jffs2_dataflash_cleanup(c);
734 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100735
736 /* and Intel "Sibley" flash */
737 if (jffs2_nor_wbuf_flash(c)) {
738 jffs2_nor_wbuf_flash_cleanup(c);
739 }
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300740
741 /* and an UBI volume */
742 if (jffs2_ubivol(c)) {
743 jffs2_ubivol_cleanup(c);
744 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}