blob: 09b3ed45572475feb68b117fcf5b420a1a5e4d8f [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
Joe Perches5a528952012-02-15 15:56:45 -080013#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080015#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/kernel.h>
17#include <linux/sched.h>
18#include <linux/fs.h>
19#include <linux/list.h>
20#include <linux/mtd/mtd.h>
21#include <linux/pagemap.h>
22#include <linux/slab.h>
23#include <linux/vmalloc.h>
24#include <linux/vfs.h>
25#include <linux/crc32.h>
26#include "nodelist.h"
27
28static int jffs2_flash_setup(struct jffs2_sb_info *c);
29
David Woodhouse9ed437c2007-08-22 12:39:19 +010030int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070031{
32 struct jffs2_full_dnode *old_metadata, *new_metadata;
33 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
34 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
35 struct jffs2_raw_inode *ri;
David Woodhouseaef9ab42006-05-19 00:28:49 +010036 union jffs2_device_node dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 unsigned char *mdata = NULL;
38 int mdatalen = 0;
39 unsigned int ivalid;
David Woodhouse9fe48542006-05-23 00:38:06 +010040 uint32_t alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 int ret;
David Woodhousedd919662008-02-25 15:25:25 +000042 int alloc_type = ALLOC_NORMAL;
David Woodhouse9ed437c2007-08-22 12:39:19 +010043
Joe Perches9c261b32012-02-15 15:56:43 -080044 jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46 /* Special cases - we don't want more than one data node
47 for these types on the medium at any time. So setattr
48 must read the original data associated with the node
49 (i.e. the device numbers or the target name) and write
50 it out again with the appropriate data attached */
51 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
52 /* For these, we don't actually need to read the old node */
David Woodhouseaef9ab42006-05-19 00:28:49 +010053 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 mdata = (char *)&dev;
Joe Perches9c261b32012-02-15 15:56:43 -080055 jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
56 __func__, mdatalen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 } else if (S_ISLNK(inode->i_mode)) {
David Woodhouseced22072008-04-22 15:13:40 +010058 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 mdatalen = f->metadata->size;
60 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010061 if (!mdata) {
David Woodhouseced22072008-04-22 15:13:40 +010062 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
66 if (ret) {
David Woodhouseced22072008-04-22 15:13:40 +010067 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 kfree(mdata);
69 return ret;
70 }
David Woodhouseced22072008-04-22 15:13:40 +010071 mutex_unlock(&f->sem);
Joe Perches9c261b32012-02-15 15:56:43 -080072 jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
73 __func__, mdatalen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 }
75
76 ri = jffs2_alloc_raw_inode();
77 if (!ri) {
78 if (S_ISLNK(inode->i_mode))
79 kfree(mdata);
80 return -ENOMEM;
81 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000082
David Woodhouse9fe48542006-05-23 00:38:06 +010083 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
84 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 if (ret) {
86 jffs2_free_raw_inode(ri);
Al Viro61effb52011-07-24 17:11:33 -040087 if (S_ISLNK(inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 kfree(mdata);
89 return ret;
90 }
David Woodhouseced22072008-04-22 15:13:40 +010091 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000093
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
95 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
96 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
97 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
98
99 ri->ino = cpu_to_je32(inode->i_ino);
100 ri->version = cpu_to_je32(++f->highest_version);
101
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800102 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
103 from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
104 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
105 from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 if (ivalid & ATTR_MODE)
David Woodhouse857013b2007-11-01 16:27:38 -0400108 ri->mode = cpu_to_jemode(iattr->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 else
110 ri->mode = cpu_to_jemode(inode->i_mode);
111
112
113 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
114 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
115 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
116 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
117
118 ri->offset = cpu_to_je32(0);
119 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
120 ri->compr = JFFS2_COMPR_NONE;
121 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
122 /* It's an extension. Make it a hole node */
123 ri->compr = JFFS2_COMPR_ZERO;
124 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
125 ri->offset = cpu_to_je32(inode->i_size);
David Woodhousedd919662008-02-25 15:25:25 +0000126 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
127 /* For truncate-to-zero, treat it as deletion because
128 it'll always be obsoleting all previous nodes */
129 alloc_type = ALLOC_DELETION;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 }
131 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
132 if (mdatalen)
133 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
134 else
135 ri->data_crc = cpu_to_je32(0);
136
David Woodhousedd919662008-02-25 15:25:25 +0000137 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 if (S_ISLNK(inode->i_mode))
139 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 if (IS_ERR(new_metadata)) {
142 jffs2_complete_reservation(c);
143 jffs2_free_raw_inode(ri);
David Woodhouseced22072008-04-22 15:13:40 +0100144 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 return PTR_ERR(new_metadata);
146 }
147 /* It worked. Update the inode */
148 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
149 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
150 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
151 inode->i_mode = jemode_to_cpu(ri->mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800152 i_uid_write(inode, je16_to_cpu(ri->uid));
153 i_gid_write(inode, je16_to_cpu(ri->gid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155
156 old_metadata = f->metadata;
157
158 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100159 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
162 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
163 inode->i_size = iattr->ia_size;
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000164 inode->i_blocks = (inode->i_size + 511) >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 f->metadata = NULL;
166 } else {
167 f->metadata = new_metadata;
168 }
169 if (old_metadata) {
170 jffs2_mark_node_obsolete(c, old_metadata->raw);
171 jffs2_free_full_dnode(old_metadata);
172 }
173 jffs2_free_raw_inode(ri);
174
David Woodhouseced22072008-04-22 15:13:40 +0100175 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 jffs2_complete_reservation(c);
177
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200178 /* We have to do the truncate_setsize() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000179 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 We are protected from a simultaneous write() extending i_size
181 back past iattr->ia_size, because do_truncate() holds the
182 generic inode semaphore. */
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000183 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200184 truncate_setsize(inode, iattr->ia_size);
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000185 inode->i_blocks = (inode->i_size + 511) >> 9;
186 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 return 0;
189}
190
191int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
192{
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900193 int rc;
194
David Woodhouse9ed437c2007-08-22 12:39:19 +0100195 rc = inode_change_ok(dentry->d_inode, iattr);
196 if (rc)
197 return rc;
198
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900199 rc = jffs2_do_setattr(dentry->d_inode, iattr);
200 if (!rc && (iattr->ia_valid & ATTR_MODE))
201 rc = jffs2_acl_chmod(dentry->d_inode);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100202
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900203 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204}
205
David Howells726c3342006-06-23 02:02:58 -0700206int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
David Howells726c3342006-06-23 02:02:58 -0700208 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 unsigned long avail;
210
211 buf->f_type = JFFS2_SUPER_MAGIC;
212 buf->f_bsize = 1 << PAGE_SHIFT;
213 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
214 buf->f_files = 0;
215 buf->f_ffree = 0;
216 buf->f_namelen = JFFS2_MAX_NAME_LEN;
David Woodhouse75caf6b2008-08-18 16:23:53 +0100217 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
218 buf->f_fsid.val[1] = c->mtd->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 avail = c->dirty_size + c->free_size;
222 if (avail > c->sector_size * c->resv_blocks_write)
223 avail -= c->sector_size * c->resv_blocks_write;
224 else
225 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100226 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return 0;
231}
232
233
Al Virob57922d2010-06-07 14:34:48 -0400234void jffs2_evict_inode (struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000236 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 * the nodelists associated with it, etc.
238 */
239 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
240 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000241
Joe Perches9c261b32012-02-15 15:56:43 -0800242 jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
243 __func__, inode->i_ino, inode->i_mode);
Al Virob57922d2010-06-07 14:34:48 -0400244 truncate_inode_pages(&inode->i_data, 0);
Jan Karadbd57682012-05-03 14:48:02 +0200245 clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 jffs2_do_clear_inode(c, f);
247}
248
David Howells5451f792008-02-07 00:15:42 -0800249struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
251 struct jffs2_inode_info *f;
252 struct jffs2_sb_info *c;
253 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100254 union jffs2_device_node jdev;
David Howells5451f792008-02-07 00:15:42 -0800255 struct inode *inode;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100256 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 int ret;
258
Joe Perches9c261b32012-02-15 15:56:43 -0800259 jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
David Howells5451f792008-02-07 00:15:42 -0800260
261 inode = iget_locked(sb, ino);
262 if (!inode)
263 return ERR_PTR(-ENOMEM);
264 if (!(inode->i_state & I_NEW))
265 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
267 f = JFFS2_INODE_INFO(inode);
268 c = JFFS2_SB_INFO(inode->i_sb);
269
270 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100271 mutex_lock(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
274
275 if (ret) {
David Woodhouseced22072008-04-22 15:13:40 +0100276 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800277 iget_failed(inode);
278 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280 inode->i_mode = jemode_to_cpu(latest_node.mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800281 i_uid_write(inode, je16_to_cpu(latest_node.uid));
282 i_gid_write(inode, je16_to_cpu(latest_node.gid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 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
Miklos Szeredibfe86842011-10-28 14:13:29 +0200288 set_nlink(inode, f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 case S_IFLNK:
295 inode->i_op = &jffs2_symlink_inode_operations;
296 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 case S_IFDIR:
299 {
300 struct jffs2_full_dirent *fd;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200301 set_nlink(inode, 2); /* parent and '.' */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 for (fd=f->dents; fd; fd = fd->next) {
304 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700305 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 /* Root dir gets i_nlink 3 for some reason */
308 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700309 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
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 */
Andrew Morton91f80262010-02-02 14:43:10 -0800325 if (f->metadata->size != sizeof(jdev.old_id) &&
326 f->metadata->size != sizeof(jdev.new_id)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800327 pr_notice("Device node has strange size %d\n",
328 f->metadata->size);
David Howells5451f792008-02-07 00:15:42 -0800329 goto error_io;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100330 }
Joe Perches9c261b32012-02-15 15:56:43 -0800331 jffs2_dbg(1, "Reading device numbers from flash\n");
David Howells5451f792008-02-07 00:15:42 -0800332 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
333 if (ret < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 /* Eep */
Joe Perchesda320f02012-02-15 15:56:44 -0800335 pr_notice("Read device numbers for inode %lu failed\n",
336 (unsigned long)inode->i_ino);
David Howells5451f792008-02-07 00:15:42 -0800337 goto error;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000338 }
Andrew Morton91f80262010-02-02 14:43:10 -0800339 if (f->metadata->size == sizeof(jdev.old_id))
340 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100341 else
Andrew Morton91f80262010-02-02 14:43:10 -0800342 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 case S_IFSOCK:
345 case S_IFIFO:
346 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100347 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 break;
349
350 default:
Joe Perchesda320f02012-02-15 15:56:44 -0800351 pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
352 __func__, inode->i_mode, (unsigned long)inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 }
354
David Woodhouseced22072008-04-22 15:13:40 +0100355 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Joe Perches9c261b32012-02-15 15:56:43 -0800357 jffs2_dbg(1, "jffs2_read_inode() returning\n");
David Howells5451f792008-02-07 00:15:42 -0800358 unlock_new_inode(inode);
359 return inode;
360
361error_io:
362 ret = -EIO;
363error:
David Woodhouseced22072008-04-22 15:13:40 +0100364 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800365 jffs2_do_clear_inode(c, f);
366 iget_failed(inode);
367 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368}
369
Christoph Hellwigaa385722011-05-27 06:53:02 -0400370void jffs2_dirty_inode(struct inode *inode, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
372 struct iattr iattr;
373
374 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800375 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
376 __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return;
378 }
379
Joe Perches9c261b32012-02-15 15:56:43 -0800380 jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
381 __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
384 iattr.ia_mode = inode->i_mode;
385 iattr.ia_uid = inode->i_uid;
386 iattr.ia_gid = inode->i_gid;
387 iattr.ia_atime = inode->i_atime;
388 iattr.ia_mtime = inode->i_mtime;
389 iattr.ia_ctime = inode->i_ctime;
390
391 jffs2_do_setattr(inode, &iattr);
392}
393
Andres Salomon92abc472011-10-16 18:15:16 -0700394int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
396 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
397
398 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
399 return -EROFS;
400
401 /* We stop if it was running, then restart if it needs to.
402 This also catches the case where it was stopped and this
403 is just a remount to restart it.
404 Flush the writebuffer, if neccecary, else we loose it */
405 if (!(sb->s_flags & MS_RDONLY)) {
406 jffs2_stop_garbage_collect_thread(c);
David Woodhouseced22072008-04-22 15:13:40 +0100407 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100409 mutex_unlock(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000410 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
412 if (!(*flags & MS_RDONLY))
413 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 *flags |= MS_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return 0;
417}
418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
420 fill in the raw_inode while you're at it. */
Al Virod3fb6122011-07-23 18:37:50 -0400421struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 struct inode *inode;
424 struct super_block *sb = dir_i->i_sb;
425 struct jffs2_sb_info *c;
426 struct jffs2_inode_info *f;
427 int ret;
428
Joe Perches9c261b32012-02-15 15:56:43 -0800429 jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
430 __func__, dir_i->i_ino, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
432 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 if (!inode)
437 return ERR_PTR(-ENOMEM);
438
439 f = JFFS2_INODE_INFO(inode);
440 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100441 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 memset(ri, 0, sizeof(*ri));
444 /* Set OS-specific defaults for new inodes */
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800445 ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 if (dir_i->i_mode & S_ISGID) {
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800448 ri->gid = cpu_to_je16(i_gid_read(dir_i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (S_ISDIR(mode))
450 mode |= S_ISGID;
451 } else {
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800452 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
David Woodhouse9ed437c2007-08-22 12:39:19 +0100454
455 /* POSIX ACLs have to be processed now, at least partly.
456 The umask is only applied if there's no default ACL */
KaiGai Koheicfc8dc62007-09-14 15:16:35 +0900457 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
458 if (ret) {
459 make_bad_inode(inode);
460 iput(inode);
461 return ERR_PTR(ret);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 ret = jffs2_do_new_inode (c, f, mode, ri);
464 if (ret) {
465 make_bad_inode(inode);
466 iput(inode);
467 return ERR_PTR(ret);
468 }
Miklos Szeredibfe86842011-10-28 14:13:29 +0200469 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 inode->i_ino = je32_to_cpu(ri->ino);
471 inode->i_mode = jemode_to_cpu(ri->mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800472 i_gid_write(inode, je16_to_cpu(ri->gid));
473 i_uid_write(inode, je16_to_cpu(ri->uid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
475 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 inode->i_blocks = 0;
478 inode->i_size = 0;
479
David Woodhousee72e6492010-06-03 08:09:12 +0100480 if (insert_inode_locked(inode) < 0) {
481 make_bad_inode(inode);
David Woodhousee72e6492010-06-03 08:09:12 +0100482 iput(inode);
483 return ERR_PTR(-EINVAL);
484 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 return inode;
487}
488
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100489static int calculate_inocache_hashsize(uint32_t flash_size)
490{
491 /*
492 * Pick a inocache hash size based on the size of the medium.
493 * Count how many megabytes we're dealing with, apply a hashsize twice
494 * that size, but rounding down to the usual big powers of 2. And keep
495 * to sensible bounds.
496 */
497
498 int size_mb = flash_size / 1024 / 1024;
499 int hashsize = (size_mb * 2) & ~0x3f;
500
501 if (hashsize < INOCACHE_HASHSIZE_MIN)
502 return INOCACHE_HASHSIZE_MIN;
503 if (hashsize > INOCACHE_HASHSIZE_MAX)
504 return INOCACHE_HASHSIZE_MAX;
505
506 return hashsize;
507}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
509int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
510{
511 struct jffs2_sb_info *c;
512 struct inode *root_i;
513 int ret;
514 size_t blocks;
515
516 c = JFFS2_SB_INFO(sb);
517
Huang Shijiee104f1e2013-09-25 14:58:20 +0800518 /* Do not support the MLC nand */
519 if (c->mtd->type == MTD_MLCNANDFLASH)
520 return -EINVAL;
521
Andrew Victor2f82ce12005-02-09 09:24:26 +0000522#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (c->mtd->type == MTD_NANDFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800524 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 return -EINVAL;
526 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000527 if (c->mtd->type == MTD_DATAFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800528 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
Andrew Victor8f15fd52005-02-09 09:17:45 +0000529 return -EINVAL;
530 }
531#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000534 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537 /*
538 * Size alignment check
539 */
540 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000541 c->flash_size = c->sector_size * blocks;
Joe Perches5a528952012-02-15 15:56:45 -0800542 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 c->flash_size / 1024);
544 }
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 if (c->flash_size < 5*c->sector_size) {
Joe Perches5a528952012-02-15 15:56:45 -0800547 pr_err("Too few erase blocks (%d)\n",
Joe Perchesda320f02012-02-15 15:56:44 -0800548 c->flash_size / c->sector_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 return -EINVAL;
550 }
551
552 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 /* NAND (or other bizarre) flash... do setup accordingly */
555 ret = jffs2_flash_setup(c);
556 if (ret)
557 return ret;
558
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100559 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
560 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (!c->inocache_list) {
562 ret = -ENOMEM;
563 goto out_wbuf;
564 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900566 jffs2_init_xattr_subsystem(c);
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 if ((ret = jffs2_do_mount_fs(c)))
569 goto out_inohash;
570
Joe Perches9c261b32012-02-15 15:56:43 -0800571 jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
David Howells5451f792008-02-07 00:15:42 -0800572 root_i = jffs2_iget(sb, 1);
573 if (IS_ERR(root_i)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800574 jffs2_dbg(1, "get root inode failed\n");
David Howells5451f792008-02-07 00:15:42 -0800575 ret = PTR_ERR(root_i);
576 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 }
578
David Howells5451f792008-02-07 00:15:42 -0800579 ret = -ENOMEM;
580
Linus Torvalds623ff772012-03-30 17:31:56 -0700581 jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
Al Viro48fde702012-01-08 22:15:13 -0500582 sb->s_root = d_make_root(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 if (!sb->s_root)
Al Viro48fde702012-01-08 22:15:13 -0500584 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 sb->s_blocksize = PAGE_CACHE_SIZE;
588 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
589 sb->s_magic = JFFS2_SUPER_MAGIC;
590 if (!(sb->s_flags & MS_RDONLY))
591 jffs2_start_garbage_collect_thread(c);
592 return 0;
593
David Howells5451f792008-02-07 00:15:42 -0800594out_root:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 jffs2_free_ino_caches(c);
596 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100597 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 vfree(c->blocks);
599 else
600 kfree(c->blocks);
601 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900602 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 kfree(c->inocache_list);
604 out_wbuf:
605 jffs2_flash_cleanup(c);
606
607 return ret;
608}
609
610void jffs2_gc_release_inode(struct jffs2_sb_info *c,
611 struct jffs2_inode_info *f)
612{
613 iput(OFNI_EDONI_2SFFJ(f));
614}
615
616struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
David Woodhouse1b690b42008-05-01 16:59:24 +0100617 int inum, int unlinked)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
619 struct inode *inode;
620 struct jffs2_inode_cache *ic;
David Woodhouse1b690b42008-05-01 16:59:24 +0100621
622 if (unlinked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000624 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 the final (close() and) iput() to happen.
626
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000627 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 happened while we were contemplating. In order to ensure
629 that we don't cause a new read_inode() (which would fail)
630 for the inode in question, we use ilookup() in this case
631 instead of iget().
632
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000633 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 holding the alloc_sem, and jffs2_do_unlink() would also
635 need that while decrementing nlink on any inode.
636 */
637 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
638 if (!inode) {
Joe Perches9c261b32012-02-15 15:56:43 -0800639 jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
640 inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
642 spin_lock(&c->inocache_lock);
643 ic = jffs2_get_ino_cache(c, inum);
644 if (!ic) {
Joe Perches9c261b32012-02-15 15:56:43 -0800645 jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
646 inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 spin_unlock(&c->inocache_lock);
648 return NULL;
649 }
650 if (ic->state != INO_STATE_CHECKEDABSENT) {
651 /* Wait for progress. Don't just loop */
Joe Perches9c261b32012-02-15 15:56:43 -0800652 jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
653 ic->ino, ic->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
655 } else {
656 spin_unlock(&c->inocache_lock);
657 }
658
659 return NULL;
660 }
661 } else {
662 /* Inode has links to it still; they're not going away because
663 jffs2_do_unlink() would need the alloc_sem and we have it.
664 Just iget() it, and if read_inode() is necessary that's OK.
665 */
David Howells5451f792008-02-07 00:15:42 -0800666 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
667 if (IS_ERR(inode))
668 return ERR_CAST(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 }
670 if (is_bad_inode(inode)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800671 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
672 inum, unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 /* NB. This will happen again. We need to do something appropriate here. */
674 iput(inode);
675 return ERR_PTR(-EIO);
676 }
677
678 return JFFS2_INODE_INFO(inode);
679}
680
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000681unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
682 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 unsigned long offset,
684 unsigned long *priv)
685{
686 struct inode *inode = OFNI_EDONI_2SFFJ(f);
687 struct page *pg;
688
Jason Lunzfc0e0192007-09-01 12:06:03 -0700689 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 (void *)jffs2_do_readpage_unlock, inode);
691 if (IS_ERR(pg))
692 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 *priv = (unsigned long)pg;
695 return kmap(pg);
696}
697
698void jffs2_gc_release_page(struct jffs2_sb_info *c,
699 unsigned char *ptr,
700 unsigned long *priv)
701{
702 struct page *pg = (void *)*priv;
703
704 kunmap(pg);
705 page_cache_release(pg);
706}
707
708static int jffs2_flash_setup(struct jffs2_sb_info *c) {
709 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (jffs2_cleanmarker_oob(c)) {
712 /* NAND flash... do setup accordingly */
713 ret = jffs2_nand_flash_setup(c);
714 if (ret)
715 return ret;
716 }
717
Andrew Victor8f15fd52005-02-09 09:17:45 +0000718 /* and Dataflash */
719 if (jffs2_dataflash(c)) {
720 ret = jffs2_dataflash_setup(c);
721 if (ret)
722 return ret;
723 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100724
725 /* and Intel "Sibley" flash */
726 if (jffs2_nor_wbuf_flash(c)) {
727 ret = jffs2_nor_wbuf_flash_setup(c);
728 if (ret)
729 return ret;
730 }
731
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300732 /* and an UBI volume */
733 if (jffs2_ubivol(c)) {
734 ret = jffs2_ubivol_setup(c);
735 if (ret)
736 return ret;
737 }
738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return ret;
740}
741
742void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
743
744 if (jffs2_cleanmarker_oob(c)) {
745 jffs2_nand_flash_cleanup(c);
746 }
747
Andrew Victor8f15fd52005-02-09 09:17:45 +0000748 /* and DataFlash */
749 if (jffs2_dataflash(c)) {
750 jffs2_dataflash_cleanup(c);
751 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100752
753 /* and Intel "Sibley" flash */
754 if (jffs2_nor_wbuf_flash(c)) {
755 jffs2_nor_wbuf_flash_cleanup(c);
756 }
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300757
758 /* and an UBI volume */
759 if (jffs2_ubivol(c)) {
760 jffs2_ubivol_cleanup(c);
761 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762}