blob: 2caf1682036dc1914aaa887565b0a54edbe0ed35 [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);
Brian Norris7aaea762014-02-25 18:27:40 -0800275 if (ret)
276 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 inode->i_mode = jemode_to_cpu(latest_node.mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800279 i_uid_write(inode, je16_to_cpu(latest_node.uid));
280 i_gid_write(inode, je16_to_cpu(latest_node.gid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 inode->i_size = je32_to_cpu(latest_node.isize);
282 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
283 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
284 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
285
Miklos Szeredibfe86842011-10-28 14:13:29 +0200286 set_nlink(inode, f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 inode->i_blocks = (inode->i_size + 511) >> 9;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 switch (inode->i_mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 case S_IFLNK:
293 inode->i_op = &jffs2_symlink_inode_operations;
Al Viroa8db1492015-05-02 10:21:20 -0400294 inode->i_link = f->target;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 case S_IFDIR:
298 {
299 struct jffs2_full_dirent *fd;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200300 set_nlink(inode, 2); /* parent and '.' */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 for (fd=f->dents; fd; fd = fd->next) {
303 if (fd->type == DT_DIR && fd->ino)
Dave Hansend8c76e62006-09-30 23:29:04 -0700304 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 /* Root dir gets i_nlink 3 for some reason */
307 if (inode->i_ino == 1)
Dave Hansend8c76e62006-09-30 23:29:04 -0700308 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
310 inode->i_op = &jffs2_dir_inode_operations;
311 inode->i_fop = &jffs2_dir_operations;
312 break;
313 }
314 case S_IFREG:
315 inode->i_op = &jffs2_file_inode_operations;
316 inode->i_fop = &jffs2_file_operations;
317 inode->i_mapping->a_ops = &jffs2_file_address_operations;
318 inode->i_mapping->nrpages = 0;
319 break;
320
321 case S_IFBLK:
322 case S_IFCHR:
323 /* Read the device numbers from the media */
Andrew Morton91f80262010-02-02 14:43:10 -0800324 if (f->metadata->size != sizeof(jdev.old_id) &&
325 f->metadata->size != sizeof(jdev.new_id)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800326 pr_notice("Device node has strange size %d\n",
327 f->metadata->size);
David Howells5451f792008-02-07 00:15:42 -0800328 goto error_io;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100329 }
Joe Perches9c261b32012-02-15 15:56:43 -0800330 jffs2_dbg(1, "Reading device numbers from flash\n");
David Howells5451f792008-02-07 00:15:42 -0800331 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
332 if (ret < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 /* Eep */
Joe Perchesda320f02012-02-15 15:56:44 -0800334 pr_notice("Read device numbers for inode %lu failed\n",
335 (unsigned long)inode->i_ino);
David Howells5451f792008-02-07 00:15:42 -0800336 goto error;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000337 }
Andrew Morton91f80262010-02-02 14:43:10 -0800338 if (f->metadata->size == sizeof(jdev.old_id))
339 rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
David Woodhouseaef9ab42006-05-19 00:28:49 +0100340 else
Andrew Morton91f80262010-02-02 14:43:10 -0800341 rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
343 case S_IFSOCK:
344 case S_IFIFO:
345 inode->i_op = &jffs2_file_inode_operations;
David Woodhouseaef9ab42006-05-19 00:28:49 +0100346 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 break;
348
349 default:
Joe Perchesda320f02012-02-15 15:56:44 -0800350 pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
351 __func__, inode->i_mode, (unsigned long)inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
353
David Woodhouseced22072008-04-22 15:13:40 +0100354 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Joe Perches9c261b32012-02-15 15:56:43 -0800356 jffs2_dbg(1, "jffs2_read_inode() returning\n");
David Howells5451f792008-02-07 00:15:42 -0800357 unlock_new_inode(inode);
358 return inode;
359
360error_io:
361 ret = -EIO;
362error:
David Woodhouseced22072008-04-22 15:13:40 +0100363 mutex_unlock(&f->sem);
David Howells5451f792008-02-07 00:15:42 -0800364 jffs2_do_clear_inode(c, f);
365 iget_failed(inode);
366 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
368
Christoph Hellwigaa385722011-05-27 06:53:02 -0400369void jffs2_dirty_inode(struct inode *inode, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370{
371 struct iattr iattr;
372
373 if (!(inode->i_state & I_DIRTY_DATASYNC)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800374 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
375 __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 return;
377 }
378
Joe Perches9c261b32012-02-15 15:56:43 -0800379 jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
380 __func__, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
383 iattr.ia_mode = inode->i_mode;
384 iattr.ia_uid = inode->i_uid;
385 iattr.ia_gid = inode->i_gid;
386 iattr.ia_atime = inode->i_atime;
387 iattr.ia_mtime = inode->i_mtime;
388 iattr.ia_ctime = inode->i_ctime;
389
390 jffs2_do_setattr(inode, &iattr);
391}
392
Andres Salomon92abc472011-10-16 18:15:16 -0700393int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394{
395 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
396
397 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
398 return -EROFS;
399
400 /* We stop if it was running, then restart if it needs to.
401 This also catches the case where it was stopped and this
402 is just a remount to restart it.
403 Flush the writebuffer, if neccecary, else we loose it */
404 if (!(sb->s_flags & MS_RDONLY)) {
405 jffs2_stop_garbage_collect_thread(c);
David Woodhouseced22072008-04-22 15:13:40 +0100406 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100408 mutex_unlock(&c->alloc_sem);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000409 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 if (!(*flags & MS_RDONLY))
412 jffs2_start_garbage_collect_thread(c);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 *flags |= MS_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 return 0;
416}
417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
419 fill in the raw_inode while you're at it. */
Al Virod3fb6122011-07-23 18:37:50 -0400420struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421{
422 struct inode *inode;
423 struct super_block *sb = dir_i->i_sb;
424 struct jffs2_sb_info *c;
425 struct jffs2_inode_info *f;
426 int ret;
427
Joe Perches9c261b32012-02-15 15:56:43 -0800428 jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
429 __func__, dir_i->i_ino, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 c = JFFS2_SB_INFO(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 inode = new_inode(sb);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 if (!inode)
436 return ERR_PTR(-ENOMEM);
437
438 f = JFFS2_INODE_INFO(inode);
439 jffs2_init_inode_info(f);
David Woodhouseced22072008-04-22 15:13:40 +0100440 mutex_lock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 memset(ri, 0, sizeof(*ri));
443 /* Set OS-specific defaults for new inodes */
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800444 ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 if (dir_i->i_mode & S_ISGID) {
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800447 ri->gid = cpu_to_je16(i_gid_read(dir_i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 if (S_ISDIR(mode))
449 mode |= S_ISGID;
450 } else {
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800451 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
David Woodhouse9ed437c2007-08-22 12:39:19 +0100453
454 /* POSIX ACLs have to be processed now, at least partly.
455 The umask is only applied if there's no default ACL */
KaiGai Koheicfc8dc62007-09-14 15:16:35 +0900456 ret = jffs2_init_acl_pre(dir_i, inode, &mode);
457 if (ret) {
Wang Guoli01887a32014-02-12 12:44:54 -0800458 mutex_unlock(&f->sem);
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) {
Wang Guoli01887a32014-02-12 12:44:54 -0800465 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 make_bad_inode(inode);
467 iput(inode);
468 return ERR_PTR(ret);
469 }
Miklos Szeredibfe86842011-10-28 14:13:29 +0200470 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 inode->i_ino = je32_to_cpu(ri->ino);
472 inode->i_mode = jemode_to_cpu(ri->mode);
Eric W. Biederman0cfe53d2012-02-07 16:28:39 -0800473 i_gid_write(inode, je16_to_cpu(ri->gid));
474 i_uid_write(inode, je16_to_cpu(ri->uid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
476 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 inode->i_blocks = 0;
479 inode->i_size = 0;
480
David Woodhousee72e6492010-06-03 08:09:12 +0100481 if (insert_inode_locked(inode) < 0) {
Wang Guoli01887a32014-02-12 12:44:54 -0800482 mutex_unlock(&f->sem);
David Woodhousee72e6492010-06-03 08:09:12 +0100483 make_bad_inode(inode);
David Woodhousee72e6492010-06-03 08:09:12 +0100484 iput(inode);
485 return ERR_PTR(-EINVAL);
486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488 return inode;
489}
490
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100491static int calculate_inocache_hashsize(uint32_t flash_size)
492{
493 /*
494 * Pick a inocache hash size based on the size of the medium.
495 * Count how many megabytes we're dealing with, apply a hashsize twice
496 * that size, but rounding down to the usual big powers of 2. And keep
497 * to sensible bounds.
498 */
499
500 int size_mb = flash_size / 1024 / 1024;
501 int hashsize = (size_mb * 2) & ~0x3f;
502
503 if (hashsize < INOCACHE_HASHSIZE_MIN)
504 return INOCACHE_HASHSIZE_MIN;
505 if (hashsize > INOCACHE_HASHSIZE_MAX)
506 return INOCACHE_HASHSIZE_MAX;
507
508 return hashsize;
509}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
512{
513 struct jffs2_sb_info *c;
514 struct inode *root_i;
515 int ret;
516 size_t blocks;
517
518 c = JFFS2_SB_INFO(sb);
519
Huang Shijiee104f1e2013-09-25 14:58:20 +0800520 /* Do not support the MLC nand */
521 if (c->mtd->type == MTD_MLCNANDFLASH)
522 return -EINVAL;
523
Andrew Victor2f82ce12005-02-09 09:24:26 +0000524#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (c->mtd->type == MTD_NANDFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800526 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return -EINVAL;
528 }
Andrew Victor8f15fd52005-02-09 09:17:45 +0000529 if (c->mtd->type == MTD_DATAFLASH) {
Joe Perches5a528952012-02-15 15:56:45 -0800530 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
Andrew Victor8f15fd52005-02-09 09:17:45 +0000531 return -EINVAL;
532 }
533#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 c->flash_size = c->mtd->size;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000536 c->sector_size = c->mtd->erasesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 blocks = c->flash_size / c->sector_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 /*
540 * Size alignment check
541 */
542 if ((c->sector_size * blocks) != c->flash_size) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000543 c->flash_size = c->sector_size * blocks;
Joe Perches5a528952012-02-15 15:56:45 -0800544 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 c->flash_size / 1024);
546 }
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 if (c->flash_size < 5*c->sector_size) {
Joe Perches5a528952012-02-15 15:56:45 -0800549 pr_err("Too few erase blocks (%d)\n",
Joe Perchesda320f02012-02-15 15:56:44 -0800550 c->flash_size / c->sector_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 return -EINVAL;
552 }
553
554 c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556 /* NAND (or other bizarre) flash... do setup accordingly */
557 ret = jffs2_flash_setup(c);
558 if (ret)
559 return ret;
560
Daniel Drake65e5a0e2010-10-07 19:14:02 +0100561 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
562 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (!c->inocache_list) {
564 ret = -ENOMEM;
565 goto out_wbuf;
566 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900568 jffs2_init_xattr_subsystem(c);
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 if ((ret = jffs2_do_mount_fs(c)))
571 goto out_inohash;
572
Joe Perches9c261b32012-02-15 15:56:43 -0800573 jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
David Howells5451f792008-02-07 00:15:42 -0800574 root_i = jffs2_iget(sb, 1);
575 if (IS_ERR(root_i)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800576 jffs2_dbg(1, "get root inode failed\n");
David Howells5451f792008-02-07 00:15:42 -0800577 ret = PTR_ERR(root_i);
578 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 }
580
David Howells5451f792008-02-07 00:15:42 -0800581 ret = -ENOMEM;
582
Linus Torvalds623ff772012-03-30 17:31:56 -0700583 jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
Al Viro48fde702012-01-08 22:15:13 -0500584 sb->s_root = d_make_root(root_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (!sb->s_root)
Al Viro48fde702012-01-08 22:15:13 -0500586 goto out_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 sb->s_maxbytes = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 sb->s_blocksize = PAGE_CACHE_SIZE;
590 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
591 sb->s_magic = JFFS2_SUPER_MAGIC;
592 if (!(sb->s_flags & MS_RDONLY))
593 jffs2_start_garbage_collect_thread(c);
594 return 0;
595
David Howells5451f792008-02-07 00:15:42 -0800596out_root:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 jffs2_free_ino_caches(c);
598 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100599 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 vfree(c->blocks);
601 else
602 kfree(c->blocks);
603 out_inohash:
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900604 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 kfree(c->inocache_list);
606 out_wbuf:
607 jffs2_flash_cleanup(c);
608
609 return ret;
610}
611
612void jffs2_gc_release_inode(struct jffs2_sb_info *c,
613 struct jffs2_inode_info *f)
614{
615 iput(OFNI_EDONI_2SFFJ(f));
616}
617
618struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
David Woodhouse1b690b42008-05-01 16:59:24 +0100619 int inum, int unlinked)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
621 struct inode *inode;
622 struct jffs2_inode_cache *ic;
David Woodhouse1b690b42008-05-01 16:59:24 +0100623
624 if (unlinked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /* The inode has zero nlink but its nodes weren't yet marked
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000626 obsolete. This has to be because we're still waiting for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 the final (close() and) iput() to happen.
628
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000629 There's a possibility that the final iput() could have
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 happened while we were contemplating. In order to ensure
631 that we don't cause a new read_inode() (which would fail)
632 for the inode in question, we use ilookup() in this case
633 instead of iget().
634
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000635 The nlink can't _become_ zero at this point because we're
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 holding the alloc_sem, and jffs2_do_unlink() would also
637 need that while decrementing nlink on any inode.
638 */
639 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
640 if (!inode) {
Joe Perches9c261b32012-02-15 15:56:43 -0800641 jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
642 inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644 spin_lock(&c->inocache_lock);
645 ic = jffs2_get_ino_cache(c, inum);
646 if (!ic) {
Joe Perches9c261b32012-02-15 15:56:43 -0800647 jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
648 inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 spin_unlock(&c->inocache_lock);
650 return NULL;
651 }
652 if (ic->state != INO_STATE_CHECKEDABSENT) {
653 /* Wait for progress. Don't just loop */
Joe Perches9c261b32012-02-15 15:56:43 -0800654 jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
655 ic->ino, ic->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
657 } else {
658 spin_unlock(&c->inocache_lock);
659 }
660
661 return NULL;
662 }
663 } else {
664 /* Inode has links to it still; they're not going away because
665 jffs2_do_unlink() would need the alloc_sem and we have it.
666 Just iget() it, and if read_inode() is necessary that's OK.
667 */
David Howells5451f792008-02-07 00:15:42 -0800668 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
669 if (IS_ERR(inode))
670 return ERR_CAST(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 }
672 if (is_bad_inode(inode)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800673 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
674 inum, unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 /* NB. This will happen again. We need to do something appropriate here. */
676 iput(inode);
677 return ERR_PTR(-EIO);
678 }
679
680 return JFFS2_INODE_INFO(inode);
681}
682
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000683unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
684 struct jffs2_inode_info *f,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 unsigned long offset,
686 unsigned long *priv)
687{
688 struct inode *inode = OFNI_EDONI_2SFFJ(f);
689 struct page *pg;
690
Sasha Levin67f9fd92014-04-03 14:48:18 -0700691 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 (void *)jffs2_do_readpage_unlock, inode);
693 if (IS_ERR(pg))
694 return (void *)pg;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 *priv = (unsigned long)pg;
697 return kmap(pg);
698}
699
700void jffs2_gc_release_page(struct jffs2_sb_info *c,
701 unsigned char *ptr,
702 unsigned long *priv)
703{
704 struct page *pg = (void *)*priv;
705
706 kunmap(pg);
707 page_cache_release(pg);
708}
709
710static int jffs2_flash_setup(struct jffs2_sb_info *c) {
711 int ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if (jffs2_cleanmarker_oob(c)) {
714 /* NAND flash... do setup accordingly */
715 ret = jffs2_nand_flash_setup(c);
716 if (ret)
717 return ret;
718 }
719
Andrew Victor8f15fd52005-02-09 09:17:45 +0000720 /* and Dataflash */
721 if (jffs2_dataflash(c)) {
722 ret = jffs2_dataflash_setup(c);
723 if (ret)
724 return ret;
725 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100726
727 /* and Intel "Sibley" flash */
728 if (jffs2_nor_wbuf_flash(c)) {
729 ret = jffs2_nor_wbuf_flash_setup(c);
730 if (ret)
731 return ret;
732 }
733
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300734 /* and an UBI volume */
735 if (jffs2_ubivol(c)) {
736 ret = jffs2_ubivol_setup(c);
737 if (ret)
738 return ret;
739 }
740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 return ret;
742}
743
744void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
745
746 if (jffs2_cleanmarker_oob(c)) {
747 jffs2_nand_flash_cleanup(c);
748 }
749
Andrew Victor8f15fd52005-02-09 09:17:45 +0000750 /* and DataFlash */
751 if (jffs2_dataflash(c)) {
752 jffs2_dataflash_cleanup(c);
753 }
Nicolas Pitre59da7212005-08-06 05:51:33 +0100754
755 /* and Intel "Sibley" flash */
756 if (jffs2_nor_wbuf_flash(c)) {
757 jffs2_nor_wbuf_flash_cleanup(c);
758 }
Artem Bityutskiy0029da32006-10-04 19:15:21 +0300759
760 /* and an UBI volume */
761 if (jffs2_ubivol(c)) {
762 jffs2_ubivol_cleanup(c);
763 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}