blob: 76fa814df3d1bfcacb3caea51cbaa9711854e120 [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>
Ingo Molnar5b825c32017-02-02 17:54:15 +010018#include <linux/cred.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/fs.h>
20#include <linux/list.h>
21#include <linux/mtd/mtd.h>
22#include <linux/pagemap.h>
23#include <linux/slab.h>
24#include <linux/vmalloc.h>
25#include <linux/vfs.h>
26#include <linux/crc32.h>
27#include "nodelist.h"
28
29static int jffs2_flash_setup(struct jffs2_sb_info *c);
30
David Woodhouse9ed437c2007-08-22 12:39:19 +010031int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070032{
33 struct jffs2_full_dnode *old_metadata, *new_metadata;
34 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
35 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
36 struct jffs2_raw_inode *ri;
David Woodhouseaef9ab42006-05-19 00:28:49 +010037 union jffs2_device_node dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 unsigned char *mdata = NULL;
39 int mdatalen = 0;
40 unsigned int ivalid;
David Woodhouse9fe48542006-05-23 00:38:06 +010041 uint32_t alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 int ret;
David Woodhousedd919662008-02-25 15:25:25 +000043 int alloc_type = ALLOC_NORMAL;
David Woodhouse9ed437c2007-08-22 12:39:19 +010044
Joe Perches9c261b32012-02-15 15:56:43 -080045 jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47 /* Special cases - we don't want more than one data node
48 for these types on the medium at any time. So setattr
49 must read the original data associated with the node
50 (i.e. the device numbers or the target name) and write
51 it out again with the appropriate data attached */
52 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
53 /* For these, we don't actually need to read the old node */
David Woodhouseaef9ab42006-05-19 00:28:49 +010054 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 mdata = (char *)&dev;
Joe Perches9c261b32012-02-15 15:56:43 -080056 jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
57 __func__, mdatalen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 } else if (S_ISLNK(inode->i_mode)) {
David Woodhouseced22072008-04-22 15:13:40 +010059 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 mdatalen = f->metadata->size;
61 mdata = kmalloc(f->metadata->size, GFP_USER);
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010062 if (!mdata) {
David Woodhouseced22072008-04-22 15:13:40 +010063 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 return -ENOMEM;
Dmitry Bazhenov422138d2006-05-05 22:46:49 +010065 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
67 if (ret) {
David Woodhouseced22072008-04-22 15:13:40 +010068 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 kfree(mdata);
70 return ret;
71 }
David Woodhouseced22072008-04-22 15:13:40 +010072 mutex_unlock(&f->sem);
Joe Perches9c261b32012-02-15 15:56:43 -080073 jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
74 __func__, mdatalen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 }
76
77 ri = jffs2_alloc_raw_inode();
78 if (!ri) {
79 if (S_ISLNK(inode->i_mode))
80 kfree(mdata);
81 return -ENOMEM;
82 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000083
David Woodhouse9fe48542006-05-23 00:38:06 +010084 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
85 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 if (ret) {
87 jffs2_free_raw_inode(ri);
Al Viro61effb52011-07-24 17:11:33 -040088 if (S_ISLNK(inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 kfree(mdata);
90 return ret;
91 }
David Woodhouseced22072008-04-22 15:13:40 +010092 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 ivalid = iattr->ia_valid;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +000094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
96 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
97 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
98 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
99
100 ri->ino = cpu_to_je32(inode->i_ino);
101 ri->version = cpu_to_je32(++f->highest_version);
102
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800103 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?
104 from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode));
105 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?
106 from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108 if (ivalid & ATTR_MODE)
David Woodhouse857013b2007-11-01 16:27:38 -0400109 ri->mode = cpu_to_jemode(iattr->ia_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 else
111 ri->mode = cpu_to_jemode(inode->i_mode);
112
113
114 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
115 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
116 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
117 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
118
119 ri->offset = cpu_to_je32(0);
120 ri->csize = ri->dsize = cpu_to_je32(mdatalen);
121 ri->compr = JFFS2_COMPR_NONE;
122 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
123 /* It's an extension. Make it a hole node */
124 ri->compr = JFFS2_COMPR_ZERO;
125 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
126 ri->offset = cpu_to_je32(inode->i_size);
David Woodhousedd919662008-02-25 15:25:25 +0000127 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
128 /* For truncate-to-zero, treat it as deletion because
129 it'll always be obsoleting all previous nodes */
130 alloc_type = ALLOC_DELETION;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 }
132 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
133 if (mdatalen)
134 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
135 else
136 ri->data_crc = cpu_to_je32(0);
137
David Woodhousedd919662008-02-25 15:25:25 +0000138 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 if (S_ISLNK(inode->i_mode))
140 kfree(mdata);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 if (IS_ERR(new_metadata)) {
143 jffs2_complete_reservation(c);
144 jffs2_free_raw_inode(ri);
David Woodhouseced22072008-04-22 15:13:40 +0100145 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 return PTR_ERR(new_metadata);
147 }
148 /* It worked. Update the inode */
149 inode->i_atime = ITIME(je32_to_cpu(ri->atime));
150 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
151 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
152 inode->i_mode = jemode_to_cpu(ri->mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800153 i_uid_write(inode, je16_to_cpu(ri->uid));
154 i_gid_write(inode, je16_to_cpu(ri->gid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
156
157 old_metadata = f->metadata;
158
159 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
Artem B. Bityutskiyf302cd02005-07-24 16:29:59 +0100160 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
163 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
164 inode->i_size = iattr->ia_size;
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000165 inode->i_blocks = (inode->i_size + 511) >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 f->metadata = NULL;
167 } else {
168 f->metadata = new_metadata;
169 }
170 if (old_metadata) {
171 jffs2_mark_node_obsolete(c, old_metadata->raw);
172 jffs2_free_full_dnode(old_metadata);
173 }
174 jffs2_free_raw_inode(ri);
175
David Woodhouseced22072008-04-22 15:13:40 +0100176 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 jffs2_complete_reservation(c);
178
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200179 /* We have to do the truncate_setsize() without f->sem held, since
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000180 some pages may be locked and waiting for it in readpage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 We are protected from a simultaneous write() extending i_size
182 back past iattr->ia_size, because do_truncate() holds the
183 generic inode semaphore. */
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000184 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200185 truncate_setsize(inode, iattr->ia_size);
David Woodhouseb28ba9f2008-02-25 15:20:50 +0000186 inode->i_blocks = (inode->i_size + 511) >> 9;
187 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 return 0;
190}
191
192int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
193{
David Howells2b0143b2015-03-17 22:25:59 +0000194 struct inode *inode = d_inode(dentry);
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900195 int rc;
196
Jan Kara31051c82016-05-26 16:55:18 +0200197 rc = setattr_prepare(dentry, iattr);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100198 if (rc)
199 return rc;
200
Christoph Hellwigf2963d42013-12-20 05:16:47 -0800201 rc = jffs2_do_setattr(inode, iattr);
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900202 if (!rc && (iattr->ia_valid & ATTR_MODE))
Christoph Hellwigf2963d42013-12-20 05:16:47 -0800203 rc = posix_acl_chmod(inode, inode->i_mode);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100204
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900205 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
David Howells726c3342006-06-23 02:02:58 -0700208int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
David Howells726c3342006-06-23 02:02:58 -0700210 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 unsigned long avail;
212
213 buf->f_type = JFFS2_SUPER_MAGIC;
214 buf->f_bsize = 1 << PAGE_SHIFT;
215 buf->f_blocks = c->flash_size >> PAGE_SHIFT;
216 buf->f_files = 0;
217 buf->f_ffree = 0;
218 buf->f_namelen = JFFS2_MAX_NAME_LEN;
David Woodhouse75caf6b2008-08-18 16:23:53 +0100219 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
220 buf->f_fsid.val[1] = c->mtd->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 avail = c->dirty_size + c->free_size;
224 if (avail > c->sector_size * c->resv_blocks_write)
225 avail -= c->sector_size * c->resv_blocks_write;
226 else
227 avail = 0;
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100228 spin_unlock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
230 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return 0;
233}
234
235
Al Virob57922d2010-06-07 14:34:48 -0400236void jffs2_evict_inode (struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237{
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000238 /* We can forget about this inode for now - drop all
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 * the nodelists associated with it, etc.
240 */
241 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
242 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000243
Joe Perches9c261b32012-02-15 15:56:43 -0800244 jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
245 __func__, inode->i_ino, inode->i_mode);
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700246 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +0200247 clear_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 jffs2_do_clear_inode(c, f);
249}
250
David Howells5451f792008-02-07 00:15:42 -0800251struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 struct jffs2_inode_info *f;
254 struct jffs2_sb_info *c;
255 struct jffs2_raw_inode latest_node;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100256 union jffs2_device_node jdev;
David Howells5451f792008-02-07 00:15:42 -0800257 struct inode *inode;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100258 dev_t rdev = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 int ret;
260
Joe Perches9c261b32012-02-15 15:56:43 -0800261 jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
David Howells5451f792008-02-07 00:15:42 -0800262
263 inode = iget_locked(sb, ino);
264 if (!inode)
265 return ERR_PTR(-ENOMEM);
266 if (!(inode->i_state & I_NEW))
267 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 f = JFFS2_INODE_INFO(inode);
270 c = JFFS2_SB_INFO(inode->i_sb);
271
272 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100273 mutex_lock(&f->sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
Brian Norris7aaea762014-02-25 18:27:40 -0800276 if (ret)
277 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 inode->i_mode = jemode_to_cpu(latest_node.mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800280 i_uid_write(inode, je16_to_cpu(latest_node.uid));
281 i_gid_write(inode, je16_to_cpu(latest_node.gid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 inode->i_size = je32_to_cpu(latest_node.isize);
283 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
284 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
285 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
286
Miklos Szeredibfe86842011-10-28 14:13:29 +0200287 set_nlink(inode, f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 case S_IFLNK:
294 inode->i_op = &jffs2_symlink_inode_operations;
Al Viroa8db1492015-05-02 10:21:20 -0400295 inode->i_link = f->target;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 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) {
Wang Guoli01887a32014-02-12 12:44:54 -0800459 mutex_unlock(&f->sem);
460 make_bad_inode(inode);
461 iput(inode);
462 return ERR_PTR(ret);
David Woodhouse9ed437c2007-08-22 12:39:19 +0100463 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 ret = jffs2_do_new_inode (c, f, mode, ri);
465 if (ret) {
Wang Guoli01887a32014-02-12 12:44:54 -0800466 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 make_bad_inode(inode);
468 iput(inode);
469 return ERR_PTR(ret);
470 }
Miklos Szeredibfe86842011-10-28 14:13:29 +0200471 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 inode->i_ino = je32_to_cpu(ri->ino);
473 inode->i_mode = jemode_to_cpu(ri->mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800474 i_gid_write(inode, je16_to_cpu(ri->gid));
475 i_uid_write(inode, je16_to_cpu(ri->uid));
Deepa Dinamani02027d42016-09-14 07:48:05 -0700476 inode->i_atime = inode->i_ctime = inode->i_mtime = current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 inode->i_blocks = 0;
480 inode->i_size = 0;
481
David Woodhousee72e6492010-06-03 08:09:12 +0100482 if (insert_inode_locked(inode) < 0) {
Wang Guoli01887a32014-02-12 12:44:54 -0800483 mutex_unlock(&f->sem);
David Woodhousee72e6492010-06-03 08:09:12 +0100484 make_bad_inode(inode);
David Woodhousee72e6492010-06-03 08:09:12 +0100485 iput(inode);
486 return ERR_PTR(-EINVAL);
487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 return inode;
490}
491
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100492static int calculate_inocache_hashsize(uint32_t flash_size)
493{
494 /*
495 * Pick a inocache hash size based on the size of the medium.
496 * Count how many megabytes we're dealing with, apply a hashsize twice
497 * that size, but rounding down to the usual big powers of 2. And keep
498 * to sensible bounds.
499 */
500
501 int size_mb = flash_size / 1024 / 1024;
502 int hashsize = (size_mb * 2) & ~0x3f;
503
504 if (hashsize < INOCACHE_HASHSIZE_MIN)
505 return INOCACHE_HASHSIZE_MIN;
506 if (hashsize > INOCACHE_HASHSIZE_MAX)
507 return INOCACHE_HASHSIZE_MAX;
508
509 return hashsize;
510}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
513{
514 struct jffs2_sb_info *c;
515 struct inode *root_i;
516 int ret;
517 size_t blocks;
518
519 c = JFFS2_SB_INFO(sb);
520
Huang Shijiee104f1e2013-09-25 14:58:20 +0800521 /* Do not support the MLC nand */
522 if (c->mtd->type == MTD_MLCNANDFLASH)
523 return -EINVAL;
524
Andrew Victor2f82ce12005-02-09 09:24:26 +0000525#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 if (c->mtd->type == MTD_NANDFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800527 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 return -EINVAL;
529 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000530 if (c->mtd->type == MTD_DATAFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800531 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
Andrew Victor8f15fd52005-02-09 09:17:45 +0000532 return -EINVAL;
533 }
534#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
536 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000537 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540 /*
541 * Size alignment check
542 */
543 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000544 c->flash_size = c->sector_size * blocks;
Joe Perches5a528952012-02-15 15:56:45 -0800545 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 c->flash_size / 1024);
547 }
548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 if (c->flash_size < 5*c->sector_size) {
Joe Perches5a528952012-02-15 15:56:45 -0800550 pr_err("Too few erase blocks (%d)\n",
Joe Perchesda320f02012-02-15 15:56:44 -0800551 c->flash_size / c->sector_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 return -EINVAL;
553 }
554
555 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 /* NAND (or other bizarre) flash... do setup accordingly */
558 ret = jffs2_flash_setup(c);
559 if (ret)
560 return ret;
561
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100562 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
563 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 if (!c->inocache_list) {
565 ret = -ENOMEM;
566 goto out_wbuf;
567 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900569 jffs2_init_xattr_subsystem(c);
570
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if ((ret = jffs2_do_mount_fs(c)))
572 goto out_inohash;
573
Joe Perches9c261b32012-02-15 15:56:43 -0800574 jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
David Howells5451f792008-02-07 00:15:42 -0800575 root_i = jffs2_iget(sb, 1);
576 if (IS_ERR(root_i)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800577 jffs2_dbg(1, "get root inode failed\n");
David Howells5451f792008-02-07 00:15:42 -0800578 ret = PTR_ERR(root_i);
579 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
581
David Howells5451f792008-02-07 00:15:42 -0800582 ret = -ENOMEM;
583
Linus Torvalds623ff772012-03-30 17:31:56 -0700584 jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
Al Viro48fde702012-01-08 22:15:13 -0500585 sb->s_root = d_make_root(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 if (!sb->s_root)
Al Viro48fde702012-01-08 22:15:13 -0500587 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 sb->s_maxbytes = 0xFFFFFFFF;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300590 sb->s_blocksize = PAGE_SIZE;
591 sb->s_blocksize_bits = PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 sb->s_magic = JFFS2_SUPER_MAGIC;
593 if (!(sb->s_flags & MS_RDONLY))
594 jffs2_start_garbage_collect_thread(c);
595 return 0;
596
David Howells5451f792008-02-07 00:15:42 -0800597out_root:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 jffs2_free_ino_caches(c);
599 jffs2_free_raw_node_refs(c);
Tetsuo Handa1d5cfdb2016-01-22 15:11:02 -0800600 kvfree(c->blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 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
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300689 pg = read_cache_page(inode->i_mapping, offset >> PAGE_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);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300705 put_page(pg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
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}