blob: c4807b3fc8a360776bda6f976baebd26b5c9ae92 [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 Szeredi7dca9fd2007-11-28 16:21:59 -0800135static u64 fuse_get_attr_version(struct fuse_conn *fc)
136{
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 Savolaa5bfffac2007-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 Savolaa5bfffac2007-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 Szeredi361b1eb52006-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/*
1110 * Set attributes, and at the same time refresh them.
1111 *
1112 * Truncation is slightly complicated, because the 'truncate' request
1113 * may fail, in which case we don't want to touch the mapping.
Miklos Szeredi9ffbb912006-10-17 00:10:06 -07001114 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1115 * and the actual truncation by hand.
Miklos Szeredi6f9f1182006-01-06 00:19:39 -08001116 */
Miklos Szeredi49d49142007-10-18 03:07:00 -07001117static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1118 struct file *file)
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001119{
1120 struct inode *inode = entry->d_inode;
1121 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001122 struct fuse_req *req;
1123 struct fuse_setattr_in inarg;
1124 struct fuse_attr_out outarg;
1125 int err;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001126
Miklos Szeredie57ac682007-10-18 03:06:58 -07001127 if (!fuse_allow_task(fc, current))
1128 return -EACCES;
1129
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -07001130 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1131 err = inode_change_ok(inode, attr);
1132 if (err)
1133 return err;
1134 }
1135
Miklos Szeredi6ff958e2007-10-18 03:07:02 -07001136 if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
1137 return 0;
1138
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001139 if (attr->ia_valid & ATTR_SIZE) {
1140 unsigned long limit;
Miklos Szeredib2d22722006-12-06 20:35:51 -08001141 if (IS_SWAPFILE(inode))
1142 return -ETXTBSY;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001143 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1144 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1145 send_sig(SIGXFSZ, current, 0);
1146 return -EFBIG;
1147 }
1148 }
1149
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001150 req = fuse_get_req(fc);
1151 if (IS_ERR(req))
1152 return PTR_ERR(req);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001153
1154 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001155 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredibefc6492005-11-07 00:59:52 -08001156 iattr_to_fattr(attr, &inarg);
Miklos Szeredi49d49142007-10-18 03:07:00 -07001157 if (file) {
1158 struct fuse_file *ff = file->private_data;
1159 inarg.valid |= FATTR_FH;
1160 inarg.fh = ff->fh;
1161 }
Miklos Szeredif3332112007-10-18 03:07:04 -07001162 if (attr->ia_valid & ATTR_SIZE) {
1163 /* For mandatory locking in truncate */
1164 inarg.valid |= FATTR_LOCKOWNER;
1165 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1166 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001167 req->in.h.opcode = FUSE_SETATTR;
1168 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001169 req->in.numargs = 1;
1170 req->in.args[0].size = sizeof(inarg);
1171 req->in.args[0].value = &inarg;
1172 req->out.numargs = 1;
Miklos Szeredi0e9663e2007-10-18 03:07:05 -07001173 if (fc->minor < 9)
1174 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1175 else
1176 req->out.args[0].size = sizeof(outarg);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001177 req->out.args[0].value = &outarg;
1178 request_send(fc, req);
1179 err = req->out.h.error;
1180 fuse_put_request(fc, req);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001181 if (err) {
1182 if (err == -EINTR)
1183 fuse_invalidate_attr(inode);
1184 return err;
1185 }
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001186
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001187 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1188 make_bad_inode(inode);
1189 return -EIO;
1190 }
1191
Miklos Szeredi1fb69e72007-10-18 03:06:58 -07001192 fuse_change_attributes(inode, &outarg.attr, attr_timeout(&outarg), 0);
Miklos Szeredie00d2c22007-10-16 23:31:01 -07001193 return 0;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001194}
1195
Miklos Szeredi49d49142007-10-18 03:07:00 -07001196static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1197{
1198 if (attr->ia_valid & ATTR_FILE)
1199 return fuse_do_setattr(entry, attr, attr->ia_file);
1200 else
1201 return fuse_do_setattr(entry, attr, NULL);
1202}
1203
Miklos Szeredie5e55582005-09-09 13:10:28 -07001204static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1205 struct kstat *stat)
1206{
1207 struct inode *inode = entry->d_inode;
Miklos Szeredi244f6382007-10-16 23:31:02 -07001208 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi244f6382007-10-16 23:31:02 -07001209
1210 if (!fuse_allow_task(fc, current))
1211 return -EACCES;
1212
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001213 return fuse_update_attributes(inode, stat, NULL, NULL);
Miklos Szeredie5e55582005-09-09 13:10:28 -07001214}
1215
Miklos Szeredi92a87802005-09-09 13:10:31 -07001216static int fuse_setxattr(struct dentry *entry, const char *name,
1217 const void *value, size_t size, int flags)
1218{
1219 struct inode *inode = entry->d_inode;
1220 struct fuse_conn *fc = get_fuse_conn(inode);
1221 struct fuse_req *req;
1222 struct fuse_setxattr_in inarg;
1223 int err;
1224
Miklos Szeredi92a87802005-09-09 13:10:31 -07001225 if (fc->no_setxattr)
1226 return -EOPNOTSUPP;
1227
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001228 req = fuse_get_req(fc);
1229 if (IS_ERR(req))
1230 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001231
1232 memset(&inarg, 0, sizeof(inarg));
1233 inarg.size = size;
1234 inarg.flags = flags;
1235 req->in.h.opcode = FUSE_SETXATTR;
1236 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001237 req->in.numargs = 3;
1238 req->in.args[0].size = sizeof(inarg);
1239 req->in.args[0].value = &inarg;
1240 req->in.args[1].size = strlen(name) + 1;
1241 req->in.args[1].value = name;
1242 req->in.args[2].size = size;
1243 req->in.args[2].value = value;
1244 request_send(fc, req);
1245 err = req->out.h.error;
1246 fuse_put_request(fc, req);
1247 if (err == -ENOSYS) {
1248 fc->no_setxattr = 1;
1249 err = -EOPNOTSUPP;
1250 }
1251 return err;
1252}
1253
1254static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1255 void *value, size_t size)
1256{
1257 struct inode *inode = entry->d_inode;
1258 struct fuse_conn *fc = get_fuse_conn(inode);
1259 struct fuse_req *req;
1260 struct fuse_getxattr_in inarg;
1261 struct fuse_getxattr_out outarg;
1262 ssize_t ret;
1263
1264 if (fc->no_getxattr)
1265 return -EOPNOTSUPP;
1266
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001267 req = fuse_get_req(fc);
1268 if (IS_ERR(req))
1269 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001270
1271 memset(&inarg, 0, sizeof(inarg));
1272 inarg.size = size;
1273 req->in.h.opcode = FUSE_GETXATTR;
1274 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001275 req->in.numargs = 2;
1276 req->in.args[0].size = sizeof(inarg);
1277 req->in.args[0].value = &inarg;
1278 req->in.args[1].size = strlen(name) + 1;
1279 req->in.args[1].value = name;
1280 /* This is really two different operations rolled into one */
1281 req->out.numargs = 1;
1282 if (size) {
1283 req->out.argvar = 1;
1284 req->out.args[0].size = size;
1285 req->out.args[0].value = value;
1286 } else {
1287 req->out.args[0].size = sizeof(outarg);
1288 req->out.args[0].value = &outarg;
1289 }
1290 request_send(fc, req);
1291 ret = req->out.h.error;
1292 if (!ret)
1293 ret = size ? req->out.args[0].size : outarg.size;
1294 else {
1295 if (ret == -ENOSYS) {
1296 fc->no_getxattr = 1;
1297 ret = -EOPNOTSUPP;
1298 }
1299 }
1300 fuse_put_request(fc, req);
1301 return ret;
1302}
1303
1304static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1305{
1306 struct inode *inode = entry->d_inode;
1307 struct fuse_conn *fc = get_fuse_conn(inode);
1308 struct fuse_req *req;
1309 struct fuse_getxattr_in inarg;
1310 struct fuse_getxattr_out outarg;
1311 ssize_t ret;
1312
Miklos Szeredie57ac682007-10-18 03:06:58 -07001313 if (!fuse_allow_task(fc, current))
1314 return -EACCES;
1315
Miklos Szeredi92a87802005-09-09 13:10:31 -07001316 if (fc->no_listxattr)
1317 return -EOPNOTSUPP;
1318
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001319 req = fuse_get_req(fc);
1320 if (IS_ERR(req))
1321 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001322
1323 memset(&inarg, 0, sizeof(inarg));
1324 inarg.size = size;
1325 req->in.h.opcode = FUSE_LISTXATTR;
1326 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001327 req->in.numargs = 1;
1328 req->in.args[0].size = sizeof(inarg);
1329 req->in.args[0].value = &inarg;
1330 /* This is really two different operations rolled into one */
1331 req->out.numargs = 1;
1332 if (size) {
1333 req->out.argvar = 1;
1334 req->out.args[0].size = size;
1335 req->out.args[0].value = list;
1336 } else {
1337 req->out.args[0].size = sizeof(outarg);
1338 req->out.args[0].value = &outarg;
1339 }
1340 request_send(fc, req);
1341 ret = req->out.h.error;
1342 if (!ret)
1343 ret = size ? req->out.args[0].size : outarg.size;
1344 else {
1345 if (ret == -ENOSYS) {
1346 fc->no_listxattr = 1;
1347 ret = -EOPNOTSUPP;
1348 }
1349 }
1350 fuse_put_request(fc, req);
1351 return ret;
1352}
1353
1354static int fuse_removexattr(struct dentry *entry, const char *name)
1355{
1356 struct inode *inode = entry->d_inode;
1357 struct fuse_conn *fc = get_fuse_conn(inode);
1358 struct fuse_req *req;
1359 int err;
1360
1361 if (fc->no_removexattr)
1362 return -EOPNOTSUPP;
1363
Miklos Szeredice1d5a42006-04-10 22:54:58 -07001364 req = fuse_get_req(fc);
1365 if (IS_ERR(req))
1366 return PTR_ERR(req);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001367
1368 req->in.h.opcode = FUSE_REMOVEXATTR;
1369 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredi92a87802005-09-09 13:10:31 -07001370 req->in.numargs = 1;
1371 req->in.args[0].size = strlen(name) + 1;
1372 req->in.args[0].value = name;
1373 request_send(fc, req);
1374 err = req->out.h.error;
1375 fuse_put_request(fc, req);
1376 if (err == -ENOSYS) {
1377 fc->no_removexattr = 1;
1378 err = -EOPNOTSUPP;
1379 }
1380 return err;
1381}
1382
Arjan van de Ven754661f2007-02-12 00:55:38 -08001383static const struct inode_operations fuse_dir_inode_operations = {
Miklos Szeredie5e55582005-09-09 13:10:28 -07001384 .lookup = fuse_lookup,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001385 .mkdir = fuse_mkdir,
1386 .symlink = fuse_symlink,
1387 .unlink = fuse_unlink,
1388 .rmdir = fuse_rmdir,
1389 .rename = fuse_rename,
1390 .link = fuse_link,
1391 .setattr = fuse_setattr,
1392 .create = fuse_create,
1393 .mknod = fuse_mknod,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001394 .permission = fuse_permission,
1395 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001396 .setxattr = fuse_setxattr,
1397 .getxattr = fuse_getxattr,
1398 .listxattr = fuse_listxattr,
1399 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001400};
1401
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001402static const struct file_operations fuse_dir_operations = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001403 .llseek = generic_file_llseek,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001404 .read = generic_read_dir,
1405 .readdir = fuse_readdir,
1406 .open = fuse_dir_open,
1407 .release = fuse_dir_release,
Miklos Szeredi82547982005-09-09 13:10:38 -07001408 .fsync = fuse_dir_fsync,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001409};
1410
Arjan van de Ven754661f2007-02-12 00:55:38 -08001411static const struct inode_operations fuse_common_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001412 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001413 .permission = fuse_permission,
1414 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001415 .setxattr = fuse_setxattr,
1416 .getxattr = fuse_getxattr,
1417 .listxattr = fuse_listxattr,
1418 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001419};
1420
Arjan van de Ven754661f2007-02-12 00:55:38 -08001421static const struct inode_operations fuse_symlink_inode_operations = {
Miklos Szeredi9e6268d2005-09-09 13:10:29 -07001422 .setattr = fuse_setattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001423 .follow_link = fuse_follow_link,
1424 .put_link = fuse_put_link,
1425 .readlink = generic_readlink,
1426 .getattr = fuse_getattr,
Miklos Szeredi92a87802005-09-09 13:10:31 -07001427 .setxattr = fuse_setxattr,
1428 .getxattr = fuse_getxattr,
1429 .listxattr = fuse_listxattr,
1430 .removexattr = fuse_removexattr,
Miklos Szeredie5e55582005-09-09 13:10:28 -07001431};
1432
1433void fuse_init_common(struct inode *inode)
1434{
1435 inode->i_op = &fuse_common_inode_operations;
1436}
1437
1438void fuse_init_dir(struct inode *inode)
1439{
1440 inode->i_op = &fuse_dir_inode_operations;
1441 inode->i_fop = &fuse_dir_operations;
1442}
1443
1444void fuse_init_symlink(struct inode *inode)
1445{
1446 inode->i_op = &fuse_symlink_inode_operations;
1447}