blob: 2060bf06b90625cf920aa08f87da07bd286a193f [file] [log] [blame]
Miklos Szeredie5e55582005-09-09 13:10:28 -07001/*
2 FUSE: Filesystem in Userspace
Miklos Szeredi51eb01e2006-06-25 05:48:50 -07003 Copyright (C) 2001-2006 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>
13#include <linux/gfp.h>
14#include <linux/sched.h>
15#include <linux/namei.h>
16
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 Szeredi8cbdf1e2006-01-06 00:19:38 -0800100static void fuse_invalidate_entry_cache(struct dentry *entry)
101{
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 Szeredie5e55582005-09-09 13:10:28 -0700115static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
116 struct dentry *entry,
117 struct fuse_entry_out *outarg)
118{
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700119 struct fuse_conn *fc = get_fuse_conn(dir);
120
121 memset(outarg, 0, sizeof(struct fuse_entry_out));
Miklos Szeredie5e55582005-09-09 13:10:28 -0700122 req->in.h.opcode = FUSE_LOOKUP;
123 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700124 req->in.numargs = 1;
125 req->in.args[0].size = entry->d_name.len + 1;
126 req->in.args[0].value = entry->d_name.name;
127 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700128 if (fc->minor < 9)
129 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
130 else
131 req->out.args[0].size = sizeof(struct fuse_entry_out);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700132 req->out.args[0].value = outarg;
133}
134
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700135u64 fuse_get_attr_version(struct fuse_conn *fc)
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800136{
137 u64 curr_version;
138
139 /*
140 * The spin lock isn't actually needed on 64bit archs, but we
141 * don't yet care too much about such optimizations.
142 */
143 spin_lock(&fc->lock);
144 curr_version = fc->attr_version;
145 spin_unlock(&fc->lock);
146
147 return curr_version;
148}
149
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800150/*
151 * Check whether the dentry is still valid
152 *
153 * If the entry validity timeout has expired and the dentry is
154 * positive, try to redo the lookup. If the lookup results in a
155 * different inode, then let the VFS invalidate the dentry and redo
156 * the lookup once more. If the lookup results in the same inode,
157 * then refresh the attributes, timeouts and mark the dentry valid.
158 */
Miklos Szeredie5e55582005-09-09 13:10:28 -0700159static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
160{
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800161 struct inode *inode = entry->d_inode;
162
163 if (inode && is_bad_inode(inode))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700164 return 0;
Miklos Szeredi0a0898c2006-07-30 03:04:10 -0700165 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700166 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700167 struct fuse_entry_out outarg;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800168 struct fuse_conn *fc;
169 struct fuse_req *req;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800170 struct fuse_req *forget_req;
Miklos Szeredie956edd2006-10-17 00:10:12 -0700171 struct dentry *parent;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700172 u64 attr_version;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800173
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800174 /* For negative dentries, always do a fresh lookup */
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800175 if (!inode)
176 return 0;
177
178 fc = get_fuse_conn(inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700179 req = fuse_get_req(fc);
180 if (IS_ERR(req))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700181 return 0;
182
Miklos Szeredi2d510132006-11-25 11:09:20 -0800183 forget_req = fuse_get_req(fc);
184 if (IS_ERR(forget_req)) {
185 fuse_put_request(fc, req);
186 return 0;
187 }
188
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800189 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700190
Miklos Szeredie956edd2006-10-17 00:10:12 -0700191 parent = dget_parent(entry);
192 fuse_lookup_init(req, parent->d_inode, entry, &outarg);
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700193 request_send(fc, req);
Miklos Szeredie956edd2006-10-17 00:10:12 -0700194 dput(parent);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700195 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800196 fuse_put_request(fc, req);
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800197 /* Zero nodeid is same as -ENOENT */
198 if (!err && !outarg.nodeid)
199 err = -ENOENT;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700200 if (!err) {
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800201 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700202 if (outarg.nodeid != get_node_id(inode)) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800203 fuse_send_forget(fc, forget_req,
204 outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700205 return 0;
206 }
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700207 spin_lock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700208 fi->nlookup ++;
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700209 spin_unlock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700210 }
Miklos Szeredi2d510132006-11-25 11:09:20 -0800211 fuse_put_request(fc, forget_req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700212 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700213 return 0;
214
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700215 fuse_change_attributes(inode, &outarg.attr,
216 entry_attr_timeout(&outarg),
217 attr_version);
218 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700219 }
220 return 1;
221}
222
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800223static int invalid_nodeid(u64 nodeid)
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800224{
225 return !nodeid || nodeid == FUSE_ROOT_ID;
226}
227
Miklos Szeredie5e55582005-09-09 13:10:28 -0700228static struct dentry_operations fuse_dentry_operations = {
229 .d_revalidate = fuse_dentry_revalidate,
230};
231
Timo Savolaa5bfffa2007-04-08 16:04:00 -0700232int fuse_valid_type(int m)
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800233{
234 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
235 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
236}
237
Miklos Szeredid2a85162006-10-17 00:10:11 -0700238/*
239 * Add a directory inode to a dentry, ensuring that no other dentry
240 * refers to this inode. Called with fc->inst_mutex.
241 */
242static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
243{
244 struct dentry *alias = d_find_alias(inode);
245 if (alias) {
246 /* This tries to shrink the subtree below alias */
247 fuse_invalidate_entry(alias);
248 dput(alias);
249 if (!list_empty(&inode->i_dentry))
250 return -EBUSY;
251 }
252 d_add(entry, inode);
253 return 0;
254}
255
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800256static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
257 struct nameidata *nd)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700258{
259 int err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700260 struct fuse_entry_out outarg;
261 struct inode *inode = NULL;
262 struct fuse_conn *fc = get_fuse_conn(dir);
263 struct fuse_req *req;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800264 struct fuse_req *forget_req;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700265 u64 attr_version;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700266
267 if (entry->d_name.len > FUSE_NAME_MAX)
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800268 return ERR_PTR(-ENAMETOOLONG);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700269
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700270 req = fuse_get_req(fc);
271 if (IS_ERR(req))
David Howellse231c2e2008-02-07 00:15:26 -0800272 return ERR_CAST(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700273
Miklos Szeredi2d510132006-11-25 11:09:20 -0800274 forget_req = fuse_get_req(fc);
275 if (IS_ERR(forget_req)) {
276 fuse_put_request(fc, req);
David Howellse231c2e2008-02-07 00:15:26 -0800277 return ERR_CAST(forget_req);
Miklos Szeredi2d510132006-11-25 11:09:20 -0800278 }
279
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800280 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700281
Miklos Szeredie5e55582005-09-09 13:10:28 -0700282 fuse_lookup_init(req, dir, entry, &outarg);
283 request_send(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700284 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800285 fuse_put_request(fc, req);
Miklos Szeredi50322fe2006-02-28 16:59:03 -0800286 /* Zero nodeid is same as -ENOENT, but with valid timeout */
287 if (!err && outarg.nodeid &&
Timo Savolaa5bfffa2007-04-08 16:04:00 -0700288 (invalid_nodeid(outarg.nodeid) ||
289 !fuse_valid_type(outarg.attr.mode)))
Miklos Szerediee4e5272005-09-27 21:45:21 -0700290 err = -EIO;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800291 if (!err && outarg.nodeid) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700292 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700293 &outarg.attr, entry_attr_timeout(&outarg),
294 attr_version);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700295 if (!inode) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800296 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800297 return ERR_PTR(-ENOMEM);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700298 }
299 }
Miklos Szeredi2d510132006-11-25 11:09:20 -0800300 fuse_put_request(fc, forget_req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700301 if (err && err != -ENOENT)
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800302 return ERR_PTR(err);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700303
Miklos Szeredid2a85162006-10-17 00:10:11 -0700304 if (inode && S_ISDIR(inode->i_mode)) {
305 mutex_lock(&fc->inst_mutex);
306 err = fuse_d_add_directory(entry, inode);
307 mutex_unlock(&fc->inst_mutex);
308 if (err) {
309 iput(inode);
310 return ERR_PTR(err);
311 }
312 } else
313 d_add(entry, inode);
314
Miklos Szeredie5e55582005-09-09 13:10:28 -0700315 entry->d_op = &fuse_dentry_operations;
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800316 if (!err)
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700317 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800318 else
319 fuse_invalidate_entry_cache(entry);
Miklos Szeredi0aa7c692006-01-06 00:19:34 -0800320 return NULL;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700321}
322
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800323/*
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700324 * Synchronous release for the case when something goes wrong in CREATE_OPEN
325 */
326static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
327 u64 nodeid, int flags)
328{
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700329 fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
330 ff->reserved_req->force = 1;
331 request_send(fc, ff->reserved_req);
332 fuse_put_request(fc, ff->reserved_req);
333 kfree(ff);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700334}
335
336/*
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800337 * Atomic create+open operation
338 *
339 * If the filesystem doesn't support this, then fall back to separate
340 * 'mknod' + 'open' requests.
341 */
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800342static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
343 struct nameidata *nd)
344{
345 int err;
346 struct inode *inode;
347 struct fuse_conn *fc = get_fuse_conn(dir);
348 struct fuse_req *req;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700349 struct fuse_req *forget_req;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800350 struct fuse_open_in inarg;
351 struct fuse_open_out outopen;
352 struct fuse_entry_out outentry;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800353 struct fuse_file *ff;
354 struct file *file;
355 int flags = nd->intent.open.flags - 1;
356
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800357 if (fc->no_create)
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700358 return -ENOSYS;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800359
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700360 forget_req = fuse_get_req(fc);
361 if (IS_ERR(forget_req))
362 return PTR_ERR(forget_req);
363
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700364 req = fuse_get_req(fc);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700365 err = PTR_ERR(req);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700366 if (IS_ERR(req))
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700367 goto out_put_forget_req;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800368
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700369 err = -ENOMEM;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800370 ff = fuse_file_alloc();
371 if (!ff)
372 goto out_put_request;
373
374 flags &= ~O_NOCTTY;
375 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700376 memset(&outentry, 0, sizeof(outentry));
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800377 inarg.flags = flags;
378 inarg.mode = mode;
379 req->in.h.opcode = FUSE_CREATE;
380 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800381 req->in.numargs = 2;
382 req->in.args[0].size = sizeof(inarg);
383 req->in.args[0].value = &inarg;
384 req->in.args[1].size = entry->d_name.len + 1;
385 req->in.args[1].value = entry->d_name.name;
386 req->out.numargs = 2;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700387 if (fc->minor < 9)
388 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
389 else
390 req->out.args[0].size = sizeof(outentry);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800391 req->out.args[0].value = &outentry;
392 req->out.args[1].size = sizeof(outopen);
393 req->out.args[1].value = &outopen;
394 request_send(fc, req);
395 err = req->out.h.error;
396 if (err) {
397 if (err == -ENOSYS)
398 fc->no_create = 1;
399 goto out_free_ff;
400 }
401
402 err = -EIO;
Miklos Szeredi2827d0b22005-11-28 13:44:16 -0800403 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800404 goto out_free_ff;
405
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700406 fuse_put_request(fc, req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800407 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700408 &outentry.attr, entry_attr_timeout(&outentry), 0);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800409 if (!inode) {
410 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
411 ff->fh = outopen.fh;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700412 fuse_sync_release(fc, ff, outentry.nodeid, flags);
413 fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
414 return -ENOMEM;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800415 }
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700416 fuse_put_request(fc, forget_req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800417 d_instantiate(entry, inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700418 fuse_change_entry_timeout(entry, &outentry);
Miklos Szeredi0952b2a2008-02-06 01:38:38 -0800419 fuse_invalidate_attr(dir);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800420 file = lookup_instantiate_filp(nd, entry, generic_file_open);
421 if (IS_ERR(file)) {
422 ff->fh = outopen.fh;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700423 fuse_sync_release(fc, ff, outentry.nodeid, flags);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800424 return PTR_ERR(file);
425 }
426 fuse_finish_open(inode, file, ff, &outopen);
427 return 0;
428
429 out_free_ff:
430 fuse_file_free(ff);
431 out_put_request:
432 fuse_put_request(fc, req);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700433 out_put_forget_req:
434 fuse_put_request(fc, forget_req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800435 return err;
436}
437
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800438/*
439 * Code shared between mknod, mkdir, symlink and link
440 */
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700441static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
442 struct inode *dir, struct dentry *entry,
443 int mode)
444{
445 struct fuse_entry_out outarg;
446 struct inode *inode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700447 int err;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800448 struct fuse_req *forget_req;
449
450 forget_req = fuse_get_req(fc);
451 if (IS_ERR(forget_req)) {
452 fuse_put_request(fc, req);
453 return PTR_ERR(forget_req);
454 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700455
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700456 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700457 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700458 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700459 if (fc->minor < 9)
460 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
461 else
462 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700463 req->out.args[0].value = &outarg;
464 request_send(fc, req);
465 err = req->out.h.error;
Miklos Szeredi2d510132006-11-25 11:09:20 -0800466 fuse_put_request(fc, req);
467 if (err)
468 goto out_put_forget_req;
469
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800470 err = -EIO;
471 if (invalid_nodeid(outarg.nodeid))
Miklos Szeredi2d510132006-11-25 11:09:20 -0800472 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800473
474 if ((outarg.attr.mode ^ mode) & S_IFMT)
Miklos Szeredi2d510132006-11-25 11:09:20 -0800475 goto out_put_forget_req;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800476
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700477 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700478 &outarg.attr, entry_attr_timeout(&outarg), 0);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700479 if (!inode) {
Miklos Szeredi2d510132006-11-25 11:09:20 -0800480 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700481 return -ENOMEM;
482 }
Miklos Szeredi2d510132006-11-25 11:09:20 -0800483 fuse_put_request(fc, forget_req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700484
Miklos Szeredid2a85162006-10-17 00:10:11 -0700485 if (S_ISDIR(inode->i_mode)) {
486 struct dentry *alias;
487 mutex_lock(&fc->inst_mutex);
488 alias = d_find_alias(inode);
489 if (alias) {
490 /* New directory must have moved since mkdir */
491 mutex_unlock(&fc->inst_mutex);
492 dput(alias);
493 iput(inode);
494 return -EBUSY;
495 }
496 d_instantiate(entry, inode);
497 mutex_unlock(&fc->inst_mutex);
498 } else
499 d_instantiate(entry, inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700500
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700501 fuse_change_entry_timeout(entry, &outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700502 fuse_invalidate_attr(dir);
503 return 0;
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800504
Miklos Szeredi2d510132006-11-25 11:09:20 -0800505 out_put_forget_req:
506 fuse_put_request(fc, forget_req);
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800507 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700508}
509
510static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
511 dev_t rdev)
512{
513 struct fuse_mknod_in inarg;
514 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700515 struct fuse_req *req = fuse_get_req(fc);
516 if (IS_ERR(req))
517 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700518
519 memset(&inarg, 0, sizeof(inarg));
520 inarg.mode = mode;
521 inarg.rdev = new_encode_dev(rdev);
522 req->in.h.opcode = FUSE_MKNOD;
523 req->in.numargs = 2;
524 req->in.args[0].size = sizeof(inarg);
525 req->in.args[0].value = &inarg;
526 req->in.args[1].size = entry->d_name.len + 1;
527 req->in.args[1].value = entry->d_name.name;
528 return create_new_entry(fc, req, dir, entry, mode);
529}
530
531static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
532 struct nameidata *nd)
533{
Miklos Szeredib9ba3472007-05-23 13:57:32 -0700534 if (nd && (nd->flags & LOOKUP_OPEN)) {
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800535 int err = fuse_create_open(dir, entry, mode, nd);
536 if (err != -ENOSYS)
537 return err;
538 /* Fall back on mknod */
539 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700540 return fuse_mknod(dir, entry, mode, 0);
541}
542
543static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
544{
545 struct fuse_mkdir_in inarg;
546 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700547 struct fuse_req *req = fuse_get_req(fc);
548 if (IS_ERR(req))
549 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700550
551 memset(&inarg, 0, sizeof(inarg));
552 inarg.mode = mode;
553 req->in.h.opcode = FUSE_MKDIR;
554 req->in.numargs = 2;
555 req->in.args[0].size = sizeof(inarg);
556 req->in.args[0].value = &inarg;
557 req->in.args[1].size = entry->d_name.len + 1;
558 req->in.args[1].value = entry->d_name.name;
559 return create_new_entry(fc, req, dir, entry, S_IFDIR);
560}
561
562static int fuse_symlink(struct inode *dir, struct dentry *entry,
563 const char *link)
564{
565 struct fuse_conn *fc = get_fuse_conn(dir);
566 unsigned len = strlen(link) + 1;
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700567 struct fuse_req *req = fuse_get_req(fc);
568 if (IS_ERR(req))
569 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700570
571 req->in.h.opcode = FUSE_SYMLINK;
572 req->in.numargs = 2;
573 req->in.args[0].size = entry->d_name.len + 1;
574 req->in.args[0].value = entry->d_name.name;
575 req->in.args[1].size = len;
576 req->in.args[1].value = link;
577 return create_new_entry(fc, req, dir, entry, S_IFLNK);
578}
579
580static int fuse_unlink(struct inode *dir, struct dentry *entry)
581{
582 int err;
583 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700584 struct fuse_req *req = fuse_get_req(fc);
585 if (IS_ERR(req))
586 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700587
588 req->in.h.opcode = FUSE_UNLINK;
589 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700590 req->in.numargs = 1;
591 req->in.args[0].size = entry->d_name.len + 1;
592 req->in.args[0].value = entry->d_name.name;
593 request_send(fc, req);
594 err = req->out.h.error;
595 fuse_put_request(fc, req);
596 if (!err) {
597 struct inode *inode = entry->d_inode;
598
599 /* Set nlink to zero so the inode can be cleared, if
600 the inode does have more links this will be
601 discovered at the next lookup/getattr */
Dave Hansence71ec32006-09-30 23:29:06 -0700602 clear_nlink(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700603 fuse_invalidate_attr(inode);
604 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800605 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700606 } else if (err == -EINTR)
607 fuse_invalidate_entry(entry);
608 return err;
609}
610
611static int fuse_rmdir(struct inode *dir, struct dentry *entry)
612{
613 int err;
614 struct fuse_conn *fc = get_fuse_conn(dir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700615 struct fuse_req *req = fuse_get_req(fc);
616 if (IS_ERR(req))
617 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700618
619 req->in.h.opcode = FUSE_RMDIR;
620 req->in.h.nodeid = get_node_id(dir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700621 req->in.numargs = 1;
622 req->in.args[0].size = entry->d_name.len + 1;
623 req->in.args[0].value = entry->d_name.name;
624 request_send(fc, req);
625 err = req->out.h.error;
626 fuse_put_request(fc, req);
627 if (!err) {
Dave Hansence71ec32006-09-30 23:29:06 -0700628 clear_nlink(entry->d_inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700629 fuse_invalidate_attr(dir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800630 fuse_invalidate_entry_cache(entry);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700631 } else if (err == -EINTR)
632 fuse_invalidate_entry(entry);
633 return err;
634}
635
636static int fuse_rename(struct inode *olddir, struct dentry *oldent,
637 struct inode *newdir, struct dentry *newent)
638{
639 int err;
640 struct fuse_rename_in inarg;
641 struct fuse_conn *fc = get_fuse_conn(olddir);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700642 struct fuse_req *req = fuse_get_req(fc);
643 if (IS_ERR(req))
644 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700645
646 memset(&inarg, 0, sizeof(inarg));
647 inarg.newdir = get_node_id(newdir);
648 req->in.h.opcode = FUSE_RENAME;
649 req->in.h.nodeid = get_node_id(olddir);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700650 req->in.numargs = 3;
651 req->in.args[0].size = sizeof(inarg);
652 req->in.args[0].value = &inarg;
653 req->in.args[1].size = oldent->d_name.len + 1;
654 req->in.args[1].value = oldent->d_name.name;
655 req->in.args[2].size = newent->d_name.len + 1;
656 req->in.args[2].value = newent->d_name.name;
657 request_send(fc, req);
658 err = req->out.h.error;
659 fuse_put_request(fc, req);
660 if (!err) {
Miklos Szeredi08b63302007-11-28 16:22:03 -0800661 /* ctime changes */
662 fuse_invalidate_attr(oldent->d_inode);
663
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700664 fuse_invalidate_attr(olddir);
665 if (olddir != newdir)
666 fuse_invalidate_attr(newdir);
Miklos Szeredi8cbdf1e2006-01-06 00:19:38 -0800667
668 /* newent will end up negative */
669 if (newent->d_inode)
670 fuse_invalidate_entry_cache(newent);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700671 } else if (err == -EINTR) {
672 /* If request was interrupted, DEITY only knows if the
673 rename actually took place. If the invalidation
674 fails (e.g. some process has CWD under the renamed
675 directory), then there can be inconsistency between
676 the dcache and the real filesystem. Tough luck. */
677 fuse_invalidate_entry(oldent);
678 if (newent->d_inode)
679 fuse_invalidate_entry(newent);
680 }
681
682 return err;
683}
684
685static int fuse_link(struct dentry *entry, struct inode *newdir,
686 struct dentry *newent)
687{
688 int err;
689 struct fuse_link_in inarg;
690 struct inode *inode = entry->d_inode;
691 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700692 struct fuse_req *req = fuse_get_req(fc);
693 if (IS_ERR(req))
694 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700695
696 memset(&inarg, 0, sizeof(inarg));
697 inarg.oldnodeid = get_node_id(inode);
698 req->in.h.opcode = FUSE_LINK;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700699 req->in.numargs = 2;
700 req->in.args[0].size = sizeof(inarg);
701 req->in.args[0].value = &inarg;
702 req->in.args[1].size = newent->d_name.len + 1;
703 req->in.args[1].value = newent->d_name.name;
704 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
705 /* Contrary to "normal" filesystems it can happen that link
706 makes two "logical" inodes point to the same "physical"
707 inode. We invalidate the attributes of the old one, so it
708 will reflect changes in the backing inode (link count,
709 etc.)
710 */
711 if (!err || err == -EINTR)
712 fuse_invalidate_attr(inode);
713 return err;
714}
715
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700716static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
717 struct kstat *stat)
718{
719 stat->dev = inode->i_sb->s_dev;
720 stat->ino = attr->ino;
721 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
722 stat->nlink = attr->nlink;
723 stat->uid = attr->uid;
724 stat->gid = attr->gid;
725 stat->rdev = inode->i_rdev;
726 stat->atime.tv_sec = attr->atime;
727 stat->atime.tv_nsec = attr->atimensec;
728 stat->mtime.tv_sec = attr->mtime;
729 stat->mtime.tv_nsec = attr->mtimensec;
730 stat->ctime.tv_sec = attr->ctime;
731 stat->ctime.tv_nsec = attr->ctimensec;
732 stat->size = attr->size;
733 stat->blocks = attr->blocks;
734 stat->blksize = (1 << inode->i_blkbits);
735}
736
Miklos Szeredic79e3222007-10-18 03:06:59 -0700737static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
738 struct file *file)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700739{
740 int err;
Miklos Szeredic79e3222007-10-18 03:06:59 -0700741 struct fuse_getattr_in inarg;
742 struct fuse_attr_out outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700743 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700744 struct fuse_req *req;
745 u64 attr_version;
746
747 req = fuse_get_req(fc);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700748 if (IS_ERR(req))
749 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700750
Miklos Szeredi7dca9fd2007-11-28 16:21:59 -0800751 attr_version = fuse_get_attr_version(fc);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700752
Miklos Szeredic79e3222007-10-18 03:06:59 -0700753 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700754 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredic79e3222007-10-18 03:06:59 -0700755 /* Directories have separate file-handle space */
756 if (file && S_ISREG(inode->i_mode)) {
757 struct fuse_file *ff = file->private_data;
758
759 inarg.getattr_flags |= FUSE_GETATTR_FH;
760 inarg.fh = ff->fh;
761 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700762 req->in.h.opcode = FUSE_GETATTR;
763 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700764 req->in.numargs = 1;
765 req->in.args[0].size = sizeof(inarg);
766 req->in.args[0].value = &inarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700767 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700768 if (fc->minor < 9)
769 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
770 else
771 req->out.args[0].size = sizeof(outarg);
Miklos Szeredic79e3222007-10-18 03:06:59 -0700772 req->out.args[0].value = &outarg;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700773 request_send(fc, req);
774 err = req->out.h.error;
775 fuse_put_request(fc, req);
776 if (!err) {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700777 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
Miklos Szeredie5e55582005-09-09 13:10:28 -0700778 make_bad_inode(inode);
779 err = -EIO;
780 } else {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700781 fuse_change_attributes(inode, &outarg.attr,
782 attr_timeout(&outarg),
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700783 attr_version);
784 if (stat)
Miklos Szeredic79e3222007-10-18 03:06:59 -0700785 fuse_fillattr(inode, &outarg.attr, stat);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700786 }
787 }
788 return err;
789}
790
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800791int fuse_update_attributes(struct inode *inode, struct kstat *stat,
792 struct file *file, bool *refreshed)
793{
794 struct fuse_inode *fi = get_fuse_inode(inode);
795 int err;
796 bool r;
797
798 if (fi->i_time < get_jiffies_64()) {
799 r = true;
800 err = fuse_do_getattr(inode, stat, file);
801 } else {
802 r = false;
803 err = 0;
804 if (stat) {
805 generic_fillattr(inode, stat);
806 stat->mode = fi->orig_i_mode;
807 }
808 }
809
810 if (refreshed != NULL)
811 *refreshed = r;
812
813 return err;
814}
815
Miklos Szeredi87729a52005-09-09 13:10:34 -0700816/*
817 * Calling into a user-controlled filesystem gives the filesystem
818 * daemon ptrace-like capabilities over the requester process. This
819 * means, that the filesystem daemon is able to record the exact
820 * filesystem operations performed, and can also control the behavior
821 * of the requester process in otherwise impossible ways. For example
822 * it can delay the operation for arbitrary length of time allowing
823 * DoS against the requester.
824 *
825 * For this reason only those processes can call into the filesystem,
826 * for which the owner of the mount has ptrace privilege. This
827 * excludes processes started by other users, suid or sgid processes.
828 */
Miklos Szeredie57ac682007-10-18 03:06:58 -0700829int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
Miklos Szeredi87729a52005-09-09 13:10:34 -0700830{
831 if (fc->flags & FUSE_ALLOW_OTHER)
832 return 1;
833
834 if (task->euid == fc->user_id &&
835 task->suid == fc->user_id &&
836 task->uid == fc->user_id &&
837 task->egid == fc->group_id &&
838 task->sgid == fc->group_id &&
839 task->gid == fc->group_id)
840 return 1;
841
842 return 0;
843}
844
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800845static int fuse_access(struct inode *inode, int mask)
846{
847 struct fuse_conn *fc = get_fuse_conn(inode);
848 struct fuse_req *req;
849 struct fuse_access_in inarg;
850 int err;
851
852 if (fc->no_access)
853 return 0;
854
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700855 req = fuse_get_req(fc);
856 if (IS_ERR(req))
857 return PTR_ERR(req);
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800858
859 memset(&inarg, 0, sizeof(inarg));
860 inarg.mask = mask;
861 req->in.h.opcode = FUSE_ACCESS;
862 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi31d40d72005-11-07 00:59:50 -0800863 req->in.numargs = 1;
864 req->in.args[0].size = sizeof(inarg);
865 req->in.args[0].value = &inarg;
866 request_send(fc, req);
867 err = req->out.h.error;
868 fuse_put_request(fc, req);
869 if (err == -ENOSYS) {
870 fc->no_access = 1;
871 err = 0;
872 }
873 return err;
874}
875
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800876/*
877 * Check permission. The two basic access models of FUSE are:
878 *
879 * 1) Local access checking ('default_permissions' mount option) based
880 * on file mode. This is the plain old disk filesystem permission
881 * modell.
882 *
883 * 2) "Remote" access checking, where server is responsible for
884 * checking permission in each inode operation. An exception to this
885 * is if ->permission() was invoked from sys_access() in which case an
886 * access request is sent. Execute permission is still checked
887 * locally based on file mode.
888 */
Miklos Szeredie5e55582005-09-09 13:10:28 -0700889static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
890{
891 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -0700892 bool refreshed = false;
893 int err = 0;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700894
Miklos Szeredi87729a52005-09-09 13:10:34 -0700895 if (!fuse_allow_task(fc, current))
Miklos Szeredie5e55582005-09-09 13:10:28 -0700896 return -EACCES;
Miklos Szeredi244f6382007-10-16 23:31:02 -0700897
898 /*
Miklos Szeredie8e96152007-10-16 23:31:06 -0700899 * If attributes are needed, refresh them before proceeding
Miklos Szeredi244f6382007-10-16 23:31:02 -0700900 */
Miklos Szeredie8e96152007-10-16 23:31:06 -0700901 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
902 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800903 err = fuse_update_attributes(inode, NULL, NULL, &refreshed);
904 if (err)
905 return err;
Miklos Szeredi244f6382007-10-16 23:31:02 -0700906 }
907
908 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
Miklos Szeredi1a823ac2008-02-23 15:23:27 -0800909 err = generic_permission(inode, mask, NULL);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700910
911 /* If permission is denied, try to refresh file
912 attributes. This is also needed, because the root
913 node will at first have no permissions */
Miklos Szeredi244f6382007-10-16 23:31:02 -0700914 if (err == -EACCES && !refreshed) {
Miklos Szeredic79e3222007-10-18 03:06:59 -0700915 err = fuse_do_getattr(inode, NULL, NULL);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700916 if (!err)
917 err = generic_permission(inode, mask, NULL);
918 }
919
Miklos Szeredi6f9f1182006-01-06 00:19:39 -0800920 /* Note: the opposite of the above test does not
921 exist. So if permissions are revoked this won't be
922 noticed immediately, only after the attribute
923 timeout has expired */
Miklos Szeredie8e96152007-10-16 23:31:06 -0700924 } else if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR))) {
925 err = fuse_access(inode, mask);
926 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
927 if (!(inode->i_mode & S_IXUGO)) {
928 if (refreshed)
929 return -EACCES;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700930
Miklos Szeredic79e3222007-10-18 03:06:59 -0700931 err = fuse_do_getattr(inode, NULL, NULL);
Miklos Szeredie8e96152007-10-16 23:31:06 -0700932 if (!err && !(inode->i_mode & S_IXUGO))
933 return -EACCES;
934 }
Miklos Szeredie5e55582005-09-09 13:10:28 -0700935 }
Miklos Szeredi244f6382007-10-16 23:31:02 -0700936 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700937}
938
939static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
940 void *dstbuf, filldir_t filldir)
941{
942 while (nbytes >= FUSE_NAME_OFFSET) {
943 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
944 size_t reclen = FUSE_DIRENT_SIZE(dirent);
945 int over;
946 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
947 return -EIO;
948 if (reclen > nbytes)
949 break;
950
951 over = filldir(dstbuf, dirent->name, dirent->namelen,
952 file->f_pos, dirent->ino, dirent->type);
953 if (over)
954 break;
955
956 buf += reclen;
957 nbytes -= reclen;
958 file->f_pos = dirent->off;
959 }
960
961 return 0;
962}
963
Miklos Szeredie5e55582005-09-09 13:10:28 -0700964static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
965{
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700966 int err;
967 size_t nbytes;
968 struct page *page;
Josef Sipek7706a9d2006-12-08 02:37:02 -0800969 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700970 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800971 struct fuse_req *req;
972
973 if (is_bad_inode(inode))
974 return -EIO;
975
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700976 req = fuse_get_req(fc);
977 if (IS_ERR(req))
978 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700979
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700980 page = alloc_page(GFP_KERNEL);
981 if (!page) {
982 fuse_put_request(fc, req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700983 return -ENOMEM;
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700984 }
985 req->num_pages = 1;
986 req->pages[0] = page;
Miklos Szeredia6643092007-11-28 16:22:00 -0800987 fuse_read_fill(req, file, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
Miklos Szeredi361b1eb2006-01-16 22:14:45 -0800988 request_send(fc, req);
989 nbytes = req->out.args[0].size;
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700990 err = req->out.h.error;
991 fuse_put_request(fc, req);
992 if (!err)
993 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
994 filldir);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700995
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700996 __free_page(page);
Miklos Szeredib36c31b2005-09-09 13:10:38 -0700997 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700998 return err;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700999}
1000
1001static char *read_link(struct dentry *dentry)
1002{
1003 struct inode *inode = dentry->d_inode;
1004 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001005 struct fuse_req *req = fuse_get_req(fc);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001006 char *link;
1007
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001008 if (IS_ERR(req))
David Howellse231c2e2008-02-07 00:15:26 -08001009 return ERR_CAST(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001010
1011 link = (char *) __get_free_page(GFP_KERNEL);
1012 if (!link) {
1013 link = ERR_PTR(-ENOMEM);
1014 goto out;
1015 }
1016 req->in.h.opcode = FUSE_READLINK;
1017 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001018 req->out.argvar = 1;
1019 req->out.numargs = 1;
1020 req->out.args[0].size = PAGE_SIZE - 1;
1021 req->out.args[0].value = link;
1022 request_send(fc, req);
1023 if (req->out.h.error) {
1024 free_page((unsigned long) link);
1025 link = ERR_PTR(req->out.h.error);
1026 } else
1027 link[req->out.args[0].size] = '\0';
1028 out:
1029 fuse_put_request(fc, req);
Miklos Szeredib36c31b2005-09-09 13:10:38 -07001030 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredie5e55582005-09-09 13:10:28 -07001031 return link;
1032}
1033
1034static void free_link(char *link)
1035{
1036 if (!IS_ERR(link))
1037 free_page((unsigned long) link);
1038}
1039
1040static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1041{
1042 nd_set_link(nd, read_link(dentry));
1043 return NULL;
1044}
1045
1046static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1047{
1048 free_link(nd_get_link(nd));
1049}
1050
1051static int fuse_dir_open(struct inode *inode, struct file *file)
1052{
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001053 return fuse_open_common(inode, file, 1);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001054}
1055
1056static int fuse_dir_release(struct inode *inode, struct file *file)
1057{
Miklos Szeredi04730fe2005-09-09 13:10:36 -07001058 return fuse_release_common(inode, file, 1);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001059}
1060
Miklos Szeredi82547982005-09-09 13:10:38 -07001061static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
1062{
1063 /* nfsd can call this with no file */
1064 return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
1065}
1066
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001067static bool update_mtime(unsigned ivalid)
1068{
1069 /* Always update if mtime is explicitly set */
1070 if (ivalid & ATTR_MTIME_SET)
1071 return true;
1072
1073 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1074 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1075 return false;
1076
1077 /* In all other cases update */
1078 return true;
1079}
1080
Miklos Szeredibefc6492005-11-07 00:59:52 -08001081static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001082{
1083 unsigned ivalid = iattr->ia_valid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001084
1085 if (ivalid & ATTR_MODE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001086 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001087 if (ivalid & ATTR_UID)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001088 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001089 if (ivalid & ATTR_GID)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001090 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001091 if (ivalid & ATTR_SIZE)
Miklos Szeredibefc6492005-11-07 00:59:52 -08001092 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001093 if (ivalid & ATTR_ATIME) {
1094 arg->valid |= FATTR_ATIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001095 arg->atime = iattr->ia_atime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001096 arg->atimensec = iattr->ia_atime.tv_nsec;
1097 if (!(ivalid & ATTR_ATIME_SET))
1098 arg->valid |= FATTR_ATIME_NOW;
1099 }
1100 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1101 arg->valid |= FATTR_MTIME;
Miklos Szeredibefc6492005-11-07 00:59:52 -08001102 arg->mtime = iattr->ia_mtime.tv_sec;
Miklos Szeredi17637cb2007-10-18 03:07:01 -07001103 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1104 if (!(ivalid & ATTR_MTIME_SET))
1105 arg->valid |= FATTR_MTIME_NOW;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001106 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001107}
1108
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001109/*
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001110 * Prevent concurrent writepages on inode
1111 *
1112 * This is done by adding a negative bias to the inode write counter
1113 * and waiting for all pending writes to finish.
1114 */
1115void fuse_set_nowrite(struct inode *inode)
1116{
1117 struct fuse_conn *fc = get_fuse_conn(inode);
1118 struct fuse_inode *fi = get_fuse_inode(inode);
1119
1120 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1121
1122 spin_lock(&fc->lock);
1123 BUG_ON(fi->writectr < 0);
1124 fi->writectr += FUSE_NOWRITE;
1125 spin_unlock(&fc->lock);
1126 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1127}
1128
1129/*
1130 * Allow writepages on inode
1131 *
1132 * Remove the bias from the writecounter and send any queued
1133 * writepages.
1134 */
1135static void __fuse_release_nowrite(struct inode *inode)
1136{
1137 struct fuse_inode *fi = get_fuse_inode(inode);
1138
1139 BUG_ON(fi->writectr != FUSE_NOWRITE);
1140 fi->writectr = 0;
1141 fuse_flush_writepages(inode);
1142}
1143
1144void fuse_release_nowrite(struct inode *inode)
1145{
1146 struct fuse_conn *fc = get_fuse_conn(inode);
1147
1148 spin_lock(&fc->lock);
1149 __fuse_release_nowrite(inode);
1150 spin_unlock(&fc->lock);
1151}
1152
1153/*
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001154 * Set attributes, and at the same time refresh them.
1155 *
1156 * Truncation is slightly complicated, because the 'truncate' request
1157 * may fail, in which case we don't want to touch the mapping.
Miklos Szeredi9ffbb912006-10-17 00:10:06 -07001158 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1159 * and the actual truncation by hand.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001160 */
Miklos Szeredi49d49142007-10-18 03:07:00 -07001161static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1162 struct file *file)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001163{
1164 struct inode *inode = entry->d_inode;
1165 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001166 struct fuse_req *req;
1167 struct fuse_setattr_in inarg;
1168 struct fuse_attr_out outarg;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001169 bool is_truncate = false;
1170 loff_t oldsize;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001171 int err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001172
Miklos Szeredie57ac682007-10-18 03:06:58 -07001173 if (!fuse_allow_task(fc, current))
1174 return -EACCES;
1175
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001176 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1177 err = inode_change_ok(inode, attr);
1178 if (err)
1179 return err;
1180 }
1181
Miklos Szeredi6ff958e2007-10-18 03:07:02 -07001182 if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
1183 return 0;
1184
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001185 if (attr->ia_valid & ATTR_SIZE) {
1186 unsigned long limit;
Miklos Szeredib2d22722006-12-06 20:35:51 -08001187 if (IS_SWAPFILE(inode))
1188 return -ETXTBSY;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001189 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1190 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1191 send_sig(SIGXFSZ, current, 0);
1192 return -EFBIG;
1193 }
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001194 is_truncate = true;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001195 }
1196
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001197 req = fuse_get_req(fc);
1198 if (IS_ERR(req))
1199 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001200
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001201 if (is_truncate)
1202 fuse_set_nowrite(inode);
1203
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001204 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001205 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredibefc6492005-11-07 00:59:52 -08001206 iattr_to_fattr(attr, &inarg);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001207 if (file) {
1208 struct fuse_file *ff = file->private_data;
1209 inarg.valid |= FATTR_FH;
1210 inarg.fh = ff->fh;
1211 }
Miklos Szeredif3332112007-10-18 03:07:04 -07001212 if (attr->ia_valid & ATTR_SIZE) {
1213 /* For mandatory locking in truncate */
1214 inarg.valid |= FATTR_LOCKOWNER;
1215 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1216 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001217 req->in.h.opcode = FUSE_SETATTR;
1218 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001219 req->in.numargs = 1;
1220 req->in.args[0].size = sizeof(inarg);
1221 req->in.args[0].value = &inarg;
1222 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001223 if (fc->minor < 9)
1224 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1225 else
1226 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001227 req->out.args[0].value = &outarg;
1228 request_send(fc, req);
1229 err = req->out.h.error;
1230 fuse_put_request(fc, req);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001231 if (err) {
1232 if (err == -EINTR)
1233 fuse_invalidate_attr(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001234 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001235 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001236
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001237 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1238 make_bad_inode(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001239 err = -EIO;
1240 goto error;
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001241 }
1242
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001243 spin_lock(&fc->lock);
1244 fuse_change_attributes_common(inode, &outarg.attr,
1245 attr_timeout(&outarg));
1246 oldsize = inode->i_size;
1247 i_size_write(inode, outarg.attr.size);
1248
1249 if (is_truncate) {
1250 /* NOTE: this may release/reacquire fc->lock */
1251 __fuse_release_nowrite(inode);
1252 }
1253 spin_unlock(&fc->lock);
1254
1255 /*
1256 * Only call invalidate_inode_pages2() after removing
1257 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1258 */
1259 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1260 if (outarg.attr.size < oldsize)
1261 fuse_truncate(inode->i_mapping, outarg.attr.size);
1262 invalidate_inode_pages2(inode->i_mapping);
1263 }
1264
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001265 return 0;
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001266
1267error:
1268 if (is_truncate)
1269 fuse_release_nowrite(inode);
1270
1271 return err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001272}
1273
Miklos Szeredi49d49142007-10-18 03:07:00 -07001274static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1275{
1276 if (attr->ia_valid & ATTR_FILE)
1277 return fuse_do_setattr(entry, attr, attr->ia_file);
1278 else
1279 return fuse_do_setattr(entry, attr, NULL);
1280}
1281
Miklos Szeredie5e55582005-09-09 13:10:28 -07001282static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1283 struct kstat *stat)
1284{
1285 struct inode *inode = entry->d_inode;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001286 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001287
1288 if (!fuse_allow_task(fc, current))
1289 return -EACCES;
1290
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001291 return fuse_update_attributes(inode, stat, NULL, NULL);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001292}
1293
Miklos Szeredi92a87802005-09-09 13:10:31 -07001294static int fuse_setxattr(struct dentry *entry, const char *name,
1295 const void *value, size_t size, int flags)
1296{
1297 struct inode *inode = entry->d_inode;
1298 struct fuse_conn *fc = get_fuse_conn(inode);
1299 struct fuse_req *req;
1300 struct fuse_setxattr_in inarg;
1301 int err;
1302
Miklos Szeredi92a87802005-09-09 13:10:31 -07001303 if (fc->no_setxattr)
1304 return -EOPNOTSUPP;
1305
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001306 req = fuse_get_req(fc);
1307 if (IS_ERR(req))
1308 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001309
1310 memset(&inarg, 0, sizeof(inarg));
1311 inarg.size = size;
1312 inarg.flags = flags;
1313 req->in.h.opcode = FUSE_SETXATTR;
1314 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001315 req->in.numargs = 3;
1316 req->in.args[0].size = sizeof(inarg);
1317 req->in.args[0].value = &inarg;
1318 req->in.args[1].size = strlen(name) + 1;
1319 req->in.args[1].value = name;
1320 req->in.args[2].size = size;
1321 req->in.args[2].value = value;
1322 request_send(fc, req);
1323 err = req->out.h.error;
1324 fuse_put_request(fc, req);
1325 if (err == -ENOSYS) {
1326 fc->no_setxattr = 1;
1327 err = -EOPNOTSUPP;
1328 }
1329 return err;
1330}
1331
1332static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1333 void *value, size_t size)
1334{
1335 struct inode *inode = entry->d_inode;
1336 struct fuse_conn *fc = get_fuse_conn(inode);
1337 struct fuse_req *req;
1338 struct fuse_getxattr_in inarg;
1339 struct fuse_getxattr_out outarg;
1340 ssize_t ret;
1341
1342 if (fc->no_getxattr)
1343 return -EOPNOTSUPP;
1344
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001345 req = fuse_get_req(fc);
1346 if (IS_ERR(req))
1347 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001348
1349 memset(&inarg, 0, sizeof(inarg));
1350 inarg.size = size;
1351 req->in.h.opcode = FUSE_GETXATTR;
1352 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001353 req->in.numargs = 2;
1354 req->in.args[0].size = sizeof(inarg);
1355 req->in.args[0].value = &inarg;
1356 req->in.args[1].size = strlen(name) + 1;
1357 req->in.args[1].value = name;
1358 /* This is really two different operations rolled into one */
1359 req->out.numargs = 1;
1360 if (size) {
1361 req->out.argvar = 1;
1362 req->out.args[0].size = size;
1363 req->out.args[0].value = value;
1364 } else {
1365 req->out.args[0].size = sizeof(outarg);
1366 req->out.args[0].value = &outarg;
1367 }
1368 request_send(fc, req);
1369 ret = req->out.h.error;
1370 if (!ret)
1371 ret = size ? req->out.args[0].size : outarg.size;
1372 else {
1373 if (ret == -ENOSYS) {
1374 fc->no_getxattr = 1;
1375 ret = -EOPNOTSUPP;
1376 }
1377 }
1378 fuse_put_request(fc, req);
1379 return ret;
1380}
1381
1382static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
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_getxattr_in inarg;
1388 struct fuse_getxattr_out outarg;
1389 ssize_t ret;
1390
Miklos Szeredie57ac682007-10-18 03:06:58 -07001391 if (!fuse_allow_task(fc, current))
1392 return -EACCES;
1393
Miklos Szeredi92a87802005-09-09 13:10:31 -07001394 if (fc->no_listxattr)
1395 return -EOPNOTSUPP;
1396
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001397 req = fuse_get_req(fc);
1398 if (IS_ERR(req))
1399 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001400
1401 memset(&inarg, 0, sizeof(inarg));
1402 inarg.size = size;
1403 req->in.h.opcode = FUSE_LISTXATTR;
1404 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001405 req->in.numargs = 1;
1406 req->in.args[0].size = sizeof(inarg);
1407 req->in.args[0].value = &inarg;
1408 /* This is really two different operations rolled into one */
1409 req->out.numargs = 1;
1410 if (size) {
1411 req->out.argvar = 1;
1412 req->out.args[0].size = size;
1413 req->out.args[0].value = list;
1414 } else {
1415 req->out.args[0].size = sizeof(outarg);
1416 req->out.args[0].value = &outarg;
1417 }
1418 request_send(fc, req);
1419 ret = req->out.h.error;
1420 if (!ret)
1421 ret = size ? req->out.args[0].size : outarg.size;
1422 else {
1423 if (ret == -ENOSYS) {
1424 fc->no_listxattr = 1;
1425 ret = -EOPNOTSUPP;
1426 }
1427 }
1428 fuse_put_request(fc, req);
1429 return ret;
1430}
1431
1432static int fuse_removexattr(struct dentry *entry, const char *name)
1433{
1434 struct inode *inode = entry->d_inode;
1435 struct fuse_conn *fc = get_fuse_conn(inode);
1436 struct fuse_req *req;
1437 int err;
1438
1439 if (fc->no_removexattr)
1440 return -EOPNOTSUPP;
1441
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001442 req = fuse_get_req(fc);
1443 if (IS_ERR(req))
1444 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001445
1446 req->in.h.opcode = FUSE_REMOVEXATTR;
1447 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001448 req->in.numargs = 1;
1449 req->in.args[0].size = strlen(name) + 1;
1450 req->in.args[0].value = name;
1451 request_send(fc, req);
1452 err = req->out.h.error;
1453 fuse_put_request(fc, req);
1454 if (err == -ENOSYS) {
1455 fc->no_removexattr = 1;
1456 err = -EOPNOTSUPP;
1457 }
1458 return err;
1459}
1460
Arjan van de Ven754661f2007-02-12 00:55:38 -08001461static const struct inode_operations fuse_dir_inode_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -07001462 .lookup = fuse_lookup,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001463 .mkdir = fuse_mkdir,
1464 .symlink = fuse_symlink,
1465 .unlink = fuse_unlink,
1466 .rmdir = fuse_rmdir,
1467 .rename = fuse_rename,
1468 .link = fuse_link,
1469 .setattr = fuse_setattr,
1470 .create = fuse_create,
1471 .mknod = fuse_mknod,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001472 .permission = fuse_permission,
1473 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001474 .setxattr = fuse_setxattr,
1475 .getxattr = fuse_getxattr,
1476 .listxattr = fuse_listxattr,
1477 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001478};
1479
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001480static const struct file_operations fuse_dir_operations = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001481 .llseek = generic_file_llseek,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001482 .read = generic_read_dir,
1483 .readdir = fuse_readdir,
1484 .open = fuse_dir_open,
1485 .release = fuse_dir_release,
Miklos Szeredi82547982005-09-09 13:10:38 -07001486 .fsync = fuse_dir_fsync,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001487};
1488
Arjan van de Ven754661f2007-02-12 00:55:38 -08001489static const struct inode_operations fuse_common_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001490 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001491 .permission = fuse_permission,
1492 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001493 .setxattr = fuse_setxattr,
1494 .getxattr = fuse_getxattr,
1495 .listxattr = fuse_listxattr,
1496 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001497};
1498
Arjan van de Ven754661f2007-02-12 00:55:38 -08001499static const struct inode_operations fuse_symlink_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001500 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001501 .follow_link = fuse_follow_link,
1502 .put_link = fuse_put_link,
1503 .readlink = generic_readlink,
1504 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001505 .setxattr = fuse_setxattr,
1506 .getxattr = fuse_getxattr,
1507 .listxattr = fuse_listxattr,
1508 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001509};
1510
1511void fuse_init_common(struct inode *inode)
1512{
1513 inode->i_op = &fuse_common_inode_operations;
1514}
1515
1516void fuse_init_dir(struct inode *inode)
1517{
1518 inode->i_op = &fuse_dir_inode_operations;
1519 inode->i_fop = &fuse_dir_operations;
1520}
1521
1522void fuse_init_symlink(struct inode *inode)
1523{
1524 inode->i_op = &fuse_symlink_inode_operations;
1525}