blob: ff15522481d4261c042b87107f90108dcd304d87 [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
Feng Shuo4582a4a2013-01-15 11:23:28 +080017static bool fuse_use_readdirplus(struct inode *dir, struct file *filp)
18{
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;
28 if (filp->f_pos == 0)
29 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
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800115/*
116 * Just mark the entry as stale, so that a next attempt to look it up
117 * will result in a new lookup call to userspace
118 *
119 * This is called when a dentry is about to become negative and the
120 * timeout is unknown (unlink, rmdir, rename and in some cases
121 * lookup)
122 */
Miklos Szeredidbd561d2008-07-25 01:49:00 -0700123void fuse_invalidate_entry_cache(struct dentry *entry)
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800124{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700125 fuse_dentry_settime(entry, 0);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800126}
127
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800128/*
129 * Same as fuse_invalidate_entry_cache(), but also try to remove the
130 * dentry from the hash
131 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800132static void fuse_invalidate_entry(struct dentry *entry)
133{
134 d_invalidate(entry);
135 fuse_invalidate_entry_cache(entry);
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800136}
137
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700138static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
139 u64 nodeid, struct qstr *name,
Miklos Szeredie5e55582005-09-09 13:10:28 -0700140 struct fuse_entry_out *outarg)
141{
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700142 memset(outarg, 0, sizeof(struct fuse_entry_out));
Miklos Szeredie5e55582005-09-09 13:10:28 -0700143 req->in.h.opcode = FUSE_LOOKUP;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700144 req->in.h.nodeid = nodeid;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700145 req->in.numargs = 1;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700146 req->in.args[0].size = name->len + 1;
147 req->in.args[0].value = name->name;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700148 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700149 if (fc->minor < 9)
150 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
151 else
152 req->out.args[0].size = sizeof(struct fuse_entry_out);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700153 req->out.args[0].value = outarg;
154}
155
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700156u64 fuse_get_attr_version(struct fuse_conn *fc)
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800157{
158 u64 curr_version;
159
160 /*
161 * The spin lock isn't actually needed on 64bit archs, but we
162 * don't yet care too much about such optimizations.
163 */
164 spin_lock(&fc->lock);
165 curr_version = fc->attr_version;
166 spin_unlock(&fc->lock);
167
168 return curr_version;
169}
170
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800171/*
172 * Check whether the dentry is still valid
173 *
174 * If the entry validity timeout has expired and the dentry is
175 * positive, try to redo the lookup. If the lookup results in a
176 * different inode, then let the VFS invalidate the dentry and redo
177 * the lookup once more. If the lookup results in the same inode,
178 * then refresh the attributes, timeouts and mark the dentry valid.
179 */
Al Viro0b728e12012-06-10 16:03:43 -0400180static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700181{
Nick Piggin34286d62011-01-07 17:49:57 +1100182 struct inode *inode;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800183
Miklos Szeredie7c0a162011-03-21 13:58:06 +0100184 inode = ACCESS_ONCE(entry->d_inode);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800185 if (inode && is_bad_inode(inode))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700186 return 0;
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700187 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700188 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700189 struct fuse_entry_out outarg;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800190 struct fuse_conn *fc;
191 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100192 struct fuse_forget_link *forget;
Miklos Szeredie956edd2006-10-17 00:10:12 -0700193 struct dentry *parent;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700194 u64 attr_version;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800195
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800196 /* For negative dentries, always do a fresh lookup */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800197 if (!inode)
198 return 0;
199
Al Viro0b728e12012-06-10 16:03:43 -0400200 if (flags & LOOKUP_RCU)
Miklos Szeredie7c0a162011-03-21 13:58:06 +0100201 return -ECHILD;
202
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800203 fc = get_fuse_conn(inode);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400204 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700205 if (IS_ERR(req))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700206 return 0;
207
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100208 forget = fuse_alloc_forget();
209 if (!forget) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800210 fuse_put_request(fc, req);
211 return 0;
212 }
213
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);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700217 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
218 &entry->d_name, &outarg);
Tejun Heob93f8582008-11-26 12:03:55 +0100219 fuse_request_send(fc, req);
Miklos Szeredie956edd2006-10-17 00:10:12 -0700220 dput(parent);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700221 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800222 fuse_put_request(fc, req);
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800223 /* Zero nodeid is same as -ENOENT */
224 if (!err && !outarg.nodeid)
225 err = -ENOENT;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700226 if (!err) {
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800227 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700228 if (outarg.nodeid != get_node_id(inode)) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100229 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700230 return 0;
231 }
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700232 spin_lock(&fc->lock);
Miklos Szeredi1729a162008-11-26 12:03:54 +0100233 fi->nlookup++;
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700234 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700235 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100236 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700237 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700238 return 0;
239
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700240 fuse_change_attributes(inode, &outarg.attr,
241 entry_attr_timeout(&outarg),
242 attr_version);
243 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700244 }
Feng Shuo4582a4a2013-01-15 11:23:28 +0800245 fuse_advise_use_readdirplus(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700246 return 1;
247}
248
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800249static int invalid_nodeid(u64 nodeid)
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800250{
251 return !nodeid || nodeid == FUSE_ROOT_ID;
252}
253
Al Viro42695902009-02-20 05:59:13 +0000254const struct dentry_operations fuse_dentry_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700255 .d_revalidate = fuse_dentry_revalidate,
256};
257
Timo Savolaa5bfffac2007-04-08 16:04:00 -0700258int fuse_valid_type(int m)
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800259{
260 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
261 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
262}
263
Miklos Szeredid2a85162006-10-17 00:10:11 -0700264/*
265 * Add a directory inode to a dentry, ensuring that no other dentry
266 * refers to this inode. Called with fc->inst_mutex.
267 */
Miklos Szeredi0de62562008-07-25 01:48:59 -0700268static struct dentry *fuse_d_add_directory(struct dentry *entry,
269 struct inode *inode)
Miklos Szeredid2a85162006-10-17 00:10:11 -0700270{
271 struct dentry *alias = d_find_alias(inode);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700272 if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
Miklos Szeredid2a85162006-10-17 00:10:11 -0700273 /* This tries to shrink the subtree below alias */
274 fuse_invalidate_entry(alias);
275 dput(alias);
Al Virob3d9b7a2012-06-09 13:51:19 -0400276 if (!hlist_empty(&inode->i_dentry))
Miklos Szeredi0de62562008-07-25 01:48:59 -0700277 return ERR_PTR(-EBUSY);
278 } else {
279 dput(alias);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700280 }
Miklos Szeredi0de62562008-07-25 01:48:59 -0700281 return d_splice_alias(inode, entry);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700282}
283
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700284int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
285 struct fuse_entry_out *outarg, struct inode **inode)
286{
287 struct fuse_conn *fc = get_fuse_conn_super(sb);
288 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100289 struct fuse_forget_link *forget;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700290 u64 attr_version;
291 int err;
292
293 *inode = NULL;
294 err = -ENAMETOOLONG;
295 if (name->len > FUSE_NAME_MAX)
296 goto out;
297
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400298 req = fuse_get_req_nopages(fc);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700299 err = PTR_ERR(req);
300 if (IS_ERR(req))
301 goto out;
302
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100303 forget = fuse_alloc_forget();
304 err = -ENOMEM;
305 if (!forget) {
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700306 fuse_put_request(fc, req);
307 goto out;
308 }
309
310 attr_version = fuse_get_attr_version(fc);
311
312 fuse_lookup_init(fc, req, nodeid, name, outarg);
Tejun Heob93f8582008-11-26 12:03:55 +0100313 fuse_request_send(fc, req);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700314 err = req->out.h.error;
315 fuse_put_request(fc, req);
316 /* Zero nodeid is same as -ENOENT, but with valid timeout */
317 if (err || !outarg->nodeid)
318 goto out_put_forget;
319
320 err = -EIO;
321 if (!outarg->nodeid)
322 goto out_put_forget;
323 if (!fuse_valid_type(outarg->attr.mode))
324 goto out_put_forget;
325
326 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
327 &outarg->attr, entry_attr_timeout(outarg),
328 attr_version);
329 err = -ENOMEM;
330 if (!*inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100331 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700332 goto out;
333 }
334 err = 0;
335
336 out_put_forget:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100337 kfree(forget);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700338 out:
339 return err;
340}
341
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800342static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400343 unsigned int flags)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700344{
345 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700346 struct fuse_entry_out outarg;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700347 struct inode *inode;
Miklos Szeredi0de62562008-07-25 01:48:59 -0700348 struct dentry *newent;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700349 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700350 bool outarg_valid = true;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700351
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700352 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
353 &outarg, &inode);
354 if (err == -ENOENT) {
355 outarg_valid = false;
356 err = 0;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800357 }
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700358 if (err)
359 goto out_err;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800360
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700361 err = -EIO;
362 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
363 goto out_iput;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700364
Miklos Szeredid2a85162006-10-17 00:10:11 -0700365 if (inode && S_ISDIR(inode->i_mode)) {
366 mutex_lock(&fc->inst_mutex);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700367 newent = fuse_d_add_directory(entry, inode);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700368 mutex_unlock(&fc->inst_mutex);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700369 err = PTR_ERR(newent);
370 if (IS_ERR(newent))
371 goto out_iput;
372 } else {
Miklos Szeredi0de62562008-07-25 01:48:59 -0700373 newent = d_splice_alias(inode, entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700374 }
Miklos Szeredid2a85162006-10-17 00:10:11 -0700375
Miklos Szeredi0de62562008-07-25 01:48:59 -0700376 entry = newent ? newent : entry;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700377 if (outarg_valid)
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700378 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800379 else
380 fuse_invalidate_entry_cache(entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700381
Feng Shuo4582a4a2013-01-15 11:23:28 +0800382 fuse_advise_use_readdirplus(dir);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700383 return newent;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700384
385 out_iput:
386 iput(inode);
387 out_err:
388 return ERR_PTR(err);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700389}
390
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800391/*
392 * Atomic create+open operation
393 *
394 * If the filesystem doesn't support this, then fall back to separate
395 * 'mknod' + 'open' requests.
396 */
Al Virod9585272012-06-22 12:39:14 +0400397static int fuse_create_open(struct inode *dir, struct dentry *entry,
Al Viro30d90492012-06-22 12:40:19 +0400398 struct file *file, unsigned flags,
Al Virod9585272012-06-22 12:39:14 +0400399 umode_t mode, int *opened)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800400{
401 int err;
402 struct inode *inode;
403 struct fuse_conn *fc = get_fuse_conn(dir);
404 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100405 struct fuse_forget_link *forget;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200406 struct fuse_create_in inarg;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800407 struct fuse_open_out outopen;
408 struct fuse_entry_out outentry;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800409 struct fuse_file *ff;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800410
Miklos Szerediaf109bc2012-08-15 13:01:24 +0200411 /* Userspace expects S_IFREG in create mode */
412 BUG_ON((mode & S_IFMT) != S_IFREG);
413
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100414 forget = fuse_alloc_forget();
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200415 err = -ENOMEM;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100416 if (!forget)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200417 goto out_err;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700418
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400419 req = fuse_get_req_nopages(fc);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700420 err = PTR_ERR(req);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700421 if (IS_ERR(req))
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700422 goto out_put_forget_req;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800423
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700424 err = -ENOMEM;
Tejun Heoacf99432008-11-26 12:03:55 +0100425 ff = fuse_file_alloc(fc);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800426 if (!ff)
427 goto out_put_request;
428
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200429 if (!fc->dont_mask)
430 mode &= ~current_umask();
431
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800432 flags &= ~O_NOCTTY;
433 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700434 memset(&outentry, 0, sizeof(outentry));
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800435 inarg.flags = flags;
436 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200437 inarg.umask = current_umask();
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800438 req->in.h.opcode = FUSE_CREATE;
439 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800440 req->in.numargs = 2;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200441 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
442 sizeof(inarg);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800443 req->in.args[0].value = &inarg;
444 req->in.args[1].size = entry->d_name.len + 1;
445 req->in.args[1].value = entry->d_name.name;
446 req->out.numargs = 2;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700447 if (fc->minor < 9)
448 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
449 else
450 req->out.args[0].size = sizeof(outentry);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800451 req->out.args[0].value = &outentry;
452 req->out.args[1].size = sizeof(outopen);
453 req->out.args[1].value = &outopen;
Tejun Heob93f8582008-11-26 12:03:55 +0100454 fuse_request_send(fc, req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800455 err = req->out.h.error;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200456 if (err)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800457 goto out_free_ff;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800458
459 err = -EIO;
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800460 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800461 goto out_free_ff;
462
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700463 fuse_put_request(fc, req);
Miklos Szeredic7b71432009-04-28 16:56:37 +0200464 ff->fh = outopen.fh;
465 ff->nodeid = outentry.nodeid;
466 ff->open_flags = outopen.open_flags;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800467 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700468 &outentry.attr, entry_attr_timeout(&outentry), 0);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800469 if (!inode) {
470 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200471 fuse_sync_release(ff, flags);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100472 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200473 err = -ENOMEM;
474 goto out_err;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800475 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100476 kfree(forget);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800477 d_instantiate(entry, inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700478 fuse_change_entry_timeout(entry, &outentry);
Miklos Szeredi0952b2a2008-02-06 01:38:38 -0800479 fuse_invalidate_attr(dir);
Al Viro30d90492012-06-22 12:40:19 +0400480 err = finish_open(file, entry, generic_file_open, opened);
481 if (err) {
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200482 fuse_sync_release(ff, flags);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200483 } else {
484 file->private_data = fuse_file_get(ff);
485 fuse_finish_open(inode, file);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800486 }
Al Virod9585272012-06-22 12:39:14 +0400487 return err;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800488
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200489out_free_ff:
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800490 fuse_file_free(ff);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200491out_put_request:
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800492 fuse_put_request(fc, req);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200493out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100494 kfree(forget);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200495out_err:
Al Virod9585272012-06-22 12:39:14 +0400496 return err;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200497}
498
499static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
Al Virod9585272012-06-22 12:39:14 +0400500static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
Al Viro30d90492012-06-22 12:40:19 +0400501 struct file *file, unsigned flags,
Al Virod9585272012-06-22 12:39:14 +0400502 umode_t mode, int *opened)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200503{
504 int err;
505 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200506 struct dentry *res = NULL;
507
508 if (d_unhashed(entry)) {
Al Viro00cd8dd2012-06-10 17:13:09 -0400509 res = fuse_lookup(dir, entry, 0);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200510 if (IS_ERR(res))
Al Virod9585272012-06-22 12:39:14 +0400511 return PTR_ERR(res);
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200512
513 if (res)
514 entry = res;
515 }
516
517 if (!(flags & O_CREAT) || entry->d_inode)
518 goto no_open;
519
520 /* Only creates */
Al Viro47237682012-06-10 05:01:45 -0400521 *opened |= FILE_CREATED;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200522
523 if (fc->no_create)
524 goto mknod;
525
Al Viro30d90492012-06-22 12:40:19 +0400526 err = fuse_create_open(dir, entry, file, flags, mode, opened);
Al Virod9585272012-06-22 12:39:14 +0400527 if (err == -ENOSYS) {
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200528 fc->no_create = 1;
529 goto mknod;
530 }
531out_dput:
532 dput(res);
Al Virod9585272012-06-22 12:39:14 +0400533 return err;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200534
535mknod:
536 err = fuse_mknod(dir, entry, mode, 0);
Al Virod9585272012-06-22 12:39:14 +0400537 if (err)
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200538 goto out_dput;
Miklos Szeredic8ccbe02012-06-05 15:10:22 +0200539no_open:
Al Viroe45198a2012-06-10 06:48:09 -0400540 return finish_no_open(file, res);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800541}
542
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800543/*
544 * Code shared between mknod, mkdir, symlink and link
545 */
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700546static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
547 struct inode *dir, struct dentry *entry,
Al Viro541af6a2011-07-26 03:17:33 -0400548 umode_t mode)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700549{
550 struct fuse_entry_out outarg;
551 struct inode *inode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700552 int err;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100553 struct fuse_forget_link *forget;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800554
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100555 forget = fuse_alloc_forget();
556 if (!forget) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800557 fuse_put_request(fc, req);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100558 return -ENOMEM;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800559 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700560
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700561 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700562 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700563 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700564 if (fc->minor < 9)
565 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
566 else
567 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700568 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100569 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700570 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800571 fuse_put_request(fc, req);
572 if (err)
573 goto out_put_forget_req;
574
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800575 err = -EIO;
576 if (invalid_nodeid(outarg.nodeid))
Miklos Szeredi2d510132006-11-25 11:09:20 -0800577 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800578
579 if ((outarg.attr.mode ^ mode) & S_IFMT)
Miklos Szeredi2d510132006-11-25 11:09:20 -0800580 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800581
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700582 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700583 &outarg.attr, entry_attr_timeout(&outarg), 0);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700584 if (!inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100585 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700586 return -ENOMEM;
587 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100588 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700589
Miklos Szeredid2a85162006-10-17 00:10:11 -0700590 if (S_ISDIR(inode->i_mode)) {
591 struct dentry *alias;
592 mutex_lock(&fc->inst_mutex);
593 alias = d_find_alias(inode);
594 if (alias) {
595 /* New directory must have moved since mkdir */
596 mutex_unlock(&fc->inst_mutex);
597 dput(alias);
598 iput(inode);
599 return -EBUSY;
600 }
601 d_instantiate(entry, inode);
602 mutex_unlock(&fc->inst_mutex);
603 } else
604 d_instantiate(entry, inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700605
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700606 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700607 fuse_invalidate_attr(dir);
608 return 0;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800609
Miklos Szeredi2d510132006-11-25 11:09:20 -0800610 out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100611 kfree(forget);
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800612 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700613}
614
Al Viro1a67aaf2011-07-26 01:52:52 -0400615static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700616 dev_t rdev)
617{
618 struct fuse_mknod_in inarg;
619 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400620 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700621 if (IS_ERR(req))
622 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700623
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200624 if (!fc->dont_mask)
625 mode &= ~current_umask();
626
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700627 memset(&inarg, 0, sizeof(inarg));
628 inarg.mode = mode;
629 inarg.rdev = new_encode_dev(rdev);
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200630 inarg.umask = current_umask();
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700631 req->in.h.opcode = FUSE_MKNOD;
632 req->in.numargs = 2;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200633 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
634 sizeof(inarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700635 req->in.args[0].value = &inarg;
636 req->in.args[1].size = entry->d_name.len + 1;
637 req->in.args[1].value = entry->d_name.name;
638 return create_new_entry(fc, req, dir, entry, mode);
639}
640
Al Viro4acdaf22011-07-26 01:42:34 -0400641static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400642 bool excl)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700643{
644 return fuse_mknod(dir, entry, mode, 0);
645}
646
Al Viro18bb1db2011-07-26 01:41:39 -0400647static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700648{
649 struct fuse_mkdir_in inarg;
650 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400651 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700652 if (IS_ERR(req))
653 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700654
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200655 if (!fc->dont_mask)
656 mode &= ~current_umask();
657
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700658 memset(&inarg, 0, sizeof(inarg));
659 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200660 inarg.umask = current_umask();
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700661 req->in.h.opcode = FUSE_MKDIR;
662 req->in.numargs = 2;
663 req->in.args[0].size = sizeof(inarg);
664 req->in.args[0].value = &inarg;
665 req->in.args[1].size = entry->d_name.len + 1;
666 req->in.args[1].value = entry->d_name.name;
667 return create_new_entry(fc, req, dir, entry, S_IFDIR);
668}
669
670static int fuse_symlink(struct inode *dir, struct dentry *entry,
671 const char *link)
672{
673 struct fuse_conn *fc = get_fuse_conn(dir);
674 unsigned len = strlen(link) + 1;
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400675 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700676 if (IS_ERR(req))
677 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700678
679 req->in.h.opcode = FUSE_SYMLINK;
680 req->in.numargs = 2;
681 req->in.args[0].size = entry->d_name.len + 1;
682 req->in.args[0].value = entry->d_name.name;
683 req->in.args[1].size = len;
684 req->in.args[1].value = link;
685 return create_new_entry(fc, req, dir, entry, S_IFLNK);
686}
687
688static 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);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700722 } else if (err == -EINTR)
723 fuse_invalidate_entry(entry);
724 return err;
725}
726
727static int fuse_rmdir(struct inode *dir, struct dentry *entry)
728{
729 int err;
730 struct fuse_conn *fc = get_fuse_conn(dir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400731 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700732 if (IS_ERR(req))
733 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700734
735 req->in.h.opcode = FUSE_RMDIR;
736 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700737 req->in.numargs = 1;
738 req->in.args[0].size = entry->d_name.len + 1;
739 req->in.args[0].value = entry->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100740 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700741 err = req->out.h.error;
742 fuse_put_request(fc, req);
743 if (!err) {
Dave Hansence71ec32006-09-30 23:29:06 -0700744 clear_nlink(entry->d_inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700745 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800746 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700747 } else if (err == -EINTR)
748 fuse_invalidate_entry(entry);
749 return err;
750}
751
752static int fuse_rename(struct inode *olddir, struct dentry *oldent,
753 struct inode *newdir, struct dentry *newent)
754{
755 int err;
756 struct fuse_rename_in inarg;
757 struct fuse_conn *fc = get_fuse_conn(olddir);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400758 struct fuse_req *req = fuse_get_req_nopages(fc);
Sage Weile4eaac02011-05-24 13:06:07 -0700759
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700760 if (IS_ERR(req))
761 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700762
763 memset(&inarg, 0, sizeof(inarg));
764 inarg.newdir = get_node_id(newdir);
765 req->in.h.opcode = FUSE_RENAME;
766 req->in.h.nodeid = get_node_id(olddir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700767 req->in.numargs = 3;
768 req->in.args[0].size = sizeof(inarg);
769 req->in.args[0].value = &inarg;
770 req->in.args[1].size = oldent->d_name.len + 1;
771 req->in.args[1].value = oldent->d_name.name;
772 req->in.args[2].size = newent->d_name.len + 1;
773 req->in.args[2].value = newent->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100774 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700775 err = req->out.h.error;
776 fuse_put_request(fc, req);
777 if (!err) {
Miklos Szeredi08b63302007-11-28 16:22:03 -0800778 /* ctime changes */
779 fuse_invalidate_attr(oldent->d_inode);
780
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700781 fuse_invalidate_attr(olddir);
782 if (olddir != newdir)
783 fuse_invalidate_attr(newdir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800784
785 /* newent will end up negative */
Miklos Szeredi5219f342009-11-04 10:24:52 +0100786 if (newent->d_inode) {
787 fuse_invalidate_attr(newent->d_inode);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800788 fuse_invalidate_entry_cache(newent);
Miklos Szeredi5219f342009-11-04 10:24:52 +0100789 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700790 } else if (err == -EINTR) {
791 /* If request was interrupted, DEITY only knows if the
792 rename actually took place. If the invalidation
793 fails (e.g. some process has CWD under the renamed
794 directory), then there can be inconsistency between
795 the dcache and the real filesystem. Tough luck. */
796 fuse_invalidate_entry(oldent);
797 if (newent->d_inode)
798 fuse_invalidate_entry(newent);
799 }
800
801 return err;
802}
803
804static int fuse_link(struct dentry *entry, struct inode *newdir,
805 struct dentry *newent)
806{
807 int err;
808 struct fuse_link_in inarg;
809 struct inode *inode = entry->d_inode;
810 struct fuse_conn *fc = get_fuse_conn(inode);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400811 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700812 if (IS_ERR(req))
813 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700814
815 memset(&inarg, 0, sizeof(inarg));
816 inarg.oldnodeid = get_node_id(inode);
817 req->in.h.opcode = FUSE_LINK;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700818 req->in.numargs = 2;
819 req->in.args[0].size = sizeof(inarg);
820 req->in.args[0].value = &inarg;
821 req->in.args[1].size = newent->d_name.len + 1;
822 req->in.args[1].value = newent->d_name.name;
823 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
824 /* Contrary to "normal" filesystems it can happen that link
825 makes two "logical" inodes point to the same "physical"
826 inode. We invalidate the attributes of the old one, so it
827 will reflect changes in the backing inode (link count,
828 etc.)
829 */
Miklos Szerediac45d612012-03-05 15:48:11 +0100830 if (!err) {
831 struct fuse_inode *fi = get_fuse_inode(inode);
832
833 spin_lock(&fc->lock);
834 fi->attr_version = ++fc->attr_version;
835 inc_nlink(inode);
836 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700837 fuse_invalidate_attr(inode);
Miklos Szerediac45d612012-03-05 15:48:11 +0100838 } else if (err == -EINTR) {
839 fuse_invalidate_attr(inode);
840 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700841 return err;
842}
843
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700844static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
845 struct kstat *stat)
846{
Miklos Szeredi203627b2012-05-10 19:49:38 +0400847 unsigned int blkbits;
848
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700849 stat->dev = inode->i_sb->s_dev;
850 stat->ino = attr->ino;
851 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
852 stat->nlink = attr->nlink;
Eric W. Biederman499dcf22012-02-07 16:26:03 -0800853 stat->uid = make_kuid(&init_user_ns, attr->uid);
854 stat->gid = make_kgid(&init_user_ns, attr->gid);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700855 stat->rdev = inode->i_rdev;
856 stat->atime.tv_sec = attr->atime;
857 stat->atime.tv_nsec = attr->atimensec;
858 stat->mtime.tv_sec = attr->mtime;
859 stat->mtime.tv_nsec = attr->mtimensec;
860 stat->ctime.tv_sec = attr->ctime;
861 stat->ctime.tv_nsec = attr->ctimensec;
862 stat->size = attr->size;
863 stat->blocks = attr->blocks;
Miklos Szeredi203627b2012-05-10 19:49:38 +0400864
865 if (attr->blksize != 0)
866 blkbits = ilog2(attr->blksize);
867 else
868 blkbits = inode->i_sb->s_blocksize_bits;
869
870 stat->blksize = 1 << blkbits;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700871}
872
Miklos Szeredic79e3222007-10-18 03:06:59 -0700873static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
874 struct file *file)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700875{
876 int err;
Miklos Szeredic79e3222007-10-18 03:06:59 -0700877 struct fuse_getattr_in inarg;
878 struct fuse_attr_out outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700879 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700880 struct fuse_req *req;
881 u64 attr_version;
882
Maxim Patlasovb111c8c2012-10-26 19:48:30 +0400883 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700884 if (IS_ERR(req))
885 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700886
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800887 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700888
Miklos Szeredic79e3222007-10-18 03:06:59 -0700889 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700890 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredic79e3222007-10-18 03:06:59 -0700891 /* Directories have separate file-handle space */
892 if (file && S_ISREG(inode->i_mode)) {
893 struct fuse_file *ff = file->private_data;
894
895 inarg.getattr_flags |= FUSE_GETATTR_FH;
896 inarg.fh = ff->fh;
897 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700898 req->in.h.opcode = FUSE_GETATTR;
899 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700900 req->in.numargs = 1;
901 req->in.args[0].size = sizeof(inarg);
902 req->in.args[0].value = &inarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700903 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700904 if (fc->minor < 9)
905 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
906 else
907 req->out.args[0].size = sizeof(outarg);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700908 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100909 fuse_request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700910 err = req->out.h.error;
911 fuse_put_request(fc, req);
912 if (!err) {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700913 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700914 make_bad_inode(inode);
915 err = -EIO;
916 } else {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700917 fuse_change_attributes(inode, &outarg.attr,
918 attr_timeout(&outarg),
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700919 attr_version);
920 if (stat)
Miklos Szeredic79e3222007-10-18 03:06:59 -0700921 fuse_fillattr(inode, &outarg.attr, stat);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700922 }
923 }
924 return err;
925}
926
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800927int fuse_update_attributes(struct inode *inode, struct kstat *stat,
928 struct file *file, bool *refreshed)
929{
930 struct fuse_inode *fi = get_fuse_inode(inode);
931 int err;
932 bool r;
933
934 if (fi->i_time < get_jiffies_64()) {
935 r = true;
936 err = fuse_do_getattr(inode, stat, file);
937 } else {
938 r = false;
939 err = 0;
940 if (stat) {
941 generic_fillattr(inode, stat);
942 stat->mode = fi->orig_i_mode;
Pavel Shilovsky45c72cd2012-05-10 19:49:38 +0400943 stat->ino = fi->orig_ino;
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800944 }
945 }
946
947 if (refreshed != NULL)
948 *refreshed = r;
949
950 return err;
951}
952
John Muir3b463ae2009-05-31 11:13:57 -0400953int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
John Muir451d0f52011-12-06 21:50:06 +0100954 u64 child_nodeid, struct qstr *name)
John Muir3b463ae2009-05-31 11:13:57 -0400955{
956 int err = -ENOTDIR;
957 struct inode *parent;
958 struct dentry *dir;
959 struct dentry *entry;
960
961 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
962 if (!parent)
963 return -ENOENT;
964
965 mutex_lock(&parent->i_mutex);
966 if (!S_ISDIR(parent->i_mode))
967 goto unlock;
968
969 err = -ENOENT;
970 dir = d_find_alias(parent);
971 if (!dir)
972 goto unlock;
973
974 entry = d_lookup(dir, name);
975 dput(dir);
976 if (!entry)
977 goto unlock;
978
979 fuse_invalidate_attr(parent);
980 fuse_invalidate_entry(entry);
John Muir451d0f52011-12-06 21:50:06 +0100981
982 if (child_nodeid != 0 && entry->d_inode) {
983 mutex_lock(&entry->d_inode->i_mutex);
984 if (get_node_id(entry->d_inode) != child_nodeid) {
985 err = -ENOENT;
986 goto badentry;
987 }
988 if (d_mountpoint(entry)) {
989 err = -EBUSY;
990 goto badentry;
991 }
992 if (S_ISDIR(entry->d_inode->i_mode)) {
993 shrink_dcache_parent(entry);
994 if (!simple_empty(entry)) {
995 err = -ENOTEMPTY;
996 goto badentry;
997 }
998 entry->d_inode->i_flags |= S_DEAD;
999 }
1000 dont_mount(entry);
1001 clear_nlink(entry->d_inode);
1002 err = 0;
1003 badentry:
1004 mutex_unlock(&entry->d_inode->i_mutex);
1005 if (!err)
1006 d_delete(entry);
1007 } else {
1008 err = 0;
1009 }
John Muir3b463ae2009-05-31 11:13:57 -04001010 dput(entry);
John Muir3b463ae2009-05-31 11:13:57 -04001011
1012 unlock:
1013 mutex_unlock(&parent->i_mutex);
1014 iput(parent);
1015 return err;
1016}
1017
Miklos Szeredi87729a52005-09-09 13:10:34 -07001018/*
1019 * Calling into a user-controlled filesystem gives the filesystem
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001020 * daemon ptrace-like capabilities over the current process. This
Miklos Szeredi87729a52005-09-09 13:10:34 -07001021 * means, that the filesystem daemon is able to record the exact
1022 * filesystem operations performed, and can also control the behavior
1023 * of the requester process in otherwise impossible ways. For example
1024 * it can delay the operation for arbitrary length of time allowing
1025 * DoS against the requester.
1026 *
1027 * For this reason only those processes can call into the filesystem,
1028 * for which the owner of the mount has ptrace privilege. This
1029 * excludes processes started by other users, suid or sgid processes.
1030 */
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001031int fuse_allow_current_process(struct fuse_conn *fc)
Miklos Szeredi87729a52005-09-09 13:10:34 -07001032{
David Howellsc69e8d92008-11-14 10:39:19 +11001033 const struct cred *cred;
David Howellsc69e8d92008-11-14 10:39:19 +11001034
Miklos Szeredi87729a52005-09-09 13:10:34 -07001035 if (fc->flags & FUSE_ALLOW_OTHER)
1036 return 1;
1037
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001038 cred = current_cred();
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001039 if (uid_eq(cred->euid, fc->user_id) &&
1040 uid_eq(cred->suid, fc->user_id) &&
1041 uid_eq(cred->uid, fc->user_id) &&
1042 gid_eq(cred->egid, fc->group_id) &&
1043 gid_eq(cred->sgid, fc->group_id) &&
1044 gid_eq(cred->gid, fc->group_id))
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001045 return 1;
Miklos Szeredi87729a52005-09-09 13:10:34 -07001046
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001047 return 0;
Miklos Szeredi87729a52005-09-09 13:10:34 -07001048}
1049
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001050static int fuse_access(struct inode *inode, int mask)
1051{
1052 struct fuse_conn *fc = get_fuse_conn(inode);
1053 struct fuse_req *req;
1054 struct fuse_access_in inarg;
1055 int err;
1056
1057 if (fc->no_access)
1058 return 0;
1059
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001060 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001061 if (IS_ERR(req))
1062 return PTR_ERR(req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001063
1064 memset(&inarg, 0, sizeof(inarg));
Al Viroe6305c42008-07-15 21:03:57 -04001065 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001066 req->in.h.opcode = FUSE_ACCESS;
1067 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001068 req->in.numargs = 1;
1069 req->in.args[0].size = sizeof(inarg);
1070 req->in.args[0].value = &inarg;
Tejun Heob93f8582008-11-26 12:03:55 +01001071 fuse_request_send(fc, req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -08001072 err = req->out.h.error;
1073 fuse_put_request(fc, req);
1074 if (err == -ENOSYS) {
1075 fc->no_access = 1;
1076 err = 0;
1077 }
1078 return err;
1079}
1080
Al Viro10556cb2011-06-20 19:28:19 -04001081static int fuse_perm_getattr(struct inode *inode, int mask)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001082{
Al Viro10556cb2011-06-20 19:28:19 -04001083 if (mask & MAY_NOT_BLOCK)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001084 return -ECHILD;
1085
1086 return fuse_do_getattr(inode, NULL, NULL);
1087}
1088
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001089/*
1090 * Check permission. The two basic access models of FUSE are:
1091 *
1092 * 1) Local access checking ('default_permissions' mount option) based
1093 * on file mode. This is the plain old disk filesystem permission
1094 * modell.
1095 *
1096 * 2) "Remote" access checking, where server is responsible for
1097 * checking permission in each inode operation. An exception to this
1098 * is if ->permission() was invoked from sys_access() in which case an
1099 * access request is sent. Execute permission is still checked
1100 * locally based on file mode.
1101 */
Al Viro10556cb2011-06-20 19:28:19 -04001102static int fuse_permission(struct inode *inode, int mask)
Miklos Szeredie5e55582005-09-09 13:10:28 -07001103{
1104 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001105 bool refreshed = false;
1106 int err = 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001107
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001108 if (!fuse_allow_current_process(fc))
Miklos Szeredie5e55582005-09-09 13:10:28 -07001109 return -EACCES;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001110
1111 /*
Miklos Szeredie8e96152007-10-16 23:31:06 -07001112 * If attributes are needed, refresh them before proceeding
Miklos Szeredi244f6382007-10-16 23:31:02 -07001113 */
Miklos Szeredie8e96152007-10-16 23:31:06 -07001114 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1115 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001116 struct fuse_inode *fi = get_fuse_inode(inode);
1117
1118 if (fi->i_time < get_jiffies_64()) {
1119 refreshed = true;
1120
Al Viro10556cb2011-06-20 19:28:19 -04001121 err = fuse_perm_getattr(inode, mask);
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001122 if (err)
1123 return err;
1124 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001125 }
1126
1127 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
Al Viro2830ba72011-06-20 19:16:29 -04001128 err = generic_permission(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001129
1130 /* If permission is denied, try to refresh file
1131 attributes. This is also needed, because the root
1132 node will at first have no permissions */
Miklos Szeredi244f6382007-10-16 23:31:02 -07001133 if (err == -EACCES && !refreshed) {
Al Viro10556cb2011-06-20 19:28:19 -04001134 err = fuse_perm_getattr(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001135 if (!err)
Al Viro2830ba72011-06-20 19:16:29 -04001136 err = generic_permission(inode, mask);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001137 }
1138
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001139 /* Note: the opposite of the above test does not
1140 exist. So if permissions are revoked this won't be
1141 noticed immediately, only after the attribute
1142 timeout has expired */
Eric Paris9cfcac82010-07-23 11:43:51 -04001143 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
Al Viro10556cb2011-06-20 19:28:19 -04001144 if (mask & MAY_NOT_BLOCK)
Miklos Szeredi19690dd2011-03-21 13:58:06 +01001145 return -ECHILD;
1146
Miklos Szeredie8e96152007-10-16 23:31:06 -07001147 err = fuse_access(inode, mask);
1148 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1149 if (!(inode->i_mode & S_IXUGO)) {
1150 if (refreshed)
1151 return -EACCES;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001152
Al Viro10556cb2011-06-20 19:28:19 -04001153 err = fuse_perm_getattr(inode, mask);
Miklos Szeredie8e96152007-10-16 23:31:06 -07001154 if (!err && !(inode->i_mode & S_IXUGO))
1155 return -EACCES;
1156 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001157 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001158 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001159}
1160
1161static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1162 void *dstbuf, filldir_t filldir)
1163{
1164 while (nbytes >= FUSE_NAME_OFFSET) {
1165 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1166 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1167 int over;
1168 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1169 return -EIO;
1170 if (reclen > nbytes)
1171 break;
1172
1173 over = filldir(dstbuf, dirent->name, dirent->namelen,
1174 file->f_pos, dirent->ino, dirent->type);
1175 if (over)
1176 break;
1177
1178 buf += reclen;
1179 nbytes -= reclen;
1180 file->f_pos = dirent->off;
1181 }
1182
1183 return 0;
1184}
1185
Anand V. Avati0b05b182012-08-19 08:53:23 -04001186static int fuse_direntplus_link(struct file *file,
1187 struct fuse_direntplus *direntplus,
1188 u64 attr_version)
1189{
1190 int err;
1191 struct fuse_entry_out *o = &direntplus->entry_out;
1192 struct fuse_dirent *dirent = &direntplus->dirent;
1193 struct dentry *parent = file->f_path.dentry;
1194 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1195 struct dentry *dentry;
1196 struct dentry *alias;
1197 struct inode *dir = parent->d_inode;
1198 struct fuse_conn *fc;
1199 struct inode *inode;
1200
1201 if (!o->nodeid) {
1202 /*
1203 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1204 * ENOENT. Instead, it only means the userspace filesystem did
1205 * not want to return attributes/handle for this entry.
1206 *
1207 * So do nothing.
1208 */
1209 return 0;
1210 }
1211
1212 if (name.name[0] == '.') {
1213 /*
1214 * We could potentially refresh the attributes of the directory
1215 * and its parent?
1216 */
1217 if (name.len == 1)
1218 return 0;
1219 if (name.name[1] == '.' && name.len == 2)
1220 return 0;
1221 }
1222 fc = get_fuse_conn(dir);
1223
1224 name.hash = full_name_hash(name.name, name.len);
1225 dentry = d_lookup(parent, &name);
1226 if (dentry && dentry->d_inode) {
1227 inode = dentry->d_inode;
1228 if (get_node_id(inode) == o->nodeid) {
1229 struct fuse_inode *fi;
1230 fi = get_fuse_inode(inode);
1231 spin_lock(&fc->lock);
1232 fi->nlookup++;
1233 spin_unlock(&fc->lock);
1234
1235 /*
1236 * The other branch to 'found' comes via fuse_iget()
1237 * which bumps nlookup inside
1238 */
1239 goto found;
1240 }
1241 err = d_invalidate(dentry);
1242 if (err)
1243 goto out;
1244 dput(dentry);
1245 dentry = NULL;
1246 }
1247
1248 dentry = d_alloc(parent, &name);
1249 err = -ENOMEM;
1250 if (!dentry)
1251 goto out;
1252
1253 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1254 &o->attr, entry_attr_timeout(o), attr_version);
1255 if (!inode)
1256 goto out;
1257
1258 alias = d_materialise_unique(dentry, inode);
1259 err = PTR_ERR(alias);
1260 if (IS_ERR(alias))
1261 goto out;
1262 if (alias) {
1263 dput(dentry);
1264 dentry = alias;
1265 }
1266
1267found:
1268 fuse_change_attributes(inode, &o->attr, entry_attr_timeout(o),
1269 attr_version);
1270
1271 fuse_change_entry_timeout(dentry, o);
1272
1273 err = 0;
1274out:
1275 if (dentry)
1276 dput(dentry);
1277 return err;
1278}
1279
1280static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1281 void *dstbuf, filldir_t filldir, u64 attr_version)
1282{
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;
1298
1299 if (!over) {
1300 /* We fill entries into dstbuf only as much as
1301 it can hold. But we still continue iterating
1302 over remaining entries to link them. If not,
1303 we need to send a FORGET for each of those
1304 which we did not link.
1305 */
1306 over = filldir(dstbuf, dirent->name, dirent->namelen,
1307 file->f_pos, dirent->ino,
1308 dirent->type);
1309 file->f_pos = dirent->off;
1310 }
1311
1312 buf += reclen;
1313 nbytes -= reclen;
1314
1315 ret = fuse_direntplus_link(file, direntplus, attr_version);
1316 if (ret)
1317 fuse_force_forget(file, direntplus->entry_out.nodeid);
1318 }
1319
1320 return 0;
1321}
1322
Miklos Szeredie5e55582005-09-09 13:10:28 -07001323static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1324{
Feng Shuo4582a4a2013-01-15 11:23:28 +08001325 int plus, err;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001326 size_t nbytes;
1327 struct page *page;
Al Viro496ad9a2013-01-23 17:07:38 -05001328 struct inode *inode = file_inode(file);
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001329 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001330 struct fuse_req *req;
Anand V. Avati0b05b182012-08-19 08:53:23 -04001331 u64 attr_version = 0;
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001332
1333 if (is_bad_inode(inode))
1334 return -EIO;
1335
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001336 req = fuse_get_req(fc, 1);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001337 if (IS_ERR(req))
1338 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001339
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001340 page = alloc_page(GFP_KERNEL);
1341 if (!page) {
1342 fuse_put_request(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001343 return -ENOMEM;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001344 }
Feng Shuo4582a4a2013-01-15 11:23:28 +08001345
1346 plus = fuse_use_readdirplus(inode, file);
Miklos Szeredif4975c62009-04-02 14:25:34 +02001347 req->out.argpages = 1;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001348 req->num_pages = 1;
1349 req->pages[0] = page;
Maxim Patlasov85f40ae2012-10-26 19:49:33 +04001350 req->page_descs[0].length = PAGE_SIZE;
Feng Shuo4582a4a2013-01-15 11:23:28 +08001351 if (plus) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001352 attr_version = fuse_get_attr_version(fc);
1353 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE,
1354 FUSE_READDIRPLUS);
1355 } else {
1356 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE,
1357 FUSE_READDIR);
1358 }
Tejun Heob93f8582008-11-26 12:03:55 +01001359 fuse_request_send(fc, req);
Miklos Szeredi361b1eb52006-01-16 22:14:45 -08001360 nbytes = req->out.args[0].size;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001361 err = req->out.h.error;
1362 fuse_put_request(fc, req);
Anand V. Avati0b05b182012-08-19 08:53:23 -04001363 if (!err) {
Feng Shuo4582a4a2013-01-15 11:23:28 +08001364 if (plus) {
Anand V. Avati0b05b182012-08-19 08:53:23 -04001365 err = parse_dirplusfile(page_address(page), nbytes,
1366 file, dstbuf, filldir,
1367 attr_version);
1368 } else {
1369 err = parse_dirfile(page_address(page), nbytes, file,
1370 dstbuf, filldir);
1371 }
1372 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001373
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001374 __free_page(page);
Miklos Szeredib36c31b2005-09-09 13:10:38 -07001375 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001376 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001377}
1378
1379static char *read_link(struct dentry *dentry)
1380{
1381 struct inode *inode = dentry->d_inode;
1382 struct fuse_conn *fc = get_fuse_conn(inode);
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001383 struct fuse_req *req = fuse_get_req_nopages(fc);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001384 char *link;
1385
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001386 if (IS_ERR(req))
David Howellse231c2e2008-02-07 00:15:26 -08001387 return ERR_CAST(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001388
1389 link = (char *) __get_free_page(GFP_KERNEL);
1390 if (!link) {
1391 link = ERR_PTR(-ENOMEM);
1392 goto out;
1393 }
1394 req->in.h.opcode = FUSE_READLINK;
1395 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001396 req->out.argvar = 1;
1397 req->out.numargs = 1;
1398 req->out.args[0].size = PAGE_SIZE - 1;
1399 req->out.args[0].value = link;
Tejun Heob93f8582008-11-26 12:03:55 +01001400 fuse_request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001401 if (req->out.h.error) {
1402 free_page((unsigned long) link);
1403 link = ERR_PTR(req->out.h.error);
1404 } else
1405 link[req->out.args[0].size] = '\0';
1406 out:
1407 fuse_put_request(fc, req);
Miklos Szeredib36c31b2005-09-09 13:10:38 -07001408 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredie5e55582005-09-09 13:10:28 -07001409 return link;
1410}
1411
1412static void free_link(char *link)
1413{
1414 if (!IS_ERR(link))
1415 free_page((unsigned long) link);
1416}
1417
1418static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1419{
1420 nd_set_link(nd, read_link(dentry));
1421 return NULL;
1422}
1423
1424static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1425{
1426 free_link(nd_get_link(nd));
1427}
1428
1429static int fuse_dir_open(struct inode *inode, struct file *file)
1430{
Miklos Szeredi91fe96b2009-04-28 16:56:37 +02001431 return fuse_open_common(inode, file, true);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001432}
1433
1434static int fuse_dir_release(struct inode *inode, struct file *file)
1435{
Miklos Szeredi8b0797a2009-04-28 16:56:39 +02001436 fuse_release_common(file, FUSE_RELEASEDIR);
1437
1438 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001439}
1440
Josef Bacik02c24a82011-07-16 20:44:56 -04001441static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1442 int datasync)
Miklos Szeredi82547982005-09-09 13:10:38 -07001443{
Josef Bacik02c24a82011-07-16 20:44:56 -04001444 return fuse_fsync_common(file, start, end, datasync, 1);
Miklos Szeredi82547982005-09-09 13:10:38 -07001445}
1446
Miklos Szeredib18da0c2011-12-13 11:58:49 +01001447static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1448 unsigned long arg)
1449{
1450 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1451
1452 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1453 if (fc->minor < 18)
1454 return -ENOTTY;
1455
1456 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1457}
1458
1459static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1460 unsigned long arg)
1461{
1462 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1463
1464 if (fc->minor < 18)
1465 return -ENOTTY;
1466
1467 return fuse_ioctl_common(file, cmd, arg,
1468 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1469}
1470
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001471static bool update_mtime(unsigned ivalid)
1472{
1473 /* Always update if mtime is explicitly set */
1474 if (ivalid & ATTR_MTIME_SET)
1475 return true;
1476
1477 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1478 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1479 return false;
1480
1481 /* In all other cases update */
1482 return true;
1483}
1484
Miklos Szeredibefc6492005-11-07 00:59:52 -08001485static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001486{
1487 unsigned ivalid = iattr->ia_valid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001488
1489 if (ivalid & ATTR_MODE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001490 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001491 if (ivalid & ATTR_UID)
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001492 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001493 if (ivalid & ATTR_GID)
Eric W. Biederman499dcf22012-02-07 16:26:03 -08001494 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001495 if (ivalid & ATTR_SIZE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001496 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001497 if (ivalid & ATTR_ATIME) {
1498 arg->valid |= FATTR_ATIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001499 arg->atime = iattr->ia_atime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001500 arg->atimensec = iattr->ia_atime.tv_nsec;
1501 if (!(ivalid & ATTR_ATIME_SET))
1502 arg->valid |= FATTR_ATIME_NOW;
1503 }
1504 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1505 arg->valid |= FATTR_MTIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001506 arg->mtime = iattr->ia_mtime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001507 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1508 if (!(ivalid & ATTR_MTIME_SET))
1509 arg->valid |= FATTR_MTIME_NOW;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001510 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001511}
1512
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001513/*
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001514 * Prevent concurrent writepages on inode
1515 *
1516 * This is done by adding a negative bias to the inode write counter
1517 * and waiting for all pending writes to finish.
1518 */
1519void fuse_set_nowrite(struct inode *inode)
1520{
1521 struct fuse_conn *fc = get_fuse_conn(inode);
1522 struct fuse_inode *fi = get_fuse_inode(inode);
1523
1524 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1525
1526 spin_lock(&fc->lock);
1527 BUG_ON(fi->writectr < 0);
1528 fi->writectr += FUSE_NOWRITE;
1529 spin_unlock(&fc->lock);
1530 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1531}
1532
1533/*
1534 * Allow writepages on inode
1535 *
1536 * Remove the bias from the writecounter and send any queued
1537 * writepages.
1538 */
1539static void __fuse_release_nowrite(struct inode *inode)
1540{
1541 struct fuse_inode *fi = get_fuse_inode(inode);
1542
1543 BUG_ON(fi->writectr != FUSE_NOWRITE);
1544 fi->writectr = 0;
1545 fuse_flush_writepages(inode);
1546}
1547
1548void fuse_release_nowrite(struct inode *inode)
1549{
1550 struct fuse_conn *fc = get_fuse_conn(inode);
1551
1552 spin_lock(&fc->lock);
1553 __fuse_release_nowrite(inode);
1554 spin_unlock(&fc->lock);
1555}
1556
1557/*
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001558 * Set attributes, and at the same time refresh them.
1559 *
1560 * Truncation is slightly complicated, because the 'truncate' request
1561 * may fail, in which case we don't want to touch the mapping.
Miklos Szeredi9ffbb912006-10-17 00:10:06 -07001562 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1563 * and the actual truncation by hand.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001564 */
Miklos Szeredi49d49142007-10-18 03:07:00 -07001565static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1566 struct file *file)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001567{
1568 struct inode *inode = entry->d_inode;
1569 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001570 struct fuse_req *req;
1571 struct fuse_setattr_in inarg;
1572 struct fuse_attr_out outarg;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001573 bool is_truncate = false;
1574 loff_t oldsize;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001575 int err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001576
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001577 if (!fuse_allow_current_process(fc))
Miklos Szeredie57ac682007-10-18 03:06:58 -07001578 return -EACCES;
1579
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001580 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1581 attr->ia_valid |= ATTR_FORCE;
1582
1583 err = inode_change_ok(inode, attr);
1584 if (err)
1585 return err;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001586
Miklos Szeredi8d56add2011-02-25 14:44:58 +01001587 if (attr->ia_valid & ATTR_OPEN) {
1588 if (fc->atomic_o_trunc)
1589 return 0;
1590 file = NULL;
1591 }
Miklos Szeredi6ff958e2007-10-18 03:07:02 -07001592
Christoph Hellwig2c27c652010-06-04 11:30:04 +02001593 if (attr->ia_valid & ATTR_SIZE)
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001594 is_truncate = true;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001595
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001596 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001597 if (IS_ERR(req))
1598 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001599
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001600 if (is_truncate)
1601 fuse_set_nowrite(inode);
1602
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001603 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001604 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredibefc6492005-11-07 00:59:52 -08001605 iattr_to_fattr(attr, &inarg);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001606 if (file) {
1607 struct fuse_file *ff = file->private_data;
1608 inarg.valid |= FATTR_FH;
1609 inarg.fh = ff->fh;
1610 }
Miklos Szeredif3332112007-10-18 03:07:04 -07001611 if (attr->ia_valid & ATTR_SIZE) {
1612 /* For mandatory locking in truncate */
1613 inarg.valid |= FATTR_LOCKOWNER;
1614 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1615 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001616 req->in.h.opcode = FUSE_SETATTR;
1617 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001618 req->in.numargs = 1;
1619 req->in.args[0].size = sizeof(inarg);
1620 req->in.args[0].value = &inarg;
1621 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001622 if (fc->minor < 9)
1623 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1624 else
1625 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001626 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +01001627 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001628 err = req->out.h.error;
1629 fuse_put_request(fc, req);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001630 if (err) {
1631 if (err == -EINTR)
1632 fuse_invalidate_attr(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001633 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001634 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001635
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001636 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1637 make_bad_inode(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001638 err = -EIO;
1639 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001640 }
1641
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001642 spin_lock(&fc->lock);
1643 fuse_change_attributes_common(inode, &outarg.attr,
1644 attr_timeout(&outarg));
1645 oldsize = inode->i_size;
1646 i_size_write(inode, outarg.attr.size);
1647
1648 if (is_truncate) {
1649 /* NOTE: this may release/reacquire fc->lock */
1650 __fuse_release_nowrite(inode);
1651 }
1652 spin_unlock(&fc->lock);
1653
1654 /*
1655 * Only call invalidate_inode_pages2() after removing
1656 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1657 */
1658 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001659 truncate_pagecache(inode, oldsize, outarg.attr.size);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001660 invalidate_inode_pages2(inode->i_mapping);
1661 }
1662
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001663 return 0;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001664
1665error:
1666 if (is_truncate)
1667 fuse_release_nowrite(inode);
1668
1669 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001670}
1671
Miklos Szeredi49d49142007-10-18 03:07:00 -07001672static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1673{
1674 if (attr->ia_valid & ATTR_FILE)
1675 return fuse_do_setattr(entry, attr, attr->ia_file);
1676 else
1677 return fuse_do_setattr(entry, attr, NULL);
1678}
1679
Miklos Szeredie5e55582005-09-09 13:10:28 -07001680static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1681 struct kstat *stat)
1682{
1683 struct inode *inode = entry->d_inode;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001684 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001685
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001686 if (!fuse_allow_current_process(fc))
Miklos Szeredi244f6382007-10-16 23:31:02 -07001687 return -EACCES;
1688
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001689 return fuse_update_attributes(inode, stat, NULL, NULL);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001690}
1691
Miklos Szeredi92a87802005-09-09 13:10:31 -07001692static int fuse_setxattr(struct dentry *entry, const char *name,
1693 const void *value, size_t size, int flags)
1694{
1695 struct inode *inode = entry->d_inode;
1696 struct fuse_conn *fc = get_fuse_conn(inode);
1697 struct fuse_req *req;
1698 struct fuse_setxattr_in inarg;
1699 int err;
1700
Miklos Szeredi92a87802005-09-09 13:10:31 -07001701 if (fc->no_setxattr)
1702 return -EOPNOTSUPP;
1703
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001704 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001705 if (IS_ERR(req))
1706 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001707
1708 memset(&inarg, 0, sizeof(inarg));
1709 inarg.size = size;
1710 inarg.flags = flags;
1711 req->in.h.opcode = FUSE_SETXATTR;
1712 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001713 req->in.numargs = 3;
1714 req->in.args[0].size = sizeof(inarg);
1715 req->in.args[0].value = &inarg;
1716 req->in.args[1].size = strlen(name) + 1;
1717 req->in.args[1].value = name;
1718 req->in.args[2].size = size;
1719 req->in.args[2].value = value;
Tejun Heob93f8582008-11-26 12:03:55 +01001720 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001721 err = req->out.h.error;
1722 fuse_put_request(fc, req);
1723 if (err == -ENOSYS) {
1724 fc->no_setxattr = 1;
1725 err = -EOPNOTSUPP;
1726 }
1727 return err;
1728}
1729
1730static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1731 void *value, size_t size)
1732{
1733 struct inode *inode = entry->d_inode;
1734 struct fuse_conn *fc = get_fuse_conn(inode);
1735 struct fuse_req *req;
1736 struct fuse_getxattr_in inarg;
1737 struct fuse_getxattr_out outarg;
1738 ssize_t ret;
1739
1740 if (fc->no_getxattr)
1741 return -EOPNOTSUPP;
1742
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001743 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001744 if (IS_ERR(req))
1745 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001746
1747 memset(&inarg, 0, sizeof(inarg));
1748 inarg.size = size;
1749 req->in.h.opcode = FUSE_GETXATTR;
1750 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001751 req->in.numargs = 2;
1752 req->in.args[0].size = sizeof(inarg);
1753 req->in.args[0].value = &inarg;
1754 req->in.args[1].size = strlen(name) + 1;
1755 req->in.args[1].value = name;
1756 /* This is really two different operations rolled into one */
1757 req->out.numargs = 1;
1758 if (size) {
1759 req->out.argvar = 1;
1760 req->out.args[0].size = size;
1761 req->out.args[0].value = value;
1762 } else {
1763 req->out.args[0].size = sizeof(outarg);
1764 req->out.args[0].value = &outarg;
1765 }
Tejun Heob93f8582008-11-26 12:03:55 +01001766 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001767 ret = req->out.h.error;
1768 if (!ret)
1769 ret = size ? req->out.args[0].size : outarg.size;
1770 else {
1771 if (ret == -ENOSYS) {
1772 fc->no_getxattr = 1;
1773 ret = -EOPNOTSUPP;
1774 }
1775 }
1776 fuse_put_request(fc, req);
1777 return ret;
1778}
1779
1780static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1781{
1782 struct inode *inode = entry->d_inode;
1783 struct fuse_conn *fc = get_fuse_conn(inode);
1784 struct fuse_req *req;
1785 struct fuse_getxattr_in inarg;
1786 struct fuse_getxattr_out outarg;
1787 ssize_t ret;
1788
Anatol Pomozovc2132c12013-01-14 22:30:00 -08001789 if (!fuse_allow_current_process(fc))
Miklos Szeredie57ac682007-10-18 03:06:58 -07001790 return -EACCES;
1791
Miklos Szeredi92a87802005-09-09 13:10:31 -07001792 if (fc->no_listxattr)
1793 return -EOPNOTSUPP;
1794
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001795 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001796 if (IS_ERR(req))
1797 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001798
1799 memset(&inarg, 0, sizeof(inarg));
1800 inarg.size = size;
1801 req->in.h.opcode = FUSE_LISTXATTR;
1802 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001803 req->in.numargs = 1;
1804 req->in.args[0].size = sizeof(inarg);
1805 req->in.args[0].value = &inarg;
1806 /* This is really two different operations rolled into one */
1807 req->out.numargs = 1;
1808 if (size) {
1809 req->out.argvar = 1;
1810 req->out.args[0].size = size;
1811 req->out.args[0].value = list;
1812 } else {
1813 req->out.args[0].size = sizeof(outarg);
1814 req->out.args[0].value = &outarg;
1815 }
Tejun Heob93f8582008-11-26 12:03:55 +01001816 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001817 ret = req->out.h.error;
1818 if (!ret)
1819 ret = size ? req->out.args[0].size : outarg.size;
1820 else {
1821 if (ret == -ENOSYS) {
1822 fc->no_listxattr = 1;
1823 ret = -EOPNOTSUPP;
1824 }
1825 }
1826 fuse_put_request(fc, req);
1827 return ret;
1828}
1829
1830static int fuse_removexattr(struct dentry *entry, const char *name)
1831{
1832 struct inode *inode = entry->d_inode;
1833 struct fuse_conn *fc = get_fuse_conn(inode);
1834 struct fuse_req *req;
1835 int err;
1836
1837 if (fc->no_removexattr)
1838 return -EOPNOTSUPP;
1839
Maxim Patlasovb111c8c2012-10-26 19:48:30 +04001840 req = fuse_get_req_nopages(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001841 if (IS_ERR(req))
1842 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001843
1844 req->in.h.opcode = FUSE_REMOVEXATTR;
1845 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001846 req->in.numargs = 1;
1847 req->in.args[0].size = strlen(name) + 1;
1848 req->in.args[0].value = name;
Tejun Heob93f8582008-11-26 12:03:55 +01001849 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001850 err = req->out.h.error;
1851 fuse_put_request(fc, req);
1852 if (err == -ENOSYS) {
1853 fc->no_removexattr = 1;
1854 err = -EOPNOTSUPP;
1855 }
1856 return err;
1857}
1858
Arjan van de Ven754661f2007-02-12 00:55:38 -08001859static const struct inode_operations fuse_dir_inode_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -07001860 .lookup = fuse_lookup,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001861 .mkdir = fuse_mkdir,
1862 .symlink = fuse_symlink,
1863 .unlink = fuse_unlink,
1864 .rmdir = fuse_rmdir,
1865 .rename = fuse_rename,
1866 .link = fuse_link,
1867 .setattr = fuse_setattr,
1868 .create = fuse_create,
Miklos Szeredic8ccbe02012-06-05 15:10:22 +02001869 .atomic_open = fuse_atomic_open,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001870 .mknod = fuse_mknod,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001871 .permission = fuse_permission,
1872 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001873 .setxattr = fuse_setxattr,
1874 .getxattr = fuse_getxattr,
1875 .listxattr = fuse_listxattr,
1876 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001877};
1878
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001879static const struct file_operations fuse_dir_operations = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001880 .llseek = generic_file_llseek,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001881 .read = generic_read_dir,
1882 .readdir = fuse_readdir,
1883 .open = fuse_dir_open,
1884 .release = fuse_dir_release,
Miklos Szeredi82547982005-09-09 13:10:38 -07001885 .fsync = fuse_dir_fsync,
Miklos Szeredib18da0c2011-12-13 11:58:49 +01001886 .unlocked_ioctl = fuse_dir_ioctl,
1887 .compat_ioctl = fuse_dir_compat_ioctl,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001888};
1889
Arjan van de Ven754661f2007-02-12 00:55:38 -08001890static const struct inode_operations fuse_common_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001891 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001892 .permission = fuse_permission,
1893 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001894 .setxattr = fuse_setxattr,
1895 .getxattr = fuse_getxattr,
1896 .listxattr = fuse_listxattr,
1897 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001898};
1899
Arjan van de Ven754661f2007-02-12 00:55:38 -08001900static const struct inode_operations fuse_symlink_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001901 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001902 .follow_link = fuse_follow_link,
1903 .put_link = fuse_put_link,
1904 .readlink = generic_readlink,
1905 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001906 .setxattr = fuse_setxattr,
1907 .getxattr = fuse_getxattr,
1908 .listxattr = fuse_listxattr,
1909 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001910};
1911
1912void fuse_init_common(struct inode *inode)
1913{
1914 inode->i_op = &fuse_common_inode_operations;
1915}
1916
1917void fuse_init_dir(struct inode *inode)
1918{
1919 inode->i_op = &fuse_dir_inode_operations;
1920 inode->i_fop = &fuse_dir_operations;
1921}
1922
1923void fuse_init_symlink(struct inode *inode)
1924{
1925 inode->i_op = &fuse_symlink_inode_operations;
1926}