blob: dbab798f5cafefd8e0ad848298a7baa0f1b70ad4 [file] [log] [blame]
Miklos Szeredie5e55582005-09-09 13:10:28 -07001/*
2 FUSE: Filesystem in Userspace
Miklos Szeredi1729a162008-11-26 12:03:54 +01003 Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
Miklos Szeredie5e55582005-09-09 13:10:28 -07004
5 This program can be distributed under the terms of the GNU GPL.
6 See the file COPYING.
7*/
8
9#include "fuse_i.h"
10
11#include <linux/pagemap.h>
12#include <linux/file.h>
Miklos Szeredie5e55582005-09-09 13:10:28 -070013#include <linux/sched.h>
14#include <linux/namei.h>
Miklos Szeredi07e77dc2010-12-07 20:16:56 +010015#include <linux/slab.h>
Miklos Szeredie5e55582005-09-09 13:10:28 -070016
Al Viro8d3af7f2013-05-18 03:03:58 -040017static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
Feng Shuo4582a4a2013-01-15 11:23:28 +080018{
19 struct fuse_conn *fc = get_fuse_conn(dir);
20 struct fuse_inode *fi = get_fuse_inode(dir);
21
22 if (!fc->do_readdirplus)
23 return false;
Eric Wong634734b2013-02-06 22:29:01 +000024 if (!fc->readdirplus_auto)
25 return true;
Feng Shuo4582a4a2013-01-15 11:23:28 +080026 if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
27 return true;
Al Viro8d3af7f2013-05-18 03:03:58 -040028 if (ctx->pos == 0)
Feng Shuo4582a4a2013-01-15 11:23:28 +080029 return true;
30 return false;
31}
32
33static void fuse_advise_use_readdirplus(struct inode *dir)
34{
35 struct fuse_inode *fi = get_fuse_inode(dir);
36
37 set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
38}
39
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070040#if BITS_PER_LONG >= 64
41static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
42{
43 entry->d_time = time;
44}
45
46static inline u64 fuse_dentry_time(struct dentry *entry)
47{
48 return entry->d_time;
49}
50#else
51/*
52 * On 32 bit archs store the high 32 bits of time in d_fsdata
53 */
54static void fuse_dentry_settime(struct dentry *entry, u64 time)
55{
56 entry->d_time = time;
57 entry->d_fsdata = (void *) (unsigned long) (time >> 32);
58}
59
60static u64 fuse_dentry_time(struct dentry *entry)
61{
62 return (u64) entry->d_time +
63 ((u64) (unsigned long) entry->d_fsdata << 32);
64}
65#endif
66
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080067/*
68 * FUSE caches dentries and attributes with separate timeout. The
69 * time in jiffies until the dentry/attributes are valid is stored in
70 * dentry->d_time and fuse_inode->i_time respectively.
71 */
72
73/*
74 * Calculate the time in jiffies until a dentry/attributes are valid
75 */
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070076static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
Miklos Szeredie5e55582005-09-09 13:10:28 -070077{
Miklos Szeredi685d16d2006-07-30 03:04:08 -070078 if (sec || nsec) {
79 struct timespec ts = {sec, nsec};
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070080 return get_jiffies_64() + timespec_to_jiffies(&ts);
Miklos Szeredi685d16d2006-07-30 03:04:08 -070081 } else
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070082 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -070083}
84
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080085/*
86 * Set dentry and possibly attribute timeouts from the lookup/mk*
87 * replies
88 */
Miklos Szeredi1fb69e72007-10-18 03:06:58 -070089static void fuse_change_entry_timeout(struct dentry *entry,
90 struct fuse_entry_out *o)
Miklos Szeredi0aa7c692006-01-06 00:19:34 -080091{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070092 fuse_dentry_settime(entry,
93 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
Miklos Szeredi1fb69e72007-10-18 03:06:58 -070094}
95
96static u64 attr_timeout(struct fuse_attr_out *o)
97{
98 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
99}
100
101static u64 entry_attr_timeout(struct fuse_entry_out *o)
102{
103 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800104}
105
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800106/*
107 * Mark the attributes as stale, so that at the next call to
108 * ->getattr() they will be fetched from userspace
109 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800110void fuse_invalidate_attr(struct inode *inode)
111{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700112 get_fuse_inode(inode)->i_time = 0;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800113}
114
Andrew Gallagher451418f2013-11-05 03:55:43 -0800115/**
116 * Mark the attributes as stale due to an atime change. Avoid the invalidate if
117 * atime is not used.
118 */
119void fuse_invalidate_atime(struct inode *inode)
120{
121 if (!IS_RDONLY(inode))
122 fuse_invalidate_attr(inode);
123}
124
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800125/*
126 * Just mark the entry as stale, so that a next attempt to look it up
127 * will result in a new lookup call to userspace
128 *
129 * This is called when a dentry is about to become negative and the
130 * timeout is unknown (unlink, rmdir, rename and in some cases
131 * lookup)
132 */
Miklos Szeredidbd561d2008-07-25 01:49:00 -0700133void fuse_invalidate_entry_cache(struct dentry *entry)
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800134{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700135 fuse_dentry_settime(entry, 0);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800136}
137
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800138/*
139 * Same as fuse_invalidate_entry_cache(), but also try to remove the
140 * dentry from the hash
141 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800142static void fuse_invalidate_entry(struct dentry *entry)
143{
144 d_invalidate(entry);
145 fuse_invalidate_entry_cache(entry);
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800146}
147
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700148static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
149 u64 nodeid, struct qstr *name,
Miklos Szeredie5e55582005-09-09 13:10:28 -0700150 struct fuse_entry_out *outarg)
151{
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700152 memset(outarg, 0, sizeof(struct fuse_entry_out));
Miklos Szeredie5e55582005-09-09 13:10:28 -0700153 req->in.h.opcode = FUSE_LOOKUP;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700154 req->in.h.nodeid = nodeid;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700155 req->in.numargs = 1;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700156 req->in.args[0].size = name->len + 1;
157 req->in.args[0].value = name->name;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700158 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700159 if (fc->minor < 9)
160 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
161 else
162 req->out.args[0].size = sizeof(struct fuse_entry_out);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700163 req->out.args[0].value = outarg;
164}
165
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700166u64 fuse_get_attr_version(struct fuse_conn *fc)
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800167{
168 u64 curr_version;
169
170 /*
171 * The spin lock isn't actually needed on 64bit archs, but we
172 * don't yet care too much about such optimizations.
173 */
174 spin_lock(&fc->lock);
175 curr_version = fc->attr_version;
176 spin_unlock(&fc->lock);
177
178 return curr_version;
179}
180
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800181/*
182 * Check whether the dentry is still valid
183 *
184 * If the entry validity timeout has expired and the dentry is
185 * positive, try to redo the lookup. If the lookup results in a
186 * different inode, then let the VFS invalidate the dentry and redo
187 * the lookup once more. If the lookup results in the same inode,
188 * then refresh the attributes, timeouts and mark the dentry valid.
189 */
Al Viro0b728e12012-06-10 16:03:43 -0400190static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700191{
Nick Piggin34286d62011-01-07 17:49:57 +1100192 struct inode *inode;
Miklos Szeredi28420da2013-06-03 14:40:22 +0200193 struct dentry *parent;
194 struct fuse_conn *fc;
Miklos Szeredi6314efe2013-10-01 16:41:22 +0200195 struct fuse_inode *fi;
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200196 int ret;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800197
Miklos Szeredie7c0a162011-03-21 13:58:06 +0100198 inode = ACCESS_ONCE(entry->d_inode);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800199 if (inode && is_bad_inode(inode))
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200200 goto invalid;
Anand Avati154210c2014-06-26 20:21:57 -0400201 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
202 (flags & LOOKUP_REVAL)) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700203 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700204 struct fuse_entry_out outarg;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800205 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100206 struct fuse_forget_link *forget;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700207 u64 attr_version;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800208
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800209 /* For negative dentries, always do a fresh lookup */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800210 if (!inode)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200211 goto invalid;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800212
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200213 ret = -ECHILD;
Al Viro0b728e12012-06-10 16:03:43 -0400214 if (flags & LOOKUP_RCU)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200215 goto out;
Miklos Szeredie7c0a162011-03-21 13:58:06 +0100216
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800217 fc = get_fuse_conn(inode);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400218 req = fuse_get_req_nopages(fc);
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200219 ret = PTR_ERR(req);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700220 if (IS_ERR(req))
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200221 goto out;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700222
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100223 forget = fuse_alloc_forget();
224 if (!forget) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800225 fuse_put_request(fc, req);
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200226 ret = -ENOMEM;
227 goto out;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800228 }
229
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800230 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700231
Miklos Szeredie956edd2006-10-17 00:10:12 -0700232 parent = dget_parent(entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700233 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
234 &entry->d_name, &outarg);
Tejun Heob93f8582008-11-26 12:03:55 +0100235 fuse_request_send(fc, req);
Miklos Szeredie956edd2006-10-17 00:10:12 -0700236 dput(parent);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700237 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800238 fuse_put_request(fc, req);
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800239 /* Zero nodeid is same as -ENOENT */
240 if (!err && !outarg.nodeid)
241 err = -ENOENT;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700242 if (!err) {
Miklos Szeredi6314efe2013-10-01 16:41:22 +0200243 fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700244 if (outarg.nodeid != get_node_id(inode)) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100245 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200246 goto invalid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700247 }
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700248 spin_lock(&fc->lock);
Miklos Szeredi1729a162008-11-26 12:03:54 +0100249 fi->nlookup++;
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700250 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700251 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100252 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700253 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200254 goto invalid;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700255
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700256 fuse_change_attributes(inode, &outarg.attr,
257 entry_attr_timeout(&outarg),
258 attr_version);
259 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi28420da2013-06-03 14:40:22 +0200260 } else if (inode) {
Miklos Szeredi6314efe2013-10-01 16:41:22 +0200261 fi = get_fuse_inode(inode);
262 if (flags & LOOKUP_RCU) {
263 if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
264 return -ECHILD;
265 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
Miklos Szeredi28420da2013-06-03 14:40:22 +0200266 parent = dget_parent(entry);
267 fuse_advise_use_readdirplus(parent->d_inode);
268 dput(parent);
269 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700270 }
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200271 ret = 1;
272out:
273 return ret;
274
275invalid:
276 ret = 0;
277 goto out;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700278}
279
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800280static int invalid_nodeid(u64 nodeid)
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800281{
282 return !nodeid || nodeid == FUSE_ROOT_ID;
283}
284
Al Viro42695902009-02-20 05:59:13 +0000285const struct dentry_operations fuse_dentry_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700286 .d_revalidate = fuse_dentry_revalidate,
287};
288
Timo Savolaa5bfffa2007-04-08 16:04:00 -0700289int fuse_valid_type(int m)
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800290{
291 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
292 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
293}
294
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700295int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
296 struct fuse_entry_out *outarg, struct inode **inode)
297{
298 struct fuse_conn *fc = get_fuse_conn_super(sb);
299 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100300 struct fuse_forget_link *forget;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700301 u64 attr_version;
302 int err;
303
304 *inode = NULL;
305 err = -ENAMETOOLONG;
306 if (name->len > FUSE_NAME_MAX)
307 goto out;
308
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400309 req = fuse_get_req_nopages(fc);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700310 err = PTR_ERR(req);
311 if (IS_ERR(req))
312 goto out;
313
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100314 forget = fuse_alloc_forget();
315 err = -ENOMEM;
316 if (!forget) {
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700317 fuse_put_request(fc, req);
318 goto out;
319 }
320
321 attr_version = fuse_get_attr_version(fc);
322
323 fuse_lookup_init(fc, req, nodeid, name, outarg);
Tejun Heob93f8582008-11-26 12:03:55 +0100324 fuse_request_send(fc, req);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700325 err = req->out.h.error;
326 fuse_put_request(fc, req);
327 /* Zero nodeid is same as -ENOENT, but with valid timeout */
328 if (err || !outarg->nodeid)
329 goto out_put_forget;
330
331 err = -EIO;
332 if (!outarg->nodeid)
333 goto out_put_forget;
334 if (!fuse_valid_type(outarg->attr.mode))
335 goto out_put_forget;
336
337 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
338 &outarg->attr, entry_attr_timeout(outarg),
339 attr_version);
340 err = -ENOMEM;
341 if (!*inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100342 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700343 goto out;
344 }
345 err = 0;
346
347 out_put_forget:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100348 kfree(forget);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700349 out:
350 return err;
351}
352
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800353static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400354 unsigned int flags)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700355{
356 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700357 struct fuse_entry_out outarg;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700358 struct inode *inode;
Miklos Szeredi0de62562008-07-25 01:48:59 -0700359 struct dentry *newent;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700360 bool outarg_valid = true;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700361
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700362 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
363 &outarg, &inode);
364 if (err == -ENOENT) {
365 outarg_valid = false;
366 err = 0;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800367 }
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700368 if (err)
369 goto out_err;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800370
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700371 err = -EIO;
372 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
373 goto out_iput;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700374
Miklos Szeredib70a80e2013-10-01 16:44:54 +0200375 newent = d_materialise_unique(entry, inode);
Miklos Szeredi5835f332013-09-05 11:44:42 +0200376 err = PTR_ERR(newent);
377 if (IS_ERR(newent))
378 goto out_err;
Miklos Szeredid2a85162006-10-17 00:10:11 -0700379
Miklos Szeredi0de62562008-07-25 01:48:59 -0700380 entry = newent ? newent : entry;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700381 if (outarg_valid)
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700382 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800383 else
384 fuse_invalidate_entry_cache(entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700385
Feng Shuo4582a4a2013-01-15 11:23:28 +0800386 fuse_advise_use_readdirplus(dir);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700387 return newent;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700388
389 out_iput:
390 iput(inode);
391 out_err:
392 return ERR_PTR(err);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700393}
394
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800395/*
396 * Atomic create+open operation
397 *
398 * If the filesystem doesn't support this, then fall back to separate
399 * 'mknod' + 'open' requests.
400 */
Al Virod9585272012-06-22 12:39:14 +0400401static int fuse_create_open(struct inode *dir, struct dentry *entry,
Al Viro30d90492012-06-22 12:40:19 +0400402 struct file *file, unsigned flags,
Al Virod9585272012-06-22 12:39:14 +0400403 umode_t mode, int *opened)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800404{
405 int err;
406 struct inode *inode;
407 struct fuse_conn *fc = get_fuse_conn(dir);
408 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100409 struct fuse_forget_link *forget;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200410 struct fuse_create_in inarg;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800411 struct fuse_open_out outopen;
412 struct fuse_entry_out outentry;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800413 struct fuse_file *ff;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800414
Miklos Szerediaf109bc2012-08-15 13:01:24 +0200415 /* Userspace expects S_IFREG in create mode */
416 BUG_ON((mode & S_IFMT) != S_IFREG);
417
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100418 forget = fuse_alloc_forget();
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200419 err = -ENOMEM;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100420 if (!forget)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200421 goto out_err;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700422
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400423 req = fuse_get_req_nopages(fc);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700424 err = PTR_ERR(req);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700425 if (IS_ERR(req))
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700426 goto out_put_forget_req;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800427
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700428 err = -ENOMEM;
Tejun Heoacf99432008-11-26 12:03:55 +0100429 ff = fuse_file_alloc(fc);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800430 if (!ff)
431 goto out_put_request;
432
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200433 if (!fc->dont_mask)
434 mode &= ~current_umask();
435
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800436 flags &= ~O_NOCTTY;
437 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700438 memset(&outentry, 0, sizeof(outentry));
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800439 inarg.flags = flags;
440 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200441 inarg.umask = current_umask();
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800442 req->in.h.opcode = FUSE_CREATE;
443 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800444 req->in.numargs = 2;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200445 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
446 sizeof(inarg);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800447 req->in.args[0].value = &inarg;
448 req->in.args[1].size = entry->d_name.len + 1;
449 req->in.args[1].value = entry->d_name.name;
450 req->out.numargs = 2;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700451 if (fc->minor < 9)
452 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
453 else
454 req->out.args[0].size = sizeof(outentry);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800455 req->out.args[0].value = &outentry;
456 req->out.args[1].size = sizeof(outopen);
457 req->out.args[1].value = &outopen;
Tejun Heob93f8582008-11-26 12:03:55 +0100458 fuse_request_send(fc, req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800459 err = req->out.h.error;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200460 if (err)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800461 goto out_free_ff;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800462
463 err = -EIO;
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800464 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800465 goto out_free_ff;
466
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700467 fuse_put_request(fc, req);
Miklos Szeredic7b71432009-04-28 16:56:37 +0200468 ff->fh = outopen.fh;
469 ff->nodeid = outentry.nodeid;
470 ff->open_flags = outopen.open_flags;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800471 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700472 &outentry.attr, entry_attr_timeout(&outentry), 0);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800473 if (!inode) {
474 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200475 fuse_sync_release(ff, flags);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100476 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200477 err = -ENOMEM;
478 goto out_err;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800479 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100480 kfree(forget);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800481 d_instantiate(entry, inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700482 fuse_change_entry_timeout(entry, &outentry);
Miklos Szeredi0952b2a2008-02-06 01:38:38 -0800483 fuse_invalidate_attr(dir);
Al Viro30d90492012-06-22 12:40:19 +0400484 err = finish_open(file, entry, generic_file_open, opened);
485 if (err) {
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200486 fuse_sync_release(ff, flags);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200487 } else {
488 file->private_data = fuse_file_get(ff);
489 fuse_finish_open(inode, file);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800490 }
Al Virod9585272012-06-22 12:39:14 +0400491 return err;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800492
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200493out_free_ff:
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800494 fuse_file_free(ff);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200495out_put_request:
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800496 fuse_put_request(fc, req);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200497out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100498 kfree(forget);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200499out_err:
Al Virod9585272012-06-22 12:39:14 +0400500 return err;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200501}
502
503static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
Al Virod9585272012-06-22 12:39:14 +0400504static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
Al Viro30d90492012-06-22 12:40:19 +0400505 struct file *file, unsigned flags,
Al Virod9585272012-06-22 12:39:14 +0400506 umode_t mode, int *opened)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200507{
508 int err;
509 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200510 struct dentry *res = NULL;
511
512 if (d_unhashed(entry)) {
Al Viro00cd8dd2012-06-10 17:13:09 -0400513 res = fuse_lookup(dir, entry, 0);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200514 if (IS_ERR(res))
Al Virod9585272012-06-22 12:39:14 +0400515 return PTR_ERR(res);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200516
517 if (res)
518 entry = res;
519 }
520
521 if (!(flags & O_CREAT) || entry->d_inode)
522 goto no_open;
523
524 /* Only creates */
Al Viro47237682012-06-10 05:01:45 -0400525 *opened |= FILE_CREATED;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200526
527 if (fc->no_create)
528 goto mknod;
529
Al Viro30d90492012-06-22 12:40:19 +0400530 err = fuse_create_open(dir, entry, file, flags, mode, opened);
Al Virod9585272012-06-22 12:39:14 +0400531 if (err == -ENOSYS) {
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200532 fc->no_create = 1;
533 goto mknod;
534 }
535out_dput:
536 dput(res);
Al Virod9585272012-06-22 12:39:14 +0400537 return err;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200538
539mknod:
540 err = fuse_mknod(dir, entry, mode, 0);
Al Virod9585272012-06-22 12:39:14 +0400541 if (err)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200542 goto out_dput;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200543no_open:
Al Viroe45198a2012-06-10 06:48:09 -0400544 return finish_no_open(file, res);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800545}
546
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800547/*
548 * Code shared between mknod, mkdir, symlink and link
549 */
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700550static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
551 struct inode *dir, struct dentry *entry,
Al Viro541af6a2011-07-26 03:17:33 -0400552 umode_t mode)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700553{
554 struct fuse_entry_out outarg;
555 struct inode *inode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700556 int err;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100557 struct fuse_forget_link *forget;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800558
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100559 forget = fuse_alloc_forget();
560 if (!forget) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800561 fuse_put_request(fc, req);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100562 return -ENOMEM;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800563 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700564
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700565 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700566 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700567 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700568 if (fc->minor < 9)
569 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
570 else
571 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700572 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100573 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700574 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800575 fuse_put_request(fc, req);
576 if (err)
577 goto out_put_forget_req;
578
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800579 err = -EIO;
580 if (invalid_nodeid(outarg.nodeid))
Miklos Szeredi2d510132006-11-25 11:09:20 -0800581 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800582
583 if ((outarg.attr.mode ^ mode) & S_IFMT)
Miklos Szeredi2d510132006-11-25 11:09:20 -0800584 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800585
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700586 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700587 &outarg.attr, entry_attr_timeout(&outarg), 0);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700588 if (!inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100589 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700590 return -ENOMEM;
591 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100592 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700593
Miklos Szeredib70a80e2013-10-01 16:44:54 +0200594 err = d_instantiate_no_diralias(entry, inode);
595 if (err)
596 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700597
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700598 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700599 fuse_invalidate_attr(dir);
600 return 0;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800601
Miklos Szeredi2d510132006-11-25 11:09:20 -0800602 out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100603 kfree(forget);
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800604 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700605}
606
Al Viro1a67aaf2011-07-26 01:52:52 -0400607static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700608 dev_t rdev)
609{
610 struct fuse_mknod_in inarg;
611 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400612 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700613 if (IS_ERR(req))
614 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700615
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200616 if (!fc->dont_mask)
617 mode &= ~current_umask();
618
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700619 memset(&inarg, 0, sizeof(inarg));
620 inarg.mode = mode;
621 inarg.rdev = new_encode_dev(rdev);
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200622 inarg.umask = current_umask();
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700623 req->in.h.opcode = FUSE_MKNOD;
624 req->in.numargs = 2;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200625 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
626 sizeof(inarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700627 req->in.args[0].value = &inarg;
628 req->in.args[1].size = entry->d_name.len + 1;
629 req->in.args[1].value = entry->d_name.name;
630 return create_new_entry(fc, req, dir, entry, mode);
631}
632
Al Viro4acdaf22011-07-26 01:42:34 -0400633static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400634 bool excl)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700635{
636 return fuse_mknod(dir, entry, mode, 0);
637}
638
Al Viro18bb1db2011-07-26 01:41:39 -0400639static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700640{
641 struct fuse_mkdir_in inarg;
642 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400643 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700644 if (IS_ERR(req))
645 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700646
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200647 if (!fc->dont_mask)
648 mode &= ~current_umask();
649
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700650 memset(&inarg, 0, sizeof(inarg));
651 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200652 inarg.umask = current_umask();
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700653 req->in.h.opcode = FUSE_MKDIR;
654 req->in.numargs = 2;
655 req->in.args[0].size = sizeof(inarg);
656 req->in.args[0].value = &inarg;
657 req->in.args[1].size = entry->d_name.len + 1;
658 req->in.args[1].value = entry->d_name.name;
659 return create_new_entry(fc, req, dir, entry, S_IFDIR);
660}
661
662static int fuse_symlink(struct inode *dir, struct dentry *entry,
663 const char *link)
664{
665 struct fuse_conn *fc = get_fuse_conn(dir);
666 unsigned len = strlen(link) + 1;
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400667 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700668 if (IS_ERR(req))
669 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700670
671 req->in.h.opcode = FUSE_SYMLINK;
672 req->in.numargs = 2;
673 req->in.args[0].size = entry->d_name.len + 1;
674 req->in.args[0].value = entry->d_name.name;
675 req->in.args[1].size = len;
676 req->in.args[1].value = link;
677 return create_new_entry(fc, req, dir, entry, S_IFLNK);
678}
679
Maxim Patlasov31f32672014-04-28 14:19:24 +0200680static inline void fuse_update_ctime(struct inode *inode)
681{
682 if (!IS_NOCMTIME(inode)) {
683 inode->i_ctime = current_fs_time(inode->i_sb);
684 mark_inode_dirty_sync(inode);
685 }
686}
687
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700688static int fuse_unlink(struct inode *dir, struct dentry *entry)
689{
690 int err;
691 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400692 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700693 if (IS_ERR(req))
694 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700695
696 req->in.h.opcode = FUSE_UNLINK;
697 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700698 req->in.numargs = 1;
699 req->in.args[0].size = entry->d_name.len + 1;
700 req->in.args[0].value = entry->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100701 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700702 err = req->out.h.error;
703 fuse_put_request(fc, req);
704 if (!err) {
705 struct inode *inode = entry->d_inode;
Miklos Szerediac45d612012-03-05 15:48:11 +0100706 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700707
Miklos Szerediac45d612012-03-05 15:48:11 +0100708 spin_lock(&fc->lock);
709 fi->attr_version = ++fc->attr_version;
Miklos Szeredidfca7ce2013-02-04 15:57:42 +0100710 /*
711 * If i_nlink == 0 then unlink doesn't make sense, yet this can
712 * happen if userspace filesystem is careless. It would be
713 * difficult to enforce correct nlink usage so just ignore this
714 * condition here
715 */
716 if (inode->i_nlink > 0)
717 drop_nlink(inode);
Miklos Szerediac45d612012-03-05 15:48:11 +0100718 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700719 fuse_invalidate_attr(inode);
720 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800721 fuse_invalidate_entry_cache(entry);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200722 fuse_update_ctime(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700723 } else if (err == -EINTR)
724 fuse_invalidate_entry(entry);
725 return err;
726}
727
728static int fuse_rmdir(struct inode *dir, struct dentry *entry)
729{
730 int err;
731 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400732 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700733 if (IS_ERR(req))
734 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700735
736 req->in.h.opcode = FUSE_RMDIR;
737 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700738 req->in.numargs = 1;
739 req->in.args[0].size = entry->d_name.len + 1;
740 req->in.args[0].value = entry->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100741 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700742 err = req->out.h.error;
743 fuse_put_request(fc, req);
744 if (!err) {
Dave Hansence71ec32006-09-30 23:29:06 -0700745 clear_nlink(entry->d_inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700746 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800747 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700748 } else if (err == -EINTR)
749 fuse_invalidate_entry(entry);
750 return err;
751}
752
Miklos Szeredi1560c972014-04-28 16:43:44 +0200753static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
754 struct inode *newdir, struct dentry *newent,
755 unsigned int flags, int opcode, size_t argsize)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700756{
757 int err;
Miklos Szeredi1560c972014-04-28 16:43:44 +0200758 struct fuse_rename2_in inarg;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700759 struct fuse_conn *fc = get_fuse_conn(olddir);
Miklos Szeredi1560c972014-04-28 16:43:44 +0200760 struct fuse_req *req;
Sage Weile4eaac02011-05-24 13:06:07 -0700761
Miklos Szeredi1560c972014-04-28 16:43:44 +0200762 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700763 if (IS_ERR(req))
764 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700765
Miklos Szeredi1560c972014-04-28 16:43:44 +0200766 memset(&inarg, 0, argsize);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700767 inarg.newdir = get_node_id(newdir);
Miklos Szeredi1560c972014-04-28 16:43:44 +0200768 inarg.flags = flags;
769 req->in.h.opcode = opcode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700770 req->in.h.nodeid = get_node_id(olddir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700771 req->in.numargs = 3;
Miklos Szeredi1560c972014-04-28 16:43:44 +0200772 req->in.args[0].size = argsize;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700773 req->in.args[0].value = &inarg;
774 req->in.args[1].size = oldent->d_name.len + 1;
775 req->in.args[1].value = oldent->d_name.name;
776 req->in.args[2].size = newent->d_name.len + 1;
777 req->in.args[2].value = newent->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100778 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700779 err = req->out.h.error;
780 fuse_put_request(fc, req);
781 if (!err) {
Miklos Szeredi08b63302007-11-28 16:22:03 -0800782 /* ctime changes */
783 fuse_invalidate_attr(oldent->d_inode);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200784 fuse_update_ctime(oldent->d_inode);
Miklos Szeredi08b63302007-11-28 16:22:03 -0800785
Miklos Szeredi1560c972014-04-28 16:43:44 +0200786 if (flags & RENAME_EXCHANGE) {
787 fuse_invalidate_attr(newent->d_inode);
788 fuse_update_ctime(newent->d_inode);
789 }
790
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700791 fuse_invalidate_attr(olddir);
792 if (olddir != newdir)
793 fuse_invalidate_attr(newdir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800794
795 /* newent will end up negative */
Miklos Szeredi1560c972014-04-28 16:43:44 +0200796 if (!(flags & RENAME_EXCHANGE) && newent->d_inode) {
Miklos Szeredi5219f342009-11-04 10:24:52 +0100797 fuse_invalidate_attr(newent->d_inode);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800798 fuse_invalidate_entry_cache(newent);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200799 fuse_update_ctime(newent->d_inode);
Miklos Szeredi5219f342009-11-04 10:24:52 +0100800 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700801 } else if (err == -EINTR) {
802 /* If request was interrupted, DEITY only knows if the
803 rename actually took place. If the invalidation
804 fails (e.g. some process has CWD under the renamed
805 directory), then there can be inconsistency between
806 the dcache and the real filesystem. Tough luck. */
807 fuse_invalidate_entry(oldent);
808 if (newent->d_inode)
809 fuse_invalidate_entry(newent);
810 }
811
812 return err;
813}
814
Miklos Szeredi1560c972014-04-28 16:43:44 +0200815static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
816 struct inode *newdir, struct dentry *newent,
817 unsigned int flags)
818{
819 struct fuse_conn *fc = get_fuse_conn(olddir);
820 int err;
821
822 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
823 return -EINVAL;
824
Miklos Szeredi4237ba42014-07-10 10:50:19 +0200825 if (flags) {
826 if (fc->no_rename2 || fc->minor < 23)
827 return -EINVAL;
Miklos Szeredi1560c972014-04-28 16:43:44 +0200828
Miklos Szeredi4237ba42014-07-10 10:50:19 +0200829 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
830 FUSE_RENAME2,
831 sizeof(struct fuse_rename2_in));
832 if (err == -ENOSYS) {
833 fc->no_rename2 = 1;
834 err = -EINVAL;
835 }
836 } else {
837 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
838 FUSE_RENAME,
839 sizeof(struct fuse_rename_in));
Miklos Szeredi1560c972014-04-28 16:43:44 +0200840 }
Miklos Szeredi1560c972014-04-28 16:43:44 +0200841
Miklos Szeredi4237ba42014-07-10 10:50:19 +0200842 return err;
843}
844
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700845static int fuse_link(struct dentry *entry, struct inode *newdir,
846 struct dentry *newent)
847{
848 int err;
849 struct fuse_link_in inarg;
850 struct inode *inode = entry->d_inode;
851 struct fuse_conn *fc = get_fuse_conn(inode);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400852 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700853 if (IS_ERR(req))
854 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700855
856 memset(&inarg, 0, sizeof(inarg));
857 inarg.oldnodeid = get_node_id(inode);
858 req->in.h.opcode = FUSE_LINK;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700859 req->in.numargs = 2;
860 req->in.args[0].size = sizeof(inarg);
861 req->in.args[0].value = &inarg;
862 req->in.args[1].size = newent->d_name.len + 1;
863 req->in.args[1].value = newent->d_name.name;
864 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
865 /* Contrary to "normal" filesystems it can happen that link
866 makes two "logical" inodes point to the same "physical"
867 inode. We invalidate the attributes of the old one, so it
868 will reflect changes in the backing inode (link count,
869 etc.)
870 */
Miklos Szerediac45d612012-03-05 15:48:11 +0100871 if (!err) {
872 struct fuse_inode *fi = get_fuse_inode(inode);
873
874 spin_lock(&fc->lock);
875 fi->attr_version = ++fc->attr_version;
876 inc_nlink(inode);
877 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700878 fuse_invalidate_attr(inode);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200879 fuse_update_ctime(inode);
Miklos Szerediac45d612012-03-05 15:48:11 +0100880 } else if (err == -EINTR) {
881 fuse_invalidate_attr(inode);
882 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700883 return err;
884}
885
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700886static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
887 struct kstat *stat)
888{
Miklos Szeredi203627b2012-05-10 19:49:38 +0400889 unsigned int blkbits;
Pavel Emelyanov83732002013-10-10 17:10:46 +0400890 struct fuse_conn *fc = get_fuse_conn(inode);
891
892 /* see the comment in fuse_change_attributes() */
Maxim Patlasovb0aa7602013-12-26 19:51:11 +0400893 if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
Pavel Emelyanov83732002013-10-10 17:10:46 +0400894 attr->size = i_size_read(inode);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +0400895 attr->mtime = inode->i_mtime.tv_sec;
896 attr->mtimensec = inode->i_mtime.tv_nsec;
Maxim Patlasov31f32672014-04-28 14:19:24 +0200897 attr->ctime = inode->i_ctime.tv_sec;
898 attr->ctimensec = inode->i_ctime.tv_nsec;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +0400899 }
Miklos Szeredi203627b2012-05-10 19:49:38 +0400900
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700901 stat->dev = inode->i_sb->s_dev;
902 stat->ino = attr->ino;
903 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
904 stat->nlink = attr->nlink;
Eric W. Biederman499dcf22012-02-07 16:26:03 -0800905 stat->uid = make_kuid(&init_user_ns, attr->uid);
906 stat->gid = make_kgid(&init_user_ns, attr->gid);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700907 stat->rdev = inode->i_rdev;
908 stat->atime.tv_sec = attr->atime;
909 stat->atime.tv_nsec = attr->atimensec;
910 stat->mtime.tv_sec = attr->mtime;
911 stat->mtime.tv_nsec = attr->mtimensec;
912 stat->ctime.tv_sec = attr->ctime;
913 stat->ctime.tv_nsec = attr->ctimensec;
914 stat->size = attr->size;
915 stat->blocks = attr->blocks;
Miklos Szeredi203627b2012-05-10 19:49:38 +0400916
917 if (attr->blksize != 0)
918 blkbits = ilog2(attr->blksize);
919 else
920 blkbits = inode->i_sb->s_blocksize_bits;
921
922 stat->blksize = 1 << blkbits;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700923}
924
Miklos Szeredic79e3222007-10-18 03:06:59 -0700925static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
926 struct file *file)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700927{
928 int err;
Miklos Szeredic79e3222007-10-18 03:06:59 -0700929 struct fuse_getattr_in inarg;
930 struct fuse_attr_out outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700931 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700932 struct fuse_req *req;
933 u64 attr_version;
934
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400935 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700936 if (IS_ERR(req))
937 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700938
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800939 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700940
Miklos Szeredic79e3222007-10-18 03:06:59 -0700941 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700942 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredic79e3222007-10-18 03:06:59 -0700943 /* Directories have separate file-handle space */
944 if (file && S_ISREG(inode->i_mode)) {
945 struct fuse_file *ff = file->private_data;
946
947 inarg.getattr_flags |= FUSE_GETATTR_FH;
948 inarg.fh = ff->fh;
949 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700950 req->in.h.opcode = FUSE_GETATTR;
951 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700952 req->in.numargs = 1;
953 req->in.args[0].size = sizeof(inarg);
954 req->in.args[0].value = &inarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700955 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700956 if (fc->minor < 9)
957 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
958 else
959 req->out.args[0].size = sizeof(outarg);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700960 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100961 fuse_request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700962 err = req->out.h.error;
963 fuse_put_request(fc, req);
964 if (!err) {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700965 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700966 make_bad_inode(inode);
967 err = -EIO;
968 } else {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700969 fuse_change_attributes(inode, &outarg.attr,
970 attr_timeout(&outarg),
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700971 attr_version);
972 if (stat)
Miklos Szeredic79e3222007-10-18 03:06:59 -0700973 fuse_fillattr(inode, &outarg.attr, stat);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700974 }
975 }
976 return err;
977}
978
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800979int fuse_update_attributes(struct inode *inode, struct kstat *stat,
980 struct file *file, bool *refreshed)
981{
982 struct fuse_inode *fi = get_fuse_inode(inode);
983 int err;
984 bool r;
985
Miklos Szeredi126b9d42014-07-07 15:28:50 +0200986 if (time_before64(fi->i_time, get_jiffies_64())) {
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800987 r = true;
988 err = fuse_do_getattr(inode, stat, file);
989 } else {
990 r = false;
991 err = 0;
992 if (stat) {
993 generic_fillattr(inode, stat);
994 stat->mode = fi->orig_i_mode;
Pavel Shilovsky45c72cd2012-05-10 19:49:38 +0400995 stat->ino = fi->orig_ino;
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800996 }
997 }
998
999 if (refreshed != NULL)
1000 *refreshed = r;
1001
1002 return err;
1003}
1004
John Muir3b463ae2009-05-31 11:13:57 -04001005int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
John Muir451d0f52011-12-06 21:50:06 +01001006 u64 child_nodeid, struct qstr *name)
John Muir3b463ae2009-05-31 11:13:57 -04001007{
1008 int err = -ENOTDIR;
1009 struct inode *parent;
1010 struct dentry *dir;
1011 struct dentry *entry;
1012
1013 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
1014 if (!parent)
1015 return -ENOENT;
1016
1017 mutex_lock(&parent->i_mutex);
1018 if (!S_ISDIR(parent->i_mode))
1019 goto unlock;
1020
1021 err = -ENOENT;
1022 dir = d_find_alias(parent);
1023 if (!dir)
1024 goto unlock;
1025
1026 entry = d_lookup(dir, name);
1027 dput(dir);
1028 if (!entry)
1029 goto unlock;
1030
1031 fuse_invalidate_attr(parent);
1032 fuse_invalidate_entry(entry);
John Muir451d0f52011-12-06 21:50:06 +01001033
1034 if (child_nodeid != 0 && entry->d_inode) {
1035 mutex_lock(&entry->d_inode->i_mutex);
1036 if (get_node_id(entry->d_inode) != child_nodeid) {
1037 err = -ENOENT;
1038 goto badentry;
1039 }
1040 if (d_mountpoint(entry)) {
1041 err = -EBUSY;
1042 goto badentry;
1043 }
1044 if (S_ISDIR(entry->d_inode->i_mode)) {
1045 shrink_dcache_parent(entry);
1046 if (!simple_empty(entry)) {
1047 err = -ENOTEMPTY;
1048 goto badentry;
1049 }
1050 entry->d_inode->i_flags |= S_DEAD;
1051 }
1052 dont_mount(entry);
1053 clear_nlink(entry->d_inode);
1054 err = 0;
1055 badentry:
1056 mutex_unlock(&entry->d_inode->i_mutex);
1057 if (!err)
1058 d_delete(entry);
1059 } else {
1060 err = 0;
1061 }
John Muir3b463ae2009-05-31 11:13:57 -04001062 dput(entry);
John Muir3b463ae2009-05-31 11:13:57 -04001063
1064 unlock:
1065 mutex_unlock(&parent->i_mutex);
1066 iput(parent);
1067 return err;
1068}
1069
Miklos Szeredi87729a52005-09-09 13:10:34 -07001070/*
1071 * Calling into a user-controlled filesystem gives the filesystem
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001072 * daemon ptrace-like capabilities over the current process. This
Miklos Szeredi87729a52005-09-09 13:10:34 -07001073 * means, that the filesystem daemon is able to record the exact
1074 * filesystem operations performed, and can also control the behavior
1075 * of the requester process in otherwise impossible ways. For example
1076 * it can delay the operation for arbitrary length of time allowing
1077 * DoS against the requester.
1078 *
1079 * For this reason only those processes can call into the filesystem,
1080 * for which the owner of the mount has ptrace privilege. This
1081 * excludes processes started by other users, suid or sgid processes.
1082 */
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001083int fuse_allow_current_process(struct fuse_conn *fc)
Miklos Szeredi87729a52005-09-09 13:10:34 -07001084{
David Howellsc69e8d92008-11-14 10:39:19 +11001085 const struct cred *cred;
David Howellsc69e8d92008-11-14 10:39:19 +11001086
Miklos Szeredi87729a52005-09-09 13:10:34 -07001087 if (fc->flags & FUSE_ALLOW_OTHER)
1088 return 1;
1089
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001090 cred = current_cred();
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001091 if (uid_eq(cred->euid, fc->user_id) &&
1092 uid_eq(cred->suid, fc->user_id) &&
1093 uid_eq(cred->uid, fc->user_id) &&
1094 gid_eq(cred->egid, fc->group_id) &&
1095 gid_eq(cred->sgid, fc->group_id) &&
1096 gid_eq(cred->gid, fc->group_id))
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001097 return 1;
Miklos Szeredi87729a52005-09-09 13:10:34 -07001098
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001099 return 0;
Miklos Szeredi87729a52005-09-09 13:10:34 -07001100}
1101
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001102static int fuse_access(struct inode *inode, int mask)
1103{
1104 struct fuse_conn *fc = get_fuse_conn(inode);
1105 struct fuse_req *req;
1106 struct fuse_access_in inarg;
1107 int err;
1108
Miklos Szeredi698fa1d2013-10-01 16:41:23 +02001109 BUG_ON(mask & MAY_NOT_BLOCK);
1110
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001111 if (fc->no_access)
1112 return 0;
1113
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001114 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001115 if (IS_ERR(req))
1116 return PTR_ERR(req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001117
1118 memset(&inarg, 0, sizeof(inarg));
Al Viroe6305c42008-07-15 21:03:57 -04001119 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001120 req->in.h.opcode = FUSE_ACCESS;
1121 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001122 req->in.numargs = 1;
1123 req->in.args[0].size = sizeof(inarg);
1124 req->in.args[0].value = &inarg;
Tejun Heob93f8582008-11-26 12:03:55 +01001125 fuse_request_send(fc, req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001126 err = req->out.h.error;
1127 fuse_put_request(fc, req);
1128 if (err == -ENOSYS) {
1129 fc->no_access = 1;
1130 err = 0;
1131 }
1132 return err;
1133}
1134
Al Viro10556cb2011-06-20 19:28:19 -04001135static int fuse_perm_getattr(struct inode *inode, int mask)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001136{
Al Viro10556cb2011-06-20 19:28:19 -04001137 if (mask & MAY_NOT_BLOCK)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001138 return -ECHILD;
1139
1140 return fuse_do_getattr(inode, NULL, NULL);
1141}
1142
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001143/*
1144 * Check permission. The two basic access models of FUSE are:
1145 *
1146 * 1) Local access checking ('default_permissions' mount option) based
1147 * on file mode. This is the plain old disk filesystem permission
1148 * modell.
1149 *
1150 * 2) "Remote" access checking, where server is responsible for
1151 * checking permission in each inode operation. An exception to this
1152 * is if ->permission() was invoked from sys_access() in which case an
1153 * access request is sent. Execute permission is still checked
1154 * locally based on file mode.
1155 */
Al Viro10556cb2011-06-20 19:28:19 -04001156static int fuse_permission(struct inode *inode, int mask)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001157{
1158 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001159 bool refreshed = false;
1160 int err = 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001161
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001162 if (!fuse_allow_current_process(fc))
Miklos Szeredie5e55582005-09-09 13:10:28 -07001163 return -EACCES;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001164
1165 /*
Miklos Szeredie8e96152007-10-16 23:31:06 -07001166 * If attributes are needed, refresh them before proceeding
Miklos Szeredi244f6382007-10-16 23:31:02 -07001167 */
Miklos Szeredie8e96152007-10-16 23:31:06 -07001168 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1169 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001170 struct fuse_inode *fi = get_fuse_inode(inode);
1171
Miklos Szeredi126b9d42014-07-07 15:28:50 +02001172 if (time_before64(fi->i_time, get_jiffies_64())) {
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001173 refreshed = true;
1174
Al Viro10556cb2011-06-20 19:28:19 -04001175 err = fuse_perm_getattr(inode, mask);
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001176 if (err)
1177 return err;
1178 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001179 }
1180
1181 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
Al Viro2830ba72011-06-20 19:16:29 -04001182 err = generic_permission(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001183
1184 /* If permission is denied, try to refresh file
1185 attributes. This is also needed, because the root
1186 node will at first have no permissions */
Miklos Szeredi244f6382007-10-16 23:31:02 -07001187 if (err == -EACCES && !refreshed) {
Al Viro10556cb2011-06-20 19:28:19 -04001188 err = fuse_perm_getattr(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001189 if (!err)
Al Viro2830ba72011-06-20 19:16:29 -04001190 err = generic_permission(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001191 }
1192
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001193 /* Note: the opposite of the above test does not
1194 exist. So if permissions are revoked this won't be
1195 noticed immediately, only after the attribute
1196 timeout has expired */
Eric Paris9cfcac82010-07-23 11:43:51 -04001197 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
Miklos Szeredie8e96152007-10-16 23:31:06 -07001198 err = fuse_access(inode, mask);
1199 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1200 if (!(inode->i_mode & S_IXUGO)) {
1201 if (refreshed)
1202 return -EACCES;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001203
Al Viro10556cb2011-06-20 19:28:19 -04001204 err = fuse_perm_getattr(inode, mask);
Miklos Szeredie8e96152007-10-16 23:31:06 -07001205 if (!err && !(inode->i_mode & S_IXUGO))
1206 return -EACCES;
1207 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001208 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001209 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001210}
1211
1212static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
Al Viro8d3af7f2013-05-18 03:03:58 -04001213 struct dir_context *ctx)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001214{
1215 while (nbytes >= FUSE_NAME_OFFSET) {
1216 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1217 size_t reclen = FUSE_DIRENT_SIZE(dirent);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001218 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1219 return -EIO;
1220 if (reclen > nbytes)
1221 break;
Miklos Szerediefeb9e62013-09-03 14:28:38 +02001222 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1223 return -EIO;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001224
Al Viro8d3af7f2013-05-18 03:03:58 -04001225 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1226 dirent->ino, dirent->type))
Miklos Szeredie5e55582005-09-09 13:10:28 -07001227 break;
1228
1229 buf += reclen;
1230 nbytes -= reclen;
Al Viro8d3af7f2013-05-18 03:03:58 -04001231 ctx->pos = dirent->off;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001232 }
1233
1234 return 0;
1235}
1236
Anand V. Avati0b05b182012-08-19 08:53:23 -04001237static int fuse_direntplus_link(struct file *file,
1238 struct fuse_direntplus *direntplus,
1239 u64 attr_version)
1240{
1241 int err;
1242 struct fuse_entry_out *o = &direntplus->entry_out;
1243 struct fuse_dirent *dirent = &direntplus->dirent;
1244 struct dentry *parent = file->f_path.dentry;
1245 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1246 struct dentry *dentry;
1247 struct dentry *alias;
1248 struct inode *dir = parent->d_inode;
1249 struct fuse_conn *fc;
1250 struct inode *inode;
1251
1252 if (!o->nodeid) {
1253 /*
1254 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1255 * ENOENT. Instead, it only means the userspace filesystem did
1256 * not want to return attributes/handle for this entry.
1257 *
1258 * So do nothing.
1259 */
1260 return 0;
1261 }
1262
1263 if (name.name[0] == '.') {
1264 /*
1265 * We could potentially refresh the attributes of the directory
1266 * and its parent?
1267 */
1268 if (name.len == 1)
1269 return 0;
1270 if (name.name[1] == '.' && name.len == 2)
1271 return 0;
1272 }
Miklos Szeredia28ef452013-07-17 14:53:53 +02001273
1274 if (invalid_nodeid(o->nodeid))
1275 return -EIO;
1276 if (!fuse_valid_type(o->attr.mode))
1277 return -EIO;
1278
Anand V. Avati0b05b182012-08-19 08:53:23 -04001279 fc = get_fuse_conn(dir);
1280
1281 name.hash = full_name_hash(name.name, name.len);
1282 dentry = d_lookup(parent, &name);
Niels de Vos53ce9a32013-07-17 14:53:53 +02001283 if (dentry) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001284 inode = dentry->d_inode;
Niels de Vos53ce9a32013-07-17 14:53:53 +02001285 if (!inode) {
1286 d_drop(dentry);
Miklos Szeredia28ef452013-07-17 14:53:53 +02001287 } else if (get_node_id(inode) != o->nodeid ||
1288 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
Eric W. Biederman5542aa22014-02-13 09:46:25 -08001289 d_invalidate(dentry);
Miklos Szeredia28ef452013-07-17 14:53:53 +02001290 } else if (is_bad_inode(inode)) {
1291 err = -EIO;
1292 goto out;
Niels de Vos53ce9a32013-07-17 14:53:53 +02001293 } else {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001294 struct fuse_inode *fi;
1295 fi = get_fuse_inode(inode);
1296 spin_lock(&fc->lock);
1297 fi->nlookup++;
1298 spin_unlock(&fc->lock);
1299
Miklos Szeredifa2b7212013-07-17 14:53:53 +02001300 fuse_change_attributes(inode, &o->attr,
1301 entry_attr_timeout(o),
1302 attr_version);
1303
Anand V. Avati0b05b182012-08-19 08:53:23 -04001304 /*
1305 * The other branch to 'found' comes via fuse_iget()
1306 * which bumps nlookup inside
1307 */
1308 goto found;
1309 }
Anand V. Avati0b05b182012-08-19 08:53:23 -04001310 dput(dentry);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001311 }
1312
1313 dentry = d_alloc(parent, &name);
1314 err = -ENOMEM;
1315 if (!dentry)
1316 goto out;
1317
1318 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1319 &o->attr, entry_attr_timeout(o), attr_version);
1320 if (!inode)
1321 goto out;
1322
Miklos Szeredib70a80e2013-10-01 16:44:54 +02001323 alias = d_materialise_unique(dentry, inode);
Miklos Szeredi5835f332013-09-05 11:44:42 +02001324 err = PTR_ERR(alias);
1325 if (IS_ERR(alias))
1326 goto out;
Miklos Szeredi29149412013-07-17 14:53:53 +02001327
Anand V. Avati0b05b182012-08-19 08:53:23 -04001328 if (alias) {
1329 dput(dentry);
1330 dentry = alias;
1331 }
1332
1333found:
Miklos Szeredi6314efe2013-10-01 16:41:22 +02001334 if (fc->readdirplus_auto)
1335 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001336 fuse_change_entry_timeout(dentry, o);
1337
1338 err = 0;
1339out:
Miklos Szeredic7263bc2013-07-17 14:53:54 +02001340 dput(dentry);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001341 return err;
1342}
1343
1344static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
Al Viro8d3af7f2013-05-18 03:03:58 -04001345 struct dir_context *ctx, u64 attr_version)
Anand V. Avati0b05b182012-08-19 08:53:23 -04001346{
1347 struct fuse_direntplus *direntplus;
1348 struct fuse_dirent *dirent;
1349 size_t reclen;
1350 int over = 0;
1351 int ret;
1352
1353 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1354 direntplus = (struct fuse_direntplus *) buf;
1355 dirent = &direntplus->dirent;
1356 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1357
1358 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1359 return -EIO;
1360 if (reclen > nbytes)
1361 break;
Miklos Szerediefeb9e62013-09-03 14:28:38 +02001362 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1363 return -EIO;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001364
1365 if (!over) {
1366 /* We fill entries into dstbuf only as much as
1367 it can hold. But we still continue iterating
1368 over remaining entries to link them. If not,
1369 we need to send a FORGET for each of those
1370 which we did not link.
1371 */
Al Viro8d3af7f2013-05-18 03:03:58 -04001372 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1373 dirent->ino, dirent->type);
1374 ctx->pos = dirent->off;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001375 }
1376
1377 buf += reclen;
1378 nbytes -= reclen;
1379
1380 ret = fuse_direntplus_link(file, direntplus, attr_version);
1381 if (ret)
1382 fuse_force_forget(file, direntplus->entry_out.nodeid);
1383 }
1384
1385 return 0;
1386}
1387
Al Viro8d3af7f2013-05-18 03:03:58 -04001388static int fuse_readdir(struct file *file, struct dir_context *ctx)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001389{
Feng Shuo4582a4a2013-01-15 11:23:28 +08001390 int plus, err;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001391 size_t nbytes;
1392 struct page *page;
Al Viro496ad9a2013-01-23 17:07:38 -05001393 struct inode *inode = file_inode(file);
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001394 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001395 struct fuse_req *req;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001396 u64 attr_version = 0;
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001397
1398 if (is_bad_inode(inode))
1399 return -EIO;
1400
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001401 req = fuse_get_req(fc, 1);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001402 if (IS_ERR(req))
1403 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001404
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001405 page = alloc_page(GFP_KERNEL);
1406 if (!page) {
1407 fuse_put_request(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001408 return -ENOMEM;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001409 }
Feng Shuo4582a4a2013-01-15 11:23:28 +08001410
Al Viro8d3af7f2013-05-18 03:03:58 -04001411 plus = fuse_use_readdirplus(inode, ctx);
Miklos Szeredif4975c62009-04-02 14:25:34 +02001412 req->out.argpages = 1;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001413 req->num_pages = 1;
1414 req->pages[0] = page;
Maxim Patlasov85f40ae2012-10-26 19:49:33 +04001415 req->page_descs[0].length = PAGE_SIZE;
Feng Shuo4582a4a2013-01-15 11:23:28 +08001416 if (plus) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001417 attr_version = fuse_get_attr_version(fc);
Al Viro8d3af7f2013-05-18 03:03:58 -04001418 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
Anand V. Avati0b05b182012-08-19 08:53:23 -04001419 FUSE_READDIRPLUS);
1420 } else {
Al Viro8d3af7f2013-05-18 03:03:58 -04001421 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
Anand V. Avati0b05b182012-08-19 08:53:23 -04001422 FUSE_READDIR);
1423 }
Tejun Heob93f8582008-11-26 12:03:55 +01001424 fuse_request_send(fc, req);
Miklos Szeredi361b1eb52006-01-16 22:14:45 -08001425 nbytes = req->out.args[0].size;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001426 err = req->out.h.error;
1427 fuse_put_request(fc, req);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001428 if (!err) {
Feng Shuo4582a4a2013-01-15 11:23:28 +08001429 if (plus) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001430 err = parse_dirplusfile(page_address(page), nbytes,
Al Viro8d3af7f2013-05-18 03:03:58 -04001431 file, ctx,
Anand V. Avati0b05b182012-08-19 08:53:23 -04001432 attr_version);
1433 } else {
1434 err = parse_dirfile(page_address(page), nbytes, file,
Al Viro8d3af7f2013-05-18 03:03:58 -04001435 ctx);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001436 }
1437 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001438
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001439 __free_page(page);
Andrew Gallagher451418f2013-11-05 03:55:43 -08001440 fuse_invalidate_atime(inode);
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001441 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001442}
1443
1444static char *read_link(struct dentry *dentry)
1445{
1446 struct inode *inode = dentry->d_inode;
1447 struct fuse_conn *fc = get_fuse_conn(inode);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001448 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001449 char *link;
1450
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001451 if (IS_ERR(req))
David Howellse231c2e2008-02-07 00:15:26 -08001452 return ERR_CAST(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001453
1454 link = (char *) __get_free_page(GFP_KERNEL);
1455 if (!link) {
1456 link = ERR_PTR(-ENOMEM);
1457 goto out;
1458 }
1459 req->in.h.opcode = FUSE_READLINK;
1460 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001461 req->out.argvar = 1;
1462 req->out.numargs = 1;
1463 req->out.args[0].size = PAGE_SIZE - 1;
1464 req->out.args[0].value = link;
Tejun Heob93f8582008-11-26 12:03:55 +01001465 fuse_request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001466 if (req->out.h.error) {
1467 free_page((unsigned long) link);
1468 link = ERR_PTR(req->out.h.error);
1469 } else
1470 link[req->out.args[0].size] = '\0';
1471 out:
1472 fuse_put_request(fc, req);
Andrew Gallagher451418f2013-11-05 03:55:43 -08001473 fuse_invalidate_atime(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001474 return link;
1475}
1476
1477static void free_link(char *link)
1478{
1479 if (!IS_ERR(link))
1480 free_page((unsigned long) link);
1481}
1482
1483static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1484{
1485 nd_set_link(nd, read_link(dentry));
1486 return NULL;
1487}
1488
1489static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1490{
1491 free_link(nd_get_link(nd));
1492}
1493
1494static int fuse_dir_open(struct inode *inode, struct file *file)
1495{
Miklos Szeredi91fe96b2009-04-28 16:56:37 +02001496 return fuse_open_common(inode, file, true);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001497}
1498
1499static int fuse_dir_release(struct inode *inode, struct file *file)
1500{
Miklos Szeredi8b0797a2009-04-28 16:56:39 +02001501 fuse_release_common(file, FUSE_RELEASEDIR);
1502
1503 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001504}
1505
Josef Bacik02c24a82011-07-16 20:44:56 -04001506static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1507 int datasync)
Miklos Szeredi82547982005-09-09 13:10:38 -07001508{
Josef Bacik02c24a82011-07-16 20:44:56 -04001509 return fuse_fsync_common(file, start, end, datasync, 1);
Miklos Szeredi82547982005-09-09 13:10:38 -07001510}
1511
Miklos Szeredib18da0c2011-12-13 11:58:49 +01001512static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1513 unsigned long arg)
1514{
1515 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1516
1517 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1518 if (fc->minor < 18)
1519 return -ENOTTY;
1520
1521 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1522}
1523
1524static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1525 unsigned long arg)
1526{
1527 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1528
1529 if (fc->minor < 18)
1530 return -ENOTTY;
1531
1532 return fuse_ioctl_common(file, cmd, arg,
1533 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1534}
1535
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001536static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001537{
1538 /* Always update if mtime is explicitly set */
1539 if (ivalid & ATTR_MTIME_SET)
1540 return true;
1541
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001542 /* Or if kernel i_mtime is the official one */
1543 if (trust_local_mtime)
1544 return true;
1545
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001546 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1547 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1548 return false;
1549
1550 /* In all other cases update */
1551 return true;
1552}
1553
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001554static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg,
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001555 bool trust_local_cmtime)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001556{
1557 unsigned ivalid = iattr->ia_valid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001558
1559 if (ivalid & ATTR_MODE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001560 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001561 if (ivalid & ATTR_UID)
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001562 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001563 if (ivalid & ATTR_GID)
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001564 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001565 if (ivalid & ATTR_SIZE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001566 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001567 if (ivalid & ATTR_ATIME) {
1568 arg->valid |= FATTR_ATIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001569 arg->atime = iattr->ia_atime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001570 arg->atimensec = iattr->ia_atime.tv_nsec;
1571 if (!(ivalid & ATTR_ATIME_SET))
1572 arg->valid |= FATTR_ATIME_NOW;
1573 }
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001574 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001575 arg->valid |= FATTR_MTIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001576 arg->mtime = iattr->ia_mtime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001577 arg->mtimensec = iattr->ia_mtime.tv_nsec;
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001578 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001579 arg->valid |= FATTR_MTIME_NOW;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001580 }
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001581 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1582 arg->valid |= FATTR_CTIME;
1583 arg->ctime = iattr->ia_ctime.tv_sec;
1584 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1585 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001586}
1587
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001588/*
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001589 * Prevent concurrent writepages on inode
1590 *
1591 * This is done by adding a negative bias to the inode write counter
1592 * and waiting for all pending writes to finish.
1593 */
1594void fuse_set_nowrite(struct inode *inode)
1595{
1596 struct fuse_conn *fc = get_fuse_conn(inode);
1597 struct fuse_inode *fi = get_fuse_inode(inode);
1598
1599 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1600
1601 spin_lock(&fc->lock);
1602 BUG_ON(fi->writectr < 0);
1603 fi->writectr += FUSE_NOWRITE;
1604 spin_unlock(&fc->lock);
1605 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1606}
1607
1608/*
1609 * Allow writepages on inode
1610 *
1611 * Remove the bias from the writecounter and send any queued
1612 * writepages.
1613 */
1614static void __fuse_release_nowrite(struct inode *inode)
1615{
1616 struct fuse_inode *fi = get_fuse_inode(inode);
1617
1618 BUG_ON(fi->writectr != FUSE_NOWRITE);
1619 fi->writectr = 0;
1620 fuse_flush_writepages(inode);
1621}
1622
1623void fuse_release_nowrite(struct inode *inode)
1624{
1625 struct fuse_conn *fc = get_fuse_conn(inode);
1626
1627 spin_lock(&fc->lock);
1628 __fuse_release_nowrite(inode);
1629 spin_unlock(&fc->lock);
1630}
1631
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001632static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_req *req,
1633 struct inode *inode,
1634 struct fuse_setattr_in *inarg_p,
1635 struct fuse_attr_out *outarg_p)
1636{
1637 req->in.h.opcode = FUSE_SETATTR;
1638 req->in.h.nodeid = get_node_id(inode);
1639 req->in.numargs = 1;
1640 req->in.args[0].size = sizeof(*inarg_p);
1641 req->in.args[0].value = inarg_p;
1642 req->out.numargs = 1;
1643 if (fc->minor < 9)
1644 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1645 else
1646 req->out.args[0].size = sizeof(*outarg_p);
1647 req->out.args[0].value = outarg_p;
1648}
1649
1650/*
1651 * Flush inode->i_mtime to the server
1652 */
Maxim Patlasovab9e13f2014-04-28 14:19:24 +02001653int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001654{
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001655 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi1e18bda2014-04-28 14:19:23 +02001656 struct fuse_req *req;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001657 struct fuse_setattr_in inarg;
1658 struct fuse_attr_out outarg;
1659 int err;
1660
Miklos Szeredi1e18bda2014-04-28 14:19:23 +02001661 req = fuse_get_req_nopages(fc);
1662 if (IS_ERR(req))
1663 return PTR_ERR(req);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001664
1665 memset(&inarg, 0, sizeof(inarg));
1666 memset(&outarg, 0, sizeof(outarg));
1667
Maxim Patlasovab9e13f2014-04-28 14:19:24 +02001668 inarg.valid = FATTR_MTIME;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001669 inarg.mtime = inode->i_mtime.tv_sec;
1670 inarg.mtimensec = inode->i_mtime.tv_nsec;
Maxim Patlasovab9e13f2014-04-28 14:19:24 +02001671 if (fc->minor >= 23) {
1672 inarg.valid |= FATTR_CTIME;
1673 inarg.ctime = inode->i_ctime.tv_sec;
1674 inarg.ctimensec = inode->i_ctime.tv_nsec;
1675 }
Miklos Szeredi1e18bda2014-04-28 14:19:23 +02001676 if (ff) {
1677 inarg.valid |= FATTR_FH;
1678 inarg.fh = ff->fh;
1679 }
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001680 fuse_setattr_fill(fc, req, inode, &inarg, &outarg);
1681 fuse_request_send(fc, req);
1682 err = req->out.h.error;
1683 fuse_put_request(fc, req);
1684
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001685 return err;
1686}
1687
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001688/*
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001689 * Set attributes, and at the same time refresh them.
1690 *
1691 * Truncation is slightly complicated, because the 'truncate' request
1692 * may fail, in which case we don't want to touch the mapping.
Miklos Szeredi9ffbb912006-10-17 00:10:06 -07001693 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1694 * and the actual truncation by hand.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001695 */
Maxim Patlasovefb9fa92012-12-18 14:05:08 +04001696int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1697 struct file *file)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001698{
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001699 struct fuse_conn *fc = get_fuse_conn(inode);
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001700 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001701 struct fuse_req *req;
1702 struct fuse_setattr_in inarg;
1703 struct fuse_attr_out outarg;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001704 bool is_truncate = false;
Pavel Emelyanov83732002013-10-10 17:10:46 +04001705 bool is_wb = fc->writeback_cache;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001706 loff_t oldsize;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001707 int err;
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001708 bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001709
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001710 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1711 attr->ia_valid |= ATTR_FORCE;
1712
1713 err = inode_change_ok(inode, attr);
1714 if (err)
1715 return err;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001716
Miklos Szeredi8d56add2011-02-25 14:44:58 +01001717 if (attr->ia_valid & ATTR_OPEN) {
1718 if (fc->atomic_o_trunc)
1719 return 0;
1720 file = NULL;
1721 }
Miklos Szeredi6ff958e2007-10-18 03:07:02 -07001722
Christoph Hellwig2c27c652010-06-04 11:30:04 +02001723 if (attr->ia_valid & ATTR_SIZE)
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001724 is_truncate = true;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001725
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001726 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001727 if (IS_ERR(req))
1728 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001729
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001730 if (is_truncate) {
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001731 fuse_set_nowrite(inode);
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001732 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001733 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1734 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001735 }
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001736
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001737 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001738 memset(&outarg, 0, sizeof(outarg));
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001739 iattr_to_fattr(attr, &inarg, trust_local_cmtime);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001740 if (file) {
1741 struct fuse_file *ff = file->private_data;
1742 inarg.valid |= FATTR_FH;
1743 inarg.fh = ff->fh;
1744 }
Miklos Szeredif3332112007-10-18 03:07:04 -07001745 if (attr->ia_valid & ATTR_SIZE) {
1746 /* For mandatory locking in truncate */
1747 inarg.valid |= FATTR_LOCKOWNER;
1748 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1749 }
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001750 fuse_setattr_fill(fc, req, inode, &inarg, &outarg);
Tejun Heob93f8582008-11-26 12:03:55 +01001751 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001752 err = req->out.h.error;
1753 fuse_put_request(fc, req);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001754 if (err) {
1755 if (err == -EINTR)
1756 fuse_invalidate_attr(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001757 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001758 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001759
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001760 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1761 make_bad_inode(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001762 err = -EIO;
1763 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001764 }
1765
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001766 spin_lock(&fc->lock);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001767 /* the kernel maintains i_mtime locally */
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001768 if (trust_local_cmtime) {
1769 if (attr->ia_valid & ATTR_MTIME)
1770 inode->i_mtime = attr->ia_mtime;
1771 if (attr->ia_valid & ATTR_CTIME)
1772 inode->i_ctime = attr->ia_ctime;
Miklos Szeredi1e18bda2014-04-28 14:19:23 +02001773 /* FIXME: clear I_DIRTY_SYNC? */
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001774 }
1775
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001776 fuse_change_attributes_common(inode, &outarg.attr,
1777 attr_timeout(&outarg));
1778 oldsize = inode->i_size;
Pavel Emelyanov83732002013-10-10 17:10:46 +04001779 /* see the comment in fuse_change_attributes() */
1780 if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1781 i_size_write(inode, outarg.attr.size);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001782
1783 if (is_truncate) {
1784 /* NOTE: this may release/reacquire fc->lock */
1785 __fuse_release_nowrite(inode);
1786 }
1787 spin_unlock(&fc->lock);
1788
1789 /*
1790 * Only call invalidate_inode_pages2() after removing
1791 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1792 */
Pavel Emelyanov83732002013-10-10 17:10:46 +04001793 if ((is_truncate || !is_wb) &&
1794 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001795 truncate_pagecache(inode, outarg.attr.size);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001796 invalidate_inode_pages2(inode->i_mapping);
1797 }
1798
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001799 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001800 return 0;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001801
1802error:
1803 if (is_truncate)
1804 fuse_release_nowrite(inode);
1805
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001806 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001807 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001808}
1809
Miklos Szeredi49d49142007-10-18 03:07:00 -07001810static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1811{
Maxim Patlasovefb9fa92012-12-18 14:05:08 +04001812 struct inode *inode = entry->d_inode;
1813
1814 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1815 return -EACCES;
1816
Miklos Szeredi49d49142007-10-18 03:07:00 -07001817 if (attr->ia_valid & ATTR_FILE)
Maxim Patlasovefb9fa92012-12-18 14:05:08 +04001818 return fuse_do_setattr(inode, attr, attr->ia_file);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001819 else
Maxim Patlasovefb9fa92012-12-18 14:05:08 +04001820 return fuse_do_setattr(inode, attr, NULL);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001821}
1822
Miklos Szeredie5e55582005-09-09 13:10:28 -07001823static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1824 struct kstat *stat)
1825{
1826 struct inode *inode = entry->d_inode;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001827 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001828
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001829 if (!fuse_allow_current_process(fc))
Miklos Szeredi244f6382007-10-16 23:31:02 -07001830 return -EACCES;
1831
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001832 return fuse_update_attributes(inode, stat, NULL, NULL);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001833}
1834
Miklos Szeredi92a87802005-09-09 13:10:31 -07001835static int fuse_setxattr(struct dentry *entry, const char *name,
1836 const void *value, size_t size, int flags)
1837{
1838 struct inode *inode = entry->d_inode;
1839 struct fuse_conn *fc = get_fuse_conn(inode);
1840 struct fuse_req *req;
1841 struct fuse_setxattr_in inarg;
1842 int err;
1843
Miklos Szeredi92a87802005-09-09 13:10:31 -07001844 if (fc->no_setxattr)
1845 return -EOPNOTSUPP;
1846
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001847 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001848 if (IS_ERR(req))
1849 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001850
1851 memset(&inarg, 0, sizeof(inarg));
1852 inarg.size = size;
1853 inarg.flags = flags;
1854 req->in.h.opcode = FUSE_SETXATTR;
1855 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001856 req->in.numargs = 3;
1857 req->in.args[0].size = sizeof(inarg);
1858 req->in.args[0].value = &inarg;
1859 req->in.args[1].size = strlen(name) + 1;
1860 req->in.args[1].value = name;
1861 req->in.args[2].size = size;
1862 req->in.args[2].value = value;
Tejun Heob93f8582008-11-26 12:03:55 +01001863 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001864 err = req->out.h.error;
1865 fuse_put_request(fc, req);
1866 if (err == -ENOSYS) {
1867 fc->no_setxattr = 1;
1868 err = -EOPNOTSUPP;
1869 }
Maxim Patlasov31f32672014-04-28 14:19:24 +02001870 if (!err) {
Anand Avatid331a412013-08-20 02:21:07 -04001871 fuse_invalidate_attr(inode);
Maxim Patlasov31f32672014-04-28 14:19:24 +02001872 fuse_update_ctime(inode);
1873 }
Miklos Szeredi92a87802005-09-09 13:10:31 -07001874 return err;
1875}
1876
1877static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1878 void *value, size_t size)
1879{
1880 struct inode *inode = entry->d_inode;
1881 struct fuse_conn *fc = get_fuse_conn(inode);
1882 struct fuse_req *req;
1883 struct fuse_getxattr_in inarg;
1884 struct fuse_getxattr_out outarg;
1885 ssize_t ret;
1886
1887 if (fc->no_getxattr)
1888 return -EOPNOTSUPP;
1889
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001890 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001891 if (IS_ERR(req))
1892 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001893
1894 memset(&inarg, 0, sizeof(inarg));
1895 inarg.size = size;
1896 req->in.h.opcode = FUSE_GETXATTR;
1897 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001898 req->in.numargs = 2;
1899 req->in.args[0].size = sizeof(inarg);
1900 req->in.args[0].value = &inarg;
1901 req->in.args[1].size = strlen(name) + 1;
1902 req->in.args[1].value = name;
1903 /* This is really two different operations rolled into one */
1904 req->out.numargs = 1;
1905 if (size) {
1906 req->out.argvar = 1;
1907 req->out.args[0].size = size;
1908 req->out.args[0].value = value;
1909 } else {
1910 req->out.args[0].size = sizeof(outarg);
1911 req->out.args[0].value = &outarg;
1912 }
Tejun Heob93f8582008-11-26 12:03:55 +01001913 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001914 ret = req->out.h.error;
1915 if (!ret)
1916 ret = size ? req->out.args[0].size : outarg.size;
1917 else {
1918 if (ret == -ENOSYS) {
1919 fc->no_getxattr = 1;
1920 ret = -EOPNOTSUPP;
1921 }
1922 }
1923 fuse_put_request(fc, req);
1924 return ret;
1925}
1926
1927static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1928{
1929 struct inode *inode = entry->d_inode;
1930 struct fuse_conn *fc = get_fuse_conn(inode);
1931 struct fuse_req *req;
1932 struct fuse_getxattr_in inarg;
1933 struct fuse_getxattr_out outarg;
1934 ssize_t ret;
1935
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001936 if (!fuse_allow_current_process(fc))
Miklos Szeredie57ac682007-10-18 03:06:58 -07001937 return -EACCES;
1938
Miklos Szeredi92a87802005-09-09 13:10:31 -07001939 if (fc->no_listxattr)
1940 return -EOPNOTSUPP;
1941
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001942 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001943 if (IS_ERR(req))
1944 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001945
1946 memset(&inarg, 0, sizeof(inarg));
1947 inarg.size = size;
1948 req->in.h.opcode = FUSE_LISTXATTR;
1949 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001950 req->in.numargs = 1;
1951 req->in.args[0].size = sizeof(inarg);
1952 req->in.args[0].value = &inarg;
1953 /* This is really two different operations rolled into one */
1954 req->out.numargs = 1;
1955 if (size) {
1956 req->out.argvar = 1;
1957 req->out.args[0].size = size;
1958 req->out.args[0].value = list;
1959 } else {
1960 req->out.args[0].size = sizeof(outarg);
1961 req->out.args[0].value = &outarg;
1962 }
Tejun Heob93f8582008-11-26 12:03:55 +01001963 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001964 ret = req->out.h.error;
1965 if (!ret)
1966 ret = size ? req->out.args[0].size : outarg.size;
1967 else {
1968 if (ret == -ENOSYS) {
1969 fc->no_listxattr = 1;
1970 ret = -EOPNOTSUPP;
1971 }
1972 }
1973 fuse_put_request(fc, req);
1974 return ret;
1975}
1976
1977static int fuse_removexattr(struct dentry *entry, const char *name)
1978{
1979 struct inode *inode = entry->d_inode;
1980 struct fuse_conn *fc = get_fuse_conn(inode);
1981 struct fuse_req *req;
1982 int err;
1983
1984 if (fc->no_removexattr)
1985 return -EOPNOTSUPP;
1986
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001987 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001988 if (IS_ERR(req))
1989 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001990
1991 req->in.h.opcode = FUSE_REMOVEXATTR;
1992 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001993 req->in.numargs = 1;
1994 req->in.args[0].size = strlen(name) + 1;
1995 req->in.args[0].value = name;
Tejun Heob93f8582008-11-26 12:03:55 +01001996 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001997 err = req->out.h.error;
1998 fuse_put_request(fc, req);
1999 if (err == -ENOSYS) {
2000 fc->no_removexattr = 1;
2001 err = -EOPNOTSUPP;
2002 }
Maxim Patlasov31f32672014-04-28 14:19:24 +02002003 if (!err) {
Anand Avatid331a412013-08-20 02:21:07 -04002004 fuse_invalidate_attr(inode);
Maxim Patlasov31f32672014-04-28 14:19:24 +02002005 fuse_update_ctime(inode);
2006 }
Miklos Szeredi92a87802005-09-09 13:10:31 -07002007 return err;
2008}
2009
Arjan van de Ven754661f2007-02-12 00:55:38 -08002010static const struct inode_operations fuse_dir_inode_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -07002011 .lookup = fuse_lookup,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07002012 .mkdir = fuse_mkdir,
2013 .symlink = fuse_symlink,
2014 .unlink = fuse_unlink,
2015 .rmdir = fuse_rmdir,
Miklos Szeredi1560c972014-04-28 16:43:44 +02002016 .rename2 = fuse_rename2,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07002017 .link = fuse_link,
2018 .setattr = fuse_setattr,
2019 .create = fuse_create,
Miklos Szeredic8ccbe02012-06-05 15:10:22 +02002020 .atomic_open = fuse_atomic_open,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07002021 .mknod = fuse_mknod,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002022 .permission = fuse_permission,
2023 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07002024 .setxattr = fuse_setxattr,
2025 .getxattr = fuse_getxattr,
2026 .listxattr = fuse_listxattr,
2027 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002028};
2029
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08002030static const struct file_operations fuse_dir_operations = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07002031 .llseek = generic_file_llseek,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002032 .read = generic_read_dir,
Al Viro8d3af7f2013-05-18 03:03:58 -04002033 .iterate = fuse_readdir,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002034 .open = fuse_dir_open,
2035 .release = fuse_dir_release,
Miklos Szeredi82547982005-09-09 13:10:38 -07002036 .fsync = fuse_dir_fsync,
Miklos Szeredib18da0c2011-12-13 11:58:49 +01002037 .unlocked_ioctl = fuse_dir_ioctl,
2038 .compat_ioctl = fuse_dir_compat_ioctl,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002039};
2040
Arjan van de Ven754661f2007-02-12 00:55:38 -08002041static const struct inode_operations fuse_common_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07002042 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002043 .permission = fuse_permission,
2044 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07002045 .setxattr = fuse_setxattr,
2046 .getxattr = fuse_getxattr,
2047 .listxattr = fuse_listxattr,
2048 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002049};
2050
Arjan van de Ven754661f2007-02-12 00:55:38 -08002051static const struct inode_operations fuse_symlink_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07002052 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002053 .follow_link = fuse_follow_link,
2054 .put_link = fuse_put_link,
2055 .readlink = generic_readlink,
2056 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07002057 .setxattr = fuse_setxattr,
2058 .getxattr = fuse_getxattr,
2059 .listxattr = fuse_listxattr,
2060 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07002061};
2062
2063void fuse_init_common(struct inode *inode)
2064{
2065 inode->i_op = &fuse_common_inode_operations;
2066}
2067
2068void fuse_init_dir(struct inode *inode)
2069{
2070 inode->i_op = &fuse_dir_inode_operations;
2071 inode->i_fop = &fuse_dir_operations;
2072}
2073
2074void fuse_init_symlink(struct inode *inode)
2075{
2076 inode->i_op = &fuse_symlink_inode_operations;
2077}