blob: 6a4d0e5418a179def0e5d4da4d3adbbcf3a82cd0 [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>
Seth Forshee703c7362016-08-29 08:46:36 -050016#include <linux/xattr.h>
Seth Forshee60bcc882016-08-29 08:46:37 -050017#include <linux/posix_acl.h>
Miklos Szeredie5e55582005-09-09 13:10:28 -070018
Al Viro8d3af7f2013-05-18 03:03:58 -040019static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
Feng Shuo4582a4a2013-01-15 11:23:28 +080020{
21 struct fuse_conn *fc = get_fuse_conn(dir);
22 struct fuse_inode *fi = get_fuse_inode(dir);
23
24 if (!fc->do_readdirplus)
25 return false;
Eric Wong634734b2013-02-06 22:29:01 +000026 if (!fc->readdirplus_auto)
27 return true;
Feng Shuo4582a4a2013-01-15 11:23:28 +080028 if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
29 return true;
Al Viro8d3af7f2013-05-18 03:03:58 -040030 if (ctx->pos == 0)
Feng Shuo4582a4a2013-01-15 11:23:28 +080031 return true;
32 return false;
33}
34
35static void fuse_advise_use_readdirplus(struct inode *dir)
36{
37 struct fuse_inode *fi = get_fuse_inode(dir);
38
39 set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
40}
41
Miklos Szeredif75fdf22016-10-01 07:32:32 +020042union fuse_dentry {
43 u64 time;
44 struct rcu_head rcu;
45};
46
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070047static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
48{
Miklos Szeredif75fdf22016-10-01 07:32:32 +020049 ((union fuse_dentry *) entry->d_fsdata)->time = time;
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070050}
51
52static inline u64 fuse_dentry_time(struct dentry *entry)
53{
Miklos Szeredif75fdf22016-10-01 07:32:32 +020054 return ((union fuse_dentry *) entry->d_fsdata)->time;
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070055}
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070056
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080057/*
58 * FUSE caches dentries and attributes with separate timeout. The
59 * time in jiffies until the dentry/attributes are valid is stored in
Miklos Szeredif75fdf22016-10-01 07:32:32 +020060 * dentry->d_fsdata and fuse_inode->i_time respectively.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080061 */
62
63/*
64 * Calculate the time in jiffies until a dentry/attributes are valid
65 */
Miklos Szeredibcb6f6d2016-10-01 07:32:32 +020066static u64 time_to_jiffies(u64 sec, u32 nsec)
Miklos Szeredie5e55582005-09-09 13:10:28 -070067{
Miklos Szeredi685d16d2006-07-30 03:04:08 -070068 if (sec || nsec) {
Miklos Szeredibcb6f6d2016-10-01 07:32:32 +020069 struct timespec64 ts = {
70 sec,
71 max_t(u32, nsec, NSEC_PER_SEC - 1)
72 };
73
74 return get_jiffies_64() + timespec64_to_jiffies(&ts);
Miklos Szeredi685d16d2006-07-30 03:04:08 -070075 } else
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070076 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -070077}
78
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080079/*
80 * Set dentry and possibly attribute timeouts from the lookup/mk*
81 * replies
82 */
Miklos Szeredi1fb69e72007-10-18 03:06:58 -070083static void fuse_change_entry_timeout(struct dentry *entry,
84 struct fuse_entry_out *o)
Miklos Szeredi0aa7c692006-01-06 00:19:34 -080085{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070086 fuse_dentry_settime(entry,
87 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
Miklos Szeredi1fb69e72007-10-18 03:06:58 -070088}
89
90static u64 attr_timeout(struct fuse_attr_out *o)
91{
92 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
93}
94
95static u64 entry_attr_timeout(struct fuse_entry_out *o)
96{
97 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -080098}
99
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800100/*
101 * Mark the attributes as stale, so that at the next call to
102 * ->getattr() they will be fetched from userspace
103 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800104void fuse_invalidate_attr(struct inode *inode)
105{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700106 get_fuse_inode(inode)->i_time = 0;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800107}
108
Andrew Gallagher451418f2013-11-05 03:55:43 -0800109/**
110 * Mark the attributes as stale due to an atime change. Avoid the invalidate if
111 * atime is not used.
112 */
113void fuse_invalidate_atime(struct inode *inode)
114{
115 if (!IS_RDONLY(inode))
116 fuse_invalidate_attr(inode);
117}
118
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800119/*
120 * Just mark the entry as stale, so that a next attempt to look it up
121 * will result in a new lookup call to userspace
122 *
123 * This is called when a dentry is about to become negative and the
124 * timeout is unknown (unlink, rmdir, rename and in some cases
125 * lookup)
126 */
Miklos Szeredidbd561d2008-07-25 01:49:00 -0700127void fuse_invalidate_entry_cache(struct dentry *entry)
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800128{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700129 fuse_dentry_settime(entry, 0);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800130}
131
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800132/*
133 * Same as fuse_invalidate_entry_cache(), but also try to remove the
134 * dentry from the hash
135 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800136static void fuse_invalidate_entry(struct dentry *entry)
137{
138 d_invalidate(entry);
139 fuse_invalidate_entry_cache(entry);
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800140}
141
Miklos Szeredi70781872014-12-12 09:49:05 +0100142static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args,
Al Viro13983d02016-07-20 22:34:44 -0400143 u64 nodeid, const struct qstr *name,
Miklos Szeredie5e55582005-09-09 13:10:28 -0700144 struct fuse_entry_out *outarg)
145{
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700146 memset(outarg, 0, sizeof(struct fuse_entry_out));
Miklos Szeredi70781872014-12-12 09:49:05 +0100147 args->in.h.opcode = FUSE_LOOKUP;
148 args->in.h.nodeid = nodeid;
149 args->in.numargs = 1;
150 args->in.args[0].size = name->len + 1;
151 args->in.args[0].value = name->name;
152 args->out.numargs = 1;
Miklos Szeredi21f62172015-01-06 10:45:35 +0100153 args->out.args[0].size = sizeof(struct fuse_entry_out);
Miklos Szeredi70781872014-12-12 09:49:05 +0100154 args->out.args[0].value = outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700155}
156
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700157u64 fuse_get_attr_version(struct fuse_conn *fc)
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800158{
159 u64 curr_version;
160
161 /*
162 * The spin lock isn't actually needed on 64bit archs, but we
163 * don't yet care too much about such optimizations.
164 */
165 spin_lock(&fc->lock);
166 curr_version = fc->attr_version;
167 spin_unlock(&fc->lock);
168
169 return curr_version;
170}
171
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800172/*
173 * Check whether the dentry is still valid
174 *
175 * If the entry validity timeout has expired and the dentry is
176 * positive, try to redo the lookup. If the lookup results in a
177 * different inode, then let the VFS invalidate the dentry and redo
178 * the lookup once more. If the lookup results in the same inode,
179 * then refresh the attributes, timeouts and mark the dentry valid.
180 */
Al Viro0b728e12012-06-10 16:03:43 -0400181static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700182{
Nick Piggin34286d62011-01-07 17:49:57 +1100183 struct inode *inode;
Miklos Szeredi28420da2013-06-03 14:40:22 +0200184 struct dentry *parent;
185 struct fuse_conn *fc;
Miklos Szeredi6314efe2013-10-01 16:41:22 +0200186 struct fuse_inode *fi;
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200187 int ret;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800188
David Howells2b0143b2015-03-17 22:25:59 +0000189 inode = d_inode_rcu(entry);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800190 if (inode && is_bad_inode(inode))
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200191 goto invalid;
Anand Avati154210c2014-06-26 20:21:57 -0400192 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
193 (flags & LOOKUP_REVAL)) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700194 struct fuse_entry_out outarg;
Miklos Szeredi70781872014-12-12 09:49:05 +0100195 FUSE_ARGS(args);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100196 struct fuse_forget_link *forget;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700197 u64 attr_version;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800198
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800199 /* For negative dentries, always do a fresh lookup */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800200 if (!inode)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200201 goto invalid;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800202
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200203 ret = -ECHILD;
Al Viro0b728e12012-06-10 16:03:43 -0400204 if (flags & LOOKUP_RCU)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200205 goto out;
Miklos Szeredie7c0a162011-03-21 13:58:06 +0100206
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800207 fc = get_fuse_conn(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700208
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100209 forget = fuse_alloc_forget();
Miklos Szeredi70781872014-12-12 09:49:05 +0100210 ret = -ENOMEM;
211 if (!forget)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200212 goto out;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800213
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800214 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700215
Miklos Szeredie956edd2006-10-17 00:10:12 -0700216 parent = dget_parent(entry);
David Howells2b0143b2015-03-17 22:25:59 +0000217 fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700218 &entry->d_name, &outarg);
Miklos Szeredi70781872014-12-12 09:49:05 +0100219 ret = fuse_simple_request(fc, &args);
Miklos Szeredie956edd2006-10-17 00:10:12 -0700220 dput(parent);
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800221 /* Zero nodeid is same as -ENOENT */
Miklos Szeredi70781872014-12-12 09:49:05 +0100222 if (!ret && !outarg.nodeid)
223 ret = -ENOENT;
224 if (!ret) {
Miklos Szeredi6314efe2013-10-01 16:41:22 +0200225 fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700226 if (outarg.nodeid != get_node_id(inode)) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100227 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200228 goto invalid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700229 }
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700230 spin_lock(&fc->lock);
Miklos Szeredi1729a162008-11-26 12:03:54 +0100231 fi->nlookup++;
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700232 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700233 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100234 kfree(forget);
Miklos Szeredi70781872014-12-12 09:49:05 +0100235 if (ret == -ENOMEM)
236 goto out;
237 if (ret || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200238 goto invalid;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700239
Seth Forshee60bcc882016-08-29 08:46:37 -0500240 forget_all_cached_acls(inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700241 fuse_change_attributes(inode, &outarg.attr,
242 entry_attr_timeout(&outarg),
243 attr_version);
244 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi28420da2013-06-03 14:40:22 +0200245 } else if (inode) {
Miklos Szeredi6314efe2013-10-01 16:41:22 +0200246 fi = get_fuse_inode(inode);
247 if (flags & LOOKUP_RCU) {
248 if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
249 return -ECHILD;
250 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
Miklos Szeredi28420da2013-06-03 14:40:22 +0200251 parent = dget_parent(entry);
David Howells2b0143b2015-03-17 22:25:59 +0000252 fuse_advise_use_readdirplus(d_inode(parent));
Miklos Szeredi28420da2013-06-03 14:40:22 +0200253 dput(parent);
254 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700255 }
Miklos Szeredie2a6b952013-09-05 11:44:43 +0200256 ret = 1;
257out:
258 return ret;
259
260invalid:
261 ret = 0;
262 goto out;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700263}
264
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800265static int invalid_nodeid(u64 nodeid)
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800266{
267 return !nodeid || nodeid == FUSE_ROOT_ID;
268}
269
Miklos Szeredif75fdf22016-10-01 07:32:32 +0200270static int fuse_dentry_init(struct dentry *dentry)
271{
272 dentry->d_fsdata = kzalloc(sizeof(union fuse_dentry), GFP_KERNEL);
273
274 return dentry->d_fsdata ? 0 : -ENOMEM;
275}
276static void fuse_dentry_release(struct dentry *dentry)
277{
278 union fuse_dentry *fd = dentry->d_fsdata;
279
280 kfree_rcu(fd, rcu);
281}
282
Al Viro42695902009-02-20 05:59:13 +0000283const struct dentry_operations fuse_dentry_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700284 .d_revalidate = fuse_dentry_revalidate,
Miklos Szeredif75fdf22016-10-01 07:32:32 +0200285 .d_init = fuse_dentry_init,
286 .d_release = fuse_dentry_release,
Miklos Szeredie5e55582005-09-09 13:10:28 -0700287};
288
Timo Savolaa5bfffac2007-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
Al Viro13983d02016-07-20 22:34:44 -0400295int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700296 struct fuse_entry_out *outarg, struct inode **inode)
297{
298 struct fuse_conn *fc = get_fuse_conn_super(sb);
Miklos Szeredi70781872014-12-12 09:49:05 +0100299 FUSE_ARGS(args);
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
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700309
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100310 forget = fuse_alloc_forget();
311 err = -ENOMEM;
Miklos Szeredi70781872014-12-12 09:49:05 +0100312 if (!forget)
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700313 goto out;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700314
315 attr_version = fuse_get_attr_version(fc);
316
Miklos Szeredi70781872014-12-12 09:49:05 +0100317 fuse_lookup_init(fc, &args, nodeid, name, outarg);
318 err = fuse_simple_request(fc, &args);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700319 /* Zero nodeid is same as -ENOENT, but with valid timeout */
320 if (err || !outarg->nodeid)
321 goto out_put_forget;
322
323 err = -EIO;
324 if (!outarg->nodeid)
325 goto out_put_forget;
326 if (!fuse_valid_type(outarg->attr.mode))
327 goto out_put_forget;
328
329 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
330 &outarg->attr, entry_attr_timeout(outarg),
331 attr_version);
332 err = -ENOMEM;
333 if (!*inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100334 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700335 goto out;
336 }
337 err = 0;
338
339 out_put_forget:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100340 kfree(forget);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700341 out:
342 return err;
343}
344
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800345static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400346 unsigned int flags)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700347{
348 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700349 struct fuse_entry_out outarg;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700350 struct inode *inode;
Miklos Szeredi0de62562008-07-25 01:48:59 -0700351 struct dentry *newent;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700352 bool outarg_valid = true;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700353
Miklos Szeredi5c672ab2016-06-30 13:10:49 +0200354 fuse_lock_inode(dir);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700355 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
356 &outarg, &inode);
Miklos Szeredi5c672ab2016-06-30 13:10:49 +0200357 fuse_unlock_inode(dir);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700358 if (err == -ENOENT) {
359 outarg_valid = false;
360 err = 0;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800361 }
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700362 if (err)
363 goto out_err;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800364
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700365 err = -EIO;
366 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
367 goto out_iput;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700368
Al Viro41d28bc2014-10-12 22:24:21 -0400369 newent = d_splice_alias(inode, entry);
Miklos Szeredi5835f332013-09-05 11:44:42 +0200370 err = PTR_ERR(newent);
371 if (IS_ERR(newent))
372 goto out_err;
Miklos Szeredid2a85162006-10-17 00:10:11 -0700373
Miklos Szeredi0de62562008-07-25 01:48:59 -0700374 entry = newent ? newent : entry;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700375 if (outarg_valid)
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700376 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800377 else
378 fuse_invalidate_entry_cache(entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700379
Feng Shuo4582a4a2013-01-15 11:23:28 +0800380 fuse_advise_use_readdirplus(dir);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700381 return newent;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700382
383 out_iput:
384 iput(inode);
385 out_err:
386 return ERR_PTR(err);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700387}
388
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800389/*
390 * Atomic create+open operation
391 *
392 * If the filesystem doesn't support this, then fall back to separate
393 * 'mknod' + 'open' requests.
394 */
Al Virod9585272012-06-22 12:39:14 +0400395static int fuse_create_open(struct inode *dir, struct dentry *entry,
Al Viro30d90492012-06-22 12:40:19 +0400396 struct file *file, unsigned flags,
Al Virod9585272012-06-22 12:39:14 +0400397 umode_t mode, int *opened)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800398{
399 int err;
400 struct inode *inode;
401 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredi70781872014-12-12 09:49:05 +0100402 FUSE_ARGS(args);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100403 struct fuse_forget_link *forget;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200404 struct fuse_create_in inarg;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800405 struct fuse_open_out outopen;
406 struct fuse_entry_out outentry;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800407 struct fuse_file *ff;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800408
Miklos Szerediaf109bc2012-08-15 13:01:24 +0200409 /* Userspace expects S_IFREG in create mode */
410 BUG_ON((mode & S_IFMT) != S_IFREG);
411
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100412 forget = fuse_alloc_forget();
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200413 err = -ENOMEM;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100414 if (!forget)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200415 goto out_err;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700416
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700417 err = -ENOMEM;
Tejun Heoacf99432008-11-26 12:03:55 +0100418 ff = fuse_file_alloc(fc);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800419 if (!ff)
Miklos Szeredi70781872014-12-12 09:49:05 +0100420 goto out_put_forget_req;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800421
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200422 if (!fc->dont_mask)
423 mode &= ~current_umask();
424
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800425 flags &= ~O_NOCTTY;
426 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700427 memset(&outentry, 0, sizeof(outentry));
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800428 inarg.flags = flags;
429 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200430 inarg.umask = current_umask();
Miklos Szeredi70781872014-12-12 09:49:05 +0100431 args.in.h.opcode = FUSE_CREATE;
432 args.in.h.nodeid = get_node_id(dir);
433 args.in.numargs = 2;
Miklos Szeredi21f62172015-01-06 10:45:35 +0100434 args.in.args[0].size = sizeof(inarg);
Miklos Szeredi70781872014-12-12 09:49:05 +0100435 args.in.args[0].value = &inarg;
436 args.in.args[1].size = entry->d_name.len + 1;
437 args.in.args[1].value = entry->d_name.name;
438 args.out.numargs = 2;
Miklos Szeredi21f62172015-01-06 10:45:35 +0100439 args.out.args[0].size = sizeof(outentry);
Miklos Szeredi70781872014-12-12 09:49:05 +0100440 args.out.args[0].value = &outentry;
441 args.out.args[1].size = sizeof(outopen);
442 args.out.args[1].value = &outopen;
443 err = fuse_simple_request(fc, &args);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200444 if (err)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800445 goto out_free_ff;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800446
447 err = -EIO;
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800448 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800449 goto out_free_ff;
450
Miklos Szeredic7b71432009-04-28 16:56:37 +0200451 ff->fh = outopen.fh;
452 ff->nodeid = outentry.nodeid;
453 ff->open_flags = outopen.open_flags;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800454 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700455 &outentry.attr, entry_attr_timeout(&outentry), 0);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800456 if (!inode) {
457 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200458 fuse_sync_release(ff, flags);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100459 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200460 err = -ENOMEM;
461 goto out_err;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800462 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100463 kfree(forget);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800464 d_instantiate(entry, inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700465 fuse_change_entry_timeout(entry, &outentry);
Miklos Szeredi0952b2a2008-02-06 01:38:38 -0800466 fuse_invalidate_attr(dir);
Al Viro30d90492012-06-22 12:40:19 +0400467 err = finish_open(file, entry, generic_file_open, opened);
468 if (err) {
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200469 fuse_sync_release(ff, flags);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200470 } else {
471 file->private_data = fuse_file_get(ff);
472 fuse_finish_open(inode, file);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800473 }
Al Virod9585272012-06-22 12:39:14 +0400474 return err;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800475
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200476out_free_ff:
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800477 fuse_file_free(ff);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200478out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100479 kfree(forget);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200480out_err:
Al Virod9585272012-06-22 12:39:14 +0400481 return err;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200482}
483
484static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
Al Virod9585272012-06-22 12:39:14 +0400485static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
Al Viro30d90492012-06-22 12:40:19 +0400486 struct file *file, unsigned flags,
Al Virod9585272012-06-22 12:39:14 +0400487 umode_t mode, int *opened)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200488{
489 int err;
490 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200491 struct dentry *res = NULL;
492
Al Viro00699ad2016-07-05 09:44:53 -0400493 if (d_in_lookup(entry)) {
Al Viro00cd8dd2012-06-10 17:13:09 -0400494 res = fuse_lookup(dir, entry, 0);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200495 if (IS_ERR(res))
Al Virod9585272012-06-22 12:39:14 +0400496 return PTR_ERR(res);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200497
498 if (res)
499 entry = res;
500 }
501
David Howells2b0143b2015-03-17 22:25:59 +0000502 if (!(flags & O_CREAT) || d_really_is_positive(entry))
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200503 goto no_open;
504
505 /* Only creates */
Al Viro47237682012-06-10 05:01:45 -0400506 *opened |= FILE_CREATED;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200507
508 if (fc->no_create)
509 goto mknod;
510
Al Viro30d90492012-06-22 12:40:19 +0400511 err = fuse_create_open(dir, entry, file, flags, mode, opened);
Al Virod9585272012-06-22 12:39:14 +0400512 if (err == -ENOSYS) {
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200513 fc->no_create = 1;
514 goto mknod;
515 }
516out_dput:
517 dput(res);
Al Virod9585272012-06-22 12:39:14 +0400518 return err;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200519
520mknod:
521 err = fuse_mknod(dir, entry, mode, 0);
Al Virod9585272012-06-22 12:39:14 +0400522 if (err)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200523 goto out_dput;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200524no_open:
Al Viroe45198a2012-06-10 06:48:09 -0400525 return finish_no_open(file, res);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800526}
527
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800528/*
529 * Code shared between mknod, mkdir, symlink and link
530 */
Miklos Szeredi70781872014-12-12 09:49:05 +0100531static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700532 struct inode *dir, struct dentry *entry,
Al Viro541af6a2011-07-26 03:17:33 -0400533 umode_t mode)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700534{
535 struct fuse_entry_out outarg;
536 struct inode *inode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700537 int err;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100538 struct fuse_forget_link *forget;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800539
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100540 forget = fuse_alloc_forget();
Miklos Szeredi70781872014-12-12 09:49:05 +0100541 if (!forget)
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100542 return -ENOMEM;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700543
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700544 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredi70781872014-12-12 09:49:05 +0100545 args->in.h.nodeid = get_node_id(dir);
546 args->out.numargs = 1;
Miklos Szeredi21f62172015-01-06 10:45:35 +0100547 args->out.args[0].size = sizeof(outarg);
Miklos Szeredi70781872014-12-12 09:49:05 +0100548 args->out.args[0].value = &outarg;
549 err = fuse_simple_request(fc, args);
Miklos Szeredi2d510132006-11-25 11:09:20 -0800550 if (err)
551 goto out_put_forget_req;
552
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800553 err = -EIO;
554 if (invalid_nodeid(outarg.nodeid))
Miklos Szeredi2d510132006-11-25 11:09:20 -0800555 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800556
557 if ((outarg.attr.mode ^ mode) & S_IFMT)
Miklos Szeredi2d510132006-11-25 11:09:20 -0800558 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800559
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700560 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700561 &outarg.attr, entry_attr_timeout(&outarg), 0);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700562 if (!inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100563 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700564 return -ENOMEM;
565 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100566 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700567
Miklos Szeredib70a80e2013-10-01 16:44:54 +0200568 err = d_instantiate_no_diralias(entry, inode);
569 if (err)
570 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700571
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700572 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700573 fuse_invalidate_attr(dir);
574 return 0;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800575
Miklos Szeredi2d510132006-11-25 11:09:20 -0800576 out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100577 kfree(forget);
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800578 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700579}
580
Al Viro1a67aaf2011-07-26 01:52:52 -0400581static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700582 dev_t rdev)
583{
584 struct fuse_mknod_in inarg;
585 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredi70781872014-12-12 09:49:05 +0100586 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700587
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200588 if (!fc->dont_mask)
589 mode &= ~current_umask();
590
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700591 memset(&inarg, 0, sizeof(inarg));
592 inarg.mode = mode;
593 inarg.rdev = new_encode_dev(rdev);
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200594 inarg.umask = current_umask();
Miklos Szeredi70781872014-12-12 09:49:05 +0100595 args.in.h.opcode = FUSE_MKNOD;
596 args.in.numargs = 2;
Miklos Szeredi21f62172015-01-06 10:45:35 +0100597 args.in.args[0].size = sizeof(inarg);
Miklos Szeredi70781872014-12-12 09:49:05 +0100598 args.in.args[0].value = &inarg;
599 args.in.args[1].size = entry->d_name.len + 1;
600 args.in.args[1].value = entry->d_name.name;
601 return create_new_entry(fc, &args, dir, entry, mode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700602}
603
Al Viro4acdaf22011-07-26 01:42:34 -0400604static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400605 bool excl)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700606{
607 return fuse_mknod(dir, entry, mode, 0);
608}
609
Al Viro18bb1db2011-07-26 01:41:39 -0400610static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700611{
612 struct fuse_mkdir_in inarg;
613 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredi70781872014-12-12 09:49:05 +0100614 FUSE_ARGS(args);
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;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200621 inarg.umask = current_umask();
Miklos Szeredi70781872014-12-12 09:49:05 +0100622 args.in.h.opcode = FUSE_MKDIR;
623 args.in.numargs = 2;
624 args.in.args[0].size = sizeof(inarg);
625 args.in.args[0].value = &inarg;
626 args.in.args[1].size = entry->d_name.len + 1;
627 args.in.args[1].value = entry->d_name.name;
628 return create_new_entry(fc, &args, dir, entry, S_IFDIR);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700629}
630
631static int fuse_symlink(struct inode *dir, struct dentry *entry,
632 const char *link)
633{
634 struct fuse_conn *fc = get_fuse_conn(dir);
635 unsigned len = strlen(link) + 1;
Miklos Szeredi70781872014-12-12 09:49:05 +0100636 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700637
Miklos Szeredi70781872014-12-12 09:49:05 +0100638 args.in.h.opcode = FUSE_SYMLINK;
639 args.in.numargs = 2;
640 args.in.args[0].size = entry->d_name.len + 1;
641 args.in.args[0].value = entry->d_name.name;
642 args.in.args[1].size = len;
643 args.in.args[1].value = link;
644 return create_new_entry(fc, &args, dir, entry, S_IFLNK);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700645}
646
Seth Forshee703c7362016-08-29 08:46:36 -0500647void fuse_update_ctime(struct inode *inode)
Maxim Patlasov31f32672014-04-28 14:19:24 +0200648{
649 if (!IS_NOCMTIME(inode)) {
Deepa Dinamanic2050a42016-09-14 07:48:06 -0700650 inode->i_ctime = current_time(inode);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200651 mark_inode_dirty_sync(inode);
652 }
653}
654
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700655static int fuse_unlink(struct inode *dir, struct dentry *entry)
656{
657 int err;
658 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredi70781872014-12-12 09:49:05 +0100659 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700660
Miklos Szeredi70781872014-12-12 09:49:05 +0100661 args.in.h.opcode = FUSE_UNLINK;
662 args.in.h.nodeid = get_node_id(dir);
663 args.in.numargs = 1;
664 args.in.args[0].size = entry->d_name.len + 1;
665 args.in.args[0].value = entry->d_name.name;
666 err = fuse_simple_request(fc, &args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700667 if (!err) {
David Howells2b0143b2015-03-17 22:25:59 +0000668 struct inode *inode = d_inode(entry);
Miklos Szerediac45d612012-03-05 15:48:11 +0100669 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700670
Miklos Szerediac45d612012-03-05 15:48:11 +0100671 spin_lock(&fc->lock);
672 fi->attr_version = ++fc->attr_version;
Miklos Szeredidfca7ce2013-02-04 15:57:42 +0100673 /*
674 * If i_nlink == 0 then unlink doesn't make sense, yet this can
675 * happen if userspace filesystem is careless. It would be
676 * difficult to enforce correct nlink usage so just ignore this
677 * condition here
678 */
679 if (inode->i_nlink > 0)
680 drop_nlink(inode);
Miklos Szerediac45d612012-03-05 15:48:11 +0100681 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700682 fuse_invalidate_attr(inode);
683 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800684 fuse_invalidate_entry_cache(entry);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200685 fuse_update_ctime(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700686 } else if (err == -EINTR)
687 fuse_invalidate_entry(entry);
688 return err;
689}
690
691static int fuse_rmdir(struct inode *dir, struct dentry *entry)
692{
693 int err;
694 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredi70781872014-12-12 09:49:05 +0100695 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700696
Miklos Szeredi70781872014-12-12 09:49:05 +0100697 args.in.h.opcode = FUSE_RMDIR;
698 args.in.h.nodeid = get_node_id(dir);
699 args.in.numargs = 1;
700 args.in.args[0].size = entry->d_name.len + 1;
701 args.in.args[0].value = entry->d_name.name;
702 err = fuse_simple_request(fc, &args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700703 if (!err) {
David Howells2b0143b2015-03-17 22:25:59 +0000704 clear_nlink(d_inode(entry));
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700705 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800706 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700707 } else if (err == -EINTR)
708 fuse_invalidate_entry(entry);
709 return err;
710}
711
Miklos Szeredi1560c972014-04-28 16:43:44 +0200712static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
713 struct inode *newdir, struct dentry *newent,
714 unsigned int flags, int opcode, size_t argsize)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700715{
716 int err;
Miklos Szeredi1560c972014-04-28 16:43:44 +0200717 struct fuse_rename2_in inarg;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700718 struct fuse_conn *fc = get_fuse_conn(olddir);
Miklos Szeredi70781872014-12-12 09:49:05 +0100719 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700720
Miklos Szeredi1560c972014-04-28 16:43:44 +0200721 memset(&inarg, 0, argsize);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700722 inarg.newdir = get_node_id(newdir);
Miklos Szeredi1560c972014-04-28 16:43:44 +0200723 inarg.flags = flags;
Miklos Szeredi70781872014-12-12 09:49:05 +0100724 args.in.h.opcode = opcode;
725 args.in.h.nodeid = get_node_id(olddir);
726 args.in.numargs = 3;
727 args.in.args[0].size = argsize;
728 args.in.args[0].value = &inarg;
729 args.in.args[1].size = oldent->d_name.len + 1;
730 args.in.args[1].value = oldent->d_name.name;
731 args.in.args[2].size = newent->d_name.len + 1;
732 args.in.args[2].value = newent->d_name.name;
733 err = fuse_simple_request(fc, &args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700734 if (!err) {
Miklos Szeredi08b63302007-11-28 16:22:03 -0800735 /* ctime changes */
David Howells2b0143b2015-03-17 22:25:59 +0000736 fuse_invalidate_attr(d_inode(oldent));
737 fuse_update_ctime(d_inode(oldent));
Miklos Szeredi08b63302007-11-28 16:22:03 -0800738
Miklos Szeredi1560c972014-04-28 16:43:44 +0200739 if (flags & RENAME_EXCHANGE) {
David Howells2b0143b2015-03-17 22:25:59 +0000740 fuse_invalidate_attr(d_inode(newent));
741 fuse_update_ctime(d_inode(newent));
Miklos Szeredi1560c972014-04-28 16:43:44 +0200742 }
743
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700744 fuse_invalidate_attr(olddir);
745 if (olddir != newdir)
746 fuse_invalidate_attr(newdir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800747
748 /* newent will end up negative */
David Howells2b0143b2015-03-17 22:25:59 +0000749 if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
750 fuse_invalidate_attr(d_inode(newent));
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800751 fuse_invalidate_entry_cache(newent);
David Howells2b0143b2015-03-17 22:25:59 +0000752 fuse_update_ctime(d_inode(newent));
Miklos Szeredi5219f342009-11-04 10:24:52 +0100753 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700754 } else if (err == -EINTR) {
755 /* If request was interrupted, DEITY only knows if the
756 rename actually took place. If the invalidation
757 fails (e.g. some process has CWD under the renamed
758 directory), then there can be inconsistency between
759 the dcache and the real filesystem. Tough luck. */
760 fuse_invalidate_entry(oldent);
David Howells2b0143b2015-03-17 22:25:59 +0000761 if (d_really_is_positive(newent))
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700762 fuse_invalidate_entry(newent);
763 }
764
765 return err;
766}
767
Miklos Szeredi1560c972014-04-28 16:43:44 +0200768static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
769 struct inode *newdir, struct dentry *newent,
770 unsigned int flags)
771{
772 struct fuse_conn *fc = get_fuse_conn(olddir);
773 int err;
774
775 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
776 return -EINVAL;
777
Miklos Szeredi4237ba42014-07-10 10:50:19 +0200778 if (flags) {
779 if (fc->no_rename2 || fc->minor < 23)
780 return -EINVAL;
Miklos Szeredi1560c972014-04-28 16:43:44 +0200781
Miklos Szeredi4237ba42014-07-10 10:50:19 +0200782 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
783 FUSE_RENAME2,
784 sizeof(struct fuse_rename2_in));
785 if (err == -ENOSYS) {
786 fc->no_rename2 = 1;
787 err = -EINVAL;
788 }
789 } else {
790 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
791 FUSE_RENAME,
792 sizeof(struct fuse_rename_in));
Miklos Szeredi1560c972014-04-28 16:43:44 +0200793 }
Miklos Szeredi1560c972014-04-28 16:43:44 +0200794
Miklos Szeredi4237ba42014-07-10 10:50:19 +0200795 return err;
796}
797
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700798static int fuse_link(struct dentry *entry, struct inode *newdir,
799 struct dentry *newent)
800{
801 int err;
802 struct fuse_link_in inarg;
David Howells2b0143b2015-03-17 22:25:59 +0000803 struct inode *inode = d_inode(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700804 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +0100805 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700806
807 memset(&inarg, 0, sizeof(inarg));
808 inarg.oldnodeid = get_node_id(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +0100809 args.in.h.opcode = FUSE_LINK;
810 args.in.numargs = 2;
811 args.in.args[0].size = sizeof(inarg);
812 args.in.args[0].value = &inarg;
813 args.in.args[1].size = newent->d_name.len + 1;
814 args.in.args[1].value = newent->d_name.name;
815 err = create_new_entry(fc, &args, newdir, newent, inode->i_mode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700816 /* Contrary to "normal" filesystems it can happen that link
817 makes two "logical" inodes point to the same "physical"
818 inode. We invalidate the attributes of the old one, so it
819 will reflect changes in the backing inode (link count,
820 etc.)
821 */
Miklos Szerediac45d612012-03-05 15:48:11 +0100822 if (!err) {
823 struct fuse_inode *fi = get_fuse_inode(inode);
824
825 spin_lock(&fc->lock);
826 fi->attr_version = ++fc->attr_version;
827 inc_nlink(inode);
828 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700829 fuse_invalidate_attr(inode);
Maxim Patlasov31f32672014-04-28 14:19:24 +0200830 fuse_update_ctime(inode);
Miklos Szerediac45d612012-03-05 15:48:11 +0100831 } else if (err == -EINTR) {
832 fuse_invalidate_attr(inode);
833 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700834 return err;
835}
836
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700837static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
838 struct kstat *stat)
839{
Miklos Szeredi203627b2012-05-10 19:49:38 +0400840 unsigned int blkbits;
Pavel Emelyanov83732002013-10-10 17:10:46 +0400841 struct fuse_conn *fc = get_fuse_conn(inode);
842
843 /* see the comment in fuse_change_attributes() */
Maxim Patlasovb0aa7602013-12-26 19:51:11 +0400844 if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
Pavel Emelyanov83732002013-10-10 17:10:46 +0400845 attr->size = i_size_read(inode);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +0400846 attr->mtime = inode->i_mtime.tv_sec;
847 attr->mtimensec = inode->i_mtime.tv_nsec;
Maxim Patlasov31f32672014-04-28 14:19:24 +0200848 attr->ctime = inode->i_ctime.tv_sec;
849 attr->ctimensec = inode->i_ctime.tv_nsec;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +0400850 }
Miklos Szeredi203627b2012-05-10 19:49:38 +0400851
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700852 stat->dev = inode->i_sb->s_dev;
853 stat->ino = attr->ino;
854 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
855 stat->nlink = attr->nlink;
Eric W. Biederman499dcf22012-02-07 16:26:03 -0800856 stat->uid = make_kuid(&init_user_ns, attr->uid);
857 stat->gid = make_kgid(&init_user_ns, attr->gid);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700858 stat->rdev = inode->i_rdev;
859 stat->atime.tv_sec = attr->atime;
860 stat->atime.tv_nsec = attr->atimensec;
861 stat->mtime.tv_sec = attr->mtime;
862 stat->mtime.tv_nsec = attr->mtimensec;
863 stat->ctime.tv_sec = attr->ctime;
864 stat->ctime.tv_nsec = attr->ctimensec;
865 stat->size = attr->size;
866 stat->blocks = attr->blocks;
Miklos Szeredi203627b2012-05-10 19:49:38 +0400867
868 if (attr->blksize != 0)
869 blkbits = ilog2(attr->blksize);
870 else
871 blkbits = inode->i_sb->s_blocksize_bits;
872
873 stat->blksize = 1 << blkbits;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700874}
875
Miklos Szeredic79e3222007-10-18 03:06:59 -0700876static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
877 struct file *file)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700878{
879 int err;
Miklos Szeredic79e3222007-10-18 03:06:59 -0700880 struct fuse_getattr_in inarg;
881 struct fuse_attr_out outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700882 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +0100883 FUSE_ARGS(args);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700884 u64 attr_version;
885
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800886 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700887
Miklos Szeredic79e3222007-10-18 03:06:59 -0700888 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700889 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredic79e3222007-10-18 03:06:59 -0700890 /* Directories have separate file-handle space */
891 if (file && S_ISREG(inode->i_mode)) {
892 struct fuse_file *ff = file->private_data;
893
894 inarg.getattr_flags |= FUSE_GETATTR_FH;
895 inarg.fh = ff->fh;
896 }
Miklos Szeredi70781872014-12-12 09:49:05 +0100897 args.in.h.opcode = FUSE_GETATTR;
898 args.in.h.nodeid = get_node_id(inode);
899 args.in.numargs = 1;
900 args.in.args[0].size = sizeof(inarg);
901 args.in.args[0].value = &inarg;
902 args.out.numargs = 1;
Miklos Szeredi21f62172015-01-06 10:45:35 +0100903 args.out.args[0].size = sizeof(outarg);
Miklos Szeredi70781872014-12-12 09:49:05 +0100904 args.out.args[0].value = &outarg;
905 err = fuse_simple_request(fc, &args);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700906 if (!err) {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700907 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700908 make_bad_inode(inode);
909 err = -EIO;
910 } else {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700911 fuse_change_attributes(inode, &outarg.attr,
912 attr_timeout(&outarg),
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700913 attr_version);
914 if (stat)
Miklos Szeredic79e3222007-10-18 03:06:59 -0700915 fuse_fillattr(inode, &outarg.attr, stat);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700916 }
917 }
918 return err;
919}
920
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800921int fuse_update_attributes(struct inode *inode, struct kstat *stat,
922 struct file *file, bool *refreshed)
923{
924 struct fuse_inode *fi = get_fuse_inode(inode);
925 int err;
926 bool r;
927
Miklos Szeredi126b9d42014-07-07 15:28:50 +0200928 if (time_before64(fi->i_time, get_jiffies_64())) {
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800929 r = true;
Seth Forshee60bcc882016-08-29 08:46:37 -0500930 forget_all_cached_acls(inode);
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800931 err = fuse_do_getattr(inode, stat, file);
932 } else {
933 r = false;
934 err = 0;
935 if (stat) {
936 generic_fillattr(inode, stat);
937 stat->mode = fi->orig_i_mode;
Pavel Shilovsky45c72cd2012-05-10 19:49:38 +0400938 stat->ino = fi->orig_ino;
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800939 }
940 }
941
942 if (refreshed != NULL)
943 *refreshed = r;
944
945 return err;
946}
947
John Muir3b463ae2009-05-31 11:13:57 -0400948int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
John Muir451d0f52011-12-06 21:50:06 +0100949 u64 child_nodeid, struct qstr *name)
John Muir3b463ae2009-05-31 11:13:57 -0400950{
951 int err = -ENOTDIR;
952 struct inode *parent;
953 struct dentry *dir;
954 struct dentry *entry;
955
956 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
957 if (!parent)
958 return -ENOENT;
959
Al Viro59551022016-01-22 15:40:57 -0500960 inode_lock(parent);
John Muir3b463ae2009-05-31 11:13:57 -0400961 if (!S_ISDIR(parent->i_mode))
962 goto unlock;
963
964 err = -ENOENT;
965 dir = d_find_alias(parent);
966 if (!dir)
967 goto unlock;
968
Linus Torvalds8387ff22016-06-10 07:51:30 -0700969 name->hash = full_name_hash(dir, name->name, name->len);
John Muir3b463ae2009-05-31 11:13:57 -0400970 entry = d_lookup(dir, name);
971 dput(dir);
972 if (!entry)
973 goto unlock;
974
975 fuse_invalidate_attr(parent);
976 fuse_invalidate_entry(entry);
John Muir451d0f52011-12-06 21:50:06 +0100977
David Howells2b0143b2015-03-17 22:25:59 +0000978 if (child_nodeid != 0 && d_really_is_positive(entry)) {
Al Viro59551022016-01-22 15:40:57 -0500979 inode_lock(d_inode(entry));
David Howells2b0143b2015-03-17 22:25:59 +0000980 if (get_node_id(d_inode(entry)) != child_nodeid) {
John Muir451d0f52011-12-06 21:50:06 +0100981 err = -ENOENT;
982 goto badentry;
983 }
984 if (d_mountpoint(entry)) {
985 err = -EBUSY;
986 goto badentry;
987 }
David Howellse36cb0b2015-01-29 12:02:35 +0000988 if (d_is_dir(entry)) {
John Muir451d0f52011-12-06 21:50:06 +0100989 shrink_dcache_parent(entry);
990 if (!simple_empty(entry)) {
991 err = -ENOTEMPTY;
992 goto badentry;
993 }
David Howells2b0143b2015-03-17 22:25:59 +0000994 d_inode(entry)->i_flags |= S_DEAD;
John Muir451d0f52011-12-06 21:50:06 +0100995 }
996 dont_mount(entry);
David Howells2b0143b2015-03-17 22:25:59 +0000997 clear_nlink(d_inode(entry));
John Muir451d0f52011-12-06 21:50:06 +0100998 err = 0;
999 badentry:
Al Viro59551022016-01-22 15:40:57 -05001000 inode_unlock(d_inode(entry));
John Muir451d0f52011-12-06 21:50:06 +01001001 if (!err)
1002 d_delete(entry);
1003 } else {
1004 err = 0;
1005 }
John Muir3b463ae2009-05-31 11:13:57 -04001006 dput(entry);
John Muir3b463ae2009-05-31 11:13:57 -04001007
1008 unlock:
Al Viro59551022016-01-22 15:40:57 -05001009 inode_unlock(parent);
John Muir3b463ae2009-05-31 11:13:57 -04001010 iput(parent);
1011 return err;
1012}
1013
Miklos Szeredi87729a52005-09-09 13:10:34 -07001014/*
1015 * Calling into a user-controlled filesystem gives the filesystem
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001016 * daemon ptrace-like capabilities over the current process. This
Miklos Szeredi87729a52005-09-09 13:10:34 -07001017 * means, that the filesystem daemon is able to record the exact
1018 * filesystem operations performed, and can also control the behavior
1019 * of the requester process in otherwise impossible ways. For example
1020 * it can delay the operation for arbitrary length of time allowing
1021 * DoS against the requester.
1022 *
1023 * For this reason only those processes can call into the filesystem,
1024 * for which the owner of the mount has ptrace privilege. This
1025 * excludes processes started by other users, suid or sgid processes.
1026 */
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001027int fuse_allow_current_process(struct fuse_conn *fc)
Miklos Szeredi87729a52005-09-09 13:10:34 -07001028{
David Howellsc69e8d92008-11-14 10:39:19 +11001029 const struct cred *cred;
David Howellsc69e8d92008-11-14 10:39:19 +11001030
Miklos Szeredi29433a22016-10-01 07:32:32 +02001031 if (fc->allow_other)
Miklos Szeredi87729a52005-09-09 13:10:34 -07001032 return 1;
1033
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001034 cred = current_cred();
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001035 if (uid_eq(cred->euid, fc->user_id) &&
1036 uid_eq(cred->suid, fc->user_id) &&
1037 uid_eq(cred->uid, fc->user_id) &&
1038 gid_eq(cred->egid, fc->group_id) &&
1039 gid_eq(cred->sgid, fc->group_id) &&
1040 gid_eq(cred->gid, fc->group_id))
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001041 return 1;
Miklos Szeredi87729a52005-09-09 13:10:34 -07001042
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001043 return 0;
Miklos Szeredi87729a52005-09-09 13:10:34 -07001044}
1045
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001046static int fuse_access(struct inode *inode, int mask)
1047{
1048 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +01001049 FUSE_ARGS(args);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001050 struct fuse_access_in inarg;
1051 int err;
1052
Miklos Szeredi698fa1d2013-10-01 16:41:23 +02001053 BUG_ON(mask & MAY_NOT_BLOCK);
1054
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001055 if (fc->no_access)
1056 return 0;
1057
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001058 memset(&inarg, 0, sizeof(inarg));
Al Viroe6305c42008-07-15 21:03:57 -04001059 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
Miklos Szeredi70781872014-12-12 09:49:05 +01001060 args.in.h.opcode = FUSE_ACCESS;
1061 args.in.h.nodeid = get_node_id(inode);
1062 args.in.numargs = 1;
1063 args.in.args[0].size = sizeof(inarg);
1064 args.in.args[0].value = &inarg;
1065 err = fuse_simple_request(fc, &args);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001066 if (err == -ENOSYS) {
1067 fc->no_access = 1;
1068 err = 0;
1069 }
1070 return err;
1071}
1072
Al Viro10556cb2011-06-20 19:28:19 -04001073static int fuse_perm_getattr(struct inode *inode, int mask)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001074{
Al Viro10556cb2011-06-20 19:28:19 -04001075 if (mask & MAY_NOT_BLOCK)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001076 return -ECHILD;
1077
Seth Forshee60bcc882016-08-29 08:46:37 -05001078 forget_all_cached_acls(inode);
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001079 return fuse_do_getattr(inode, NULL, NULL);
1080}
1081
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001082/*
1083 * Check permission. The two basic access models of FUSE are:
1084 *
1085 * 1) Local access checking ('default_permissions' mount option) based
1086 * on file mode. This is the plain old disk filesystem permission
1087 * modell.
1088 *
1089 * 2) "Remote" access checking, where server is responsible for
1090 * checking permission in each inode operation. An exception to this
1091 * is if ->permission() was invoked from sys_access() in which case an
1092 * access request is sent. Execute permission is still checked
1093 * locally based on file mode.
1094 */
Al Viro10556cb2011-06-20 19:28:19 -04001095static int fuse_permission(struct inode *inode, int mask)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001096{
1097 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001098 bool refreshed = false;
1099 int err = 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001100
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001101 if (!fuse_allow_current_process(fc))
Miklos Szeredie5e55582005-09-09 13:10:28 -07001102 return -EACCES;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001103
1104 /*
Miklos Szeredie8e96152007-10-16 23:31:06 -07001105 * If attributes are needed, refresh them before proceeding
Miklos Szeredi244f6382007-10-16 23:31:02 -07001106 */
Miklos Szeredi29433a22016-10-01 07:32:32 +02001107 if (fc->default_permissions ||
Miklos Szeredie8e96152007-10-16 23:31:06 -07001108 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001109 struct fuse_inode *fi = get_fuse_inode(inode);
1110
Miklos Szeredi126b9d42014-07-07 15:28:50 +02001111 if (time_before64(fi->i_time, get_jiffies_64())) {
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001112 refreshed = true;
1113
Al Viro10556cb2011-06-20 19:28:19 -04001114 err = fuse_perm_getattr(inode, mask);
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001115 if (err)
1116 return err;
1117 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001118 }
1119
Miklos Szeredi29433a22016-10-01 07:32:32 +02001120 if (fc->default_permissions) {
Al Viro2830ba72011-06-20 19:16:29 -04001121 err = generic_permission(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001122
1123 /* If permission is denied, try to refresh file
1124 attributes. This is also needed, because the root
1125 node will at first have no permissions */
Miklos Szeredi244f6382007-10-16 23:31:02 -07001126 if (err == -EACCES && !refreshed) {
Al Viro10556cb2011-06-20 19:28:19 -04001127 err = fuse_perm_getattr(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001128 if (!err)
Al Viro2830ba72011-06-20 19:16:29 -04001129 err = generic_permission(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001130 }
1131
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001132 /* Note: the opposite of the above test does not
1133 exist. So if permissions are revoked this won't be
1134 noticed immediately, only after the attribute
1135 timeout has expired */
Eric Paris9cfcac82010-07-23 11:43:51 -04001136 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
Miklos Szeredie8e96152007-10-16 23:31:06 -07001137 err = fuse_access(inode, mask);
1138 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1139 if (!(inode->i_mode & S_IXUGO)) {
1140 if (refreshed)
1141 return -EACCES;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001142
Al Viro10556cb2011-06-20 19:28:19 -04001143 err = fuse_perm_getattr(inode, mask);
Miklos Szeredie8e96152007-10-16 23:31:06 -07001144 if (!err && !(inode->i_mode & S_IXUGO))
1145 return -EACCES;
1146 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001147 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001148 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001149}
1150
1151static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
Al Viro8d3af7f2013-05-18 03:03:58 -04001152 struct dir_context *ctx)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001153{
1154 while (nbytes >= FUSE_NAME_OFFSET) {
1155 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1156 size_t reclen = FUSE_DIRENT_SIZE(dirent);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001157 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1158 return -EIO;
1159 if (reclen > nbytes)
1160 break;
Miklos Szerediefeb9e62013-09-03 14:28:38 +02001161 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1162 return -EIO;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001163
Al Viro8d3af7f2013-05-18 03:03:58 -04001164 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1165 dirent->ino, dirent->type))
Miklos Szeredie5e55582005-09-09 13:10:28 -07001166 break;
1167
1168 buf += reclen;
1169 nbytes -= reclen;
Al Viro8d3af7f2013-05-18 03:03:58 -04001170 ctx->pos = dirent->off;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001171 }
1172
1173 return 0;
1174}
1175
Anand V. Avati0b05b182012-08-19 08:53:23 -04001176static int fuse_direntplus_link(struct file *file,
1177 struct fuse_direntplus *direntplus,
1178 u64 attr_version)
1179{
Anand V. Avati0b05b182012-08-19 08:53:23 -04001180 struct fuse_entry_out *o = &direntplus->entry_out;
1181 struct fuse_dirent *dirent = &direntplus->dirent;
1182 struct dentry *parent = file->f_path.dentry;
1183 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1184 struct dentry *dentry;
1185 struct dentry *alias;
David Howells2b0143b2015-03-17 22:25:59 +00001186 struct inode *dir = d_inode(parent);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001187 struct fuse_conn *fc;
1188 struct inode *inode;
Al Virod9b3dbd2016-04-20 17:30:32 -04001189 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001190
1191 if (!o->nodeid) {
1192 /*
1193 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1194 * ENOENT. Instead, it only means the userspace filesystem did
1195 * not want to return attributes/handle for this entry.
1196 *
1197 * So do nothing.
1198 */
1199 return 0;
1200 }
1201
1202 if (name.name[0] == '.') {
1203 /*
1204 * We could potentially refresh the attributes of the directory
1205 * and its parent?
1206 */
1207 if (name.len == 1)
1208 return 0;
1209 if (name.name[1] == '.' && name.len == 2)
1210 return 0;
1211 }
Miklos Szeredia28ef452013-07-17 14:53:53 +02001212
1213 if (invalid_nodeid(o->nodeid))
1214 return -EIO;
1215 if (!fuse_valid_type(o->attr.mode))
1216 return -EIO;
1217
Anand V. Avati0b05b182012-08-19 08:53:23 -04001218 fc = get_fuse_conn(dir);
1219
Linus Torvalds8387ff22016-06-10 07:51:30 -07001220 name.hash = full_name_hash(parent, name.name, name.len);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001221 dentry = d_lookup(parent, &name);
Al Virod9b3dbd2016-04-20 17:30:32 -04001222 if (!dentry) {
1223retry:
1224 dentry = d_alloc_parallel(parent, &name, &wq);
1225 if (IS_ERR(dentry))
1226 return PTR_ERR(dentry);
1227 }
1228 if (!d_in_lookup(dentry)) {
1229 struct fuse_inode *fi;
David Howells2b0143b2015-03-17 22:25:59 +00001230 inode = d_inode(dentry);
Al Virod9b3dbd2016-04-20 17:30:32 -04001231 if (!inode ||
1232 get_node_id(inode) != o->nodeid ||
1233 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
Eric W. Biederman5542aa22014-02-13 09:46:25 -08001234 d_invalidate(dentry);
Al Virod9b3dbd2016-04-20 17:30:32 -04001235 dput(dentry);
1236 goto retry;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001237 }
Al Virod9b3dbd2016-04-20 17:30:32 -04001238 if (is_bad_inode(inode)) {
1239 dput(dentry);
1240 return -EIO;
1241 }
1242
1243 fi = get_fuse_inode(inode);
1244 spin_lock(&fc->lock);
1245 fi->nlookup++;
1246 spin_unlock(&fc->lock);
1247
Seth Forshee60bcc882016-08-29 08:46:37 -05001248 forget_all_cached_acls(inode);
Al Virod9b3dbd2016-04-20 17:30:32 -04001249 fuse_change_attributes(inode, &o->attr,
1250 entry_attr_timeout(o),
1251 attr_version);
1252 /*
1253 * The other branch comes via fuse_iget()
1254 * which bumps nlookup inside
1255 */
1256 } else {
1257 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1258 &o->attr, entry_attr_timeout(o),
1259 attr_version);
1260 if (!inode)
1261 inode = ERR_PTR(-ENOMEM);
1262
1263 alias = d_splice_alias(inode, dentry);
1264 d_lookup_done(dentry);
1265 if (alias) {
1266 dput(dentry);
1267 dentry = alias;
1268 }
1269 if (IS_ERR(dentry))
1270 return PTR_ERR(dentry);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001271 }
Miklos Szeredi6314efe2013-10-01 16:41:22 +02001272 if (fc->readdirplus_auto)
1273 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001274 fuse_change_entry_timeout(dentry, o);
1275
Miklos Szeredic7263bc2013-07-17 14:53:54 +02001276 dput(dentry);
Al Virod9b3dbd2016-04-20 17:30:32 -04001277 return 0;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001278}
1279
1280static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
Al Viro8d3af7f2013-05-18 03:03:58 -04001281 struct dir_context *ctx, u64 attr_version)
Anand V. Avati0b05b182012-08-19 08:53:23 -04001282{
1283 struct fuse_direntplus *direntplus;
1284 struct fuse_dirent *dirent;
1285 size_t reclen;
1286 int over = 0;
1287 int ret;
1288
1289 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1290 direntplus = (struct fuse_direntplus *) buf;
1291 dirent = &direntplus->dirent;
1292 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1293
1294 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1295 return -EIO;
1296 if (reclen > nbytes)
1297 break;
Miklos Szerediefeb9e62013-09-03 14:28:38 +02001298 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1299 return -EIO;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001300
1301 if (!over) {
1302 /* We fill entries into dstbuf only as much as
1303 it can hold. But we still continue iterating
1304 over remaining entries to link them. If not,
1305 we need to send a FORGET for each of those
1306 which we did not link.
1307 */
Al Viro8d3af7f2013-05-18 03:03:58 -04001308 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1309 dirent->ino, dirent->type);
1310 ctx->pos = dirent->off;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001311 }
1312
1313 buf += reclen;
1314 nbytes -= reclen;
1315
1316 ret = fuse_direntplus_link(file, direntplus, attr_version);
1317 if (ret)
1318 fuse_force_forget(file, direntplus->entry_out.nodeid);
1319 }
1320
1321 return 0;
1322}
1323
Al Viro8d3af7f2013-05-18 03:03:58 -04001324static int fuse_readdir(struct file *file, struct dir_context *ctx)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001325{
Feng Shuo4582a4a2013-01-15 11:23:28 +08001326 int plus, err;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001327 size_t nbytes;
1328 struct page *page;
Al Viro496ad9a2013-01-23 17:07:38 -05001329 struct inode *inode = file_inode(file);
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001330 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001331 struct fuse_req *req;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001332 u64 attr_version = 0;
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001333
1334 if (is_bad_inode(inode))
1335 return -EIO;
1336
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001337 req = fuse_get_req(fc, 1);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001338 if (IS_ERR(req))
1339 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001340
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001341 page = alloc_page(GFP_KERNEL);
1342 if (!page) {
1343 fuse_put_request(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001344 return -ENOMEM;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001345 }
Feng Shuo4582a4a2013-01-15 11:23:28 +08001346
Al Viro8d3af7f2013-05-18 03:03:58 -04001347 plus = fuse_use_readdirplus(inode, ctx);
Miklos Szeredif4975c62009-04-02 14:25:34 +02001348 req->out.argpages = 1;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001349 req->num_pages = 1;
1350 req->pages[0] = page;
Maxim Patlasov85f40ae2012-10-26 19:49:33 +04001351 req->page_descs[0].length = PAGE_SIZE;
Feng Shuo4582a4a2013-01-15 11:23:28 +08001352 if (plus) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001353 attr_version = fuse_get_attr_version(fc);
Al Viro8d3af7f2013-05-18 03:03:58 -04001354 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
Anand V. Avati0b05b182012-08-19 08:53:23 -04001355 FUSE_READDIRPLUS);
1356 } else {
Al Viro8d3af7f2013-05-18 03:03:58 -04001357 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
Anand V. Avati0b05b182012-08-19 08:53:23 -04001358 FUSE_READDIR);
1359 }
Miklos Szeredi5c672ab2016-06-30 13:10:49 +02001360 fuse_lock_inode(inode);
Tejun Heob93f8582008-11-26 12:03:55 +01001361 fuse_request_send(fc, req);
Miklos Szeredi5c672ab2016-06-30 13:10:49 +02001362 fuse_unlock_inode(inode);
Miklos Szeredi361b1eb52006-01-16 22:14:45 -08001363 nbytes = req->out.args[0].size;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001364 err = req->out.h.error;
1365 fuse_put_request(fc, req);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001366 if (!err) {
Feng Shuo4582a4a2013-01-15 11:23:28 +08001367 if (plus) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001368 err = parse_dirplusfile(page_address(page), nbytes,
Al Viro8d3af7f2013-05-18 03:03:58 -04001369 file, ctx,
Anand V. Avati0b05b182012-08-19 08:53:23 -04001370 attr_version);
1371 } else {
1372 err = parse_dirfile(page_address(page), nbytes, file,
Al Viro8d3af7f2013-05-18 03:03:58 -04001373 ctx);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001374 }
1375 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001376
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001377 __free_page(page);
Andrew Gallagher451418f2013-11-05 03:55:43 -08001378 fuse_invalidate_atime(inode);
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001379 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001380}
1381
Al Viro6b255392015-11-17 10:20:54 -05001382static const char *fuse_get_link(struct dentry *dentry,
Al Virofceef392015-12-29 15:58:39 -05001383 struct inode *inode,
1384 struct delayed_call *done)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001385{
Miklos Szeredie5e55582005-09-09 13:10:28 -07001386 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +01001387 FUSE_ARGS(args);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001388 char *link;
Miklos Szeredi70781872014-12-12 09:49:05 +01001389 ssize_t ret;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001390
Al Viro6b255392015-11-17 10:20:54 -05001391 if (!dentry)
1392 return ERR_PTR(-ECHILD);
1393
Al Virocd3417c2015-12-29 16:03:53 -05001394 link = kmalloc(PAGE_SIZE, GFP_KERNEL);
Miklos Szeredi70781872014-12-12 09:49:05 +01001395 if (!link)
1396 return ERR_PTR(-ENOMEM);
1397
1398 args.in.h.opcode = FUSE_READLINK;
1399 args.in.h.nodeid = get_node_id(inode);
1400 args.out.argvar = 1;
1401 args.out.numargs = 1;
1402 args.out.args[0].size = PAGE_SIZE - 1;
1403 args.out.args[0].value = link;
1404 ret = fuse_simple_request(fc, &args);
1405 if (ret < 0) {
Al Virocd3417c2015-12-29 16:03:53 -05001406 kfree(link);
Miklos Szeredi70781872014-12-12 09:49:05 +01001407 link = ERR_PTR(ret);
1408 } else {
1409 link[ret] = '\0';
Al Virofceef392015-12-29 15:58:39 -05001410 set_delayed_call(done, kfree_link, link);
Miklos Szeredi70781872014-12-12 09:49:05 +01001411 }
Andrew Gallagher451418f2013-11-05 03:55:43 -08001412 fuse_invalidate_atime(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001413 return link;
1414}
1415
Miklos Szeredie5e55582005-09-09 13:10:28 -07001416static int fuse_dir_open(struct inode *inode, struct file *file)
1417{
Miklos Szeredi91fe96b2009-04-28 16:56:37 +02001418 return fuse_open_common(inode, file, true);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001419}
1420
1421static int fuse_dir_release(struct inode *inode, struct file *file)
1422{
Miklos Szeredi8b0797a2009-04-28 16:56:39 +02001423 fuse_release_common(file, FUSE_RELEASEDIR);
1424
1425 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001426}
1427
Josef Bacik02c24a82011-07-16 20:44:56 -04001428static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1429 int datasync)
Miklos Szeredi82547982005-09-09 13:10:38 -07001430{
Josef Bacik02c24a82011-07-16 20:44:56 -04001431 return fuse_fsync_common(file, start, end, datasync, 1);
Miklos Szeredi82547982005-09-09 13:10:38 -07001432}
1433
Miklos Szeredib18da0c2011-12-13 11:58:49 +01001434static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1435 unsigned long arg)
1436{
1437 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1438
1439 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1440 if (fc->minor < 18)
1441 return -ENOTTY;
1442
1443 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1444}
1445
1446static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1447 unsigned long arg)
1448{
1449 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1450
1451 if (fc->minor < 18)
1452 return -ENOTTY;
1453
1454 return fuse_ioctl_common(file, cmd, arg,
1455 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1456}
1457
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001458static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001459{
1460 /* Always update if mtime is explicitly set */
1461 if (ivalid & ATTR_MTIME_SET)
1462 return true;
1463
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001464 /* Or if kernel i_mtime is the official one */
1465 if (trust_local_mtime)
1466 return true;
1467
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001468 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1469 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1470 return false;
1471
1472 /* In all other cases update */
1473 return true;
1474}
1475
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001476static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg,
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001477 bool trust_local_cmtime)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001478{
1479 unsigned ivalid = iattr->ia_valid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001480
1481 if (ivalid & ATTR_MODE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001482 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001483 if (ivalid & ATTR_UID)
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001484 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001485 if (ivalid & ATTR_GID)
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001486 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001487 if (ivalid & ATTR_SIZE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001488 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001489 if (ivalid & ATTR_ATIME) {
1490 arg->valid |= FATTR_ATIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001491 arg->atime = iattr->ia_atime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001492 arg->atimensec = iattr->ia_atime.tv_nsec;
1493 if (!(ivalid & ATTR_ATIME_SET))
1494 arg->valid |= FATTR_ATIME_NOW;
1495 }
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001496 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001497 arg->valid |= FATTR_MTIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001498 arg->mtime = iattr->ia_mtime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001499 arg->mtimensec = iattr->ia_mtime.tv_nsec;
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001500 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001501 arg->valid |= FATTR_MTIME_NOW;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001502 }
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001503 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1504 arg->valid |= FATTR_CTIME;
1505 arg->ctime = iattr->ia_ctime.tv_sec;
1506 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1507 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001508}
1509
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001510/*
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001511 * Prevent concurrent writepages on inode
1512 *
1513 * This is done by adding a negative bias to the inode write counter
1514 * and waiting for all pending writes to finish.
1515 */
1516void fuse_set_nowrite(struct inode *inode)
1517{
1518 struct fuse_conn *fc = get_fuse_conn(inode);
1519 struct fuse_inode *fi = get_fuse_inode(inode);
1520
Al Viro59551022016-01-22 15:40:57 -05001521 BUG_ON(!inode_is_locked(inode));
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001522
1523 spin_lock(&fc->lock);
1524 BUG_ON(fi->writectr < 0);
1525 fi->writectr += FUSE_NOWRITE;
1526 spin_unlock(&fc->lock);
1527 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1528}
1529
1530/*
1531 * Allow writepages on inode
1532 *
1533 * Remove the bias from the writecounter and send any queued
1534 * writepages.
1535 */
1536static void __fuse_release_nowrite(struct inode *inode)
1537{
1538 struct fuse_inode *fi = get_fuse_inode(inode);
1539
1540 BUG_ON(fi->writectr != FUSE_NOWRITE);
1541 fi->writectr = 0;
1542 fuse_flush_writepages(inode);
1543}
1544
1545void fuse_release_nowrite(struct inode *inode)
1546{
1547 struct fuse_conn *fc = get_fuse_conn(inode);
1548
1549 spin_lock(&fc->lock);
1550 __fuse_release_nowrite(inode);
1551 spin_unlock(&fc->lock);
1552}
1553
Miklos Szeredi70781872014-12-12 09:49:05 +01001554static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001555 struct inode *inode,
1556 struct fuse_setattr_in *inarg_p,
1557 struct fuse_attr_out *outarg_p)
1558{
Miklos Szeredi70781872014-12-12 09:49:05 +01001559 args->in.h.opcode = FUSE_SETATTR;
1560 args->in.h.nodeid = get_node_id(inode);
1561 args->in.numargs = 1;
1562 args->in.args[0].size = sizeof(*inarg_p);
1563 args->in.args[0].value = inarg_p;
1564 args->out.numargs = 1;
Miklos Szeredi21f62172015-01-06 10:45:35 +01001565 args->out.args[0].size = sizeof(*outarg_p);
Miklos Szeredi70781872014-12-12 09:49:05 +01001566 args->out.args[0].value = outarg_p;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001567}
1568
1569/*
1570 * Flush inode->i_mtime to the server
1571 */
Maxim Patlasovab9e13f2014-04-28 14:19:24 +02001572int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001573{
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001574 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +01001575 FUSE_ARGS(args);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001576 struct fuse_setattr_in inarg;
1577 struct fuse_attr_out outarg;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001578
1579 memset(&inarg, 0, sizeof(inarg));
1580 memset(&outarg, 0, sizeof(outarg));
1581
Maxim Patlasovab9e13f2014-04-28 14:19:24 +02001582 inarg.valid = FATTR_MTIME;
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001583 inarg.mtime = inode->i_mtime.tv_sec;
1584 inarg.mtimensec = inode->i_mtime.tv_nsec;
Maxim Patlasovab9e13f2014-04-28 14:19:24 +02001585 if (fc->minor >= 23) {
1586 inarg.valid |= FATTR_CTIME;
1587 inarg.ctime = inode->i_ctime.tv_sec;
1588 inarg.ctimensec = inode->i_ctime.tv_nsec;
1589 }
Miklos Szeredi1e18bda2014-04-28 14:19:23 +02001590 if (ff) {
1591 inarg.valid |= FATTR_FH;
1592 inarg.fh = ff->fh;
1593 }
Miklos Szeredi70781872014-12-12 09:49:05 +01001594 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001595
Miklos Szeredi70781872014-12-12 09:49:05 +01001596 return fuse_simple_request(fc, &args);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001597}
1598
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001599/*
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001600 * Set attributes, and at the same time refresh them.
1601 *
1602 * Truncation is slightly complicated, because the 'truncate' request
1603 * may fail, in which case we don't want to touch the mapping.
Miklos Szeredi9ffbb912006-10-17 00:10:06 -07001604 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1605 * and the actual truncation by hand.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001606 */
Jan Kara62490332016-05-26 17:12:41 +02001607int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
Maxim Patlasovefb9fa92012-12-18 14:05:08 +04001608 struct file *file)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001609{
Jan Kara62490332016-05-26 17:12:41 +02001610 struct inode *inode = d_inode(dentry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001611 struct fuse_conn *fc = get_fuse_conn(inode);
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001612 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi70781872014-12-12 09:49:05 +01001613 FUSE_ARGS(args);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001614 struct fuse_setattr_in inarg;
1615 struct fuse_attr_out outarg;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001616 bool is_truncate = false;
Pavel Emelyanov83732002013-10-10 17:10:46 +04001617 bool is_wb = fc->writeback_cache;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001618 loff_t oldsize;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001619 int err;
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001620 bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001621
Miklos Szeredi29433a22016-10-01 07:32:32 +02001622 if (!fc->default_permissions)
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001623 attr->ia_valid |= ATTR_FORCE;
1624
Jan Kara31051c82016-05-26 16:55:18 +02001625 err = setattr_prepare(dentry, attr);
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001626 if (err)
1627 return err;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001628
Miklos Szeredi8d56add2011-02-25 14:44:58 +01001629 if (attr->ia_valid & ATTR_OPEN) {
1630 if (fc->atomic_o_trunc)
1631 return 0;
1632 file = NULL;
1633 }
Miklos Szeredi6ff958e2007-10-18 03:07:02 -07001634
Christoph Hellwig2c27c652010-06-04 11:30:04 +02001635 if (attr->ia_valid & ATTR_SIZE)
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001636 is_truncate = true;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001637
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001638 if (is_truncate) {
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001639 fuse_set_nowrite(inode);
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001640 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001641 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1642 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001643 }
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001644
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001645 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001646 memset(&outarg, 0, sizeof(outarg));
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001647 iattr_to_fattr(attr, &inarg, trust_local_cmtime);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001648 if (file) {
1649 struct fuse_file *ff = file->private_data;
1650 inarg.valid |= FATTR_FH;
1651 inarg.fh = ff->fh;
1652 }
Miklos Szeredif3332112007-10-18 03:07:04 -07001653 if (attr->ia_valid & ATTR_SIZE) {
1654 /* For mandatory locking in truncate */
1655 inarg.valid |= FATTR_LOCKOWNER;
1656 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1657 }
Miklos Szeredi70781872014-12-12 09:49:05 +01001658 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1659 err = fuse_simple_request(fc, &args);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001660 if (err) {
1661 if (err == -EINTR)
1662 fuse_invalidate_attr(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001663 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001664 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001665
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001666 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1667 make_bad_inode(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001668 err = -EIO;
1669 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001670 }
1671
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001672 spin_lock(&fc->lock);
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001673 /* the kernel maintains i_mtime locally */
Maxim Patlasov3ad22c62014-04-28 14:19:25 +02001674 if (trust_local_cmtime) {
1675 if (attr->ia_valid & ATTR_MTIME)
1676 inode->i_mtime = attr->ia_mtime;
1677 if (attr->ia_valid & ATTR_CTIME)
1678 inode->i_ctime = attr->ia_ctime;
Miklos Szeredi1e18bda2014-04-28 14:19:23 +02001679 /* FIXME: clear I_DIRTY_SYNC? */
Maxim Patlasovb0aa7602013-12-26 19:51:11 +04001680 }
1681
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001682 fuse_change_attributes_common(inode, &outarg.attr,
1683 attr_timeout(&outarg));
1684 oldsize = inode->i_size;
Pavel Emelyanov83732002013-10-10 17:10:46 +04001685 /* see the comment in fuse_change_attributes() */
1686 if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1687 i_size_write(inode, outarg.attr.size);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001688
1689 if (is_truncate) {
1690 /* NOTE: this may release/reacquire fc->lock */
1691 __fuse_release_nowrite(inode);
1692 }
1693 spin_unlock(&fc->lock);
1694
1695 /*
1696 * Only call invalidate_inode_pages2() after removing
1697 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1698 */
Pavel Emelyanov83732002013-10-10 17:10:46 +04001699 if ((is_truncate || !is_wb) &&
1700 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001701 truncate_pagecache(inode, outarg.attr.size);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001702 invalidate_inode_pages2(inode->i_mapping);
1703 }
1704
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001705 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001706 return 0;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001707
1708error:
1709 if (is_truncate)
1710 fuse_release_nowrite(inode);
1711
Maxim Patlasov06a7c3c2013-08-30 17:06:04 +04001712 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001713 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001714}
1715
Miklos Szeredi49d49142007-10-18 03:07:00 -07001716static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1717{
David Howells2b0143b2015-03-17 22:25:59 +00001718 struct inode *inode = d_inode(entry);
Miklos Szeredi5e940c12016-10-01 07:32:32 +02001719 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredia09f99e2016-10-01 07:32:32 +02001720 struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL;
Miklos Szeredi5e2b8822016-10-01 07:32:32 +02001721 int ret;
Maxim Patlasovefb9fa92012-12-18 14:05:08 +04001722
1723 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1724 return -EACCES;
1725
Miklos Szeredia09f99e2016-10-01 07:32:32 +02001726 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) {
Miklos Szeredia09f99e2016-10-01 07:32:32 +02001727 attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID |
1728 ATTR_MODE);
Miklos Szeredia09f99e2016-10-01 07:32:32 +02001729
Miklos Szeredi5e940c12016-10-01 07:32:32 +02001730 /*
1731 * The only sane way to reliably kill suid/sgid is to do it in
1732 * the userspace filesystem
1733 *
1734 * This should be done on write(), truncate() and chown().
1735 */
1736 if (!fc->handle_killpriv) {
1737 int kill;
1738
1739 /*
1740 * ia_mode calculation may have used stale i_mode.
1741 * Refresh and recalculate.
1742 */
1743 ret = fuse_do_getattr(inode, NULL, file);
1744 if (ret)
1745 return ret;
1746
1747 attr->ia_mode = inode->i_mode;
1748 kill = should_remove_suid(entry);
1749 if (kill & ATTR_KILL_SUID) {
1750 attr->ia_valid |= ATTR_MODE;
1751 attr->ia_mode &= ~S_ISUID;
1752 }
1753 if (kill & ATTR_KILL_SGID) {
1754 attr->ia_valid |= ATTR_MODE;
1755 attr->ia_mode &= ~S_ISGID;
1756 }
Miklos Szeredia09f99e2016-10-01 07:32:32 +02001757 }
1758 }
1759 if (!attr->ia_valid)
1760 return 0;
1761
Linus Torvaldsabb5a142016-10-10 13:04:49 -07001762 ret = fuse_do_setattr(entry, attr, file);
Miklos Szeredi5e2b8822016-10-01 07:32:32 +02001763 if (!ret) {
Seth Forshee60bcc882016-08-29 08:46:37 -05001764 /*
1765 * If filesystem supports acls it may have updated acl xattrs in
1766 * the filesystem, so forget cached acls for the inode.
1767 */
1768 if (fc->posix_acl)
1769 forget_all_cached_acls(inode);
1770
Miklos Szeredi5e2b8822016-10-01 07:32:32 +02001771 /* Directory mode changed, may need to revalidate access */
1772 if (d_is_dir(entry) && (attr->ia_valid & ATTR_MODE))
1773 fuse_invalidate_entry_cache(entry);
1774 }
1775 return ret;
Miklos Szeredi49d49142007-10-18 03:07:00 -07001776}
1777
Miklos Szeredie5e55582005-09-09 13:10:28 -07001778static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1779 struct kstat *stat)
1780{
David Howells2b0143b2015-03-17 22:25:59 +00001781 struct inode *inode = d_inode(entry);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001782 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001783
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001784 if (!fuse_allow_current_process(fc))
Miklos Szeredi244f6382007-10-16 23:31:02 -07001785 return -EACCES;
1786
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001787 return fuse_update_attributes(inode, stat, NULL, NULL);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001788}
1789
Arjan van de Ven754661f2007-02-12 00:55:38 -08001790static const struct inode_operations fuse_dir_inode_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -07001791 .lookup = fuse_lookup,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001792 .mkdir = fuse_mkdir,
1793 .symlink = fuse_symlink,
1794 .unlink = fuse_unlink,
1795 .rmdir = fuse_rmdir,
Miklos Szeredi2773bf02016-09-27 11:03:58 +02001796 .rename = fuse_rename2,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001797 .link = fuse_link,
1798 .setattr = fuse_setattr,
1799 .create = fuse_create,
Miklos Szeredic8ccbe02012-06-05 15:10:22 +02001800 .atomic_open = fuse_atomic_open,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001801 .mknod = fuse_mknod,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001802 .permission = fuse_permission,
1803 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001804 .listxattr = fuse_listxattr,
Seth Forshee60bcc882016-08-29 08:46:37 -05001805 .get_acl = fuse_get_acl,
1806 .set_acl = fuse_set_acl,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001807};
1808
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001809static const struct file_operations fuse_dir_operations = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001810 .llseek = generic_file_llseek,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001811 .read = generic_read_dir,
Al Virod9b3dbd2016-04-20 17:30:32 -04001812 .iterate_shared = fuse_readdir,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001813 .open = fuse_dir_open,
1814 .release = fuse_dir_release,
Miklos Szeredi82547982005-09-09 13:10:38 -07001815 .fsync = fuse_dir_fsync,
Miklos Szeredib18da0c2011-12-13 11:58:49 +01001816 .unlocked_ioctl = fuse_dir_ioctl,
1817 .compat_ioctl = fuse_dir_compat_ioctl,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001818};
1819
Arjan van de Ven754661f2007-02-12 00:55:38 -08001820static const struct inode_operations fuse_common_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001821 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001822 .permission = fuse_permission,
1823 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001824 .listxattr = fuse_listxattr,
Seth Forshee60bcc882016-08-29 08:46:37 -05001825 .get_acl = fuse_get_acl,
1826 .set_acl = fuse_set_acl,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001827};
1828
Arjan van de Ven754661f2007-02-12 00:55:38 -08001829static const struct inode_operations fuse_symlink_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001830 .setattr = fuse_setattr,
Al Viro6b255392015-11-17 10:20:54 -05001831 .get_link = fuse_get_link,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001832 .readlink = generic_readlink,
1833 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001834 .listxattr = fuse_listxattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001835};
1836
1837void fuse_init_common(struct inode *inode)
1838{
1839 inode->i_op = &fuse_common_inode_operations;
1840}
1841
1842void fuse_init_dir(struct inode *inode)
1843{
1844 inode->i_op = &fuse_dir_inode_operations;
1845 inode->i_fop = &fuse_dir_operations;
1846}
1847
1848void fuse_init_symlink(struct inode *inode)
1849{
1850 inode->i_op = &fuse_symlink_inode_operations;
1851}