blob: 6ea42e98cb1724f064f3112058ba6d0fa1a39f6b [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
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070017#if BITS_PER_LONG >= 64
18static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
19{
20 entry->d_time = time;
21}
22
23static inline u64 fuse_dentry_time(struct dentry *entry)
24{
25 return entry->d_time;
26}
27#else
28/*
29 * On 32 bit archs store the high 32 bits of time in d_fsdata
30 */
31static void fuse_dentry_settime(struct dentry *entry, u64 time)
32{
33 entry->d_time = time;
34 entry->d_fsdata = (void *) (unsigned long) (time >> 32);
35}
36
37static u64 fuse_dentry_time(struct dentry *entry)
38{
39 return (u64) entry->d_time +
40 ((u64) (unsigned long) entry->d_fsdata << 32);
41}
42#endif
43
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080044/*
45 * FUSE caches dentries and attributes with separate timeout. The
46 * time in jiffies until the dentry/attributes are valid is stored in
47 * dentry->d_time and fuse_inode->i_time respectively.
48 */
49
50/*
51 * Calculate the time in jiffies until a dentry/attributes are valid
52 */
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070053static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
Miklos Szeredie5e55582005-09-09 13:10:28 -070054{
Miklos Szeredi685d16d2006-07-30 03:04:08 -070055 if (sec || nsec) {
56 struct timespec ts = {sec, nsec};
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070057 return get_jiffies_64() + timespec_to_jiffies(&ts);
Miklos Szeredi685d16d2006-07-30 03:04:08 -070058 } else
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070059 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -070060}
61
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080062/*
63 * Set dentry and possibly attribute timeouts from the lookup/mk*
64 * replies
65 */
Miklos Szeredi1fb69e72007-10-18 03:06:58 -070066static void fuse_change_entry_timeout(struct dentry *entry,
67 struct fuse_entry_out *o)
Miklos Szeredi0aa7c692006-01-06 00:19:34 -080068{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070069 fuse_dentry_settime(entry,
70 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
Miklos Szeredi1fb69e72007-10-18 03:06:58 -070071}
72
73static u64 attr_timeout(struct fuse_attr_out *o)
74{
75 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
76}
77
78static u64 entry_attr_timeout(struct fuse_entry_out *o)
79{
80 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -080081}
82
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080083/*
84 * Mark the attributes as stale, so that at the next call to
85 * ->getattr() they will be fetched from userspace
86 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -080087void fuse_invalidate_attr(struct inode *inode)
88{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070089 get_fuse_inode(inode)->i_time = 0;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -080090}
91
Miklos Szeredi6f9f1182006-01-06 00:19:39 -080092/*
93 * Just mark the entry as stale, so that a next attempt to look it up
94 * will result in a new lookup call to userspace
95 *
96 * This is called when a dentry is about to become negative and the
97 * timeout is unknown (unlink, rmdir, rename and in some cases
98 * lookup)
99 */
Miklos Szeredidbd561d2008-07-25 01:49:00 -0700100void fuse_invalidate_entry_cache(struct dentry *entry)
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800101{
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700102 fuse_dentry_settime(entry, 0);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800103}
104
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800105/*
106 * Same as fuse_invalidate_entry_cache(), but also try to remove the
107 * dentry from the hash
108 */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800109static void fuse_invalidate_entry(struct dentry *entry)
110{
111 d_invalidate(entry);
112 fuse_invalidate_entry_cache(entry);
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800113}
114
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700115static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
116 u64 nodeid, struct qstr *name,
Miklos Szeredie5e55582005-09-09 13:10:28 -0700117 struct fuse_entry_out *outarg)
118{
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700119 memset(outarg, 0, sizeof(struct fuse_entry_out));
Miklos Szeredie5e55582005-09-09 13:10:28 -0700120 req->in.h.opcode = FUSE_LOOKUP;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700121 req->in.h.nodeid = nodeid;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700122 req->in.numargs = 1;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700123 req->in.args[0].size = name->len + 1;
124 req->in.args[0].value = name->name;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700125 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700126 if (fc->minor < 9)
127 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
128 else
129 req->out.args[0].size = sizeof(struct fuse_entry_out);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700130 req->out.args[0].value = outarg;
131}
132
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700133u64 fuse_get_attr_version(struct fuse_conn *fc)
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800134{
135 u64 curr_version;
136
137 /*
138 * The spin lock isn't actually needed on 64bit archs, but we
139 * don't yet care too much about such optimizations.
140 */
141 spin_lock(&fc->lock);
142 curr_version = fc->attr_version;
143 spin_unlock(&fc->lock);
144
145 return curr_version;
146}
147
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800148/*
149 * Check whether the dentry is still valid
150 *
151 * If the entry validity timeout has expired and the dentry is
152 * positive, try to redo the lookup. If the lookup results in a
153 * different inode, then let the VFS invalidate the dentry and redo
154 * the lookup once more. If the lookup results in the same inode,
155 * then refresh the attributes, timeouts and mark the dentry valid.
156 */
Miklos Szeredie5e55582005-09-09 13:10:28 -0700157static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
158{
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800159 struct inode *inode = entry->d_inode;
160
161 if (inode && is_bad_inode(inode))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700162 return 0;
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700163 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700164 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700165 struct fuse_entry_out outarg;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800166 struct fuse_conn *fc;
167 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100168 struct fuse_forget_link *forget;
Miklos Szeredie956edd2006-10-17 00:10:12 -0700169 struct dentry *parent;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700170 u64 attr_version;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800171
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800172 /* For negative dentries, always do a fresh lookup */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800173 if (!inode)
174 return 0;
175
176 fc = get_fuse_conn(inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700177 req = fuse_get_req(fc);
178 if (IS_ERR(req))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700179 return 0;
180
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100181 forget = fuse_alloc_forget();
182 if (!forget) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800183 fuse_put_request(fc, req);
184 return 0;
185 }
186
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800187 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700188
Miklos Szeredie956edd2006-10-17 00:10:12 -0700189 parent = dget_parent(entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700190 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
191 &entry->d_name, &outarg);
Tejun Heob93f8582008-11-26 12:03:55 +0100192 fuse_request_send(fc, req);
Miklos Szeredie956edd2006-10-17 00:10:12 -0700193 dput(parent);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700194 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800195 fuse_put_request(fc, req);
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800196 /* Zero nodeid is same as -ENOENT */
197 if (!err && !outarg.nodeid)
198 err = -ENOENT;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700199 if (!err) {
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800200 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700201 if (outarg.nodeid != get_node_id(inode)) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100202 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700203 return 0;
204 }
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700205 spin_lock(&fc->lock);
Miklos Szeredi1729a162008-11-26 12:03:54 +0100206 fi->nlookup++;
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700207 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700208 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100209 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700210 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700211 return 0;
212
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700213 fuse_change_attributes(inode, &outarg.attr,
214 entry_attr_timeout(&outarg),
215 attr_version);
216 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700217 }
218 return 1;
219}
220
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800221static int invalid_nodeid(u64 nodeid)
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800222{
223 return !nodeid || nodeid == FUSE_ROOT_ID;
224}
225
Al Viro42695902009-02-20 05:59:13 +0000226const struct dentry_operations fuse_dentry_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700227 .d_revalidate = fuse_dentry_revalidate,
228};
229
Timo Savolaa5bfffac2007-04-08 16:04:00 -0700230int fuse_valid_type(int m)
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800231{
232 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
233 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
234}
235
Miklos Szeredid2a85162006-10-17 00:10:11 -0700236/*
237 * Add a directory inode to a dentry, ensuring that no other dentry
238 * refers to this inode. Called with fc->inst_mutex.
239 */
Miklos Szeredi0de62562008-07-25 01:48:59 -0700240static struct dentry *fuse_d_add_directory(struct dentry *entry,
241 struct inode *inode)
Miklos Szeredid2a85162006-10-17 00:10:11 -0700242{
243 struct dentry *alias = d_find_alias(inode);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700244 if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
Miklos Szeredid2a85162006-10-17 00:10:11 -0700245 /* This tries to shrink the subtree below alias */
246 fuse_invalidate_entry(alias);
247 dput(alias);
248 if (!list_empty(&inode->i_dentry))
Miklos Szeredi0de62562008-07-25 01:48:59 -0700249 return ERR_PTR(-EBUSY);
250 } else {
251 dput(alias);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700252 }
Miklos Szeredi0de62562008-07-25 01:48:59 -0700253 return d_splice_alias(inode, entry);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700254}
255
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700256int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
257 struct fuse_entry_out *outarg, struct inode **inode)
258{
259 struct fuse_conn *fc = get_fuse_conn_super(sb);
260 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100261 struct fuse_forget_link *forget;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700262 u64 attr_version;
263 int err;
264
265 *inode = NULL;
266 err = -ENAMETOOLONG;
267 if (name->len > FUSE_NAME_MAX)
268 goto out;
269
270 req = fuse_get_req(fc);
271 err = PTR_ERR(req);
272 if (IS_ERR(req))
273 goto out;
274
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100275 forget = fuse_alloc_forget();
276 err = -ENOMEM;
277 if (!forget) {
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700278 fuse_put_request(fc, req);
279 goto out;
280 }
281
282 attr_version = fuse_get_attr_version(fc);
283
284 fuse_lookup_init(fc, req, nodeid, name, outarg);
Tejun Heob93f8582008-11-26 12:03:55 +0100285 fuse_request_send(fc, req);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700286 err = req->out.h.error;
287 fuse_put_request(fc, req);
288 /* Zero nodeid is same as -ENOENT, but with valid timeout */
289 if (err || !outarg->nodeid)
290 goto out_put_forget;
291
292 err = -EIO;
293 if (!outarg->nodeid)
294 goto out_put_forget;
295 if (!fuse_valid_type(outarg->attr.mode))
296 goto out_put_forget;
297
298 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
299 &outarg->attr, entry_attr_timeout(outarg),
300 attr_version);
301 err = -ENOMEM;
302 if (!*inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100303 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700304 goto out;
305 }
306 err = 0;
307
308 out_put_forget:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100309 kfree(forget);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700310 out:
311 return err;
312}
313
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800314static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
315 struct nameidata *nd)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700316{
317 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700318 struct fuse_entry_out outarg;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700319 struct inode *inode;
Miklos Szeredi0de62562008-07-25 01:48:59 -0700320 struct dentry *newent;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700321 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700322 bool outarg_valid = true;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700323
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700324 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
325 &outarg, &inode);
326 if (err == -ENOENT) {
327 outarg_valid = false;
328 err = 0;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800329 }
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700330 if (err)
331 goto out_err;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800332
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700333 err = -EIO;
334 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
335 goto out_iput;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700336
Miklos Szeredid2a85162006-10-17 00:10:11 -0700337 if (inode && S_ISDIR(inode->i_mode)) {
338 mutex_lock(&fc->inst_mutex);
Miklos Szeredi0de62562008-07-25 01:48:59 -0700339 newent = fuse_d_add_directory(entry, inode);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700340 mutex_unlock(&fc->inst_mutex);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700341 err = PTR_ERR(newent);
342 if (IS_ERR(newent))
343 goto out_iput;
344 } else {
Miklos Szeredi0de62562008-07-25 01:48:59 -0700345 newent = d_splice_alias(inode, entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700346 }
Miklos Szeredid2a85162006-10-17 00:10:11 -0700347
Miklos Szeredi0de62562008-07-25 01:48:59 -0700348 entry = newent ? newent : entry;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700349 entry->d_op = &fuse_dentry_operations;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700350 if (outarg_valid)
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700351 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800352 else
353 fuse_invalidate_entry_cache(entry);
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700354
Miklos Szeredi0de62562008-07-25 01:48:59 -0700355 return newent;
Miklos Szeredic180eeb2008-07-25 01:49:01 -0700356
357 out_iput:
358 iput(inode);
359 out_err:
360 return ERR_PTR(err);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700361}
362
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800363/*
364 * Atomic create+open operation
365 *
366 * If the filesystem doesn't support this, then fall back to separate
367 * 'mknod' + 'open' requests.
368 */
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800369static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
370 struct nameidata *nd)
371{
372 int err;
373 struct inode *inode;
374 struct fuse_conn *fc = get_fuse_conn(dir);
375 struct fuse_req *req;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100376 struct fuse_forget_link *forget;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200377 struct fuse_create_in inarg;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800378 struct fuse_open_out outopen;
379 struct fuse_entry_out outentry;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800380 struct fuse_file *ff;
381 struct file *file;
382 int flags = nd->intent.open.flags - 1;
383
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800384 if (fc->no_create)
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700385 return -ENOSYS;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800386
Csaba Henk1b7323962009-11-27 19:30:14 +0530387 if (flags & O_DIRECT)
388 return -EINVAL;
389
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100390 forget = fuse_alloc_forget();
391 if (!forget)
392 return -ENOMEM;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700393
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700394 req = fuse_get_req(fc);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700395 err = PTR_ERR(req);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700396 if (IS_ERR(req))
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700397 goto out_put_forget_req;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800398
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700399 err = -ENOMEM;
Tejun Heoacf99432008-11-26 12:03:55 +0100400 ff = fuse_file_alloc(fc);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800401 if (!ff)
402 goto out_put_request;
403
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200404 if (!fc->dont_mask)
405 mode &= ~current_umask();
406
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800407 flags &= ~O_NOCTTY;
408 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700409 memset(&outentry, 0, sizeof(outentry));
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800410 inarg.flags = flags;
411 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200412 inarg.umask = current_umask();
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800413 req->in.h.opcode = FUSE_CREATE;
414 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800415 req->in.numargs = 2;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200416 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
417 sizeof(inarg);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800418 req->in.args[0].value = &inarg;
419 req->in.args[1].size = entry->d_name.len + 1;
420 req->in.args[1].value = entry->d_name.name;
421 req->out.numargs = 2;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700422 if (fc->minor < 9)
423 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
424 else
425 req->out.args[0].size = sizeof(outentry);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800426 req->out.args[0].value = &outentry;
427 req->out.args[1].size = sizeof(outopen);
428 req->out.args[1].value = &outopen;
Tejun Heob93f8582008-11-26 12:03:55 +0100429 fuse_request_send(fc, req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800430 err = req->out.h.error;
431 if (err) {
432 if (err == -ENOSYS)
433 fc->no_create = 1;
434 goto out_free_ff;
435 }
436
437 err = -EIO;
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800438 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800439 goto out_free_ff;
440
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700441 fuse_put_request(fc, req);
Miklos Szeredic7b71432009-04-28 16:56:37 +0200442 ff->fh = outopen.fh;
443 ff->nodeid = outentry.nodeid;
444 ff->open_flags = outopen.open_flags;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800445 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700446 &outentry.attr, entry_attr_timeout(&outentry), 0);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800447 if (!inode) {
448 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200449 fuse_sync_release(ff, flags);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100450 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700451 return -ENOMEM;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800452 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100453 kfree(forget);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800454 d_instantiate(entry, inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700455 fuse_change_entry_timeout(entry, &outentry);
Miklos Szeredi0952b2a2008-02-06 01:38:38 -0800456 fuse_invalidate_attr(dir);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800457 file = lookup_instantiate_filp(nd, entry, generic_file_open);
458 if (IS_ERR(file)) {
Miklos Szeredi8b0797a2009-04-28 16:56:39 +0200459 fuse_sync_release(ff, flags);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800460 return PTR_ERR(file);
461 }
Miklos Szeredic7b71432009-04-28 16:56:37 +0200462 file->private_data = fuse_file_get(ff);
463 fuse_finish_open(inode, file);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800464 return 0;
465
466 out_free_ff:
467 fuse_file_free(ff);
468 out_put_request:
469 fuse_put_request(fc, req);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700470 out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100471 kfree(forget);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800472 return err;
473}
474
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800475/*
476 * Code shared between mknod, mkdir, symlink and link
477 */
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700478static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
479 struct inode *dir, struct dentry *entry,
480 int mode)
481{
482 struct fuse_entry_out outarg;
483 struct inode *inode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700484 int err;
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100485 struct fuse_forget_link *forget;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800486
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100487 forget = fuse_alloc_forget();
488 if (!forget) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800489 fuse_put_request(fc, req);
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100490 return -ENOMEM;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800491 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700492
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700493 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700494 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700495 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700496 if (fc->minor < 9)
497 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
498 else
499 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700500 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100501 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700502 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800503 fuse_put_request(fc, req);
504 if (err)
505 goto out_put_forget_req;
506
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800507 err = -EIO;
508 if (invalid_nodeid(outarg.nodeid))
Miklos Szeredi2d510132006-11-25 11:09:20 -0800509 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800510
511 if ((outarg.attr.mode ^ mode) & S_IFMT)
Miklos Szeredi2d510132006-11-25 11:09:20 -0800512 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800513
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700514 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700515 &outarg.attr, entry_attr_timeout(&outarg), 0);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700516 if (!inode) {
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100517 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700518 return -ENOMEM;
519 }
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100520 kfree(forget);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700521
Miklos Szeredid2a85162006-10-17 00:10:11 -0700522 if (S_ISDIR(inode->i_mode)) {
523 struct dentry *alias;
524 mutex_lock(&fc->inst_mutex);
525 alias = d_find_alias(inode);
526 if (alias) {
527 /* New directory must have moved since mkdir */
528 mutex_unlock(&fc->inst_mutex);
529 dput(alias);
530 iput(inode);
531 return -EBUSY;
532 }
533 d_instantiate(entry, inode);
534 mutex_unlock(&fc->inst_mutex);
535 } else
536 d_instantiate(entry, inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700537
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700538 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700539 fuse_invalidate_attr(dir);
540 return 0;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800541
Miklos Szeredi2d510132006-11-25 11:09:20 -0800542 out_put_forget_req:
Miklos Szeredi07e77dc2010-12-07 20:16:56 +0100543 kfree(forget);
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800544 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700545}
546
547static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
548 dev_t rdev)
549{
550 struct fuse_mknod_in inarg;
551 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700552 struct fuse_req *req = fuse_get_req(fc);
553 if (IS_ERR(req))
554 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700555
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200556 if (!fc->dont_mask)
557 mode &= ~current_umask();
558
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700559 memset(&inarg, 0, sizeof(inarg));
560 inarg.mode = mode;
561 inarg.rdev = new_encode_dev(rdev);
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200562 inarg.umask = current_umask();
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700563 req->in.h.opcode = FUSE_MKNOD;
564 req->in.numargs = 2;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200565 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
566 sizeof(inarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700567 req->in.args[0].value = &inarg;
568 req->in.args[1].size = entry->d_name.len + 1;
569 req->in.args[1].value = entry->d_name.name;
570 return create_new_entry(fc, req, dir, entry, mode);
571}
572
573static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
574 struct nameidata *nd)
575{
Miklos Szeredib9ba3472007-05-23 13:57:32 -0700576 if (nd && (nd->flags & LOOKUP_OPEN)) {
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800577 int err = fuse_create_open(dir, entry, mode, nd);
578 if (err != -ENOSYS)
579 return err;
580 /* Fall back on mknod */
581 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700582 return fuse_mknod(dir, entry, mode, 0);
583}
584
585static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
586{
587 struct fuse_mkdir_in inarg;
588 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700589 struct fuse_req *req = fuse_get_req(fc);
590 if (IS_ERR(req))
591 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700592
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200593 if (!fc->dont_mask)
594 mode &= ~current_umask();
595
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700596 memset(&inarg, 0, sizeof(inarg));
597 inarg.mode = mode;
Miklos Szeredie0a43dd2009-06-30 20:12:23 +0200598 inarg.umask = current_umask();
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700599 req->in.h.opcode = FUSE_MKDIR;
600 req->in.numargs = 2;
601 req->in.args[0].size = sizeof(inarg);
602 req->in.args[0].value = &inarg;
603 req->in.args[1].size = entry->d_name.len + 1;
604 req->in.args[1].value = entry->d_name.name;
605 return create_new_entry(fc, req, dir, entry, S_IFDIR);
606}
607
608static int fuse_symlink(struct inode *dir, struct dentry *entry,
609 const char *link)
610{
611 struct fuse_conn *fc = get_fuse_conn(dir);
612 unsigned len = strlen(link) + 1;
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700613 struct fuse_req *req = fuse_get_req(fc);
614 if (IS_ERR(req))
615 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700616
617 req->in.h.opcode = FUSE_SYMLINK;
618 req->in.numargs = 2;
619 req->in.args[0].size = entry->d_name.len + 1;
620 req->in.args[0].value = entry->d_name.name;
621 req->in.args[1].size = len;
622 req->in.args[1].value = link;
623 return create_new_entry(fc, req, dir, entry, S_IFLNK);
624}
625
626static int fuse_unlink(struct inode *dir, struct dentry *entry)
627{
628 int err;
629 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700630 struct fuse_req *req = fuse_get_req(fc);
631 if (IS_ERR(req))
632 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700633
634 req->in.h.opcode = FUSE_UNLINK;
635 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700636 req->in.numargs = 1;
637 req->in.args[0].size = entry->d_name.len + 1;
638 req->in.args[0].value = entry->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100639 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700640 err = req->out.h.error;
641 fuse_put_request(fc, req);
642 if (!err) {
643 struct inode *inode = entry->d_inode;
644
Miklos Szeredi1729a162008-11-26 12:03:54 +0100645 /*
646 * Set nlink to zero so the inode can be cleared, if the inode
647 * does have more links this will be discovered at the next
648 * lookup/getattr.
649 */
Dave Hansence71ec32006-09-30 23:29:06 -0700650 clear_nlink(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700651 fuse_invalidate_attr(inode);
652 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800653 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700654 } else if (err == -EINTR)
655 fuse_invalidate_entry(entry);
656 return err;
657}
658
659static int fuse_rmdir(struct inode *dir, struct dentry *entry)
660{
661 int err;
662 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700663 struct fuse_req *req = fuse_get_req(fc);
664 if (IS_ERR(req))
665 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700666
667 req->in.h.opcode = FUSE_RMDIR;
668 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700669 req->in.numargs = 1;
670 req->in.args[0].size = entry->d_name.len + 1;
671 req->in.args[0].value = entry->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100672 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700673 err = req->out.h.error;
674 fuse_put_request(fc, req);
675 if (!err) {
Dave Hansence71ec32006-09-30 23:29:06 -0700676 clear_nlink(entry->d_inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700677 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800678 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700679 } else if (err == -EINTR)
680 fuse_invalidate_entry(entry);
681 return err;
682}
683
684static int fuse_rename(struct inode *olddir, struct dentry *oldent,
685 struct inode *newdir, struct dentry *newent)
686{
687 int err;
688 struct fuse_rename_in inarg;
689 struct fuse_conn *fc = get_fuse_conn(olddir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700690 struct fuse_req *req = fuse_get_req(fc);
691 if (IS_ERR(req))
692 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700693
694 memset(&inarg, 0, sizeof(inarg));
695 inarg.newdir = get_node_id(newdir);
696 req->in.h.opcode = FUSE_RENAME;
697 req->in.h.nodeid = get_node_id(olddir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700698 req->in.numargs = 3;
699 req->in.args[0].size = sizeof(inarg);
700 req->in.args[0].value = &inarg;
701 req->in.args[1].size = oldent->d_name.len + 1;
702 req->in.args[1].value = oldent->d_name.name;
703 req->in.args[2].size = newent->d_name.len + 1;
704 req->in.args[2].value = newent->d_name.name;
Tejun Heob93f8582008-11-26 12:03:55 +0100705 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700706 err = req->out.h.error;
707 fuse_put_request(fc, req);
708 if (!err) {
Miklos Szeredi08b63302007-11-28 16:22:03 -0800709 /* ctime changes */
710 fuse_invalidate_attr(oldent->d_inode);
711
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700712 fuse_invalidate_attr(olddir);
713 if (olddir != newdir)
714 fuse_invalidate_attr(newdir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800715
716 /* newent will end up negative */
Miklos Szeredi5219f342009-11-04 10:24:52 +0100717 if (newent->d_inode) {
718 fuse_invalidate_attr(newent->d_inode);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800719 fuse_invalidate_entry_cache(newent);
Miklos Szeredi5219f342009-11-04 10:24:52 +0100720 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700721 } else if (err == -EINTR) {
722 /* If request was interrupted, DEITY only knows if the
723 rename actually took place. If the invalidation
724 fails (e.g. some process has CWD under the renamed
725 directory), then there can be inconsistency between
726 the dcache and the real filesystem. Tough luck. */
727 fuse_invalidate_entry(oldent);
728 if (newent->d_inode)
729 fuse_invalidate_entry(newent);
730 }
731
732 return err;
733}
734
735static int fuse_link(struct dentry *entry, struct inode *newdir,
736 struct dentry *newent)
737{
738 int err;
739 struct fuse_link_in inarg;
740 struct inode *inode = entry->d_inode;
741 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700742 struct fuse_req *req = fuse_get_req(fc);
743 if (IS_ERR(req))
744 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700745
746 memset(&inarg, 0, sizeof(inarg));
747 inarg.oldnodeid = get_node_id(inode);
748 req->in.h.opcode = FUSE_LINK;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700749 req->in.numargs = 2;
750 req->in.args[0].size = sizeof(inarg);
751 req->in.args[0].value = &inarg;
752 req->in.args[1].size = newent->d_name.len + 1;
753 req->in.args[1].value = newent->d_name.name;
754 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
755 /* Contrary to "normal" filesystems it can happen that link
756 makes two "logical" inodes point to the same "physical"
757 inode. We invalidate the attributes of the old one, so it
758 will reflect changes in the backing inode (link count,
759 etc.)
760 */
761 if (!err || err == -EINTR)
762 fuse_invalidate_attr(inode);
763 return err;
764}
765
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700766static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
767 struct kstat *stat)
768{
769 stat->dev = inode->i_sb->s_dev;
770 stat->ino = attr->ino;
771 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
772 stat->nlink = attr->nlink;
773 stat->uid = attr->uid;
774 stat->gid = attr->gid;
775 stat->rdev = inode->i_rdev;
776 stat->atime.tv_sec = attr->atime;
777 stat->atime.tv_nsec = attr->atimensec;
778 stat->mtime.tv_sec = attr->mtime;
779 stat->mtime.tv_nsec = attr->mtimensec;
780 stat->ctime.tv_sec = attr->ctime;
781 stat->ctime.tv_nsec = attr->ctimensec;
782 stat->size = attr->size;
783 stat->blocks = attr->blocks;
784 stat->blksize = (1 << inode->i_blkbits);
785}
786
Miklos Szeredic79e3222007-10-18 03:06:59 -0700787static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
788 struct file *file)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700789{
790 int err;
Miklos Szeredic79e3222007-10-18 03:06:59 -0700791 struct fuse_getattr_in inarg;
792 struct fuse_attr_out outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700793 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700794 struct fuse_req *req;
795 u64 attr_version;
796
797 req = fuse_get_req(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700798 if (IS_ERR(req))
799 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700800
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800801 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700802
Miklos Szeredic79e3222007-10-18 03:06:59 -0700803 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700804 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredic79e3222007-10-18 03:06:59 -0700805 /* Directories have separate file-handle space */
806 if (file && S_ISREG(inode->i_mode)) {
807 struct fuse_file *ff = file->private_data;
808
809 inarg.getattr_flags |= FUSE_GETATTR_FH;
810 inarg.fh = ff->fh;
811 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700812 req->in.h.opcode = FUSE_GETATTR;
813 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700814 req->in.numargs = 1;
815 req->in.args[0].size = sizeof(inarg);
816 req->in.args[0].value = &inarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700817 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700818 if (fc->minor < 9)
819 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
820 else
821 req->out.args[0].size = sizeof(outarg);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700822 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100823 fuse_request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700824 err = req->out.h.error;
825 fuse_put_request(fc, req);
826 if (!err) {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700827 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700828 make_bad_inode(inode);
829 err = -EIO;
830 } else {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700831 fuse_change_attributes(inode, &outarg.attr,
832 attr_timeout(&outarg),
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700833 attr_version);
834 if (stat)
Miklos Szeredic79e3222007-10-18 03:06:59 -0700835 fuse_fillattr(inode, &outarg.attr, stat);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700836 }
837 }
838 return err;
839}
840
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800841int fuse_update_attributes(struct inode *inode, struct kstat *stat,
842 struct file *file, bool *refreshed)
843{
844 struct fuse_inode *fi = get_fuse_inode(inode);
845 int err;
846 bool r;
847
848 if (fi->i_time < get_jiffies_64()) {
849 r = true;
850 err = fuse_do_getattr(inode, stat, file);
851 } else {
852 r = false;
853 err = 0;
854 if (stat) {
855 generic_fillattr(inode, stat);
856 stat->mode = fi->orig_i_mode;
857 }
858 }
859
860 if (refreshed != NULL)
861 *refreshed = r;
862
863 return err;
864}
865
John Muir3b463ae2009-05-31 11:13:57 -0400866int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
867 struct qstr *name)
868{
869 int err = -ENOTDIR;
870 struct inode *parent;
871 struct dentry *dir;
872 struct dentry *entry;
873
874 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
875 if (!parent)
876 return -ENOENT;
877
878 mutex_lock(&parent->i_mutex);
879 if (!S_ISDIR(parent->i_mode))
880 goto unlock;
881
882 err = -ENOENT;
883 dir = d_find_alias(parent);
884 if (!dir)
885 goto unlock;
886
887 entry = d_lookup(dir, name);
888 dput(dir);
889 if (!entry)
890 goto unlock;
891
892 fuse_invalidate_attr(parent);
893 fuse_invalidate_entry(entry);
894 dput(entry);
895 err = 0;
896
897 unlock:
898 mutex_unlock(&parent->i_mutex);
899 iput(parent);
900 return err;
901}
902
Miklos Szeredi87729a52005-09-09 13:10:34 -0700903/*
904 * Calling into a user-controlled filesystem gives the filesystem
905 * daemon ptrace-like capabilities over the requester process. This
906 * means, that the filesystem daemon is able to record the exact
907 * filesystem operations performed, and can also control the behavior
908 * of the requester process in otherwise impossible ways. For example
909 * it can delay the operation for arbitrary length of time allowing
910 * DoS against the requester.
911 *
912 * For this reason only those processes can call into the filesystem,
913 * for which the owner of the mount has ptrace privilege. This
914 * excludes processes started by other users, suid or sgid processes.
915 */
Miklos Szeredie57ac682007-10-18 03:06:58 -0700916int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
Miklos Szeredi87729a52005-09-09 13:10:34 -0700917{
David Howellsc69e8d92008-11-14 10:39:19 +1100918 const struct cred *cred;
919 int ret;
920
Miklos Szeredi87729a52005-09-09 13:10:34 -0700921 if (fc->flags & FUSE_ALLOW_OTHER)
922 return 1;
923
David Howellsc69e8d92008-11-14 10:39:19 +1100924 rcu_read_lock();
925 ret = 0;
926 cred = __task_cred(task);
927 if (cred->euid == fc->user_id &&
928 cred->suid == fc->user_id &&
929 cred->uid == fc->user_id &&
930 cred->egid == fc->group_id &&
931 cred->sgid == fc->group_id &&
932 cred->gid == fc->group_id)
933 ret = 1;
934 rcu_read_unlock();
Miklos Szeredi87729a52005-09-09 13:10:34 -0700935
David Howellsc69e8d92008-11-14 10:39:19 +1100936 return ret;
Miklos Szeredi87729a52005-09-09 13:10:34 -0700937}
938
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800939static int fuse_access(struct inode *inode, int mask)
940{
941 struct fuse_conn *fc = get_fuse_conn(inode);
942 struct fuse_req *req;
943 struct fuse_access_in inarg;
944 int err;
945
946 if (fc->no_access)
947 return 0;
948
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700949 req = fuse_get_req(fc);
950 if (IS_ERR(req))
951 return PTR_ERR(req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800952
953 memset(&inarg, 0, sizeof(inarg));
Al Viroe6305c42008-07-15 21:03:57 -0400954 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800955 req->in.h.opcode = FUSE_ACCESS;
956 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800957 req->in.numargs = 1;
958 req->in.args[0].size = sizeof(inarg);
959 req->in.args[0].value = &inarg;
Tejun Heob93f8582008-11-26 12:03:55 +0100960 fuse_request_send(fc, req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800961 err = req->out.h.error;
962 fuse_put_request(fc, req);
963 if (err == -ENOSYS) {
964 fc->no_access = 1;
965 err = 0;
966 }
967 return err;
968}
969
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800970/*
971 * Check permission. The two basic access models of FUSE are:
972 *
973 * 1) Local access checking ('default_permissions' mount option) based
974 * on file mode. This is the plain old disk filesystem permission
975 * modell.
976 *
977 * 2) "Remote" access checking, where server is responsible for
978 * checking permission in each inode operation. An exception to this
979 * is if ->permission() was invoked from sys_access() in which case an
980 * access request is sent. Execute permission is still checked
981 * locally based on file mode.
982 */
Al Viroe6305c42008-07-15 21:03:57 -0400983static int fuse_permission(struct inode *inode, int mask)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700984{
985 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -0700986 bool refreshed = false;
987 int err = 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700988
Miklos Szeredi87729a52005-09-09 13:10:34 -0700989 if (!fuse_allow_task(fc, current))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700990 return -EACCES;
Miklos Szeredi244f6382007-10-16 23:31:02 -0700991
992 /*
Miklos Szeredie8e96152007-10-16 23:31:06 -0700993 * If attributes are needed, refresh them before proceeding
Miklos Szeredi244f6382007-10-16 23:31:02 -0700994 */
Miklos Szeredie8e96152007-10-16 23:31:06 -0700995 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
996 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800997 err = fuse_update_attributes(inode, NULL, NULL, &refreshed);
998 if (err)
999 return err;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001000 }
1001
1002 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
Miklos Szeredi1a823ac2008-02-23 15:23:27 -08001003 err = generic_permission(inode, mask, NULL);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001004
1005 /* If permission is denied, try to refresh file
1006 attributes. This is also needed, because the root
1007 node will at first have no permissions */
Miklos Szeredi244f6382007-10-16 23:31:02 -07001008 if (err == -EACCES && !refreshed) {
Miklos Szeredic79e3222007-10-18 03:06:59 -07001009 err = fuse_do_getattr(inode, NULL, NULL);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001010 if (!err)
1011 err = generic_permission(inode, mask, NULL);
1012 }
1013
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001014 /* Note: the opposite of the above test does not
1015 exist. So if permissions are revoked this won't be
1016 noticed immediately, only after the attribute
1017 timeout has expired */
Eric Paris9cfcac82010-07-23 11:43:51 -04001018 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
Miklos Szeredie8e96152007-10-16 23:31:06 -07001019 err = fuse_access(inode, mask);
1020 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1021 if (!(inode->i_mode & S_IXUGO)) {
1022 if (refreshed)
1023 return -EACCES;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001024
Miklos Szeredic79e3222007-10-18 03:06:59 -07001025 err = fuse_do_getattr(inode, NULL, NULL);
Miklos Szeredie8e96152007-10-16 23:31:06 -07001026 if (!err && !(inode->i_mode & S_IXUGO))
1027 return -EACCES;
1028 }
Miklos Szeredie5e55582005-09-09 13:10:28 -07001029 }
Miklos Szeredi244f6382007-10-16 23:31:02 -07001030 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001031}
1032
1033static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1034 void *dstbuf, filldir_t filldir)
1035{
1036 while (nbytes >= FUSE_NAME_OFFSET) {
1037 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1038 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1039 int over;
1040 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1041 return -EIO;
1042 if (reclen > nbytes)
1043 break;
1044
1045 over = filldir(dstbuf, dirent->name, dirent->namelen,
1046 file->f_pos, dirent->ino, dirent->type);
1047 if (over)
1048 break;
1049
1050 buf += reclen;
1051 nbytes -= reclen;
1052 file->f_pos = dirent->off;
1053 }
1054
1055 return 0;
1056}
1057
Miklos Szeredie5e55582005-09-09 13:10:28 -07001058static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1059{
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001060 int err;
1061 size_t nbytes;
1062 struct page *page;
Josef Sipek7706a9d2006-12-08 02:37:02 -08001063 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001064 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi248d86e2006-01-06 00:19:39 -08001065 struct fuse_req *req;
1066
1067 if (is_bad_inode(inode))
1068 return -EIO;
1069
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001070 req = fuse_get_req(fc);
1071 if (IS_ERR(req))
1072 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001073
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001074 page = alloc_page(GFP_KERNEL);
1075 if (!page) {
1076 fuse_put_request(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001077 return -ENOMEM;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001078 }
Miklos Szeredif4975c62009-04-02 14:25:34 +02001079 req->out.argpages = 1;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001080 req->num_pages = 1;
1081 req->pages[0] = page;
Miklos Szeredi2106cb12009-04-28 16:56:37 +02001082 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
Tejun Heob93f8582008-11-26 12:03:55 +01001083 fuse_request_send(fc, req);
Miklos Szeredi361b1eb52006-01-16 22:14:45 -08001084 nbytes = req->out.args[0].size;
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001085 err = req->out.h.error;
1086 fuse_put_request(fc, req);
1087 if (!err)
1088 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
1089 filldir);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001090
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001091 __free_page(page);
Miklos Szeredib36c31b2005-09-09 13:10:38 -07001092 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001093 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001094}
1095
1096static char *read_link(struct dentry *dentry)
1097{
1098 struct inode *inode = dentry->d_inode;
1099 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001100 struct fuse_req *req = fuse_get_req(fc);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001101 char *link;
1102
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001103 if (IS_ERR(req))
David Howellse231c2e2008-02-07 00:15:26 -08001104 return ERR_CAST(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001105
1106 link = (char *) __get_free_page(GFP_KERNEL);
1107 if (!link) {
1108 link = ERR_PTR(-ENOMEM);
1109 goto out;
1110 }
1111 req->in.h.opcode = FUSE_READLINK;
1112 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001113 req->out.argvar = 1;
1114 req->out.numargs = 1;
1115 req->out.args[0].size = PAGE_SIZE - 1;
1116 req->out.args[0].value = link;
Tejun Heob93f8582008-11-26 12:03:55 +01001117 fuse_request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001118 if (req->out.h.error) {
1119 free_page((unsigned long) link);
1120 link = ERR_PTR(req->out.h.error);
1121 } else
1122 link[req->out.args[0].size] = '\0';
1123 out:
1124 fuse_put_request(fc, req);
Miklos Szeredib36c31b2005-09-09 13:10:38 -07001125 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredie5e55582005-09-09 13:10:28 -07001126 return link;
1127}
1128
1129static void free_link(char *link)
1130{
1131 if (!IS_ERR(link))
1132 free_page((unsigned long) link);
1133}
1134
1135static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1136{
1137 nd_set_link(nd, read_link(dentry));
1138 return NULL;
1139}
1140
1141static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1142{
1143 free_link(nd_get_link(nd));
1144}
1145
1146static int fuse_dir_open(struct inode *inode, struct file *file)
1147{
Miklos Szeredi91fe96b2009-04-28 16:56:37 +02001148 return fuse_open_common(inode, file, true);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001149}
1150
1151static int fuse_dir_release(struct inode *inode, struct file *file)
1152{
Miklos Szeredi8b0797a2009-04-28 16:56:39 +02001153 fuse_release_common(file, FUSE_RELEASEDIR);
1154
1155 return 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -07001156}
1157
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001158static int fuse_dir_fsync(struct file *file, int datasync)
Miklos Szeredi82547982005-09-09 13:10:38 -07001159{
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001160 return fuse_fsync_common(file, datasync, 1);
Miklos Szeredi82547982005-09-09 13:10:38 -07001161}
1162
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001163static bool update_mtime(unsigned ivalid)
1164{
1165 /* Always update if mtime is explicitly set */
1166 if (ivalid & ATTR_MTIME_SET)
1167 return true;
1168
1169 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1170 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1171 return false;
1172
1173 /* In all other cases update */
1174 return true;
1175}
1176
Miklos Szeredibefc6492005-11-07 00:59:52 -08001177static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001178{
1179 unsigned ivalid = iattr->ia_valid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001180
1181 if (ivalid & ATTR_MODE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001182 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001183 if (ivalid & ATTR_UID)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001184 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001185 if (ivalid & ATTR_GID)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001186 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001187 if (ivalid & ATTR_SIZE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001188 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001189 if (ivalid & ATTR_ATIME) {
1190 arg->valid |= FATTR_ATIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001191 arg->atime = iattr->ia_atime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001192 arg->atimensec = iattr->ia_atime.tv_nsec;
1193 if (!(ivalid & ATTR_ATIME_SET))
1194 arg->valid |= FATTR_ATIME_NOW;
1195 }
1196 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1197 arg->valid |= FATTR_MTIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001198 arg->mtime = iattr->ia_mtime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001199 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1200 if (!(ivalid & ATTR_MTIME_SET))
1201 arg->valid |= FATTR_MTIME_NOW;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001202 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001203}
1204
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001205/*
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001206 * Prevent concurrent writepages on inode
1207 *
1208 * This is done by adding a negative bias to the inode write counter
1209 * and waiting for all pending writes to finish.
1210 */
1211void fuse_set_nowrite(struct inode *inode)
1212{
1213 struct fuse_conn *fc = get_fuse_conn(inode);
1214 struct fuse_inode *fi = get_fuse_inode(inode);
1215
1216 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1217
1218 spin_lock(&fc->lock);
1219 BUG_ON(fi->writectr < 0);
1220 fi->writectr += FUSE_NOWRITE;
1221 spin_unlock(&fc->lock);
1222 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1223}
1224
1225/*
1226 * Allow writepages on inode
1227 *
1228 * Remove the bias from the writecounter and send any queued
1229 * writepages.
1230 */
1231static void __fuse_release_nowrite(struct inode *inode)
1232{
1233 struct fuse_inode *fi = get_fuse_inode(inode);
1234
1235 BUG_ON(fi->writectr != FUSE_NOWRITE);
1236 fi->writectr = 0;
1237 fuse_flush_writepages(inode);
1238}
1239
1240void fuse_release_nowrite(struct inode *inode)
1241{
1242 struct fuse_conn *fc = get_fuse_conn(inode);
1243
1244 spin_lock(&fc->lock);
1245 __fuse_release_nowrite(inode);
1246 spin_unlock(&fc->lock);
1247}
1248
1249/*
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001250 * Set attributes, and at the same time refresh them.
1251 *
1252 * Truncation is slightly complicated, because the 'truncate' request
1253 * may fail, in which case we don't want to touch the mapping.
Miklos Szeredi9ffbb912006-10-17 00:10:06 -07001254 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1255 * and the actual truncation by hand.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001256 */
Miklos Szeredi49d49142007-10-18 03:07:00 -07001257static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1258 struct file *file)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001259{
1260 struct inode *inode = entry->d_inode;
1261 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001262 struct fuse_req *req;
1263 struct fuse_setattr_in inarg;
1264 struct fuse_attr_out outarg;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001265 bool is_truncate = false;
1266 loff_t oldsize;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001267 int err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001268
Miklos Szeredie57ac682007-10-18 03:06:58 -07001269 if (!fuse_allow_task(fc, current))
1270 return -EACCES;
1271
Christoph Hellwigdb78b872010-06-04 11:30:03 +02001272 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1273 attr->ia_valid |= ATTR_FORCE;
1274
1275 err = inode_change_ok(inode, attr);
1276 if (err)
1277 return err;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001278
Miklos Szeredi6ff958e2007-10-18 03:07:02 -07001279 if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
1280 return 0;
1281
Christoph Hellwig2c27c652010-06-04 11:30:04 +02001282 if (attr->ia_valid & ATTR_SIZE)
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001283 is_truncate = true;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001284
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001285 req = fuse_get_req(fc);
1286 if (IS_ERR(req))
1287 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001288
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001289 if (is_truncate)
1290 fuse_set_nowrite(inode);
1291
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001292 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001293 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredibefc6492005-11-07 00:59:52 -08001294 iattr_to_fattr(attr, &inarg);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001295 if (file) {
1296 struct fuse_file *ff = file->private_data;
1297 inarg.valid |= FATTR_FH;
1298 inarg.fh = ff->fh;
1299 }
Miklos Szeredif3332112007-10-18 03:07:04 -07001300 if (attr->ia_valid & ATTR_SIZE) {
1301 /* For mandatory locking in truncate */
1302 inarg.valid |= FATTR_LOCKOWNER;
1303 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1304 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001305 req->in.h.opcode = FUSE_SETATTR;
1306 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001307 req->in.numargs = 1;
1308 req->in.args[0].size = sizeof(inarg);
1309 req->in.args[0].value = &inarg;
1310 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001311 if (fc->minor < 9)
1312 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1313 else
1314 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001315 req->out.args[0].value = &outarg;
Tejun Heob93f8582008-11-26 12:03:55 +01001316 fuse_request_send(fc, req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001317 err = req->out.h.error;
1318 fuse_put_request(fc, req);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001319 if (err) {
1320 if (err == -EINTR)
1321 fuse_invalidate_attr(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001322 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001323 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001324
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001325 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1326 make_bad_inode(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001327 err = -EIO;
1328 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001329 }
1330
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001331 spin_lock(&fc->lock);
1332 fuse_change_attributes_common(inode, &outarg.attr,
1333 attr_timeout(&outarg));
1334 oldsize = inode->i_size;
1335 i_size_write(inode, outarg.attr.size);
1336
1337 if (is_truncate) {
1338 /* NOTE: this may release/reacquire fc->lock */
1339 __fuse_release_nowrite(inode);
1340 }
1341 spin_unlock(&fc->lock);
1342
1343 /*
1344 * Only call invalidate_inode_pages2() after removing
1345 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1346 */
1347 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
npiggin@suse.dec08d3b02009-08-21 02:35:06 +10001348 truncate_pagecache(inode, oldsize, outarg.attr.size);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001349 invalidate_inode_pages2(inode->i_mapping);
1350 }
1351
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001352 return 0;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001353
1354error:
1355 if (is_truncate)
1356 fuse_release_nowrite(inode);
1357
1358 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001359}
1360
Miklos Szeredi49d49142007-10-18 03:07:00 -07001361static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1362{
1363 if (attr->ia_valid & ATTR_FILE)
1364 return fuse_do_setattr(entry, attr, attr->ia_file);
1365 else
1366 return fuse_do_setattr(entry, attr, NULL);
1367}
1368
Miklos Szeredie5e55582005-09-09 13:10:28 -07001369static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1370 struct kstat *stat)
1371{
1372 struct inode *inode = entry->d_inode;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001373 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001374
1375 if (!fuse_allow_task(fc, current))
1376 return -EACCES;
1377
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001378 return fuse_update_attributes(inode, stat, NULL, NULL);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001379}
1380
Miklos Szeredi92a87802005-09-09 13:10:31 -07001381static int fuse_setxattr(struct dentry *entry, const char *name,
1382 const void *value, size_t size, int flags)
1383{
1384 struct inode *inode = entry->d_inode;
1385 struct fuse_conn *fc = get_fuse_conn(inode);
1386 struct fuse_req *req;
1387 struct fuse_setxattr_in inarg;
1388 int err;
1389
Miklos Szeredi92a87802005-09-09 13:10:31 -07001390 if (fc->no_setxattr)
1391 return -EOPNOTSUPP;
1392
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001393 req = fuse_get_req(fc);
1394 if (IS_ERR(req))
1395 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001396
1397 memset(&inarg, 0, sizeof(inarg));
1398 inarg.size = size;
1399 inarg.flags = flags;
1400 req->in.h.opcode = FUSE_SETXATTR;
1401 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001402 req->in.numargs = 3;
1403 req->in.args[0].size = sizeof(inarg);
1404 req->in.args[0].value = &inarg;
1405 req->in.args[1].size = strlen(name) + 1;
1406 req->in.args[1].value = name;
1407 req->in.args[2].size = size;
1408 req->in.args[2].value = value;
Tejun Heob93f8582008-11-26 12:03:55 +01001409 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001410 err = req->out.h.error;
1411 fuse_put_request(fc, req);
1412 if (err == -ENOSYS) {
1413 fc->no_setxattr = 1;
1414 err = -EOPNOTSUPP;
1415 }
1416 return err;
1417}
1418
1419static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1420 void *value, size_t size)
1421{
1422 struct inode *inode = entry->d_inode;
1423 struct fuse_conn *fc = get_fuse_conn(inode);
1424 struct fuse_req *req;
1425 struct fuse_getxattr_in inarg;
1426 struct fuse_getxattr_out outarg;
1427 ssize_t ret;
1428
1429 if (fc->no_getxattr)
1430 return -EOPNOTSUPP;
1431
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001432 req = fuse_get_req(fc);
1433 if (IS_ERR(req))
1434 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001435
1436 memset(&inarg, 0, sizeof(inarg));
1437 inarg.size = size;
1438 req->in.h.opcode = FUSE_GETXATTR;
1439 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001440 req->in.numargs = 2;
1441 req->in.args[0].size = sizeof(inarg);
1442 req->in.args[0].value = &inarg;
1443 req->in.args[1].size = strlen(name) + 1;
1444 req->in.args[1].value = name;
1445 /* This is really two different operations rolled into one */
1446 req->out.numargs = 1;
1447 if (size) {
1448 req->out.argvar = 1;
1449 req->out.args[0].size = size;
1450 req->out.args[0].value = value;
1451 } else {
1452 req->out.args[0].size = sizeof(outarg);
1453 req->out.args[0].value = &outarg;
1454 }
Tejun Heob93f8582008-11-26 12:03:55 +01001455 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001456 ret = req->out.h.error;
1457 if (!ret)
1458 ret = size ? req->out.args[0].size : outarg.size;
1459 else {
1460 if (ret == -ENOSYS) {
1461 fc->no_getxattr = 1;
1462 ret = -EOPNOTSUPP;
1463 }
1464 }
1465 fuse_put_request(fc, req);
1466 return ret;
1467}
1468
1469static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1470{
1471 struct inode *inode = entry->d_inode;
1472 struct fuse_conn *fc = get_fuse_conn(inode);
1473 struct fuse_req *req;
1474 struct fuse_getxattr_in inarg;
1475 struct fuse_getxattr_out outarg;
1476 ssize_t ret;
1477
Miklos Szeredie57ac682007-10-18 03:06:58 -07001478 if (!fuse_allow_task(fc, current))
1479 return -EACCES;
1480
Miklos Szeredi92a87802005-09-09 13:10:31 -07001481 if (fc->no_listxattr)
1482 return -EOPNOTSUPP;
1483
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001484 req = fuse_get_req(fc);
1485 if (IS_ERR(req))
1486 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001487
1488 memset(&inarg, 0, sizeof(inarg));
1489 inarg.size = size;
1490 req->in.h.opcode = FUSE_LISTXATTR;
1491 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001492 req->in.numargs = 1;
1493 req->in.args[0].size = sizeof(inarg);
1494 req->in.args[0].value = &inarg;
1495 /* This is really two different operations rolled into one */
1496 req->out.numargs = 1;
1497 if (size) {
1498 req->out.argvar = 1;
1499 req->out.args[0].size = size;
1500 req->out.args[0].value = list;
1501 } else {
1502 req->out.args[0].size = sizeof(outarg);
1503 req->out.args[0].value = &outarg;
1504 }
Tejun Heob93f8582008-11-26 12:03:55 +01001505 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001506 ret = req->out.h.error;
1507 if (!ret)
1508 ret = size ? req->out.args[0].size : outarg.size;
1509 else {
1510 if (ret == -ENOSYS) {
1511 fc->no_listxattr = 1;
1512 ret = -EOPNOTSUPP;
1513 }
1514 }
1515 fuse_put_request(fc, req);
1516 return ret;
1517}
1518
1519static int fuse_removexattr(struct dentry *entry, const char *name)
1520{
1521 struct inode *inode = entry->d_inode;
1522 struct fuse_conn *fc = get_fuse_conn(inode);
1523 struct fuse_req *req;
1524 int err;
1525
1526 if (fc->no_removexattr)
1527 return -EOPNOTSUPP;
1528
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001529 req = fuse_get_req(fc);
1530 if (IS_ERR(req))
1531 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001532
1533 req->in.h.opcode = FUSE_REMOVEXATTR;
1534 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001535 req->in.numargs = 1;
1536 req->in.args[0].size = strlen(name) + 1;
1537 req->in.args[0].value = name;
Tejun Heob93f8582008-11-26 12:03:55 +01001538 fuse_request_send(fc, req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001539 err = req->out.h.error;
1540 fuse_put_request(fc, req);
1541 if (err == -ENOSYS) {
1542 fc->no_removexattr = 1;
1543 err = -EOPNOTSUPP;
1544 }
1545 return err;
1546}
1547
Arjan van de Ven754661f2007-02-12 00:55:38 -08001548static const struct inode_operations fuse_dir_inode_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -07001549 .lookup = fuse_lookup,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001550 .mkdir = fuse_mkdir,
1551 .symlink = fuse_symlink,
1552 .unlink = fuse_unlink,
1553 .rmdir = fuse_rmdir,
1554 .rename = fuse_rename,
1555 .link = fuse_link,
1556 .setattr = fuse_setattr,
1557 .create = fuse_create,
1558 .mknod = fuse_mknod,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001559 .permission = fuse_permission,
1560 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001561 .setxattr = fuse_setxattr,
1562 .getxattr = fuse_getxattr,
1563 .listxattr = fuse_listxattr,
1564 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001565};
1566
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001567static const struct file_operations fuse_dir_operations = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001568 .llseek = generic_file_llseek,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001569 .read = generic_read_dir,
1570 .readdir = fuse_readdir,
1571 .open = fuse_dir_open,
1572 .release = fuse_dir_release,
Miklos Szeredi82547982005-09-09 13:10:38 -07001573 .fsync = fuse_dir_fsync,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001574};
1575
Arjan van de Ven754661f2007-02-12 00:55:38 -08001576static const struct inode_operations fuse_common_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001577 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001578 .permission = fuse_permission,
1579 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001580 .setxattr = fuse_setxattr,
1581 .getxattr = fuse_getxattr,
1582 .listxattr = fuse_listxattr,
1583 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001584};
1585
Arjan van de Ven754661f2007-02-12 00:55:38 -08001586static const struct inode_operations fuse_symlink_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001587 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001588 .follow_link = fuse_follow_link,
1589 .put_link = fuse_put_link,
1590 .readlink = generic_readlink,
1591 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001592 .setxattr = fuse_setxattr,
1593 .getxattr = fuse_getxattr,
1594 .listxattr = fuse_listxattr,
1595 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001596};
1597
1598void fuse_init_common(struct inode *inode)
1599{
1600 inode->i_op = &fuse_common_inode_operations;
1601}
1602
1603void fuse_init_dir(struct inode *inode)
1604{
1605 inode->i_op = &fuse_dir_inode_operations;
1606 inode->i_fop = &fuse_dir_operations;
1607}
1608
1609void fuse_init_symlink(struct inode *inode)
1610{
1611 inode->i_op = &fuse_symlink_inode_operations;
1612}