blob: fe5ea080b4ec810f29589b257f605389067dadf4 [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{
David Howells2b0143b2015-03-17 22:25:59 +0000193 struct inode *inode = d_inode(dentry);
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900194 int rc;
195
Christoph Hellwigf2963d42013-12-20 05:16:47 -0800196 rc = inode_change_ok(inode, iattr);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100197 if (rc)
198 return rc;
199
Christoph Hellwigf2963d42013-12-20 05:16:47 -0800200 rc = jffs2_do_setattr(inode, iattr);
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900201 if (!rc && (iattr->ia_valid & ATTR_MODE))
Christoph Hellwigf2963d42013-12-20 05:16:47 -0800202 rc = posix_acl_chmod(inode, inode->i_mode);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100203
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900204 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206
David Howells726c3342006-06-23 02:02:58 -0700207int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
David Howells726c3342006-06-23 02:02:58 -0700209 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 unsigned long avail;
211
212 buf->f_type = JFFS2_SUPER_MAGIC;
213 buf->f_bsize = 1 << PAGE_SHIFT;
214 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
215 buf->f_files = 0;
216 buf->f_ffree = 0;
217 buf->f_namelen = JFFS2_MAX_NAME_LEN;
David Woodhouse75caf6b2008-08-18 16:23:53 +0100218 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
219 buf->f_fsid.val[1] = c->mtd->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 avail = c->dirty_size + c->free_size;
223 if (avail > c->sector_size * c->resv_blocks_write)
224 avail -= c->sector_size * c->resv_blocks_write;
225 else
226 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100227 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return 0;
232}
233
234
Al Virob57922d2010-06-07 14:34:48 -0400235void jffs2_evict_inode (struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000237 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 * the nodelists associated with it, etc.
239 */
240 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
241 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000242
Joe Perches9c261b32012-02-15 15:56:43 -0800243 jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
244 __func__, inode->i_ino, inode->i_mode);
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700245 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +0200246 clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 jffs2_do_clear_inode(c, f);
248}
249
David Howells5451f792008-02-07 00:15:42 -0800250struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
252 struct jffs2_inode_info *f;
253 struct jffs2_sb_info *c;
254 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100255 union jffs2_device_node jdev;
David Howells5451f792008-02-07 00:15:42 -0800256 struct inode *inode;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100257 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 int ret;
259
Joe Perches9c261b32012-02-15 15:56:43 -0800260 jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
David Howells5451f792008-02-07 00:15:42 -0800261
262 inode = iget_locked(sb, ino);
263 if (!inode)
264 return ERR_PTR(-ENOMEM);
265 if (!(inode->i_state & I_NEW))
266 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 f = JFFS2_INODE_INFO(inode);
269 c = JFFS2_SB_INFO(inode->i_sb);
270
271 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100272 mutex_lock(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
275
276 if (ret) {
David Woodhouseced22072008-04-22 15:13:40 +0100277 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800278 iget_failed(inode);
279 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 }
281 inode->i_mode = jemode_to_cpu(latest_node.mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800282 i_uid_write(inode, je16_to_cpu(latest_node.uid));
283 i_gid_write(inode, je16_to_cpu(latest_node.gid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 inode->i_size = je32_to_cpu(latest_node.isize);
285 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
286 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
287 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
288
Miklos Szeredibfe86842011-10-28 14:13:29 +0200289 set_nlink(inode, f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
295 case S_IFLNK:
296 inode->i_op = &jffs2_symlink_inode_operations;
297 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 case S_IFDIR:
300 {
301 struct jffs2_full_dirent *fd;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200302 set_nlink(inode, 2); /* parent and '.' */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 for (fd=f->dents; fd; fd = fd->next) {
305 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700306 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 /* Root dir gets i_nlink 3 for some reason */
309 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700310 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
312 inode->i_op = &jffs2_dir_inode_operations;
313 inode->i_fop = &jffs2_dir_operations;
314 break;
315 }
316 case S_IFREG:
317 inode->i_op = &jffs2_file_inode_operations;
318 inode->i_fop = &jffs2_file_operations;
319 inode->i_mapping->a_ops = &jffs2_file_address_operations;
320 inode->i_mapping->nrpages = 0;
321 break;
322
323 case S_IFBLK:
324 case S_IFCHR:
325 /* Read the device numbers from the media */
Andrew Morton91f80262010-02-02 14:43:10 -0800326 if (f->metadata->size != sizeof(jdev.old_id) &&
327 f->metadata->size != sizeof(jdev.new_id)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800328 pr_notice("Device node has strange size %d\n",
329 f->metadata->size);
David Howells5451f792008-02-07 00:15:42 -0800330 goto error_io;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100331 }
Joe Perches9c261b32012-02-15 15:56:43 -0800332 jffs2_dbg(1, "Reading device numbers from flash\n");
David Howells5451f792008-02-07 00:15:42 -0800333 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
334 if (ret < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 /* Eep */
Joe Perchesda320f02012-02-15 15:56:44 -0800336 pr_notice("Read device numbers for inode %lu failed\n",
337 (unsigned long)inode->i_ino);
David Howells5451f792008-02-07 00:15:42 -0800338 goto error;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000339 }
Andrew Morton91f80262010-02-02 14:43:10 -0800340 if (f->metadata->size == sizeof(jdev.old_id))
341 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100342 else
Andrew Morton91f80262010-02-02 14:43:10 -0800343 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 case S_IFSOCK:
346 case S_IFIFO:
347 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100348 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 break;
350
351 default:
Joe Perchesda320f02012-02-15 15:56:44 -0800352 pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
353 __func__, inode->i_mode, (unsigned long)inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
355
David Woodhouseced22072008-04-22 15:13:40 +0100356 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Joe Perches9c261b32012-02-15 15:56:43 -0800358 jffs2_dbg(1, "jffs2_read_inode() returning\n");
David Howells5451f792008-02-07 00:15:42 -0800359 unlock_new_inode(inode);
360 return inode;
361
362error_io:
363 ret = -EIO;
364error:
David Woodhouseced22072008-04-22 15:13:40 +0100365 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800366 jffs2_do_clear_inode(c, f);
367 iget_failed(inode);
368 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370
Christoph Hellwigaa385722011-05-27 06:53:02 -0400371void jffs2_dirty_inode(struct inode *inode, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
373 struct iattr iattr;
374
375 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800376 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
377 __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 return;
379 }
380
Joe Perches9c261b32012-02-15 15:56:43 -0800381 jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
382 __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
385 iattr.ia_mode = inode->i_mode;
386 iattr.ia_uid = inode->i_uid;
387 iattr.ia_gid = inode->i_gid;
388 iattr.ia_atime = inode->i_atime;
389 iattr.ia_mtime = inode->i_mtime;
390 iattr.ia_ctime = inode->i_ctime;
391
392 jffs2_do_setattr(inode, &iattr);
393}
394
Andres Salomon92abc472011-10-16 18:15:16 -0700395int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
397 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
398
399 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
400 return -EROFS;
401
402 /* We stop if it was running, then restart if it needs to.
403 This also catches the case where it was stopped and this
404 is just a remount to restart it.
405 Flush the writebuffer, if neccecary, else we loose it */
406 if (!(sb->s_flags & MS_RDONLY)) {
407 jffs2_stop_garbage_collect_thread(c);
David Woodhouseced22072008-04-22 15:13:40 +0100408 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100410 mutex_unlock(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000411 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 if (!(*flags & MS_RDONLY))
414 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 *flags |= MS_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return 0;
418}
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
421 fill in the raw_inode while you're at it. */
Al Virod3fb6122011-07-23 18:37:50 -0400422struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
424 struct inode *inode;
425 struct super_block *sb = dir_i->i_sb;
426 struct jffs2_sb_info *c;
427 struct jffs2_inode_info *f;
428 int ret;
429
Joe Perches9c261b32012-02-15 15:56:43 -0800430 jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
431 __func__, dir_i->i_ino, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 if (!inode)
438 return ERR_PTR(-ENOMEM);
439
440 f = JFFS2_INODE_INFO(inode);
441 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100442 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 memset(ri, 0, sizeof(*ri));
445 /* Set OS-specific defaults for new inodes */
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800446 ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
448 if (dir_i->i_mode & S_ISGID) {
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800449 ri->gid = cpu_to_je16(i_gid_read(dir_i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 if (S_ISDIR(mode))
451 mode |= S_ISGID;
452 } else {
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800453 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 }
David Woodhouse9ed437c2007-08-22 12:39:19 +0100455
456 /* POSIX ACLs have to be processed now, at least partly.
457 The umask is only applied if there's no default ACL */
KaiGai Koheicfc8dc62007-09-14 15:16:35 +0900458 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
459 if (ret) {
Wang Guoli01887a32014-02-12 12:44:54 -0800460 mutex_unlock(&f->sem);
461 make_bad_inode(inode);
462 iput(inode);
463 return ERR_PTR(ret);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 ret = jffs2_do_new_inode (c, f, mode, ri);
466 if (ret) {
Wang Guoli01887a32014-02-12 12:44:54 -0800467 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 make_bad_inode(inode);
469 iput(inode);
470 return ERR_PTR(ret);
471 }
Miklos Szeredibfe86842011-10-28 14:13:29 +0200472 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 inode->i_ino = je32_to_cpu(ri->ino);
474 inode->i_mode = jemode_to_cpu(ri->mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800475 i_gid_write(inode, je16_to_cpu(ri->gid));
476 i_uid_write(inode, je16_to_cpu(ri->uid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
478 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 inode->i_blocks = 0;
481 inode->i_size = 0;
482
David Woodhousee72e6492010-06-03 08:09:12 +0100483 if (insert_inode_locked(inode) < 0) {
Wang Guoli01887a32014-02-12 12:44:54 -0800484 mutex_unlock(&f->sem);
David Woodhousee72e6492010-06-03 08:09:12 +0100485 make_bad_inode(inode);
David Woodhousee72e6492010-06-03 08:09:12 +0100486 iput(inode);
487 return ERR_PTR(-EINVAL);
488 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490 return inode;
491}
492
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100493static int calculate_inocache_hashsize(uint32_t flash_size)
494{
495 /*
496 * Pick a inocache hash size based on the size of the medium.
497 * Count how many megabytes we're dealing with, apply a hashsize twice
498 * that size, but rounding down to the usual big powers of 2. And keep
499 * to sensible bounds.
500 */
501
502 int size_mb = flash_size / 1024 / 1024;
503 int hashsize = (size_mb * 2) & ~0x3f;
504
505 if (hashsize < INOCACHE_HASHSIZE_MIN)
506 return INOCACHE_HASHSIZE_MIN;
507 if (hashsize > INOCACHE_HASHSIZE_MAX)
508 return INOCACHE_HASHSIZE_MAX;
509
510 return hashsize;
511}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
513int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
514{
515 struct jffs2_sb_info *c;
516 struct inode *root_i;
517 int ret;
518 size_t blocks;
519
520 c = JFFS2_SB_INFO(sb);
521
Huang Shijiee104f1e2013-09-25 14:58:20 +0800522 /* Do not support the MLC nand */
523 if (c->mtd->type == MTD_MLCNANDFLASH)
524 return -EINVAL;
525
Andrew Victor2f82ce12005-02-09 09:24:26 +0000526#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 if (c->mtd->type == MTD_NANDFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800528 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 return -EINVAL;
530 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000531 if (c->mtd->type == MTD_DATAFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800532 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
Andrew Victor8f15fd52005-02-09 09:17:45 +0000533 return -EINVAL;
534 }
535#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000538 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
541 /*
542 * Size alignment check
543 */
544 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000545 c->flash_size = c->sector_size * blocks;
Joe Perches5a528952012-02-15 15:56:45 -0800546 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 c->flash_size / 1024);
548 }
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if (c->flash_size < 5*c->sector_size) {
Joe Perches5a528952012-02-15 15:56:45 -0800551 pr_err("Too few erase blocks (%d)\n",
Joe Perchesda320f02012-02-15 15:56:44 -0800552 c->flash_size / c->sector_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 return -EINVAL;
554 }
555
556 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558 /* NAND (or other bizarre) flash... do setup accordingly */
559 ret = jffs2_flash_setup(c);
560 if (ret)
561 return ret;
562
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100563 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
564 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 if (!c->inocache_list) {
566 ret = -ENOMEM;
567 goto out_wbuf;
568 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900570 jffs2_init_xattr_subsystem(c);
571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if ((ret = jffs2_do_mount_fs(c)))
573 goto out_inohash;
574
Joe Perches9c261b32012-02-15 15:56:43 -0800575 jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
David Howells5451f792008-02-07 00:15:42 -0800576 root_i = jffs2_iget(sb, 1);
577 if (IS_ERR(root_i)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800578 jffs2_dbg(1, "get root inode failed\n");
David Howells5451f792008-02-07 00:15:42 -0800579 ret = PTR_ERR(root_i);
580 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
582
David Howells5451f792008-02-07 00:15:42 -0800583 ret = -ENOMEM;
584
Linus Torvalds623ff772012-03-30 17:31:56 -0700585 jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
Al Viro48fde702012-01-08 22:15:13 -0500586 sb->s_root = d_make_root(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 if (!sb->s_root)
Al Viro48fde702012-01-08 22:15:13 -0500588 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 sb->s_blocksize = PAGE_CACHE_SIZE;
592 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
593 sb->s_magic = JFFS2_SUPER_MAGIC;
594 if (!(sb->s_flags & MS_RDONLY))
595 jffs2_start_garbage_collect_thread(c);
596 return 0;
597
David Howells5451f792008-02-07 00:15:42 -0800598out_root:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 jffs2_free_ino_caches(c);
600 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100601 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 vfree(c->blocks);
603 else
604 kfree(c->blocks);
605 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900606 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 kfree(c->inocache_list);
608 out_wbuf:
609 jffs2_flash_cleanup(c);
610
611 return ret;
612}
613
614void jffs2_gc_release_inode(struct jffs2_sb_info *c,
615 struct jffs2_inode_info *f)
616{
617 iput(OFNI_EDONI_2SFFJ(f));
618}
619
620struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
David Woodhouse1b690b42008-05-01 16:59:24 +0100621 int inum, int unlinked)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
623 struct inode *inode;
624 struct jffs2_inode_cache *ic;
David Woodhouse1b690b42008-05-01 16:59:24 +0100625
626 if (unlinked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000628 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 the final (close() and) iput() to happen.
630
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000631 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 happened while we were contemplating. In order to ensure
633 that we don't cause a new read_inode() (which would fail)
634 for the inode in question, we use ilookup() in this case
635 instead of iget().
636
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000637 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 holding the alloc_sem, and jffs2_do_unlink() would also
639 need that while decrementing nlink on any inode.
640 */
641 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
642 if (!inode) {
Joe Perches9c261b32012-02-15 15:56:43 -0800643 jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
644 inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 spin_lock(&c->inocache_lock);
647 ic = jffs2_get_ino_cache(c, inum);
648 if (!ic) {
Joe Perches9c261b32012-02-15 15:56:43 -0800649 jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
650 inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 spin_unlock(&c->inocache_lock);
652 return NULL;
653 }
654 if (ic->state != INO_STATE_CHECKEDABSENT) {
655 /* Wait for progress. Don't just loop */
Joe Perches9c261b32012-02-15 15:56:43 -0800656 jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
657 ic->ino, ic->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
659 } else {
660 spin_unlock(&c->inocache_lock);
661 }
662
663 return NULL;
664 }
665 } else {
666 /* Inode has links to it still; they're not going away because
667 jffs2_do_unlink() would need the alloc_sem and we have it.
668 Just iget() it, and if read_inode() is necessary that's OK.
669 */
David Howells5451f792008-02-07 00:15:42 -0800670 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
671 if (IS_ERR(inode))
672 return ERR_CAST(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
674 if (is_bad_inode(inode)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800675 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
676 inum, unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /* NB. This will happen again. We need to do something appropriate here. */
678 iput(inode);
679 return ERR_PTR(-EIO);
680 }
681
682 return JFFS2_INODE_INFO(inode);
683}
684
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000685unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
686 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 unsigned long offset,
688 unsigned long *priv)
689{
690 struct inode *inode = OFNI_EDONI_2SFFJ(f);
691 struct page *pg;
692
Sasha Levin67f9fd92014-04-03 14:48:18 -0700693 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 (void *)jffs2_do_readpage_unlock, inode);
695 if (IS_ERR(pg))
696 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 *priv = (unsigned long)pg;
699 return kmap(pg);
700}
701
702void jffs2_gc_release_page(struct jffs2_sb_info *c,
703 unsigned char *ptr,
704 unsigned long *priv)
705{
706 struct page *pg = (void *)*priv;
707
708 kunmap(pg);
709 page_cache_release(pg);
710}
711
712static int jffs2_flash_setup(struct jffs2_sb_info *c) {
713 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (jffs2_cleanmarker_oob(c)) {
716 /* NAND flash... do setup accordingly */
717 ret = jffs2_nand_flash_setup(c);
718 if (ret)
719 return ret;
720 }
721
Andrew Victor8f15fd52005-02-09 09:17:45 +0000722 /* and Dataflash */
723 if (jffs2_dataflash(c)) {
724 ret = jffs2_dataflash_setup(c);
725 if (ret)
726 return ret;
727 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100728
729 /* and Intel "Sibley" flash */
730 if (jffs2_nor_wbuf_flash(c)) {
731 ret = jffs2_nor_wbuf_flash_setup(c);
732 if (ret)
733 return ret;
734 }
735
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300736 /* and an UBI volume */
737 if (jffs2_ubivol(c)) {
738 ret = jffs2_ubivol_setup(c);
739 if (ret)
740 return ret;
741 }
742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 return ret;
744}
745
746void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
747
748 if (jffs2_cleanmarker_oob(c)) {
749 jffs2_nand_flash_cleanup(c);
750 }
751
Andrew Victor8f15fd52005-02-09 09:17:45 +0000752 /* and DataFlash */
753 if (jffs2_dataflash(c)) {
754 jffs2_dataflash_cleanup(c);
755 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100756
757 /* and Intel "Sibley" flash */
758 if (jffs2_nor_wbuf_flash(c)) {
759 jffs2_nor_wbuf_flash_cleanup(c);
760 }
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300761
762 /* and an UBI volume */
763 if (jffs2_ubivol(c)) {
764 jffs2_ubivol_cleanup(c);
765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}